--- /dev/null
+(self["webpackChunkmotion_chat"] = self["webpackChunkmotion_chat"] || []).push([["chat"],{
+
+/***/ "./node_modules/@flowjs/flow.js/src/flow.js":
+/*!**************************************************!*\
+ !*** ./node_modules/@flowjs/flow.js/src/flow.js ***!
+ \**************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
+ * @license MIT
+ */
+(function(window, document, undefined) {'use strict';
+ if (!window || !document) {
+ console.warn('Flowjs needs window and document objects to work');
+ return;
+ }
+ // ie10+
+ var ie10plus = window.navigator.msPointerEnabled;
+ /**
+ * Flow.js is a library providing multiple simultaneous, stable and
+ * resumable uploads via the HTML5 File API.
+ * @param [opts]
+ * @param {number|Function} [opts.chunkSize]
+ * @param {bool} [opts.forceChunkSize]
+ * @param {number} [opts.simultaneousUploads]
+ * @param {bool} [opts.singleFile]
+ * @param {string} [opts.fileParameterName]
+ * @param {number} [opts.progressCallbacksInterval]
+ * @param {number} [opts.speedSmoothingFactor]
+ * @param {Object|Function} [opts.query]
+ * @param {Object|Function} [opts.headers]
+ * @param {bool} [opts.withCredentials]
+ * @param {Function} [opts.preprocess]
+ * @param {string} [opts.method]
+ * @param {string|Function} [opts.testMethod]
+ * @param {string|Function} [opts.uploadMethod]
+ * @param {bool} [opts.prioritizeFirstAndLastChunk]
+ * @param {bool} [opts.allowDuplicateUploads]
+ * @param {string|Function} [opts.target]
+ * @param {number} [opts.maxChunkRetries]
+ * @param {number} [opts.chunkRetryInterval]
+ * @param {Array.<number>} [opts.permanentErrors]
+ * @param {Array.<number>} [opts.successStatuses]
+ * @param {Function} [opts.initFileFn]
+ * @param {Function} [opts.readFileFn]
+ * @param {Function} [opts.generateUniqueIdentifier]
+ * @constructor
+ */
+ function Flow(opts) {
+ /**
+ * Supported by browser?
+ * @type {boolean}
+ */
+ this.support = (
+ typeof File !== 'undefined' &&
+ typeof Blob !== 'undefined' &&
+ typeof FileList !== 'undefined' &&
+ (
+ !!Blob.prototype.slice || !!Blob.prototype.webkitSlice || !!Blob.prototype.mozSlice ||
+ false
+ ) // slicing files support
+ );
+
+ if (!this.support) {
+ return ;
+ }
+
+ /**
+ * Check if directory upload is supported
+ * @type {boolean}
+ */
+ this.supportDirectory = (
+ /Chrome/.test(window.navigator.userAgent) ||
+ /Firefox/.test(window.navigator.userAgent) ||
+ /Edge/.test(window.navigator.userAgent)
+ );
+
+ /**
+ * List of FlowFile objects
+ * @type {Array.<FlowFile>}
+ */
+ this.files = [];
+
+ /**
+ * Default options for flow.js
+ * @type {Object}
+ */
+ this.defaults = {
+ chunkSize: 1024 * 1024,
+ forceChunkSize: false,
+ simultaneousUploads: 3,
+ singleFile: false,
+ fileParameterName: 'file',
+ progressCallbacksInterval: 500,
+ speedSmoothingFactor: 0.1,
+ query: {},
+ headers: {},
+ withCredentials: false,
+ preprocess: null,
+ changeRawDataBeforeSend: null,
+ method: 'multipart',
+ testMethod: 'GET',
+ uploadMethod: 'POST',
+ prioritizeFirstAndLastChunk: false,
+ allowDuplicateUploads: false,
+ target: '/',
+ testChunks: true,
+ generateUniqueIdentifier: null,
+ maxChunkRetries: 0,
+ chunkRetryInterval: null,
+ permanentErrors: [404, 413, 415, 500, 501],
+ successStatuses: [200, 201, 202],
+ onDropStopPropagation: false,
+ initFileFn: null,
+ readFileFn: webAPIFileRead
+ };
+
+ /**
+ * Current options
+ * @type {Object}
+ */
+ this.opts = {};
+
+ /**
+ * List of events:
+ * key stands for event name
+ * value array list of callbacks
+ * @type {}
+ */
+ this.events = {};
+
+ var $ = this;
+
+ /**
+ * On drop event
+ * @function
+ * @param {MouseEvent} event
+ */
+ this.onDrop = function (event) {
+ if ($.opts.onDropStopPropagation) {
+ event.stopPropagation();
+ }
+ event.preventDefault();
+ var dataTransfer = event.dataTransfer;
+ if (dataTransfer.items && dataTransfer.items[0] &&
+ dataTransfer.items[0].webkitGetAsEntry) {
+ $.webkitReadDataTransfer(event);
+ } else {
+ $.addFiles(dataTransfer.files, event);
+ }
+ };
+
+ /**
+ * Prevent default
+ * @function
+ * @param {MouseEvent} event
+ */
+ this.preventEvent = function (event) {
+ event.preventDefault();
+ };
+
+
+ /**
+ * Current options
+ * @type {Object}
+ */
+ this.opts = Flow.extend({}, this.defaults, opts || {});
+
+ }
+
+ Flow.prototype = {
+ /**
+ * Set a callback for an event, possible events:
+ * fileSuccess(file), fileProgress(file), fileAdded(file, event),
+ * fileRemoved(file), fileRetry(file), fileError(file, message),
+ * complete(), progress(), error(message, file), pause()
+ * @function
+ * @param {string} event
+ * @param {Function} callback
+ */
+ on: function (event, callback) {
+ event = event.toLowerCase();
+ if (!this.events.hasOwnProperty(event)) {
+ this.events[event] = [];
+ }
+ this.events[event].push(callback);
+ },
+
+ /**
+ * Remove event callback
+ * @function
+ * @param {string} [event] removes all events if not specified
+ * @param {Function} [fn] removes all callbacks of event if not specified
+ */
+ off: function (event, fn) {
+ if (event !== undefined) {
+ event = event.toLowerCase();
+ if (fn !== undefined) {
+ if (this.events.hasOwnProperty(event)) {
+ arrayRemove(this.events[event], fn);
+ }
+ } else {
+ delete this.events[event];
+ }
+ } else {
+ this.events = {};
+ }
+ },
+
+ /**
+ * Fire an event
+ * @function
+ * @param {string} event event name
+ * @param {...} args arguments of a callback
+ * @return {bool} value is false if at least one of the event handlers which handled this event
+ * returned false. Otherwise it returns true.
+ */
+ fire: function (event, args) {
+ // `arguments` is an object, not array, in FF, so:
+ args = Array.prototype.slice.call(arguments);
+ event = event.toLowerCase();
+ var preventDefault = false;
+ if (this.events.hasOwnProperty(event)) {
+ each(this.events[event], function (callback) {
+ preventDefault = callback.apply(this, args.slice(1)) === false || preventDefault;
+ }, this);
+ }
+ if (event != 'catchall') {
+ args.unshift('catchAll');
+ preventDefault = this.fire.apply(this, args) === false || preventDefault;
+ }
+ return !preventDefault;
+ },
+
+ /**
+ * Read webkit dataTransfer object
+ * @param event
+ */
+ webkitReadDataTransfer: function (event) {
+ var $ = this;
+ var queue = event.dataTransfer.items.length;
+ var files = [];
+ each(event.dataTransfer.items, function (item) {
+ var entry = item.webkitGetAsEntry();
+ if (!entry) {
+ decrement();
+ return ;
+ }
+ if (entry.isFile) {
+ // due to a bug in Chrome's File System API impl - #149735
+ fileReadSuccess(item.getAsFile(), entry.fullPath);
+ } else {
+ readDirectory(entry.createReader());
+ }
+ });
+ function readDirectory(reader) {
+ reader.readEntries(function (entries) {
+ if (entries.length) {
+ queue += entries.length;
+ each(entries, function(entry) {
+ if (entry.isFile) {
+ var fullPath = entry.fullPath;
+ entry.file(function (file) {
+ fileReadSuccess(file, fullPath);
+ }, readError);
+ } else if (entry.isDirectory) {
+ readDirectory(entry.createReader());
+ }
+ });
+ readDirectory(reader);
+ } else {
+ decrement();
+ }
+ }, readError);
+ }
+ function fileReadSuccess(file, fullPath) {
+ // relative path should not start with "/"
+ file.relativePath = fullPath.substring(1);
+ files.push(file);
+ decrement();
+ }
+ function readError(fileError) {
+ decrement();
+ throw fileError;
+ }
+ function decrement() {
+ if (--queue == 0) {
+ $.addFiles(files, event);
+ }
+ }
+ },
+
+ /**
+ * Generate unique identifier for a file
+ * @function
+ * @param {FlowFile} file
+ * @returns {string}
+ */
+ generateUniqueIdentifier: function (file) {
+ var custom = this.opts.generateUniqueIdentifier;
+ if (typeof custom === 'function') {
+ return custom(file);
+ }
+ // Some confusion in different versions of Firefox
+ var relativePath = file.relativePath || file.webkitRelativePath || file.fileName || file.name;
+ return file.size + '-' + relativePath.replace(/[^0-9a-zA-Z_-]/img, '');
+ },
+
+ /**
+ * Upload next chunk from the queue
+ * @function
+ * @returns {boolean}
+ * @private
+ */
+ uploadNextChunk: function (preventEvents) {
+ // In some cases (such as videos) it's really handy to upload the first
+ // and last chunk of a file quickly; this let's the server check the file's
+ // metadata and determine if there's even a point in continuing.
+ var found = false;
+ if (this.opts.prioritizeFirstAndLastChunk) {
+ each(this.files, function (file) {
+ if (!file.paused && file.chunks.length &&
+ file.chunks[0].status() === 'pending') {
+ file.chunks[0].send();
+ found = true;
+ return false;
+ }
+ if (!file.paused && file.chunks.length > 1 &&
+ file.chunks[file.chunks.length - 1].status() === 'pending') {
+ file.chunks[file.chunks.length - 1].send();
+ found = true;
+ return false;
+ }
+ });
+ if (found) {
+ return found;
+ }
+ }
+
+ // Now, simply look for the next, best thing to upload
+ each(this.files, function (file) {
+ if (!file.paused) {
+ each(file.chunks, function (chunk) {
+ if (chunk.status() === 'pending') {
+ chunk.send();
+ found = true;
+ return false;
+ }
+ });
+ }
+ if (found) {
+ return false;
+ }
+ });
+ if (found) {
+ return true;
+ }
+
+ // The are no more outstanding chunks to upload, check is everything is done
+ var outstanding = false;
+ each(this.files, function (file) {
+ if (!file.isComplete()) {
+ outstanding = true;
+ return false;
+ }
+ });
+ if (!outstanding && !preventEvents) {
+ // All chunks have been uploaded, complete
+ async(function () {
+ this.fire('complete');
+ }, this);
+ }
+ return false;
+ },
+
+
+ /**
+ * Assign a browse action to one or more DOM nodes.
+ * @function
+ * @param {Element|Array.<Element>} domNodes
+ * @param {boolean} isDirectory Pass in true to allow directories to
+ * @param {boolean} singleFile prevent multi file upload
+ * @param {Object} attributes set custom attributes:
+ * http://www.w3.org/TR/html-markup/input.file.html#input.file-attributes
+ * eg: accept: 'image/*'
+ * be selected (Chrome only).
+ */
+ assignBrowse: function (domNodes, isDirectory, singleFile, attributes) {
+ if (domNodes instanceof Element) {
+ domNodes = [domNodes];
+ }
+
+ each(domNodes, function (domNode) {
+ var input;
+ if (domNode.tagName === 'INPUT' && domNode.type === 'file') {
+ input = domNode;
+ } else {
+ input = document.createElement('input');
+ input.setAttribute('type', 'file');
+ // display:none - not working in opera 12
+ extend(input.style, {
+ visibility: 'hidden',
+ position: 'absolute',
+ width: '1px',
+ height: '1px'
+ });
+ // for opera 12 browser, input must be assigned to a document
+ domNode.appendChild(input);
+ // https://developer.mozilla.org/en/using_files_from_web_applications)
+ // event listener is executed two times
+ // first one - original mouse click event
+ // second - input.click(), input is inside domNode
+ domNode.addEventListener('click', function() {
+ input.click();
+ }, false);
+ }
+ if (!this.opts.singleFile && !singleFile) {
+ input.setAttribute('multiple', 'multiple');
+ }
+ if (isDirectory) {
+ input.setAttribute('webkitdirectory', 'webkitdirectory');
+ }
+ each(attributes, function (value, key) {
+ input.setAttribute(key, value);
+ });
+ // When new files are added, simply append them to the overall list
+ var $ = this;
+ input.addEventListener('change', function (e) {
+ if (e.target.value) {
+ $.addFiles(e.target.files, e);
+ e.target.value = '';
+ }
+ }, false);
+ }, this);
+ },
+
+ /**
+ * Assign one or more DOM nodes as a drop target.
+ * @function
+ * @param {Element|Array.<Element>} domNodes
+ */
+ assignDrop: function (domNodes) {
+ if (typeof domNodes.length === 'undefined') {
+ domNodes = [domNodes];
+ }
+ each(domNodes, function (domNode) {
+ domNode.addEventListener('dragover', this.preventEvent, false);
+ domNode.addEventListener('dragenter', this.preventEvent, false);
+ domNode.addEventListener('drop', this.onDrop, false);
+ }, this);
+ },
+
+ /**
+ * Un-assign drop event from DOM nodes
+ * @function
+ * @param domNodes
+ */
+ unAssignDrop: function (domNodes) {
+ if (typeof domNodes.length === 'undefined') {
+ domNodes = [domNodes];
+ }
+ each(domNodes, function (domNode) {
+ domNode.removeEventListener('dragover', this.preventEvent);
+ domNode.removeEventListener('dragenter', this.preventEvent);
+ domNode.removeEventListener('drop', this.onDrop);
+ }, this);
+ },
+
+ /**
+ * Returns a boolean indicating whether or not the instance is currently
+ * uploading anything.
+ * @function
+ * @returns {boolean}
+ */
+ isUploading: function () {
+ var uploading = false;
+ each(this.files, function (file) {
+ if (file.isUploading()) {
+ uploading = true;
+ return false;
+ }
+ });
+ return uploading;
+ },
+
+ /**
+ * should upload next chunk
+ * @function
+ * @returns {boolean|number}
+ */
+ _shouldUploadNext: function () {
+ var num = 0;
+ var should = true;
+ var simultaneousUploads = this.opts.simultaneousUploads;
+ each(this.files, function (file) {
+ each(file.chunks, function(chunk) {
+ if (chunk.status() === 'uploading') {
+ num++;
+ if (num >= simultaneousUploads) {
+ should = false;
+ return false;
+ }
+ }
+ });
+ });
+ // if should is true then return uploading chunks's length
+ return should && num;
+ },
+
+ /**
+ * Start or resume uploading.
+ * @function
+ */
+ upload: function () {
+ // Make sure we don't start too many uploads at once
+ var ret = this._shouldUploadNext();
+ if (ret === false) {
+ return;
+ }
+ // Kick off the queue
+ this.fire('uploadStart');
+ var started = false;
+ for (var num = 1; num <= this.opts.simultaneousUploads - ret; num++) {
+ started = this.uploadNextChunk(true) || started;
+ }
+ if (!started) {
+ async(function () {
+ this.fire('complete');
+ }, this);
+ }
+ },
+
+ /**
+ * Resume uploading.
+ * @function
+ */
+ resume: function () {
+ each(this.files, function (file) {
+ if (!file.isComplete()) {
+ file.resume();
+ }
+ });
+ },
+
+ /**
+ * Pause uploading.
+ * @function
+ */
+ pause: function () {
+ each(this.files, function (file) {
+ file.pause();
+ });
+ },
+
+ /**
+ * Cancel upload of all FlowFile objects and remove them from the list.
+ * @function
+ */
+ cancel: function () {
+ for (var i = this.files.length - 1; i >= 0; i--) {
+ this.files[i].cancel();
+ }
+ },
+
+ /**
+ * Returns a number between 0 and 1 indicating the current upload progress
+ * of all files.
+ * @function
+ * @returns {number}
+ */
+ progress: function () {
+ var totalDone = 0;
+ var totalSize = 0;
+ // Resume all chunks currently being uploaded
+ each(this.files, function (file) {
+ totalDone += file.progress() * file.size;
+ totalSize += file.size;
+ });
+ return totalSize > 0 ? totalDone / totalSize : 0;
+ },
+
+ /**
+ * Add a HTML5 File object to the list of files.
+ * @function
+ * @param {File} file
+ * @param {Event} [event] event is optional
+ */
+ addFile: function (file, event) {
+ this.addFiles([file], event);
+ },
+
+ /**
+ * Add a HTML5 File object to the list of files.
+ * @function
+ * @param {FileList|Array} fileList
+ * @param {Event} [event] event is optional
+ */
+ addFiles: function (fileList, event) {
+ var files = [];
+ each(fileList, function (file) {
+ // https://github.com/flowjs/flow.js/issues/55
+ if ((!ie10plus || ie10plus && file.size > 0) && !(file.size % 4096 === 0 && (file.name === '.' || file.fileName === '.'))) {
+ var uniqueIdentifier = this.generateUniqueIdentifier(file);
+ if (this.opts.allowDuplicateUploads || !this.getFromUniqueIdentifier(uniqueIdentifier)) {
+ var f = new FlowFile(this, file, uniqueIdentifier);
+ if (this.fire('fileAdded', f, event)) {
+ files.push(f);
+ }
+ }
+ }
+ }, this);
+ if (this.fire('filesAdded', files, event)) {
+ each(files, function (file) {
+ if (this.opts.singleFile && this.files.length > 0) {
+ this.removeFile(this.files[0]);
+ }
+ this.files.push(file);
+ }, this);
+ this.fire('filesSubmitted', files, event);
+ }
+ },
+
+
+ /**
+ * Cancel upload of a specific FlowFile object from the list.
+ * @function
+ * @param {FlowFile} file
+ */
+ removeFile: function (file) {
+ for (var i = this.files.length - 1; i >= 0; i--) {
+ if (this.files[i] === file) {
+ this.files.splice(i, 1);
+ file.abort();
+ this.fire('fileRemoved', file);
+ }
+ }
+ },
+
+ /**
+ * Look up a FlowFile object by its unique identifier.
+ * @function
+ * @param {string} uniqueIdentifier
+ * @returns {boolean|FlowFile} false if file was not found
+ */
+ getFromUniqueIdentifier: function (uniqueIdentifier) {
+ var ret = false;
+ each(this.files, function (file) {
+ if (file.uniqueIdentifier === uniqueIdentifier) {
+ ret = file;
+ }
+ });
+ return ret;
+ },
+
+ /**
+ * Returns the total size of all files in bytes.
+ * @function
+ * @returns {number}
+ */
+ getSize: function () {
+ var totalSize = 0;
+ each(this.files, function (file) {
+ totalSize += file.size;
+ });
+ return totalSize;
+ },
+
+ /**
+ * Returns the total size uploaded of all files in bytes.
+ * @function
+ * @returns {number}
+ */
+ sizeUploaded: function () {
+ var size = 0;
+ each(this.files, function (file) {
+ size += file.sizeUploaded();
+ });
+ return size;
+ },
+
+ /**
+ * Returns remaining time to upload all files in seconds. Accuracy is based on average speed.
+ * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
+ * @function
+ * @returns {number}
+ */
+ timeRemaining: function () {
+ var sizeDelta = 0;
+ var averageSpeed = 0;
+ each(this.files, function (file) {
+ if (!file.paused && !file.error) {
+ sizeDelta += file.size - file.sizeUploaded();
+ averageSpeed += file.averageSpeed;
+ }
+ });
+ if (sizeDelta && !averageSpeed) {
+ return Number.POSITIVE_INFINITY;
+ }
+ if (!sizeDelta && !averageSpeed) {
+ return 0;
+ }
+ return Math.floor(sizeDelta / averageSpeed);
+ }
+ };
+
+
+
+
+
+
+ /**
+ * FlowFile class
+ * @name FlowFile
+ * @param {Flow} flowObj
+ * @param {File} file
+ * @param {string} uniqueIdentifier
+ * @constructor
+ */
+ function FlowFile(flowObj, file, uniqueIdentifier) {
+
+ /**
+ * Reference to parent Flow instance
+ * @type {Flow}
+ */
+ this.flowObj = flowObj;
+
+ /**
+ * Used to store the bytes read
+ * @type {Blob|string}
+ */
+ this.bytes = null;
+
+ /**
+ * Reference to file
+ * @type {File}
+ */
+ this.file = file;
+
+ /**
+ * File name. Some confusion in different versions of Firefox
+ * @type {string}
+ */
+ this.name = file.fileName || file.name;
+
+ /**
+ * File size
+ * @type {number}
+ */
+ this.size = file.size;
+
+ /**
+ * Relative file path
+ * @type {string}
+ */
+ this.relativePath = file.relativePath || file.webkitRelativePath || this.name;
+
+ /**
+ * File unique identifier
+ * @type {string}
+ */
+ this.uniqueIdentifier = (uniqueIdentifier === undefined ? flowObj.generateUniqueIdentifier(file) : uniqueIdentifier);
+
+ /**
+ * Size of Each Chunk
+ * @type {number}
+ */
+ this.chunkSize = 0;
+
+ /**
+ * List of chunks
+ * @type {Array.<FlowChunk>}
+ */
+ this.chunks = [];
+
+ /**
+ * Indicated if file is paused
+ * @type {boolean}
+ */
+ this.paused = false;
+
+ /**
+ * Indicated if file has encountered an error
+ * @type {boolean}
+ */
+ this.error = false;
+
+ /**
+ * Average upload speed
+ * @type {number}
+ */
+ this.averageSpeed = 0;
+
+ /**
+ * Current upload speed
+ * @type {number}
+ */
+ this.currentSpeed = 0;
+
+ /**
+ * Date then progress was called last time
+ * @type {number}
+ * @private
+ */
+ this._lastProgressCallback = Date.now();
+
+ /**
+ * Previously uploaded file size
+ * @type {number}
+ * @private
+ */
+ this._prevUploadedSize = 0;
+
+ /**
+ * Holds previous progress
+ * @type {number}
+ * @private
+ */
+ this._prevProgress = 0;
+
+ this.bootstrap();
+ }
+
+ FlowFile.prototype = {
+ /**
+ * Update speed parameters
+ * @link http://stackoverflow.com/questions/2779600/how-to-estimate-download-time-remaining-accurately
+ * @function
+ */
+ measureSpeed: function () {
+ var timeSpan = Date.now() - this._lastProgressCallback;
+ if (!timeSpan) {
+ return ;
+ }
+ var smoothingFactor = this.flowObj.opts.speedSmoothingFactor;
+ var uploaded = this.sizeUploaded();
+ // Prevent negative upload speed after file upload resume
+ this.currentSpeed = Math.max((uploaded - this._prevUploadedSize) / timeSpan * 1000, 0);
+ this.averageSpeed = smoothingFactor * this.currentSpeed + (1 - smoothingFactor) * this.averageSpeed;
+ this._prevUploadedSize = uploaded;
+ },
+
+ /**
+ * For internal usage only.
+ * Callback when something happens within the chunk.
+ * @function
+ * @param {FlowChunk} chunk
+ * @param {string} event can be 'progress', 'success', 'error' or 'retry'
+ * @param {string} [message]
+ */
+ chunkEvent: function (chunk, event, message) {
+ switch (event) {
+ case 'progress':
+ if (Date.now() - this._lastProgressCallback <
+ this.flowObj.opts.progressCallbacksInterval) {
+ break;
+ }
+ this.measureSpeed();
+ this.flowObj.fire('fileProgress', this, chunk);
+ this.flowObj.fire('progress');
+ this._lastProgressCallback = Date.now();
+ break;
+ case 'error':
+ this.error = true;
+ this.abort(true);
+ this.flowObj.fire('fileError', this, message, chunk);
+ this.flowObj.fire('error', message, this, chunk);
+ break;
+ case 'success':
+ if (this.error) {
+ return;
+ }
+ this.measureSpeed();
+ this.flowObj.fire('fileProgress', this, chunk);
+ this.flowObj.fire('progress');
+ this._lastProgressCallback = Date.now();
+ if (this.isComplete()) {
+ this.currentSpeed = 0;
+ this.averageSpeed = 0;
+ this.flowObj.fire('fileSuccess', this, message, chunk);
+ }
+ break;
+ case 'retry':
+ this.flowObj.fire('fileRetry', this, chunk);
+ break;
+ }
+ },
+
+ /**
+ * Pause file upload
+ * @function
+ */
+ pause: function() {
+ this.paused = true;
+ this.abort();
+ },
+
+ /**
+ * Resume file upload
+ * @function
+ */
+ resume: function() {
+ this.paused = false;
+ this.flowObj.upload();
+ },
+
+ /**
+ * Abort current upload
+ * @function
+ */
+ abort: function (reset) {
+ this.currentSpeed = 0;
+ this.averageSpeed = 0;
+ var chunks = this.chunks;
+ if (reset) {
+ this.chunks = [];
+ }
+ each(chunks, function (c) {
+ if (c.status() === 'uploading') {
+ c.abort();
+ this.flowObj.uploadNextChunk();
+ }
+ }, this);
+ },
+
+ /**
+ * Cancel current upload and remove from a list
+ * @function
+ */
+ cancel: function () {
+ this.flowObj.removeFile(this);
+ },
+
+ /**
+ * Retry aborted file upload
+ * @function
+ */
+ retry: function () {
+ this.bootstrap();
+ this.flowObj.upload();
+ },
+
+ /**
+ * Clear current chunks and slice file again
+ * @function
+ */
+ bootstrap: function () {
+ if (typeof this.flowObj.opts.initFileFn === "function") {
+ this.flowObj.opts.initFileFn(this);
+ }
+
+ this.abort(true);
+ this.error = false;
+ // Rebuild stack of chunks from file
+ this._prevProgress = 0;
+ var round = this.flowObj.opts.forceChunkSize ? Math.ceil : Math.floor;
+ this.chunkSize = evalOpts(this.flowObj.opts.chunkSize, this);
+ var chunks = Math.max(
+ round(this.size / this.chunkSize), 1
+ );
+ for (var offset = 0; offset < chunks; offset++) {
+ this.chunks.push(
+ new FlowChunk(this.flowObj, this, offset)
+ );
+ }
+ },
+
+ /**
+ * Get current upload progress status
+ * @function
+ * @returns {number} from 0 to 1
+ */
+ progress: function () {
+ if (this.error) {
+ return 1;
+ }
+ if (this.chunks.length === 1) {
+ this._prevProgress = Math.max(this._prevProgress, this.chunks[0].progress());
+ return this._prevProgress;
+ }
+ // Sum up progress across everything
+ var bytesLoaded = 0;
+ each(this.chunks, function (c) {
+ // get chunk progress relative to entire file
+ bytesLoaded += c.progress() * (c.endByte - c.startByte);
+ });
+ var percent = bytesLoaded / this.size;
+ // We don't want to lose percentages when an upload is paused
+ this._prevProgress = Math.max(this._prevProgress, percent > 0.9999 ? 1 : percent);
+ return this._prevProgress;
+ },
+
+ /**
+ * Indicates if file is being uploaded at the moment
+ * @function
+ * @returns {boolean}
+ */
+ isUploading: function () {
+ var uploading = false;
+ each(this.chunks, function (chunk) {
+ if (chunk.status() === 'uploading') {
+ uploading = true;
+ return false;
+ }
+ });
+ return uploading;
+ },
+
+ /**
+ * Indicates if file is has finished uploading and received a response
+ * @function
+ * @returns {boolean}
+ */
+ isComplete: function () {
+ var outstanding = false;
+ each(this.chunks, function (chunk) {
+ var status = chunk.status();
+ if (status === 'pending' || status === 'uploading' || status === 'reading' || chunk.preprocessState === 1 || chunk.readState === 1) {
+ outstanding = true;
+ return false;
+ }
+ });
+ return !outstanding;
+ },
+
+ /**
+ * Count total size uploaded
+ * @function
+ * @returns {number}
+ */
+ sizeUploaded: function () {
+ var size = 0;
+ each(this.chunks, function (chunk) {
+ size += chunk.sizeUploaded();
+ });
+ return size;
+ },
+
+ /**
+ * Returns remaining time to finish upload file in seconds. Accuracy is based on average speed.
+ * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
+ * @function
+ * @returns {number}
+ */
+ timeRemaining: function () {
+ if (this.paused || this.error) {
+ return 0;
+ }
+ var delta = this.size - this.sizeUploaded();
+ if (delta && !this.averageSpeed) {
+ return Number.POSITIVE_INFINITY;
+ }
+ if (!delta && !this.averageSpeed) {
+ return 0;
+ }
+ return Math.floor(delta / this.averageSpeed);
+ },
+
+ /**
+ * Get file type
+ * @function
+ * @returns {string}
+ */
+ getType: function () {
+ return this.file.type && this.file.type.split('/')[1];
+ },
+
+ /**
+ * Get file extension
+ * @function
+ * @returns {string}
+ */
+ getExtension: function () {
+ return this.name.substr((~-this.name.lastIndexOf(".") >>> 0) + 2).toLowerCase();
+ }
+ };
+
+ /**
+ * Default read function using the webAPI
+ *
+ * @function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk)
+ *
+ */
+ function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk) {
+ var function_name = 'slice';
+
+ if (fileObj.file.slice)
+ function_name = 'slice';
+ else if (fileObj.file.mozSlice)
+ function_name = 'mozSlice';
+ else if (fileObj.file.webkitSlice)
+ function_name = 'webkitSlice';
+
+ chunk.readFinished(fileObj.file[function_name](startByte, endByte, fileType));
+ }
+
+
+ /**
+ * Class for storing a single chunk
+ * @name FlowChunk
+ * @param {Flow} flowObj
+ * @param {FlowFile} fileObj
+ * @param {number} offset
+ * @constructor
+ */
+ function FlowChunk(flowObj, fileObj, offset) {
+
+ /**
+ * Reference to parent flow object
+ * @type {Flow}
+ */
+ this.flowObj = flowObj;
+
+ /**
+ * Reference to parent FlowFile object
+ * @type {FlowFile}
+ */
+ this.fileObj = fileObj;
+
+ /**
+ * File offset
+ * @type {number}
+ */
+ this.offset = offset;
+
+ /**
+ * Indicates if chunk existence was checked on the server
+ * @type {boolean}
+ */
+ this.tested = false;
+
+ /**
+ * Number of retries performed
+ * @type {number}
+ */
+ this.retries = 0;
+
+ /**
+ * Pending retry
+ * @type {boolean}
+ */
+ this.pendingRetry = false;
+
+ /**
+ * Preprocess state
+ * @type {number} 0 = unprocessed, 1 = processing, 2 = finished
+ */
+ this.preprocessState = 0;
+
+ /**
+ * Read state
+ * @type {number} 0 = not read, 1 = reading, 2 = finished
+ */
+ this.readState = 0;
+
+
+ /**
+ * Bytes transferred from total request size
+ * @type {number}
+ */
+ this.loaded = 0;
+
+ /**
+ * Total request size
+ * @type {number}
+ */
+ this.total = 0;
+
+ /**
+ * Size of a chunk
+ * @type {number}
+ */
+ this.chunkSize = this.fileObj.chunkSize;
+
+ /**
+ * Chunk start byte in a file
+ * @type {number}
+ */
+ this.startByte = this.offset * this.chunkSize;
+
+ /**
+ * A specific filename for this chunk which otherwise default to the main name
+ * @type {string}
+ */
+ this.filename = null;
+
+ /**
+ * Compute the endbyte in a file
+ *
+ */
+ this.computeEndByte = function() {
+ var endByte = Math.min(this.fileObj.size, (this.offset + 1) * this.chunkSize);
+ if (this.fileObj.size - endByte < this.chunkSize && !this.flowObj.opts.forceChunkSize) {
+ // The last chunk will be bigger than the chunk size,
+ // but less than 2 * this.chunkSize
+ endByte = this.fileObj.size;
+ }
+ return endByte;
+ }
+
+ /**
+ * Chunk end byte in a file
+ * @type {number}
+ */
+ this.endByte = this.computeEndByte();
+
+ /**
+ * XMLHttpRequest
+ * @type {XMLHttpRequest}
+ */
+ this.xhr = null;
+
+ var $ = this;
+
+ /**
+ * Send chunk event
+ * @param event
+ * @param {...} args arguments of a callback
+ */
+ this.event = function (event, args) {
+ args = Array.prototype.slice.call(arguments);
+ args.unshift($);
+ $.fileObj.chunkEvent.apply($.fileObj, args);
+ };
+ /**
+ * Catch progress event
+ * @param {ProgressEvent} event
+ */
+ this.progressHandler = function(event) {
+ if (event.lengthComputable) {
+ $.loaded = event.loaded ;
+ $.total = event.total;
+ }
+ $.event('progress', event);
+ };
+
+ /**
+ * Catch test event
+ * @param {Event} event
+ */
+ this.testHandler = function(event) {
+ var status = $.status(true);
+ if (status === 'error') {
+ $.event(status, $.message());
+ $.flowObj.uploadNextChunk();
+ } else if (status === 'success') {
+ $.tested = true;
+ $.event(status, $.message());
+ $.flowObj.uploadNextChunk();
+ } else if (!$.fileObj.paused) {
+ // Error might be caused by file pause method
+ // Chunks does not exist on the server side
+ $.tested = true;
+ $.send();
+ }
+ };
+
+ /**
+ * Upload has stopped
+ * @param {Event} event
+ */
+ this.doneHandler = function(event) {
+ var status = $.status();
+ if (status === 'success' || status === 'error') {
+ delete this.data;
+ $.event(status, $.message());
+ $.flowObj.uploadNextChunk();
+ } else if (!$.fileObj.paused) {
+ $.event('retry', $.message());
+ $.pendingRetry = true;
+ $.abort();
+ $.retries++;
+ var retryInterval = $.flowObj.opts.chunkRetryInterval;
+ if (retryInterval !== null) {
+ setTimeout(function () {
+ $.send();
+ }, retryInterval);
+ } else {
+ $.send();
+ }
+ }
+ };
+ }
+
+ FlowChunk.prototype = {
+ /**
+ * Get params for a request
+ * @function
+ */
+ getParams: function () {
+ return {
+ flowChunkNumber: this.offset + 1,
+ flowChunkSize: this.chunkSize,
+ flowCurrentChunkSize: this.endByte - this.startByte,
+ flowTotalSize: this.fileObj.size,
+ flowIdentifier: this.fileObj.uniqueIdentifier,
+ flowFilename: this.fileObj.name,
+ flowRelativePath: this.fileObj.relativePath,
+ flowTotalChunks: this.fileObj.chunks.length
+ };
+ },
+
+ /**
+ * Get target option with query params
+ * @function
+ * @param params
+ * @returns {string}
+ */
+ getTarget: function(target, params){
+ if (params.length == 0) {
+ return target;
+ }
+
+ if(target.indexOf('?') < 0) {
+ target += '?';
+ } else {
+ target += '&';
+ }
+ return target + params.join('&');
+ },
+
+ /**
+ * Makes a GET request without any data to see if the chunk has already
+ * been uploaded in a previous session
+ * @function
+ */
+ test: function () {
+ // Set up request and listen for event
+ this.xhr = new XMLHttpRequest();
+ this.xhr.addEventListener("load", this.testHandler, false);
+ this.xhr.addEventListener("error", this.testHandler, false);
+ var testMethod = evalOpts(this.flowObj.opts.testMethod, this.fileObj, this);
+ var data = this.prepareXhrRequest(testMethod, true);
+ this.xhr.send(data);
+ },
+
+ /**
+ * Finish preprocess state
+ * @function
+ */
+ preprocessFinished: function () {
+ // Re-compute the endByte after the preprocess function to allow an
+ // implementer of preprocess to set the fileObj size
+ this.endByte = this.computeEndByte();
+
+ this.preprocessState = 2;
+ this.send();
+ },
+
+ /**
+ * Finish read state
+ * @function
+ */
+ readFinished: function (bytes) {
+ this.readState = 2;
+ this.bytes = bytes;
+ this.send();
+ },
+
+
+ /**
+ * Uploads the actual data in a POST call
+ * @function
+ */
+ send: function () {
+ var preprocess = this.flowObj.opts.preprocess;
+ var read = this.flowObj.opts.readFileFn;
+ if (typeof preprocess === 'function') {
+ switch (this.preprocessState) {
+ case 0:
+ this.preprocessState = 1;
+ preprocess(this);
+ return;
+ case 1:
+ return;
+ }
+ }
+ switch (this.readState) {
+ case 0:
+ this.readState = 1;
+ read(this.fileObj, this.startByte, this.endByte, this.fileObj.file.type, this);
+ return;
+ case 1:
+ return;
+ }
+ if (this.flowObj.opts.testChunks && !this.tested) {
+ this.test();
+ return;
+ }
+
+ this.loaded = 0;
+ this.total = 0;
+ this.pendingRetry = false;
+
+ // Set up request and listen for event
+ this.xhr = new XMLHttpRequest();
+ this.xhr.upload.addEventListener('progress', this.progressHandler, false);
+ this.xhr.addEventListener("load", this.doneHandler, false);
+ this.xhr.addEventListener("error", this.doneHandler, false);
+
+ var uploadMethod = evalOpts(this.flowObj.opts.uploadMethod, this.fileObj, this);
+ var data = this.prepareXhrRequest(uploadMethod, false, this.flowObj.opts.method, this.bytes);
+ var changeRawDataBeforeSend = this.flowObj.opts.changeRawDataBeforeSend;
+ if (typeof changeRawDataBeforeSend === 'function') {
+ data = changeRawDataBeforeSend(this, data);
+ }
+ this.xhr.send(data);
+ },
+
+ /**
+ * Abort current xhr request
+ * @function
+ */
+ abort: function () {
+ // Abort and reset
+ var xhr = this.xhr;
+ this.xhr = null;
+ if (xhr) {
+ xhr.abort();
+ }
+ },
+
+ /**
+ * Retrieve current chunk upload status
+ * @function
+ * @returns {string} 'pending', 'uploading', 'success', 'error'
+ */
+ status: function (isTest) {
+ if (this.readState === 1) {
+ return 'reading';
+ } else if (this.pendingRetry || this.preprocessState === 1) {
+ // if pending retry then that's effectively the same as actively uploading,
+ // there might just be a slight delay before the retry starts
+ return 'uploading';
+ } else if (!this.xhr) {
+ return 'pending';
+ } else if (this.xhr.readyState < 4) {
+ // Status is really 'OPENED', 'HEADERS_RECEIVED'
+ // or 'LOADING' - meaning that stuff is happening
+ return 'uploading';
+ } else {
+ if (this.flowObj.opts.successStatuses.indexOf(this.xhr.status) > -1) {
+ // HTTP 200, perfect
+ // HTTP 202 Accepted - The request has been accepted for processing, but the processing has not been completed.
+ return 'success';
+ } else if (this.flowObj.opts.permanentErrors.indexOf(this.xhr.status) > -1 ||
+ !isTest && this.retries >= this.flowObj.opts.maxChunkRetries) {
+ // HTTP 413/415/500/501, permanent error
+ return 'error';
+ } else {
+ // this should never happen, but we'll reset and queue a retry
+ // a likely case for this would be 503 service unavailable
+ this.abort();
+ return 'pending';
+ }
+ }
+ },
+
+ /**
+ * Get response from xhr request
+ * @function
+ * @returns {String}
+ */
+ message: function () {
+ return this.xhr ? this.xhr.responseText : '';
+ },
+
+ /**
+ * Get upload progress
+ * @function
+ * @returns {number}
+ */
+ progress: function () {
+ if (this.pendingRetry) {
+ return 0;
+ }
+ var s = this.status();
+ if (s === 'success' || s === 'error') {
+ return 1;
+ } else if (s === 'pending') {
+ return 0;
+ } else {
+ return this.total > 0 ? this.loaded / this.total : 0;
+ }
+ },
+
+ /**
+ * Count total size uploaded
+ * @function
+ * @returns {number}
+ */
+ sizeUploaded: function () {
+ var size = this.endByte - this.startByte;
+ // can't return only chunk.loaded value, because it is bigger than chunk size
+ if (this.status() !== 'success') {
+ size = this.progress() * size;
+ }
+ return size;
+ },
+
+ /**
+ * Prepare Xhr request. Set query, headers and data
+ * @param {string} method GET or POST
+ * @param {bool} isTest is this a test request
+ * @param {string} [paramsMethod] octet or form
+ * @param {Blob} [blob] to send
+ * @returns {FormData|Blob|Null} data to send
+ */
+ prepareXhrRequest: function(method, isTest, paramsMethod, blob) {
+ // Add data from the query options
+ var query = evalOpts(this.flowObj.opts.query, this.fileObj, this, isTest);
+ query = extend(query || {}, this.getParams());
+
+ var target = evalOpts(this.flowObj.opts.target, this.fileObj, this, isTest);
+ var data = null;
+ if (method === 'GET' || paramsMethod === 'octet') {
+ // Add data from the query options
+ var params = [];
+ each(query, function (v, k) {
+ params.push([encodeURIComponent(k), encodeURIComponent(v)].join('='));
+ });
+ target = this.getTarget(target, params);
+ data = blob || null;
+ } else {
+ // Add data from the query options
+ data = new FormData();
+ each(query, function (v, k) {
+ data.append(k, v);
+ });
+ if (typeof blob !== "undefined") {
+ data.append(this.flowObj.opts.fileParameterName, blob, this.filename || this.fileObj.file.name);
+ }
+ }
+
+ this.xhr.open(method, target, true);
+ this.xhr.withCredentials = this.flowObj.opts.withCredentials;
+
+ // Add data from header options
+ each(evalOpts(this.flowObj.opts.headers, this.fileObj, this, isTest), function (v, k) {
+ this.xhr.setRequestHeader(k, v);
+ }, this);
+
+ return data;
+ }
+ };
+
+ /**
+ * Remove value from array
+ * @param array
+ * @param value
+ */
+ function arrayRemove(array, value) {
+ var index = array.indexOf(value);
+ if (index > -1) {
+ array.splice(index, 1);
+ }
+ }
+
+ /**
+ * If option is a function, evaluate it with given params
+ * @param {*} data
+ * @param {...} args arguments of a callback
+ * @returns {*}
+ */
+ function evalOpts(data, args) {
+ if (typeof data === "function") {
+ // `arguments` is an object, not array, in FF, so:
+ args = Array.prototype.slice.call(arguments);
+ data = data.apply(null, args.slice(1));
+ }
+ return data;
+ }
+ Flow.evalOpts = evalOpts;
+
+ /**
+ * Execute function asynchronously
+ * @param fn
+ * @param context
+ */
+ function async(fn, context) {
+ setTimeout(fn.bind(context), 0);
+ }
+
+ /**
+ * Extends the destination object `dst` by copying all of the properties from
+ * the `src` object(s) to `dst`. You can specify multiple `src` objects.
+ * @function
+ * @param {Object} dst Destination object.
+ * @param {...Object} src Source object(s).
+ * @returns {Object} Reference to `dst`.
+ */
+ function extend(dst, src) {
+ each(arguments, function(obj) {
+ if (obj !== dst) {
+ each(obj, function(value, key){
+ dst[key] = value;
+ });
+ }
+ });
+ return dst;
+ }
+ Flow.extend = extend;
+
+ /**
+ * Iterate each element of an object
+ * @function
+ * @param {Array|Object} obj object or an array to iterate
+ * @param {Function} callback first argument is a value and second is a key.
+ * @param {Object=} context Object to become context (`this`) for the iterator function.
+ */
+ function each(obj, callback, context) {
+ if (!obj) {
+ return ;
+ }
+ var key;
+ // Is Array?
+ // Array.isArray won't work, not only arrays can be iterated by index https://github.com/flowjs/ng-flow/issues/236#
+ if (typeof(obj.length) !== 'undefined') {
+ for (key = 0; key < obj.length; key++) {
+ if (callback.call(context, obj[key], key) === false) {
+ return ;
+ }
+ }
+ } else {
+ for (key in obj) {
+ if (obj.hasOwnProperty(key) && callback.call(context, obj[key], key) === false) {
+ return ;
+ }
+ }
+ }
+ }
+ Flow.each = each;
+
+ /**
+ * FlowFile constructor
+ * @type {FlowFile}
+ */
+ Flow.FlowFile = FlowFile;
+
+ /**
+ * FlowFile constructor
+ * @type {FlowChunk}
+ */
+ Flow.FlowChunk = FlowChunk;
+
+ /**
+ * Library version
+ * @type {string}
+ */
+ Flow.version = '<%= version %>';
+
+ if ( true && module && typeof module.exports === "object" ) {
+ // Expose Flow as module.exports in loaders that implement the Node
+ // module pattern (including browserify). Do not create the global, since
+ // the user will be storing it themselves locally, and globals are frowned
+ // upon in the Node module world.
+ module.exports = Flow;
+ } else {
+ // Otherwise expose Flow to the global object as usual
+ window.Flow = Flow;
+
+ // Register as a named AMD module, since Flow can be concatenated with other
+ // files that may use define, but not via a proper concatenation script that
+ // understands anonymous AMD modules. A named AMD is safest and most robust
+ // way to register. Lowercase flow is used because AMD module names are
+ // derived from file names, and Flow is normally delivered in a lowercase
+ // file name. Do this after creating the global so that if an AMD module wants
+ // to call noConflict to hide this version of Flow, it will work.
+ if ( true ) {
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () { return Flow; }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+ }
+ }
+})(typeof window !== 'undefined' && window, typeof document !== 'undefined' && document);
+
+
+/***/ }),
+
+/***/ "./node_modules/@flowjs/ng-flow/dist/ng-flow.js":
+/*!******************************************************!*\
+ !*** ./node_modules/@flowjs/ng-flow/dist/ng-flow.js ***!
+ \******************************************************/
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+/* provided dependency */ var Flow = __webpack_require__(/*! @flowjs/flow.js */ "./node_modules/@flowjs/flow.js/src/flow.js");
+/**
+ * @description
+ * var app = angular.module('App', ['flow.provider'], function(flowFactoryProvider){
+ * flowFactoryProvider.defaults = {target: '/'};
+ * });
+ * @name flowFactoryProvider
+ */
+angular.module('flow.provider', [])
+.provider('flowFactory', function() {
+ 'use strict';
+ /**
+ * Define the default properties for flow.js
+ * @name flowFactoryProvider.defaults
+ * @type {Object}
+ */
+ this.defaults = {};
+
+ /**
+ * Flow, MaybeFlow or NotFlow
+ * @name flowFactoryProvider.factory
+ * @type {function}
+ * @return {Flow}
+ */
+ this.factory = function (options) {
+ return new Flow(options);
+ };
+
+ /**
+ * Define the default events
+ * @name flowFactoryProvider.events
+ * @type {Array}
+ * @private
+ */
+ this.events = [];
+
+ /**
+ * Add default events
+ * @name flowFactoryProvider.on
+ * @function
+ * @param {string} event
+ * @param {Function} callback
+ */
+ this.on = function (event, callback) {
+ this.events.push([event, callback]);
+ };
+
+ this.$get = function() {
+ var fn = this.factory;
+ var defaults = this.defaults;
+ var events = this.events;
+ return {
+ 'create': function(opts) {
+ // combine default options with global options and options
+ var flow = fn(angular.extend({}, defaults, opts));
+ angular.forEach(events, function (event) {
+ flow.on(event[0], event[1]);
+ });
+ return flow;
+ }
+ };
+ };
+});
+angular.module('flow.init', ['flow.provider'])
+ .controller('flowCtrl', ['$scope', '$attrs', '$parse', 'flowFactory',
+ function ($scope, $attrs, $parse, flowFactory) {
+
+ var options = angular.extend({}, $scope.$eval($attrs.flowInit));
+
+ // use existing flow object or create a new one
+ var flow = $scope.$eval($attrs.flowObject) || flowFactory.create(options);
+
+ var catchAllHandler = function(eventName){
+ var args = Array.prototype.slice.call(arguments);
+ args.shift();
+ var event = $scope.$broadcast.apply($scope, ['flow::' + eventName, flow].concat(args));
+ if ({
+ 'progress':1, 'filesSubmitted':1, 'fileSuccess': 1, 'fileError': 1, 'complete': 1
+ }[eventName]) {
+ $scope.$applyAsync();
+ }
+ if (event.defaultPrevented) {
+ return false;
+ }
+ };
+
+ flow.on('catchAll', catchAllHandler);
+ $scope.$on('$destroy', function(){
+ flow.off('catchAll', catchAllHandler);
+ });
+
+ $scope.$flow = flow;
+
+ if ($attrs.hasOwnProperty('flowName')) {
+ $parse($attrs.flowName).assign($scope, flow);
+ $scope.$on('$destroy', function () {
+ $parse($attrs.flowName).assign($scope);
+ });
+ }
+ }])
+ .directive('flowInit', [function() {
+ return {
+ scope: true,
+ controller: 'flowCtrl'
+ };
+ }]);
+angular.module('flow.btn', ['flow.init'])
+.directive('flowBtn', [function() {
+ return {
+ 'restrict': 'EA',
+ 'scope': false,
+ 'require': '^flowInit',
+ 'link': function(scope, element, attrs) {
+ var isDirectory = attrs.hasOwnProperty('flowDirectory');
+ var isSingleFile = attrs.hasOwnProperty('flowSingleFile');
+ var inputAttrs = attrs.hasOwnProperty('flowAttrs') && scope.$eval(attrs.flowAttrs);
+ scope.$flow.assignBrowse(element, isDirectory, isSingleFile, inputAttrs);
+ }
+ };
+}]);
+angular.module('flow.dragEvents', ['flow.init'])
+/**
+ * @name flowPreventDrop
+ * Prevent loading files then dropped on element
+ */
+ .directive('flowPreventDrop', function() {
+ return {
+ 'scope': false,
+ 'link': function(scope, element, attrs) {
+ element.bind('drop dragover', function (event) {
+ event.preventDefault();
+ });
+ }
+ };
+ })
+/**
+ * @name flowDragEnter
+ * executes `flowDragEnter` and `flowDragLeave` events
+ */
+ .directive('flowDragEnter', ['$timeout', function($timeout) {
+ return {
+ 'scope': false,
+ 'link': function(scope, element, attrs) {
+ var promise;
+ var enter = false;
+ element.bind('dragover', function (event) {
+ if (!isFileDrag(event)) {
+ return ;
+ }
+ if (!enter) {
+ scope.$apply(attrs.flowDragEnter);
+ enter = true;
+ }
+ $timeout.cancel(promise);
+ event.preventDefault();
+ });
+ element.bind('dragleave drop', function (event) {
+ $timeout.cancel(promise);
+ promise = $timeout(function () {
+ scope.$eval(attrs.flowDragLeave);
+ promise = null;
+ enter = false;
+ }, 100);
+ });
+ function isFileDrag(dragEvent) {
+ var fileDrag = false;
+ var dataTransfer = dragEvent.dataTransfer || dragEvent.originalEvent.dataTransfer;
+ angular.forEach(dataTransfer && dataTransfer.types, function(val) {
+ if (val === 'Files') {
+ fileDrag = true;
+ }
+ });
+ return fileDrag;
+ }
+ }
+ };
+ }]);
+
+angular.module('flow.drop', ['flow.init'])
+.directive('flowDrop', function() {
+ return {
+ 'scope': false,
+ 'require': '^flowInit',
+ 'link': function(scope, element, attrs) {
+ if (attrs.flowDropEnabled) {
+ scope.$watch(attrs.flowDropEnabled, function (value) {
+ if (value) {
+ assignDrop();
+ } else {
+ unAssignDrop();
+ }
+ });
+ } else {
+ assignDrop();
+ }
+ function assignDrop() {
+ scope.$flow.assignDrop(element);
+ }
+ function unAssignDrop() {
+ scope.$flow.unAssignDrop(element);
+ }
+ }
+ };
+});
+
+!function (angular) {'use strict';
+ var module = angular.module('flow.events', ['flow.init']);
+ var events = {
+ fileSuccess: ['$file', '$message'],
+ fileProgress: ['$file'],
+ fileAdded: ['$file', '$event'],
+ filesAdded: ['$files', '$event'],
+ filesSubmitted: ['$files', '$event'],
+ fileRetry: ['$file'],
+ fileRemoved: ['$file'],
+ fileError: ['$file', '$message'],
+ uploadStart: [],
+ complete: [],
+ progress: [],
+ error: ['$message', '$file']
+ };
+
+ angular.forEach(events, function (eventArgs, eventName) {
+ var name = 'flow' + capitaliseFirstLetter(eventName);
+ if (name == 'flowUploadStart') {
+ name = 'flowUploadStarted';// event alias
+ }
+ module.directive(name, [function() {
+ return {
+ require: '^flowInit',
+ controller: ['$scope', '$attrs', function ($scope, $attrs) {
+ $scope.$on('flow::' + eventName, function () {
+ var funcArgs = Array.prototype.slice.call(arguments);
+ var event = funcArgs.shift();// remove angular event
+ // remove flow object and ignore event if it is from parent directive
+ if ($scope.$flow !== funcArgs.shift()) {
+ return ;
+ }
+ var args = {};
+ angular.forEach(eventArgs, function(value, key) {
+ args[value] = funcArgs[key];
+ });
+ if ($scope.$eval($attrs[name], args) === false) {
+ event.preventDefault();
+ }
+ });
+ }]
+ };
+ }]);
+ });
+
+ function capitaliseFirstLetter(string) {
+ return string.charAt(0).toUpperCase() + string.slice(1);
+ }
+}(angular);
+
+angular.module('flow.img', ['flow.init'])
+.directive('flowImg', [function() {
+ return {
+ 'scope': false,
+ 'require': '^flowInit',
+ 'link': function(scope, element, attrs) {
+ var file = attrs.flowImg;
+ scope.$watch(file, function (file) {
+ if (!file) {
+ return ;
+ }
+ var fileReader = new FileReader();
+ fileReader.readAsDataURL(file.file);
+ fileReader.onload = function (event) {
+ scope.$apply(function () {
+ attrs.$set('src', event.target.result);
+ });
+ };
+ });
+ }
+ };
+}]);
+angular.module('flow.transfers', ['flow.init'])
+.directive('flowTransfers', [function() {
+ return {
+ 'scope': true,
+ 'require': '^flowInit',
+ 'link': function(scope) {
+ scope.transfers = scope.$flow.files;
+ }
+ };
+}]);
+angular.module('flow', ['flow.provider', 'flow.init', 'flow.events', 'flow.btn',
+ 'flow.drop', 'flow.transfers', 'flow.img', 'flow.dragEvents']);
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/angular.js":
+/*!*************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/angular.js ***!
+ \*************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "ng": () => (/* binding */ ng)
+/* harmony export */ });
+/* harmony import */ var angular__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! angular */ "./node_modules/angular/index-exposed.js");
+/* harmony import */ var angular__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(angular__WEBPACK_IMPORTED_MODULE_0__);
+/** @publicapi @module ng1 */ /** */
+
+/** @hidden */ var ng_from_global = angular;
+/** @hidden */ var ng = angular__WEBPACK_IMPORTED_MODULE_0__ && angular__WEBPACK_IMPORTED_MODULE_0__.module ? angular__WEBPACK_IMPORTED_MODULE_0__ : ng_from_global;
+//# sourceMappingURL=angular.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/directives/stateDirectives.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/directives/stateDirectives.js ***!
+ \********************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _angular__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../angular */ "./node_modules/@uirouter/angularjs/lib-esm/angular.js");
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable prefer-const */
+/**
+ * # Angular 1 Directives
+ *
+ * These are the directives included in UI-Router for Angular 1.
+ * These directives are used in templates to create viewports and link/navigate to states.
+ *
+ * @preferred @publicapi @module directives
+ */ /** */
+
+
+/** @hidden */
+function parseStateRef(ref) {
+ var paramsOnly = ref.match(/^\s*({[^}]*})\s*$/);
+ if (paramsOnly)
+ ref = '(' + paramsOnly[1] + ')';
+ var parsed = ref.replace(/\n/g, ' ').match(/^\s*([^(]*?)\s*(\((.*)\))?\s*$/);
+ if (!parsed || parsed.length !== 4)
+ throw new Error("Invalid state ref '" + ref + "'");
+ return { state: parsed[1] || null, paramExpr: parsed[3] || null };
+}
+/** @hidden */
+function stateContext(el) {
+ var $uiView = el.parent().inheritedData('$uiView');
+ var path = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.parse)('$cfg.path')($uiView);
+ return path ? (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.tail)(path).state.name : undefined;
+}
+/** @hidden */
+function processedDef($state, $element, def) {
+ var uiState = def.uiState || $state.current.name;
+ var uiStateOpts = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.extend)(defaultOpts($element, $state), def.uiStateOpts || {});
+ var href = $state.href(uiState, def.uiStateParams, uiStateOpts);
+ return { uiState: uiState, uiStateParams: def.uiStateParams, uiStateOpts: uiStateOpts, href: href };
+}
+/** @hidden */
+function getTypeInfo(el) {
+ // SVGAElement does not use the href attribute, but rather the 'xlinkHref' attribute.
+ var isSvg = Object.prototype.toString.call(el.prop('href')) === '[object SVGAnimatedString]';
+ var isForm = el[0].nodeName === 'FORM';
+ return {
+ attr: isForm ? 'action' : isSvg ? 'xlink:href' : 'href',
+ isAnchor: el.prop('tagName').toUpperCase() === 'A',
+ clickable: !isForm,
+ };
+}
+/** @hidden */
+function clickHook(el, $state, $timeout, type, getDef) {
+ return function (e) {
+ var button = e.which || e.button, target = getDef();
+ if (!(button > 1 || e.ctrlKey || e.metaKey || e.shiftKey || e.altKey || el.attr('target'))) {
+ // HACK: This is to allow ng-clicks to be processed before the transition is initiated:
+ var transition_1 = $timeout(function () {
+ if (!el.attr('disabled')) {
+ $state.go(target.uiState, target.uiStateParams, target.uiStateOpts);
+ }
+ });
+ e.preventDefault();
+ // if the state has no URL, ignore one preventDefault from the <a> directive.
+ var ignorePreventDefaultCount_1 = type.isAnchor && !target.href ? 1 : 0;
+ e.preventDefault = function () {
+ if (ignorePreventDefaultCount_1-- <= 0)
+ $timeout.cancel(transition_1);
+ };
+ }
+ };
+}
+/** @hidden */
+function defaultOpts(el, $state) {
+ return {
+ relative: stateContext(el) || $state.$current,
+ inherit: true,
+ source: 'sref',
+ };
+}
+/** @hidden */
+function bindEvents(element, scope, hookFn, uiStateOpts) {
+ var events;
+ if (uiStateOpts) {
+ events = uiStateOpts.events;
+ }
+ if (!(0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isArray)(events)) {
+ events = ['click'];
+ }
+ var on = element.on ? 'on' : 'bind';
+ for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
+ var event_1 = events_1[_i];
+ element[on](event_1, hookFn);
+ }
+ scope.$on('$destroy', function () {
+ var off = element.off ? 'off' : 'unbind';
+ for (var _i = 0, events_2 = events; _i < events_2.length; _i++) {
+ var event_2 = events_2[_i];
+ element[off](event_2, hookFn);
+ }
+ });
+}
+/**
+ * `ui-sref`: A directive for linking to a state
+ *
+ * A directive which links to a state (and optionally, parameters).
+ * When clicked, this directive activates the linked state with the supplied parameter values.
+ *
+ * ### Linked State
+ * The attribute value of the `ui-sref` is the name of the state to link to.
+ *
+ * #### Example:
+ * This will activate the `home` state when the link is clicked.
+ * ```html
+ * <a ui-sref="home">Home</a>
+ * ```
+ *
+ * ### Relative Links
+ * You can also use relative state paths within `ui-sref`, just like a relative path passed to `$state.go()` ([[StateService.go]]).
+ * You just need to be aware that the path is relative to the state that *created* the link.
+ * This allows a state to create a relative `ui-sref` which always targets the same destination.
+ *
+ * #### Example:
+ * Both these links are relative to the parent state, even when a child state is currently active.
+ * ```html
+ * <a ui-sref=".child1">child 1 state</a>
+ * <a ui-sref=".child2">child 2 state</a>
+ * ```
+ *
+ * This link activates the parent state.
+ * ```html
+ * <a ui-sref="^">Return</a>
+ * ```
+ *
+ * ### hrefs
+ * If the linked state has a URL, the directive will automatically generate and
+ * update the `href` attribute (using the [[StateService.href]] method).
+ *
+ * #### Example:
+ * Assuming the `users` state has a url of `/users/`
+ * ```html
+ * <a ui-sref="users" href="/users/">Users</a>
+ * ```
+ *
+ * ### Parameter Values
+ * In addition to the state name, a `ui-sref` can include parameter values which are applied when activating the state.
+ * Param values can be provided in the `ui-sref` value after the state name, enclosed by parentheses.
+ * The content inside the parentheses is an expression, evaluated to the parameter values.
+ *
+ * #### Example:
+ * This example renders a list of links to users.
+ * The state's `userId` parameter value comes from each user's `user.id` property.
+ * ```html
+ * <li ng-repeat="user in users">
+ * <a ui-sref="users.detail({ userId: user.id })">{{ user.displayName }}</a>
+ * </li>
+ * ```
+ *
+ * Note:
+ * The parameter values expression is `$watch`ed for updates.
+ *
+ * ### Transition Options
+ * You can specify [[TransitionOptions]] to pass to [[StateService.go]] by using the `ui-sref-opts` attribute.
+ * Options are restricted to `location`, `inherit`, and `reload`.
+ *
+ * #### Example:
+ * ```html
+ * <a ui-sref="home" ui-sref-opts="{ reload: true }">Home</a>
+ * ```
+ *
+ * ### Other DOM Events
+ *
+ * You can also customize which DOM events to respond to (instead of `click`) by
+ * providing an `events` array in the `ui-sref-opts` attribute.
+ *
+ * #### Example:
+ * ```html
+ * <input type="text" ui-sref="contacts" ui-sref-opts="{ events: ['change', 'blur'] }">
+ * ```
+ *
+ * ### Highlighting the active link
+ * This directive can be used in conjunction with [[uiSrefActive]] to highlight the active link.
+ *
+ * ### Examples
+ * If you have the following template:
+ *
+ * ```html
+ * <a ui-sref="home">Home</a>
+ * <a ui-sref="about">About</a>
+ * <a ui-sref="{page: 2}">Next page</a>
+ *
+ * <ul>
+ * <li ng-repeat="contact in contacts">
+ * <a ui-sref="contacts.detail({ id: contact.id })">{{ contact.name }}</a>
+ * </li>
+ * </ul>
+ * ```
+ *
+ * Then (assuming the current state is `contacts`) the rendered html including hrefs would be:
+ *
+ * ```html
+ * <a href="#/home" ui-sref="home">Home</a>
+ * <a href="#/about" ui-sref="about">About</a>
+ * <a href="#/contacts?page=2" ui-sref="{page: 2}">Next page</a>
+ *
+ * <ul>
+ * <li ng-repeat="contact in contacts">
+ * <a href="#/contacts/1" ui-sref="contacts.detail({ id: contact.id })">Joe</a>
+ * </li>
+ * <li ng-repeat="contact in contacts">
+ * <a href="#/contacts/2" ui-sref="contacts.detail({ id: contact.id })">Alice</a>
+ * </li>
+ * <li ng-repeat="contact in contacts">
+ * <a href="#/contacts/3" ui-sref="contacts.detail({ id: contact.id })">Bob</a>
+ * </li>
+ * </ul>
+ *
+ * <a href="#/home" ui-sref="home" ui-sref-opts="{reload: true}">Home</a>
+ * ```
+ *
+ * ### Notes
+ *
+ * - You can use `ui-sref` to change **only the parameter values** by omitting the state name and parentheses.
+ * #### Example:
+ * Sets the `lang` parameter to `en` and remains on the same state.
+ *
+ * ```html
+ * <a ui-sref="{ lang: 'en' }">English</a>
+ * ```
+ *
+ * - A middle-click, right-click, or ctrl-click is handled (natively) by the browser to open the href in a new window, for example.
+ *
+ * - Unlike the parameter values expression, the state name is not `$watch`ed (for performance reasons).
+ * If you need to dynamically update the state being linked to, use the fully dynamic [[uiState]] directive.
+ */
+var uiSrefDirective;
+uiSrefDirective = [
+ '$uiRouter',
+ '$timeout',
+ function $StateRefDirective($uiRouter, $timeout) {
+ var $state = $uiRouter.stateService;
+ return {
+ restrict: 'A',
+ require: ['?^uiSrefActive', '?^uiSrefActiveEq'],
+ link: function (scope, element, attrs, uiSrefActive) {
+ var type = getTypeInfo(element);
+ var active = uiSrefActive[1] || uiSrefActive[0];
+ var unlinkInfoFn = null;
+ var rawDef = {};
+ var getDef = function () { return processedDef($state, element, rawDef); };
+ var ref = parseStateRef(attrs.uiSref);
+ rawDef.uiState = ref.state;
+ rawDef.uiStateOpts = attrs.uiSrefOpts ? scope.$eval(attrs.uiSrefOpts) : {};
+ function update() {
+ var def = getDef();
+ if (unlinkInfoFn)
+ unlinkInfoFn();
+ if (active)
+ unlinkInfoFn = active.$$addStateInfo(def.uiState, def.uiStateParams);
+ if (def.href != null)
+ attrs.$set(type.attr, def.href);
+ }
+ if (ref.paramExpr) {
+ scope.$watch(ref.paramExpr, function (val) {
+ rawDef.uiStateParams = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.extend)({}, val);
+ update();
+ }, true);
+ rawDef.uiStateParams = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.extend)({}, scope.$eval(ref.paramExpr));
+ }
+ update();
+ scope.$on('$destroy', $uiRouter.stateRegistry.onStatesChanged(update));
+ scope.$on('$destroy', $uiRouter.transitionService.onSuccess({}, update));
+ if (!type.clickable)
+ return;
+ var hookFn = clickHook(element, $state, $timeout, type, getDef);
+ bindEvents(element, scope, hookFn, rawDef.uiStateOpts);
+ },
+ };
+ },
+];
+/**
+ * `ui-state`: A fully dynamic directive for linking to a state
+ *
+ * A directive which links to a state (and optionally, parameters).
+ * When clicked, this directive activates the linked state with the supplied parameter values.
+ *
+ * **This directive is very similar to [[uiSref]], but it `$observe`s and `$watch`es/evaluates all its inputs.**
+ *
+ * A directive which links to a state (and optionally, parameters).
+ * When clicked, this directive activates the linked state with the supplied parameter values.
+ *
+ * ### Linked State
+ * The attribute value of `ui-state` is an expression which is `$watch`ed and evaluated as the state to link to.
+ * **This is in contrast with `ui-sref`, which takes a state name as a string literal.**
+ *
+ * #### Example:
+ * Create a list of links.
+ * ```html
+ * <li ng-repeat="link in navlinks">
+ * <a ui-state="link.state">{{ link.displayName }}</a>
+ * </li>
+ * ```
+ *
+ * ### Relative Links
+ * If the expression evaluates to a relative path, it is processed like [[uiSref]].
+ * You just need to be aware that the path is relative to the state that *created* the link.
+ * This allows a state to create relative `ui-state` which always targets the same destination.
+ *
+ * ### hrefs
+ * If the linked state has a URL, the directive will automatically generate and
+ * update the `href` attribute (using the [[StateService.href]] method).
+ *
+ * ### Parameter Values
+ * In addition to the state name expression, a `ui-state` can include parameter values which are applied when activating the state.
+ * Param values should be provided using the `ui-state-params` attribute.
+ * The `ui-state-params` attribute value is `$watch`ed and evaluated as an expression.
+ *
+ * #### Example:
+ * This example renders a list of links with param values.
+ * The state's `userId` parameter value comes from each user's `user.id` property.
+ * ```html
+ * <li ng-repeat="link in navlinks">
+ * <a ui-state="link.state" ui-state-params="link.params">{{ link.displayName }}</a>
+ * </li>
+ * ```
+ *
+ * ### Transition Options
+ * You can specify [[TransitionOptions]] to pass to [[StateService.go]] by using the `ui-state-opts` attribute.
+ * Options are restricted to `location`, `inherit`, and `reload`.
+ * The value of the `ui-state-opts` is `$watch`ed and evaluated as an expression.
+ *
+ * #### Example:
+ * ```html
+ * <a ui-state="returnto.state" ui-state-opts="{ reload: true }">Home</a>
+ * ```
+ *
+ * ### Other DOM Events
+ *
+ * You can also customize which DOM events to respond to (instead of `click`) by
+ * providing an `events` array in the `ui-state-opts` attribute.
+ *
+ * #### Example:
+ * ```html
+ * <input type="text" ui-state="contacts" ui-state-opts="{ events: ['change', 'blur'] }">
+ * ```
+ *
+ * ### Highlighting the active link
+ * This directive can be used in conjunction with [[uiSrefActive]] to highlight the active link.
+ *
+ * ### Notes
+ *
+ * - You can use `ui-params` to change **only the parameter values** by omitting the state name and supplying only `ui-state-params`.
+ * However, it might be simpler to use [[uiSref]] parameter-only links.
+ *
+ * #### Example:
+ * Sets the `lang` parameter to `en` and remains on the same state.
+ *
+ * ```html
+ * <a ui-state="" ui-state-params="{ lang: 'en' }">English</a>
+ * ```
+ *
+ * - A middle-click, right-click, or ctrl-click is handled (natively) by the browser to open the href in a new window, for example.
+ * ```
+ */
+var uiStateDirective;
+uiStateDirective = [
+ '$uiRouter',
+ '$timeout',
+ function $StateRefDynamicDirective($uiRouter, $timeout) {
+ var $state = $uiRouter.stateService;
+ return {
+ restrict: 'A',
+ require: ['?^uiSrefActive', '?^uiSrefActiveEq'],
+ link: function (scope, element, attrs, uiSrefActive) {
+ var type = getTypeInfo(element);
+ var active = uiSrefActive[1] || uiSrefActive[0];
+ var unlinkInfoFn = null;
+ var hookFn;
+ var rawDef = {};
+ var getDef = function () { return processedDef($state, element, rawDef); };
+ var inputAttrs = ['uiState', 'uiStateParams', 'uiStateOpts'];
+ var watchDeregFns = inputAttrs.reduce(function (acc, attr) { return ((acc[attr] = _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.noop), acc); }, {});
+ function update() {
+ var def = getDef();
+ if (unlinkInfoFn)
+ unlinkInfoFn();
+ if (active)
+ unlinkInfoFn = active.$$addStateInfo(def.uiState, def.uiStateParams);
+ if (def.href != null)
+ attrs.$set(type.attr, def.href);
+ }
+ inputAttrs.forEach(function (field) {
+ rawDef[field] = attrs[field] ? scope.$eval(attrs[field]) : null;
+ attrs.$observe(field, function (expr) {
+ watchDeregFns[field]();
+ watchDeregFns[field] = scope.$watch(expr, function (newval) {
+ rawDef[field] = newval;
+ update();
+ }, true);
+ });
+ });
+ update();
+ scope.$on('$destroy', $uiRouter.stateRegistry.onStatesChanged(update));
+ scope.$on('$destroy', $uiRouter.transitionService.onSuccess({}, update));
+ if (!type.clickable)
+ return;
+ hookFn = clickHook(element, $state, $timeout, type, getDef);
+ bindEvents(element, scope, hookFn, rawDef.uiStateOpts);
+ },
+ };
+ },
+];
+/**
+ * `ui-sref-active` and `ui-sref-active-eq`: A directive that adds a CSS class when a `ui-sref` is active
+ *
+ * A directive working alongside [[uiSref]] and [[uiState]] to add classes to an element when the
+ * related directive's state is active (and remove them when it is inactive).
+ *
+ * The primary use-case is to highlight the active link in navigation menus,
+ * distinguishing it from the inactive menu items.
+ *
+ * ### Linking to a `ui-sref` or `ui-state`
+ * `ui-sref-active` can live on the same element as `ui-sref`/`ui-state`, or it can be on a parent element.
+ * If a `ui-sref-active` is a parent to more than one `ui-sref`/`ui-state`, it will apply the CSS class when **any of the links are active**.
+ *
+ * ### Matching
+ *
+ * The `ui-sref-active` directive applies the CSS class when the `ui-sref`/`ui-state`'s target state **or any child state is active**.
+ * This is a "fuzzy match" which uses [[StateService.includes]].
+ *
+ * The `ui-sref-active-eq` directive applies the CSS class when the `ui-sref`/`ui-state`'s target state is directly active (not when child states are active).
+ * This is an "exact match" which uses [[StateService.is]].
+ *
+ * ### Parameter values
+ * If the `ui-sref`/`ui-state` includes parameter values, the current parameter values must match the link's values for the link to be highlighted.
+ * This allows a list of links to the same state with different parameters to be rendered, and the correct one highlighted.
+ *
+ * #### Example:
+ * ```html
+ * <li ng-repeat="user in users" ui-sref-active="active">
+ * <a ui-sref="user.details({ userId: user.id })">{{ user.lastName }}</a>
+ * </li>
+ * ```
+ *
+ * ### Examples
+ *
+ * Given the following template:
+ * #### Example:
+ * ```html
+ * <ul>
+ * <li ui-sref-active="active" class="item">
+ * <a href ui-sref="app.user({user: 'bilbobaggins'})">@bilbobaggins</a>
+ * </li>
+ * </ul>
+ * ```
+ *
+ * When the app state is `app.user` (or any child state),
+ * and contains the state parameter "user" with value "bilbobaggins",
+ * the resulting HTML will appear as (note the 'active' class):
+ *
+ * ```html
+ * <ul>
+ * <li ui-sref-active="active" class="item active">
+ * <a ui-sref="app.user({user: 'bilbobaggins'})" href="/users/bilbobaggins">@bilbobaggins</a>
+ * </li>
+ * </ul>
+ * ```
+ *
+ * ### Glob mode
+ *
+ * It is possible to pass `ui-sref-active` an expression that evaluates to an object.
+ * The objects keys represent active class names and values represent the respective state names/globs.
+ * `ui-sref-active` will match if the current active state **includes** any of
+ * the specified state names/globs, even the abstract ones.
+ *
+ * #### Example:
+ * Given the following template, with "admin" being an abstract state:
+ * ```html
+ * <div ui-sref-active="{'active': 'admin.**'}">
+ * <a ui-sref-active="active" ui-sref="admin.roles">Roles</a>
+ * </div>
+ * ```
+ *
+ * Arrays are also supported as values in the `ngClass`-like interface.
+ * This allows multiple states to add `active` class.
+ *
+ * #### Example:
+ * Given the following template, with "admin.roles" being the current state, the class will be added too:
+ * ```html
+ * <div ui-sref-active="{'active': ['owner.**', 'admin.**']}">
+ * <a ui-sref-active="active" ui-sref="admin.roles">Roles</a>
+ * </div>
+ * ```
+ *
+ * When the current state is "admin.roles" the "active" class will be applied to both the `<div>` and `<a>` elements.
+ * It is important to note that the state names/globs passed to `ui-sref-active` override any state provided by a linked `ui-sref`.
+ *
+ * ### Notes:
+ *
+ * - The class name is interpolated **once** during the directives link time (any further changes to the
+ * interpolated value are ignored).
+ *
+ * - Multiple classes may be specified in a space-separated format: `ui-sref-active='class1 class2 class3'`
+ */
+var uiSrefActiveDirective;
+uiSrefActiveDirective = [
+ '$state',
+ '$stateParams',
+ '$interpolate',
+ '$uiRouter',
+ function $StateRefActiveDirective($state, $stateParams, $interpolate, $uiRouter) {
+ return {
+ restrict: 'A',
+ controller: [
+ '$scope',
+ '$element',
+ '$attrs',
+ function ($scope, $element, $attrs) {
+ var states = [];
+ var activeEqClass;
+ var uiSrefActive;
+ // There probably isn't much point in $observing this
+ // uiSrefActive and uiSrefActiveEq share the same directive object with some
+ // slight difference in logic routing
+ activeEqClass = $interpolate($attrs.uiSrefActiveEq || '', false)($scope);
+ try {
+ uiSrefActive = $scope.$eval($attrs.uiSrefActive);
+ }
+ catch (e) {
+ // Do nothing. uiSrefActive is not a valid expression.
+ // Fall back to using $interpolate below
+ }
+ uiSrefActive = uiSrefActive || $interpolate($attrs.uiSrefActive || '', false)($scope);
+ setStatesFromDefinitionObject(uiSrefActive);
+ // Allow uiSref to communicate with uiSrefActive[Equals]
+ this.$$addStateInfo = function (newState, newParams) {
+ // we already got an explicit state provided by ui-sref-active, so we
+ // shadow the one that comes from ui-sref
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isObject)(uiSrefActive) && states.length > 0) {
+ return;
+ }
+ var deregister = addState(newState, newParams, uiSrefActive);
+ update();
+ return deregister;
+ };
+ function updateAfterTransition(trans) {
+ trans.promise.then(update, _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.noop);
+ }
+ $scope.$on('$destroy', setupEventListeners());
+ if ($uiRouter.globals.transition) {
+ updateAfterTransition($uiRouter.globals.transition);
+ }
+ function setupEventListeners() {
+ var deregisterStatesChangedListener = $uiRouter.stateRegistry.onStatesChanged(handleStatesChanged);
+ var deregisterOnStartListener = $uiRouter.transitionService.onStart({}, updateAfterTransition);
+ var deregisterStateChangeSuccessListener = $scope.$on('$stateChangeSuccess', update);
+ return function cleanUp() {
+ deregisterStatesChangedListener();
+ deregisterOnStartListener();
+ deregisterStateChangeSuccessListener();
+ };
+ }
+ function handleStatesChanged() {
+ setStatesFromDefinitionObject(uiSrefActive);
+ }
+ function setStatesFromDefinitionObject(statesDefinition) {
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isObject)(statesDefinition)) {
+ states = [];
+ (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.forEach)(statesDefinition, function (stateOrName, activeClass) {
+ // Helper function to abstract adding state.
+ var addStateForClass = function (stateOrName, activeClass) {
+ var ref = parseStateRef(stateOrName);
+ addState(ref.state, $scope.$eval(ref.paramExpr), activeClass);
+ };
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isString)(stateOrName)) {
+ // If state is string, just add it.
+ addStateForClass(stateOrName, activeClass);
+ }
+ else if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isArray)(stateOrName)) {
+ // If state is an array, iterate over it and add each array item individually.
+ (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.forEach)(stateOrName, function (stateOrName) {
+ addStateForClass(stateOrName, activeClass);
+ });
+ }
+ });
+ }
+ }
+ function addState(stateName, stateParams, activeClass) {
+ var state = $state.get(stateName, stateContext($element));
+ var stateInfo = {
+ state: state || { name: stateName },
+ params: stateParams,
+ activeClass: activeClass,
+ };
+ states.push(stateInfo);
+ return function removeState() {
+ (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.removeFrom)(states)(stateInfo);
+ };
+ }
+ // Update route state
+ function update() {
+ var splitClasses = function (str) { return str.split(/\s/).filter(_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.identity); };
+ var getClasses = function (stateList) {
+ return stateList
+ .map(function (x) { return x.activeClass; })
+ .map(splitClasses)
+ .reduce(_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.unnestR, []);
+ };
+ var allClasses = getClasses(states).concat(splitClasses(activeEqClass)).reduce(_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.uniqR, []);
+ var fuzzyClasses = getClasses(states.filter(function (x) { return $state.includes(x.state.name, x.params); }));
+ var exactlyMatchesAny = !!states.filter(function (x) { return $state.is(x.state.name, x.params); }).length;
+ var exactClasses = exactlyMatchesAny ? splitClasses(activeEqClass) : [];
+ var addClasses = fuzzyClasses.concat(exactClasses).reduce(_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.uniqR, []);
+ var removeClasses = allClasses.filter(function (cls) { return !(0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.inArray)(addClasses, cls); });
+ $scope.$evalAsync(function () {
+ addClasses.forEach(function (className) { return $element.addClass(className); });
+ removeClasses.forEach(function (className) { return $element.removeClass(className); });
+ });
+ }
+ update();
+ },
+ ],
+ };
+ },
+];
+_angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router.state')
+ .directive('uiSref', uiSrefDirective)
+ .directive('uiSrefActive', uiSrefActiveDirective)
+ .directive('uiSrefActiveEq', uiSrefActiveDirective)
+ .directive('uiState', uiStateDirective);
+//# sourceMappingURL=stateDirectives.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/directives/viewDirective.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/directives/viewDirective.js ***!
+ \******************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "uiView": () => (/* binding */ uiView)
+/* harmony export */ });
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/* harmony import */ var _angular__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../angular */ "./node_modules/@uirouter/angularjs/lib-esm/angular.js");
+/* harmony import */ var _services__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../services */ "./node_modules/@uirouter/angularjs/lib-esm/services.js");
+/* harmony import */ var _statebuilders_views__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../statebuilders/views */ "./node_modules/@uirouter/angularjs/lib-esm/statebuilders/views.js");
+/** @publicapi @module directives */ /** */
+
+
+
+
+/**
+ * `ui-view`: A viewport directive which is filled in by a view from the active state.
+ *
+ * ### Attributes
+ *
+ * - `name`: (Optional) A view name.
+ * The name should be unique amongst the other views in the same state.
+ * You can have views of the same name that live in different states.
+ * The ui-view can be targeted in a View using the name ([[Ng1StateDeclaration.views]]).
+ *
+ * - `autoscroll`: an expression. When it evaluates to true, the `ui-view` will be scrolled into view when it is activated.
+ * Uses [[$uiViewScroll]] to do the scrolling.
+ *
+ * - `onload`: Expression to evaluate whenever the view updates.
+ *
+ * #### Example:
+ * A view can be unnamed or named.
+ * ```html
+ * <!-- Unnamed -->
+ * <div ui-view></div>
+ *
+ * <!-- Named -->
+ * <div ui-view="viewName"></div>
+ *
+ * <!-- Named (different style) -->
+ * <ui-view name="viewName"></ui-view>
+ * ```
+ *
+ * You can only have one unnamed view within any template (or root html). If you are only using a
+ * single view and it is unnamed then you can populate it like so:
+ *
+ * ```html
+ * <div ui-view></div>
+ * $stateProvider.state("home", {
+ * template: "<h1>HELLO!</h1>"
+ * })
+ * ```
+ *
+ * The above is a convenient shortcut equivalent to specifying your view explicitly with the
+ * [[Ng1StateDeclaration.views]] config property, by name, in this case an empty name:
+ *
+ * ```js
+ * $stateProvider.state("home", {
+ * views: {
+ * "": {
+ * template: "<h1>HELLO!</h1>"
+ * }
+ * }
+ * })
+ * ```
+ *
+ * But typically you'll only use the views property if you name your view or have more than one view
+ * in the same template. There's not really a compelling reason to name a view if its the only one,
+ * but you could if you wanted, like so:
+ *
+ * ```html
+ * <div ui-view="main"></div>
+ * ```
+ *
+ * ```js
+ * $stateProvider.state("home", {
+ * views: {
+ * "main": {
+ * template: "<h1>HELLO!</h1>"
+ * }
+ * }
+ * })
+ * ```
+ *
+ * Really though, you'll use views to set up multiple views:
+ *
+ * ```html
+ * <div ui-view></div>
+ * <div ui-view="chart"></div>
+ * <div ui-view="data"></div>
+ * ```
+ *
+ * ```js
+ * $stateProvider.state("home", {
+ * views: {
+ * "": {
+ * template: "<h1>HELLO!</h1>"
+ * },
+ * "chart": {
+ * template: "<chart_thing/>"
+ * },
+ * "data": {
+ * template: "<data_thing/>"
+ * }
+ * }
+ * })
+ * ```
+ *
+ * #### Examples for `autoscroll`:
+ * ```html
+ * <!-- If autoscroll present with no expression,
+ * then scroll ui-view into view -->
+ * <ui-view autoscroll/>
+ *
+ * <!-- If autoscroll present with valid expression,
+ * then scroll ui-view into view if expression evaluates to true -->
+ * <ui-view autoscroll='true'/>
+ * <ui-view autoscroll='false'/>
+ * <ui-view autoscroll='scopeVariable'/>
+ * ```
+ *
+ * Resolve data:
+ *
+ * The resolved data from the state's `resolve` block is placed on the scope as `$resolve` (this
+ * can be customized using [[Ng1ViewDeclaration.resolveAs]]). This can be then accessed from the template.
+ *
+ * Note that when `controllerAs` is being used, `$resolve` is set on the controller instance *after* the
+ * controller is instantiated. The `$onInit()` hook can be used to perform initialization code which
+ * depends on `$resolve` data.
+ *
+ * #### Example:
+ * ```js
+ * $stateProvider.state('home', {
+ * template: '<my-component user="$resolve.user"></my-component>',
+ * resolve: {
+ * user: function(UserService) { return UserService.fetchUser(); }
+ * }
+ * });
+ * ```
+ */
+var uiView;
+// eslint-disable-next-line prefer-const
+uiView = [
+ '$view',
+ '$animate',
+ '$uiViewScroll',
+ '$interpolate',
+ '$q',
+ function $ViewDirective($view, $animate, $uiViewScroll, $interpolate, $q) {
+ function getRenderer() {
+ return {
+ enter: function (element, target, cb) {
+ if (_angular__WEBPACK_IMPORTED_MODULE_1__.ng.version.minor > 2) {
+ $animate.enter(element, null, target).then(cb);
+ }
+ else {
+ $animate.enter(element, null, target, cb);
+ }
+ },
+ leave: function (element, cb) {
+ if (_angular__WEBPACK_IMPORTED_MODULE_1__.ng.version.minor > 2) {
+ $animate.leave(element).then(cb);
+ }
+ else {
+ $animate.leave(element, cb);
+ }
+ },
+ };
+ }
+ function configsEqual(config1, config2) {
+ return config1 === config2;
+ }
+ var rootData = {
+ $cfg: { viewDecl: { $context: $view._pluginapi._rootViewContext() } },
+ $uiView: {},
+ };
+ var directive = {
+ count: 0,
+ restrict: 'ECA',
+ terminal: true,
+ priority: 400,
+ transclude: 'element',
+ compile: function (tElement, tAttrs, $transclude) {
+ return function (scope, $element, attrs) {
+ var onloadExp = attrs['onload'] || '', autoScrollExp = attrs['autoscroll'], renderer = getRenderer(), inherited = $element.inheritedData('$uiView') || rootData, name = $interpolate(attrs['uiView'] || attrs['name'] || '')(scope) || '$default';
+ var previousEl, currentEl, currentScope, viewConfig;
+ var activeUIView = {
+ $type: 'ng1',
+ id: directive.count++,
+ name: name,
+ fqn: inherited.$uiView.fqn ? inherited.$uiView.fqn + '.' + name : name,
+ config: null,
+ configUpdated: configUpdatedCallback,
+ get creationContext() {
+ // The context in which this ui-view "tag" was created
+ var fromParentTagConfig = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.parse)('$cfg.viewDecl.$context')(inherited);
+ // Allow <ui-view name="foo"><ui-view name="bar"></ui-view></ui-view>
+ // See https://github.com/angular-ui/ui-router/issues/3355
+ var fromParentTag = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.parse)('$uiView.creationContext')(inherited);
+ return fromParentTagConfig || fromParentTag;
+ },
+ };
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.trace.traceUIViewEvent('Linking', activeUIView);
+ function configUpdatedCallback(config) {
+ if (config && !(config instanceof _statebuilders_views__WEBPACK_IMPORTED_MODULE_3__.Ng1ViewConfig))
+ return;
+ if (configsEqual(viewConfig, config))
+ return;
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.trace.traceUIViewConfigUpdated(activeUIView, config && config.viewDecl && config.viewDecl.$context);
+ viewConfig = config;
+ updateView(config);
+ }
+ $element.data('$uiView', { $uiView: activeUIView });
+ updateView();
+ var unregister = $view.registerUIView(activeUIView);
+ scope.$on('$destroy', function () {
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.trace.traceUIViewEvent('Destroying/Unregistering', activeUIView);
+ unregister();
+ });
+ function cleanupLastView() {
+ if (previousEl) {
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.trace.traceUIViewEvent('Removing (previous) el', previousEl.data('$uiView'));
+ previousEl.remove();
+ previousEl = null;
+ }
+ if (currentScope) {
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.trace.traceUIViewEvent('Destroying scope', activeUIView);
+ currentScope.$destroy();
+ currentScope = null;
+ }
+ if (currentEl) {
+ var _viewData_1 = currentEl.data('$uiViewAnim');
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.trace.traceUIViewEvent('Animate out', _viewData_1);
+ renderer.leave(currentEl, function () {
+ _viewData_1.$$animLeave.resolve();
+ previousEl = null;
+ });
+ previousEl = currentEl;
+ currentEl = null;
+ }
+ }
+ function updateView(config) {
+ var newScope = scope.$new();
+ var animEnter = $q.defer(), animLeave = $q.defer();
+ var $uiViewData = {
+ $cfg: config,
+ $uiView: activeUIView,
+ };
+ var $uiViewAnim = {
+ $animEnter: animEnter.promise,
+ $animLeave: animLeave.promise,
+ $$animLeave: animLeave,
+ };
+ /**
+ * @ngdoc event
+ * @name ui.router.state.directive:ui-view#$viewContentLoading
+ * @eventOf ui.router.state.directive:ui-view
+ * @eventType emits on ui-view directive scope
+ * @description
+ *
+ * Fired once the view **begins loading**, *before* the DOM is rendered.
+ *
+ * @param {Object} event Event object.
+ * @param {string} viewName Name of the view.
+ */
+ newScope.$emit('$viewContentLoading', name);
+ var cloned = $transclude(newScope, function (clone) {
+ clone.data('$uiViewAnim', $uiViewAnim);
+ clone.data('$uiView', $uiViewData);
+ renderer.enter(clone, $element, function onUIViewEnter() {
+ animEnter.resolve();
+ if (currentScope)
+ currentScope.$emit('$viewContentAnimationEnded');
+ if (((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isDefined)(autoScrollExp) && !autoScrollExp) || scope.$eval(autoScrollExp)) {
+ $uiViewScroll(clone);
+ }
+ });
+ cleanupLastView();
+ });
+ currentEl = cloned;
+ currentScope = newScope;
+ /**
+ * @ngdoc event
+ * @name ui.router.state.directive:ui-view#$viewContentLoaded
+ * @eventOf ui.router.state.directive:ui-view
+ * @eventType emits on ui-view directive scope
+ * @description *
+ * Fired once the view is **loaded**, *after* the DOM is rendered.
+ *
+ * @param {Object} event Event object.
+ */
+ currentScope.$emit('$viewContentLoaded', config || viewConfig);
+ currentScope.$eval(onloadExp);
+ }
+ };
+ },
+ };
+ return directive;
+ },
+];
+$ViewDirectiveFill.$inject = ['$compile', '$controller', '$transitions', '$view', '$q'];
+/** @hidden */
+function $ViewDirectiveFill($compile, $controller, $transitions, $view, $q) {
+ var getControllerAs = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.parse)('viewDecl.controllerAs');
+ var getResolveAs = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.parse)('viewDecl.resolveAs');
+ return {
+ restrict: 'ECA',
+ priority: -400,
+ compile: function (tElement) {
+ var initial = tElement.html();
+ tElement.empty();
+ return function (scope, $element) {
+ var data = $element.data('$uiView');
+ if (!data) {
+ $element.html(initial);
+ $compile($element.contents())(scope);
+ return;
+ }
+ var cfg = data.$cfg || { viewDecl: {}, getTemplate: _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.noop };
+ var resolveCtx = cfg.path && new _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.ResolveContext(cfg.path);
+ $element.html(cfg.getTemplate($element, resolveCtx) || initial);
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.trace.traceUIViewFill(data.$uiView, $element.html());
+ var link = $compile($element.contents());
+ var controller = cfg.controller;
+ var controllerAs = getControllerAs(cfg);
+ var resolveAs = getResolveAs(cfg);
+ var locals = resolveCtx && (0,_services__WEBPACK_IMPORTED_MODULE_2__.getLocals)(resolveCtx);
+ scope[resolveAs] = locals;
+ if (controller) {
+ var controllerInstance = ($controller(controller, (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.extend)({}, locals, { $scope: scope, $element: $element })));
+ if (controllerAs) {
+ scope[controllerAs] = controllerInstance;
+ scope[controllerAs][resolveAs] = locals;
+ }
+ // TODO: Use $view service as a central point for registering component-level hooks
+ // Then, when a component is created, tell the $view service, so it can invoke hooks
+ // $view.componentLoaded(controllerInstance, { $scope: scope, $element: $element });
+ // scope.$on('$destroy', () => $view.componentUnloaded(controllerInstance, { $scope: scope, $element: $element }));
+ $element.data('$ngControllerController', controllerInstance);
+ $element.children().data('$ngControllerController', controllerInstance);
+ registerControllerCallbacks($q, $transitions, controllerInstance, scope, cfg);
+ }
+ // Wait for the component to appear in the DOM
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isString)(cfg.component)) {
+ var kebobName = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.kebobString)(cfg.component);
+ var tagRegexp_1 = new RegExp("^(x-|data-)?" + kebobName + "$", 'i');
+ var getComponentController = function () {
+ var directiveEl = [].slice
+ .call($element[0].children)
+ .filter(function (el) { return el && el.tagName && tagRegexp_1.exec(el.tagName); });
+ return directiveEl && _angular__WEBPACK_IMPORTED_MODULE_1__.ng.element(directiveEl).data("$" + cfg.component + "Controller");
+ };
+ var deregisterWatch_1 = scope.$watch(getComponentController, function (ctrlInstance) {
+ if (!ctrlInstance)
+ return;
+ registerControllerCallbacks($q, $transitions, ctrlInstance, scope, cfg);
+ deregisterWatch_1();
+ });
+ }
+ link(scope);
+ };
+ },
+ };
+}
+/** @hidden */
+var hasComponentImpl = typeof _angular__WEBPACK_IMPORTED_MODULE_1__.ng.module('ui.router')['component'] === 'function';
+/** @hidden incrementing id */
+var _uiCanExitId = 0;
+/** @hidden TODO: move these callbacks to $view and/or `/hooks/components.ts` or something */
+function registerControllerCallbacks($q, $transitions, controllerInstance, $scope, cfg) {
+ // Call $onInit() ASAP
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isFunction)(controllerInstance.$onInit) &&
+ !((cfg.viewDecl.component || cfg.viewDecl.componentProvider) && hasComponentImpl)) {
+ controllerInstance.$onInit();
+ }
+ var viewState = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.tail)(cfg.path).state.self;
+ var hookOptions = { bind: controllerInstance };
+ // Add component-level hook for onUiParamsChanged
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isFunction)(controllerInstance.uiOnParamsChanged)) {
+ var resolveContext = new _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.ResolveContext(cfg.path);
+ var viewCreationTrans_1 = resolveContext.getResolvable('$transition$').data;
+ // Fire callback on any successful transition
+ var paramsUpdated = function ($transition$) {
+ // Exit early if the $transition$ is the same as the view was created within.
+ // Exit early if the $transition$ will exit the state the view is for.
+ if ($transition$ === viewCreationTrans_1 || $transition$.exiting().indexOf(viewState) !== -1)
+ return;
+ var toParams = $transition$.params('to');
+ var fromParams = $transition$.params('from');
+ var getNodeSchema = function (node) { return node.paramSchema; };
+ var toSchema = $transition$.treeChanges('to').map(getNodeSchema).reduce(_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.unnestR, []);
+ var fromSchema = $transition$.treeChanges('from').map(getNodeSchema).reduce(_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.unnestR, []);
+ // Find the to params that have different values than the from params
+ var changedToParams = toSchema.filter(function (param) {
+ var idx = fromSchema.indexOf(param);
+ return idx === -1 || !fromSchema[idx].type.equals(toParams[param.id], fromParams[param.id]);
+ });
+ // Only trigger callback if a to param has changed or is new
+ if (changedToParams.length) {
+ var changedKeys_1 = changedToParams.map(function (x) { return x.id; });
+ // Filter the params to only changed/new to params. `$transition$.params()` may be used to get all params.
+ var newValues = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.filter)(toParams, function (val, key) { return changedKeys_1.indexOf(key) !== -1; });
+ controllerInstance.uiOnParamsChanged(newValues, $transition$);
+ }
+ };
+ $scope.$on('$destroy', $transitions.onSuccess({}, paramsUpdated, hookOptions));
+ }
+ // Add component-level hook for uiCanExit
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isFunction)(controllerInstance.uiCanExit)) {
+ var id_1 = _uiCanExitId++;
+ var cacheProp_1 = '_uiCanExitIds';
+ // Returns true if a redirect transition already answered truthy
+ var prevTruthyAnswer_1 = function (trans) {
+ return !!trans && ((trans[cacheProp_1] && trans[cacheProp_1][id_1] === true) || prevTruthyAnswer_1(trans.redirectedFrom()));
+ };
+ // If a user answered yes, but the transition was later redirected, don't also ask for the new redirect transition
+ var wrappedHook = function (trans) {
+ var promise;
+ var ids = (trans[cacheProp_1] = trans[cacheProp_1] || {});
+ if (!prevTruthyAnswer_1(trans)) {
+ promise = $q.when(controllerInstance.uiCanExit(trans));
+ promise.then(function (val) { return (ids[id_1] = val !== false); });
+ }
+ return promise;
+ };
+ var criteria = { exiting: viewState.name };
+ $scope.$on('$destroy', $transitions.onBefore(criteria, wrappedHook, hookOptions));
+ }
+}
+_angular__WEBPACK_IMPORTED_MODULE_1__.ng.module('ui.router.state').directive('uiView', uiView);
+_angular__WEBPACK_IMPORTED_MODULE_1__.ng.module('ui.router.state').directive('uiView', $ViewDirectiveFill);
+//# sourceMappingURL=viewDirective.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/index.js":
+/*!***********************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/index.js ***!
+ \***********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "getLocals": () => (/* reexport safe */ _services__WEBPACK_IMPORTED_MODULE_1__.getLocals),
+/* harmony export */ "watchDigests": () => (/* reexport safe */ _services__WEBPACK_IMPORTED_MODULE_1__.watchDigests),
+/* harmony export */ "Ng1ViewConfig": () => (/* reexport safe */ _statebuilders_views__WEBPACK_IMPORTED_MODULE_2__.Ng1ViewConfig),
+/* harmony export */ "getNg1ViewConfigFactory": () => (/* reexport safe */ _statebuilders_views__WEBPACK_IMPORTED_MODULE_2__.getNg1ViewConfigFactory),
+/* harmony export */ "ng1ViewsBuilder": () => (/* reexport safe */ _statebuilders_views__WEBPACK_IMPORTED_MODULE_2__.ng1ViewsBuilder),
+/* harmony export */ "StateProvider": () => (/* reexport safe */ _stateProvider__WEBPACK_IMPORTED_MODULE_3__.StateProvider),
+/* harmony export */ "UrlRouterProvider": () => (/* reexport safe */ _urlRouterProvider__WEBPACK_IMPORTED_MODULE_4__.UrlRouterProvider),
+/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */ "core": () => (/* reexport module object */ _uirouter_core__WEBPACK_IMPORTED_MODULE_10__)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/angularjs/lib-esm/interface.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_interface__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _interface__WEBPACK_IMPORTED_MODULE_0__) if(["default","core"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _interface__WEBPACK_IMPORTED_MODULE_0__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _services__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./services */ "./node_modules/@uirouter/angularjs/lib-esm/services.js");
+/* harmony import */ var _statebuilders_views__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./statebuilders/views */ "./node_modules/@uirouter/angularjs/lib-esm/statebuilders/views.js");
+/* harmony import */ var _stateProvider__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./stateProvider */ "./node_modules/@uirouter/angularjs/lib-esm/stateProvider.js");
+/* harmony import */ var _urlRouterProvider__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./urlRouterProvider */ "./node_modules/@uirouter/angularjs/lib-esm/urlRouterProvider.js");
+/* harmony import */ var _injectables__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./injectables */ "./node_modules/@uirouter/angularjs/lib-esm/injectables.js");
+/* harmony import */ var _injectables__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_injectables__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _directives_stateDirectives__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./directives/stateDirectives */ "./node_modules/@uirouter/angularjs/lib-esm/directives/stateDirectives.js");
+/* harmony import */ var _stateFilters__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./stateFilters */ "./node_modules/@uirouter/angularjs/lib-esm/stateFilters.js");
+/* harmony import */ var _directives_viewDirective__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./directives/viewDirective */ "./node_modules/@uirouter/angularjs/lib-esm/directives/viewDirective.js");
+/* harmony import */ var _viewScroll__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./viewScroll */ "./node_modules/@uirouter/angularjs/lib-esm/viewScroll.js");
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _uirouter_core__WEBPACK_IMPORTED_MODULE_10__) if(["default","core","getLocals","watchDigests","Ng1ViewConfig","getNg1ViewConfigFactory","ng1ViewsBuilder","StateProvider","UrlRouterProvider"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _uirouter_core__WEBPACK_IMPORTED_MODULE_10__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/**
+ * Main entry point for angular 1.x build
+ * @publicapi @module ng1
+ */ /** */
+
+
+
+
+
+
+
+
+
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ('ui.router');
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/injectables.js":
+/*!*****************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/injectables.js ***!
+ \*****************************************************************/
+/***/ (() => {
+
+/**
+ * The current (or pending) State Parameters
+ *
+ * An injectable global **Service Object** which holds the state parameters for the latest **SUCCESSFUL** transition.
+ *
+ * The values are not updated until *after* a `Transition` successfully completes.
+ *
+ * **Also:** an injectable **Per-Transition Object** object which holds the pending state parameters for the pending `Transition` currently running.
+ *
+ * ### Deprecation warning:
+ *
+ * The value injected for `$stateParams` is different depending on where it is injected.
+ *
+ * - When injected into an angular service, the object injected is the global **Service Object** with the parameter values for the latest successful `Transition`.
+ * - When injected into transition hooks, resolves, or view controllers, the object is the **Per-Transition Object** with the parameter values for the running `Transition`.
+ *
+ * Because of these confusing details, this service is deprecated.
+ *
+ * ### Instead of using the global `$stateParams` service object,
+ * inject [[$uiRouterGlobals]] and use [[UIRouterGlobals.params]]
+ *
+ * ```js
+ * MyService.$inject = ['$uiRouterGlobals'];
+ * function MyService($uiRouterGlobals) {
+ * return {
+ * paramValues: function () {
+ * return $uiRouterGlobals.params;
+ * }
+ * }
+ * }
+ * ```
+ *
+ * ### Instead of using the per-transition `$stateParams` object,
+ * inject the current `Transition` (as [[$transition$]]) and use [[Transition.params]]
+ *
+ * ```js
+ * MyController.$inject = ['$transition$'];
+ * function MyController($transition$) {
+ * var username = $transition$.params().username;
+ * // .. do something with username
+ * }
+ * ```
+ *
+ * ---
+ *
+ * This object can be injected into other services.
+ *
+ * #### Deprecated Example:
+ * ```js
+ * SomeService.$inject = ['$http', '$stateParams'];
+ * function SomeService($http, $stateParams) {
+ * return {
+ * getUser: function() {
+ * return $http.get('/api/users/' + $stateParams.username);
+ * }
+ * }
+ * };
+ * angular.service('SomeService', SomeService);
+ * ```
+ * @deprecated
+ */
+var $stateParams;
+/**
+ * Global UI-Router variables
+ *
+ * The router global state as a **Service Object** (injectable during runtime).
+ *
+ * This object contains globals such as the current state and current parameter values.
+ */
+var $uiRouterGlobals;
+/**
+ * The UI-Router instance
+ *
+ * The [[UIRouter]] singleton (the router instance) as a **Service Object** (injectable during runtime).
+ *
+ * This object is the UI-Router singleton instance, created by angular dependency injection during application bootstrap.
+ * It has references to the other UI-Router services
+ *
+ * #### Note: This object is also exposed as [[$uiRouterProvider]] for injection during angular config time.
+ */
+var $uiRouter;
+/**
+ * The UI-Router instance
+ *
+ * The [[UIRouter]] singleton (the router instance) as a **Provider Object** (injectable during config phase).
+ *
+ * This object is the UI-Router singleton instance, created by angular dependency injection during application bootstrap.
+ * It has references to the other UI-Router services
+ *
+ * #### Note: This object is also exposed as [[$uiRouter]] for injection during runtime.
+ */
+var $uiRouterProvider;
+/**
+ * Transition debug/tracing
+ *
+ * The [[Trace]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * Enables or disables Transition tracing which can help to debug issues.
+ */
+var $trace;
+/**
+ * The Transition Service
+ *
+ * The [[TransitionService]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * This angular service exposes the [[TransitionService]] singleton, which is primarily
+ * used to register global transition hooks.
+ *
+ * #### Note: This object is also exposed as [[$transitionsProvider]] for injection during the config phase.
+ */
+var $transitions;
+/**
+ * The Transition Service
+ *
+ * The [[TransitionService]] singleton as a **Provider Object** (injectable during config phase)
+ *
+ * This angular service exposes the [[TransitionService]] singleton, which is primarily
+ * used to register global transition hooks.
+ *
+ * #### Note: This object is also exposed as [[$transitions]] for injection during runtime.
+ */
+var $transitionsProvider;
+/**
+ * The current [[Transition]] object
+ *
+ * The current [[Transition]] object as a **Per-Transition Object** (injectable into Resolve, Hooks, Controllers)
+ *
+ * This object returns information about the current transition, including:
+ *
+ * - To/from states
+ * - To/from parameters
+ * - Transition options
+ * - States being entered, exited, and retained
+ * - Resolve data
+ * - A Promise for the transition
+ * - Any transition failure information
+ * - An injector for both Service and Per-Transition Objects
+ */
+var $transition$;
+/**
+ * The State Service
+ *
+ * The [[StateService]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * This service used to manage and query information on registered states.
+ * It exposes state related APIs including:
+ *
+ * - Start a [[Transition]]
+ * - Imperatively lazy load states
+ * - Check if a state is currently active
+ * - Look up states by name
+ * - Build URLs for a state+parameters
+ * - Configure the global Transition error handler
+ *
+ * This angular service exposes the [[StateService]] singleton.
+ */
+var $state;
+/**
+ * The State Registry
+ *
+ * The [[StateRegistry]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * This service is used to register/deregister states.
+ * It has state registration related APIs including:
+ *
+ * - Register/deregister states
+ * - Listen for state registration/deregistration
+ * - Get states by name
+ * - Add state decorators (to customize the state creation process)
+ *
+ * #### Note: This object is also exposed as [[$stateRegistryProvider]] for injection during the config phase.
+ */
+var $stateRegistry;
+/**
+ * The State Registry
+ *
+ * The [[StateRegistry]] singleton as a **Provider Object** (injectable during config time).
+ *
+ * This service is used to register/deregister states.
+ * It has state registration related APIs including:
+ *
+ * - Register/deregister states
+ * - Listen for state registration/deregistration
+ * - Get states by name
+ * - Add state decorators (to customize the state creation process)
+ *
+ * #### Note: This object is also exposed as [[$stateRegistry]] for injection during runtime.
+ */
+var $stateRegistryProvider;
+/**
+ * The View Scroll provider
+ *
+ * The [[UIViewScrollProvider]] as a **Provider Object** (injectable during config time).
+ *
+ * This angular service exposes the [[UIViewScrollProvider]] singleton and is
+ * used to disable UI-Router's scroll behavior.
+ */
+var $uiViewScrollProvider;
+/**
+ * The View Scroll function
+ *
+ * The View Scroll function as a **Service Object** (injectable during runtime).
+ *
+ * This is a function that scrolls an element into view.
+ * The element is scrolled after a `$timeout` so the DOM has time to refresh.
+ *
+ * If you prefer to rely on `$anchorScroll` to scroll the view to the anchor,
+ * this can be enabled by calling [[UIViewScrollProvider.useAnchorScroll]].
+ *
+ * Note: this function is used by the [[directives.uiView]] when the `autoscroll` expression evaluates to true.
+ */
+var $uiViewScroll;
+/**
+ * The StateProvider
+ *
+ * An angular1-only [[StateProvider]] as a **Provider Object** (injectable during config time).
+ *
+ * This angular service exposes the [[StateProvider]] singleton.
+ *
+ * The `StateProvider` is primarily used to register states or add custom state decorators.
+ *
+ * ##### Note: This provider is a ng1 vestige.
+ * It is a passthrough to [[$stateRegistry]] and [[$state]].
+ */
+var $stateProvider;
+/**
+ * The URL Service Provider
+ *
+ * The [[UrlService]] singleton as a **Provider Object** (injectable during the angular config phase).
+ *
+ * A service used to configure and interact with the URL.
+ * It has URL related APIs including:
+ *
+ * - register custom Parameter types `UrlService.config.type` ([[UrlConfigApi.type]])
+ * - add URL rules: `UrlService.rules.when` ([[UrlRulesApi.when]])
+ * - configure behavior when no url matches: `UrlService.rules.otherwise` ([[UrlRulesApi.otherwise]])
+ * - delay initial URL synchronization [[UrlService.deferIntercept]].
+ * - get or set the current url: [[UrlService.url]]
+ *
+ * ##### Note: This service can also be injected during runtime as [[$urlService]].
+ */
+var $urlServiceProvider;
+/**
+ * The URL Service
+ *
+ * The [[UrlService]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * Note: This service can also be injected during the config phase as [[$urlServiceProvider]].
+ *
+ * Used to configure the URL.
+ * It has URL related APIs including:
+ *
+ * - register custom Parameter types `UrlService.config.type` ([[UrlConfigApi.type]])
+ * - add URL rules: `UrlService.rules.when` ([[UrlRulesApi.when]])
+ * - configure behavior when no url matches: `UrlService.rules.otherwise` ([[UrlRulesApi.otherwise]])
+ * - delay initial URL synchronization [[UrlService.deferIntercept]].
+ * - get or set the current url: [[UrlService.url]]
+ *
+ * ##### Note: This service can also be injected during the config phase as [[$urlServiceProvider]].
+ */
+var $urlService;
+/**
+ * The URL Router Provider
+ *
+ * ### Deprecation warning: This object is now considered internal. Use [[$urlServiceProvider]] instead.
+ *
+ * The [[UrlRouter]] singleton as a **Provider Object** (injectable during config time).
+ *
+ * #### Note: This object is also exposed as [[$urlRouter]] for injection during runtime.
+ *
+ * @deprecated
+ */
+var $urlRouterProvider;
+/**
+ * The Url Router
+ *
+ * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
+ *
+ * The [[UrlRouter]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * #### Note: This object is also exposed as [[$urlRouterProvider]] for injection during angular config time.
+ *
+ * @deprecated
+ */
+var $urlRouter;
+/**
+ * The URL Matcher Factory
+ *
+ * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
+ *
+ * The [[UrlMatcherFactory]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * This service is used to set url mapping options, define custom parameter types, and create [[UrlMatcher]] objects.
+ *
+ * #### Note: This object is also exposed as [[$urlMatcherFactoryProvider]] for injection during angular config time.
+ *
+ * @deprecated
+ */
+var $urlMatcherFactory;
+/**
+ * The URL Matcher Factory
+ *
+ * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
+ *
+ * The [[UrlMatcherFactory]] singleton as a **Provider Object** (injectable during config time).
+ *
+ * This service is used to set url mapping options, define custom parameter types, and create [[UrlMatcher]] objects.
+ *
+ * #### Note: This object is also exposed as [[$urlMatcherFactory]] for injection during runtime.
+ *
+ * @deprecated
+ */
+var $urlMatcherFactoryProvider;
+//# sourceMappingURL=injectables.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/interface.js":
+/*!***************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/interface.js ***!
+ \***************************************************************/
+/***/ (() => {
+
+//# sourceMappingURL=interface.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/locationServices.js":
+/*!**********************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/locationServices.js ***!
+ \**********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "Ng1LocationServices": () => (/* binding */ Ng1LocationServices)
+/* harmony export */ });
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/** @publicapi @module ng1 */ /** */
+
+
+/**
+ * Implements UI-Router LocationServices and LocationConfig using Angular 1's $location service
+ * @internalapi
+ */
+var Ng1LocationServices = /** @class */ (function () {
+ function Ng1LocationServices($locationProvider) {
+ // .onChange() registry
+ this._urlListeners = [];
+ this.$locationProvider = $locationProvider;
+ var _lp = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.val)($locationProvider);
+ (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.createProxyFunctions)(_lp, this, _lp, ['hashPrefix']);
+ }
+ /**
+ * Applys ng1-specific path parameter encoding
+ *
+ * The Angular 1 `$location` service is a bit weird.
+ * It doesn't allow slashes to be encoded/decoded bi-directionally.
+ *
+ * See the writeup at https://github.com/angular-ui/ui-router/issues/2598
+ *
+ * This code patches the `path` parameter type so it encoded/decodes slashes as ~2F
+ *
+ * @param router
+ */
+ Ng1LocationServices.monkeyPatchPathParameterType = function (router) {
+ var pathType = router.urlMatcherFactory.type('path');
+ pathType.encode = function (x) {
+ return x != null ? x.toString().replace(/(~|\/)/g, function (m) { return ({ '~': '~~', '/': '~2F' }[m]); }) : x;
+ };
+ pathType.decode = function (x) {
+ return x != null ? x.toString().replace(/(~~|~2F)/g, function (m) { return ({ '~~': '~', '~2F': '/' }[m]); }) : x;
+ };
+ };
+ // eslint-disable-next-line @typescript-eslint/no-empty-function
+ Ng1LocationServices.prototype.dispose = function () { };
+ Ng1LocationServices.prototype.onChange = function (callback) {
+ var _this = this;
+ this._urlListeners.push(callback);
+ return function () { return (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.removeFrom)(_this._urlListeners)(callback); };
+ };
+ Ng1LocationServices.prototype.html5Mode = function () {
+ var html5Mode = this.$locationProvider.html5Mode();
+ html5Mode = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isObject)(html5Mode) ? html5Mode.enabled : html5Mode;
+ return html5Mode && this.$sniffer.history;
+ };
+ Ng1LocationServices.prototype.baseHref = function () {
+ return this._baseHref || (this._baseHref = this.$browser.baseHref() || this.$window.location.pathname);
+ };
+ Ng1LocationServices.prototype.url = function (newUrl, replace, state) {
+ if (replace === void 0) { replace = false; }
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isDefined)(newUrl))
+ this.$location.url(newUrl);
+ if (replace)
+ this.$location.replace();
+ if (state)
+ this.$location.state(state);
+ return this.$location.url();
+ };
+ Ng1LocationServices.prototype._runtimeServices = function ($rootScope, $location, $sniffer, $browser, $window) {
+ var _this = this;
+ this.$location = $location;
+ this.$sniffer = $sniffer;
+ this.$browser = $browser;
+ this.$window = $window;
+ // Bind $locationChangeSuccess to the listeners registered in LocationService.onChange
+ $rootScope.$on('$locationChangeSuccess', function (evt) { return _this._urlListeners.forEach(function (fn) { return fn(evt); }); });
+ var _loc = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.val)($location);
+ // Bind these LocationService functions to $location
+ (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.createProxyFunctions)(_loc, this, _loc, ['replace', 'path', 'search', 'hash']);
+ // Bind these LocationConfig functions to $location
+ (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.createProxyFunctions)(_loc, this, _loc, ['port', 'protocol', 'host']);
+ };
+ return Ng1LocationServices;
+}());
+
+//# sourceMappingURL=locationServices.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/services.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/services.js ***!
+ \**************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "watchDigests": () => (/* binding */ watchDigests),
+/* harmony export */ "getLocals": () => (/* binding */ getLocals)
+/* harmony export */ });
+/* harmony import */ var _angular__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./angular */ "./node_modules/@uirouter/angularjs/lib-esm/angular.js");
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/* harmony import */ var _statebuilders_views__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./statebuilders/views */ "./node_modules/@uirouter/angularjs/lib-esm/statebuilders/views.js");
+/* harmony import */ var _templateFactory__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./templateFactory */ "./node_modules/@uirouter/angularjs/lib-esm/templateFactory.js");
+/* harmony import */ var _stateProvider__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./stateProvider */ "./node_modules/@uirouter/angularjs/lib-esm/stateProvider.js");
+/* harmony import */ var _statebuilders_onEnterExitRetain__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./statebuilders/onEnterExitRetain */ "./node_modules/@uirouter/angularjs/lib-esm/statebuilders/onEnterExitRetain.js");
+/* harmony import */ var _locationServices__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./locationServices */ "./node_modules/@uirouter/angularjs/lib-esm/locationServices.js");
+/* harmony import */ var _urlRouterProvider__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./urlRouterProvider */ "./node_modules/@uirouter/angularjs/lib-esm/urlRouterProvider.js");
+/* eslint-disable @typescript-eslint/no-empty-function */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * # Angular 1 types
+ *
+ * UI-Router core provides various Typescript types which you can use for code completion and validating parameter values, etc.
+ * The customizations to the core types for Angular UI-Router are documented here.
+ *
+ * The optional [[$resolve]] service is also documented here.
+ *
+ * @preferred @publicapi @module ng1
+ */ /** */
+
+
+
+
+
+
+
+
+_angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router.angular1', []);
+var mod_init = _angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router.init', ['ng']);
+var mod_util = _angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router.util', ['ui.router.init']);
+var mod_rtr = _angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router.router', ['ui.router.util']);
+var mod_state = _angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router.state', ['ui.router.router', 'ui.router.util', 'ui.router.angular1']);
+var mod_main = _angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router', ['ui.router.init', 'ui.router.state', 'ui.router.angular1']);
+var mod_cmpt = _angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router.compat', ['ui.router']);
+var router = null;
+$uiRouterProvider.$inject = ['$locationProvider'];
+/** This angular 1 provider instantiates a Router and exposes its services via the angular injector */
+function $uiRouterProvider($locationProvider) {
+ // Create a new instance of the Router when the $uiRouterProvider is initialized
+ router = this.router = new _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.UIRouter();
+ router.stateProvider = new _stateProvider__WEBPACK_IMPORTED_MODULE_4__.StateProvider(router.stateRegistry, router.stateService);
+ // Apply ng1 specific StateBuilder code for `views`, `resolve`, and `onExit/Retain/Enter` properties
+ router.stateRegistry.decorator('views', _statebuilders_views__WEBPACK_IMPORTED_MODULE_2__.ng1ViewsBuilder);
+ router.stateRegistry.decorator('onExit', (0,_statebuilders_onEnterExitRetain__WEBPACK_IMPORTED_MODULE_5__.getStateHookBuilder)('onExit'));
+ router.stateRegistry.decorator('onRetain', (0,_statebuilders_onEnterExitRetain__WEBPACK_IMPORTED_MODULE_5__.getStateHookBuilder)('onRetain'));
+ router.stateRegistry.decorator('onEnter', (0,_statebuilders_onEnterExitRetain__WEBPACK_IMPORTED_MODULE_5__.getStateHookBuilder)('onEnter'));
+ router.viewService._pluginapi._viewConfigFactory('ng1', (0,_statebuilders_views__WEBPACK_IMPORTED_MODULE_2__.getNg1ViewConfigFactory)());
+ // Disable decoding of params by UrlMatcherFactory because $location already handles this
+ router.urlService.config._decodeParams = false;
+ var ng1LocationService = (router.locationService = router.locationConfig = new _locationServices__WEBPACK_IMPORTED_MODULE_6__.Ng1LocationServices($locationProvider));
+ _locationServices__WEBPACK_IMPORTED_MODULE_6__.Ng1LocationServices.monkeyPatchPathParameterType(router);
+ // backwards compat: also expose router instance as $uiRouterProvider.router
+ router['router'] = router;
+ router['$get'] = $get;
+ $get.$inject = ['$location', '$browser', '$window', '$sniffer', '$rootScope', '$http', '$templateCache'];
+ function $get($location, $browser, $window, $sniffer, $rootScope, $http, $templateCache) {
+ ng1LocationService._runtimeServices($rootScope, $location, $sniffer, $browser, $window);
+ delete router['router'];
+ delete router['$get'];
+ return router;
+ }
+ return router;
+}
+var getProviderFor = function (serviceName) { return [
+ '$uiRouterProvider',
+ function ($urp) {
+ var service = $urp.router[serviceName];
+ service['$get'] = function () { return service; };
+ return service;
+ },
+]; };
+// This effectively calls $get() on `$uiRouterProvider` to trigger init (when ng enters runtime)
+runBlock.$inject = ['$injector', '$q', '$uiRouter'];
+function runBlock($injector, $q, $uiRouter) {
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.services.$injector = $injector;
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.services.$q = $q;
+ // https://github.com/angular-ui/ui-router/issues/3678
+ if (!Object.prototype.hasOwnProperty.call($injector, 'strictDi')) {
+ try {
+ $injector.invoke(function (checkStrictDi) { });
+ }
+ catch (error) {
+ $injector.strictDi = !!/strict mode/.exec(error && error.toString());
+ }
+ }
+ // The $injector is now available.
+ // Find any resolvables that had dependency annotation deferred
+ $uiRouter.stateRegistry
+ .get()
+ .map(function (x) { return x.$$state().resolvables; })
+ .reduce(_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.unnestR, [])
+ .filter(function (x) { return x.deps === 'deferred'; })
+ .forEach(function (resolvable) { return (resolvable.deps = $injector.annotate(resolvable.resolveFn, $injector.strictDi)); });
+}
+// $urlRouter service and $urlRouterProvider
+var getUrlRouterProvider = function (uiRouter) { return (uiRouter.urlRouterProvider = new _urlRouterProvider__WEBPACK_IMPORTED_MODULE_7__.UrlRouterProvider(uiRouter)); };
+// $state service and $stateProvider
+// $urlRouter service and $urlRouterProvider
+var getStateProvider = function () { return (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.extend)(router.stateProvider, { $get: function () { return router.stateService; } }); };
+watchDigests.$inject = ['$rootScope'];
+function watchDigests($rootScope) {
+ $rootScope.$watch(function () {
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.trace.approximateDigests++;
+ });
+}
+mod_init.provider('$uiRouter', $uiRouterProvider);
+mod_rtr.provider('$urlRouter', ['$uiRouterProvider', getUrlRouterProvider]);
+mod_util.provider('$urlService', getProviderFor('urlService'));
+mod_util.provider('$urlMatcherFactory', ['$uiRouterProvider', function () { return router.urlMatcherFactory; }]);
+mod_util.provider('$templateFactory', function () { return new _templateFactory__WEBPACK_IMPORTED_MODULE_3__.TemplateFactory(); });
+mod_state.provider('$stateRegistry', getProviderFor('stateRegistry'));
+mod_state.provider('$uiRouterGlobals', getProviderFor('globals'));
+mod_state.provider('$transitions', getProviderFor('transitionService'));
+mod_state.provider('$state', ['$uiRouterProvider', getStateProvider]);
+mod_state.factory('$stateParams', ['$uiRouter', function ($uiRouter) { return $uiRouter.globals.params; }]);
+mod_main.factory('$view', function () { return router.viewService; });
+mod_main.service('$trace', function () { return _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.trace; });
+mod_main.run(watchDigests);
+mod_util.run(['$urlMatcherFactory', function ($urlMatcherFactory) { }]);
+mod_state.run(['$state', function ($state) { }]);
+mod_rtr.run(['$urlRouter', function ($urlRouter) { }]);
+mod_init.run(runBlock);
+/** @hidden TODO: find a place to move this */
+var getLocals = function (ctx) {
+ var tokens = ctx.getTokens().filter(_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isString);
+ var tuples = tokens.map(function (key) {
+ var resolvable = ctx.getResolvable(key);
+ var waitPolicy = ctx.getPolicy(resolvable).async;
+ return [key, waitPolicy === 'NOWAIT' ? resolvable.promise : resolvable.data];
+ });
+ return tuples.reduce(_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.applyPairs, {});
+};
+//# sourceMappingURL=services.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/stateFilters.js":
+/*!******************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/stateFilters.js ***!
+ \******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "$IsStateFilter": () => (/* binding */ $IsStateFilter),
+/* harmony export */ "$IncludedByStateFilter": () => (/* binding */ $IncludedByStateFilter)
+/* harmony export */ });
+/* harmony import */ var _angular__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./angular */ "./node_modules/@uirouter/angularjs/lib-esm/angular.js");
+/** @publicapi @module ng1 */ /** */
+
+/**
+ * `isState` Filter: truthy if the current state is the parameter
+ *
+ * Translates to [[StateService.is]] `$state.is("stateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'stateName' | isState">show if state is 'stateName'</div>
+ * ```
+ */
+$IsStateFilter.$inject = ['$state'];
+function $IsStateFilter($state) {
+ var isFilter = function (state, params, options) {
+ return $state.is(state, params, options);
+ };
+ isFilter.$stateful = true;
+ return isFilter;
+}
+/**
+ * `includedByState` Filter: truthy if the current state includes the parameter
+ *
+ * Translates to [[StateService.includes]]` $state.is("fullOrPartialStateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'fullOrPartialStateName' | includedByState">show if state includes 'fullOrPartialStateName'</div>
+ * ```
+ */
+$IncludedByStateFilter.$inject = ['$state'];
+function $IncludedByStateFilter($state) {
+ var includesFilter = function (state, params, options) {
+ return $state.includes(state, params, options);
+ };
+ includesFilter.$stateful = true;
+ return includesFilter;
+}
+_angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router.state').filter('isState', $IsStateFilter).filter('includedByState', $IncludedByStateFilter);
+
+//# sourceMappingURL=stateFilters.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/stateProvider.js":
+/*!*******************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/stateProvider.js ***!
+ \*******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "StateProvider": () => (/* binding */ StateProvider)
+/* harmony export */ });
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/** @publicapi @module ng1 */ /** */
+
+/**
+ * The Angular 1 `StateProvider`
+ *
+ * The `$stateProvider` works similar to Angular's v1 router, but it focuses purely
+ * on state.
+ *
+ * A state corresponds to a "place" in the application in terms of the overall UI and
+ * navigation. A state describes (via the controller / template / view properties) what
+ * the UI looks like and does at that place.
+ *
+ * States often have things in common, and the primary way of factoring out these
+ * commonalities in this model is via the state hierarchy, i.e. parent/child states aka
+ * nested states.
+ *
+ * The `$stateProvider` provides interfaces to declare these states for your app.
+ */
+var StateProvider = /** @class */ (function () {
+ function StateProvider(stateRegistry, stateService) {
+ this.stateRegistry = stateRegistry;
+ this.stateService = stateService;
+ (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.createProxyFunctions)((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.val)(StateProvider.prototype), this, (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.val)(this));
+ }
+ /**
+ * Decorates states when they are registered
+ *
+ * Allows you to extend (carefully) or override (at your own peril) the
+ * `stateBuilder` object used internally by [[StateRegistry]].
+ * This can be used to add custom functionality to ui-router,
+ * for example inferring templateUrl based on the state name.
+ *
+ * When passing only a name, it returns the current (original or decorated) builder
+ * function that matches `name`.
+ *
+ * The builder functions that can be decorated are listed below. Though not all
+ * necessarily have a good use case for decoration, that is up to you to decide.
+ *
+ * In addition, users can attach custom decorators, which will generate new
+ * properties within the state's internal definition. There is currently no clear
+ * use-case for this beyond accessing internal states (i.e. $state.$current),
+ * however, expect this to become increasingly relevant as we introduce additional
+ * meta-programming features.
+ *
+ * **Warning**: Decorators should not be interdependent because the order of
+ * execution of the builder functions in non-deterministic. Builder functions
+ * should only be dependent on the state definition object and super function.
+ *
+ *
+ * Existing builder functions and current return values:
+ *
+ * - **parent** `{object}` - returns the parent state object.
+ * - **data** `{object}` - returns state data, including any inherited data that is not
+ * overridden by own values (if any).
+ * - **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher}
+ * or `null`.
+ * - **navigable** `{object}` - returns closest ancestor state that has a URL (aka is
+ * navigable).
+ * - **params** `{object}` - returns an array of state params that are ensured to
+ * be a super-set of parent's params.
+ * - **views** `{object}` - returns a views object where each key is an absolute view
+ * name (i.e. "viewName@stateName") and each value is the config object
+ * (template, controller) for the view. Even when you don't use the views object
+ * explicitly on a state config, one is still created for you internally.
+ * So by decorating this builder function you have access to decorating template
+ * and controller properties.
+ * - **ownParams** `{object}` - returns an array of params that belong to the state,
+ * not including any params defined by ancestor states.
+ * - **path** `{string}` - returns the full path from the root down to this state.
+ * Needed for state activation.
+ * - **includes** `{object}` - returns an object that includes every state that
+ * would pass a `$state.includes()` test.
+ *
+ * #### Example:
+ * Override the internal 'views' builder with a function that takes the state
+ * definition, and a reference to the internal function being overridden:
+ * ```js
+ * $stateProvider.decorator('views', function (state, parent) {
+ * let result = {},
+ * views = parent(state);
+ *
+ * angular.forEach(views, function (config, name) {
+ * let autoName = (state.name + '.' + name).replace('.', '/');
+ * config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
+ * result[name] = config;
+ * });
+ * return result;
+ * });
+ *
+ * $stateProvider.state('home', {
+ * views: {
+ * 'contact.list': { controller: 'ListController' },
+ * 'contact.item': { controller: 'ItemController' }
+ * }
+ * });
+ * ```
+ *
+ *
+ * ```js
+ * // Auto-populates list and item views with /partials/home/contact/list.html,
+ * // and /partials/home/contact/item.html, respectively.
+ * $state.go('home');
+ * ```
+ *
+ * @param {string} name The name of the builder function to decorate.
+ * @param {object} func A function that is responsible for decorating the original
+ * builder function. The function receives two parameters:
+ *
+ * - `{object}` - state - The state config object.
+ * - `{object}` - super - The original builder function.
+ *
+ * @return {object} $stateProvider - $stateProvider instance
+ */
+ StateProvider.prototype.decorator = function (name, func) {
+ return this.stateRegistry.decorator(name, func) || this;
+ };
+ StateProvider.prototype.state = function (name, definition) {
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isObject)(name)) {
+ definition = name;
+ }
+ else {
+ definition.name = name;
+ }
+ this.stateRegistry.register(definition);
+ return this;
+ };
+ /**
+ * Registers an invalid state handler
+ *
+ * This is a passthrough to [[StateService.onInvalid]] for ng1.
+ */
+ StateProvider.prototype.onInvalid = function (callback) {
+ return this.stateService.onInvalid(callback);
+ };
+ return StateProvider;
+}());
+
+//# sourceMappingURL=stateProvider.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/statebuilders/onEnterExitRetain.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/statebuilders/onEnterExitRetain.js ***!
+ \*************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "getStateHookBuilder": () => (/* binding */ getStateHookBuilder)
+/* harmony export */ });
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/* harmony import */ var _services__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../services */ "./node_modules/@uirouter/angularjs/lib-esm/services.js");
+/** @publicapi @module ng1 */ /** */
+
+
+/**
+ * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
+ * `onRetain` callback hooks on a [[Ng1StateDeclaration]].
+ *
+ * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+ * ensures that those hooks are injectable for @uirouter/angularjs (ng1).
+ *
+ * @internalapi
+ */
+var getStateHookBuilder = function (hookName) {
+ return function stateHookBuilder(stateObject) {
+ var hook = stateObject[hookName];
+ var pathname = hookName === 'onExit' ? 'from' : 'to';
+ function decoratedNg1Hook(trans, state) {
+ var resolveContext = new _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.ResolveContext(trans.treeChanges(pathname));
+ var subContext = resolveContext.subContext(state.$$state());
+ var locals = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.extend)((0,_services__WEBPACK_IMPORTED_MODULE_1__.getLocals)(subContext), { $state$: state, $transition$: trans });
+ return _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.services.$injector.invoke(hook, this, locals);
+ }
+ return hook ? decoratedNg1Hook : undefined;
+ };
+};
+//# sourceMappingURL=onEnterExitRetain.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/statebuilders/views.js":
+/*!*************************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/statebuilders/views.js ***!
+ \*************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "getNg1ViewConfigFactory": () => (/* binding */ getNg1ViewConfigFactory),
+/* harmony export */ "ng1ViewsBuilder": () => (/* binding */ ng1ViewsBuilder),
+/* harmony export */ "Ng1ViewConfig": () => (/* binding */ Ng1ViewConfig)
+/* harmony export */ });
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/** @publicapi @module ng1 */ /** */
+
+/** @internalapi */
+function getNg1ViewConfigFactory() {
+ var templateFactory = null;
+ return function (path, view) {
+ templateFactory = templateFactory || _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.services.$injector.get('$templateFactory');
+ return [new Ng1ViewConfig(path, view, templateFactory)];
+ };
+}
+/** @internalapi */
+var hasAnyKey = function (keys, obj) { return keys.reduce(function (acc, key) { return acc || (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isDefined)(obj[key]); }, false); };
+/**
+ * This is a [[StateBuilder.builder]] function for angular1 `views`.
+ *
+ * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+ * handles the `views` property with logic specific to @uirouter/angularjs (ng1).
+ *
+ * If no `views: {}` property exists on the [[StateDeclaration]], then it creates the `views` object
+ * and applies the state-level configuration to a view named `$default`.
+ *
+ * @internalapi
+ */
+function ng1ViewsBuilder(state) {
+ // Do not process root state
+ if (!state.parent)
+ return {};
+ var tplKeys = ['templateProvider', 'templateUrl', 'template', 'notify', 'async'], ctrlKeys = ['controller', 'controllerProvider', 'controllerAs', 'resolveAs'], compKeys = ['component', 'bindings', 'componentProvider'], nonCompKeys = tplKeys.concat(ctrlKeys), allViewKeys = compKeys.concat(nonCompKeys);
+ // Do not allow a state to have both state-level props and also a `views: {}` property.
+ // A state without a `views: {}` property can declare properties for the `$default` view as properties of the state.
+ // However, the `$default` approach should not be mixed with a separate `views: ` block.
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isDefined)(state.views) && hasAnyKey(allViewKeys, state)) {
+ throw new Error("State '" + state.name + "' has a 'views' object. " +
+ "It cannot also have \"view properties\" at the state level. " +
+ "Move the following properties into a view (in the 'views' object): " +
+ (" " + allViewKeys.filter(function (key) { return (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isDefined)(state[key]); }).join(', ')));
+ }
+ var views = {}, viewsObject = state.views || { $default: (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.pick)(state, allViewKeys) };
+ (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.forEach)(viewsObject, function (config, name) {
+ // Account for views: { "": { template... } }
+ name = name || '$default';
+ // Account for views: { header: "headerComponent" }
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isString)(config))
+ config = { component: config };
+ // Make a shallow copy of the config object
+ config = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.extend)({}, config);
+ // Do not allow a view to mix props for component-style view with props for template/controller-style view
+ if (hasAnyKey(compKeys, config) && hasAnyKey(nonCompKeys, config)) {
+ throw new Error("Cannot combine: " + compKeys.join('|') + " with: " + nonCompKeys.join('|') + " in stateview: '" + name + "@" + state.name + "'");
+ }
+ config.resolveAs = config.resolveAs || '$resolve';
+ config.$type = 'ng1';
+ config.$context = state;
+ config.$name = name;
+ var normalized = _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.ViewService.normalizeUIViewTarget(config.$context, config.$name);
+ config.$uiViewName = normalized.uiViewName;
+ config.$uiViewContextAnchor = normalized.uiViewContextAnchor;
+ views[name] = config;
+ });
+ return views;
+}
+/** @hidden */
+var id = 0;
+/** @internalapi */
+var Ng1ViewConfig = /** @class */ (function () {
+ function Ng1ViewConfig(path, viewDecl, factory) {
+ var _this = this;
+ this.path = path;
+ this.viewDecl = viewDecl;
+ this.factory = factory;
+ this.$id = id++;
+ this.loaded = false;
+ this.getTemplate = function (uiView, context) {
+ return _this.component
+ ? _this.factory.makeComponentTemplate(uiView, context, _this.component, _this.viewDecl.bindings)
+ : _this.template;
+ };
+ }
+ Ng1ViewConfig.prototype.load = function () {
+ var _this = this;
+ var $q = _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.services.$q;
+ var context = new _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.ResolveContext(this.path);
+ var params = this.path.reduce(function (acc, node) { return (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.extend)(acc, node.paramValues); }, {});
+ var promises = {
+ template: $q.when(this.factory.fromConfig(this.viewDecl, params, context)),
+ controller: $q.when(this.getController(context)),
+ };
+ return $q.all(promises).then(function (results) {
+ _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.trace.traceViewServiceEvent('Loaded', _this);
+ _this.controller = results.controller;
+ (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.extend)(_this, results.template); // Either { template: "tpl" } or { component: "cmpName" }
+ return _this;
+ });
+ };
+ /**
+ * Gets the controller for a view configuration.
+ *
+ * @returns {Function|Promise.<Function>} Returns a controller, or a promise that resolves to a controller.
+ */
+ Ng1ViewConfig.prototype.getController = function (context) {
+ var provider = this.viewDecl.controllerProvider;
+ if (!(0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isInjectable)(provider))
+ return this.viewDecl.controller;
+ var deps = _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.services.$injector.annotate(provider);
+ var providerFn = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isArray)(provider) ? (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.tail)(provider) : provider;
+ var resolvable = new _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.Resolvable('', providerFn, deps);
+ return resolvable.get(context);
+ };
+ return Ng1ViewConfig;
+}());
+
+//# sourceMappingURL=views.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/templateFactory.js":
+/*!*********************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/templateFactory.js ***!
+ \*********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "TemplateFactory": () => (/* binding */ TemplateFactory)
+/* harmony export */ });
+/* harmony import */ var _angular__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./angular */ "./node_modules/@uirouter/angularjs/lib-esm/angular.js");
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/** @publicapi @module view */ /** */
+
+
+/**
+ * Service which manages loading of templates from a ViewConfig.
+ */
+var TemplateFactory = /** @class */ (function () {
+ function TemplateFactory() {
+ var _this = this;
+ /** @hidden */ this._useHttp = _angular__WEBPACK_IMPORTED_MODULE_0__.ng.version.minor < 3;
+ /** @hidden */ this.$get = [
+ '$http',
+ '$templateCache',
+ '$injector',
+ function ($http, $templateCache, $injector) {
+ _this.$templateRequest = $injector.has && $injector.has('$templateRequest') && $injector.get('$templateRequest');
+ _this.$http = $http;
+ _this.$templateCache = $templateCache;
+ return _this;
+ },
+ ];
+ }
+ /** @hidden */
+ TemplateFactory.prototype.useHttpService = function (value) {
+ this._useHttp = value;
+ };
+ /**
+ * Creates a template from a configuration object.
+ *
+ * @param config Configuration object for which to load a template.
+ * The following properties are search in the specified order, and the first one
+ * that is defined is used to create the template:
+ *
+ * @param params Parameters to pass to the template function.
+ * @param context The resolve context associated with the template's view
+ *
+ * @return {string|object} The template html as a string, or a promise for
+ * that string,or `null` if no template is configured.
+ */
+ TemplateFactory.prototype.fromConfig = function (config, params, context) {
+ var defaultTemplate = '<ui-view></ui-view>';
+ var asTemplate = function (result) { return _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.services.$q.when(result).then(function (str) { return ({ template: str }); }); };
+ var asComponent = function (result) { return _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.services.$q.when(result).then(function (str) { return ({ component: str }); }); };
+ return (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isDefined)(config.template)
+ ? asTemplate(this.fromString(config.template, params))
+ : (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isDefined)(config.templateUrl)
+ ? asTemplate(this.fromUrl(config.templateUrl, params))
+ : (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isDefined)(config.templateProvider)
+ ? asTemplate(this.fromProvider(config.templateProvider, params, context))
+ : (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isDefined)(config.component)
+ ? asComponent(config.component)
+ : (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isDefined)(config.componentProvider)
+ ? asComponent(this.fromComponentProvider(config.componentProvider, params, context))
+ : asTemplate(defaultTemplate);
+ };
+ /**
+ * Creates a template from a string or a function returning a string.
+ *
+ * @param template html template as a string or function that returns an html template as a string.
+ * @param params Parameters to pass to the template function.
+ *
+ * @return {string|object} The template html as a string, or a promise for that
+ * string.
+ */
+ TemplateFactory.prototype.fromString = function (template, params) {
+ return (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isFunction)(template) ? template(params) : template;
+ };
+ /**
+ * Loads a template from the a URL via `$http` and `$templateCache`.
+ *
+ * @param {string|Function} url url of the template to load, or a function
+ * that returns a url.
+ * @param {Object} params Parameters to pass to the url function.
+ * @return {string|Promise.<string>} The template html as a string, or a promise
+ * for that string.
+ */
+ TemplateFactory.prototype.fromUrl = function (url, params) {
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isFunction)(url))
+ url = url(params);
+ if (url == null)
+ return null;
+ if (this._useHttp) {
+ return this.$http
+ .get(url, { cache: this.$templateCache, headers: { Accept: 'text/html' } })
+ .then(function (response) {
+ return response.data;
+ });
+ }
+ return this.$templateRequest(url);
+ };
+ /**
+ * Creates a template by invoking an injectable provider function.
+ *
+ * @param provider Function to invoke via `locals`
+ * @param {Function} injectFn a function used to invoke the template provider
+ * @return {string|Promise.<string>} The template html as a string, or a promise
+ * for that string.
+ */
+ TemplateFactory.prototype.fromProvider = function (provider, params, context) {
+ var deps = _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.services.$injector.annotate(provider);
+ var providerFn = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isArray)(provider) ? (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.tail)(provider) : provider;
+ var resolvable = new _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.Resolvable('', providerFn, deps);
+ return resolvable.get(context);
+ };
+ /**
+ * Creates a component's template by invoking an injectable provider function.
+ *
+ * @param provider Function to invoke via `locals`
+ * @param {Function} injectFn a function used to invoke the template provider
+ * @return {string} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
+ */
+ TemplateFactory.prototype.fromComponentProvider = function (provider, params, context) {
+ var deps = _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.services.$injector.annotate(provider);
+ var providerFn = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isArray)(provider) ? (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.tail)(provider) : provider;
+ var resolvable = new _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.Resolvable('', providerFn, deps);
+ return resolvable.get(context);
+ };
+ /**
+ * Creates a template from a component's name
+ *
+ * This implements route-to-component.
+ * It works by retrieving the component (directive) metadata from the injector.
+ * It analyses the component's bindings, then constructs a template that instantiates the component.
+ * The template wires input and output bindings to resolves or from the parent component.
+ *
+ * @param uiView {object} The parent ui-view (for binding outputs to callbacks)
+ * @param context The ResolveContext (for binding outputs to callbacks returned from resolves)
+ * @param component {string} Component's name in camel case.
+ * @param bindings An object defining the component's bindings: {foo: '<'}
+ * @return {string} The template as a string: "<component-name input1='::$resolve.foo'></component-name>".
+ */
+ TemplateFactory.prototype.makeComponentTemplate = function (uiView, context, component, bindings) {
+ bindings = bindings || {};
+ // Bind once prefix
+ var prefix = _angular__WEBPACK_IMPORTED_MODULE_0__.ng.version.minor >= 3 ? '::' : '';
+ // Convert to kebob name. Add x- prefix if the string starts with `x-` or `data-`
+ var kebob = function (camelCase) {
+ var kebobed = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.kebobString)(camelCase);
+ return /^(x|data)-/.exec(kebobed) ? "x-" + kebobed : kebobed;
+ };
+ var attributeTpl = function (input) {
+ var name = input.name, type = input.type;
+ var attrName = kebob(name);
+ // If the ui-view has an attribute which matches a binding on the routed component
+ // then pass that attribute through to the routed component template.
+ // Prefer ui-view wired mappings to resolve data, unless the resolve was explicitly bound using `bindings:`
+ if (uiView.attr(attrName) && !bindings[name])
+ return attrName + "='" + uiView.attr(attrName) + "'";
+ var resolveName = bindings[name] || name;
+ // Pre-evaluate the expression for "@" bindings by enclosing in {{ }}
+ // some-attr="{{ ::$resolve.someResolveName }}"
+ if (type === '@')
+ return attrName + "='{{" + prefix + "$resolve." + resolveName + "}}'";
+ // Wire "&" callbacks to resolves that return a callback function
+ // Get the result of the resolve (should be a function) and annotate it to get its arguments.
+ // some-attr="$resolve.someResolveResultName(foo, bar)"
+ if (type === '&') {
+ var res = context.getResolvable(resolveName);
+ var fn = res && res.data;
+ var args = (fn && _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.services.$injector.annotate(fn)) || [];
+ // account for array style injection, i.e., ['foo', function(foo) {}]
+ var arrayIdxStr = (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isArray)(fn) ? "[" + (fn.length - 1) + "]" : '';
+ return attrName + "='$resolve." + resolveName + arrayIdxStr + "(" + args.join(',') + ")'";
+ }
+ // some-attr="::$resolve.someResolveName"
+ return attrName + "='" + prefix + "$resolve." + resolveName + "'";
+ };
+ var attrs = getComponentBindings(component).map(attributeTpl).join(' ');
+ var kebobName = kebob(component);
+ return "<" + kebobName + " " + attrs + "></" + kebobName + ">";
+ };
+ return TemplateFactory;
+}());
+
+// Gets all the directive(s)' inputs ('@', '=', and '<') and outputs ('&')
+function getComponentBindings(name) {
+ var cmpDefs = _uirouter_core__WEBPACK_IMPORTED_MODULE_1__.services.$injector.get(name + 'Directive'); // could be multiple
+ if (!cmpDefs || !cmpDefs.length)
+ throw new Error("Unable to find component named '" + name + "'");
+ return cmpDefs.map(getBindings).reduce(_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.unnestR, []);
+}
+// Given a directive definition, find its object input attributes
+// Use different properties, depending on the type of directive (component, bindToController, normal)
+var getBindings = function (def) {
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isObject)(def.bindToController))
+ return scopeBindings(def.bindToController);
+ return scopeBindings(def.scope);
+};
+// for ng 1.2 style, process the scope: { input: "=foo" }
+// for ng 1.3 through ng 1.5, process the component's bindToController: { input: "=foo" } object
+var scopeBindings = function (bindingsObj) {
+ return Object.keys(bindingsObj || {})
+ // [ 'input', [ '=foo', '=', 'foo' ] ]
+ .map(function (key) { return [key, /^([=<@&])[?]?(.*)/.exec(bindingsObj[key])]; })
+ // skip malformed values
+ .filter(function (tuple) { return (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isDefined)(tuple) && (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_1__.isArray)(tuple[1]); })
+ // { name: ('foo' || 'input'), type: '=' }
+ .map(function (tuple) { return ({ name: tuple[1][2] || tuple[0], type: tuple[1][1] }); });
+};
+//# sourceMappingURL=templateFactory.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/urlRouterProvider.js":
+/*!***********************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/urlRouterProvider.js ***!
+ \***********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UrlRouterProvider": () => (/* binding */ UrlRouterProvider)
+/* harmony export */ });
+/* harmony import */ var _uirouter_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @uirouter/core */ "./node_modules/@uirouter/core/lib-esm/index.js");
+/** @publicapi @module url */ /** */
+
+
+/**
+ * Manages rules for client-side URL
+ *
+ * ### Deprecation warning:
+ * This class is now considered to be an internal API
+ * Use the [[UrlService]] instead.
+ * For configuring URL rules, use the [[UrlRulesApi]] which can be found as [[UrlService.rules]].
+ *
+ * This class manages the router rules for what to do when the URL changes.
+ *
+ * This provider remains for backwards compatibility.
+ *
+ * @internalapi
+ * @deprecated
+ */
+var UrlRouterProvider = /** @class */ (function () {
+ /** @hidden */
+ function UrlRouterProvider(/** @hidden */ router) {
+ this.router = router;
+ }
+ UrlRouterProvider.injectableHandler = function (router, handler) {
+ return function (match) { return _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.services.$injector.invoke(handler, null, { $match: match, $stateParams: router.globals.params }); };
+ };
+ /** @hidden */
+ UrlRouterProvider.prototype.$get = function () {
+ var urlService = this.router.urlService;
+ this.router.urlRouter.update(true);
+ if (!urlService.interceptDeferred)
+ urlService.listen();
+ return this.router.urlRouter;
+ };
+ /**
+ * Registers a url handler function.
+ *
+ * Registers a low level url handler (a `rule`).
+ * A rule detects specific URL patterns and returns a redirect, or performs some action.
+ *
+ * If a rule returns a string, the URL is replaced with the string, and all rules are fired again.
+ *
+ * #### Example:
+ * ```js
+ * var app = angular.module('app', ['ui.router.router']);
+ *
+ * app.config(function ($urlRouterProvider) {
+ * // Here's an example of how you might allow case insensitive urls
+ * $urlRouterProvider.rule(function ($injector, $location) {
+ * var path = $location.path(),
+ * normalized = path.toLowerCase();
+ *
+ * if (path !== normalized) {
+ * return normalized;
+ * }
+ * });
+ * });
+ * ```
+ *
+ * @param ruleFn
+ * Handler function that takes `$injector` and `$location` services as arguments.
+ * You can use them to detect a url and return a different url as a string.
+ *
+ * @return [[UrlRouterProvider]] (`this`)
+ */
+ UrlRouterProvider.prototype.rule = function (ruleFn) {
+ var _this = this;
+ if (!(0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isFunction)(ruleFn))
+ throw new Error("'rule' must be a function");
+ var match = function () { return ruleFn(_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.services.$injector, _this.router.locationService); };
+ var rule = new _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.BaseUrlRule(match, _uirouter_core__WEBPACK_IMPORTED_MODULE_0__.identity);
+ this.router.urlService.rules.rule(rule);
+ return this;
+ };
+ /**
+ * Defines the path or behavior to use when no url can be matched.
+ *
+ * #### Example:
+ * ```js
+ * var app = angular.module('app', ['ui.router.router']);
+ *
+ * app.config(function ($urlRouterProvider) {
+ * // if the path doesn't match any of the urls you configured
+ * // otherwise will take care of routing the user to the
+ * // specified url
+ * $urlRouterProvider.otherwise('/index');
+ *
+ * // Example of using function rule as param
+ * $urlRouterProvider.otherwise(function ($injector, $location) {
+ * return '/a/valid/url';
+ * });
+ * });
+ * ```
+ *
+ * @param rule
+ * The url path you want to redirect to or a function rule that returns the url path or performs a `$state.go()`.
+ * The function version is passed two params: `$injector` and `$location` services, and should return a url string.
+ *
+ * @return {object} `$urlRouterProvider` - `$urlRouterProvider` instance
+ */
+ UrlRouterProvider.prototype.otherwise = function (rule) {
+ var _this = this;
+ var urlRules = this.router.urlService.rules;
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isString)(rule)) {
+ urlRules.otherwise(rule);
+ }
+ else if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isFunction)(rule)) {
+ urlRules.otherwise(function () { return rule(_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.services.$injector, _this.router.locationService); });
+ }
+ else {
+ throw new Error("'rule' must be a string or function");
+ }
+ return this;
+ };
+ /**
+ * Registers a handler for a given url matching.
+ *
+ * If the handler is a string, it is
+ * treated as a redirect, and is interpolated according to the syntax of match
+ * (i.e. like `String.replace()` for `RegExp`, or like a `UrlMatcher` pattern otherwise).
+ *
+ * If the handler is a function, it is injectable.
+ * It gets invoked if `$location` matches.
+ * You have the option of inject the match object as `$match`.
+ *
+ * The handler can return
+ *
+ * - **falsy** to indicate that the rule didn't match after all, then `$urlRouter`
+ * will continue trying to find another one that matches.
+ * - **string** which is treated as a redirect and passed to `$location.url()`
+ * - **void** or any **truthy** value tells `$urlRouter` that the url was handled.
+ *
+ * #### Example:
+ * ```js
+ * var app = angular.module('app', ['ui.router.router']);
+ *
+ * app.config(function ($urlRouterProvider) {
+ * $urlRouterProvider.when($state.url, function ($match, $stateParams) {
+ * if ($state.$current.navigable !== state ||
+ * !equalForKeys($match, $stateParams) {
+ * $state.transitionTo(state, $match, false);
+ * }
+ * });
+ * });
+ * ```
+ *
+ * @param what A pattern string to match, compiled as a [[UrlMatcher]].
+ * @param handler The path (or function that returns a path) that you want to redirect your user to.
+ * @param ruleCallback [optional] A callback that receives the `rule` registered with [[UrlMatcher.rule]]
+ *
+ * Note: the handler may also invoke arbitrary code, such as `$state.go()`
+ */
+ UrlRouterProvider.prototype.when = function (what, handler) {
+ if ((0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isArray)(handler) || (0,_uirouter_core__WEBPACK_IMPORTED_MODULE_0__.isFunction)(handler)) {
+ handler = UrlRouterProvider.injectableHandler(this.router, handler);
+ }
+ this.router.urlService.rules.when(what, handler);
+ return this;
+ };
+ /**
+ * Disables monitoring of the URL.
+ *
+ * Call this method before UI-Router has bootstrapped.
+ * It will stop UI-Router from performing the initial url sync.
+ *
+ * This can be useful to perform some asynchronous initialization before the router starts.
+ * Once the initialization is complete, call [[listen]] to tell UI-Router to start watching and synchronizing the URL.
+ *
+ * #### Example:
+ * ```js
+ * var app = angular.module('app', ['ui.router']);
+ *
+ * app.config(function ($urlRouterProvider) {
+ * // Prevent $urlRouter from automatically intercepting URL changes;
+ * $urlRouterProvider.deferIntercept();
+ * })
+ *
+ * app.run(function (MyService, $urlRouter, $http) {
+ * $http.get("/stuff").then(function(resp) {
+ * MyService.doStuff(resp.data);
+ * $urlRouter.listen();
+ * $urlRouter.sync();
+ * });
+ * });
+ * ```
+ *
+ * @param defer Indicates whether to defer location change interception.
+ * Passing no parameter is equivalent to `true`.
+ */
+ UrlRouterProvider.prototype.deferIntercept = function (defer) {
+ this.router.urlService.deferIntercept(defer);
+ };
+ return UrlRouterProvider;
+}());
+
+//# sourceMappingURL=urlRouterProvider.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/angularjs/lib-esm/viewScroll.js":
+/*!****************************************************************!*\
+ !*** ./node_modules/@uirouter/angularjs/lib-esm/viewScroll.js ***!
+ \****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _angular__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./angular */ "./node_modules/@uirouter/angularjs/lib-esm/angular.js");
+/** @publicapi @module ng1 */ /** */
+
+/** @hidden */
+function $ViewScrollProvider() {
+ var useAnchorScroll = false;
+ this.useAnchorScroll = function () {
+ useAnchorScroll = true;
+ };
+ this.$get = [
+ '$anchorScroll',
+ '$timeout',
+ function ($anchorScroll, $timeout) {
+ if (useAnchorScroll) {
+ return $anchorScroll;
+ }
+ return function ($element) {
+ return $timeout(function () {
+ $element[0].scrollIntoView();
+ }, 0, false);
+ };
+ },
+ ];
+}
+_angular__WEBPACK_IMPORTED_MODULE_0__.ng.module('ui.router.state').provider('$uiViewScroll', $ViewScrollProvider);
+//# sourceMappingURL=viewScroll.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/common.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/common.js ***!
+ \**************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "root": () => (/* binding */ root),
+/* harmony export */ "fromJson": () => (/* binding */ fromJson),
+/* harmony export */ "toJson": () => (/* binding */ toJson),
+/* harmony export */ "forEach": () => (/* binding */ forEach),
+/* harmony export */ "extend": () => (/* binding */ extend),
+/* harmony export */ "equals": () => (/* binding */ equals),
+/* harmony export */ "identity": () => (/* binding */ identity),
+/* harmony export */ "noop": () => (/* binding */ noop),
+/* harmony export */ "createProxyFunctions": () => (/* binding */ createProxyFunctions),
+/* harmony export */ "inherit": () => (/* binding */ inherit),
+/* harmony export */ "inArray": () => (/* binding */ inArray),
+/* harmony export */ "_inArray": () => (/* binding */ _inArray),
+/* harmony export */ "removeFrom": () => (/* binding */ removeFrom),
+/* harmony export */ "_removeFrom": () => (/* binding */ _removeFrom),
+/* harmony export */ "pushTo": () => (/* binding */ pushTo),
+/* harmony export */ "_pushTo": () => (/* binding */ _pushTo),
+/* harmony export */ "deregAll": () => (/* binding */ deregAll),
+/* harmony export */ "defaults": () => (/* binding */ defaults),
+/* harmony export */ "mergeR": () => (/* binding */ mergeR),
+/* harmony export */ "ancestors": () => (/* binding */ ancestors),
+/* harmony export */ "pick": () => (/* binding */ pick),
+/* harmony export */ "omit": () => (/* binding */ omit),
+/* harmony export */ "pluck": () => (/* binding */ pluck),
+/* harmony export */ "filter": () => (/* binding */ filter),
+/* harmony export */ "find": () => (/* binding */ find),
+/* harmony export */ "mapObj": () => (/* binding */ mapObj),
+/* harmony export */ "map": () => (/* binding */ map),
+/* harmony export */ "values": () => (/* binding */ values),
+/* harmony export */ "allTrueR": () => (/* binding */ allTrueR),
+/* harmony export */ "anyTrueR": () => (/* binding */ anyTrueR),
+/* harmony export */ "unnestR": () => (/* binding */ unnestR),
+/* harmony export */ "flattenR": () => (/* binding */ flattenR),
+/* harmony export */ "pushR": () => (/* binding */ pushR),
+/* harmony export */ "uniqR": () => (/* binding */ uniqR),
+/* harmony export */ "unnest": () => (/* binding */ unnest),
+/* harmony export */ "flatten": () => (/* binding */ flatten),
+/* harmony export */ "assertPredicate": () => (/* binding */ assertPredicate),
+/* harmony export */ "assertMap": () => (/* binding */ assertMap),
+/* harmony export */ "assertFn": () => (/* binding */ assertFn),
+/* harmony export */ "pairs": () => (/* binding */ pairs),
+/* harmony export */ "arrayTuples": () => (/* binding */ arrayTuples),
+/* harmony export */ "applyPairs": () => (/* binding */ applyPairs),
+/* harmony export */ "tail": () => (/* binding */ tail),
+/* harmony export */ "copy": () => (/* binding */ copy),
+/* harmony export */ "_extend": () => (/* binding */ _extend),
+/* harmony export */ "silenceUncaughtInPromise": () => (/* binding */ silenceUncaughtInPromise),
+/* harmony export */ "silentRejection": () => (/* binding */ silentRejection)
+/* harmony export */ });
+/* harmony import */ var _predicates__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _hof__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _coreservices__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+var __spreadArrays = (undefined && undefined.__spreadArrays) || function () {
+ for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+ for (var r = Array(s), k = 0, i = 0; i < il; i++)
+ for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+ r[k] = a[j];
+ return r;
+};
+/**
+ * Random utility functions used in the UI-Router code
+ *
+ * These functions are exported, but are subject to change without notice.
+ *
+ * @packageDocumentation
+ * @preferred
+ */
+
+
+
+var root = (typeof self === 'object' && self.self === self && self) ||
+ (typeof __webpack_require__.g === 'object' && __webpack_require__.g.global === __webpack_require__.g && __webpack_require__.g) ||
+ undefined;
+var angular = root.angular || {};
+var fromJson = angular.fromJson || JSON.parse.bind(JSON);
+var toJson = angular.toJson || JSON.stringify.bind(JSON);
+var forEach = angular.forEach || _forEach;
+var extend = Object.assign || _extend;
+var equals = angular.equals || _equals;
+function identity(x) {
+ return x;
+}
+function noop() { }
+/**
+ * Builds proxy functions on the `to` object which pass through to the `from` object.
+ *
+ * For each key in `fnNames`, creates a proxy function on the `to` object.
+ * The proxy function calls the real function on the `from` object.
+ *
+ *
+ * #### Example:
+ * This example creates an new class instance whose functions are prebound to the new'd object.
+ * ```js
+ * class Foo {
+ * constructor(data) {
+ * // Binds all functions from Foo.prototype to 'this',
+ * // then copies them to 'this'
+ * bindFunctions(Foo.prototype, this, this);
+ * this.data = data;
+ * }
+ *
+ * log() {
+ * console.log(this.data);
+ * }
+ * }
+ *
+ * let myFoo = new Foo([1,2,3]);
+ * var logit = myFoo.log;
+ * logit(); // logs [1, 2, 3] from the myFoo 'this' instance
+ * ```
+ *
+ * #### Example:
+ * This example creates a bound version of a service function, and copies it to another object
+ * ```
+ *
+ * var SomeService = {
+ * this.data = [3, 4, 5];
+ * this.log = function() {
+ * console.log(this.data);
+ * }
+ * }
+ *
+ * // Constructor fn
+ * function OtherThing() {
+ * // Binds all functions from SomeService to SomeService,
+ * // then copies them to 'this'
+ * bindFunctions(SomeService, this, SomeService);
+ * }
+ *
+ * let myOtherThing = new OtherThing();
+ * myOtherThing.log(); // logs [3, 4, 5] from SomeService's 'this'
+ * ```
+ *
+ * @param source A function that returns the source object which contains the original functions to be bound
+ * @param target A function that returns the target object which will receive the bound functions
+ * @param bind A function that returns the object which the functions will be bound to
+ * @param fnNames The function names which will be bound (Defaults to all the functions found on the 'from' object)
+ * @param latebind If true, the binding of the function is delayed until the first time it's invoked
+ */
+function createProxyFunctions(source, target, bind, fnNames, latebind) {
+ if (latebind === void 0) { latebind = false; }
+ var bindFunction = function (fnName) { return source()[fnName].bind(bind()); };
+ var makeLateRebindFn = function (fnName) {
+ return function lateRebindFunction() {
+ target[fnName] = bindFunction(fnName);
+ return target[fnName].apply(null, arguments);
+ };
+ };
+ fnNames = fnNames || Object.keys(source());
+ return fnNames.reduce(function (acc, name) {
+ acc[name] = latebind ? makeLateRebindFn(name) : bindFunction(name);
+ return acc;
+ }, target);
+}
+/**
+ * prototypal inheritance helper.
+ * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it
+ */
+var inherit = function (parent, extra) { return extend(Object.create(parent), extra); };
+/** Given an array, returns true if the object is found in the array, (using indexOf) */
+var inArray = (0,_hof__WEBPACK_IMPORTED_MODULE_1__.curry)(_inArray);
+function _inArray(array, obj) {
+ return array.indexOf(obj) !== -1;
+}
+/**
+ * Given an array, and an item, if the item is found in the array, it removes it (in-place).
+ * The same array is returned
+ */
+var removeFrom = (0,_hof__WEBPACK_IMPORTED_MODULE_1__.curry)(_removeFrom);
+function _removeFrom(array, obj) {
+ var idx = array.indexOf(obj);
+ if (idx >= 0)
+ array.splice(idx, 1);
+ return array;
+}
+/** pushes a values to an array and returns the value */
+var pushTo = (0,_hof__WEBPACK_IMPORTED_MODULE_1__.curry)(_pushTo);
+function _pushTo(arr, val) {
+ return arr.push(val), val;
+}
+/** Given an array of (deregistration) functions, calls all functions and removes each one from the source array */
+var deregAll = function (functions) {
+ return functions.slice().forEach(function (fn) {
+ typeof fn === 'function' && fn();
+ removeFrom(functions, fn);
+ });
+};
+/**
+ * Applies a set of defaults to an options object. The options object is filtered
+ * to only those properties of the objects in the defaultsList.
+ * Earlier objects in the defaultsList take precedence when applying defaults.
+ */
+function defaults(opts) {
+ var defaultsList = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ defaultsList[_i - 1] = arguments[_i];
+ }
+ var defaultVals = extend.apply(void 0, __spreadArrays([{}], defaultsList.reverse()));
+ return extend(defaultVals, pick(opts || {}, Object.keys(defaultVals)));
+}
+/** Reduce function that merges each element of the list into a single object, using extend */
+var mergeR = function (memo, item) { return extend(memo, item); };
+/**
+ * Finds the common ancestor path between two states.
+ *
+ * @param {Object} first The first state.
+ * @param {Object} second The second state.
+ * @return {Array} Returns an array of state names in descending order, not including the root.
+ */
+function ancestors(first, second) {
+ var path = [];
+ // tslint:disable-next-line:forin
+ for (var n in first.path) {
+ if (first.path[n] !== second.path[n])
+ break;
+ path.push(first.path[n]);
+ }
+ return path;
+}
+/**
+ * Return a copy of the object only containing the whitelisted properties.
+ *
+ * #### Example:
+ * ```
+ * var foo = { a: 1, b: 2, c: 3 };
+ * var ab = pick(foo, ['a', 'b']); // { a: 1, b: 2 }
+ * ```
+ * @param obj the source object
+ * @param propNames an Array of strings, which are the whitelisted property names
+ */
+function pick(obj, propNames) {
+ var objCopy = {};
+ for (var _prop in obj) {
+ if (propNames.indexOf(_prop) !== -1) {
+ objCopy[_prop] = obj[_prop];
+ }
+ }
+ return objCopy;
+}
+/**
+ * Return a copy of the object omitting the blacklisted properties.
+ *
+ * @example
+ * ```
+ *
+ * var foo = { a: 1, b: 2, c: 3 };
+ * var ab = omit(foo, ['a', 'b']); // { c: 3 }
+ * ```
+ * @param obj the source object
+ * @param propNames an Array of strings, which are the blacklisted property names
+ */
+function omit(obj, propNames) {
+ return Object.keys(obj)
+ .filter((0,_hof__WEBPACK_IMPORTED_MODULE_1__.not)(inArray(propNames)))
+ .reduce(function (acc, key) { return ((acc[key] = obj[key]), acc); }, {});
+}
+/**
+ * Maps an array, or object to a property (by name)
+ */
+function pluck(collection, propName) {
+ return map(collection, (0,_hof__WEBPACK_IMPORTED_MODULE_1__.prop)(propName));
+}
+/** Filters an Array or an Object's properties based on a predicate */
+function filter(collection, callback) {
+ var arr = (0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isArray)(collection), result = arr ? [] : {};
+ var accept = arr ? function (x) { return result.push(x); } : function (x, key) { return (result[key] = x); };
+ forEach(collection, function (item, i) {
+ if (callback(item, i))
+ accept(item, i);
+ });
+ return result;
+}
+/** Finds an object from an array, or a property of an object, that matches a predicate */
+function find(collection, callback) {
+ var result;
+ forEach(collection, function (item, i) {
+ if (result)
+ return;
+ if (callback(item, i))
+ result = item;
+ });
+ return result;
+}
+/** Given an object, returns a new object, where each property is transformed by the callback function */
+var mapObj = map;
+/** Maps an array or object properties using a callback function */
+function map(collection, callback, target) {
+ target = target || ((0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isArray)(collection) ? [] : {});
+ forEach(collection, function (item, i) { return (target[i] = callback(item, i)); });
+ return target;
+}
+/**
+ * Given an object, return its enumerable property values
+ *
+ * @example
+ * ```
+ *
+ * let foo = { a: 1, b: 2, c: 3 }
+ * let vals = values(foo); // [ 1, 2, 3 ]
+ * ```
+ */
+var values = function (obj) { return Object.keys(obj).map(function (key) { return obj[key]; }); };
+/**
+ * Reduce function that returns true if all of the values are truthy.
+ *
+ * @example
+ * ```
+ *
+ * let vals = [ 1, true, {}, "hello world"];
+ * vals.reduce(allTrueR, true); // true
+ *
+ * vals.push(0);
+ * vals.reduce(allTrueR, true); // false
+ * ```
+ */
+var allTrueR = function (memo, elem) { return memo && elem; };
+/**
+ * Reduce function that returns true if any of the values are truthy.
+ *
+ * * @example
+ * ```
+ *
+ * let vals = [ 0, null, undefined ];
+ * vals.reduce(anyTrueR, true); // false
+ *
+ * vals.push("hello world");
+ * vals.reduce(anyTrueR, true); // true
+ * ```
+ */
+var anyTrueR = function (memo, elem) { return memo || elem; };
+/**
+ * Reduce function which un-nests a single level of arrays
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * input.reduce(unnestR, []) // [ "a", "b", "c", "d", [ "double, "nested" ] ]
+ * ```
+ */
+var unnestR = function (memo, elem) { return memo.concat(elem); };
+/**
+ * Reduce function which recursively un-nests all arrays
+ *
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * input.reduce(unnestR, []) // [ "a", "b", "c", "d", "double, "nested" ]
+ * ```
+ */
+var flattenR = function (memo, elem) {
+ return (0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isArray)(elem) ? memo.concat(elem.reduce(flattenR, [])) : pushR(memo, elem);
+};
+/**
+ * Reduce function that pushes an object to an array, then returns the array.
+ * Mostly just for [[flattenR]] and [[uniqR]]
+ */
+function pushR(arr, obj) {
+ arr.push(obj);
+ return arr;
+}
+/** Reduce function that filters out duplicates */
+var uniqR = function (acc, token) { return (inArray(acc, token) ? acc : pushR(acc, token)); };
+/**
+ * Return a new array with a single level of arrays unnested.
+ *
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * unnest(input) // [ "a", "b", "c", "d", [ "double, "nested" ] ]
+ * ```
+ */
+var unnest = function (arr) { return arr.reduce(unnestR, []); };
+/**
+ * Return a completely flattened version of an array.
+ *
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * flatten(input) // [ "a", "b", "c", "d", "double, "nested" ]
+ * ```
+ */
+var flatten = function (arr) { return arr.reduce(flattenR, []); };
+/**
+ * Given a .filter Predicate, builds a .filter Predicate which throws an error if any elements do not pass.
+ * @example
+ * ```
+ *
+ * let isNumber = (obj) => typeof(obj) === 'number';
+ * let allNumbers = [ 1, 2, 3, 4, 5 ];
+ * allNumbers.filter(assertPredicate(isNumber)); //OK
+ *
+ * let oneString = [ 1, 2, 3, 4, "5" ];
+ * oneString.filter(assertPredicate(isNumber, "Not all numbers")); // throws Error(""Not all numbers"");
+ * ```
+ */
+var assertPredicate = assertFn;
+/**
+ * Given a .map function, builds a .map function which throws an error if any mapped elements do not pass a truthyness test.
+ * @example
+ * ```
+ *
+ * var data = { foo: 1, bar: 2 };
+ *
+ * let keys = [ 'foo', 'bar' ]
+ * let values = keys.map(assertMap(key => data[key], "Key not found"));
+ * // values is [1, 2]
+ *
+ * let keys = [ 'foo', 'bar', 'baz' ]
+ * let values = keys.map(assertMap(key => data[key], "Key not found"));
+ * // throws Error("Key not found")
+ * ```
+ */
+var assertMap = assertFn;
+function assertFn(predicateOrMap, errMsg) {
+ if (errMsg === void 0) { errMsg = 'assert failure'; }
+ return function (obj) {
+ var result = predicateOrMap(obj);
+ if (!result) {
+ throw new Error((0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isFunction)(errMsg) ? errMsg(obj) : errMsg);
+ }
+ return result;
+ };
+}
+/**
+ * Like _.pairs: Given an object, returns an array of key/value pairs
+ *
+ * @example
+ * ```
+ *
+ * pairs({ foo: "FOO", bar: "BAR }) // [ [ "foo", "FOO" ], [ "bar": "BAR" ] ]
+ * ```
+ */
+var pairs = function (obj) { return Object.keys(obj).map(function (key) { return [key, obj[key]]; }); };
+/**
+ * Given two or more parallel arrays, returns an array of tuples where
+ * each tuple is composed of [ a[i], b[i], ... z[i] ]
+ *
+ * @example
+ * ```
+ *
+ * let foo = [ 0, 2, 4, 6 ];
+ * let bar = [ 1, 3, 5, 7 ];
+ * let baz = [ 10, 30, 50, 70 ];
+ * arrayTuples(foo, bar); // [ [0, 1], [2, 3], [4, 5], [6, 7] ]
+ * arrayTuples(foo, bar, baz); // [ [0, 1, 10], [2, 3, 30], [4, 5, 50], [6, 7, 70] ]
+ * ```
+ */
+function arrayTuples() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ if (args.length === 0)
+ return [];
+ var maxArrayLen = args.reduce(function (min, arr) { return Math.min(arr.length, min); }, 9007199254740991); // aka 2^53 − 1 aka Number.MAX_SAFE_INTEGER
+ var result = [];
+ var _loop_1 = function (i) {
+ // This is a hot function
+ // Unroll when there are 1-4 arguments
+ switch (args.length) {
+ case 1:
+ result.push([args[0][i]]);
+ break;
+ case 2:
+ result.push([args[0][i], args[1][i]]);
+ break;
+ case 3:
+ result.push([args[0][i], args[1][i], args[2][i]]);
+ break;
+ case 4:
+ result.push([args[0][i], args[1][i], args[2][i], args[3][i]]);
+ break;
+ default:
+ result.push(args.map(function (array) { return array[i]; }));
+ break;
+ }
+ };
+ for (var i = 0; i < maxArrayLen; i++) {
+ _loop_1(i);
+ }
+ return result;
+}
+/**
+ * Reduce function which builds an object from an array of [key, value] pairs.
+ *
+ * Each iteration sets the key/val pair on the memo object, then returns the memo for the next iteration.
+ *
+ * Each keyValueTuple should be an array with values [ key: string, value: any ]
+ *
+ * @example
+ * ```
+ *
+ * var pairs = [ ["fookey", "fooval"], ["barkey", "barval"] ]
+ *
+ * var pairsToObj = pairs.reduce((memo, pair) => applyPairs(memo, pair), {})
+ * // pairsToObj == { fookey: "fooval", barkey: "barval" }
+ *
+ * // Or, more simply:
+ * var pairsToObj = pairs.reduce(applyPairs, {})
+ * // pairsToObj == { fookey: "fooval", barkey: "barval" }
+ * ```
+ */
+function applyPairs(memo, keyValTuple) {
+ var key, value;
+ if ((0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isArray)(keyValTuple))
+ key = keyValTuple[0], value = keyValTuple[1];
+ if (!(0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isString)(key))
+ throw new Error('invalid parameters to applyPairs');
+ memo[key] = value;
+ return memo;
+}
+/** Get the last element of an array */
+function tail(arr) {
+ return (arr.length && arr[arr.length - 1]) || undefined;
+}
+/**
+ * shallow copy from src to dest
+ */
+function copy(src, dest) {
+ if (dest)
+ Object.keys(dest).forEach(function (key) { return delete dest[key]; });
+ if (!dest)
+ dest = {};
+ return extend(dest, src);
+}
+/** Naive forEach implementation works with Objects or Arrays */
+function _forEach(obj, cb, _this) {
+ if ((0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isArray)(obj))
+ return obj.forEach(cb, _this);
+ Object.keys(obj).forEach(function (key) { return cb(obj[key], key); });
+}
+function _extend(toObj) {
+ for (var i = 1; i < arguments.length; i++) {
+ var obj = arguments[i];
+ if (!obj)
+ continue;
+ var keys = Object.keys(obj);
+ for (var j = 0; j < keys.length; j++) {
+ toObj[keys[j]] = obj[keys[j]];
+ }
+ }
+ return toObj;
+}
+function _equals(o1, o2) {
+ if (o1 === o2)
+ return true;
+ if (o1 === null || o2 === null)
+ return false;
+ if (o1 !== o1 && o2 !== o2)
+ return true; // NaN === NaN
+ var t1 = typeof o1, t2 = typeof o2;
+ if (t1 !== t2 || t1 !== 'object')
+ return false;
+ var tup = [o1, o2];
+ if ((0,_hof__WEBPACK_IMPORTED_MODULE_1__.all)(_predicates__WEBPACK_IMPORTED_MODULE_0__.isArray)(tup))
+ return _arraysEq(o1, o2);
+ if ((0,_hof__WEBPACK_IMPORTED_MODULE_1__.all)(_predicates__WEBPACK_IMPORTED_MODULE_0__.isDate)(tup))
+ return o1.getTime() === o2.getTime();
+ if ((0,_hof__WEBPACK_IMPORTED_MODULE_1__.all)(_predicates__WEBPACK_IMPORTED_MODULE_0__.isRegExp)(tup))
+ return o1.toString() === o2.toString();
+ if ((0,_hof__WEBPACK_IMPORTED_MODULE_1__.all)(_predicates__WEBPACK_IMPORTED_MODULE_0__.isFunction)(tup))
+ return true; // meh
+ var predicates = [_predicates__WEBPACK_IMPORTED_MODULE_0__.isFunction, _predicates__WEBPACK_IMPORTED_MODULE_0__.isArray, _predicates__WEBPACK_IMPORTED_MODULE_0__.isDate, _predicates__WEBPACK_IMPORTED_MODULE_0__.isRegExp];
+ if (predicates.map(_hof__WEBPACK_IMPORTED_MODULE_1__.any).reduce(function (b, fn) { return b || !!fn(tup); }, false))
+ return false;
+ var keys = {};
+ // tslint:disable-next-line:forin
+ for (var key in o1) {
+ if (!_equals(o1[key], o2[key]))
+ return false;
+ keys[key] = true;
+ }
+ for (var key in o2) {
+ if (!keys[key])
+ return false;
+ }
+ return true;
+}
+function _arraysEq(a1, a2) {
+ if (a1.length !== a2.length)
+ return false;
+ return arrayTuples(a1, a2).reduce(function (b, t) { return b && _equals(t[0], t[1]); }, true);
+}
+// issue #2676
+var silenceUncaughtInPromise = function (promise) { return promise.catch(function (e) { return 0; }) && promise; };
+var silentRejection = function (error) { return silenceUncaughtInPromise(_coreservices__WEBPACK_IMPORTED_MODULE_2__.services.$q.reject(error)); };
+//# sourceMappingURL=common.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js":
+/*!********************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/coreservices.js ***!
+ \********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "makeStub": () => (/* binding */ makeStub),
+/* harmony export */ "services": () => (/* binding */ services)
+/* harmony export */ });
+var noImpl = function (fnname) { return function () {
+ throw new Error("No implementation for " + fnname + ". The framework specific code did not implement this method.");
+}; };
+var makeStub = function (service, methods) {
+ return methods.reduce(function (acc, key) { return ((acc[key] = noImpl(service + "." + key + "()")), acc); }, {});
+};
+var services = {
+ $q: undefined,
+ $injector: undefined,
+};
+
+//# sourceMappingURL=coreservices.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/glob.js":
+/*!************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/glob.js ***!
+ \************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "Glob": () => (/* binding */ Glob)
+/* harmony export */ });
+/**
+ * Matches state names using glob-like pattern strings.
+ *
+ * Globs can be used in specific APIs including:
+ *
+ * - [[StateService.is]]
+ * - [[StateService.includes]]
+ * - The first argument to Hook Registration functions like [[TransitionService.onStart]]
+ * - [[HookMatchCriteria]] and [[HookMatchCriterion]]
+ *
+ * A `Glob` string is a pattern which matches state names.
+ * Nested state names are split into segments (separated by a dot) when processing.
+ * The state named `foo.bar.baz` is split into three segments ['foo', 'bar', 'baz']
+ *
+ * Globs work according to the following rules:
+ *
+ * ### Exact match:
+ *
+ * The glob `'A.B'` matches the state named exactly `'A.B'`.
+ *
+ * | Glob |Matches states named|Does not match state named|
+ * |:------------|:--------------------|:---------------------|
+ * | `'A'` | `'A'` | `'B'` , `'A.C'` |
+ * | `'A.B'` | `'A.B'` | `'A'` , `'A.B.C'` |
+ * | `'foo'` | `'foo'` | `'FOO'` , `'foo.bar'`|
+ *
+ * ### Single star (`*`)
+ *
+ * A single star (`*`) is a wildcard that matches exactly one segment.
+ *
+ * | Glob |Matches states named |Does not match state named |
+ * |:------------|:---------------------|:--------------------------|
+ * | `'*'` | `'A'` , `'Z'` | `'A.B'` , `'Z.Y.X'` |
+ * | `'A.*'` | `'A.B'` , `'A.C'` | `'A'` , `'A.B.C'` |
+ * | `'A.*.*'` | `'A.B.C'` , `'A.X.Y'`| `'A'`, `'A.B'` , `'Z.Y.X'`|
+ *
+ * ### Double star (`**`)
+ *
+ * A double star (`'**'`) is a wildcard that matches *zero or more segments*
+ *
+ * | Glob |Matches states named |Does not match state named |
+ * |:------------|:----------------------------------------------|:----------------------------------|
+ * | `'**'` | `'A'` , `'A.B'`, `'Z.Y.X'` | (matches all states) |
+ * | `'A.**'` | `'A'` , `'A.B'` , `'A.C.X'` | `'Z.Y.X'` |
+ * | `'**.X'` | `'X'` , `'A.X'` , `'Z.Y.X'` | `'A'` , `'A.login.Z'` |
+ * | `'A.**.X'` | `'A.X'` , `'A.B.X'` , `'A.B.C.X'` | `'A'` , `'A.B.C'` |
+ *
+ * @packageDocumentation
+ */
+var Glob = /** @class */ (function () {
+ function Glob(text) {
+ this.text = text;
+ this.glob = text.split('.');
+ var regexpString = this.text
+ .split('.')
+ .map(function (seg) {
+ if (seg === '**')
+ return '(?:|(?:\\.[^.]*)*)';
+ if (seg === '*')
+ return '\\.[^.]*';
+ return '\\.' + seg;
+ })
+ .join('');
+ this.regexp = new RegExp('^' + regexpString + '$');
+ }
+ /** Returns true if the string has glob-like characters in it */
+ Glob.is = function (text) {
+ return !!/[!,*]+/.exec(text);
+ };
+ /** Returns a glob from the string, or null if the string isn't Glob-like */
+ Glob.fromString = function (text) {
+ return Glob.is(text) ? new Glob(text) : null;
+ };
+ Glob.prototype.matches = function (name) {
+ return this.regexp.test('.' + name);
+ };
+ return Glob;
+}());
+
+//# sourceMappingURL=glob.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/hof.js":
+/*!***********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/hof.js ***!
+ \***********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "curry": () => (/* binding */ curry),
+/* harmony export */ "compose": () => (/* binding */ compose),
+/* harmony export */ "pipe": () => (/* binding */ pipe),
+/* harmony export */ "prop": () => (/* binding */ prop),
+/* harmony export */ "propEq": () => (/* binding */ propEq),
+/* harmony export */ "parse": () => (/* binding */ parse),
+/* harmony export */ "not": () => (/* binding */ not),
+/* harmony export */ "and": () => (/* binding */ and),
+/* harmony export */ "or": () => (/* binding */ or),
+/* harmony export */ "all": () => (/* binding */ all),
+/* harmony export */ "any": () => (/* binding */ any),
+/* harmony export */ "is": () => (/* binding */ is),
+/* harmony export */ "eq": () => (/* binding */ eq),
+/* harmony export */ "val": () => (/* binding */ val),
+/* harmony export */ "invoke": () => (/* binding */ invoke),
+/* harmony export */ "pattern": () => (/* binding */ pattern)
+/* harmony export */ });
+/**
+ * Higher order functions
+ *
+ * These utility functions are exported, but are subject to change without notice.
+ *
+ * @packageDocumentation
+ */
+var __spreadArrays = (undefined && undefined.__spreadArrays) || function () {
+ for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+ for (var r = Array(s), k = 0, i = 0; i < il; i++)
+ for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+ r[k] = a[j];
+ return r;
+};
+/**
+ * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.
+ *
+ * Given a function with N parameters, returns a new function that supports partial application.
+ * The new function accepts anywhere from 1 to N parameters. When that function is called with M parameters,
+ * where M is less than N, it returns a new function that accepts the remaining parameters. It continues to
+ * accept more parameters until all N parameters have been supplied.
+ *
+ *
+ * This contrived example uses a partially applied function as an predicate, which returns true
+ * if an object is found in both arrays.
+ * @example
+ * ```
+ * // returns true if an object is in both of the two arrays
+ * function inBoth(array1, array2, object) {
+ * return array1.indexOf(object) !== -1 &&
+ * array2.indexOf(object) !== 1;
+ * }
+ * let obj1, obj2, obj3, obj4, obj5, obj6, obj7
+ * let foos = [obj1, obj3]
+ * let bars = [obj3, obj4, obj5]
+ *
+ * // A curried "copy" of inBoth
+ * let curriedInBoth = curry(inBoth);
+ * // Partially apply both the array1 and array2
+ * let inFoosAndBars = curriedInBoth(foos, bars);
+ *
+ * // Supply the final argument; since all arguments are
+ * // supplied, the original inBoth function is then called.
+ * let obj1InBoth = inFoosAndBars(obj1); // false
+ *
+ * // Use the inFoosAndBars as a predicate.
+ * // Filter, on each iteration, supplies the final argument
+ * let allObjs = [ obj1, obj2, obj3, obj4, obj5, obj6, obj7 ];
+ * let foundInBoth = allObjs.filter(inFoosAndBars); // [ obj3 ]
+ *
+ * ```
+ *
+ * @param fn
+ * @returns {*|function(): (*|any)}
+ */
+function curry(fn) {
+ return function curried() {
+ if (arguments.length >= fn.length) {
+ return fn.apply(this, arguments);
+ }
+ var args = Array.prototype.slice.call(arguments);
+ return curried.bind.apply(curried, __spreadArrays([this], args));
+ };
+}
+/**
+ * Given a varargs list of functions, returns a function that composes the argument functions, right-to-left
+ * given: f(x), g(x), h(x)
+ * let composed = compose(f,g,h)
+ * then, composed is: f(g(h(x)))
+ */
+function compose() {
+ var args = arguments;
+ var start = args.length - 1;
+ return function () {
+ var i = start, result = args[start].apply(this, arguments);
+ while (i--)
+ result = args[i].call(this, result);
+ return result;
+ };
+}
+/**
+ * Given a varargs list of functions, returns a function that is composes the argument functions, left-to-right
+ * given: f(x), g(x), h(x)
+ * let piped = pipe(f,g,h);
+ * then, piped is: h(g(f(x)))
+ */
+function pipe() {
+ var funcs = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ funcs[_i] = arguments[_i];
+ }
+ return compose.apply(null, [].slice.call(arguments).reverse());
+}
+/**
+ * Given a property name, returns a function that returns that property from an object
+ * let obj = { foo: 1, name: "blarg" };
+ * let getName = prop("name");
+ * getName(obj) === "blarg"
+ */
+var prop = function (name) { return function (obj) { return obj && obj[name]; }; };
+/**
+ * Given a property name and a value, returns a function that returns a boolean based on whether
+ * the passed object has a property that matches the value
+ * let obj = { foo: 1, name: "blarg" };
+ * let getName = propEq("name", "blarg");
+ * getName(obj) === true
+ */
+var propEq = curry(function (name, _val, obj) { return obj && obj[name] === _val; });
+/**
+ * Given a dotted property name, returns a function that returns a nested property from an object, or undefined
+ * let obj = { id: 1, nestedObj: { foo: 1, name: "blarg" }, };
+ * let getName = prop("nestedObj.name");
+ * getName(obj) === "blarg"
+ * let propNotFound = prop("this.property.doesnt.exist");
+ * propNotFound(obj) === undefined
+ */
+var parse = function (name) { return pipe.apply(null, name.split('.').map(prop)); };
+/**
+ * Given a function that returns a truthy or falsey value, returns a
+ * function that returns the opposite (falsey or truthy) value given the same inputs
+ */
+var not = function (fn) { return function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return !fn.apply(null, args);
+}; };
+/**
+ * Given two functions that return truthy or falsey values, returns a function that returns truthy
+ * if both functions return truthy for the given arguments
+ */
+function and(fn1, fn2) {
+ return function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return fn1.apply(null, args) && fn2.apply(null, args);
+ };
+}
+/**
+ * Given two functions that return truthy or falsey values, returns a function that returns truthy
+ * if at least one of the functions returns truthy for the given arguments
+ */
+function or(fn1, fn2) {
+ return function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return fn1.apply(null, args) || fn2.apply(null, args);
+ };
+}
+/**
+ * Check if all the elements of an array match a predicate function
+ *
+ * @param fn1 a predicate function `fn1`
+ * @returns a function which takes an array and returns true if `fn1` is true for all elements of the array
+ */
+var all = function (fn1) { return function (arr) { return arr.reduce(function (b, x) { return b && !!fn1(x); }, true); }; };
+// tslint:disable-next-line:variable-name
+var any = function (fn1) { return function (arr) { return arr.reduce(function (b, x) { return b || !!fn1(x); }, false); }; };
+/** Given a class, returns a Predicate function that returns true if the object is of that class */
+var is = function (ctor) { return function (obj) {
+ return (obj != null && obj.constructor === ctor) || obj instanceof ctor;
+}; };
+/** Given a value, returns a Predicate function that returns true if another value is === equal to the original value */
+var eq = function (value) { return function (other) { return value === other; }; };
+/** Given a value, returns a function which returns the value */
+var val = function (v) { return function () { return v; }; };
+function invoke(fnName, args) {
+ return function (obj) { return obj[fnName].apply(obj, args); };
+}
+/**
+ * Sorta like Pattern Matching (a functional programming conditional construct)
+ *
+ * See http://c2.com/cgi/wiki?PatternMatching
+ *
+ * This is a conditional construct which allows a series of predicates and output functions
+ * to be checked and then applied. Each predicate receives the input. If the predicate
+ * returns truthy, then its matching output function (mapping function) is provided with
+ * the input and, then the result is returned.
+ *
+ * Each combination (2-tuple) of predicate + output function should be placed in an array
+ * of size 2: [ predicate, mapFn ]
+ *
+ * These 2-tuples should be put in an outer array.
+ *
+ * @example
+ * ```
+ *
+ * // Here's a 2-tuple where the first element is the isString predicate
+ * // and the second element is a function that returns a description of the input
+ * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
+ *
+ * // Second tuple: predicate "isNumber", mapfn returns a description
+ * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
+ *
+ * let third = [ (input) => input === null, (input) => `Oh, null...` ];
+ *
+ * let fourth = [ (input) => input === undefined, (input) => `notdefined` ];
+ *
+ * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
+ *
+ * console.log(descriptionOf(undefined)); // 'notdefined'
+ * console.log(descriptionOf(55)); // '(55) That's a number!'
+ * console.log(descriptionOf("foo")); // 'Here's your string foo'
+ * ```
+ *
+ * @param struct A 2D array. Each element of the array should be an array, a 2-tuple,
+ * with a Predicate and a mapping/output function
+ * @returns {function(any): *}
+ */
+function pattern(struct) {
+ return function (x) {
+ for (var i = 0; i < struct.length; i++) {
+ if (struct[i][0](x))
+ return struct[i][1](x);
+ }
+ };
+}
+//# sourceMappingURL=hof.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/index.js":
+/*!*************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/index.js ***!
+ \*************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "_extend": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__._extend),
+/* harmony export */ "_inArray": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__._inArray),
+/* harmony export */ "_pushTo": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__._pushTo),
+/* harmony export */ "_removeFrom": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__._removeFrom),
+/* harmony export */ "allTrueR": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.allTrueR),
+/* harmony export */ "ancestors": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.ancestors),
+/* harmony export */ "anyTrueR": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.anyTrueR),
+/* harmony export */ "applyPairs": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.applyPairs),
+/* harmony export */ "arrayTuples": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.arrayTuples),
+/* harmony export */ "assertFn": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.assertFn),
+/* harmony export */ "assertMap": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.assertMap),
+/* harmony export */ "assertPredicate": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.assertPredicate),
+/* harmony export */ "copy": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.copy),
+/* harmony export */ "createProxyFunctions": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.createProxyFunctions),
+/* harmony export */ "defaults": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.defaults),
+/* harmony export */ "deregAll": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.deregAll),
+/* harmony export */ "equals": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.equals),
+/* harmony export */ "extend": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.extend),
+/* harmony export */ "filter": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.filter),
+/* harmony export */ "find": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.find),
+/* harmony export */ "flatten": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.flatten),
+/* harmony export */ "flattenR": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.flattenR),
+/* harmony export */ "forEach": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.forEach),
+/* harmony export */ "fromJson": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.fromJson),
+/* harmony export */ "identity": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.identity),
+/* harmony export */ "inArray": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.inArray),
+/* harmony export */ "inherit": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.inherit),
+/* harmony export */ "map": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.map),
+/* harmony export */ "mapObj": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.mapObj),
+/* harmony export */ "mergeR": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.mergeR),
+/* harmony export */ "noop": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.noop),
+/* harmony export */ "omit": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.omit),
+/* harmony export */ "pairs": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.pairs),
+/* harmony export */ "pick": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.pick),
+/* harmony export */ "pluck": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.pluck),
+/* harmony export */ "pushR": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.pushR),
+/* harmony export */ "pushTo": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.pushTo),
+/* harmony export */ "removeFrom": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.removeFrom),
+/* harmony export */ "root": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.root),
+/* harmony export */ "silenceUncaughtInPromise": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.silenceUncaughtInPromise),
+/* harmony export */ "silentRejection": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.silentRejection),
+/* harmony export */ "tail": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.tail),
+/* harmony export */ "toJson": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.toJson),
+/* harmony export */ "uniqR": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.uniqR),
+/* harmony export */ "unnest": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.unnest),
+/* harmony export */ "unnestR": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.unnestR),
+/* harmony export */ "values": () => (/* reexport safe */ _common__WEBPACK_IMPORTED_MODULE_0__.values),
+/* harmony export */ "makeStub": () => (/* reexport safe */ _coreservices__WEBPACK_IMPORTED_MODULE_1__.makeStub),
+/* harmony export */ "services": () => (/* reexport safe */ _coreservices__WEBPACK_IMPORTED_MODULE_1__.services),
+/* harmony export */ "Glob": () => (/* reexport safe */ _glob__WEBPACK_IMPORTED_MODULE_2__.Glob),
+/* harmony export */ "all": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.all),
+/* harmony export */ "and": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.and),
+/* harmony export */ "any": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.any),
+/* harmony export */ "compose": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.compose),
+/* harmony export */ "curry": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.curry),
+/* harmony export */ "eq": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.eq),
+/* harmony export */ "invoke": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.invoke),
+/* harmony export */ "is": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.is),
+/* harmony export */ "not": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.not),
+/* harmony export */ "or": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.or),
+/* harmony export */ "parse": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.parse),
+/* harmony export */ "pattern": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.pattern),
+/* harmony export */ "pipe": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.pipe),
+/* harmony export */ "prop": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.prop),
+/* harmony export */ "propEq": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.propEq),
+/* harmony export */ "val": () => (/* reexport safe */ _hof__WEBPACK_IMPORTED_MODULE_3__.val),
+/* harmony export */ "isArray": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isArray),
+/* harmony export */ "isDate": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isDate),
+/* harmony export */ "isDefined": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isDefined),
+/* harmony export */ "isFunction": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isFunction),
+/* harmony export */ "isInjectable": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isInjectable),
+/* harmony export */ "isNull": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isNull),
+/* harmony export */ "isNullOrUndefined": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isNullOrUndefined),
+/* harmony export */ "isNumber": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isNumber),
+/* harmony export */ "isObject": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isObject),
+/* harmony export */ "isPromise": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isPromise),
+/* harmony export */ "isRegExp": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isRegExp),
+/* harmony export */ "isString": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isString),
+/* harmony export */ "isUndefined": () => (/* reexport safe */ _predicates__WEBPACK_IMPORTED_MODULE_4__.isUndefined),
+/* harmony export */ "Queue": () => (/* reexport safe */ _queue__WEBPACK_IMPORTED_MODULE_5__.Queue),
+/* harmony export */ "beforeAfterSubstr": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.beforeAfterSubstr),
+/* harmony export */ "fnToString": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.fnToString),
+/* harmony export */ "functionToString": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.functionToString),
+/* harmony export */ "hostRegex": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.hostRegex),
+/* harmony export */ "joinNeighborsR": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.joinNeighborsR),
+/* harmony export */ "kebobString": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.kebobString),
+/* harmony export */ "maxLength": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.maxLength),
+/* harmony export */ "padString": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.padString),
+/* harmony export */ "splitEqual": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.splitEqual),
+/* harmony export */ "splitHash": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.splitHash),
+/* harmony export */ "splitOnDelim": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.splitOnDelim),
+/* harmony export */ "splitQuery": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.splitQuery),
+/* harmony export */ "stringify": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.stringify),
+/* harmony export */ "stripLastPathElement": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.stripLastPathElement),
+/* harmony export */ "trimHashVal": () => (/* reexport safe */ _strings__WEBPACK_IMPORTED_MODULE_6__.trimHashVal),
+/* harmony export */ "Category": () => (/* reexport safe */ _trace__WEBPACK_IMPORTED_MODULE_7__.Category),
+/* harmony export */ "Trace": () => (/* reexport safe */ _trace__WEBPACK_IMPORTED_MODULE_7__.Trace),
+/* harmony export */ "trace": () => (/* reexport safe */ _trace__WEBPACK_IMPORTED_MODULE_7__.trace)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _coreservices__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+/* harmony import */ var _glob__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glob */ "./node_modules/@uirouter/core/lib-esm/common/glob.js");
+/* harmony import */ var _hof__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _predicates__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _queue__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./queue */ "./node_modules/@uirouter/core/lib-esm/common/queue.js");
+/* harmony import */ var _strings__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _trace__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./trace */ "./node_modules/@uirouter/core/lib-esm/common/trace.js");
+
+
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/predicates.js":
+/*!******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/predicates.js ***!
+ \******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "isUndefined": () => (/* binding */ isUndefined),
+/* harmony export */ "isDefined": () => (/* binding */ isDefined),
+/* harmony export */ "isNull": () => (/* binding */ isNull),
+/* harmony export */ "isNullOrUndefined": () => (/* binding */ isNullOrUndefined),
+/* harmony export */ "isFunction": () => (/* binding */ isFunction),
+/* harmony export */ "isNumber": () => (/* binding */ isNumber),
+/* harmony export */ "isString": () => (/* binding */ isString),
+/* harmony export */ "isObject": () => (/* binding */ isObject),
+/* harmony export */ "isArray": () => (/* binding */ isArray),
+/* harmony export */ "isDate": () => (/* binding */ isDate),
+/* harmony export */ "isRegExp": () => (/* binding */ isRegExp),
+/* harmony export */ "isInjectable": () => (/* binding */ isInjectable),
+/* harmony export */ "isPromise": () => (/* binding */ isPromise)
+/* harmony export */ });
+/* harmony import */ var _hof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/**
+ * Predicates
+ *
+ * These predicates return true/false based on the input.
+ * Although these functions are exported, they are subject to change without notice.
+ *
+ * @packageDocumentation
+ */
+
+var toStr = Object.prototype.toString;
+var tis = function (t) { return function (x) { return typeof x === t; }; };
+var isUndefined = tis('undefined');
+var isDefined = (0,_hof__WEBPACK_IMPORTED_MODULE_0__.not)(isUndefined);
+var isNull = function (o) { return o === null; };
+var isNullOrUndefined = (0,_hof__WEBPACK_IMPORTED_MODULE_0__.or)(isNull, isUndefined);
+var isFunction = tis('function');
+var isNumber = tis('number');
+var isString = tis('string');
+var isObject = function (x) { return x !== null && typeof x === 'object'; };
+var isArray = Array.isArray;
+var isDate = (function (x) { return toStr.call(x) === '[object Date]'; });
+var isRegExp = (function (x) { return toStr.call(x) === '[object RegExp]'; });
+/**
+ * Predicate which checks if a value is injectable
+ *
+ * A value is "injectable" if it is a function, or if it is an ng1 array-notation-style array
+ * where all the elements in the array are Strings, except the last one, which is a Function
+ */
+function isInjectable(val) {
+ if (isArray(val) && val.length) {
+ var head = val.slice(0, -1), tail = val.slice(-1);
+ return !(head.filter((0,_hof__WEBPACK_IMPORTED_MODULE_0__.not)(isString)).length || tail.filter((0,_hof__WEBPACK_IMPORTED_MODULE_0__.not)(isFunction)).length);
+ }
+ return isFunction(val);
+}
+/**
+ * Predicate which checks if a value looks like a Promise
+ *
+ * It is probably a Promise if it's an object, and it has a `then` property which is a Function
+ */
+var isPromise = (0,_hof__WEBPACK_IMPORTED_MODULE_0__.and)(isObject, (0,_hof__WEBPACK_IMPORTED_MODULE_0__.pipe)((0,_hof__WEBPACK_IMPORTED_MODULE_0__.prop)('then'), isFunction));
+//# sourceMappingURL=predicates.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/queue.js":
+/*!*************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/queue.js ***!
+ \*************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "Queue": () => (/* binding */ Queue)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+
+var Queue = /** @class */ (function () {
+ function Queue(_items, _limit) {
+ if (_items === void 0) { _items = []; }
+ if (_limit === void 0) { _limit = null; }
+ this._items = _items;
+ this._limit = _limit;
+ this._evictListeners = [];
+ this.onEvict = (0,_common__WEBPACK_IMPORTED_MODULE_0__.pushTo)(this._evictListeners);
+ }
+ Queue.prototype.enqueue = function (item) {
+ var items = this._items;
+ items.push(item);
+ if (this._limit && items.length > this._limit)
+ this.evict();
+ return item;
+ };
+ Queue.prototype.evict = function () {
+ var item = this._items.shift();
+ this._evictListeners.forEach(function (fn) { return fn(item); });
+ return item;
+ };
+ Queue.prototype.dequeue = function () {
+ if (this.size())
+ return this._items.splice(0, 1)[0];
+ };
+ Queue.prototype.clear = function () {
+ var current = this._items;
+ this._items = [];
+ return current;
+ };
+ Queue.prototype.size = function () {
+ return this._items.length;
+ };
+ Queue.prototype.remove = function (item) {
+ var idx = this._items.indexOf(item);
+ return idx > -1 && this._items.splice(idx, 1)[0];
+ };
+ Queue.prototype.peekTail = function () {
+ return this._items[this._items.length - 1];
+ };
+ Queue.prototype.peekHead = function () {
+ if (this.size())
+ return this._items[0];
+ };
+ return Queue;
+}());
+
+//# sourceMappingURL=queue.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/safeConsole.js":
+/*!*******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/safeConsole.js ***!
+ \*******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "safeConsole": () => (/* binding */ safeConsole)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/**
+ * workaround for missing console object in IE9 when dev tools haven't been opened o_O
+ * @packageDocumentation
+ */
+/* tslint:disable:no-console */
+
+var noopConsoleStub = { log: _common__WEBPACK_IMPORTED_MODULE_0__.noop, error: _common__WEBPACK_IMPORTED_MODULE_0__.noop, table: _common__WEBPACK_IMPORTED_MODULE_0__.noop };
+function ie9Console(console) {
+ var bound = function (fn) { return Function.prototype.bind.call(fn, console); };
+ return {
+ log: bound(console.log),
+ error: bound(console.log),
+ table: bound(console.log),
+ };
+}
+function fallbackConsole(console) {
+ var log = console.log.bind(console);
+ var error = console.error ? console.error.bind(console) : log;
+ var table = console.table ? console.table.bind(console) : log;
+ return { log: log, error: error, table: table };
+}
+function getSafeConsole() {
+ // @ts-ignore
+ var isIE9 = typeof document !== 'undefined' && document.documentMode && document.documentMode === 9;
+ if (isIE9) {
+ return window && window.console ? ie9Console(window.console) : noopConsoleStub;
+ }
+ else if (!console.table || !console.error) {
+ return fallbackConsole(console);
+ }
+ else {
+ return console;
+ }
+}
+var safeConsole = getSafeConsole();
+//# sourceMappingURL=safeConsole.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/strings.js":
+/*!***************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/strings.js ***!
+ \***************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "maxLength": () => (/* binding */ maxLength),
+/* harmony export */ "padString": () => (/* binding */ padString),
+/* harmony export */ "kebobString": () => (/* binding */ kebobString),
+/* harmony export */ "functionToString": () => (/* binding */ functionToString),
+/* harmony export */ "fnToString": () => (/* binding */ fnToString),
+/* harmony export */ "stringify": () => (/* binding */ stringify),
+/* harmony export */ "beforeAfterSubstr": () => (/* binding */ beforeAfterSubstr),
+/* harmony export */ "hostRegex": () => (/* binding */ hostRegex),
+/* harmony export */ "stripLastPathElement": () => (/* binding */ stripLastPathElement),
+/* harmony export */ "splitHash": () => (/* binding */ splitHash),
+/* harmony export */ "splitQuery": () => (/* binding */ splitQuery),
+/* harmony export */ "splitEqual": () => (/* binding */ splitEqual),
+/* harmony export */ "trimHashVal": () => (/* binding */ trimHashVal),
+/* harmony export */ "splitOnDelim": () => (/* binding */ splitOnDelim),
+/* harmony export */ "joinNeighborsR": () => (/* binding */ joinNeighborsR)
+/* harmony export */ });
+/* harmony import */ var _predicates__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../transition/rejectFactory */ "./node_modules/@uirouter/core/lib-esm/transition/rejectFactory.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _hof__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/**
+ * Functions that manipulate strings
+ *
+ * Although these functions are exported, they are subject to change without notice.
+ *
+ * @packageDocumentation
+ */
+
+
+
+
+/**
+ * Returns a string shortened to a maximum length
+ *
+ * If the string is already less than the `max` length, return the string.
+ * Else return the string, shortened to `max - 3` and append three dots ("...").
+ *
+ * @param max the maximum length of the string to return
+ * @param str the input string
+ */
+function maxLength(max, str) {
+ if (str.length <= max)
+ return str;
+ return str.substr(0, max - 3) + '...';
+}
+/**
+ * Returns a string, with spaces added to the end, up to a desired str length
+ *
+ * If the string is already longer than the desired length, return the string.
+ * Else returns the string, with extra spaces on the end, such that it reaches `length` characters.
+ *
+ * @param length the desired length of the string to return
+ * @param str the input string
+ */
+function padString(length, str) {
+ while (str.length < length)
+ str += ' ';
+ return str;
+}
+function kebobString(camelCase) {
+ return camelCase
+ .replace(/^([A-Z])/, function ($1) { return $1.toLowerCase(); }) // replace first char
+ .replace(/([A-Z])/g, function ($1) { return '-' + $1.toLowerCase(); }); // replace rest
+}
+function functionToString(fn) {
+ var fnStr = fnToString(fn);
+ var namedFunctionMatch = fnStr.match(/^(function [^ ]+\([^)]*\))/);
+ var toStr = namedFunctionMatch ? namedFunctionMatch[1] : fnStr;
+ var fnName = fn['name'] || '';
+ if (fnName && toStr.match(/function \(/)) {
+ return 'function ' + fnName + toStr.substr(9);
+ }
+ return toStr;
+}
+function fnToString(fn) {
+ var _fn = (0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isArray)(fn) ? fn.slice(-1)[0] : fn;
+ return (_fn && _fn.toString()) || 'undefined';
+}
+var isRejection = _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_1__.Rejection.isRejectionPromise;
+var hasToString = function (obj) {
+ return (0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isObject)(obj) && !(0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isArray)(obj) && obj.constructor !== Object && (0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isFunction)(obj.toString);
+};
+var stringifyPattern = (0,_hof__WEBPACK_IMPORTED_MODULE_3__.pattern)([
+ [_predicates__WEBPACK_IMPORTED_MODULE_0__.isUndefined, (0,_hof__WEBPACK_IMPORTED_MODULE_3__.val)('undefined')],
+ [_predicates__WEBPACK_IMPORTED_MODULE_0__.isNull, (0,_hof__WEBPACK_IMPORTED_MODULE_3__.val)('null')],
+ [_predicates__WEBPACK_IMPORTED_MODULE_0__.isPromise, (0,_hof__WEBPACK_IMPORTED_MODULE_3__.val)('[Promise]')],
+ [isRejection, function (x) { return x._transitionRejection.toString(); }],
+ [hasToString, function (x) { return x.toString(); }],
+ [_predicates__WEBPACK_IMPORTED_MODULE_0__.isInjectable, functionToString],
+ [(0,_hof__WEBPACK_IMPORTED_MODULE_3__.val)(true), _common__WEBPACK_IMPORTED_MODULE_2__.identity],
+]);
+function stringify(o) {
+ var seen = [];
+ function format(value) {
+ if ((0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isObject)(value)) {
+ if (seen.indexOf(value) !== -1)
+ return '[circular ref]';
+ seen.push(value);
+ }
+ return stringifyPattern(value);
+ }
+ if ((0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isUndefined)(o)) {
+ // Workaround for IE & Edge Spec incompatibility where replacer function would not be called when JSON.stringify
+ // is given `undefined` as value. To work around that, we simply detect `undefined` and bail out early by
+ // manually stringifying it.
+ return format(o);
+ }
+ return JSON.stringify(o, function (key, value) { return format(value); }).replace(/\\"/g, '"');
+}
+/** Returns a function that splits a string on a character or substring */
+var beforeAfterSubstr = function (char) { return function (str) {
+ if (!str)
+ return ['', ''];
+ var idx = str.indexOf(char);
+ if (idx === -1)
+ return [str, ''];
+ return [str.substr(0, idx), str.substr(idx + 1)];
+}; };
+var hostRegex = new RegExp('^(?:[a-z]+:)?//[^/]+/');
+var stripLastPathElement = function (str) { return str.replace(/\/[^/]*$/, ''); };
+var splitHash = beforeAfterSubstr('#');
+var splitQuery = beforeAfterSubstr('?');
+var splitEqual = beforeAfterSubstr('=');
+var trimHashVal = function (str) { return (str ? str.replace(/^#/, '') : ''); };
+/**
+ * Splits on a delimiter, but returns the delimiters in the array
+ *
+ * #### Example:
+ * ```js
+ * var splitOnSlashes = splitOnDelim('/');
+ * splitOnSlashes("/foo"); // ["/", "foo"]
+ * splitOnSlashes("/foo/"); // ["/", "foo", "/"]
+ * ```
+ */
+function splitOnDelim(delim) {
+ var re = new RegExp('(' + delim + ')', 'g');
+ return function (str) { return str.split(re).filter(_common__WEBPACK_IMPORTED_MODULE_2__.identity); };
+}
+/**
+ * Reduce fn that joins neighboring strings
+ *
+ * Given an array of strings, returns a new array
+ * where all neighboring strings have been joined.
+ *
+ * #### Example:
+ * ```js
+ * let arr = ["foo", "bar", 1, "baz", "", "qux" ];
+ * arr.reduce(joinNeighborsR, []) // ["foobar", 1, "bazqux" ]
+ * ```
+ */
+function joinNeighborsR(acc, x) {
+ if ((0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isString)((0,_common__WEBPACK_IMPORTED_MODULE_2__.tail)(acc)) && (0,_predicates__WEBPACK_IMPORTED_MODULE_0__.isString)(x))
+ return acc.slice(0, -1).concat((0,_common__WEBPACK_IMPORTED_MODULE_2__.tail)(acc) + x);
+ return (0,_common__WEBPACK_IMPORTED_MODULE_2__.pushR)(acc, x);
+}
+//# sourceMappingURL=strings.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/common/trace.js":
+/*!*************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/common/trace.js ***!
+ \*************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "Category": () => (/* binding */ Category),
+/* harmony export */ "Trace": () => (/* binding */ Trace),
+/* harmony export */ "trace": () => (/* binding */ trace)
+/* harmony export */ });
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _strings__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _safeConsole__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./safeConsole */ "./node_modules/@uirouter/core/lib-esm/common/safeConsole.js");
+/**
+ * # Transition tracing (debug)
+ *
+ * Enable transition tracing to print transition information to the console,
+ * in order to help debug your application.
+ * Tracing logs detailed information about each Transition to your console.
+ *
+ * To enable tracing, import the [[Trace]] singleton and enable one or more categories.
+ *
+ * ### ES6
+ * ```js
+ * import {trace} from "@uirouter/core";
+ * trace.enable(1, 5); // TRANSITION and VIEWCONFIG
+ * ```
+ *
+ * ### CJS
+ * ```js
+ * let trace = require("@uirouter/core").trace;
+ * trace.enable("TRANSITION", "VIEWCONFIG");
+ * ```
+ *
+ * ### Globals
+ * ```js
+ * let trace = window["@uirouter/core"].trace;
+ * trace.enable(); // Trace everything (very verbose)
+ * ```
+ *
+ * ### Angular 1:
+ * ```js
+ * app.run($trace => $trace.enable());
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+
+
+
+function uiViewString(uiview) {
+ if (!uiview)
+ return 'ui-view (defunct)';
+ var state = uiview.creationContext ? uiview.creationContext.name || '(root)' : '(none)';
+ return "[ui-view#" + uiview.id + " " + uiview.$type + ":" + uiview.fqn + " (" + uiview.name + "@" + state + ")]";
+}
+var viewConfigString = function (viewConfig) {
+ var view = viewConfig.viewDecl;
+ var state = view.$context.name || '(root)';
+ return "[View#" + viewConfig.$id + " from '" + state + "' state]: target ui-view: '" + view.$uiViewName + "@" + view.$uiViewContextAnchor + "'";
+};
+function normalizedCat(input) {
+ return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isNumber)(input) ? Category[input] : Category[Category[input]];
+}
+/**
+ * Trace categories Enum
+ *
+ * Enable or disable a category using [[Trace.enable]] or [[Trace.disable]]
+ *
+ * `trace.enable(Category.TRANSITION)`
+ *
+ * These can also be provided using a matching string, or position ordinal
+ *
+ * `trace.enable("TRANSITION")`
+ *
+ * `trace.enable(1)`
+ */
+var Category;
+(function (Category) {
+ Category[Category["RESOLVE"] = 0] = "RESOLVE";
+ Category[Category["TRANSITION"] = 1] = "TRANSITION";
+ Category[Category["HOOK"] = 2] = "HOOK";
+ Category[Category["UIVIEW"] = 3] = "UIVIEW";
+ Category[Category["VIEWCONFIG"] = 4] = "VIEWCONFIG";
+})(Category || (Category = {}));
+
+var _tid = (0,_common_hof__WEBPACK_IMPORTED_MODULE_0__.parse)('$id');
+var _rid = (0,_common_hof__WEBPACK_IMPORTED_MODULE_0__.parse)('router.$id');
+var transLbl = function (trans) { return "Transition #" + _tid(trans) + "-" + _rid(trans); };
+/**
+ * Prints UI-Router Transition trace information to the console.
+ */
+var Trace = /** @class */ (function () {
+ /** @internal */
+ function Trace() {
+ /** @internal */
+ this._enabled = {};
+ this.approximateDigests = 0;
+ }
+ /** @internal */
+ Trace.prototype._set = function (enabled, categories) {
+ var _this = this;
+ if (!categories.length) {
+ categories = Object.keys(Category)
+ .map(function (k) { return parseInt(k, 10); })
+ .filter(function (k) { return !isNaN(k); })
+ .map(function (key) { return Category[key]; });
+ }
+ categories.map(normalizedCat).forEach(function (category) { return (_this._enabled[category] = enabled); });
+ };
+ Trace.prototype.enable = function () {
+ var categories = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ categories[_i] = arguments[_i];
+ }
+ this._set(true, categories);
+ };
+ Trace.prototype.disable = function () {
+ var categories = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ categories[_i] = arguments[_i];
+ }
+ this._set(false, categories);
+ };
+ /**
+ * Retrieves the enabled stateus of a [[Category]]
+ *
+ * ```js
+ * trace.enabled("VIEWCONFIG"); // true or false
+ * ```
+ *
+ * @returns boolean true if the category is enabled
+ */
+ Trace.prototype.enabled = function (category) {
+ return !!this._enabled[normalizedCat(category)];
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceTransitionStart = function (trans) {
+ if (!this.enabled(Category.TRANSITION))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log(transLbl(trans) + ": Started -> " + (0,_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(trans));
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceTransitionIgnored = function (trans) {
+ if (!this.enabled(Category.TRANSITION))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log(transLbl(trans) + ": Ignored <> " + (0,_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(trans));
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceHookInvocation = function (step, trans, options) {
+ if (!this.enabled(Category.HOOK))
+ return;
+ var event = (0,_common_hof__WEBPACK_IMPORTED_MODULE_0__.parse)('traceData.hookType')(options) || 'internal', context = (0,_common_hof__WEBPACK_IMPORTED_MODULE_0__.parse)('traceData.context.state.name')(options) || (0,_common_hof__WEBPACK_IMPORTED_MODULE_0__.parse)('traceData.context')(options) || 'unknown', name = (0,_strings__WEBPACK_IMPORTED_MODULE_2__.functionToString)(step.registeredHook.callback);
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log(transLbl(trans) + ": Hook -> " + event + " context: " + context + ", " + (0,_strings__WEBPACK_IMPORTED_MODULE_2__.maxLength)(200, name));
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceHookResult = function (hookResult, trans, transitionOptions) {
+ if (!this.enabled(Category.HOOK))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log(transLbl(trans) + ": <- Hook returned: " + (0,_strings__WEBPACK_IMPORTED_MODULE_2__.maxLength)(200, (0,_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(hookResult)));
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceResolvePath = function (path, when, trans) {
+ if (!this.enabled(Category.RESOLVE))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log(transLbl(trans) + ": Resolving " + path + " (" + when + ")");
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceResolvableResolved = function (resolvable, trans) {
+ if (!this.enabled(Category.RESOLVE))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log(transLbl(trans) + ": <- Resolved " + resolvable + " to: " + (0,_strings__WEBPACK_IMPORTED_MODULE_2__.maxLength)(200, (0,_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(resolvable.data)));
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceError = function (reason, trans) {
+ if (!this.enabled(Category.TRANSITION))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log(transLbl(trans) + ": <- Rejected " + (0,_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(trans) + ", reason: " + reason);
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceSuccess = function (finalState, trans) {
+ if (!this.enabled(Category.TRANSITION))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log(transLbl(trans) + ": <- Success " + (0,_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(trans) + ", final state: " + finalState.name);
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceUIViewEvent = function (event, viewData, extra) {
+ if (extra === void 0) { extra = ''; }
+ if (!this.enabled(Category.UIVIEW))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log("ui-view: " + (0,_strings__WEBPACK_IMPORTED_MODULE_2__.padString)(30, event) + " " + uiViewString(viewData) + extra);
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceUIViewConfigUpdated = function (viewData, context) {
+ if (!this.enabled(Category.UIVIEW))
+ return;
+ this.traceUIViewEvent('Updating', viewData, " with ViewConfig from context='" + context + "'");
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceUIViewFill = function (viewData, html) {
+ if (!this.enabled(Category.UIVIEW))
+ return;
+ this.traceUIViewEvent('Fill', viewData, " with: " + (0,_strings__WEBPACK_IMPORTED_MODULE_2__.maxLength)(200, html));
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceViewSync = function (pairs) {
+ if (!this.enabled(Category.VIEWCONFIG))
+ return;
+ var uivheader = 'uiview component fqn';
+ var cfgheader = 'view config state (view name)';
+ var mapping = pairs
+ .map(function (_a) {
+ var _b;
+ var uiView = _a.uiView, viewConfig = _a.viewConfig;
+ var uiv = uiView && uiView.fqn;
+ var cfg = viewConfig && viewConfig.viewDecl.$context.name + ": (" + viewConfig.viewDecl.$name + ")";
+ return _b = {}, _b[uivheader] = uiv, _b[cfgheader] = cfg, _b;
+ })
+ .sort(function (a, b) { return (a[uivheader] || '').localeCompare(b[uivheader] || ''); });
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.table(mapping);
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceViewServiceEvent = function (event, viewConfig) {
+ if (!this.enabled(Category.VIEWCONFIG))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log("VIEWCONFIG: " + event + " " + viewConfigString(viewConfig));
+ };
+ /** @internal called by ui-router code */
+ Trace.prototype.traceViewServiceUIViewEvent = function (event, viewData) {
+ if (!this.enabled(Category.VIEWCONFIG))
+ return;
+ _safeConsole__WEBPACK_IMPORTED_MODULE_3__.safeConsole.log("VIEWCONFIG: " + event + " " + uiViewString(viewData));
+ };
+ return Trace;
+}());
+
+/**
+ * The [[Trace]] singleton
+ *
+ * #### Example:
+ * ```js
+ * import {trace} from "@uirouter/core";
+ * trace.enable(1, 5);
+ * ```
+ */
+var trace = new Trace();
+
+//# sourceMappingURL=trace.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/globals.js":
+/*!********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/globals.js ***!
+ \********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UIRouterGlobals": () => (/* binding */ UIRouterGlobals)
+/* harmony export */ });
+/* harmony import */ var _params_stateParams__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./params/stateParams */ "./node_modules/@uirouter/core/lib-esm/params/stateParams.js");
+/* harmony import */ var _common_queue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./common/queue */ "./node_modules/@uirouter/core/lib-esm/common/queue.js");
+
+
+/**
+ * Global router state
+ *
+ * This is where we hold the global mutable state such as current state, current
+ * params, current transition, etc.
+ */
+var UIRouterGlobals = /** @class */ (function () {
+ function UIRouterGlobals() {
+ /**
+ * Current parameter values
+ *
+ * The parameter values from the latest successful transition
+ */
+ this.params = new _params_stateParams__WEBPACK_IMPORTED_MODULE_0__.StateParams();
+ /** @internal */
+ this.lastStartedTransitionId = -1;
+ /** @internal */
+ this.transitionHistory = new _common_queue__WEBPACK_IMPORTED_MODULE_1__.Queue([], 1);
+ /** @internal */
+ this.successfulTransitions = new _common_queue__WEBPACK_IMPORTED_MODULE_1__.Queue([], 1);
+ }
+ UIRouterGlobals.prototype.dispose = function () {
+ this.transitionHistory.clear();
+ this.successfulTransitions.clear();
+ this.transition = null;
+ };
+ return UIRouterGlobals;
+}());
+
+//# sourceMappingURL=globals.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/coreResolvables.js":
+/*!**********************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/coreResolvables.js ***!
+ \**********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "registerAddCoreResolvables": () => (/* binding */ registerAddCoreResolvables),
+/* harmony export */ "treeChangesCleanup": () => (/* binding */ treeChangesCleanup)
+/* harmony export */ });
+/* harmony import */ var _transition_transition__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../transition/transition */ "./node_modules/@uirouter/core/lib-esm/transition/transition.js");
+/* harmony import */ var _router__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../router */ "./node_modules/@uirouter/core/lib-esm/router.js");
+/* harmony import */ var _resolve__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../resolve */ "./node_modules/@uirouter/core/lib-esm/resolve/index.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+
+
+
+function addCoreResolvables(trans) {
+ trans.addResolvable(_resolve__WEBPACK_IMPORTED_MODULE_2__.Resolvable.fromData(_router__WEBPACK_IMPORTED_MODULE_1__.UIRouter, trans.router), '');
+ trans.addResolvable(_resolve__WEBPACK_IMPORTED_MODULE_2__.Resolvable.fromData(_transition_transition__WEBPACK_IMPORTED_MODULE_0__.Transition, trans), '');
+ trans.addResolvable(_resolve__WEBPACK_IMPORTED_MODULE_2__.Resolvable.fromData('$transition$', trans), '');
+ trans.addResolvable(_resolve__WEBPACK_IMPORTED_MODULE_2__.Resolvable.fromData('$stateParams', trans.params()), '');
+ trans.entering().forEach(function (state) {
+ trans.addResolvable(_resolve__WEBPACK_IMPORTED_MODULE_2__.Resolvable.fromData('$state$', state), state);
+ });
+}
+var registerAddCoreResolvables = function (transitionService) {
+ return transitionService.onCreate({}, addCoreResolvables);
+};
+var TRANSITION_TOKENS = ['$transition$', _transition_transition__WEBPACK_IMPORTED_MODULE_0__.Transition];
+var isTransition = (0,_common__WEBPACK_IMPORTED_MODULE_3__.inArray)(TRANSITION_TOKENS);
+// References to Transition in the treeChanges pathnodes makes all
+// previous Transitions reachable in memory, causing a memory leak
+// This function removes resolves for '$transition$' and `Transition` from the treeChanges.
+// Do not use this on current transitions, only on old ones.
+var treeChangesCleanup = function (trans) {
+ var nodes = (0,_common__WEBPACK_IMPORTED_MODULE_3__.values)(trans.treeChanges()).reduce(_common__WEBPACK_IMPORTED_MODULE_3__.unnestR, []).reduce(_common__WEBPACK_IMPORTED_MODULE_3__.uniqR, []);
+ // If the resolvable is a Transition, return a new resolvable with null data
+ var replaceTransitionWithNull = function (r) {
+ return isTransition(r.token) ? _resolve__WEBPACK_IMPORTED_MODULE_2__.Resolvable.fromData(r.token, null) : r;
+ };
+ nodes.forEach(function (node) {
+ node.resolvables = node.resolvables.map(replaceTransitionWithNull);
+ });
+};
+//# sourceMappingURL=coreResolvables.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/ignoredTransition.js":
+/*!************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/ignoredTransition.js ***!
+ \************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "registerIgnoredTransitionHook": () => (/* binding */ registerIgnoredTransitionHook)
+/* harmony export */ });
+/* harmony import */ var _common_trace__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/trace */ "./node_modules/@uirouter/core/lib-esm/common/trace.js");
+/* harmony import */ var _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../transition/rejectFactory */ "./node_modules/@uirouter/core/lib-esm/transition/rejectFactory.js");
+
+
+/**
+ * A [[TransitionHookFn]] that skips a transition if it should be ignored
+ *
+ * This hook is invoked at the end of the onBefore phase.
+ *
+ * If the transition should be ignored (because no parameter or states changed)
+ * then the transition is ignored and not processed.
+ */
+function ignoredHook(trans) {
+ var ignoredReason = trans._ignoredReason();
+ if (!ignoredReason)
+ return;
+ _common_trace__WEBPACK_IMPORTED_MODULE_0__.trace.traceTransitionIgnored(trans);
+ var pending = trans.router.globals.transition;
+ // The user clicked a link going back to the *current state* ('A')
+ // However, there is also a pending transition in flight (to 'B')
+ // Abort the transition to 'B' because the user now wants to be back at 'A'.
+ if (ignoredReason === 'SameAsCurrent' && pending) {
+ pending.abort();
+ }
+ return _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_1__.Rejection.ignored().toPromise();
+}
+var registerIgnoredTransitionHook = function (transitionService) {
+ return transitionService.onBefore({}, ignoredHook, { priority: -9999 });
+};
+//# sourceMappingURL=ignoredTransition.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/invalidTransition.js":
+/*!************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/invalidTransition.js ***!
+ \************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "registerInvalidTransitionHook": () => (/* binding */ registerInvalidTransitionHook)
+/* harmony export */ });
+/**
+ * A [[TransitionHookFn]] that rejects the Transition if it is invalid
+ *
+ * This hook is invoked at the end of the onBefore phase.
+ * If the transition is invalid (for example, param values do not validate)
+ * then the transition is rejected.
+ */
+function invalidTransitionHook(trans) {
+ if (!trans.valid()) {
+ throw new Error(trans.error().toString());
+ }
+}
+var registerInvalidTransitionHook = function (transitionService) {
+ return transitionService.onBefore({}, invalidTransitionHook, { priority: -10000 });
+};
+//# sourceMappingURL=invalidTransition.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/lazyLoad.js":
+/*!***************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/lazyLoad.js ***!
+ \***************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "registerLazyLoadHook": () => (/* binding */ registerLazyLoadHook),
+/* harmony export */ "lazyLoadState": () => (/* binding */ lazyLoadState)
+/* harmony export */ });
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+
+/**
+ * A [[TransitionHookFn]] that performs lazy loading
+ *
+ * When entering a state "abc" which has a `lazyLoad` function defined:
+ * - Invoke the `lazyLoad` function (unless it is already in process)
+ * - Flag the hook function as "in process"
+ * - The function should return a promise (that resolves when lazy loading is complete)
+ * - Wait for the promise to settle
+ * - If the promise resolves to a [[LazyLoadResult]], then register those states
+ * - Flag the hook function as "not in process"
+ * - If the hook was successful
+ * - Remove the `lazyLoad` function from the state declaration
+ * - If all the hooks were successful
+ * - Retry the transition (by returning a TargetState)
+ *
+ * ```
+ * .state('abc', {
+ * component: 'fooComponent',
+ * lazyLoad: () => import('./fooComponent')
+ * });
+ * ```
+ *
+ * See [[StateDeclaration.lazyLoad]]
+ */
+var lazyLoadHook = function (transition) {
+ var router = transition.router;
+ function retryTransition() {
+ if (transition.originalTransition().options().source !== 'url') {
+ // The original transition was not triggered via url sync
+ // The lazy state should be loaded now, so re-try the original transition
+ var orig = transition.targetState();
+ return router.stateService.target(orig.identifier(), orig.params(), orig.options());
+ }
+ // The original transition was triggered via url sync
+ // Run the URL rules and find the best match
+ var $url = router.urlService;
+ var result = $url.match($url.parts());
+ var rule = result && result.rule;
+ // If the best match is a state, redirect the transition (instead
+ // of calling sync() which supersedes the current transition)
+ if (rule && rule.type === 'STATE') {
+ var state = rule.state;
+ var params = result.match;
+ return router.stateService.target(state, params, transition.options());
+ }
+ // No matching state found, so let .sync() choose the best non-state match/otherwise
+ router.urlService.sync();
+ }
+ var promises = transition
+ .entering()
+ .filter(function (state) { return !!state.$$state().lazyLoad; })
+ .map(function (state) { return lazyLoadState(transition, state); });
+ return _common_coreservices__WEBPACK_IMPORTED_MODULE_0__.services.$q.all(promises).then(retryTransition);
+};
+var registerLazyLoadHook = function (transitionService) {
+ return transitionService.onBefore({ entering: function (state) { return !!state.lazyLoad; } }, lazyLoadHook);
+};
+/**
+ * Invokes a state's lazy load function
+ *
+ * @param transition a Transition context
+ * @param state the state to lazy load
+ * @returns A promise for the lazy load result
+ */
+function lazyLoadState(transition, state) {
+ var lazyLoadFn = state.$$state().lazyLoad;
+ // Store/get the lazy load promise on/from the hookfn so it doesn't get re-invoked
+ var promise = lazyLoadFn['_promise'];
+ if (!promise) {
+ var success = function (result) {
+ delete state.lazyLoad;
+ delete state.$$state().lazyLoad;
+ delete lazyLoadFn['_promise'];
+ return result;
+ };
+ var error = function (err) {
+ delete lazyLoadFn['_promise'];
+ return _common_coreservices__WEBPACK_IMPORTED_MODULE_0__.services.$q.reject(err);
+ };
+ promise = lazyLoadFn['_promise'] = _common_coreservices__WEBPACK_IMPORTED_MODULE_0__.services.$q.when(lazyLoadFn(transition, state))
+ .then(updateStateRegistry)
+ .then(success, error);
+ }
+ /** Register any lazy loaded state definitions */
+ function updateStateRegistry(result) {
+ if (result && Array.isArray(result.states)) {
+ result.states.forEach(function (_state) { return transition.router.stateRegistry.register(_state); });
+ }
+ return result;
+ }
+ return promise;
+}
+//# sourceMappingURL=lazyLoad.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/onEnterExitRetain.js":
+/*!************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/onEnterExitRetain.js ***!
+ \************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "registerOnExitHook": () => (/* binding */ registerOnExitHook),
+/* harmony export */ "registerOnRetainHook": () => (/* binding */ registerOnRetainHook),
+/* harmony export */ "registerOnEnterHook": () => (/* binding */ registerOnEnterHook)
+/* harmony export */ });
+/**
+ * A factory which creates an onEnter, onExit or onRetain transition hook function
+ *
+ * The returned function invokes the (for instance) state.onEnter hook when the
+ * state is being entered.
+ */
+function makeEnterExitRetainHook(hookName) {
+ return function (transition, state) {
+ var _state = state.$$state();
+ var hookFn = _state[hookName];
+ return hookFn(transition, state);
+ };
+}
+/**
+ * The [[TransitionStateHookFn]] for onExit
+ *
+ * When the state is being exited, the state's .onExit function is invoked.
+ *
+ * Registered using `transitionService.onExit({ exiting: (state) => !!state.onExit }, onExitHook);`
+ *
+ * See: [[IHookRegistry.onExit]]
+ */
+var onExitHook = makeEnterExitRetainHook('onExit');
+var registerOnExitHook = function (transitionService) {
+ return transitionService.onExit({ exiting: function (state) { return !!state.onExit; } }, onExitHook);
+};
+/**
+ * The [[TransitionStateHookFn]] for onRetain
+ *
+ * When the state was already entered, and is not being exited or re-entered, the state's .onRetain function is invoked.
+ *
+ * Registered using `transitionService.onRetain({ retained: (state) => !!state.onRetain }, onRetainHook);`
+ *
+ * See: [[IHookRegistry.onRetain]]
+ */
+var onRetainHook = makeEnterExitRetainHook('onRetain');
+var registerOnRetainHook = function (transitionService) {
+ return transitionService.onRetain({ retained: function (state) { return !!state.onRetain; } }, onRetainHook);
+};
+/**
+ * The [[TransitionStateHookFn]] for onEnter
+ *
+ * When the state is being entered, the state's .onEnter function is invoked.
+ *
+ * Registered using `transitionService.onEnter({ entering: (state) => !!state.onEnter }, onEnterHook);`
+ *
+ * See: [[IHookRegistry.onEnter]]
+ */
+var onEnterHook = makeEnterExitRetainHook('onEnter');
+var registerOnEnterHook = function (transitionService) {
+ return transitionService.onEnter({ entering: function (state) { return !!state.onEnter; } }, onEnterHook);
+};
+//# sourceMappingURL=onEnterExitRetain.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/redirectTo.js":
+/*!*****************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/redirectTo.js ***!
+ \*****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "registerRedirectToHook": () => (/* binding */ registerRedirectToHook)
+/* harmony export */ });
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+/* harmony import */ var _state_targetState__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../state/targetState */ "./node_modules/@uirouter/core/lib-esm/state/targetState.js");
+
+
+
+/**
+ * A [[TransitionHookFn]] that redirects to a different state or params
+ *
+ * Registered using `transitionService.onStart({ to: (state) => !!state.redirectTo }, redirectHook);`
+ *
+ * See [[StateDeclaration.redirectTo]]
+ */
+var redirectToHook = function (trans) {
+ var redirect = trans.to().redirectTo;
+ if (!redirect)
+ return;
+ var $state = trans.router.stateService;
+ function handleResult(result) {
+ if (!result)
+ return;
+ if (result instanceof _state_targetState__WEBPACK_IMPORTED_MODULE_2__.TargetState)
+ return result;
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isString)(result))
+ return $state.target(result, trans.params(), trans.options());
+ if (result['state'] || result['params'])
+ return $state.target(result['state'] || trans.to(), result['params'] || trans.params(), trans.options());
+ }
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isFunction)(redirect)) {
+ return _common_coreservices__WEBPACK_IMPORTED_MODULE_1__.services.$q.when(redirect(trans)).then(handleResult);
+ }
+ return handleResult(redirect);
+};
+var registerRedirectToHook = function (transitionService) {
+ return transitionService.onStart({ to: function (state) { return !!state.redirectTo; } }, redirectToHook);
+};
+//# sourceMappingURL=redirectTo.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/resolve.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/resolve.js ***!
+ \**************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "RESOLVE_HOOK_PRIORITY": () => (/* binding */ RESOLVE_HOOK_PRIORITY),
+/* harmony export */ "registerEagerResolvePath": () => (/* binding */ registerEagerResolvePath),
+/* harmony export */ "registerLazyResolveState": () => (/* binding */ registerLazyResolveState),
+/* harmony export */ "registerResolveRemaining": () => (/* binding */ registerResolveRemaining)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../resolve/resolveContext */ "./node_modules/@uirouter/core/lib-esm/resolve/resolveContext.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+
+
+
+var RESOLVE_HOOK_PRIORITY = 1000;
+/**
+ * A [[TransitionHookFn]] which resolves all EAGER Resolvables in the To Path
+ *
+ * Registered using `transitionService.onStart({}, eagerResolvePath, { priority: 1000 });`
+ *
+ * When a Transition starts, this hook resolves all the EAGER Resolvables, which the transition then waits for.
+ *
+ * See [[StateDeclaration.resolve]]
+ */
+var eagerResolvePath = function (trans) {
+ return new _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_1__.ResolveContext(trans.treeChanges().to).resolvePath('EAGER', trans).then(_common_common__WEBPACK_IMPORTED_MODULE_0__.noop);
+};
+var registerEagerResolvePath = function (transitionService) {
+ return transitionService.onStart({}, eagerResolvePath, { priority: RESOLVE_HOOK_PRIORITY });
+};
+/**
+ * A [[TransitionHookFn]] which resolves all LAZY Resolvables for the state (and all its ancestors) in the To Path
+ *
+ * Registered using `transitionService.onEnter({ entering: () => true }, lazyResolveState, { priority: 1000 });`
+ *
+ * When a State is being entered, this hook resolves all the Resolvables for this state, which the transition then waits for.
+ *
+ * See [[StateDeclaration.resolve]]
+ */
+var lazyResolveState = function (trans, state) {
+ return new _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_1__.ResolveContext(trans.treeChanges().to).subContext(state.$$state()).resolvePath('LAZY', trans).then(_common_common__WEBPACK_IMPORTED_MODULE_0__.noop);
+};
+var registerLazyResolveState = function (transitionService) {
+ return transitionService.onEnter({ entering: (0,_common_hof__WEBPACK_IMPORTED_MODULE_2__.val)(true) }, lazyResolveState, { priority: RESOLVE_HOOK_PRIORITY });
+};
+/**
+ * A [[TransitionHookFn]] which resolves any dynamically added (LAZY or EAGER) Resolvables.
+ *
+ * Registered using `transitionService.onFinish({}, eagerResolvePath, { priority: 1000 });`
+ *
+ * After all entering states have been entered, this hook resolves any remaining Resolvables.
+ * These are typically dynamic resolves which were added by some Transition Hook using [[Transition.addResolvable]].
+ *
+ * See [[StateDeclaration.resolve]]
+ */
+var resolveRemaining = function (trans) {
+ return new _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_1__.ResolveContext(trans.treeChanges().to).resolvePath('LAZY', trans).then(_common_common__WEBPACK_IMPORTED_MODULE_0__.noop);
+};
+var registerResolveRemaining = function (transitionService) {
+ return transitionService.onFinish({}, resolveRemaining, { priority: RESOLVE_HOOK_PRIORITY });
+};
+//# sourceMappingURL=resolve.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/updateGlobals.js":
+/*!********************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/updateGlobals.js ***!
+ \********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "registerUpdateGlobalState": () => (/* binding */ registerUpdateGlobalState)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+
+/**
+ * A [[TransitionHookFn]] which updates global UI-Router state
+ *
+ * Registered using `transitionService.onBefore({}, updateGlobalState);`
+ *
+ * Before a [[Transition]] starts, updates the global value of "the current transition" ([[Globals.transition]]).
+ * After a successful [[Transition]], updates the global values of "the current state"
+ * ([[Globals.current]] and [[Globals.$current]]) and "the current param values" ([[Globals.params]]).
+ *
+ * See also the deprecated properties:
+ * [[StateService.transition]], [[StateService.current]], [[StateService.params]]
+ */
+var updateGlobalState = function (trans) {
+ var globals = trans.router.globals;
+ var transitionSuccessful = function () {
+ globals.successfulTransitions.enqueue(trans);
+ globals.$current = trans.$to();
+ globals.current = globals.$current.self;
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.copy)(trans.params(), globals.params);
+ };
+ var clearCurrentTransition = function () {
+ // Do not clear globals.transition if a different transition has started in the meantime
+ if (globals.transition === trans)
+ globals.transition = null;
+ };
+ trans.onSuccess({}, transitionSuccessful, { priority: 10000 });
+ trans.promise.then(clearCurrentTransition, clearCurrentTransition);
+};
+var registerUpdateGlobalState = function (transitionService) {
+ return transitionService.onCreate({}, updateGlobalState);
+};
+//# sourceMappingURL=updateGlobals.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/url.js":
+/*!**********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/url.js ***!
+ \**********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "registerUpdateUrl": () => (/* binding */ registerUpdateUrl)
+/* harmony export */ });
+/**
+ * A [[TransitionHookFn]] which updates the URL after a successful transition
+ *
+ * Registered using `transitionService.onSuccess({}, updateUrl);`
+ */
+var updateUrl = function (transition) {
+ var options = transition.options();
+ var $state = transition.router.stateService;
+ var $urlRouter = transition.router.urlRouter;
+ // Dont update the url in these situations:
+ // The transition was triggered by a URL sync (options.source === 'url')
+ // The user doesn't want the url to update (options.location === false)
+ // The destination state, and all parents have no navigable url
+ if (options.source !== 'url' && options.location && $state.$current.navigable) {
+ var urlOptions = { replace: options.location === 'replace' };
+ $urlRouter.push($state.$current.navigable.url, $state.params, urlOptions);
+ }
+ $urlRouter.update(true);
+};
+var registerUpdateUrl = function (transitionService) {
+ return transitionService.onSuccess({}, updateUrl, { priority: 9999 });
+};
+//# sourceMappingURL=url.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/hooks/views.js":
+/*!************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/hooks/views.js ***!
+ \************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "registerLoadEnteringViews": () => (/* binding */ registerLoadEnteringViews),
+/* harmony export */ "registerActivateViews": () => (/* binding */ registerActivateViews)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+
+
+/**
+ * A [[TransitionHookFn]] which waits for the views to load
+ *
+ * Registered using `transitionService.onStart({}, loadEnteringViews);`
+ *
+ * Allows the views to do async work in [[ViewConfig.load]] before the transition continues.
+ * In angular 1, this includes loading the templates.
+ */
+var loadEnteringViews = function (transition) {
+ var $q = _common_coreservices__WEBPACK_IMPORTED_MODULE_1__.services.$q;
+ var enteringViews = transition.views('entering');
+ if (!enteringViews.length)
+ return;
+ return $q.all(enteringViews.map(function (view) { return $q.when(view.load()); })).then(_common_common__WEBPACK_IMPORTED_MODULE_0__.noop);
+};
+var registerLoadEnteringViews = function (transitionService) {
+ return transitionService.onFinish({}, loadEnteringViews);
+};
+/**
+ * A [[TransitionHookFn]] which activates the new views when a transition is successful.
+ *
+ * Registered using `transitionService.onSuccess({}, activateViews);`
+ *
+ * After a transition is complete, this hook deactivates the old views from the previous state,
+ * and activates the new views from the destination state.
+ *
+ * See [[ViewService]]
+ */
+var activateViews = function (transition) {
+ var enteringViews = transition.views('entering');
+ var exitingViews = transition.views('exiting');
+ if (!enteringViews.length && !exitingViews.length)
+ return;
+ var $view = transition.router.viewService;
+ exitingViews.forEach(function (vc) { return $view.deactivateViewConfig(vc); });
+ enteringViews.forEach(function (vc) { return $view.activateViewConfig(vc); });
+ $view.sync();
+};
+var registerActivateViews = function (transitionService) {
+ return transitionService.onSuccess({}, activateViews);
+};
+//# sourceMappingURL=views.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/index.js":
+/*!******************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/index.js ***!
+ \******************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "Category": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.Category),
+/* harmony export */ "Glob": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.Glob),
+/* harmony export */ "Queue": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.Queue),
+/* harmony export */ "Trace": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.Trace),
+/* harmony export */ "_extend": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__._extend),
+/* harmony export */ "_inArray": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__._inArray),
+/* harmony export */ "_pushTo": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__._pushTo),
+/* harmony export */ "_removeFrom": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__._removeFrom),
+/* harmony export */ "all": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.all),
+/* harmony export */ "allTrueR": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.allTrueR),
+/* harmony export */ "ancestors": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.ancestors),
+/* harmony export */ "and": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.and),
+/* harmony export */ "any": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.any),
+/* harmony export */ "anyTrueR": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.anyTrueR),
+/* harmony export */ "applyPairs": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.applyPairs),
+/* harmony export */ "arrayTuples": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.arrayTuples),
+/* harmony export */ "assertFn": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.assertFn),
+/* harmony export */ "assertMap": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.assertMap),
+/* harmony export */ "assertPredicate": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.assertPredicate),
+/* harmony export */ "beforeAfterSubstr": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.beforeAfterSubstr),
+/* harmony export */ "compose": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.compose),
+/* harmony export */ "copy": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.copy),
+/* harmony export */ "createProxyFunctions": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.createProxyFunctions),
+/* harmony export */ "curry": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.curry),
+/* harmony export */ "defaults": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.defaults),
+/* harmony export */ "deregAll": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.deregAll),
+/* harmony export */ "eq": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.eq),
+/* harmony export */ "equals": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.equals),
+/* harmony export */ "extend": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.extend),
+/* harmony export */ "filter": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.filter),
+/* harmony export */ "find": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.find),
+/* harmony export */ "flatten": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.flatten),
+/* harmony export */ "flattenR": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.flattenR),
+/* harmony export */ "fnToString": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.fnToString),
+/* harmony export */ "forEach": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.forEach),
+/* harmony export */ "fromJson": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.fromJson),
+/* harmony export */ "functionToString": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.functionToString),
+/* harmony export */ "hostRegex": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.hostRegex),
+/* harmony export */ "identity": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.identity),
+/* harmony export */ "inArray": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.inArray),
+/* harmony export */ "inherit": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.inherit),
+/* harmony export */ "invoke": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.invoke),
+/* harmony export */ "is": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.is),
+/* harmony export */ "isArray": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isArray),
+/* harmony export */ "isDate": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isDate),
+/* harmony export */ "isDefined": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isDefined),
+/* harmony export */ "isFunction": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isFunction),
+/* harmony export */ "isInjectable": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isInjectable),
+/* harmony export */ "isNull": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isNull),
+/* harmony export */ "isNullOrUndefined": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isNullOrUndefined),
+/* harmony export */ "isNumber": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isNumber),
+/* harmony export */ "isObject": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isObject),
+/* harmony export */ "isPromise": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isPromise),
+/* harmony export */ "isRegExp": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isRegExp),
+/* harmony export */ "isString": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isString),
+/* harmony export */ "isUndefined": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.isUndefined),
+/* harmony export */ "joinNeighborsR": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.joinNeighborsR),
+/* harmony export */ "kebobString": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.kebobString),
+/* harmony export */ "makeStub": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.makeStub),
+/* harmony export */ "map": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.map),
+/* harmony export */ "mapObj": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.mapObj),
+/* harmony export */ "maxLength": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.maxLength),
+/* harmony export */ "mergeR": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.mergeR),
+/* harmony export */ "noop": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.noop),
+/* harmony export */ "not": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.not),
+/* harmony export */ "omit": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.omit),
+/* harmony export */ "or": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.or),
+/* harmony export */ "padString": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.padString),
+/* harmony export */ "pairs": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.pairs),
+/* harmony export */ "parse": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.parse),
+/* harmony export */ "pattern": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.pattern),
+/* harmony export */ "pick": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.pick),
+/* harmony export */ "pipe": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.pipe),
+/* harmony export */ "pluck": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.pluck),
+/* harmony export */ "prop": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.prop),
+/* harmony export */ "propEq": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.propEq),
+/* harmony export */ "pushR": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.pushR),
+/* harmony export */ "pushTo": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.pushTo),
+/* harmony export */ "removeFrom": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.removeFrom),
+/* harmony export */ "root": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.root),
+/* harmony export */ "services": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.services),
+/* harmony export */ "silenceUncaughtInPromise": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.silenceUncaughtInPromise),
+/* harmony export */ "silentRejection": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.silentRejection),
+/* harmony export */ "splitEqual": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.splitEqual),
+/* harmony export */ "splitHash": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.splitHash),
+/* harmony export */ "splitOnDelim": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.splitOnDelim),
+/* harmony export */ "splitQuery": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.splitQuery),
+/* harmony export */ "stringify": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.stringify),
+/* harmony export */ "stripLastPathElement": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.stripLastPathElement),
+/* harmony export */ "tail": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.tail),
+/* harmony export */ "toJson": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.toJson),
+/* harmony export */ "trace": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.trace),
+/* harmony export */ "trimHashVal": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.trimHashVal),
+/* harmony export */ "uniqR": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.uniqR),
+/* harmony export */ "unnest": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.unnest),
+/* harmony export */ "unnestR": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.unnestR),
+/* harmony export */ "val": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.val),
+/* harmony export */ "values": () => (/* reexport safe */ _common_index__WEBPACK_IMPORTED_MODULE_0__.values),
+/* harmony export */ "PathNode": () => (/* reexport safe */ _path_index__WEBPACK_IMPORTED_MODULE_2__.PathNode),
+/* harmony export */ "PathUtils": () => (/* reexport safe */ _path_index__WEBPACK_IMPORTED_MODULE_2__.PathUtils),
+/* harmony export */ "NATIVE_INJECTOR_TOKEN": () => (/* reexport safe */ _resolve_index__WEBPACK_IMPORTED_MODULE_3__.NATIVE_INJECTOR_TOKEN),
+/* harmony export */ "Resolvable": () => (/* reexport safe */ _resolve_index__WEBPACK_IMPORTED_MODULE_3__.Resolvable),
+/* harmony export */ "ResolveContext": () => (/* reexport safe */ _resolve_index__WEBPACK_IMPORTED_MODULE_3__.ResolveContext),
+/* harmony export */ "defaultResolvePolicy": () => (/* reexport safe */ _resolve_index__WEBPACK_IMPORTED_MODULE_3__.defaultResolvePolicy),
+/* harmony export */ "resolvePolicies": () => (/* reexport safe */ _resolve_index__WEBPACK_IMPORTED_MODULE_3__.resolvePolicies),
+/* harmony export */ "HookBuilder": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.HookBuilder),
+/* harmony export */ "RegisteredHook": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.RegisteredHook),
+/* harmony export */ "RejectType": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.RejectType),
+/* harmony export */ "Rejection": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.Rejection),
+/* harmony export */ "Transition": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.Transition),
+/* harmony export */ "TransitionEventType": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.TransitionEventType),
+/* harmony export */ "TransitionHook": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.TransitionHook),
+/* harmony export */ "TransitionHookPhase": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.TransitionHookPhase),
+/* harmony export */ "TransitionHookScope": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.TransitionHookScope),
+/* harmony export */ "TransitionService": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.TransitionService),
+/* harmony export */ "defaultTransOpts": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.defaultTransOpts),
+/* harmony export */ "makeEvent": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.makeEvent),
+/* harmony export */ "matchState": () => (/* reexport safe */ _transition_index__WEBPACK_IMPORTED_MODULE_5__.matchState),
+/* harmony export */ "UIRouterGlobals": () => (/* reexport safe */ _globals__WEBPACK_IMPORTED_MODULE_8__.UIRouterGlobals),
+/* harmony export */ "UIRouter": () => (/* reexport safe */ _router__WEBPACK_IMPORTED_MODULE_9__.UIRouter),
+/* harmony export */ "UIRouterPluginBase": () => (/* reexport safe */ _interface__WEBPACK_IMPORTED_MODULE_11__.UIRouterPluginBase)
+/* harmony export */ });
+/* harmony import */ var _common_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common/index */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+/* harmony import */ var _params_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./params/index */ "./node_modules/@uirouter/core/lib-esm/params/index.js");
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _params_index__WEBPACK_IMPORTED_MODULE_1__) if(["default","Category","Glob","Queue","Trace","_extend","_inArray","_pushTo","_removeFrom","all","allTrueR","ancestors","and","any","anyTrueR","applyPairs","arrayTuples","assertFn","assertMap","assertPredicate","beforeAfterSubstr","compose","copy","createProxyFunctions","curry","defaults","deregAll","eq","equals","extend","filter","find","flatten","flattenR","fnToString","forEach","fromJson","functionToString","hostRegex","identity","inArray","inherit","invoke","is","isArray","isDate","isDefined","isFunction","isInjectable","isNull","isNullOrUndefined","isNumber","isObject","isPromise","isRegExp","isString","isUndefined","joinNeighborsR","kebobString","makeStub","map","mapObj","maxLength","mergeR","noop","not","omit","or","padString","pairs","parse","pattern","pick","pipe","pluck","prop","propEq","pushR","pushTo","removeFrom","root","services","silenceUncaughtInPromise","silentRejection","splitEqual","splitHash","splitOnDelim","splitQuery","stringify","stripLastPathElement","tail","toJson","trace","trimHashVal","uniqR","unnest","unnestR","val","values"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _params_index__WEBPACK_IMPORTED_MODULE_1__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _path_index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./path/index */ "./node_modules/@uirouter/core/lib-esm/path/index.js");
+/* harmony import */ var _resolve_index__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./resolve/index */ "./node_modules/@uirouter/core/lib-esm/resolve/index.js");
+/* harmony import */ var _state_index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./state/index */ "./node_modules/@uirouter/core/lib-esm/state/index.js");
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _state_index__WEBPACK_IMPORTED_MODULE_4__) if(["default","Category","Glob","Queue","Trace","_extend","_inArray","_pushTo","_removeFrom","all","allTrueR","ancestors","and","any","anyTrueR","applyPairs","arrayTuples","assertFn","assertMap","assertPredicate","beforeAfterSubstr","compose","copy","createProxyFunctions","curry","defaults","deregAll","eq","equals","extend","filter","find","flatten","flattenR","fnToString","forEach","fromJson","functionToString","hostRegex","identity","inArray","inherit","invoke","is","isArray","isDate","isDefined","isFunction","isInjectable","isNull","isNullOrUndefined","isNumber","isObject","isPromise","isRegExp","isString","isUndefined","joinNeighborsR","kebobString","makeStub","map","mapObj","maxLength","mergeR","noop","not","omit","or","padString","pairs","parse","pattern","pick","pipe","pluck","prop","propEq","pushR","pushTo","removeFrom","root","services","silenceUncaughtInPromise","silentRejection","splitEqual","splitHash","splitOnDelim","splitQuery","stringify","stripLastPathElement","tail","toJson","trace","trimHashVal","uniqR","unnest","unnestR","val","values","DefType","Param","ParamType","ParamTypes","StateParams","PathNode","PathUtils","NATIVE_INJECTOR_TOKEN","Resolvable","ResolveContext","defaultResolvePolicy","resolvePolicies"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _state_index__WEBPACK_IMPORTED_MODULE_4__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _transition_index__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./transition/index */ "./node_modules/@uirouter/core/lib-esm/transition/index.js");
+/* harmony import */ var _url_index__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./url/index */ "./node_modules/@uirouter/core/lib-esm/url/index.js");
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _url_index__WEBPACK_IMPORTED_MODULE_6__) if(["default","Category","Glob","Queue","Trace","_extend","_inArray","_pushTo","_removeFrom","all","allTrueR","ancestors","and","any","anyTrueR","applyPairs","arrayTuples","assertFn","assertMap","assertPredicate","beforeAfterSubstr","compose","copy","createProxyFunctions","curry","defaults","deregAll","eq","equals","extend","filter","find","flatten","flattenR","fnToString","forEach","fromJson","functionToString","hostRegex","identity","inArray","inherit","invoke","is","isArray","isDate","isDefined","isFunction","isInjectable","isNull","isNullOrUndefined","isNumber","isObject","isPromise","isRegExp","isString","isUndefined","joinNeighborsR","kebobString","makeStub","map","mapObj","maxLength","mergeR","noop","not","omit","or","padString","pairs","parse","pattern","pick","pipe","pluck","prop","propEq","pushR","pushTo","removeFrom","root","services","silenceUncaughtInPromise","silentRejection","splitEqual","splitHash","splitOnDelim","splitQuery","stringify","stripLastPathElement","tail","toJson","trace","trimHashVal","uniqR","unnest","unnestR","val","values","DefType","Param","ParamType","ParamTypes","StateParams","PathNode","PathUtils","NATIVE_INJECTOR_TOKEN","Resolvable","ResolveContext","defaultResolvePolicy","resolvePolicies","StateBuilder","StateMatcher","StateObject","StateQueueManager","StateRegistry","StateService","TargetState","resolvablesBuilder","HookBuilder","RegisteredHook","RejectType","Rejection","Transition","TransitionEventType","TransitionHook","TransitionHookPhase","TransitionHookScope","TransitionService","defaultTransOpts","makeEvent","matchState"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _url_index__WEBPACK_IMPORTED_MODULE_6__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _view_index__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./view/index */ "./node_modules/@uirouter/core/lib-esm/view/index.js");
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _view_index__WEBPACK_IMPORTED_MODULE_7__) if(["default","Category","Glob","Queue","Trace","_extend","_inArray","_pushTo","_removeFrom","all","allTrueR","ancestors","and","any","anyTrueR","applyPairs","arrayTuples","assertFn","assertMap","assertPredicate","beforeAfterSubstr","compose","copy","createProxyFunctions","curry","defaults","deregAll","eq","equals","extend","filter","find","flatten","flattenR","fnToString","forEach","fromJson","functionToString","hostRegex","identity","inArray","inherit","invoke","is","isArray","isDate","isDefined","isFunction","isInjectable","isNull","isNullOrUndefined","isNumber","isObject","isPromise","isRegExp","isString","isUndefined","joinNeighborsR","kebobString","makeStub","map","mapObj","maxLength","mergeR","noop","not","omit","or","padString","pairs","parse","pattern","pick","pipe","pluck","prop","propEq","pushR","pushTo","removeFrom","root","services","silenceUncaughtInPromise","silentRejection","splitEqual","splitHash","splitOnDelim","splitQuery","stringify","stripLastPathElement","tail","toJson","trace","trimHashVal","uniqR","unnest","unnestR","val","values","DefType","Param","ParamType","ParamTypes","StateParams","PathNode","PathUtils","NATIVE_INJECTOR_TOKEN","Resolvable","ResolveContext","defaultResolvePolicy","resolvePolicies","StateBuilder","StateMatcher","StateObject","StateQueueManager","StateRegistry","StateService","TargetState","resolvablesBuilder","HookBuilder","RegisteredHook","RejectType","Rejection","Transition","TransitionEventType","TransitionHook","TransitionHookPhase","TransitionHookScope","TransitionService","defaultTransOpts","makeEvent","matchState","BaseUrlRule","ParamFactory","UrlConfig","UrlMatcher","UrlMatcherFactory","UrlRouter","UrlRuleFactory","UrlRules","UrlService"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _view_index__WEBPACK_IMPORTED_MODULE_7__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _globals__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./globals */ "./node_modules/@uirouter/core/lib-esm/globals.js");
+/* harmony import */ var _router__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./router */ "./node_modules/@uirouter/core/lib-esm/router.js");
+/* harmony import */ var _vanilla__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./vanilla */ "./node_modules/@uirouter/core/lib-esm/vanilla.js");
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _vanilla__WEBPACK_IMPORTED_MODULE_10__) if(["default","Category","Glob","Queue","Trace","_extend","_inArray","_pushTo","_removeFrom","all","allTrueR","ancestors","and","any","anyTrueR","applyPairs","arrayTuples","assertFn","assertMap","assertPredicate","beforeAfterSubstr","compose","copy","createProxyFunctions","curry","defaults","deregAll","eq","equals","extend","filter","find","flatten","flattenR","fnToString","forEach","fromJson","functionToString","hostRegex","identity","inArray","inherit","invoke","is","isArray","isDate","isDefined","isFunction","isInjectable","isNull","isNullOrUndefined","isNumber","isObject","isPromise","isRegExp","isString","isUndefined","joinNeighborsR","kebobString","makeStub","map","mapObj","maxLength","mergeR","noop","not","omit","or","padString","pairs","parse","pattern","pick","pipe","pluck","prop","propEq","pushR","pushTo","removeFrom","root","services","silenceUncaughtInPromise","silentRejection","splitEqual","splitHash","splitOnDelim","splitQuery","stringify","stripLastPathElement","tail","toJson","trace","trimHashVal","uniqR","unnest","unnestR","val","values","DefType","Param","ParamType","ParamTypes","StateParams","PathNode","PathUtils","NATIVE_INJECTOR_TOKEN","Resolvable","ResolveContext","defaultResolvePolicy","resolvePolicies","StateBuilder","StateMatcher","StateObject","StateQueueManager","StateRegistry","StateService","TargetState","resolvablesBuilder","HookBuilder","RegisteredHook","RejectType","Rejection","Transition","TransitionEventType","TransitionHook","TransitionHookPhase","TransitionHookScope","TransitionService","defaultTransOpts","makeEvent","matchState","BaseUrlRule","ParamFactory","UrlConfig","UrlMatcher","UrlMatcherFactory","UrlRouter","UrlRuleFactory","UrlRules","UrlService","ViewService","UIRouterGlobals","UIRouter"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _vanilla__WEBPACK_IMPORTED_MODULE_10__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/interface.js");
+
+
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/interface.js":
+/*!**********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/interface.js ***!
+ \**********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UIRouterPluginBase": () => (/* binding */ UIRouterPluginBase)
+/* harmony export */ });
+var UIRouterPluginBase = /** @class */ (function () {
+ function UIRouterPluginBase() {
+ }
+ UIRouterPluginBase.prototype.dispose = function (router) { };
+ return UIRouterPluginBase;
+}());
+
+//# sourceMappingURL=interface.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/params/index.js":
+/*!*************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/params/index.js ***!
+ \*************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "DefType": () => (/* reexport safe */ _param__WEBPACK_IMPORTED_MODULE_1__.DefType),
+/* harmony export */ "Param": () => (/* reexport safe */ _param__WEBPACK_IMPORTED_MODULE_1__.Param),
+/* harmony export */ "ParamTypes": () => (/* reexport safe */ _paramTypes__WEBPACK_IMPORTED_MODULE_2__.ParamTypes),
+/* harmony export */ "StateParams": () => (/* reexport safe */ _stateParams__WEBPACK_IMPORTED_MODULE_3__.StateParams),
+/* harmony export */ "ParamType": () => (/* reexport safe */ _paramType__WEBPACK_IMPORTED_MODULE_4__.ParamType)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/params/interface.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_interface__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _interface__WEBPACK_IMPORTED_MODULE_0__) if(__WEBPACK_IMPORT_KEY__ !== "default") __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _interface__WEBPACK_IMPORTED_MODULE_0__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _param__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./param */ "./node_modules/@uirouter/core/lib-esm/params/param.js");
+/* harmony import */ var _paramTypes__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./paramTypes */ "./node_modules/@uirouter/core/lib-esm/params/paramTypes.js");
+/* harmony import */ var _stateParams__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./stateParams */ "./node_modules/@uirouter/core/lib-esm/params/stateParams.js");
+/* harmony import */ var _paramType__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./paramType */ "./node_modules/@uirouter/core/lib-esm/params/paramType.js");
+/**
+ * This module contains code for State Parameters.
+ *
+ * See [[ParamDeclaration]]
+ *
+ * @packageDocumentation @preferred
+ */
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/params/interface.js":
+/*!*****************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/params/interface.js ***!
+ \*****************************************************************/
+/***/ (() => {
+
+//# sourceMappingURL=interface.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/params/param.js":
+/*!*************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/params/param.js ***!
+ \*************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "DefType": () => (/* binding */ DefType),
+/* harmony export */ "Param": () => (/* binding */ Param)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+/* harmony import */ var _paramType__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./paramType */ "./node_modules/@uirouter/core/lib-esm/params/paramType.js");
+
+
+
+
+
+var hasOwn = Object.prototype.hasOwnProperty;
+var isShorthand = function (cfg) {
+ return ['value', 'type', 'squash', 'array', 'dynamic'].filter(hasOwn.bind(cfg || {})).length === 0;
+};
+var DefType;
+(function (DefType) {
+ DefType[DefType["PATH"] = 0] = "PATH";
+ DefType[DefType["SEARCH"] = 1] = "SEARCH";
+ DefType[DefType["CONFIG"] = 2] = "CONFIG";
+})(DefType || (DefType = {}));
+
+function getParamDeclaration(paramName, location, state) {
+ var noReloadOnSearch = (state.reloadOnSearch === false && location === DefType.SEARCH) || undefined;
+ var dynamic = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.find)([state.dynamic, noReloadOnSearch], _common_predicates__WEBPACK_IMPORTED_MODULE_2__.isDefined);
+ var defaultConfig = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isDefined)(dynamic) ? { dynamic: dynamic } : {};
+ var paramConfig = unwrapShorthand(state && state.params && state.params[paramName]);
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(defaultConfig, paramConfig);
+}
+function unwrapShorthand(cfg) {
+ cfg = isShorthand(cfg) ? { value: cfg } : cfg;
+ getStaticDefaultValue['__cacheable'] = true;
+ function getStaticDefaultValue() {
+ return cfg.value;
+ }
+ var $$fn = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isInjectable)(cfg.value) ? cfg.value : getStaticDefaultValue;
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(cfg, { $$fn: $$fn });
+}
+function getType(cfg, urlType, location, id, paramTypes) {
+ if (cfg.type && urlType && urlType.name !== 'string')
+ throw new Error("Param '" + id + "' has two type configurations.");
+ if (cfg.type && urlType && urlType.name === 'string' && paramTypes.type(cfg.type))
+ return paramTypes.type(cfg.type);
+ if (urlType)
+ return urlType;
+ if (!cfg.type) {
+ var type = location === DefType.CONFIG
+ ? 'any'
+ : location === DefType.PATH
+ ? 'path'
+ : location === DefType.SEARCH
+ ? 'query'
+ : 'string';
+ return paramTypes.type(type);
+ }
+ return cfg.type instanceof _paramType__WEBPACK_IMPORTED_MODULE_4__.ParamType ? cfg.type : paramTypes.type(cfg.type);
+}
+/** returns false, true, or the squash value to indicate the "default parameter url squash policy". */
+function getSquashPolicy(config, isOptional, defaultPolicy) {
+ var squash = config.squash;
+ if (!isOptional || squash === false)
+ return false;
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isDefined)(squash) || squash == null)
+ return defaultPolicy;
+ if (squash === true || (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isString)(squash))
+ return squash;
+ throw new Error("Invalid squash policy: '" + squash + "'. Valid policies: false, true, or arbitrary string");
+}
+function getReplace(config, arrayMode, isOptional, squash) {
+ var defaultPolicy = [
+ { from: '', to: isOptional || arrayMode ? undefined : '' },
+ { from: null, to: isOptional || arrayMode ? undefined : '' },
+ ];
+ var replace = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isArray)(config.replace) ? config.replace : [];
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isString)(squash))
+ replace.push({ from: squash, to: undefined });
+ var configuredKeys = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.map)(replace, (0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.prop)('from'));
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.filter)(defaultPolicy, function (item) { return configuredKeys.indexOf(item.from) === -1; }).concat(replace);
+}
+var Param = /** @class */ (function () {
+ function Param(id, type, location, urlConfig, state) {
+ var config = getParamDeclaration(id, location, state);
+ type = getType(config, type, location, id, urlConfig.paramTypes);
+ var arrayMode = getArrayMode();
+ type = arrayMode ? type.$asArray(arrayMode, location === DefType.SEARCH) : type;
+ var isOptional = config.value !== undefined || location === DefType.SEARCH;
+ var dynamic = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isDefined)(config.dynamic) ? !!config.dynamic : !!type.dynamic;
+ var raw = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isDefined)(config.raw) ? !!config.raw : !!type.raw;
+ var squash = getSquashPolicy(config, isOptional, urlConfig.defaultSquashPolicy());
+ var replace = getReplace(config, arrayMode, isOptional, squash);
+ var inherit = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isDefined)(config.inherit) ? !!config.inherit : !!type.inherit;
+ // array config: param name (param[]) overrides default settings. explicit config overrides param name.
+ function getArrayMode() {
+ var arrayDefaults = { array: location === DefType.SEARCH ? 'auto' : false };
+ var arrayParamNomenclature = id.match(/\[\]$/) ? { array: true } : {};
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(arrayDefaults, arrayParamNomenclature, config).array;
+ }
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(this, { id: id, type: type, location: location, isOptional: isOptional, dynamic: dynamic, raw: raw, squash: squash, replace: replace, inherit: inherit, array: arrayMode, config: config });
+ }
+ Param.values = function (params, values) {
+ if (values === void 0) { values = {}; }
+ var paramValues = {};
+ for (var _i = 0, params_1 = params; _i < params_1.length; _i++) {
+ var param = params_1[_i];
+ paramValues[param.id] = param.value(values[param.id]);
+ }
+ return paramValues;
+ };
+ /**
+ * Finds [[Param]] objects which have different param values
+ *
+ * Filters a list of [[Param]] objects to only those whose parameter values differ in two param value objects
+ *
+ * @param params: The list of Param objects to filter
+ * @param values1: The first set of parameter values
+ * @param values2: the second set of parameter values
+ *
+ * @returns any Param objects whose values were different between values1 and values2
+ */
+ Param.changed = function (params, values1, values2) {
+ if (values1 === void 0) { values1 = {}; }
+ if (values2 === void 0) { values2 = {}; }
+ return params.filter(function (param) { return !param.type.equals(values1[param.id], values2[param.id]); });
+ };
+ /**
+ * Checks if two param value objects are equal (for a set of [[Param]] objects)
+ *
+ * @param params The list of [[Param]] objects to check
+ * @param values1 The first set of param values
+ * @param values2 The second set of param values
+ *
+ * @returns true if the param values in values1 and values2 are equal
+ */
+ Param.equals = function (params, values1, values2) {
+ if (values1 === void 0) { values1 = {}; }
+ if (values2 === void 0) { values2 = {}; }
+ return Param.changed(params, values1, values2).length === 0;
+ };
+ /** Returns true if a the parameter values are valid, according to the Param definitions */
+ Param.validates = function (params, values) {
+ if (values === void 0) { values = {}; }
+ return params.map(function (param) { return param.validates(values[param.id]); }).reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.allTrueR, true);
+ };
+ Param.prototype.isDefaultValue = function (value) {
+ return this.isOptional && this.type.equals(this.value(), value);
+ };
+ /**
+ * [Internal] Gets the decoded representation of a value if the value is defined, otherwise, returns the
+ * default value, which may be the result of an injectable function.
+ */
+ Param.prototype.value = function (value) {
+ var _this = this;
+ /**
+ * [Internal] Get the default value of a parameter, which may be an injectable function.
+ */
+ var getDefaultValue = function () {
+ if (_this._defaultValueCache)
+ return _this._defaultValueCache.defaultValue;
+ if (!_common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$injector)
+ throw new Error('Injectable functions cannot be called at configuration time');
+ var defaultValue = _common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$injector.invoke(_this.config.$$fn);
+ if (defaultValue !== null && defaultValue !== undefined && !_this.type.is(defaultValue))
+ throw new Error("Default value (" + defaultValue + ") for parameter '" + _this.id + "' is not an instance of ParamType (" + _this.type.name + ")");
+ if (_this.config.$$fn['__cacheable']) {
+ _this._defaultValueCache = { defaultValue: defaultValue };
+ }
+ return defaultValue;
+ };
+ var replaceSpecialValues = function (val) {
+ for (var _i = 0, _a = _this.replace; _i < _a.length; _i++) {
+ var tuple = _a[_i];
+ if (tuple.from === val)
+ return tuple.to;
+ }
+ return val;
+ };
+ value = replaceSpecialValues(value);
+ return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isUndefined)(value) ? getDefaultValue() : this.type.$normalize(value);
+ };
+ Param.prototype.isSearch = function () {
+ return this.location === DefType.SEARCH;
+ };
+ Param.prototype.validates = function (value) {
+ // There was no parameter value, but the param is optional
+ if (((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isUndefined)(value) || value === null) && this.isOptional)
+ return true;
+ // The value was not of the correct ParamType, and could not be decoded to the correct ParamType
+ var normalized = this.type.$normalize(value);
+ if (!this.type.is(normalized))
+ return false;
+ // The value was of the correct type, but when encoded, did not match the ParamType's regexp
+ var encoded = this.type.encode(normalized);
+ return !((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isString)(encoded) && !this.type.pattern.exec(encoded));
+ };
+ Param.prototype.toString = function () {
+ return "{Param:" + this.id + " " + this.type + " squash: '" + this.squash + "' optional: " + this.isOptional + "}";
+ };
+ return Param;
+}());
+
+//# sourceMappingURL=param.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/params/paramType.js":
+/*!*****************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/params/paramType.js ***!
+ \*****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "ParamType": () => (/* binding */ ParamType)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+
+
+/**
+ * An internal class which implements [[ParamTypeDefinition]].
+ *
+ * A [[ParamTypeDefinition]] is a plain javascript object used to register custom parameter types.
+ * When a param type definition is registered, an instance of this class is created internally.
+ *
+ * This class has naive implementations for all the [[ParamTypeDefinition]] methods.
+ *
+ * Used by [[UrlMatcher]] when matching or formatting URLs, or comparing and validating parameter values.
+ *
+ * #### Example:
+ * ```js
+ * var paramTypeDef = {
+ * decode: function(val) { return parseInt(val, 10); },
+ * encode: function(val) { return val && val.toString(); },
+ * equals: function(a, b) { return this.is(a) && a === b; },
+ * is: function(val) { return angular.isNumber(val) && isFinite(val) && val % 1 === 0; },
+ * pattern: /\d+/
+ * }
+ *
+ * var paramType = new ParamType(paramTypeDef);
+ * ```
+ */
+var ParamType = /** @class */ (function () {
+ /**
+ * @param def A configuration object which contains the custom type definition. The object's
+ * properties will override the default methods and/or pattern in `ParamType`'s public interface.
+ * @returns a new ParamType object
+ */
+ function ParamType(def) {
+ /** @inheritdoc */
+ this.pattern = /.*/;
+ /** @inheritdoc */
+ this.inherit = true;
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(this, def);
+ }
+ // consider these four methods to be "abstract methods" that should be overridden
+ /** @inheritdoc */
+ ParamType.prototype.is = function (val, key) {
+ return true;
+ };
+ /** @inheritdoc */
+ ParamType.prototype.encode = function (val, key) {
+ return val;
+ };
+ /** @inheritdoc */
+ ParamType.prototype.decode = function (val, key) {
+ return val;
+ };
+ /** @inheritdoc */
+ ParamType.prototype.equals = function (a, b) {
+ // tslint:disable-next-line:triple-equals
+ return a == b;
+ };
+ ParamType.prototype.$subPattern = function () {
+ var sub = this.pattern.toString();
+ return sub.substr(1, sub.length - 2);
+ };
+ ParamType.prototype.toString = function () {
+ return "{ParamType:" + this.name + "}";
+ };
+ /** Given an encoded string, or a decoded object, returns a decoded object */
+ ParamType.prototype.$normalize = function (val) {
+ return this.is(val) ? val : this.decode(val);
+ };
+ /**
+ * Wraps an existing custom ParamType as an array of ParamType, depending on 'mode'.
+ * e.g.:
+ * - urlmatcher pattern "/path?{queryParam[]:int}"
+ * - url: "/path?queryParam=1&queryParam=2
+ * - $stateParams.queryParam will be [1, 2]
+ * if `mode` is "auto", then
+ * - url: "/path?queryParam=1 will create $stateParams.queryParam: 1
+ * - url: "/path?queryParam=1&queryParam=2 will create $stateParams.queryParam: [1, 2]
+ */
+ ParamType.prototype.$asArray = function (mode, isSearch) {
+ if (!mode)
+ return this;
+ if (mode === 'auto' && !isSearch)
+ throw new Error("'auto' array mode is for query parameters only");
+ return new ArrayType(this, mode);
+ };
+ return ParamType;
+}());
+
+/** Wraps up a `ParamType` object to handle array values. */
+function ArrayType(type, mode) {
+ var _this = this;
+ // Wrap non-array value as array
+ function arrayWrap(val) {
+ return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isArray)(val) ? val : (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isDefined)(val) ? [val] : [];
+ }
+ // Unwrap array value for "auto" mode. Return undefined for empty array.
+ function arrayUnwrap(val) {
+ switch (val.length) {
+ case 0:
+ return undefined;
+ case 1:
+ return mode === 'auto' ? val[0] : val;
+ default:
+ return val;
+ }
+ }
+ // Wraps type (.is/.encode/.decode) functions to operate on each value of an array
+ function arrayHandler(callback, allTruthyMode) {
+ return function handleArray(val) {
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isArray)(val) && val.length === 0)
+ return val;
+ var arr = arrayWrap(val);
+ var result = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.map)(arr, callback);
+ return allTruthyMode === true ? (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.filter)(result, function (x) { return !x; }).length === 0 : arrayUnwrap(result);
+ };
+ }
+ // Wraps type (.equals) functions to operate on each value of an array
+ function arrayEqualsHandler(callback) {
+ return function handleArray(val1, val2) {
+ var left = arrayWrap(val1), right = arrayWrap(val2);
+ if (left.length !== right.length)
+ return false;
+ for (var i = 0; i < left.length; i++) {
+ if (!callback(left[i], right[i]))
+ return false;
+ }
+ return true;
+ };
+ }
+ ['encode', 'decode', 'equals', '$normalize'].forEach(function (name) {
+ var paramTypeFn = type[name].bind(type);
+ var wrapperFn = name === 'equals' ? arrayEqualsHandler : arrayHandler;
+ _this[name] = wrapperFn(paramTypeFn);
+ });
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(this, {
+ dynamic: type.dynamic,
+ name: type.name,
+ pattern: type.pattern,
+ inherit: type.inherit,
+ raw: type.raw,
+ is: arrayHandler(type.is.bind(type), true),
+ $arrayMode: mode,
+ });
+}
+//# sourceMappingURL=paramType.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/params/paramTypes.js":
+/*!******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/params/paramTypes.js ***!
+ \******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "ParamTypes": () => (/* binding */ ParamTypes)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+/* harmony import */ var _paramType__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./paramType */ "./node_modules/@uirouter/core/lib-esm/params/paramType.js");
+
+
+
+
+
+/**
+ * A registry for parameter types.
+ *
+ * This registry manages the built-in (and custom) parameter types.
+ *
+ * The built-in parameter types are:
+ *
+ * - [[string]]
+ * - [[path]]
+ * - [[query]]
+ * - [[hash]]
+ * - [[int]]
+ * - [[bool]]
+ * - [[date]]
+ * - [[json]]
+ * - [[any]]
+ *
+ * To register custom parameter types, use [[UrlConfig.type]], i.e.,
+ *
+ * ```js
+ * router.urlService.config.type(customType)
+ * ```
+ */
+var ParamTypes = /** @class */ (function () {
+ function ParamTypes() {
+ this.enqueue = true;
+ this.typeQueue = [];
+ this.defaultTypes = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.pick)(ParamTypes.prototype, [
+ 'hash',
+ 'string',
+ 'query',
+ 'path',
+ 'int',
+ 'bool',
+ 'date',
+ 'json',
+ 'any',
+ ]);
+ // Register default types. Store them in the prototype of this.types.
+ var makeType = function (definition, name) { return new _paramType__WEBPACK_IMPORTED_MODULE_4__.ParamType((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)({ name: name }, definition)); };
+ this.types = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inherit)((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.map)(this.defaultTypes, makeType), {});
+ }
+ ParamTypes.prototype.dispose = function () {
+ this.types = {};
+ };
+ /**
+ * Registers a parameter type
+ *
+ * End users should call [[UrlMatcherFactory.type]], which delegates to this method.
+ */
+ ParamTypes.prototype.type = function (name, definition, definitionFn) {
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isDefined)(definition))
+ return this.types[name];
+ if (this.types.hasOwnProperty(name))
+ throw new Error("A type named '" + name + "' has already been defined.");
+ this.types[name] = new _paramType__WEBPACK_IMPORTED_MODULE_4__.ParamType((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)({ name: name }, definition));
+ if (definitionFn) {
+ this.typeQueue.push({ name: name, def: definitionFn });
+ if (!this.enqueue)
+ this._flushTypeQueue();
+ }
+ return this;
+ };
+ ParamTypes.prototype._flushTypeQueue = function () {
+ while (this.typeQueue.length) {
+ var type = this.typeQueue.shift();
+ if (type.pattern)
+ throw new Error("You cannot override a type's .pattern at runtime.");
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(this.types[type.name], _common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$injector.invoke(type.def));
+ }
+ };
+ return ParamTypes;
+}());
+
+function initDefaultTypes() {
+ var makeDefaultType = function (def) {
+ var valToString = function (val) { return (val != null ? val.toString() : val); };
+ var defaultTypeBase = {
+ encode: valToString,
+ decode: valToString,
+ is: (0,_common_hof__WEBPACK_IMPORTED_MODULE_2__.is)(String),
+ pattern: /.*/,
+ // tslint:disable-next-line:triple-equals
+ equals: function (a, b) { return a == b; },
+ };
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)({}, defaultTypeBase, def);
+ };
+ // Default Parameter Type Definitions
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(ParamTypes.prototype, {
+ string: makeDefaultType({}),
+ path: makeDefaultType({
+ pattern: /[^/]*/,
+ }),
+ query: makeDefaultType({}),
+ hash: makeDefaultType({
+ inherit: false,
+ }),
+ int: makeDefaultType({
+ decode: function (val) { return parseInt(val, 10); },
+ is: function (val) {
+ return !(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isNullOrUndefined)(val) && this.decode(val.toString()) === val;
+ },
+ pattern: /-?\d+/,
+ }),
+ bool: makeDefaultType({
+ encode: function (val) { return (val && 1) || 0; },
+ decode: function (val) { return parseInt(val, 10) !== 0; },
+ is: (0,_common_hof__WEBPACK_IMPORTED_MODULE_2__.is)(Boolean),
+ pattern: /0|1/,
+ }),
+ date: makeDefaultType({
+ encode: function (val) {
+ return !this.is(val)
+ ? undefined
+ : [val.getFullYear(), ('0' + (val.getMonth() + 1)).slice(-2), ('0' + val.getDate()).slice(-2)].join('-');
+ },
+ decode: function (val) {
+ if (this.is(val))
+ return val;
+ var match = this.capture.exec(val);
+ return match ? new Date(match[1], match[2] - 1, match[3]) : undefined;
+ },
+ is: function (val) { return val instanceof Date && !isNaN(val.valueOf()); },
+ equals: function (l, r) {
+ return ['getFullYear', 'getMonth', 'getDate'].reduce(function (acc, fn) { return acc && l[fn]() === r[fn](); }, true);
+ },
+ pattern: /[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[1-2][0-9]|3[0-1])/,
+ capture: /([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/,
+ }),
+ json: makeDefaultType({
+ encode: _common_common__WEBPACK_IMPORTED_MODULE_0__.toJson,
+ decode: _common_common__WEBPACK_IMPORTED_MODULE_0__.fromJson,
+ is: (0,_common_hof__WEBPACK_IMPORTED_MODULE_2__.is)(Object),
+ equals: _common_common__WEBPACK_IMPORTED_MODULE_0__.equals,
+ pattern: /[^/]*/,
+ }),
+ // does not encode/decode
+ any: makeDefaultType({
+ encode: _common_common__WEBPACK_IMPORTED_MODULE_0__.identity,
+ decode: _common_common__WEBPACK_IMPORTED_MODULE_0__.identity,
+ is: function () { return true; },
+ equals: _common_common__WEBPACK_IMPORTED_MODULE_0__.equals,
+ }),
+ });
+}
+initDefaultTypes();
+//# sourceMappingURL=paramTypes.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/params/stateParams.js":
+/*!*******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/params/stateParams.js ***!
+ \*******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "StateParams": () => (/* binding */ StateParams)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+
+var StateParams = /** @class */ (function () {
+ function StateParams(params) {
+ if (params === void 0) { params = {}; }
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(this, params);
+ }
+ /**
+ * Merges a set of parameters with all parameters inherited between the common parents of the
+ * current state and a given destination state.
+ *
+ * @param {Object} newParams The set of parameters which will be composited with inherited params.
+ * @param {Object} $current Internal definition of object representing the current state.
+ * @param {Object} $to Internal definition of object representing state to transition to.
+ */
+ StateParams.prototype.$inherit = function (newParams, $current, $to) {
+ var parentParams;
+ var parents = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.ancestors)($current, $to), inherited = {}, inheritList = [];
+ for (var i in parents) {
+ if (!parents[i] || !parents[i].params)
+ continue;
+ parentParams = Object.keys(parents[i].params);
+ if (!parentParams.length)
+ continue;
+ for (var j in parentParams) {
+ if (inheritList.indexOf(parentParams[j]) >= 0)
+ continue;
+ inheritList.push(parentParams[j]);
+ inherited[parentParams[j]] = this[parentParams[j]];
+ }
+ }
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)({}, inherited, newParams);
+ };
+ return StateParams;
+}());
+
+//# sourceMappingURL=stateParams.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/path/index.js":
+/*!***********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/path/index.js ***!
+ \***********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "PathNode": () => (/* reexport safe */ _pathNode__WEBPACK_IMPORTED_MODULE_0__.PathNode),
+/* harmony export */ "PathUtils": () => (/* reexport safe */ _pathUtils__WEBPACK_IMPORTED_MODULE_1__.PathUtils)
+/* harmony export */ });
+/* harmony import */ var _pathNode__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./pathNode */ "./node_modules/@uirouter/core/lib-esm/path/pathNode.js");
+/* harmony import */ var _pathUtils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./pathUtils */ "./node_modules/@uirouter/core/lib-esm/path/pathUtils.js");
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/path/pathNode.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/path/pathNode.js ***!
+ \**************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "PathNode": () => (/* binding */ PathNode)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _params_param__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../params/param */ "./node_modules/@uirouter/core/lib-esm/params/param.js");
+
+
+
+/**
+ * A node in a [[TreeChanges]] path
+ *
+ * For a [[TreeChanges]] path, this class holds the stateful information for a single node in the path.
+ * Each PathNode corresponds to a state being entered, exited, or retained.
+ * The stateful information includes parameter values and resolve data.
+ */
+var PathNode = /** @class */ (function () {
+ function PathNode(stateOrNode) {
+ if (stateOrNode instanceof PathNode) {
+ var node = stateOrNode;
+ this.state = node.state;
+ this.paramSchema = node.paramSchema.slice();
+ this.paramValues = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)({}, node.paramValues);
+ this.resolvables = node.resolvables.slice();
+ this.views = node.views && node.views.slice();
+ }
+ else {
+ var state = stateOrNode;
+ this.state = state;
+ this.paramSchema = state.parameters({ inherit: false });
+ this.paramValues = {};
+ this.resolvables = state.resolvables.map(function (res) { return res.clone(); });
+ }
+ }
+ PathNode.prototype.clone = function () {
+ return new PathNode(this);
+ };
+ /** Sets [[paramValues]] for the node, from the values of an object hash */
+ PathNode.prototype.applyRawParams = function (params) {
+ var getParamVal = function (paramDef) { return [paramDef.id, paramDef.value(params[paramDef.id])]; };
+ this.paramValues = this.paramSchema.reduce(function (memo, pDef) { return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.applyPairs)(memo, getParamVal(pDef)); }, {});
+ return this;
+ };
+ /** Gets a specific [[Param]] metadata that belongs to the node */
+ PathNode.prototype.parameter = function (name) {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.find)(this.paramSchema, (0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.propEq)('id', name));
+ };
+ /**
+ * @returns true if the state and parameter values for another PathNode are
+ * equal to the state and param values for this PathNode
+ */
+ PathNode.prototype.equals = function (node, paramsFn) {
+ var diff = this.diff(node, paramsFn);
+ return diff && diff.length === 0;
+ };
+ /**
+ * Finds Params with different parameter values on another PathNode.
+ *
+ * Given another node (of the same state), finds the parameter values which differ.
+ * Returns the [[Param]] (schema objects) whose parameter values differ.
+ *
+ * Given another node for a different state, returns `false`
+ *
+ * @param node The node to compare to
+ * @param paramsFn A function that returns which parameters should be compared.
+ * @returns The [[Param]]s which differ, or null if the two nodes are for different states
+ */
+ PathNode.prototype.diff = function (node, paramsFn) {
+ if (this.state !== node.state)
+ return false;
+ var params = paramsFn ? paramsFn(this) : this.paramSchema;
+ return _params_param__WEBPACK_IMPORTED_MODULE_2__.Param.changed(params, this.paramValues, node.paramValues);
+ };
+ /**
+ * Returns a clone of the PathNode
+ * @deprecated use instance method `node.clone()`
+ */
+ PathNode.clone = function (node) { return node.clone(); };
+ return PathNode;
+}());
+
+//# sourceMappingURL=pathNode.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/path/pathUtils.js":
+/*!***************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/path/pathUtils.js ***!
+ \***************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "PathUtils": () => (/* binding */ PathUtils)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _state_targetState__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../state/targetState */ "./node_modules/@uirouter/core/lib-esm/state/targetState.js");
+/* harmony import */ var _pathNode__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./pathNode */ "./node_modules/@uirouter/core/lib-esm/path/pathNode.js");
+
+
+
+
+/**
+ * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
+ */
+var PathUtils = /** @class */ (function () {
+ function PathUtils() {
+ }
+ /** Given a PathNode[], create an TargetState */
+ PathUtils.makeTargetState = function (registry, path) {
+ var state = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.tail)(path).state;
+ return new _state_targetState__WEBPACK_IMPORTED_MODULE_2__.TargetState(registry, state, path.map((0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.prop)('paramValues')).reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.mergeR, {}), {});
+ };
+ PathUtils.buildPath = function (targetState) {
+ var toParams = targetState.params();
+ return targetState.$state().path.map(function (state) { return new _pathNode__WEBPACK_IMPORTED_MODULE_3__.PathNode(state).applyRawParams(toParams); });
+ };
+ /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
+ PathUtils.buildToPath = function (fromPath, targetState) {
+ var toPath = PathUtils.buildPath(targetState);
+ if (targetState.options().inherit) {
+ return PathUtils.inheritParams(fromPath, toPath, Object.keys(targetState.params()));
+ }
+ return toPath;
+ };
+ /**
+ * Creates ViewConfig objects and adds to nodes.
+ *
+ * On each [[PathNode]], creates ViewConfig objects from the views: property of the node's state
+ */
+ PathUtils.applyViewConfigs = function ($view, path, states) {
+ // Only apply the viewConfigs to the nodes for the given states
+ path
+ .filter(function (node) { return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inArray)(states, node.state); })
+ .forEach(function (node) {
+ var viewDecls = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.values)(node.state.views || {});
+ var subPath = PathUtils.subPath(path, function (n) { return n === node; });
+ var viewConfigs = viewDecls.map(function (view) { return $view.createViewConfig(subPath, view); });
+ node.views = viewConfigs.reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, []);
+ });
+ };
+ /**
+ * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath
+ *
+ * For a parameter in a node to be inherited from the from path:
+ * - The toPath's node must have a matching node in the fromPath (by state).
+ * - The parameter name must not be found in the toKeys parameter array.
+ *
+ * Note: the keys provided in toKeys are intended to be those param keys explicitly specified by some
+ * caller, for instance, $state.transitionTo(..., toParams). If a key was found in toParams,
+ * it is not inherited from the fromPath.
+ */
+ PathUtils.inheritParams = function (fromPath, toPath, toKeys) {
+ if (toKeys === void 0) { toKeys = []; }
+ function nodeParamVals(path, state) {
+ var node = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.find)(path, (0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.propEq)('state', state));
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)({}, node && node.paramValues);
+ }
+ var noInherit = fromPath
+ .map(function (node) { return node.paramSchema; })
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .filter(function (param) { return !param.inherit; })
+ .map((0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.prop)('id'));
+ /**
+ * Given an [[PathNode]] "toNode", return a new [[PathNode]] with param values inherited from the
+ * matching node in fromPath. Only inherit keys that aren't found in "toKeys" from the node in "fromPath""
+ */
+ function makeInheritedParamsNode(toNode) {
+ // All param values for the node (may include default key/vals, when key was not found in toParams)
+ var toParamVals = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)({}, toNode && toNode.paramValues);
+ // limited to only those keys found in toParams
+ var incomingParamVals = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.pick)(toParamVals, toKeys);
+ toParamVals = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.omit)(toParamVals, toKeys);
+ var fromParamVals = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.omit)(nodeParamVals(fromPath, toNode.state) || {}, noInherit);
+ // extend toParamVals with any fromParamVals, then override any of those those with incomingParamVals
+ var ownParamVals = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(toParamVals, fromParamVals, incomingParamVals);
+ return new _pathNode__WEBPACK_IMPORTED_MODULE_3__.PathNode(toNode.state).applyRawParams(ownParamVals);
+ }
+ // The param keys specified by the incoming toParams
+ return toPath.map(makeInheritedParamsNode);
+ };
+ /**
+ * Computes the tree changes (entering, exiting) between a fromPath and toPath.
+ */
+ PathUtils.treeChanges = function (fromPath, toPath, reloadState) {
+ var max = Math.min(fromPath.length, toPath.length);
+ var keep = 0;
+ var nodesMatch = function (node1, node2) { return node1.equals(node2, PathUtils.nonDynamicParams); };
+ while (keep < max && fromPath[keep].state !== reloadState && nodesMatch(fromPath[keep], toPath[keep])) {
+ keep++;
+ }
+ /** Given a retained node, return a new node which uses the to node's param values */
+ function applyToParams(retainedNode, idx) {
+ var cloned = retainedNode.clone();
+ cloned.paramValues = toPath[idx].paramValues;
+ return cloned;
+ }
+ var from, retained, exiting, entering, to;
+ from = fromPath;
+ retained = from.slice(0, keep);
+ exiting = from.slice(keep);
+ // Create a new retained path (with shallow copies of nodes) which have the params of the toPath mapped
+ var retainedWithToParams = retained.map(applyToParams);
+ entering = toPath.slice(keep);
+ to = retainedWithToParams.concat(entering);
+ return { from: from, to: to, retained: retained, retainedWithToParams: retainedWithToParams, exiting: exiting, entering: entering };
+ };
+ /**
+ * Returns a new path which is: the subpath of the first path which matches the second path.
+ *
+ * The new path starts from root and contains any nodes that match the nodes in the second path.
+ * It stops before the first non-matching node.
+ *
+ * Nodes are compared using their state property and their parameter values.
+ * If a `paramsFn` is provided, only the [[Param]] returned by the function will be considered when comparing nodes.
+ *
+ * @param pathA the first path
+ * @param pathB the second path
+ * @param paramsFn a function which returns the parameters to consider when comparing
+ *
+ * @returns an array of PathNodes from the first path which match the nodes in the second path
+ */
+ PathUtils.matching = function (pathA, pathB, paramsFn) {
+ var done = false;
+ var tuples = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.arrayTuples)(pathA, pathB);
+ return tuples.reduce(function (matching, _a) {
+ var nodeA = _a[0], nodeB = _a[1];
+ done = done || !nodeA.equals(nodeB, paramsFn);
+ return done ? matching : matching.concat(nodeA);
+ }, []);
+ };
+ /**
+ * Returns true if two paths are identical.
+ *
+ * @param pathA
+ * @param pathB
+ * @param paramsFn a function which returns the parameters to consider when comparing
+ * @returns true if the the states and parameter values for both paths are identical
+ */
+ PathUtils.equals = function (pathA, pathB, paramsFn) {
+ return pathA.length === pathB.length && PathUtils.matching(pathA, pathB, paramsFn).length === pathA.length;
+ };
+ /**
+ * Return a subpath of a path, which stops at the first matching node
+ *
+ * Given an array of nodes, returns a subset of the array starting from the first node,
+ * stopping when the first node matches the predicate.
+ *
+ * @param path a path of [[PathNode]]s
+ * @param predicate a [[Predicate]] fn that matches [[PathNode]]s
+ * @returns a subpath up to the matching node, or undefined if no match is found
+ */
+ PathUtils.subPath = function (path, predicate) {
+ var node = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.find)(path, predicate);
+ var elementIdx = path.indexOf(node);
+ return elementIdx === -1 ? undefined : path.slice(0, elementIdx + 1);
+ };
+ PathUtils.nonDynamicParams = function (node) {
+ return node.state.parameters({ inherit: false }).filter(function (param) { return !param.dynamic; });
+ };
+ /** Gets the raw parameter values from a path */
+ PathUtils.paramValues = function (path) { return path.reduce(function (acc, node) { return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(acc, node.paramValues); }, {}); };
+ return PathUtils;
+}());
+
+//# sourceMappingURL=pathUtils.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/resolve/index.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/resolve/index.js ***!
+ \**************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "resolvePolicies": () => (/* reexport safe */ _interface__WEBPACK_IMPORTED_MODULE_0__.resolvePolicies),
+/* harmony export */ "Resolvable": () => (/* reexport safe */ _resolvable__WEBPACK_IMPORTED_MODULE_1__.Resolvable),
+/* harmony export */ "defaultResolvePolicy": () => (/* reexport safe */ _resolvable__WEBPACK_IMPORTED_MODULE_1__.defaultResolvePolicy),
+/* harmony export */ "NATIVE_INJECTOR_TOKEN": () => (/* reexport safe */ _resolveContext__WEBPACK_IMPORTED_MODULE_2__.NATIVE_INJECTOR_TOKEN),
+/* harmony export */ "ResolveContext": () => (/* reexport safe */ _resolveContext__WEBPACK_IMPORTED_MODULE_2__.ResolveContext)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/resolve/interface.js");
+/* harmony import */ var _resolvable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./resolvable */ "./node_modules/@uirouter/core/lib-esm/resolve/resolvable.js");
+/* harmony import */ var _resolveContext__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./resolveContext */ "./node_modules/@uirouter/core/lib-esm/resolve/resolveContext.js");
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/resolve/interface.js":
+/*!******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/resolve/interface.js ***!
+ \******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "resolvePolicies": () => (/* binding */ resolvePolicies)
+/* harmony export */ });
+var resolvePolicies = {
+ when: {
+ LAZY: 'LAZY',
+ EAGER: 'EAGER',
+ },
+ async: {
+ WAIT: 'WAIT',
+ NOWAIT: 'NOWAIT',
+ },
+};
+//# sourceMappingURL=interface.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/resolve/resolvable.js":
+/*!*******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/resolve/resolvable.js ***!
+ \*******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "defaultResolvePolicy": () => (/* binding */ defaultResolvePolicy),
+/* harmony export */ "Resolvable": () => (/* binding */ Resolvable)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+/* harmony import */ var _common_trace__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/trace */ "./node_modules/@uirouter/core/lib-esm/common/trace.js");
+/* harmony import */ var _common_strings__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+
+
+
+
+
+
+// TODO: explicitly make this user configurable
+var defaultResolvePolicy = {
+ when: 'LAZY',
+ async: 'WAIT',
+};
+/**
+ * The basic building block for the resolve system.
+ *
+ * Resolvables encapsulate a state's resolve's resolveFn, the resolveFn's declared dependencies, the wrapped (.promise),
+ * and the unwrapped-when-complete (.data) result of the resolveFn.
+ *
+ * Resolvable.get() either retrieves the Resolvable's existing promise, or else invokes resolve() (which invokes the
+ * resolveFn) and returns the resulting promise.
+ *
+ * Resolvable.get() and Resolvable.resolve() both execute within a context path, which is passed as the first
+ * parameter to those fns.
+ */
+var Resolvable = /** @class */ (function () {
+ function Resolvable(arg1, resolveFn, deps, policy, data) {
+ this.resolved = false;
+ this.promise = undefined;
+ if (arg1 instanceof Resolvable) {
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(this, arg1);
+ }
+ else if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_4__.isFunction)(resolveFn)) {
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_4__.isNullOrUndefined)(arg1))
+ throw new Error('new Resolvable(): token argument is required');
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_4__.isFunction)(resolveFn))
+ throw new Error('new Resolvable(): resolveFn argument must be a function');
+ this.token = arg1;
+ this.policy = policy;
+ this.resolveFn = resolveFn;
+ this.deps = deps || [];
+ this.data = data;
+ this.resolved = data !== undefined;
+ this.promise = this.resolved ? _common_coreservices__WEBPACK_IMPORTED_MODULE_1__.services.$q.when(this.data) : undefined;
+ }
+ else if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_4__.isObject)(arg1) && arg1.token && (arg1.hasOwnProperty('resolveFn') || arg1.hasOwnProperty('data'))) {
+ var literal = arg1;
+ return new Resolvable(literal.token, literal.resolveFn, literal.deps, literal.policy, literal.data);
+ }
+ }
+ Resolvable.prototype.getPolicy = function (state) {
+ var thisPolicy = this.policy || {};
+ var statePolicy = (state && state.resolvePolicy) || {};
+ return {
+ when: thisPolicy.when || statePolicy.when || defaultResolvePolicy.when,
+ async: thisPolicy.async || statePolicy.async || defaultResolvePolicy.async,
+ };
+ };
+ /**
+ * Asynchronously resolve this Resolvable's data
+ *
+ * Given a ResolveContext that this Resolvable is found in:
+ * Wait for this Resolvable's dependencies, then invoke this Resolvable's function
+ * and update the Resolvable's state
+ */
+ Resolvable.prototype.resolve = function (resolveContext, trans) {
+ var _this = this;
+ var $q = _common_coreservices__WEBPACK_IMPORTED_MODULE_1__.services.$q;
+ // Gets all dependencies from ResolveContext and wait for them to be resolved
+ var getResolvableDependencies = function () {
+ return $q.all(resolveContext.getDependencies(_this).map(function (resolvable) { return resolvable.get(resolveContext, trans); }));
+ };
+ // Invokes the resolve function passing the resolved dependencies as arguments
+ var invokeResolveFn = function (resolvedDeps) { return _this.resolveFn.apply(null, resolvedDeps); };
+ var node = resolveContext.findNode(this);
+ var state = node && node.state;
+ var asyncPolicy = this.getPolicy(state).async;
+ var customAsyncPolicy = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_4__.isFunction)(asyncPolicy) ? asyncPolicy : _common_common__WEBPACK_IMPORTED_MODULE_0__.identity;
+ // After the final value has been resolved, update the state of the Resolvable
+ var applyResolvedValue = function (resolvedValue) {
+ _this.data = resolvedValue;
+ _this.resolved = true;
+ _this.resolveFn = null;
+ _common_trace__WEBPACK_IMPORTED_MODULE_2__.trace.traceResolvableResolved(_this, trans);
+ return _this.data;
+ };
+ // Sets the promise property first, then getsResolvableDependencies in the context of the promise chain. Always waits one tick.
+ return (this.promise = $q
+ .when()
+ .then(getResolvableDependencies)
+ .then(invokeResolveFn)
+ .then(customAsyncPolicy)
+ .then(applyResolvedValue));
+ };
+ /**
+ * Gets a promise for this Resolvable's data.
+ *
+ * Fetches the data and returns a promise.
+ * Returns the existing promise if it has already been fetched once.
+ */
+ Resolvable.prototype.get = function (resolveContext, trans) {
+ return this.promise || this.resolve(resolveContext, trans);
+ };
+ Resolvable.prototype.toString = function () {
+ return "Resolvable(token: " + (0,_common_strings__WEBPACK_IMPORTED_MODULE_3__.stringify)(this.token) + ", requires: [" + this.deps.map(_common_strings__WEBPACK_IMPORTED_MODULE_3__.stringify) + "])";
+ };
+ Resolvable.prototype.clone = function () {
+ return new Resolvable(this);
+ };
+ Resolvable.fromData = function (token, data) { return new Resolvable(token, function () { return data; }, null, null, data); };
+ return Resolvable;
+}());
+
+//# sourceMappingURL=resolvable.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/resolve/resolveContext.js":
+/*!***********************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/resolve/resolveContext.js ***!
+ \***********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "NATIVE_INJECTOR_TOKEN": () => (/* binding */ NATIVE_INJECTOR_TOKEN),
+/* harmony export */ "ResolveContext": () => (/* binding */ ResolveContext)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _common_trace__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/trace */ "./node_modules/@uirouter/core/lib-esm/common/trace.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/resolve/interface.js");
+/* harmony import */ var _resolvable__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./resolvable */ "./node_modules/@uirouter/core/lib-esm/resolve/resolvable.js");
+/* harmony import */ var _path_pathUtils__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../path/pathUtils */ "./node_modules/@uirouter/core/lib-esm/path/pathUtils.js");
+/* harmony import */ var _common_strings__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../common/strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+
+
+
+
+
+
+
+
+var whens = _interface__WEBPACK_IMPORTED_MODULE_4__.resolvePolicies.when;
+var ALL_WHENS = [whens.EAGER, whens.LAZY];
+var EAGER_WHENS = [whens.EAGER];
+// tslint:disable-next-line:no-inferrable-types
+var NATIVE_INJECTOR_TOKEN = 'Native Injector';
+/**
+ * Encapsulates Dependency Injection for a path of nodes
+ *
+ * UI-Router states are organized as a tree.
+ * A nested state has a path of ancestors to the root of the tree.
+ * When a state is being activated, each element in the path is wrapped as a [[PathNode]].
+ * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.
+ *
+ * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.
+ */
+var ResolveContext = /** @class */ (function () {
+ function ResolveContext(_path) {
+ this._path = _path;
+ }
+ /** Gets all the tokens found in the resolve context, de-duplicated */
+ ResolveContext.prototype.getTokens = function () {
+ return this._path.reduce(function (acc, node) { return acc.concat(node.resolvables.map(function (r) { return r.token; })); }, []).reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.uniqR, []);
+ };
+ /**
+ * Gets the Resolvable that matches the token
+ *
+ * Gets the last Resolvable that matches the token in this context, or undefined.
+ * Throws an error if it doesn't exist in the ResolveContext
+ */
+ ResolveContext.prototype.getResolvable = function (token) {
+ var matching = this._path
+ .map(function (node) { return node.resolvables; })
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .filter(function (r) { return r.token === token; });
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.tail)(matching);
+ };
+ /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
+ ResolveContext.prototype.getPolicy = function (resolvable) {
+ var node = this.findNode(resolvable);
+ return resolvable.getPolicy(node.state);
+ };
+ /**
+ * Returns a ResolveContext that includes a portion of this one
+ *
+ * Given a state, this method creates a new ResolveContext from this one.
+ * The new context starts at the first node (root) and stops at the node for the `state` parameter.
+ *
+ * #### Why
+ *
+ * When a transition is created, the nodes in the "To Path" are injected from a ResolveContext.
+ * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.
+ * The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).
+ * This method is used to create a narrower context when injecting ancestor nodes.
+ *
+ * @example
+ * `let ABCD = new ResolveContext([A, B, C, D]);`
+ *
+ * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
+ * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
+ * However, `B` should only be able to access resolvables from `A`, `B`.
+ *
+ * When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
+ * `let AB = ABCD.subcontext(a)`
+ */
+ ResolveContext.prototype.subContext = function (state) {
+ return new ResolveContext(_path_pathUtils__WEBPACK_IMPORTED_MODULE_6__.PathUtils.subPath(this._path, function (node) { return node.state === state; }));
+ };
+ /**
+ * Adds Resolvables to the node that matches the state
+ *
+ * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).
+ * The resolvable is added to the node matching the `state` parameter.
+ *
+ * These new resolvables are not automatically fetched.
+ * The calling code should either fetch them, fetch something that depends on them,
+ * or rely on [[resolvePath]] being called when some state is being entered.
+ *
+ * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
+ *
+ * @param newResolvables the new Resolvables
+ * @param state Used to find the node to put the resolvable on
+ */
+ ResolveContext.prototype.addResolvables = function (newResolvables, state) {
+ var node = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.find)(this._path, (0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.propEq)('state', state));
+ var keys = newResolvables.map(function (r) { return r.token; });
+ node.resolvables = node.resolvables.filter(function (r) { return keys.indexOf(r.token) === -1; }).concat(newResolvables);
+ };
+ /**
+ * Returns a promise for an array of resolved path Element promises
+ *
+ * @param when
+ * @param trans
+ * @returns {Promise<any>|any}
+ */
+ ResolveContext.prototype.resolvePath = function (when, trans) {
+ var _this = this;
+ if (when === void 0) { when = 'LAZY'; }
+ // This option determines which 'when' policy Resolvables we are about to fetch.
+ var whenOption = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inArray)(ALL_WHENS, when) ? when : 'LAZY';
+ // If the caller specified EAGER, only the EAGER Resolvables are fetched.
+ // if the caller specified LAZY, both EAGER and LAZY Resolvables are fetched.`
+ var matchedWhens = whenOption === _interface__WEBPACK_IMPORTED_MODULE_4__.resolvePolicies.when.EAGER ? EAGER_WHENS : ALL_WHENS;
+ // get the subpath to the state argument, if provided
+ _common_trace__WEBPACK_IMPORTED_MODULE_2__.trace.traceResolvePath(this._path, when, trans);
+ var matchesPolicy = function (acceptedVals, whenOrAsync) { return function (resolvable) {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inArray)(acceptedVals, _this.getPolicy(resolvable)[whenOrAsync]);
+ }; };
+ // Trigger all the (matching) Resolvables in the path
+ // Reduce all the "WAIT" Resolvables into an array
+ var promises = this._path.reduce(function (acc, node) {
+ var nodeResolvables = node.resolvables.filter(matchesPolicy(matchedWhens, 'when'));
+ var nowait = nodeResolvables.filter(matchesPolicy(['NOWAIT'], 'async'));
+ var wait = nodeResolvables.filter((0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.not)(matchesPolicy(['NOWAIT'], 'async')));
+ // For the matching Resolvables, start their async fetch process.
+ var subContext = _this.subContext(node.state);
+ var getResult = function (r) {
+ return r
+ .get(subContext, trans)
+ // Return a tuple that includes the Resolvable's token
+ .then(function (value) { return ({ token: r.token, value: value }); });
+ };
+ nowait.forEach(getResult);
+ return acc.concat(wait.map(getResult));
+ }, []);
+ // Wait for all the "WAIT" resolvables
+ return _common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$q.all(promises);
+ };
+ ResolveContext.prototype.injector = function () {
+ return this._injector || (this._injector = new UIInjectorImpl(this));
+ };
+ ResolveContext.prototype.findNode = function (resolvable) {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.find)(this._path, function (node) { return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inArray)(node.resolvables, resolvable); });
+ };
+ /**
+ * Gets the async dependencies of a Resolvable
+ *
+ * Given a Resolvable, returns its dependencies as a Resolvable[]
+ */
+ ResolveContext.prototype.getDependencies = function (resolvable) {
+ var _this = this;
+ var node = this.findNode(resolvable);
+ // Find which other resolvables are "visible" to the `resolvable` argument
+ // subpath stopping at resolvable's node, or the whole path (if the resolvable isn't in the path)
+ var subPath = _path_pathUtils__WEBPACK_IMPORTED_MODULE_6__.PathUtils.subPath(this._path, function (x) { return x === node; }) || this._path;
+ var availableResolvables = subPath
+ .reduce(function (acc, _node) { return acc.concat(_node.resolvables); }, []) // all of subpath's resolvables
+ .filter(function (res) { return res !== resolvable; }); // filter out the `resolvable` argument
+ var getDependency = function (token) {
+ var matching = availableResolvables.filter(function (r) { return r.token === token; });
+ if (matching.length)
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.tail)(matching);
+ var fromInjector = _this.injector().getNative(token);
+ if ((0,_common__WEBPACK_IMPORTED_MODULE_8__.isUndefined)(fromInjector)) {
+ throw new Error('Could not find Dependency Injection token: ' + (0,_common_strings__WEBPACK_IMPORTED_MODULE_7__.stringify)(token));
+ }
+ return new _resolvable__WEBPACK_IMPORTED_MODULE_5__.Resolvable(token, function () { return fromInjector; }, [], fromInjector);
+ };
+ return resolvable.deps.map(getDependency);
+ };
+ return ResolveContext;
+}());
+
+/** @internal */
+var UIInjectorImpl = /** @class */ (function () {
+ function UIInjectorImpl(context) {
+ this.context = context;
+ this.native = this.get(NATIVE_INJECTOR_TOKEN) || _common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$injector;
+ }
+ UIInjectorImpl.prototype.get = function (token) {
+ var resolvable = this.context.getResolvable(token);
+ if (resolvable) {
+ if (this.context.getPolicy(resolvable).async === 'NOWAIT') {
+ return resolvable.get(this.context);
+ }
+ if (!resolvable.resolved) {
+ throw new Error('Resolvable async .get() not complete:' + (0,_common_strings__WEBPACK_IMPORTED_MODULE_7__.stringify)(resolvable.token));
+ }
+ return resolvable.data;
+ }
+ return this.getNative(token);
+ };
+ UIInjectorImpl.prototype.getAsync = function (token) {
+ var resolvable = this.context.getResolvable(token);
+ if (resolvable)
+ return resolvable.get(this.context);
+ return _common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$q.when(this.native.get(token));
+ };
+ UIInjectorImpl.prototype.getNative = function (token) {
+ return this.native && this.native.get(token);
+ };
+ return UIInjectorImpl;
+}());
+//# sourceMappingURL=resolveContext.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/router.js":
+/*!*******************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/router.js ***!
+ \*******************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UIRouter": () => (/* binding */ UIRouter)
+/* harmony export */ });
+/* harmony import */ var _url_urlMatcherFactory__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./url/urlMatcherFactory */ "./node_modules/@uirouter/core/lib-esm/url/urlMatcherFactory.js");
+/* harmony import */ var _url_urlRouter__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./url/urlRouter */ "./node_modules/@uirouter/core/lib-esm/url/urlRouter.js");
+/* harmony import */ var _transition_transitionService__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./transition/transitionService */ "./node_modules/@uirouter/core/lib-esm/transition/transitionService.js");
+/* harmony import */ var _view_view__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./view/view */ "./node_modules/@uirouter/core/lib-esm/view/view.js");
+/* harmony import */ var _state_stateRegistry__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./state/stateRegistry */ "./node_modules/@uirouter/core/lib-esm/state/stateRegistry.js");
+/* harmony import */ var _state_stateService__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./state/stateService */ "./node_modules/@uirouter/core/lib-esm/state/stateService.js");
+/* harmony import */ var _globals__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./globals */ "./node_modules/@uirouter/core/lib-esm/globals.js");
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _url_urlService__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./url/urlService */ "./node_modules/@uirouter/core/lib-esm/url/urlService.js");
+/* harmony import */ var _common_trace__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./common/trace */ "./node_modules/@uirouter/core/lib-esm/common/trace.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+
+
+
+
+
+
+
+
+
+
+
+/** @internal */
+var _routerInstance = 0;
+/** @internal */
+var locSvcFns = ['url', 'path', 'search', 'hash', 'onChange'];
+/** @internal */
+var locCfgFns = ['port', 'protocol', 'host', 'baseHref', 'html5Mode', 'hashPrefix'];
+/** @internal */
+var locationServiceStub = (0,_common__WEBPACK_IMPORTED_MODULE_11__.makeStub)('LocationServices', locSvcFns);
+/** @internal */
+var locationConfigStub = (0,_common__WEBPACK_IMPORTED_MODULE_11__.makeStub)('LocationConfig', locCfgFns);
+/**
+ * An instance of UI-Router.
+ *
+ * This object contains references to service APIs which define your application's routing behavior.
+ */
+var UIRouter = /** @class */ (function () {
+ /**
+ * Creates a new `UIRouter` object
+ *
+ * @param locationService a [[LocationServices]] implementation
+ * @param locationConfig a [[LocationConfig]] implementation
+ * @internal
+ */
+ function UIRouter(locationService, locationConfig) {
+ if (locationService === void 0) { locationService = locationServiceStub; }
+ if (locationConfig === void 0) { locationConfig = locationConfigStub; }
+ this.locationService = locationService;
+ this.locationConfig = locationConfig;
+ /** @internal */ this.$id = _routerInstance++;
+ /** @internal */ this._disposed = false;
+ /** @internal */ this._disposables = [];
+ /** Enable/disable tracing to the javascript console */
+ this.trace = _common_trace__WEBPACK_IMPORTED_MODULE_10__.trace;
+ /** Provides services related to ui-view synchronization */
+ this.viewService = new _view_view__WEBPACK_IMPORTED_MODULE_3__.ViewService(this);
+ /** An object that contains global router state, such as the current state and params */
+ this.globals = new _globals__WEBPACK_IMPORTED_MODULE_6__.UIRouterGlobals();
+ /** A service that exposes global Transition Hooks */
+ this.transitionService = new _transition_transitionService__WEBPACK_IMPORTED_MODULE_2__.TransitionService(this);
+ /**
+ * Deprecated for public use. Use [[urlService]] instead.
+ * @deprecated Use [[urlService]] instead
+ */
+ this.urlMatcherFactory = new _url_urlMatcherFactory__WEBPACK_IMPORTED_MODULE_0__.UrlMatcherFactory(this);
+ /**
+ * Deprecated for public use. Use [[urlService]] instead.
+ * @deprecated Use [[urlService]] instead
+ */
+ this.urlRouter = new _url_urlRouter__WEBPACK_IMPORTED_MODULE_1__.UrlRouter(this);
+ /** Provides services related to the URL */
+ this.urlService = new _url_urlService__WEBPACK_IMPORTED_MODULE_9__.UrlService(this);
+ /** Provides a registry for states, and related registration services */
+ this.stateRegistry = new _state_stateRegistry__WEBPACK_IMPORTED_MODULE_4__.StateRegistry(this);
+ /** Provides services related to states */
+ this.stateService = new _state_stateService__WEBPACK_IMPORTED_MODULE_5__.StateService(this);
+ /** @internal plugin instances are registered here */
+ this._plugins = {};
+ this.viewService._pluginapi._rootViewContext(this.stateRegistry.root());
+ this.globals.$current = this.stateRegistry.root();
+ this.globals.current = this.globals.$current.self;
+ this.disposable(this.globals);
+ this.disposable(this.stateService);
+ this.disposable(this.stateRegistry);
+ this.disposable(this.transitionService);
+ this.disposable(this.urlService);
+ this.disposable(locationService);
+ this.disposable(locationConfig);
+ }
+ /** Registers an object to be notified when the router is disposed */
+ UIRouter.prototype.disposable = function (disposable) {
+ this._disposables.push(disposable);
+ };
+ /**
+ * Disposes this router instance
+ *
+ * When called, clears resources retained by the router by calling `dispose(this)` on all
+ * registered [[disposable]] objects.
+ *
+ * Or, if a `disposable` object is provided, calls `dispose(this)` on that object only.
+ *
+ * @internal
+ * @param disposable (optional) the disposable to dispose
+ */
+ UIRouter.prototype.dispose = function (disposable) {
+ var _this = this;
+ if (disposable && (0,_common_predicates__WEBPACK_IMPORTED_MODULE_8__.isFunction)(disposable.dispose)) {
+ disposable.dispose(this);
+ return undefined;
+ }
+ this._disposed = true;
+ this._disposables.slice().forEach(function (d) {
+ try {
+ typeof d.dispose === 'function' && d.dispose(_this);
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_7__.removeFrom)(_this._disposables, d);
+ }
+ catch (ignored) { }
+ });
+ };
+ /**
+ * Adds a plugin to UI-Router
+ *
+ * This method adds a UI-Router Plugin.
+ * A plugin can enhance or change UI-Router behavior using any public API.
+ *
+ * #### Example:
+ * ```js
+ * import { MyCoolPlugin } from "ui-router-cool-plugin";
+ *
+ * var plugin = router.addPlugin(MyCoolPlugin);
+ * ```
+ *
+ * ### Plugin authoring
+ *
+ * A plugin is simply a class (or constructor function) which accepts a [[UIRouter]] instance and (optionally) an options object.
+ *
+ * The plugin can implement its functionality using any of the public APIs of [[UIRouter]].
+ * For example, it may configure router options or add a Transition Hook.
+ *
+ * The plugin can then be published as a separate module.
+ *
+ * #### Example:
+ * ```js
+ * export class MyAuthPlugin implements UIRouterPlugin {
+ * constructor(router: UIRouter, options: any) {
+ * this.name = "MyAuthPlugin";
+ * let $transitions = router.transitionService;
+ * let $state = router.stateService;
+ *
+ * let authCriteria = {
+ * to: (state) => state.data && state.data.requiresAuth
+ * };
+ *
+ * function authHook(transition: Transition) {
+ * let authService = transition.injector().get('AuthService');
+ * if (!authService.isAuthenticated()) {
+ * return $state.target('login');
+ * }
+ * }
+ *
+ * $transitions.onStart(authCriteria, authHook);
+ * }
+ * }
+ * ```
+ *
+ * @param plugin one of:
+ * - a plugin class which implements [[UIRouterPlugin]]
+ * - a constructor function for a [[UIRouterPlugin]] which accepts a [[UIRouter]] instance
+ * - a factory function which accepts a [[UIRouter]] instance and returns a [[UIRouterPlugin]] instance
+ * @param options options to pass to the plugin class/factory
+ * @returns the registered plugin instance
+ */
+ UIRouter.prototype.plugin = function (plugin, options) {
+ if (options === void 0) { options = {}; }
+ var pluginInstance = new plugin(this, options);
+ if (!pluginInstance.name)
+ throw new Error('Required property `name` missing on plugin: ' + pluginInstance);
+ this._disposables.push(pluginInstance);
+ return (this._plugins[pluginInstance.name] = pluginInstance);
+ };
+ UIRouter.prototype.getPlugin = function (pluginName) {
+ return pluginName ? this._plugins[pluginName] : (0,_common_common__WEBPACK_IMPORTED_MODULE_7__.values)(this._plugins);
+ };
+ return UIRouter;
+}());
+
+//# sourceMappingURL=router.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/state/index.js":
+/*!************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/state/index.js ***!
+ \************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "StateBuilder": () => (/* reexport safe */ _stateBuilder__WEBPACK_IMPORTED_MODULE_1__.StateBuilder),
+/* harmony export */ "resolvablesBuilder": () => (/* reexport safe */ _stateBuilder__WEBPACK_IMPORTED_MODULE_1__.resolvablesBuilder),
+/* harmony export */ "StateObject": () => (/* reexport safe */ _stateObject__WEBPACK_IMPORTED_MODULE_2__.StateObject),
+/* harmony export */ "StateMatcher": () => (/* reexport safe */ _stateMatcher__WEBPACK_IMPORTED_MODULE_3__.StateMatcher),
+/* harmony export */ "StateQueueManager": () => (/* reexport safe */ _stateQueueManager__WEBPACK_IMPORTED_MODULE_4__.StateQueueManager),
+/* harmony export */ "StateRegistry": () => (/* reexport safe */ _stateRegistry__WEBPACK_IMPORTED_MODULE_5__.StateRegistry),
+/* harmony export */ "StateService": () => (/* reexport safe */ _stateService__WEBPACK_IMPORTED_MODULE_6__.StateService),
+/* harmony export */ "TargetState": () => (/* reexport safe */ _targetState__WEBPACK_IMPORTED_MODULE_7__.TargetState)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/state/interface.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_interface__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _interface__WEBPACK_IMPORTED_MODULE_0__) if(__WEBPACK_IMPORT_KEY__ !== "default") __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _interface__WEBPACK_IMPORTED_MODULE_0__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _stateBuilder__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stateBuilder */ "./node_modules/@uirouter/core/lib-esm/state/stateBuilder.js");
+/* harmony import */ var _stateObject__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./stateObject */ "./node_modules/@uirouter/core/lib-esm/state/stateObject.js");
+/* harmony import */ var _stateMatcher__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./stateMatcher */ "./node_modules/@uirouter/core/lib-esm/state/stateMatcher.js");
+/* harmony import */ var _stateQueueManager__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./stateQueueManager */ "./node_modules/@uirouter/core/lib-esm/state/stateQueueManager.js");
+/* harmony import */ var _stateRegistry__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./stateRegistry */ "./node_modules/@uirouter/core/lib-esm/state/stateRegistry.js");
+/* harmony import */ var _stateService__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./stateService */ "./node_modules/@uirouter/core/lib-esm/state/stateService.js");
+/* harmony import */ var _targetState__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./targetState */ "./node_modules/@uirouter/core/lib-esm/state/targetState.js");
+/**
+ * # The state subsystem
+ *
+ * This subsystem implements the ui-router state tree
+ *
+ * - The [[StateService]] has state-related service methods such as:
+ * - [[StateService.get]]: Get a registered [[StateDeclaration]] object
+ * - [[StateService.go]]: Transition from the current state to a new state
+ * - [[StateService.reload]]: Reload the current state
+ * - [[StateService.target]]: Get a [[TargetState]] (useful when redirecting from a Transition Hook)
+ * - [[StateService.onInvalid]]: Register a callback for when a transition to an invalid state is started
+ * - [[StateService.defaultErrorHandler]]: Register a global callback for when a transition errors
+ * - The [[StateDeclaration]] interface defines the shape of a state declaration
+ * - The [[StateRegistry]] contains all the registered states
+ * - States can be added/removed using the [[StateRegistry.register]] and [[StateRegistry.deregister]]
+ * - Note: Bootstrap state registration differs by front-end framework.
+ * - Get notified of state registration/deregistration using [[StateRegistry.onStatesChanged]].
+ *
+ * @packageDocumentation
+ */
+
+
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/state/interface.js":
+/*!****************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/state/interface.js ***!
+ \****************************************************************/
+/***/ (() => {
+
+//# sourceMappingURL=interface.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/state/stateBuilder.js":
+/*!*******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/state/stateBuilder.js ***!
+ \*******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "resolvablesBuilder": () => (/* binding */ resolvablesBuilder),
+/* harmony export */ "StateBuilder": () => (/* binding */ StateBuilder)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_strings__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../resolve/resolvable */ "./node_modules/@uirouter/core/lib-esm/resolve/resolvable.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+
+
+
+
+
+
+var parseUrl = function (url) {
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(url))
+ return false;
+ var root = url.charAt(0) === '^';
+ return { val: root ? url.substring(1) : url, root: root };
+};
+function nameBuilder(state) {
+ return state.name;
+}
+function selfBuilder(state) {
+ state.self.$$state = function () { return state; };
+ return state.self;
+}
+function dataBuilder(state) {
+ if (state.parent && state.parent.data) {
+ state.data = state.self.data = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inherit)(state.parent.data, state.data);
+ }
+ return state.data;
+}
+var getUrlBuilder = function ($urlMatcherFactoryProvider, root) {
+ return function urlBuilder(stateObject) {
+ var stateDec = stateObject.self;
+ // For future states, i.e., states whose name ends with `.**`,
+ // match anything that starts with the url prefix
+ if (stateDec && stateDec.url && stateDec.name && stateDec.name.match(/\.\*\*$/)) {
+ var newStateDec = {};
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.copy)(stateDec, newStateDec);
+ newStateDec.url += '{remainder:any}'; // match any path (.*)
+ stateDec = newStateDec;
+ }
+ var parent = stateObject.parent;
+ var parsed = parseUrl(stateDec.url);
+ var url = !parsed ? stateDec.url : $urlMatcherFactoryProvider.compile(parsed.val, { state: stateDec });
+ if (!url)
+ return null;
+ if (!$urlMatcherFactoryProvider.isMatcher(url))
+ throw new Error("Invalid url '" + url + "' in state '" + stateObject + "'");
+ return parsed && parsed.root ? url : ((parent && parent.navigable) || root()).url.append(url);
+ };
+};
+var getNavigableBuilder = function (isRoot) {
+ return function navigableBuilder(state) {
+ return !isRoot(state) && state.url ? state : state.parent ? state.parent.navigable : null;
+ };
+};
+var getParamsBuilder = function (paramFactory) {
+ return function paramsBuilder(state) {
+ var makeConfigParam = function (config, id) { return paramFactory.fromConfig(id, null, state.self); };
+ var urlParams = (state.url && state.url.parameters({ inherit: false })) || [];
+ var nonUrlParams = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.values)((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.mapObj)((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.omit)(state.params || {}, urlParams.map((0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.prop)('id'))), makeConfigParam));
+ return urlParams
+ .concat(nonUrlParams)
+ .map(function (p) { return [p.id, p]; })
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.applyPairs, {});
+ };
+};
+function pathBuilder(state) {
+ return state.parent ? state.parent.path.concat(state) : /*root*/ [state];
+}
+function includesBuilder(state) {
+ var includes = state.parent ? (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)({}, state.parent.includes) : {};
+ includes[state.name] = true;
+ return includes;
+}
+/**
+ * This is a [[StateBuilder.builder]] function for the `resolve:` block on a [[StateDeclaration]].
+ *
+ * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+ * validates the `resolve` property and converts it to a [[Resolvable]] array.
+ *
+ * resolve: input value can be:
+ *
+ * {
+ * // analyzed but not injected
+ * myFooResolve: function() { return "myFooData"; },
+ *
+ * // function.toString() parsed, "DependencyName" dep as string (not min-safe)
+ * myBarResolve: function(DependencyName) { return DependencyName.fetchSomethingAsPromise() },
+ *
+ * // Array split; "DependencyName" dep as string
+ * myBazResolve: [ "DependencyName", function(dep) { return dep.fetchSomethingAsPromise() },
+ *
+ * // Array split; DependencyType dep as token (compared using ===)
+ * myQuxResolve: [ DependencyType, function(dep) { return dep.fetchSometingAsPromise() },
+ *
+ * // val.$inject used as deps
+ * // where:
+ * // corgeResolve.$inject = ["DependencyName"];
+ * // function corgeResolve(dep) { dep.fetchSometingAsPromise() }
+ * // then "DependencyName" dep as string
+ * myCorgeResolve: corgeResolve,
+ *
+ * // inject service by name
+ * // When a string is found, desugar creating a resolve that injects the named service
+ * myGraultResolve: "SomeService"
+ * }
+ *
+ * or:
+ *
+ * [
+ * new Resolvable("myFooResolve", function() { return "myFooData" }),
+ * new Resolvable("myBarResolve", function(dep) { return dep.fetchSomethingAsPromise() }, [ "DependencyName" ]),
+ * { provide: "myBazResolve", useFactory: function(dep) { dep.fetchSomethingAsPromise() }, deps: [ "DependencyName" ] }
+ * ]
+ */
+function resolvablesBuilder(state) {
+ /** convert resolve: {} and resolvePolicy: {} objects to an array of tuples */
+ var objects2Tuples = function (resolveObj, resolvePolicies) {
+ return Object.keys(resolveObj || {}).map(function (token) { return ({
+ token: token,
+ val: resolveObj[token],
+ deps: undefined,
+ policy: resolvePolicies[token],
+ }); });
+ };
+ /** fetch DI annotations from a function or ng1-style array */
+ var annotate = function (fn) {
+ var $injector = _common_coreservices__WEBPACK_IMPORTED_MODULE_5__.services.$injector;
+ // ng1 doesn't have an $injector until runtime.
+ // If the $injector doesn't exist, use "deferred" literal as a
+ // marker indicating they should be annotated when runtime starts
+ return fn['$inject'] || ($injector && $injector.annotate(fn, $injector.strictDi)) || 'deferred';
+ };
+ /** true if the object has both `token` and `resolveFn`, and is probably a [[ResolveLiteral]] */
+ var isResolveLiteral = function (obj) { return !!(obj.token && obj.resolveFn); };
+ /** true if the object looks like a provide literal, or a ng2 Provider */
+ var isLikeNg2Provider = function (obj) {
+ return !!((obj.provide || obj.token) && (obj.useValue || obj.useFactory || obj.useExisting || obj.useClass));
+ };
+ /** true if the object looks like a tuple from obj2Tuples */
+ var isTupleFromObj = function (obj) {
+ return !!(obj && obj.val && ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(obj.val) || (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isArray)(obj.val) || (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isFunction)(obj.val)));
+ };
+ /** extracts the token from a Provider or provide literal */
+ var getToken = function (p) { return p.provide || p.token; };
+ // prettier-ignore: Given a literal resolve or provider object, returns a Resolvable
+ var literal2Resolvable = (0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.pattern)([
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.prop)('resolveFn'), function (p) { return new _resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__.Resolvable(getToken(p), p.resolveFn, p.deps, p.policy); }],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.prop)('useFactory'), function (p) { return new _resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__.Resolvable(getToken(p), p.useFactory, p.deps || p.dependencies, p.policy); }],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.prop)('useClass'), function (p) { return new _resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__.Resolvable(getToken(p), function () { return new p.useClass(); }, [], p.policy); }],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.prop)('useValue'), function (p) { return new _resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__.Resolvable(getToken(p), function () { return p.useValue; }, [], p.policy, p.useValue); }],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.prop)('useExisting'), function (p) { return new _resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__.Resolvable(getToken(p), _common_common__WEBPACK_IMPORTED_MODULE_0__.identity, [p.useExisting], p.policy); }],
+ ]);
+ // prettier-ignore
+ var tuple2Resolvable = (0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.pattern)([
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.pipe)((0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.prop)('val'), _common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString), function (tuple) { return new _resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__.Resolvable(tuple.token, _common_common__WEBPACK_IMPORTED_MODULE_0__.identity, [tuple.val], tuple.policy); }],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.pipe)((0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.prop)('val'), _common_predicates__WEBPACK_IMPORTED_MODULE_1__.isArray), function (tuple) { return new _resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__.Resolvable(tuple.token, (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.tail)(tuple.val), tuple.val.slice(0, -1), tuple.policy); }],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.pipe)((0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.prop)('val'), _common_predicates__WEBPACK_IMPORTED_MODULE_1__.isFunction), function (tuple) { return new _resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__.Resolvable(tuple.token, tuple.val, annotate(tuple.val), tuple.policy); }],
+ ]);
+ // prettier-ignore
+ var item2Resolvable = (0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.pattern)([
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.is)(_resolve_resolvable__WEBPACK_IMPORTED_MODULE_4__.Resolvable), function (r) { return r; }],
+ [isResolveLiteral, literal2Resolvable],
+ [isLikeNg2Provider, literal2Resolvable],
+ [isTupleFromObj, tuple2Resolvable],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.val)(true), function (obj) { throw new Error('Invalid resolve value: ' + (0,_common_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(obj)); },],
+ ]);
+ // If resolveBlock is already an array, use it as-is.
+ // Otherwise, assume it's an object and convert to an Array of tuples
+ var decl = state.resolve;
+ var items = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isArray)(decl) ? decl : objects2Tuples(decl, state.resolvePolicy || {});
+ return items.map(item2Resolvable);
+}
+/**
+ * A internal global service
+ *
+ * StateBuilder is a factory for the internal [[StateObject]] objects.
+ *
+ * When you register a state with the [[StateRegistry]], you register a plain old javascript object which
+ * conforms to the [[StateDeclaration]] interface. This factory takes that object and builds the corresponding
+ * [[StateObject]] object, which has an API and is used internally.
+ *
+ * Custom properties or API may be added to the internal [[StateObject]] object by registering a decorator function
+ * using the [[builder]] method.
+ */
+var StateBuilder = /** @class */ (function () {
+ function StateBuilder(matcher, urlMatcherFactory) {
+ this.matcher = matcher;
+ var self = this;
+ var root = function () { return matcher.find(''); };
+ var isRoot = function (state) { return state.name === ''; };
+ function parentBuilder(state) {
+ if (isRoot(state))
+ return null;
+ return matcher.find(self.parentName(state)) || root();
+ }
+ this.builders = {
+ name: [nameBuilder],
+ self: [selfBuilder],
+ parent: [parentBuilder],
+ data: [dataBuilder],
+ // Build a URLMatcher if necessary, either via a relative or absolute URL
+ url: [getUrlBuilder(urlMatcherFactory, root)],
+ // Keep track of the closest ancestor state that has a URL (i.e. is navigable)
+ navigable: [getNavigableBuilder(isRoot)],
+ params: [getParamsBuilder(urlMatcherFactory.paramFactory)],
+ // Each framework-specific ui-router implementation should define its own `views` builder
+ // e.g., src/ng1/statebuilders/views.ts
+ views: [],
+ // Keep a full path from the root down to this state as this is needed for state activation.
+ path: [pathBuilder],
+ // Speed up $state.includes() as it's used a lot
+ includes: [includesBuilder],
+ resolvables: [resolvablesBuilder],
+ };
+ }
+ StateBuilder.prototype.builder = function (name, fn) {
+ var builders = this.builders;
+ var array = builders[name] || [];
+ // Backwards compat: if only one builder exists, return it, else return whole arary.
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(name) && !(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isDefined)(fn))
+ return array.length > 1 ? array : array[0];
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(name) || !(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isFunction)(fn))
+ return;
+ builders[name] = array;
+ builders[name].push(fn);
+ return function () { return builders[name].splice(builders[name].indexOf(fn, 1)) && null; };
+ };
+ /**
+ * Builds all of the properties on an essentially blank State object, returning a State object which has all its
+ * properties and API built.
+ *
+ * @param state an uninitialized State object
+ * @returns the built State object
+ */
+ StateBuilder.prototype.build = function (state) {
+ var _a = this, matcher = _a.matcher, builders = _a.builders;
+ var parent = this.parentName(state);
+ if (parent && !matcher.find(parent, undefined, false)) {
+ return null;
+ }
+ for (var key in builders) {
+ if (!builders.hasOwnProperty(key))
+ continue;
+ var chain = builders[key].reduce(function (parentFn, step) { return function (_state) { return step(_state, parentFn); }; }, _common_common__WEBPACK_IMPORTED_MODULE_0__.noop);
+ state[key] = chain(state);
+ }
+ return state;
+ };
+ StateBuilder.prototype.parentName = function (state) {
+ // name = 'foo.bar.baz.**'
+ var name = state.name || '';
+ // segments = ['foo', 'bar', 'baz', '.**']
+ var segments = name.split('.');
+ // segments = ['foo', 'bar', 'baz']
+ var lastSegment = segments.pop();
+ // segments = ['foo', 'bar'] (ignore .** segment for future states)
+ if (lastSegment === '**')
+ segments.pop();
+ if (segments.length) {
+ if (state.parent) {
+ throw new Error("States that specify the 'parent:' property should not have a '.' in their name (" + name + ")");
+ }
+ // 'foo.bar'
+ return segments.join('.');
+ }
+ if (!state.parent)
+ return '';
+ return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(state.parent) ? state.parent : state.parent.name;
+ };
+ StateBuilder.prototype.name = function (state) {
+ var name = state.name;
+ if (name.indexOf('.') !== -1 || !state.parent)
+ return name;
+ var parentName = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(state.parent) ? state.parent : state.parent.name;
+ return parentName ? parentName + '.' + name : name;
+ };
+ return StateBuilder;
+}());
+
+//# sourceMappingURL=stateBuilder.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/state/stateMatcher.js":
+/*!*******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/state/stateMatcher.js ***!
+ \*******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "StateMatcher": () => (/* binding */ StateMatcher)
+/* harmony export */ });
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_safeConsole__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/safeConsole */ "./node_modules/@uirouter/core/lib-esm/common/safeConsole.js");
+
+
+
+var StateMatcher = /** @class */ (function () {
+ function StateMatcher(_states) {
+ this._states = _states;
+ }
+ StateMatcher.prototype.isRelative = function (stateName) {
+ stateName = stateName || '';
+ return stateName.indexOf('.') === 0 || stateName.indexOf('^') === 0;
+ };
+ StateMatcher.prototype.find = function (stateOrName, base, matchGlob) {
+ if (matchGlob === void 0) { matchGlob = true; }
+ if (!stateOrName && stateOrName !== '')
+ return undefined;
+ var isStr = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isString)(stateOrName);
+ var name = isStr ? stateOrName : stateOrName.name;
+ if (this.isRelative(name))
+ name = this.resolvePath(name, base);
+ var state = this._states[name];
+ if (state && (isStr || (!isStr && (state === stateOrName || state.self === stateOrName)))) {
+ return state;
+ }
+ else if (isStr && matchGlob) {
+ var _states = (0,_common_common__WEBPACK_IMPORTED_MODULE_1__.values)(this._states);
+ var matches = _states.filter(function (_state) { return _state.__stateObjectCache.nameGlob && _state.__stateObjectCache.nameGlob.matches(name); });
+ if (matches.length > 1) {
+ _common_safeConsole__WEBPACK_IMPORTED_MODULE_2__.safeConsole.error("stateMatcher.find: Found multiple matches for " + name + " using glob: ", matches.map(function (match) { return match.name; }));
+ }
+ return matches[0];
+ }
+ return undefined;
+ };
+ StateMatcher.prototype.resolvePath = function (name, base) {
+ if (!base)
+ throw new Error("No reference point given for path '" + name + "'");
+ var baseState = this.find(base);
+ var splitName = name.split('.');
+ var pathLength = splitName.length;
+ var i = 0, current = baseState;
+ for (; i < pathLength; i++) {
+ if (splitName[i] === '' && i === 0) {
+ current = baseState;
+ continue;
+ }
+ if (splitName[i] === '^') {
+ if (!current.parent)
+ throw new Error("Path '" + name + "' not valid for state '" + baseState.name + "'");
+ current = current.parent;
+ continue;
+ }
+ break;
+ }
+ var relName = splitName.slice(i).join('.');
+ return current.name + (current.name && relName ? '.' : '') + relName;
+ };
+ return StateMatcher;
+}());
+
+//# sourceMappingURL=stateMatcher.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/state/stateObject.js":
+/*!******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/state/stateObject.js ***!
+ \******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "StateObject": () => (/* binding */ StateObject)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _common_glob__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/glob */ "./node_modules/@uirouter/core/lib-esm/common/glob.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+
+
+
+
+/**
+ * Internal representation of a UI-Router state.
+ *
+ * Instances of this class are created when a [[StateDeclaration]] is registered with the [[StateRegistry]].
+ *
+ * A registered [[StateDeclaration]] is augmented with a getter ([[StateDeclaration.$$state]]) which returns the corresponding [[StateObject]] object.
+ *
+ * This class prototypally inherits from the corresponding [[StateDeclaration]].
+ * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
+ */
+var StateObject = /** @class */ (function () {
+ /** @deprecated use State.create() */
+ function StateObject(config) {
+ return StateObject.create(config || {});
+ }
+ /**
+ * Create a state object to put the private/internal implementation details onto.
+ * The object's prototype chain looks like:
+ * (Internal State Object) -> (Copy of State.prototype) -> (State Declaration object) -> (State Declaration's prototype...)
+ *
+ * @param stateDecl the user-supplied State Declaration
+ * @returns {StateObject} an internal State object
+ */
+ StateObject.create = function (stateDecl) {
+ stateDecl = StateObject.isStateClass(stateDecl) ? new stateDecl() : stateDecl;
+ var state = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inherit)((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inherit)(stateDecl, StateObject.prototype));
+ stateDecl.$$state = function () { return state; };
+ state.self = stateDecl;
+ state.__stateObjectCache = {
+ nameGlob: _common_glob__WEBPACK_IMPORTED_MODULE_2__.Glob.fromString(state.name),
+ };
+ return state;
+ };
+ /**
+ * Returns true if the provided parameter is the same state.
+ *
+ * Compares the identity of the state against the passed value, which is either an object
+ * reference to the actual `State` instance, the original definition object passed to
+ * `$stateProvider.state()`, or the fully-qualified name.
+ *
+ * @param ref Can be one of (a) a `State` instance, (b) an object that was passed
+ * into `$stateProvider.state()`, (c) the fully-qualified name of a state as a string.
+ * @returns Returns `true` if `ref` matches the current `State` instance.
+ */
+ StateObject.prototype.is = function (ref) {
+ return this === ref || this.self === ref || this.fqn() === ref;
+ };
+ /**
+ * @deprecated this does not properly handle dot notation
+ * @returns Returns a dot-separated name of the state.
+ */
+ StateObject.prototype.fqn = function () {
+ if (!this.parent || !(this.parent instanceof this.constructor))
+ return this.name;
+ var name = this.parent.fqn();
+ return name ? name + '.' + this.name : this.name;
+ };
+ /**
+ * Returns the root node of this state's tree.
+ *
+ * @returns The root of this state's tree.
+ */
+ StateObject.prototype.root = function () {
+ return (this.parent && this.parent.root()) || this;
+ };
+ /**
+ * Gets the state's `Param` objects
+ *
+ * Gets the list of [[Param]] objects owned by the state.
+ * If `opts.inherit` is true, it also includes the ancestor states' [[Param]] objects.
+ * If `opts.matchingKeys` exists, returns only `Param`s whose `id` is a key on the `matchingKeys` object
+ *
+ * @param opts options
+ */
+ StateObject.prototype.parameters = function (opts) {
+ opts = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.defaults)(opts, { inherit: true, matchingKeys: null });
+ var inherited = (opts.inherit && this.parent && this.parent.parameters()) || [];
+ return inherited
+ .concat((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.values)(this.params))
+ .filter(function (param) { return !opts.matchingKeys || opts.matchingKeys.hasOwnProperty(param.id); });
+ };
+ /**
+ * Returns a single [[Param]] that is owned by the state
+ *
+ * If `opts.inherit` is true, it also searches the ancestor states` [[Param]]s.
+ * @param id the name of the [[Param]] to return
+ * @param opts options
+ */
+ StateObject.prototype.parameter = function (id, opts) {
+ if (opts === void 0) { opts = {}; }
+ return ((this.url && this.url.parameter(id, opts)) ||
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.find)((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.values)(this.params), (0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.propEq)('id', id)) ||
+ (opts.inherit && this.parent && this.parent.parameter(id)));
+ };
+ StateObject.prototype.toString = function () {
+ return this.fqn();
+ };
+ /** Predicate which returns true if the object is an class with @State() decorator */
+ StateObject.isStateClass = function (stateDecl) {
+ return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_3__.isFunction)(stateDecl) && stateDecl['__uiRouterState'] === true;
+ };
+ /** Predicate which returns true if the object is a [[StateDeclaration]] object */
+ StateObject.isStateDeclaration = function (obj) { return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_3__.isFunction)(obj['$$state']); };
+ /** Predicate which returns true if the object is an internal [[StateObject]] object */
+ StateObject.isState = function (obj) { return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_3__.isObject)(obj['__stateObjectCache']); };
+ return StateObject;
+}());
+
+//# sourceMappingURL=stateObject.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/state/stateQueueManager.js":
+/*!************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/state/stateQueueManager.js ***!
+ \************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "StateQueueManager": () => (/* binding */ StateQueueManager)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+/* harmony import */ var _stateObject__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stateObject */ "./node_modules/@uirouter/core/lib-esm/state/stateObject.js");
+
+
+var StateQueueManager = /** @class */ (function () {
+ function StateQueueManager(router, states, builder, listeners) {
+ this.router = router;
+ this.states = states;
+ this.builder = builder;
+ this.listeners = listeners;
+ this.queue = [];
+ }
+ StateQueueManager.prototype.dispose = function () {
+ this.queue = [];
+ };
+ StateQueueManager.prototype.register = function (stateDecl) {
+ var queue = this.queue;
+ var state = _stateObject__WEBPACK_IMPORTED_MODULE_1__.StateObject.create(stateDecl);
+ var name = state.name;
+ if (!(0,_common__WEBPACK_IMPORTED_MODULE_0__.isString)(name))
+ throw new Error('State must have a valid name');
+ if (this.states.hasOwnProperty(name) || (0,_common__WEBPACK_IMPORTED_MODULE_0__.inArray)(queue.map((0,_common__WEBPACK_IMPORTED_MODULE_0__.prop)('name')), name))
+ throw new Error("State '" + name + "' is already defined");
+ queue.push(state);
+ this.flush();
+ return state;
+ };
+ StateQueueManager.prototype.flush = function () {
+ var _this = this;
+ var _a = this, queue = _a.queue, states = _a.states, builder = _a.builder;
+ var registered = [], // states that got registered
+ orphans = [], // states that don't yet have a parent registered
+ previousQueueLength = {}; // keep track of how long the queue when an orphan was first encountered
+ var getState = function (name) { return _this.states.hasOwnProperty(name) && _this.states[name]; };
+ var notifyListeners = function () {
+ if (registered.length) {
+ _this.listeners.forEach(function (listener) {
+ return listener('registered', registered.map(function (s) { return s.self; }));
+ });
+ }
+ };
+ while (queue.length > 0) {
+ var state = queue.shift();
+ var name_1 = state.name;
+ var result = builder.build(state);
+ var orphanIdx = orphans.indexOf(state);
+ if (result) {
+ var existingState = getState(name_1);
+ if (existingState && existingState.name === name_1) {
+ throw new Error("State '" + name_1 + "' is already defined");
+ }
+ var existingFutureState = getState(name_1 + '.**');
+ if (existingFutureState) {
+ // Remove future state of the same name
+ this.router.stateRegistry.deregister(existingFutureState);
+ }
+ states[name_1] = state;
+ this.attachRoute(state);
+ if (orphanIdx >= 0)
+ orphans.splice(orphanIdx, 1);
+ registered.push(state);
+ continue;
+ }
+ var prev = previousQueueLength[name_1];
+ previousQueueLength[name_1] = queue.length;
+ if (orphanIdx >= 0 && prev === queue.length) {
+ // Wait until two consecutive iterations where no additional states were dequeued successfully.
+ // throw new Error(`Cannot register orphaned state '${name}'`);
+ queue.push(state);
+ notifyListeners();
+ return states;
+ }
+ else if (orphanIdx < 0) {
+ orphans.push(state);
+ }
+ queue.push(state);
+ }
+ notifyListeners();
+ return states;
+ };
+ StateQueueManager.prototype.attachRoute = function (state) {
+ if (state.abstract || !state.url)
+ return;
+ var rulesApi = this.router.urlService.rules;
+ rulesApi.rule(rulesApi.urlRuleFactory.create(state));
+ };
+ return StateQueueManager;
+}());
+
+//# sourceMappingURL=stateQueueManager.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/state/stateRegistry.js":
+/*!********************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/state/stateRegistry.js ***!
+ \********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "StateRegistry": () => (/* binding */ StateRegistry)
+/* harmony export */ });
+/* harmony import */ var _stateMatcher__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./stateMatcher */ "./node_modules/@uirouter/core/lib-esm/state/stateMatcher.js");
+/* harmony import */ var _stateBuilder__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stateBuilder */ "./node_modules/@uirouter/core/lib-esm/state/stateBuilder.js");
+/* harmony import */ var _stateQueueManager__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./stateQueueManager */ "./node_modules/@uirouter/core/lib-esm/state/stateQueueManager.js");
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+
+
+
+
+
+/**
+ * A registry for all of the application's [[StateDeclaration]]s
+ *
+ * This API is found at `router.stateRegistry` ([[UIRouter.stateRegistry]])
+ */
+var StateRegistry = /** @class */ (function () {
+ /** @internal */
+ function StateRegistry(router) {
+ this.router = router;
+ this.states = {};
+ /** @internal */
+ this.listeners = [];
+ this.matcher = new _stateMatcher__WEBPACK_IMPORTED_MODULE_0__.StateMatcher(this.states);
+ this.builder = new _stateBuilder__WEBPACK_IMPORTED_MODULE_1__.StateBuilder(this.matcher, router.urlMatcherFactory);
+ this.stateQueue = new _stateQueueManager__WEBPACK_IMPORTED_MODULE_2__.StateQueueManager(router, this.states, this.builder, this.listeners);
+ this._registerRoot();
+ }
+ /** @internal */
+ StateRegistry.prototype._registerRoot = function () {
+ var rootStateDef = {
+ name: '',
+ url: '^',
+ views: null,
+ params: {
+ '#': { value: null, type: 'hash', dynamic: true },
+ },
+ abstract: true,
+ };
+ var _root = (this._root = this.stateQueue.register(rootStateDef));
+ _root.navigable = null;
+ };
+ /** @internal */
+ StateRegistry.prototype.dispose = function () {
+ var _this = this;
+ this.stateQueue.dispose();
+ this.listeners = [];
+ this.get().forEach(function (state) { return _this.get(state) && _this.deregister(state); });
+ };
+ /**
+ * Listen for a State Registry events
+ *
+ * Adds a callback that is invoked when states are registered or deregistered with the StateRegistry.
+ *
+ * #### Example:
+ * ```js
+ * let allStates = registry.get();
+ *
+ * // Later, invoke deregisterFn() to remove the listener
+ * let deregisterFn = registry.onStatesChanged((event, states) => {
+ * switch(event) {
+ * case: 'registered':
+ * states.forEach(state => allStates.push(state));
+ * break;
+ * case: 'deregistered':
+ * states.forEach(state => {
+ * let idx = allStates.indexOf(state);
+ * if (idx !== -1) allStates.splice(idx, 1);
+ * });
+ * break;
+ * }
+ * });
+ * ```
+ *
+ * @param listener a callback function invoked when the registered states changes.
+ * The function receives two parameters, `event` and `state`.
+ * See [[StateRegistryListener]]
+ * @return a function that deregisters the listener
+ */
+ StateRegistry.prototype.onStatesChanged = function (listener) {
+ this.listeners.push(listener);
+ return function deregisterListener() {
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.removeFrom)(this.listeners)(listener);
+ }.bind(this);
+ };
+ /**
+ * Gets the implicit root state
+ *
+ * Gets the root of the state tree.
+ * The root state is implicitly created by UI-Router.
+ * Note: this returns the internal [[StateObject]] representation, not a [[StateDeclaration]]
+ *
+ * @return the root [[StateObject]]
+ */
+ StateRegistry.prototype.root = function () {
+ return this._root;
+ };
+ /**
+ * Adds a state to the registry
+ *
+ * Registers a [[StateDeclaration]] or queues it for registration.
+ *
+ * Note: a state will be queued if the state's parent isn't yet registered.
+ *
+ * @param stateDefinition the definition of the state to register.
+ * @returns the internal [[StateObject]] object.
+ * If the state was successfully registered, then the object is fully built (See: [[StateBuilder]]).
+ * If the state was only queued, then the object is not fully built.
+ */
+ StateRegistry.prototype.register = function (stateDefinition) {
+ return this.stateQueue.register(stateDefinition);
+ };
+ /** @internal */
+ StateRegistry.prototype._deregisterTree = function (state) {
+ var _this = this;
+ var all = this.get().map(function (s) { return s.$$state(); });
+ var getChildren = function (states) {
+ var _children = all.filter(function (s) { return states.indexOf(s.parent) !== -1; });
+ return _children.length === 0 ? _children : _children.concat(getChildren(_children));
+ };
+ var children = getChildren([state]);
+ var deregistered = [state].concat(children).reverse();
+ deregistered.forEach(function (_state) {
+ var rulesApi = _this.router.urlService.rules;
+ // Remove URL rule
+ rulesApi
+ .rules()
+ .filter((0,_common_hof__WEBPACK_IMPORTED_MODULE_4__.propEq)('state', _state))
+ .forEach(function (rule) { return rulesApi.removeRule(rule); });
+ // Remove state from registry
+ delete _this.states[_state.name];
+ });
+ return deregistered;
+ };
+ /**
+ * Removes a state from the registry
+ *
+ * This removes a state from the registry.
+ * If the state has children, they are are also removed from the registry.
+ *
+ * @param stateOrName the state's name or object representation
+ * @returns {StateObject[]} a list of removed states
+ */
+ StateRegistry.prototype.deregister = function (stateOrName) {
+ var _state = this.get(stateOrName);
+ if (!_state)
+ throw new Error("Can't deregister state; not found: " + stateOrName);
+ var deregisteredStates = this._deregisterTree(_state.$$state());
+ this.listeners.forEach(function (listener) {
+ return listener('deregistered', deregisteredStates.map(function (s) { return s.self; }));
+ });
+ return deregisteredStates;
+ };
+ StateRegistry.prototype.get = function (stateOrName, base) {
+ var _this = this;
+ if (arguments.length === 0)
+ return Object.keys(this.states).map(function (name) { return _this.states[name].self; });
+ var found = this.matcher.find(stateOrName, base);
+ return (found && found.self) || null;
+ };
+ /**
+ * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).
+ * More than one BuilderFunction can be registered for a given property.
+ *
+ * The BuilderFunction(s) will be used to define the property on any subsequently built [[StateObject]] objects.
+ *
+ * @param property The name of the State property being registered for.
+ * @param builderFunction The BuilderFunction which will be used to build the State property
+ * @returns a function which deregisters the BuilderFunction
+ */
+ StateRegistry.prototype.decorator = function (property, builderFunction) {
+ return this.builder.builder(property, builderFunction);
+ };
+ return StateRegistry;
+}());
+
+//# sourceMappingURL=stateRegistry.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/state/stateService.js":
+/*!*******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/state/stateService.js ***!
+ \*******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "StateService": () => (/* binding */ StateService)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_queue__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/queue */ "./node_modules/@uirouter/core/lib-esm/common/queue.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+/* harmony import */ var _path_pathUtils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../path/pathUtils */ "./node_modules/@uirouter/core/lib-esm/path/pathUtils.js");
+/* harmony import */ var _path_pathNode__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../path/pathNode */ "./node_modules/@uirouter/core/lib-esm/path/pathNode.js");
+/* harmony import */ var _transition_transitionService__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../transition/transitionService */ "./node_modules/@uirouter/core/lib-esm/transition/transitionService.js");
+/* harmony import */ var _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../transition/rejectFactory */ "./node_modules/@uirouter/core/lib-esm/transition/rejectFactory.js");
+/* harmony import */ var _targetState__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./targetState */ "./node_modules/@uirouter/core/lib-esm/state/targetState.js");
+/* harmony import */ var _params_param__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../params/param */ "./node_modules/@uirouter/core/lib-esm/params/param.js");
+/* harmony import */ var _common_glob__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../common/glob */ "./node_modules/@uirouter/core/lib-esm/common/glob.js");
+/* harmony import */ var _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../resolve/resolveContext */ "./node_modules/@uirouter/core/lib-esm/resolve/resolveContext.js");
+/* harmony import */ var _hooks_lazyLoad__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../hooks/lazyLoad */ "./node_modules/@uirouter/core/lib-esm/hooks/lazyLoad.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Provides services related to ui-router states.
+ *
+ * This API is located at `router.stateService` ([[UIRouter.stateService]])
+ */
+var StateService = /** @class */ (function () {
+ /** @internal */
+ function StateService(/** @internal */ router) {
+ this.router = router;
+ /** @internal */
+ this.invalidCallbacks = [];
+ /** @internal */
+ this._defaultErrorHandler = function $defaultErrorHandler($error$) {
+ if ($error$ instanceof Error && $error$.stack) {
+ console.error($error$);
+ console.error($error$.stack);
+ }
+ else if ($error$ instanceof _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection) {
+ console.error($error$.toString());
+ if ($error$.detail && $error$.detail.stack)
+ console.error($error$.detail.stack);
+ }
+ else {
+ console.error($error$);
+ }
+ };
+ var getters = ['current', '$current', 'params', 'transition'];
+ var boundFns = Object.keys(StateService.prototype).filter((0,_common_hof__WEBPACK_IMPORTED_MODULE_13__.not)((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inArray)(getters)));
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.createProxyFunctions)((0,_common_hof__WEBPACK_IMPORTED_MODULE_13__.val)(StateService.prototype), this, (0,_common_hof__WEBPACK_IMPORTED_MODULE_13__.val)(this), boundFns);
+ }
+ Object.defineProperty(StateService.prototype, "transition", {
+ /**
+ * The [[Transition]] currently in progress (or null)
+ *
+ * @deprecated This is a passthrough through to [[UIRouterGlobals.transition]]
+ */
+ get: function () {
+ return this.router.globals.transition;
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(StateService.prototype, "params", {
+ /**
+ * The latest successful state parameters
+ *
+ * @deprecated This is a passthrough through to [[UIRouterGlobals.params]]
+ */
+ get: function () {
+ return this.router.globals.params;
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(StateService.prototype, "current", {
+ /**
+ * The current [[StateDeclaration]]
+ *
+ * @deprecated This is a passthrough through to [[UIRouterGlobals.current]]
+ */
+ get: function () {
+ return this.router.globals.current;
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(StateService.prototype, "$current", {
+ /**
+ * The current [[StateObject]] (an internal API)
+ *
+ * @deprecated This is a passthrough through to [[UIRouterGlobals.$current]]
+ */
+ get: function () {
+ return this.router.globals.$current;
+ },
+ enumerable: false,
+ configurable: true
+ });
+ /** @internal */
+ StateService.prototype.dispose = function () {
+ this.defaultErrorHandler(_common_common__WEBPACK_IMPORTED_MODULE_0__.noop);
+ this.invalidCallbacks = [];
+ };
+ /**
+ * Handler for when [[transitionTo]] is called with an invalid state.
+ *
+ * Invokes the [[onInvalid]] callbacks, in natural order.
+ * Each callback's return value is checked in sequence until one of them returns an instance of TargetState.
+ * The results of the callbacks are wrapped in $q.when(), so the callbacks may return promises.
+ *
+ * If a callback returns an TargetState, then it is used as arguments to $state.transitionTo() and the result returned.
+ *
+ * @internal
+ */
+ StateService.prototype._handleInvalidTargetState = function (fromPath, toState) {
+ var _this = this;
+ var fromState = _path_pathUtils__WEBPACK_IMPORTED_MODULE_4__.PathUtils.makeTargetState(this.router.stateRegistry, fromPath);
+ var globals = this.router.globals;
+ var latestThing = function () { return globals.transitionHistory.peekTail(); };
+ var latest = latestThing();
+ var callbackQueue = new _common_queue__WEBPACK_IMPORTED_MODULE_2__.Queue(this.invalidCallbacks.slice());
+ var injector = new _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_11__.ResolveContext(fromPath).injector();
+ var checkForRedirect = function (result) {
+ if (!(result instanceof _targetState__WEBPACK_IMPORTED_MODULE_8__.TargetState)) {
+ return;
+ }
+ var target = result;
+ // Recreate the TargetState, in case the state is now defined.
+ target = _this.target(target.identifier(), target.params(), target.options());
+ if (!target.valid()) {
+ return _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.invalid(target.error()).toPromise();
+ }
+ if (latestThing() !== latest) {
+ return _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.superseded().toPromise();
+ }
+ return _this.transitionTo(target.identifier(), target.params(), target.options());
+ };
+ function invokeNextCallback() {
+ var nextCallback = callbackQueue.dequeue();
+ if (nextCallback === undefined)
+ return _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.invalid(toState.error()).toPromise();
+ var callbackResult = _common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$q.when(nextCallback(toState, fromState, injector));
+ return callbackResult.then(checkForRedirect).then(function (result) { return result || invokeNextCallback(); });
+ }
+ return invokeNextCallback();
+ };
+ /**
+ * Registers an Invalid State handler
+ *
+ * Registers a [[OnInvalidCallback]] function to be invoked when [[StateService.transitionTo]]
+ * has been called with an invalid state reference parameter
+ *
+ * Example:
+ * ```js
+ * stateService.onInvalid(function(to, from, injector) {
+ * if (to.name() === 'foo') {
+ * let lazyLoader = injector.get('LazyLoadService');
+ * return lazyLoader.load('foo')
+ * .then(() => stateService.target('foo'));
+ * }
+ * });
+ * ```
+ *
+ * @param {function} callback invoked when the toState is invalid
+ * This function receives the (invalid) toState, the fromState, and an injector.
+ * The function may optionally return a [[TargetState]] or a Promise for a TargetState.
+ * If one is returned, it is treated as a redirect.
+ *
+ * @returns a function which deregisters the callback
+ */
+ StateService.prototype.onInvalid = function (callback) {
+ this.invalidCallbacks.push(callback);
+ return function deregisterListener() {
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.removeFrom)(this.invalidCallbacks)(callback);
+ }.bind(this);
+ };
+ /**
+ * Reloads the current state
+ *
+ * A method that force reloads the current state, or a partial state hierarchy.
+ * All resolves are re-resolved, and components reinstantiated.
+ *
+ * #### Example:
+ * ```js
+ * let app angular.module('app', ['ui.router']);
+ *
+ * app.controller('ctrl', function ($scope, $state) {
+ * $scope.reload = function(){
+ * $state.reload();
+ * }
+ * });
+ * ```
+ *
+ * Note: `reload()` is just an alias for:
+ *
+ * ```js
+ * $state.transitionTo($state.current, $state.params, {
+ * reload: true, inherit: false
+ * });
+ * ```
+ *
+ * @param reloadState A state name or a state object.
+ * If present, this state and all its children will be reloaded, but ancestors will not reload.
+ *
+ * #### Example:
+ * ```js
+ * //assuming app application consists of 3 states: 'contacts', 'contacts.detail', 'contacts.detail.item'
+ * //and current state is 'contacts.detail.item'
+ * let app angular.module('app', ['ui.router']);
+ *
+ * app.controller('ctrl', function ($scope, $state) {
+ * $scope.reload = function(){
+ * //will reload 'contact.detail' and nested 'contact.detail.item' states
+ * $state.reload('contact.detail');
+ * }
+ * });
+ * ```
+ *
+ * @returns A promise representing the state of the new transition. See [[StateService.go]]
+ */
+ StateService.prototype.reload = function (reloadState) {
+ return this.transitionTo(this.current, this.params, {
+ reload: (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isDefined)(reloadState) ? reloadState : true,
+ inherit: false,
+ notify: false,
+ });
+ };
+ /**
+ * Transition to a different state and/or parameters
+ *
+ * Convenience method for transitioning to a new state.
+ *
+ * `$state.go` calls `$state.transitionTo` internally but automatically sets options to
+ * `{ location: true, inherit: true, relative: router.globals.$current, notify: true }`.
+ * This allows you to use either an absolute or relative `to` argument (because of `relative: router.globals.$current`).
+ * It also allows you to specify * only the parameters you'd like to update, while letting unspecified parameters
+ * inherit from the current parameter values (because of `inherit: true`).
+ *
+ * #### Example:
+ * ```js
+ * let app = angular.module('app', ['ui.router']);
+ *
+ * app.controller('ctrl', function ($scope, $state) {
+ * $scope.changeState = function () {
+ * $state.go('contact.detail');
+ * };
+ * });
+ * ```
+ *
+ * @param to Absolute state name, state object, or relative state path (relative to current state).
+ *
+ * Some examples:
+ *
+ * - `$state.go('contact.detail')` - will go to the `contact.detail` state
+ * - `$state.go('^')` - will go to the parent state
+ * - `$state.go('^.sibling')` - if current state is `home.child`, will go to the `home.sibling` state
+ * - `$state.go('.child.grandchild')` - if current state is home, will go to the `home.child.grandchild` state
+ *
+ * @param params A map of the parameters that will be sent to the state, will populate $stateParams.
+ *
+ * Any parameters that are not specified will be inherited from current parameter values (because of `inherit: true`).
+ * This allows, for example, going to a sibling state that shares parameters defined by a parent state.
+ *
+ * @param options Transition options
+ *
+ * @returns {promise} A promise representing the state of the new transition.
+ */
+ StateService.prototype.go = function (to, params, options) {
+ var defautGoOpts = { relative: this.$current, inherit: true };
+ var transOpts = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.defaults)(options, defautGoOpts, _transition_transitionService__WEBPACK_IMPORTED_MODULE_6__.defaultTransOpts);
+ return this.transitionTo(to, params, transOpts);
+ };
+ /**
+ * Creates a [[TargetState]]
+ *
+ * This is a factory method for creating a TargetState
+ *
+ * This may be returned from a Transition Hook to redirect a transition, for example.
+ */
+ StateService.prototype.target = function (identifier, params, options) {
+ if (options === void 0) { options = {}; }
+ // If we're reloading, find the state object to reload from
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isObject)(options.reload) && !options.reload.name)
+ throw new Error('Invalid reload state object');
+ var reg = this.router.stateRegistry;
+ options.reloadState =
+ options.reload === true ? reg.root() : reg.matcher.find(options.reload, options.relative);
+ if (options.reload && !options.reloadState)
+ throw new Error("No such reload state '" + ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(options.reload) ? options.reload : options.reload.name) + "'");
+ return new _targetState__WEBPACK_IMPORTED_MODULE_8__.TargetState(this.router.stateRegistry, identifier, params, options);
+ };
+ /** @internal */
+ StateService.prototype.getCurrentPath = function () {
+ var _this = this;
+ var globals = this.router.globals;
+ var latestSuccess = globals.successfulTransitions.peekTail();
+ var rootPath = function () { return [new _path_pathNode__WEBPACK_IMPORTED_MODULE_5__.PathNode(_this.router.stateRegistry.root())]; };
+ return latestSuccess ? latestSuccess.treeChanges().to : rootPath();
+ };
+ /**
+ * Low-level method for transitioning to a new state.
+ *
+ * The [[go]] method (which uses `transitionTo` internally) is recommended in most situations.
+ *
+ * #### Example:
+ * ```js
+ * let app = angular.module('app', ['ui.router']);
+ *
+ * app.controller('ctrl', function ($scope, $state) {
+ * $scope.changeState = function () {
+ * $state.transitionTo('contact.detail');
+ * };
+ * });
+ * ```
+ *
+ * @param to State name or state object.
+ * @param toParams A map of the parameters that will be sent to the state,
+ * will populate $stateParams.
+ * @param options Transition options
+ *
+ * @returns A promise representing the state of the new transition. See [[go]]
+ */
+ StateService.prototype.transitionTo = function (to, toParams, options) {
+ var _this = this;
+ if (toParams === void 0) { toParams = {}; }
+ if (options === void 0) { options = {}; }
+ var router = this.router;
+ var globals = router.globals;
+ options = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.defaults)(options, _transition_transitionService__WEBPACK_IMPORTED_MODULE_6__.defaultTransOpts);
+ var getCurrent = function () { return globals.transition; };
+ options = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(options, { current: getCurrent });
+ var ref = this.target(to, toParams, options);
+ var currentPath = this.getCurrentPath();
+ if (!ref.exists())
+ return this._handleInvalidTargetState(currentPath, ref);
+ if (!ref.valid())
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.silentRejection)(ref.error());
+ if (options.supercede === false && getCurrent()) {
+ return (_transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.ignored('Another transition is in progress and supercede has been set to false in TransitionOptions for the transition. So the transition was ignored in favour of the existing one in progress.').toPromise());
+ }
+ /**
+ * Special handling for Ignored, Aborted, and Redirected transitions
+ *
+ * The semantics for the transition.run() promise and the StateService.transitionTo()
+ * promise differ. For instance, the run() promise may be rejected because it was
+ * IGNORED, but the transitionTo() promise is resolved because from the user perspective
+ * no error occurred. Likewise, the transition.run() promise may be rejected because of
+ * a Redirect, but the transitionTo() promise is chained to the new Transition's promise.
+ */
+ var rejectedTransitionHandler = function (trans) { return function (error) {
+ if (error instanceof _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection) {
+ var isLatest = router.globals.lastStartedTransitionId <= trans.$id;
+ if (error.type === _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.RejectType.IGNORED) {
+ isLatest && router.urlRouter.update();
+ // Consider ignored `Transition.run()` as a successful `transitionTo`
+ return _common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$q.when(globals.current);
+ }
+ var detail = error.detail;
+ if (error.type === _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.RejectType.SUPERSEDED && error.redirected && detail instanceof _targetState__WEBPACK_IMPORTED_MODULE_8__.TargetState) {
+ // If `Transition.run()` was redirected, allow the `transitionTo()` promise to resolve successfully
+ // by returning the promise for the new (redirect) `Transition.run()`.
+ var redirect = trans.redirect(detail);
+ return redirect.run().catch(rejectedTransitionHandler(redirect));
+ }
+ if (error.type === _transition_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.RejectType.ABORTED) {
+ isLatest && router.urlRouter.update();
+ return _common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$q.reject(error);
+ }
+ }
+ var errorHandler = _this.defaultErrorHandler();
+ errorHandler(error);
+ return _common_coreservices__WEBPACK_IMPORTED_MODULE_3__.services.$q.reject(error);
+ }; };
+ var transition = this.router.transitionService.create(currentPath, ref);
+ var transitionToPromise = transition.run().catch(rejectedTransitionHandler(transition));
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.silenceUncaughtInPromise)(transitionToPromise); // issue #2676
+ // Return a promise for the transition, which also has the transition object on it.
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)(transitionToPromise, { transition: transition });
+ };
+ /**
+ * Checks if the current state *is* the provided state
+ *
+ * Similar to [[includes]] but only checks for the full state name.
+ * If params is supplied then it will be tested for strict equality against the current
+ * active params object, so all params must match with none missing and no extras.
+ *
+ * #### Example:
+ * ```js
+ * $state.$current.name = 'contacts.details.item';
+ *
+ * // absolute name
+ * $state.is('contact.details.item'); // returns true
+ * $state.is(contactDetailItemStateObject); // returns true
+ * ```
+ *
+ * // relative name (. and ^), typically from a template
+ * // E.g. from the 'contacts.details' template
+ * ```html
+ * <div ng-class="{highlighted: $state.is('.item')}">Item</div>
+ * ```
+ *
+ * @param stateOrName The state name (absolute or relative) or state object you'd like to check.
+ * @param params A param object, e.g. `{sectionId: section.id}`, that you'd like
+ * to test against the current active state.
+ * @param options An options object. The options are:
+ * - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will
+ * test relative to `options.relative` state (or name).
+ *
+ * @returns Returns true if it is the state.
+ */
+ StateService.prototype.is = function (stateOrName, params, options) {
+ options = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.defaults)(options, { relative: this.$current });
+ var state = this.router.stateRegistry.matcher.find(stateOrName, options.relative);
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isDefined)(state))
+ return undefined;
+ if (this.$current !== state)
+ return false;
+ if (!params)
+ return true;
+ var schema = state.parameters({ inherit: true, matchingKeys: params });
+ return _params_param__WEBPACK_IMPORTED_MODULE_9__.Param.equals(schema, _params_param__WEBPACK_IMPORTED_MODULE_9__.Param.values(schema, params), this.params);
+ };
+ /**
+ * Checks if the current state *includes* the provided state
+ *
+ * A method to determine if the current active state is equal to or is the child of the
+ * state stateName. If any params are passed then they will be tested for a match as well.
+ * Not all the parameters need to be passed, just the ones you'd like to test for equality.
+ *
+ * #### Example when `$state.$current.name === 'contacts.details.item'`
+ * ```js
+ * // Using partial names
+ * $state.includes("contacts"); // returns true
+ * $state.includes("contacts.details"); // returns true
+ * $state.includes("contacts.details.item"); // returns true
+ * $state.includes("contacts.list"); // returns false
+ * $state.includes("about"); // returns false
+ * ```
+ *
+ * #### Glob Examples when `* $state.$current.name === 'contacts.details.item.url'`:
+ * ```js
+ * $state.includes("*.details.*.*"); // returns true
+ * $state.includes("*.details.**"); // returns true
+ * $state.includes("**.item.**"); // returns true
+ * $state.includes("*.details.item.url"); // returns true
+ * $state.includes("*.details.*.url"); // returns true
+ * $state.includes("*.details.*"); // returns false
+ * $state.includes("item.**"); // returns false
+ * ```
+ *
+ * @param stateOrName A partial name, relative name, glob pattern,
+ * or state object to be searched for within the current state name.
+ * @param params A param object, e.g. `{sectionId: section.id}`,
+ * that you'd like to test against the current active state.
+ * @param options An options object. The options are:
+ * - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will
+ * test relative to `options.relative` state (or name).
+ *
+ * @returns {boolean} Returns true if it does include the state
+ */
+ StateService.prototype.includes = function (stateOrName, params, options) {
+ options = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.defaults)(options, { relative: this.$current });
+ var glob = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(stateOrName) && _common_glob__WEBPACK_IMPORTED_MODULE_10__.Glob.fromString(stateOrName);
+ if (glob) {
+ if (!glob.matches(this.$current.name))
+ return false;
+ stateOrName = this.$current.name;
+ }
+ var state = this.router.stateRegistry.matcher.find(stateOrName, options.relative), include = this.$current.includes;
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isDefined)(state))
+ return undefined;
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isDefined)(include[state.name]))
+ return false;
+ if (!params)
+ return true;
+ var schema = state.parameters({ inherit: true, matchingKeys: params });
+ return _params_param__WEBPACK_IMPORTED_MODULE_9__.Param.equals(schema, _params_param__WEBPACK_IMPORTED_MODULE_9__.Param.values(schema, params), this.params);
+ };
+ /**
+ * Generates a URL for a state and parameters
+ *
+ * Returns the url for the given state populated with the given params.
+ *
+ * #### Example:
+ * ```js
+ * expect($state.href("about.person", { person: "bob" })).toEqual("/about/bob");
+ * ```
+ *
+ * @param stateOrName The state name or state object you'd like to generate a url from.
+ * @param params An object of parameter values to fill the state's required parameters.
+ * @param options Options object. The options are:
+ *
+ * @returns {string} compiled state url
+ */
+ StateService.prototype.href = function (stateOrName, params, options) {
+ var defaultHrefOpts = {
+ lossy: true,
+ inherit: true,
+ absolute: false,
+ relative: this.$current,
+ };
+ options = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.defaults)(options, defaultHrefOpts);
+ params = params || {};
+ var state = this.router.stateRegistry.matcher.find(stateOrName, options.relative);
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isDefined)(state))
+ return null;
+ if (options.inherit)
+ params = this.params.$inherit(params, this.$current, state);
+ var nav = state && options.lossy ? state.navigable : state;
+ if (!nav || nav.url === undefined || nav.url === null) {
+ return null;
+ }
+ return this.router.urlRouter.href(nav.url, params, { absolute: options.absolute });
+ };
+ /**
+ * Sets or gets the default [[transitionTo]] error handler.
+ *
+ * The error handler is called when a [[Transition]] is rejected or when any error occurred during the Transition.
+ * This includes errors caused by resolves and transition hooks.
+ *
+ * Note:
+ * This handler does not receive certain Transition rejections.
+ * Redirected and Ignored Transitions are not considered to be errors by [[StateService.transitionTo]].
+ *
+ * The built-in default error handler logs the error to the console.
+ *
+ * You can provide your own custom handler.
+ *
+ * #### Example:
+ * ```js
+ * stateService.defaultErrorHandler(function() {
+ * // Do not log transitionTo errors
+ * });
+ * ```
+ *
+ * @param handler a global error handler function
+ * @returns the current global error handler
+ */
+ StateService.prototype.defaultErrorHandler = function (handler) {
+ return (this._defaultErrorHandler = handler || this._defaultErrorHandler);
+ };
+ StateService.prototype.get = function (stateOrName, base) {
+ var reg = this.router.stateRegistry;
+ if (arguments.length === 0)
+ return reg.get();
+ return reg.get(stateOrName, base || this.$current);
+ };
+ /**
+ * Lazy loads a state
+ *
+ * Explicitly runs a state's [[StateDeclaration.lazyLoad]] function.
+ *
+ * @param stateOrName the state that should be lazy loaded
+ * @param transition the optional Transition context to use (if the lazyLoad function requires an injector, etc)
+ * Note: If no transition is provided, a noop transition is created using the from the current state to the current state.
+ * This noop transition is not actually run.
+ *
+ * @returns a promise to lazy load
+ */
+ StateService.prototype.lazyLoad = function (stateOrName, transition) {
+ var state = this.get(stateOrName);
+ if (!state || !state.lazyLoad)
+ throw new Error('Can not lazy load ' + stateOrName);
+ var currentPath = this.getCurrentPath();
+ var target = _path_pathUtils__WEBPACK_IMPORTED_MODULE_4__.PathUtils.makeTargetState(this.router.stateRegistry, currentPath);
+ transition = transition || this.router.transitionService.create(currentPath, target);
+ return (0,_hooks_lazyLoad__WEBPACK_IMPORTED_MODULE_12__.lazyLoadState)(transition, state);
+ };
+ return StateService;
+}());
+
+//# sourceMappingURL=stateService.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/state/targetState.js":
+/*!******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/state/targetState.js ***!
+ \******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "TargetState": () => (/* binding */ TargetState)
+/* harmony export */ });
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_strings__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+
+
+/**
+ * Encapsulate the target (destination) state/params/options of a [[Transition]].
+ *
+ * This class is frequently used to redirect a transition to a new destination.
+ *
+ * See:
+ *
+ * - [[HookResult]]
+ * - [[TransitionHookFn]]
+ * - [[TransitionService.onStart]]
+ *
+ * To create a `TargetState`, use [[StateService.target]].
+ *
+ * ---
+ *
+ * This class wraps:
+ *
+ * 1) an identifier for a state
+ * 2) a set of parameters
+ * 3) and transition options
+ * 4) the registered state object (the [[StateDeclaration]])
+ *
+ * Many UI-Router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can
+ * either be a *state object* (a [[StateDeclaration]] or [[StateObject]]) or a *state name* (a string).
+ * The `TargetState` class normalizes those options.
+ *
+ * A `TargetState` may be valid (the state being targeted exists in the registry)
+ * or invalid (the state being targeted is not registered).
+ */
+var TargetState = /** @class */ (function () {
+ /**
+ * The TargetState constructor
+ *
+ * Note: Do not construct a `TargetState` manually.
+ * To create a `TargetState`, use the [[StateService.target]] factory method.
+ *
+ * @param _stateRegistry The StateRegistry to use to look up the _definition
+ * @param _identifier An identifier for a state.
+ * Either a fully-qualified state name, or the object used to define the state.
+ * @param _params Parameters for the target state
+ * @param _options Transition options.
+ *
+ * @internal
+ */
+ function TargetState(_stateRegistry, _identifier, _params, _options) {
+ this._stateRegistry = _stateRegistry;
+ this._identifier = _identifier;
+ this._identifier = _identifier;
+ this._params = (0,_common__WEBPACK_IMPORTED_MODULE_2__.extend)({}, _params || {});
+ this._options = (0,_common__WEBPACK_IMPORTED_MODULE_2__.extend)({}, _options || {});
+ this._definition = _stateRegistry.matcher.find(_identifier, this._options.relative);
+ }
+ /** The name of the state this object targets */
+ TargetState.prototype.name = function () {
+ return (this._definition && this._definition.name) || this._identifier;
+ };
+ /** The identifier used when creating this TargetState */
+ TargetState.prototype.identifier = function () {
+ return this._identifier;
+ };
+ /** The target parameter values */
+ TargetState.prototype.params = function () {
+ return this._params;
+ };
+ /** The internal state object (if it was found) */
+ TargetState.prototype.$state = function () {
+ return this._definition;
+ };
+ /** The internal state declaration (if it was found) */
+ TargetState.prototype.state = function () {
+ return this._definition && this._definition.self;
+ };
+ /** The target options */
+ TargetState.prototype.options = function () {
+ return this._options;
+ };
+ /** True if the target state was found */
+ TargetState.prototype.exists = function () {
+ return !!(this._definition && this._definition.self);
+ };
+ /** True if the object is valid */
+ TargetState.prototype.valid = function () {
+ return !this.error();
+ };
+ /** If the object is invalid, returns the reason why */
+ TargetState.prototype.error = function () {
+ var base = this.options().relative;
+ if (!this._definition && !!base) {
+ var stateName = base.name ? base.name : base;
+ return "Could not resolve '" + this.name() + "' from state '" + stateName + "'";
+ }
+ if (!this._definition)
+ return "No such state '" + this.name() + "'";
+ if (!this._definition.self)
+ return "State '" + this.name() + "' has an invalid definition";
+ };
+ TargetState.prototype.toString = function () {
+ return "'" + this.name() + "'" + (0,_common_strings__WEBPACK_IMPORTED_MODULE_1__.stringify)(this.params());
+ };
+ /**
+ * Returns a copy of this TargetState which targets a different state.
+ * The new TargetState has the same parameter values and transition options.
+ *
+ * @param state The new state that should be targeted
+ */
+ TargetState.prototype.withState = function (state) {
+ return new TargetState(this._stateRegistry, state, this._params, this._options);
+ };
+ /**
+ * Returns a copy of this TargetState, using the specified parameter values.
+ *
+ * @param params the new parameter values to use
+ * @param replace When false (default) the new parameter values will be merged with the current values.
+ * When true the parameter values will be used instead of the current values.
+ */
+ TargetState.prototype.withParams = function (params, replace) {
+ if (replace === void 0) { replace = false; }
+ var newParams = replace ? params : (0,_common__WEBPACK_IMPORTED_MODULE_2__.extend)({}, this._params, params);
+ return new TargetState(this._stateRegistry, this._identifier, newParams, this._options);
+ };
+ /**
+ * Returns a copy of this TargetState, using the specified Transition Options.
+ *
+ * @param options the new options to use
+ * @param replace When false (default) the new options will be merged with the current options.
+ * When true the options will be used instead of the current options.
+ */
+ TargetState.prototype.withOptions = function (options, replace) {
+ if (replace === void 0) { replace = false; }
+ var newOpts = replace ? options : (0,_common__WEBPACK_IMPORTED_MODULE_2__.extend)({}, this._options, options);
+ return new TargetState(this._stateRegistry, this._identifier, this._params, newOpts);
+ };
+ /** Returns true if the object has a state property that might be a state or state name */
+ TargetState.isDef = function (obj) {
+ return obj && obj.state && ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isString)(obj.state) || ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isObject)(obj.state) && (0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isString)(obj.state.name)));
+ };
+ return TargetState;
+}());
+
+//# sourceMappingURL=targetState.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/transition/hookBuilder.js":
+/*!***********************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/transition/hookBuilder.js ***!
+ \***********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "HookBuilder": () => (/* binding */ HookBuilder)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/transition/interface.js");
+/* harmony import */ var _transitionHook__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./transitionHook */ "./node_modules/@uirouter/core/lib-esm/transition/transitionHook.js");
+
+
+
+
+/**
+ * This class returns applicable TransitionHooks for a specific Transition instance.
+ *
+ * Hooks ([[RegisteredHook]]) may be registered globally, e.g., $transitions.onEnter(...), or locally, e.g.
+ * myTransition.onEnter(...). The HookBuilder finds matching RegisteredHooks (where the match criteria is
+ * determined by the type of hook)
+ *
+ * The HookBuilder also converts RegisteredHooks objects to TransitionHook objects, which are used to run a Transition.
+ *
+ * The HookBuilder constructor is given the $transitions service and a Transition instance. Thus, a HookBuilder
+ * instance may only be used for one specific Transition object. (side note: the _treeChanges accessor is private
+ * in the Transition class, so we must also provide the Transition's _treeChanges)
+ */
+var HookBuilder = /** @class */ (function () {
+ function HookBuilder(transition) {
+ this.transition = transition;
+ }
+ HookBuilder.prototype.buildHooksForPhase = function (phase) {
+ var _this = this;
+ var $transitions = this.transition.router.transitionService;
+ return $transitions._pluginapi
+ ._getEvents(phase)
+ .map(function (type) { return _this.buildHooks(type); })
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .filter(_common_common__WEBPACK_IMPORTED_MODULE_0__.identity);
+ };
+ /**
+ * Returns an array of newly built TransitionHook objects.
+ *
+ * - Finds all RegisteredHooks registered for the given `hookType` which matched the transition's [[TreeChanges]].
+ * - Finds [[PathNode]] (or `PathNode[]`) to use as the TransitionHook context(s)
+ * - For each of the [[PathNode]]s, creates a TransitionHook
+ *
+ * @param hookType the type of the hook registration function, e.g., 'onEnter', 'onFinish'.
+ */
+ HookBuilder.prototype.buildHooks = function (hookType) {
+ var transition = this.transition;
+ var treeChanges = transition.treeChanges();
+ // Find all the matching registered hooks for a given hook type
+ var matchingHooks = this.getMatchingHooks(hookType, treeChanges, transition);
+ if (!matchingHooks)
+ return [];
+ var baseHookOptions = {
+ transition: transition,
+ current: transition.options().current,
+ };
+ var makeTransitionHooks = function (hook) {
+ // Fetch the Nodes that caused this hook to match.
+ var matches = hook.matches(treeChanges, transition);
+ // Select the PathNode[] that will be used as TransitionHook context objects
+ var matchingNodes = matches[hookType.criteriaMatchPath.name];
+ // Return an array of HookTuples
+ return matchingNodes.map(function (node) {
+ var _options = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)({
+ bind: hook.bind,
+ traceData: { hookType: hookType.name, context: node },
+ }, baseHookOptions);
+ var state = hookType.criteriaMatchPath.scope === _interface__WEBPACK_IMPORTED_MODULE_2__.TransitionHookScope.STATE ? node.state.self : null;
+ var transitionHook = new _transitionHook__WEBPACK_IMPORTED_MODULE_3__.TransitionHook(transition, state, hook, _options);
+ return { hook: hook, node: node, transitionHook: transitionHook };
+ });
+ };
+ return matchingHooks
+ .map(makeTransitionHooks)
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .sort(tupleSort(hookType.reverseSort))
+ .map(function (tuple) { return tuple.transitionHook; });
+ };
+ /**
+ * Finds all RegisteredHooks from:
+ * - The Transition object instance hook registry
+ * - The TransitionService ($transitions) global hook registry
+ *
+ * which matched:
+ * - the eventType
+ * - the matchCriteria (to, from, exiting, retained, entering)
+ *
+ * @returns an array of matched [[RegisteredHook]]s
+ */
+ HookBuilder.prototype.getMatchingHooks = function (hookType, treeChanges, transition) {
+ var isCreate = hookType.hookPhase === _interface__WEBPACK_IMPORTED_MODULE_2__.TransitionHookPhase.CREATE;
+ // Instance and Global hook registries
+ var $transitions = this.transition.router.transitionService;
+ var registries = isCreate ? [$transitions] : [this.transition, $transitions];
+ return registries
+ .map(function (reg) { return reg.getHooks(hookType.name); }) // Get named hooks from registries
+ .filter((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.assertPredicate)(_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isArray, "broken event named: " + hookType.name)) // Sanity check
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, []) // Un-nest RegisteredHook[][] to RegisteredHook[] array
+ .filter(function (hook) { return hook.matches(treeChanges, transition); }); // Only those satisfying matchCriteria
+ };
+ return HookBuilder;
+}());
+
+/**
+ * A factory for a sort function for HookTuples.
+ *
+ * The sort function first compares the PathNode depth (how deep in the state tree a node is), then compares
+ * the EventHook priority.
+ *
+ * @param reverseDepthSort a boolean, when true, reverses the sort order for the node depth
+ * @returns a tuple sort function
+ */
+function tupleSort(reverseDepthSort) {
+ if (reverseDepthSort === void 0) { reverseDepthSort = false; }
+ return function nodeDepthThenPriority(l, r) {
+ var factor = reverseDepthSort ? -1 : 1;
+ var depthDelta = (l.node.state.path.length - r.node.state.path.length) * factor;
+ return depthDelta !== 0 ? depthDelta : r.hook.priority - l.hook.priority;
+ };
+}
+//# sourceMappingURL=hookBuilder.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/transition/hookRegistry.js":
+/*!************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/transition/hookRegistry.js ***!
+ \************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "matchState": () => (/* binding */ matchState),
+/* harmony export */ "RegisteredHook": () => (/* binding */ RegisteredHook),
+/* harmony export */ "makeEvent": () => (/* binding */ makeEvent)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/transition/interface.js");
+
+
+/**
+ * Determines if the given state matches the matchCriteria
+ *
+ * @internal
+ *
+ * @param state a State Object to test against
+ * @param criterion
+ * - If a string, matchState uses the string as a glob-matcher against the state name
+ * - If an array (of strings), matchState uses each string in the array as a glob-matchers against the state name
+ * and returns a positive match if any of the globs match.
+ * - If a function, matchState calls the function with the state and returns true if the function's result is truthy.
+ * @returns {boolean}
+ */
+function matchState(state, criterion, transition) {
+ var toMatch = (0,_common__WEBPACK_IMPORTED_MODULE_0__.isString)(criterion) ? [criterion] : criterion;
+ function matchGlobs(_state) {
+ var globStrings = toMatch;
+ for (var i = 0; i < globStrings.length; i++) {
+ var glob = new _common__WEBPACK_IMPORTED_MODULE_0__.Glob(globStrings[i]);
+ if ((glob && glob.matches(_state.name)) || (!glob && globStrings[i] === _state.name)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ var matchFn = ((0,_common__WEBPACK_IMPORTED_MODULE_0__.isFunction)(toMatch) ? toMatch : matchGlobs);
+ return !!matchFn(state, transition);
+}
+/**
+ * The registration data for a registered transition hook
+ */
+var RegisteredHook = /** @class */ (function () {
+ function RegisteredHook(tranSvc, eventType, callback, matchCriteria, removeHookFromRegistry, options) {
+ if (options === void 0) { options = {}; }
+ this.tranSvc = tranSvc;
+ this.eventType = eventType;
+ this.callback = callback;
+ this.matchCriteria = matchCriteria;
+ this.removeHookFromRegistry = removeHookFromRegistry;
+ this.invokeCount = 0;
+ this._deregistered = false;
+ this.priority = options.priority || 0;
+ this.bind = options.bind || null;
+ this.invokeLimit = options.invokeLimit;
+ }
+ /**
+ * Gets the matching [[PathNode]]s
+ *
+ * Given an array of [[PathNode]]s, and a [[HookMatchCriterion]], returns an array containing
+ * the [[PathNode]]s that the criteria matches, or `null` if there were no matching nodes.
+ *
+ * Returning `null` is significant to distinguish between the default
+ * "match-all criterion value" of `true` compared to a `() => true` function,
+ * when the nodes is an empty array.
+ *
+ * This is useful to allow a transition match criteria of `entering: true`
+ * to still match a transition, even when `entering === []`. Contrast that
+ * with `entering: (state) => true` which only matches when a state is actually
+ * being entered.
+ */
+ RegisteredHook.prototype._matchingNodes = function (nodes, criterion, transition) {
+ if (criterion === true)
+ return nodes;
+ var matching = nodes.filter(function (node) { return matchState(node.state, criterion, transition); });
+ return matching.length ? matching : null;
+ };
+ /**
+ * Gets the default match criteria (all `true`)
+ *
+ * Returns an object which has all the criteria match paths as keys and `true` as values, i.e.:
+ *
+ * ```js
+ * {
+ * to: true,
+ * from: true,
+ * entering: true,
+ * exiting: true,
+ * retained: true,
+ * }
+ */
+ RegisteredHook.prototype._getDefaultMatchCriteria = function () {
+ return (0,_common__WEBPACK_IMPORTED_MODULE_0__.mapObj)(this.tranSvc._pluginapi._getPathTypes(), function () { return true; });
+ };
+ /**
+ * Gets matching nodes as [[IMatchingNodes]]
+ *
+ * Create a IMatchingNodes object from the TransitionHookTypes that is roughly equivalent to:
+ *
+ * ```js
+ * let matches: IMatchingNodes = {
+ * to: _matchingNodes([tail(treeChanges.to)], mc.to),
+ * from: _matchingNodes([tail(treeChanges.from)], mc.from),
+ * exiting: _matchingNodes(treeChanges.exiting, mc.exiting),
+ * retained: _matchingNodes(treeChanges.retained, mc.retained),
+ * entering: _matchingNodes(treeChanges.entering, mc.entering),
+ * };
+ * ```
+ */
+ RegisteredHook.prototype._getMatchingNodes = function (treeChanges, transition) {
+ var _this = this;
+ var criteria = (0,_common__WEBPACK_IMPORTED_MODULE_0__.extend)(this._getDefaultMatchCriteria(), this.matchCriteria);
+ var paths = (0,_common__WEBPACK_IMPORTED_MODULE_0__.values)(this.tranSvc._pluginapi._getPathTypes());
+ return paths.reduce(function (mn, pathtype) {
+ // STATE scope criteria matches against every node in the path.
+ // TRANSITION scope criteria matches against only the last node in the path
+ var isStateHook = pathtype.scope === _interface__WEBPACK_IMPORTED_MODULE_1__.TransitionHookScope.STATE;
+ var path = treeChanges[pathtype.name] || [];
+ var nodes = isStateHook ? path : [(0,_common__WEBPACK_IMPORTED_MODULE_0__.tail)(path)];
+ mn[pathtype.name] = _this._matchingNodes(nodes, criteria[pathtype.name], transition);
+ return mn;
+ }, {});
+ };
+ /**
+ * Determines if this hook's [[matchCriteria]] match the given [[TreeChanges]]
+ *
+ * @returns an IMatchingNodes object, or null. If an IMatchingNodes object is returned, its values
+ * are the matching [[PathNode]]s for each [[HookMatchCriterion]] (to, from, exiting, retained, entering)
+ */
+ RegisteredHook.prototype.matches = function (treeChanges, transition) {
+ var matches = this._getMatchingNodes(treeChanges, transition);
+ // Check if all the criteria matched the TreeChanges object
+ var allMatched = (0,_common__WEBPACK_IMPORTED_MODULE_0__.values)(matches).every(_common__WEBPACK_IMPORTED_MODULE_0__.identity);
+ return allMatched ? matches : null;
+ };
+ RegisteredHook.prototype.deregister = function () {
+ this.removeHookFromRegistry(this);
+ this._deregistered = true;
+ };
+ return RegisteredHook;
+}());
+
+/** Return a registration function of the requested type. */
+function makeEvent(registry, transitionService, eventType) {
+ // Create the object which holds the registered transition hooks.
+ var _registeredHooks = (registry._registeredHooks = registry._registeredHooks || {});
+ var hooks = (_registeredHooks[eventType.name] = []);
+ var removeHookFn = (0,_common__WEBPACK_IMPORTED_MODULE_0__.removeFrom)(hooks);
+ // Create hook registration function on the IHookRegistry for the event
+ registry[eventType.name] = hookRegistrationFn;
+ function hookRegistrationFn(matchObject, callback, options) {
+ if (options === void 0) { options = {}; }
+ var registeredHook = new RegisteredHook(transitionService, eventType, callback, matchObject, removeHookFn, options);
+ hooks.push(registeredHook);
+ return registeredHook.deregister.bind(registeredHook);
+ }
+ return hookRegistrationFn;
+}
+//# sourceMappingURL=hookRegistry.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/transition/index.js":
+/*!*****************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/transition/index.js ***!
+ \*****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "TransitionHookPhase": () => (/* reexport safe */ _interface__WEBPACK_IMPORTED_MODULE_0__.TransitionHookPhase),
+/* harmony export */ "TransitionHookScope": () => (/* reexport safe */ _interface__WEBPACK_IMPORTED_MODULE_0__.TransitionHookScope),
+/* harmony export */ "HookBuilder": () => (/* reexport safe */ _hookBuilder__WEBPACK_IMPORTED_MODULE_1__.HookBuilder),
+/* harmony export */ "RegisteredHook": () => (/* reexport safe */ _hookRegistry__WEBPACK_IMPORTED_MODULE_2__.RegisteredHook),
+/* harmony export */ "makeEvent": () => (/* reexport safe */ _hookRegistry__WEBPACK_IMPORTED_MODULE_2__.makeEvent),
+/* harmony export */ "matchState": () => (/* reexport safe */ _hookRegistry__WEBPACK_IMPORTED_MODULE_2__.matchState),
+/* harmony export */ "RejectType": () => (/* reexport safe */ _rejectFactory__WEBPACK_IMPORTED_MODULE_3__.RejectType),
+/* harmony export */ "Rejection": () => (/* reexport safe */ _rejectFactory__WEBPACK_IMPORTED_MODULE_3__.Rejection),
+/* harmony export */ "Transition": () => (/* reexport safe */ _transition__WEBPACK_IMPORTED_MODULE_4__.Transition),
+/* harmony export */ "TransitionHook": () => (/* reexport safe */ _transitionHook__WEBPACK_IMPORTED_MODULE_5__.TransitionHook),
+/* harmony export */ "TransitionEventType": () => (/* reexport safe */ _transitionEventType__WEBPACK_IMPORTED_MODULE_6__.TransitionEventType),
+/* harmony export */ "TransitionService": () => (/* reexport safe */ _transitionService__WEBPACK_IMPORTED_MODULE_7__.TransitionService),
+/* harmony export */ "defaultTransOpts": () => (/* reexport safe */ _transitionService__WEBPACK_IMPORTED_MODULE_7__.defaultTransOpts)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/transition/interface.js");
+/* harmony import */ var _hookBuilder__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./hookBuilder */ "./node_modules/@uirouter/core/lib-esm/transition/hookBuilder.js");
+/* harmony import */ var _hookRegistry__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./hookRegistry */ "./node_modules/@uirouter/core/lib-esm/transition/hookRegistry.js");
+/* harmony import */ var _rejectFactory__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./rejectFactory */ "./node_modules/@uirouter/core/lib-esm/transition/rejectFactory.js");
+/* harmony import */ var _transition__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./transition */ "./node_modules/@uirouter/core/lib-esm/transition/transition.js");
+/* harmony import */ var _transitionHook__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./transitionHook */ "./node_modules/@uirouter/core/lib-esm/transition/transitionHook.js");
+/* harmony import */ var _transitionEventType__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./transitionEventType */ "./node_modules/@uirouter/core/lib-esm/transition/transitionEventType.js");
+/* harmony import */ var _transitionService__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./transitionService */ "./node_modules/@uirouter/core/lib-esm/transition/transitionService.js");
+/**
+ * # Transition subsystem
+ *
+ * This module contains APIs related to a Transition.
+ *
+ * See:
+ * - [[TransitionService]]
+ * - [[Transition]]
+ * - [[HookFn]], [[TransitionHookFn]], [[TransitionStateHookFn]], [[HookMatchCriteria]], [[HookResult]]
+ *
+ * @packageDocumentation @preferred
+ */
+
+
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/transition/interface.js":
+/*!*********************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/transition/interface.js ***!
+ \*********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "TransitionHookPhase": () => (/* binding */ TransitionHookPhase),
+/* harmony export */ "TransitionHookScope": () => (/* binding */ TransitionHookScope)
+/* harmony export */ });
+var TransitionHookPhase;
+(function (TransitionHookPhase) {
+ TransitionHookPhase[TransitionHookPhase["CREATE"] = 0] = "CREATE";
+ TransitionHookPhase[TransitionHookPhase["BEFORE"] = 1] = "BEFORE";
+ TransitionHookPhase[TransitionHookPhase["RUN"] = 2] = "RUN";
+ TransitionHookPhase[TransitionHookPhase["SUCCESS"] = 3] = "SUCCESS";
+ TransitionHookPhase[TransitionHookPhase["ERROR"] = 4] = "ERROR";
+})(TransitionHookPhase || (TransitionHookPhase = {}));
+var TransitionHookScope;
+(function (TransitionHookScope) {
+ TransitionHookScope[TransitionHookScope["TRANSITION"] = 0] = "TRANSITION";
+ TransitionHookScope[TransitionHookScope["STATE"] = 1] = "STATE";
+})(TransitionHookScope || (TransitionHookScope = {}));
+
+//# sourceMappingURL=interface.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/transition/rejectFactory.js":
+/*!*************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/transition/rejectFactory.js ***!
+ \*************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "RejectType": () => (/* binding */ RejectType),
+/* harmony export */ "Rejection": () => (/* binding */ Rejection)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_strings__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+
+
+
+
+/** An enum for Transition Rejection reasons */
+var RejectType;
+(function (RejectType) {
+ /**
+ * A new transition superseded this one.
+ *
+ * While this transition was running, a new transition started.
+ * This transition is cancelled because it was superseded by new transition.
+ */
+ RejectType[RejectType["SUPERSEDED"] = 2] = "SUPERSEDED";
+ /**
+ * The transition was aborted
+ *
+ * The transition was aborted by a hook which returned `false`
+ */
+ RejectType[RejectType["ABORTED"] = 3] = "ABORTED";
+ /**
+ * The transition was invalid
+ *
+ * The transition was never started because it was invalid
+ */
+ RejectType[RejectType["INVALID"] = 4] = "INVALID";
+ /**
+ * The transition was ignored
+ *
+ * The transition was ignored because it would have no effect.
+ *
+ * Either:
+ *
+ * - The transition is targeting the current state and parameter values
+ * - The transition is targeting the same state and parameter values as the currently running transition.
+ */
+ RejectType[RejectType["IGNORED"] = 5] = "IGNORED";
+ /**
+ * The transition errored.
+ *
+ * This generally means a hook threw an error or returned a rejected promise
+ */
+ RejectType[RejectType["ERROR"] = 6] = "ERROR";
+})(RejectType || (RejectType = {}));
+
+/** @internal */
+var id = 0;
+var Rejection = /** @class */ (function () {
+ function Rejection(type, message, detail) {
+ /** @internal */
+ this.$id = id++;
+ this.type = type;
+ this.message = message;
+ this.detail = detail;
+ }
+ /** Returns true if the obj is a rejected promise created from the `asPromise` factory */
+ Rejection.isRejectionPromise = function (obj) {
+ return obj && typeof obj.then === 'function' && (0,_common_hof__WEBPACK_IMPORTED_MODULE_2__.is)(Rejection)(obj._transitionRejection);
+ };
+ /** Returns a Rejection due to transition superseded */
+ Rejection.superseded = function (detail, options) {
+ var message = 'The transition has been superseded by a different transition';
+ var rejection = new Rejection(RejectType.SUPERSEDED, message, detail);
+ if (options && options.redirected) {
+ rejection.redirected = true;
+ }
+ return rejection;
+ };
+ /** Returns a Rejection due to redirected transition */
+ Rejection.redirected = function (detail) {
+ return Rejection.superseded(detail, { redirected: true });
+ };
+ /** Returns a Rejection due to invalid transition */
+ Rejection.invalid = function (detail) {
+ var message = 'This transition is invalid';
+ return new Rejection(RejectType.INVALID, message, detail);
+ };
+ /** Returns a Rejection due to ignored transition */
+ Rejection.ignored = function (detail) {
+ var message = 'The transition was ignored';
+ return new Rejection(RejectType.IGNORED, message, detail);
+ };
+ /** Returns a Rejection due to aborted transition */
+ Rejection.aborted = function (detail) {
+ var message = 'The transition has been aborted';
+ return new Rejection(RejectType.ABORTED, message, detail);
+ };
+ /** Returns a Rejection due to aborted transition */
+ Rejection.errored = function (detail) {
+ var message = 'The transition errored';
+ return new Rejection(RejectType.ERROR, message, detail);
+ };
+ /**
+ * Returns a Rejection
+ *
+ * Normalizes a value as a Rejection.
+ * If the value is already a Rejection, returns it.
+ * Otherwise, wraps and returns the value as a Rejection (Rejection type: ERROR).
+ *
+ * @returns `detail` if it is already a `Rejection`, else returns an ERROR Rejection.
+ */
+ Rejection.normalize = function (detail) {
+ return (0,_common_hof__WEBPACK_IMPORTED_MODULE_2__.is)(Rejection)(detail) ? detail : Rejection.errored(detail);
+ };
+ Rejection.prototype.toString = function () {
+ var detailString = function (d) { return (d && d.toString !== Object.prototype.toString ? d.toString() : (0,_common_strings__WEBPACK_IMPORTED_MODULE_1__.stringify)(d)); };
+ var detail = detailString(this.detail);
+ var _a = this, $id = _a.$id, type = _a.type, message = _a.message;
+ return "Transition Rejection($id: " + $id + " type: " + type + ", message: " + message + ", detail: " + detail + ")";
+ };
+ Rejection.prototype.toPromise = function () {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.extend)((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.silentRejection)(this), { _transitionRejection: this });
+ };
+ return Rejection;
+}());
+
+//# sourceMappingURL=rejectFactory.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/transition/transition.js":
+/*!**********************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/transition/transition.js ***!
+ \**********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "Transition": () => (/* binding */ Transition)
+/* harmony export */ });
+/* harmony import */ var _common_trace__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/trace */ "./node_modules/@uirouter/core/lib-esm/common/trace.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+/* harmony import */ var _common_strings__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/transition/interface.js");
+/* harmony import */ var _transitionHook__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./transitionHook */ "./node_modules/@uirouter/core/lib-esm/transition/transitionHook.js");
+/* harmony import */ var _hookRegistry__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./hookRegistry */ "./node_modules/@uirouter/core/lib-esm/transition/hookRegistry.js");
+/* harmony import */ var _hookBuilder__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./hookBuilder */ "./node_modules/@uirouter/core/lib-esm/transition/hookBuilder.js");
+/* harmony import */ var _path_pathUtils__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../path/pathUtils */ "./node_modules/@uirouter/core/lib-esm/path/pathUtils.js");
+/* harmony import */ var _params_param__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../params/param */ "./node_modules/@uirouter/core/lib-esm/params/param.js");
+/* harmony import */ var _resolve_resolvable__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../resolve/resolvable */ "./node_modules/@uirouter/core/lib-esm/resolve/resolvable.js");
+/* harmony import */ var _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../resolve/resolveContext */ "./node_modules/@uirouter/core/lib-esm/resolve/resolveContext.js");
+/* harmony import */ var _rejectFactory__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./rejectFactory */ "./node_modules/@uirouter/core/lib-esm/transition/rejectFactory.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+
+
+
+
+
+ // has or is using
+
+
+
+
+
+
+
+
+
+/** @internal */
+var stateSelf = (0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.prop)('self');
+/**
+ * Represents a transition between two states.
+ *
+ * When navigating to a state, we are transitioning **from** the current state **to** the new state.
+ *
+ * This object contains all contextual information about the to/from states, parameters, resolves.
+ * It has information about all states being entered and exited as a result of the transition.
+ */
+var Transition = /** @class */ (function () {
+ /**
+ * Creates a new Transition object.
+ *
+ * If the target state is not valid, an error is thrown.
+ *
+ * @internal
+ *
+ * @param fromPath The path of [[PathNode]]s from which the transition is leaving. The last node in the `fromPath`
+ * encapsulates the "from state".
+ * @param targetState The target state and parameters being transitioned to (also, the transition options)
+ * @param router The [[UIRouter]] instance
+ * @internal
+ */
+ function Transition(fromPath, targetState, router) {
+ var _this = this;
+ /** @internal */
+ this._deferred = _common_coreservices__WEBPACK_IMPORTED_MODULE_1__.services.$q.defer();
+ /**
+ * This promise is resolved or rejected based on the outcome of the Transition.
+ *
+ * When the transition is successful, the promise is resolved
+ * When the transition is unsuccessful, the promise is rejected with the [[Rejection]] or javascript error
+ */
+ this.promise = this._deferred.promise;
+ /** @internal Holds the hook registration functions such as those passed to Transition.onStart() */
+ this._registeredHooks = {};
+ /** @internal */
+ this._hookBuilder = new _hookBuilder__WEBPACK_IMPORTED_MODULE_9__.HookBuilder(this);
+ /** Checks if this transition is currently active/running. */
+ this.isActive = function () { return _this.router.globals.transition === _this; };
+ this.router = router;
+ this._targetState = targetState;
+ if (!targetState.valid()) {
+ throw new Error(targetState.error());
+ }
+ // current() is assumed to come from targetState.options, but provide a naive implementation otherwise.
+ this._options = (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.extend)({ current: (0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.val)(this) }, targetState.options());
+ this.$id = router.transitionService._transitionCount++;
+ var toPath = _path_pathUtils__WEBPACK_IMPORTED_MODULE_10__.PathUtils.buildToPath(fromPath, targetState);
+ this._treeChanges = _path_pathUtils__WEBPACK_IMPORTED_MODULE_10__.PathUtils.treeChanges(fromPath, toPath, this._options.reloadState);
+ this.createTransitionHookRegFns();
+ var onCreateHooks = this._hookBuilder.buildHooksForPhase(_interface__WEBPACK_IMPORTED_MODULE_6__.TransitionHookPhase.CREATE);
+ _transitionHook__WEBPACK_IMPORTED_MODULE_7__.TransitionHook.invokeHooks(onCreateHooks, function () { return null; });
+ this.applyViewConfigs(router);
+ }
+ /** @internal */
+ Transition.prototype.onBefore = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ Transition.prototype.onStart = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ Transition.prototype.onExit = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ Transition.prototype.onRetain = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ Transition.prototype.onEnter = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ Transition.prototype.onFinish = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ Transition.prototype.onSuccess = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ Transition.prototype.onError = function (criteria, callback, options) {
+ return;
+ };
+ /** @internal
+ * Creates the transition-level hook registration functions
+ * (which can then be used to register hooks)
+ */
+ Transition.prototype.createTransitionHookRegFns = function () {
+ var _this = this;
+ this.router.transitionService._pluginapi
+ ._getEvents()
+ .filter(function (type) { return type.hookPhase !== _interface__WEBPACK_IMPORTED_MODULE_6__.TransitionHookPhase.CREATE; })
+ .forEach(function (type) { return (0,_hookRegistry__WEBPACK_IMPORTED_MODULE_8__.makeEvent)(_this, _this.router.transitionService, type); });
+ };
+ /** @internal */
+ Transition.prototype.getHooks = function (hookName) {
+ return this._registeredHooks[hookName];
+ };
+ Transition.prototype.applyViewConfigs = function (router) {
+ var enteringStates = this._treeChanges.entering.map(function (node) { return node.state; });
+ _path_pathUtils__WEBPACK_IMPORTED_MODULE_10__.PathUtils.applyViewConfigs(router.transitionService.$view, this._treeChanges.to, enteringStates);
+ };
+ /**
+ * @internal
+ * @returns the internal from [State] object
+ */
+ Transition.prototype.$from = function () {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.tail)(this._treeChanges.from).state;
+ };
+ /**
+ * @internal
+ * @returns the internal to [State] object
+ */
+ Transition.prototype.$to = function () {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.tail)(this._treeChanges.to).state;
+ };
+ /**
+ * Returns the "from state"
+ *
+ * Returns the state that the transition is coming *from*.
+ *
+ * @returns The state declaration object for the Transition's ("from state").
+ */
+ Transition.prototype.from = function () {
+ return this.$from().self;
+ };
+ /**
+ * Returns the "to state"
+ *
+ * Returns the state that the transition is going *to*.
+ *
+ * @returns The state declaration object for the Transition's target state ("to state").
+ */
+ Transition.prototype.to = function () {
+ return this.$to().self;
+ };
+ /**
+ * Gets the Target State
+ *
+ * A transition's [[TargetState]] encapsulates the [[to]] state, the [[params]], and the [[options]] as a single object.
+ *
+ * @returns the [[TargetState]] of this Transition
+ */
+ Transition.prototype.targetState = function () {
+ return this._targetState;
+ };
+ /**
+ * Determines whether two transitions are equivalent.
+ * @deprecated
+ */
+ Transition.prototype.is = function (compare) {
+ if (compare instanceof Transition) {
+ // TODO: Also compare parameters
+ return this.is({ to: compare.$to().name, from: compare.$from().name });
+ }
+ return !((compare.to && !(0,_hookRegistry__WEBPACK_IMPORTED_MODULE_8__.matchState)(this.$to(), compare.to, this)) ||
+ (compare.from && !(0,_hookRegistry__WEBPACK_IMPORTED_MODULE_8__.matchState)(this.$from(), compare.from, this)));
+ };
+ Transition.prototype.params = function (pathname) {
+ if (pathname === void 0) { pathname = 'to'; }
+ return Object.freeze(this._treeChanges[pathname].map((0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.prop)('paramValues')).reduce(_common_common__WEBPACK_IMPORTED_MODULE_3__.mergeR, {}));
+ };
+ Transition.prototype.paramsChanged = function () {
+ var fromParams = this.params('from');
+ var toParams = this.params('to');
+ // All the parameters declared on both the "to" and "from" paths
+ var allParamDescriptors = []
+ .concat(this._treeChanges.to)
+ .concat(this._treeChanges.from)
+ .map(function (pathNode) { return pathNode.paramSchema; })
+ .reduce(_common__WEBPACK_IMPORTED_MODULE_15__.flattenR, [])
+ .reduce(_common__WEBPACK_IMPORTED_MODULE_15__.uniqR, []);
+ var changedParamDescriptors = _params_param__WEBPACK_IMPORTED_MODULE_11__.Param.changed(allParamDescriptors, fromParams, toParams);
+ return changedParamDescriptors.reduce(function (changedValues, descriptor) {
+ changedValues[descriptor.id] = toParams[descriptor.id];
+ return changedValues;
+ }, {});
+ };
+ /**
+ * Creates a [[UIInjector]] Dependency Injector
+ *
+ * Returns a Dependency Injector for the Transition's target state (to state).
+ * The injector provides resolve values which the target state has access to.
+ *
+ * The `UIInjector` can also provide values from the native root/global injector (ng1/ng2).
+ *
+ * #### Example:
+ * ```js
+ * .onEnter({ entering: 'myState' }, trans => {
+ * var myResolveValue = trans.injector().get('myResolve');
+ * // Inject a global service from the global/native injector (if it exists)
+ * var MyService = trans.injector().get('MyService');
+ * })
+ * ```
+ *
+ * In some cases (such as `onBefore`), you may need access to some resolve data but it has not yet been fetched.
+ * You can use [[UIInjector.getAsync]] to get a promise for the data.
+ * #### Example:
+ * ```js
+ * .onBefore({}, trans => {
+ * return trans.injector().getAsync('myResolve').then(myResolveValue =>
+ * return myResolveValue !== 'ABORT';
+ * });
+ * });
+ * ```
+ *
+ * If a `state` is provided, the injector that is returned will be limited to resolve values that the provided state has access to.
+ * This can be useful if both a parent state `foo` and a child state `foo.bar` have both defined a resolve such as `data`.
+ * #### Example:
+ * ```js
+ * .onEnter({ to: 'foo.bar' }, trans => {
+ * // returns result of `foo` state's `myResolve` resolve
+ * // even though `foo.bar` also has a `myResolve` resolve
+ * var fooData = trans.injector('foo').get('myResolve');
+ * });
+ * ```
+ *
+ * If you need resolve data from the exiting states, pass `'from'` as `pathName`.
+ * The resolve data from the `from` path will be returned.
+ * #### Example:
+ * ```js
+ * .onExit({ exiting: 'foo.bar' }, trans => {
+ * // Gets the resolve value of `myResolve` from the state being exited
+ * var fooData = trans.injector(null, 'from').get('myResolve');
+ * });
+ * ```
+ *
+ *
+ * @param state Limits the resolves provided to only the resolves the provided state has access to.
+ * @param pathName Default: `'to'`: Chooses the path for which to create the injector. Use this to access resolves for `exiting` states.
+ *
+ * @returns a [[UIInjector]]
+ */
+ Transition.prototype.injector = function (state, pathName) {
+ if (pathName === void 0) { pathName = 'to'; }
+ var path = this._treeChanges[pathName];
+ if (state)
+ path = _path_pathUtils__WEBPACK_IMPORTED_MODULE_10__.PathUtils.subPath(path, function (node) { return node.state === state || node.state.name === state; });
+ return new _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_13__.ResolveContext(path).injector();
+ };
+ /**
+ * Gets all available resolve tokens (keys)
+ *
+ * This method can be used in conjunction with [[injector]] to inspect the resolve values
+ * available to the Transition.
+ *
+ * This returns all the tokens defined on [[StateDeclaration.resolve]] blocks, for the states
+ * in the Transition's [[TreeChanges.to]] path.
+ *
+ * #### Example:
+ * This example logs all resolve values
+ * ```js
+ * let tokens = trans.getResolveTokens();
+ * tokens.forEach(token => console.log(token + " = " + trans.injector().get(token)));
+ * ```
+ *
+ * #### Example:
+ * This example creates promises for each resolve value.
+ * This triggers fetches of resolves (if any have not yet been fetched).
+ * When all promises have all settled, it logs the resolve values.
+ * ```js
+ * let tokens = trans.getResolveTokens();
+ * let promise = tokens.map(token => trans.injector().getAsync(token));
+ * Promise.all(promises).then(values => console.log("Resolved values: " + values));
+ * ```
+ *
+ * Note: Angular 1 users whould use `$q.all()`
+ *
+ * @param pathname resolve context's path name (e.g., `to` or `from`)
+ *
+ * @returns an array of resolve tokens (keys)
+ */
+ Transition.prototype.getResolveTokens = function (pathname) {
+ if (pathname === void 0) { pathname = 'to'; }
+ return new _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_13__.ResolveContext(this._treeChanges[pathname]).getTokens();
+ };
+ /**
+ * Dynamically adds a new [[Resolvable]] (i.e., [[StateDeclaration.resolve]]) to this transition.
+ *
+ * Allows a transition hook to dynamically add a Resolvable to this Transition.
+ *
+ * Use the [[Transition.injector]] to retrieve the resolved data in subsequent hooks ([[UIInjector.get]]).
+ *
+ * If a `state` argument is provided, the Resolvable is processed when that state is being entered.
+ * If no `state` is provided then the root state is used.
+ * If the given `state` has already been entered, the Resolvable is processed when any child state is entered.
+ * If no child states will be entered, the Resolvable is processed during the `onFinish` phase of the Transition.
+ *
+ * The `state` argument also scopes the resolved data.
+ * The resolved data is available from the injector for that `state` and any children states.
+ *
+ * #### Example:
+ * ```js
+ * transitionService.onBefore({}, transition => {
+ * transition.addResolvable({
+ * token: 'myResolve',
+ * deps: ['MyService'],
+ * resolveFn: myService => myService.getData()
+ * });
+ * });
+ * ```
+ *
+ * @param resolvable a [[ResolvableLiteral]] object (or a [[Resolvable]])
+ * @param state the state in the "to path" which should receive the new resolve (otherwise, the root state)
+ */
+ Transition.prototype.addResolvable = function (resolvable, state) {
+ if (state === void 0) { state = ''; }
+ resolvable = (0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.is)(_resolve_resolvable__WEBPACK_IMPORTED_MODULE_12__.Resolvable)(resolvable) ? resolvable : new _resolve_resolvable__WEBPACK_IMPORTED_MODULE_12__.Resolvable(resolvable);
+ var stateName = typeof state === 'string' ? state : state.name;
+ var topath = this._treeChanges.to;
+ var targetNode = (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.find)(topath, function (node) { return node.state.name === stateName; });
+ var resolveContext = new _resolve_resolveContext__WEBPACK_IMPORTED_MODULE_13__.ResolveContext(topath);
+ resolveContext.addResolvables([resolvable], targetNode.state);
+ };
+ /**
+ * Gets the transition from which this transition was redirected.
+ *
+ * If the current transition is a redirect, this method returns the transition that was redirected.
+ *
+ * #### Example:
+ * ```js
+ * let transitionA = $state.go('A').transition
+ * transitionA.onStart({}, () => $state.target('B'));
+ * $transitions.onSuccess({ to: 'B' }, (trans) => {
+ * trans.to().name === 'B'; // true
+ * trans.redirectedFrom() === transitionA; // true
+ * });
+ * ```
+ *
+ * @returns The previous Transition, or null if this Transition is not the result of a redirection
+ */
+ Transition.prototype.redirectedFrom = function () {
+ return this._options.redirectedFrom || null;
+ };
+ /**
+ * Gets the original transition in a redirect chain
+ *
+ * A transition might belong to a long chain of multiple redirects.
+ * This method walks the [[redirectedFrom]] chain back to the original (first) transition in the chain.
+ *
+ * #### Example:
+ * ```js
+ * // states
+ * registry.register({ name: 'A', redirectTo: 'B' });
+ * registry.register({ name: 'B', redirectTo: 'C' });
+ * registry.register({ name: 'C', redirectTo: 'D' });
+ * registry.register({ name: 'D' });
+ *
+ * let transitionA = $state.go('A').transition
+ *
+ * $transitions.onSuccess({ to: 'D' }, (trans) => {
+ * trans.to().name === 'D'; // true
+ * trans.redirectedFrom().to().name === 'C'; // true
+ * trans.originalTransition() === transitionA; // true
+ * trans.originalTransition().to().name === 'A'; // true
+ * });
+ * ```
+ *
+ * @returns The original Transition that started a redirect chain
+ */
+ Transition.prototype.originalTransition = function () {
+ var rf = this.redirectedFrom();
+ return (rf && rf.originalTransition()) || this;
+ };
+ /**
+ * Get the transition options
+ *
+ * @returns the options for this Transition.
+ */
+ Transition.prototype.options = function () {
+ return this._options;
+ };
+ /**
+ * Gets the states being entered.
+ *
+ * @returns an array of states that will be entered during this transition.
+ */
+ Transition.prototype.entering = function () {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.map)(this._treeChanges.entering, (0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.prop)('state')).map(stateSelf);
+ };
+ /**
+ * Gets the states being exited.
+ *
+ * @returns an array of states that will be exited during this transition.
+ */
+ Transition.prototype.exiting = function () {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.map)(this._treeChanges.exiting, (0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.prop)('state')).map(stateSelf).reverse();
+ };
+ /**
+ * Gets the states being retained.
+ *
+ * @returns an array of states that are already entered from a previous Transition, that will not be
+ * exited during this Transition
+ */
+ Transition.prototype.retained = function () {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.map)(this._treeChanges.retained, (0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.prop)('state')).map(stateSelf);
+ };
+ /**
+ * Get the [[ViewConfig]]s associated with this Transition
+ *
+ * Each state can define one or more views (template/controller), which are encapsulated as `ViewConfig` objects.
+ * This method fetches the `ViewConfigs` for a given path in the Transition (e.g., "to" or "entering").
+ *
+ * @param pathname the name of the path to fetch views for:
+ * (`'to'`, `'from'`, `'entering'`, `'exiting'`, `'retained'`)
+ * @param state If provided, only returns the `ViewConfig`s for a single state in the path
+ *
+ * @returns a list of ViewConfig objects for the given path.
+ */
+ Transition.prototype.views = function (pathname, state) {
+ if (pathname === void 0) { pathname = 'entering'; }
+ var path = this._treeChanges[pathname];
+ path = !state ? path : path.filter((0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.propEq)('state', state));
+ return path.map((0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.prop)('views')).filter(_common_common__WEBPACK_IMPORTED_MODULE_3__.identity).reduce(_common_common__WEBPACK_IMPORTED_MODULE_3__.unnestR, []);
+ };
+ Transition.prototype.treeChanges = function (pathname) {
+ return pathname ? this._treeChanges[pathname] : this._treeChanges;
+ };
+ /**
+ * Creates a new transition that is a redirection of the current one.
+ *
+ * This transition can be returned from a [[TransitionService]] hook to
+ * redirect a transition to a new state and/or set of parameters.
+ *
+ * @internal
+ *
+ * @returns Returns a new [[Transition]] instance.
+ */
+ Transition.prototype.redirect = function (targetState) {
+ var redirects = 1, trans = this;
+ // tslint:disable-next-line:no-conditional-assignment
+ while ((trans = trans.redirectedFrom()) != null) {
+ if (++redirects > 20)
+ throw new Error("Too many consecutive Transition redirects (20+)");
+ }
+ var redirectOpts = { redirectedFrom: this, source: 'redirect' };
+ // If the original transition was caused by URL sync, then use { location: 'replace' }
+ // on the new transition (unless the target state explicitly specifies location: false).
+ // This causes the original url to be replaced with the url for the redirect target
+ // so the original url disappears from the browser history.
+ if (this.options().source === 'url' && targetState.options().location !== false) {
+ redirectOpts.location = 'replace';
+ }
+ var newOptions = (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.extend)({}, this.options(), targetState.options(), redirectOpts);
+ targetState = targetState.withOptions(newOptions, true);
+ var newTransition = this.router.transitionService.create(this._treeChanges.from, targetState);
+ var originalEnteringNodes = this._treeChanges.entering;
+ var redirectEnteringNodes = newTransition._treeChanges.entering;
+ // --- Re-use resolve data from original transition ---
+ // When redirecting from a parent state to a child state where the parent parameter values haven't changed
+ // (because of the redirect), the resolves fetched by the original transition are still valid in the
+ // redirected transition.
+ //
+ // This allows you to define a redirect on a parent state which depends on an async resolve value.
+ // You can wait for the resolve, then redirect to a child state based on the result.
+ // The redirected transition does not have to re-fetch the resolve.
+ // ---------------------------------------------------------
+ var nodeIsReloading = function (reloadState) { return function (node) {
+ return reloadState && node.state.includes[reloadState.name];
+ }; };
+ // Find any "entering" nodes in the redirect path that match the original path and aren't being reloaded
+ var matchingEnteringNodes = _path_pathUtils__WEBPACK_IMPORTED_MODULE_10__.PathUtils.matching(redirectEnteringNodes, originalEnteringNodes, _path_pathUtils__WEBPACK_IMPORTED_MODULE_10__.PathUtils.nonDynamicParams).filter((0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.not)(nodeIsReloading(targetState.options().reloadState)));
+ // Use the existing (possibly pre-resolved) resolvables for the matching entering nodes.
+ matchingEnteringNodes.forEach(function (node, idx) {
+ node.resolvables = originalEnteringNodes[idx].resolvables;
+ });
+ return newTransition;
+ };
+ /** @internal If a transition doesn't exit/enter any states, returns any [[Param]] whose value changed */
+ Transition.prototype._changedParams = function () {
+ var tc = this._treeChanges;
+ /** Return undefined if it's not a "dynamic" transition, for the following reasons */
+ // If user explicitly wants a reload
+ if (this._options.reload)
+ return undefined;
+ // If any states are exiting or entering
+ if (tc.exiting.length || tc.entering.length)
+ return undefined;
+ // If to/from path lengths differ
+ if (tc.to.length !== tc.from.length)
+ return undefined;
+ // If the to/from paths are different
+ var pathsDiffer = (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.arrayTuples)(tc.to, tc.from)
+ .map(function (tuple) { return tuple[0].state !== tuple[1].state; })
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_3__.anyTrueR, false);
+ if (pathsDiffer)
+ return undefined;
+ // Find any parameter values that differ
+ var nodeSchemas = tc.to.map(function (node) { return node.paramSchema; });
+ var _a = [tc.to, tc.from].map(function (path) { return path.map(function (x) { return x.paramValues; }); }), toValues = _a[0], fromValues = _a[1];
+ var tuples = (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.arrayTuples)(nodeSchemas, toValues, fromValues);
+ return tuples.map(function (_a) {
+ var schema = _a[0], toVals = _a[1], fromVals = _a[2];
+ return _params_param__WEBPACK_IMPORTED_MODULE_11__.Param.changed(schema, toVals, fromVals);
+ }).reduce(_common_common__WEBPACK_IMPORTED_MODULE_3__.unnestR, []);
+ };
+ /**
+ * Returns true if the transition is dynamic.
+ *
+ * A transition is dynamic if no states are entered nor exited, but at least one dynamic parameter has changed.
+ *
+ * @returns true if the Transition is dynamic
+ */
+ Transition.prototype.dynamic = function () {
+ var changes = this._changedParams();
+ return !changes ? false : changes.map(function (x) { return x.dynamic; }).reduce(_common_common__WEBPACK_IMPORTED_MODULE_3__.anyTrueR, false);
+ };
+ /**
+ * Returns true if the transition is ignored.
+ *
+ * A transition is ignored if no states are entered nor exited, and no parameter values have changed.
+ *
+ * @returns true if the Transition is ignored.
+ */
+ Transition.prototype.ignored = function () {
+ return !!this._ignoredReason();
+ };
+ /** @internal */
+ Transition.prototype._ignoredReason = function () {
+ var pending = this.router.globals.transition;
+ var reloadState = this._options.reloadState;
+ var same = function (pathA, pathB) {
+ if (pathA.length !== pathB.length)
+ return false;
+ var matching = _path_pathUtils__WEBPACK_IMPORTED_MODULE_10__.PathUtils.matching(pathA, pathB);
+ return pathA.length === matching.filter(function (node) { return !reloadState || !node.state.includes[reloadState.name]; }).length;
+ };
+ var newTC = this.treeChanges();
+ var pendTC = pending && pending.treeChanges();
+ if (pendTC && same(pendTC.to, newTC.to) && same(pendTC.exiting, newTC.exiting))
+ return 'SameAsPending';
+ if (newTC.exiting.length === 0 && newTC.entering.length === 0 && same(newTC.from, newTC.to))
+ return 'SameAsCurrent';
+ };
+ /**
+ * Runs the transition
+ *
+ * This method is generally called from the [[StateService.transitionTo]]
+ *
+ * @internal
+ *
+ * @returns a promise for a successful transition.
+ */
+ Transition.prototype.run = function () {
+ var _this = this;
+ var runAllHooks = _transitionHook__WEBPACK_IMPORTED_MODULE_7__.TransitionHook.runAllHooks;
+ // Gets transition hooks array for the given phase
+ var getHooksFor = function (phase) { return _this._hookBuilder.buildHooksForPhase(phase); };
+ // When the chain is complete, then resolve or reject the deferred
+ var transitionSuccess = function () {
+ _common_trace__WEBPACK_IMPORTED_MODULE_0__.trace.traceSuccess(_this.$to(), _this);
+ _this.success = true;
+ _this._deferred.resolve(_this.to());
+ runAllHooks(getHooksFor(_interface__WEBPACK_IMPORTED_MODULE_6__.TransitionHookPhase.SUCCESS));
+ };
+ var transitionError = function (reason) {
+ _common_trace__WEBPACK_IMPORTED_MODULE_0__.trace.traceError(reason, _this);
+ _this.success = false;
+ _this._deferred.reject(reason);
+ _this._error = reason;
+ runAllHooks(getHooksFor(_interface__WEBPACK_IMPORTED_MODULE_6__.TransitionHookPhase.ERROR));
+ };
+ var runTransition = function () {
+ // Wait to build the RUN hook chain until the BEFORE hooks are done
+ // This allows a BEFORE hook to dynamically add additional RUN hooks via the Transition object.
+ var allRunHooks = getHooksFor(_interface__WEBPACK_IMPORTED_MODULE_6__.TransitionHookPhase.RUN);
+ var done = function () { return _common_coreservices__WEBPACK_IMPORTED_MODULE_1__.services.$q.when(undefined); };
+ return _transitionHook__WEBPACK_IMPORTED_MODULE_7__.TransitionHook.invokeHooks(allRunHooks, done);
+ };
+ var startTransition = function () {
+ var globals = _this.router.globals;
+ globals.lastStartedTransitionId = _this.$id;
+ globals.transition = _this;
+ globals.transitionHistory.enqueue(_this);
+ _common_trace__WEBPACK_IMPORTED_MODULE_0__.trace.traceTransitionStart(_this);
+ return _common_coreservices__WEBPACK_IMPORTED_MODULE_1__.services.$q.when(undefined);
+ };
+ var allBeforeHooks = getHooksFor(_interface__WEBPACK_IMPORTED_MODULE_6__.TransitionHookPhase.BEFORE);
+ _transitionHook__WEBPACK_IMPORTED_MODULE_7__.TransitionHook.invokeHooks(allBeforeHooks, startTransition)
+ .then(runTransition)
+ .then(transitionSuccess, transitionError);
+ return this.promise;
+ };
+ /**
+ * Checks if the Transition is valid
+ *
+ * @returns true if the Transition is valid
+ */
+ Transition.prototype.valid = function () {
+ return !this.error() || this.success !== undefined;
+ };
+ /**
+ * Aborts this transition
+ *
+ * Imperative API to abort a Transition.
+ * This only applies to Transitions that are not yet complete.
+ */
+ Transition.prototype.abort = function () {
+ // Do not set flag if the transition is already complete
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_4__.isUndefined)(this.success)) {
+ this._aborted = true;
+ }
+ };
+ /**
+ * The Transition error reason.
+ *
+ * If the transition is invalid (and could not be run), returns the reason the transition is invalid.
+ * If the transition was valid and ran, but was not successful, returns the reason the transition failed.
+ *
+ * @returns a transition rejection explaining why the transition is invalid, or the reason the transition failed.
+ */
+ Transition.prototype.error = function () {
+ var state = this.$to();
+ if (state.self.abstract) {
+ return _rejectFactory__WEBPACK_IMPORTED_MODULE_14__.Rejection.invalid("Cannot transition to abstract state '" + state.name + "'");
+ }
+ var paramDefs = state.parameters();
+ var values = this.params();
+ var invalidParams = paramDefs.filter(function (param) { return !param.validates(values[param.id]); });
+ if (invalidParams.length) {
+ var invalidValues = invalidParams.map(function (param) { return "[" + param.id + ":" + (0,_common_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(values[param.id]) + "]"; }).join(', ');
+ var detail = "The following parameter values are not valid for state '" + state.name + "': " + invalidValues;
+ return _rejectFactory__WEBPACK_IMPORTED_MODULE_14__.Rejection.invalid(detail);
+ }
+ if (this.success === false)
+ return this._error;
+ };
+ /**
+ * A string representation of the Transition
+ *
+ * @returns A string representation of the Transition
+ */
+ Transition.prototype.toString = function () {
+ var fromStateOrName = this.from();
+ var toStateOrName = this.to();
+ var avoidEmptyHash = function (params) {
+ return params['#'] !== null && params['#'] !== undefined ? params : (0,_common_common__WEBPACK_IMPORTED_MODULE_3__.omit)(params, ['#']);
+ };
+ // (X) means the to state is invalid.
+ var id = this.$id, from = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_4__.isObject)(fromStateOrName) ? fromStateOrName.name : fromStateOrName, fromParams = (0,_common_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(avoidEmptyHash(this._treeChanges.from.map((0,_common_hof__WEBPACK_IMPORTED_MODULE_5__.prop)('paramValues')).reduce(_common_common__WEBPACK_IMPORTED_MODULE_3__.mergeR, {}))), toValid = this.valid() ? '' : '(X) ', to = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_4__.isObject)(toStateOrName) ? toStateOrName.name : toStateOrName, toParams = (0,_common_strings__WEBPACK_IMPORTED_MODULE_2__.stringify)(avoidEmptyHash(this.params()));
+ return "Transition#" + id + "( '" + from + "'" + fromParams + " -> " + toValid + "'" + to + "'" + toParams + " )";
+ };
+ /** @internal */
+ Transition.diToken = Transition;
+ return Transition;
+}());
+
+//# sourceMappingURL=transition.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/transition/transitionEventType.js":
+/*!*******************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/transition/transitionEventType.js ***!
+ \*******************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "TransitionEventType": () => (/* binding */ TransitionEventType)
+/* harmony export */ });
+/* harmony import */ var _transitionHook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./transitionHook */ "./node_modules/@uirouter/core/lib-esm/transition/transitionHook.js");
+
+/**
+ * This class defines a type of hook, such as `onBefore` or `onEnter`.
+ * Plugins can define custom hook types, such as sticky states does for `onInactive`.
+ */
+var TransitionEventType = /** @class */ (function () {
+ /* tslint:disable:no-inferrable-types */
+ function TransitionEventType(name, hookPhase, hookOrder, criteriaMatchPath, reverseSort, getResultHandler, getErrorHandler, synchronous) {
+ if (reverseSort === void 0) { reverseSort = false; }
+ if (getResultHandler === void 0) { getResultHandler = _transitionHook__WEBPACK_IMPORTED_MODULE_0__.TransitionHook.HANDLE_RESULT; }
+ if (getErrorHandler === void 0) { getErrorHandler = _transitionHook__WEBPACK_IMPORTED_MODULE_0__.TransitionHook.REJECT_ERROR; }
+ if (synchronous === void 0) { synchronous = false; }
+ this.name = name;
+ this.hookPhase = hookPhase;
+ this.hookOrder = hookOrder;
+ this.criteriaMatchPath = criteriaMatchPath;
+ this.reverseSort = reverseSort;
+ this.getResultHandler = getResultHandler;
+ this.getErrorHandler = getErrorHandler;
+ this.synchronous = synchronous;
+ }
+ return TransitionEventType;
+}());
+
+//# sourceMappingURL=transitionEventType.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/transition/transitionHook.js":
+/*!**************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/transition/transitionHook.js ***!
+ \**************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "TransitionHook": () => (/* binding */ TransitionHook)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/transition/interface.js");
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_strings__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _common_trace__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../common/trace */ "./node_modules/@uirouter/core/lib-esm/common/trace.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+/* harmony import */ var _rejectFactory__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./rejectFactory */ "./node_modules/@uirouter/core/lib-esm/transition/rejectFactory.js");
+/* harmony import */ var _state_targetState__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../state/targetState */ "./node_modules/@uirouter/core/lib-esm/state/targetState.js");
+
+
+
+
+
+
+
+
+
+var defaultOptions = {
+ current: _common_common__WEBPACK_IMPORTED_MODULE_1__.noop,
+ transition: null,
+ traceData: {},
+ bind: null,
+};
+var TransitionHook = /** @class */ (function () {
+ function TransitionHook(transition, stateContext, registeredHook, options) {
+ var _this = this;
+ this.transition = transition;
+ this.stateContext = stateContext;
+ this.registeredHook = registeredHook;
+ this.options = options;
+ this.isSuperseded = function () { return _this.type.hookPhase === _interface__WEBPACK_IMPORTED_MODULE_0__.TransitionHookPhase.RUN && !_this.options.transition.isActive(); };
+ this.options = (0,_common_common__WEBPACK_IMPORTED_MODULE_1__.defaults)(options, defaultOptions);
+ this.type = registeredHook.eventType;
+ }
+ /**
+ * Chains together an array of TransitionHooks.
+ *
+ * Given a list of [[TransitionHook]] objects, chains them together.
+ * Each hook is invoked after the previous one completes.
+ *
+ * #### Example:
+ * ```js
+ * var hooks: TransitionHook[] = getHooks();
+ * let promise: Promise<any> = TransitionHook.chain(hooks);
+ *
+ * promise.then(handleSuccess, handleError);
+ * ```
+ *
+ * @param hooks the list of hooks to chain together
+ * @param waitFor if provided, the chain is `.then()`'ed off this promise
+ * @returns a `Promise` for sequentially invoking the hooks (in order)
+ */
+ TransitionHook.chain = function (hooks, waitFor) {
+ // Chain the next hook off the previous
+ var createHookChainR = function (prev, nextHook) { return prev.then(function () { return nextHook.invokeHook(); }); };
+ return hooks.reduce(createHookChainR, waitFor || _common_coreservices__WEBPACK_IMPORTED_MODULE_6__.services.$q.when());
+ };
+ /**
+ * Invokes all the provided TransitionHooks, in order.
+ * Each hook's return value is checked.
+ * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.
+ * If no hook returns a promise, then all hooks are processed synchronously.
+ *
+ * @param hooks the list of TransitionHooks to invoke
+ * @param doneCallback a callback that is invoked after all the hooks have successfully completed
+ *
+ * @returns a promise for the async result, or the result of the callback
+ */
+ TransitionHook.invokeHooks = function (hooks, doneCallback) {
+ for (var idx = 0; idx < hooks.length; idx++) {
+ var hookResult = hooks[idx].invokeHook();
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_3__.isPromise)(hookResult)) {
+ var remainingHooks = hooks.slice(idx + 1);
+ return TransitionHook.chain(remainingHooks, hookResult).then(doneCallback);
+ }
+ }
+ return doneCallback();
+ };
+ /**
+ * Run all TransitionHooks, ignoring their return value.
+ */
+ TransitionHook.runAllHooks = function (hooks) {
+ hooks.forEach(function (hook) { return hook.invokeHook(); });
+ };
+ TransitionHook.prototype.logError = function (err) {
+ this.transition.router.stateService.defaultErrorHandler()(err);
+ };
+ TransitionHook.prototype.invokeHook = function () {
+ var _this = this;
+ var hook = this.registeredHook;
+ if (hook._deregistered)
+ return;
+ var notCurrent = this.getNotCurrentRejection();
+ if (notCurrent)
+ return notCurrent;
+ var options = this.options;
+ _common_trace__WEBPACK_IMPORTED_MODULE_5__.trace.traceHookInvocation(this, this.transition, options);
+ var invokeCallback = function () { return hook.callback.call(options.bind, _this.transition, _this.stateContext); };
+ var normalizeErr = function (err) { return _rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.normalize(err).toPromise(); };
+ var handleError = function (err) { return hook.eventType.getErrorHandler(_this)(err); };
+ var handleResult = function (result) { return hook.eventType.getResultHandler(_this)(result); };
+ try {
+ var result = invokeCallback();
+ if (!this.type.synchronous && (0,_common_predicates__WEBPACK_IMPORTED_MODULE_3__.isPromise)(result)) {
+ return result.catch(normalizeErr).then(handleResult, handleError);
+ }
+ else {
+ return handleResult(result);
+ }
+ }
+ catch (err) {
+ // If callback throws (synchronously)
+ return handleError(_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.normalize(err));
+ }
+ finally {
+ if (hook.invokeLimit && ++hook.invokeCount >= hook.invokeLimit) {
+ hook.deregister();
+ }
+ }
+ };
+ /**
+ * This method handles the return value of a Transition Hook.
+ *
+ * A hook can return false (cancel), a TargetState (redirect),
+ * or a promise (which may later resolve to false or a redirect)
+ *
+ * This also handles "transition superseded" -- when a new transition
+ * was started while the hook was still running
+ */
+ TransitionHook.prototype.handleHookResult = function (result) {
+ var _this = this;
+ var notCurrent = this.getNotCurrentRejection();
+ if (notCurrent)
+ return notCurrent;
+ // Hook returned a promise
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_3__.isPromise)(result)) {
+ // Wait for the promise, then reprocess with the resulting value
+ return result.then(function (val) { return _this.handleHookResult(val); });
+ }
+ _common_trace__WEBPACK_IMPORTED_MODULE_5__.trace.traceHookResult(result, this.transition, this.options);
+ // Hook returned false
+ if (result === false) {
+ // Abort this Transition
+ return _rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.aborted('Hook aborted transition').toPromise();
+ }
+ var isTargetState = (0,_common_hof__WEBPACK_IMPORTED_MODULE_4__.is)(_state_targetState__WEBPACK_IMPORTED_MODULE_8__.TargetState);
+ // hook returned a TargetState
+ if (isTargetState(result)) {
+ // Halt the current Transition and redirect (a new Transition) to the TargetState.
+ return _rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.redirected(result).toPromise();
+ }
+ };
+ /**
+ * Return a Rejection promise if the transition is no longer current due
+ * to a stopped router (disposed), or a new transition has started and superseded this one.
+ */
+ TransitionHook.prototype.getNotCurrentRejection = function () {
+ var router = this.transition.router;
+ // The router is stopped
+ if (router._disposed) {
+ return _rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.aborted("UIRouter instance #" + router.$id + " has been stopped (disposed)").toPromise();
+ }
+ if (this.transition._aborted) {
+ return _rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.aborted().toPromise();
+ }
+ // This transition is no longer current.
+ // Another transition started while this hook was still running.
+ if (this.isSuperseded()) {
+ // Abort this transition
+ return _rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.superseded(this.options.current()).toPromise();
+ }
+ };
+ TransitionHook.prototype.toString = function () {
+ var _a = this, options = _a.options, registeredHook = _a.registeredHook;
+ var event = (0,_common_hof__WEBPACK_IMPORTED_MODULE_4__.parse)('traceData.hookType')(options) || 'internal', context = (0,_common_hof__WEBPACK_IMPORTED_MODULE_4__.parse)('traceData.context.state.name')(options) || (0,_common_hof__WEBPACK_IMPORTED_MODULE_4__.parse)('traceData.context')(options) || 'unknown', name = (0,_common_strings__WEBPACK_IMPORTED_MODULE_2__.fnToString)(registeredHook.callback);
+ return event + " context: " + context + ", " + (0,_common_strings__WEBPACK_IMPORTED_MODULE_2__.maxLength)(200, name);
+ };
+ /**
+ * These GetResultHandler(s) are used by [[invokeHook]] below
+ * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])
+ */
+ TransitionHook.HANDLE_RESULT = function (hook) { return function (result) {
+ return hook.handleHookResult(result);
+ }; };
+ /**
+ * If the result is a promise rejection, log it.
+ * Otherwise, ignore the result.
+ */
+ TransitionHook.LOG_REJECTED_RESULT = function (hook) { return function (result) {
+ (0,_common_predicates__WEBPACK_IMPORTED_MODULE_3__.isPromise)(result) && result.catch(function (err) { return hook.logError(_rejectFactory__WEBPACK_IMPORTED_MODULE_7__.Rejection.normalize(err)); });
+ return undefined;
+ }; };
+ /**
+ * These GetErrorHandler(s) are used by [[invokeHook]] below
+ * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])
+ */
+ TransitionHook.LOG_ERROR = function (hook) { return function (error) { return hook.logError(error); }; };
+ TransitionHook.REJECT_ERROR = function (hook) { return function (error) { return (0,_common_common__WEBPACK_IMPORTED_MODULE_1__.silentRejection)(error); }; };
+ TransitionHook.THROW_ERROR = function (hook) { return function (error) {
+ throw error;
+ }; };
+ return TransitionHook;
+}());
+
+//# sourceMappingURL=transitionHook.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/transition/transitionService.js":
+/*!*****************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/transition/transitionService.js ***!
+ \*****************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "defaultTransOpts": () => (/* binding */ defaultTransOpts),
+/* harmony export */ "TransitionService": () => (/* binding */ TransitionService)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/transition/interface.js");
+/* harmony import */ var _transition__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./transition */ "./node_modules/@uirouter/core/lib-esm/transition/transition.js");
+/* harmony import */ var _hookRegistry__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./hookRegistry */ "./node_modules/@uirouter/core/lib-esm/transition/hookRegistry.js");
+/* harmony import */ var _hooks_coreResolvables__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../hooks/coreResolvables */ "./node_modules/@uirouter/core/lib-esm/hooks/coreResolvables.js");
+/* harmony import */ var _hooks_redirectTo__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../hooks/redirectTo */ "./node_modules/@uirouter/core/lib-esm/hooks/redirectTo.js");
+/* harmony import */ var _hooks_onEnterExitRetain__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../hooks/onEnterExitRetain */ "./node_modules/@uirouter/core/lib-esm/hooks/onEnterExitRetain.js");
+/* harmony import */ var _hooks_resolve__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../hooks/resolve */ "./node_modules/@uirouter/core/lib-esm/hooks/resolve.js");
+/* harmony import */ var _hooks_views__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../hooks/views */ "./node_modules/@uirouter/core/lib-esm/hooks/views.js");
+/* harmony import */ var _hooks_updateGlobals__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../hooks/updateGlobals */ "./node_modules/@uirouter/core/lib-esm/hooks/updateGlobals.js");
+/* harmony import */ var _hooks_url__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../hooks/url */ "./node_modules/@uirouter/core/lib-esm/hooks/url.js");
+/* harmony import */ var _hooks_lazyLoad__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../hooks/lazyLoad */ "./node_modules/@uirouter/core/lib-esm/hooks/lazyLoad.js");
+/* harmony import */ var _transitionEventType__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./transitionEventType */ "./node_modules/@uirouter/core/lib-esm/transition/transitionEventType.js");
+/* harmony import */ var _transitionHook__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./transitionHook */ "./node_modules/@uirouter/core/lib-esm/transition/transitionHook.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _hooks_ignoredTransition__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ../hooks/ignoredTransition */ "./node_modules/@uirouter/core/lib-esm/hooks/ignoredTransition.js");
+/* harmony import */ var _hooks_invalidTransition__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ../hooks/invalidTransition */ "./node_modules/@uirouter/core/lib-esm/hooks/invalidTransition.js");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * The default [[Transition]] options.
+ *
+ * Include this object when applying custom defaults:
+ * let reloadOpts = { reload: true, notify: true }
+ * let options = defaults(theirOpts, customDefaults, defaultOptions);
+ */
+var defaultTransOpts = {
+ location: true,
+ relative: null,
+ inherit: false,
+ notify: true,
+ reload: false,
+ supercede: true,
+ custom: {},
+ current: function () { return null; },
+ source: 'unknown',
+};
+/**
+ * This class provides services related to Transitions.
+ *
+ * - Most importantly, it allows global Transition Hooks to be registered.
+ * - It allows the default transition error handler to be set.
+ * - It also has a factory function for creating new [[Transition]] objects, (used internally by the [[StateService]]).
+ *
+ * At bootstrap, [[UIRouter]] creates a single instance (singleton) of this class.
+ *
+ * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
+ */
+var TransitionService = /** @class */ (function () {
+ /** @internal */
+ function TransitionService(_router) {
+ /** @internal */
+ this._transitionCount = 0;
+ /** The transition hook types, such as `onEnter`, `onStart`, etc */
+ this._eventTypes = [];
+ /** @internal The registered transition hooks */
+ this._registeredHooks = {};
+ /** The paths on a criteria object */
+ this._criteriaPaths = {};
+ this._router = _router;
+ this.$view = _router.viewService;
+ this._deregisterHookFns = {};
+ this._pluginapi = ((0,_common_common__WEBPACK_IMPORTED_MODULE_14__.createProxyFunctions)((0,_common_hof__WEBPACK_IMPORTED_MODULE_15__.val)(this), {}, (0,_common_hof__WEBPACK_IMPORTED_MODULE_15__.val)(this), [
+ '_definePathType',
+ '_defineEvent',
+ '_getPathTypes',
+ '_getEvents',
+ 'getHooks',
+ ]));
+ this._defineCorePaths();
+ this._defineCoreEvents();
+ this._registerCoreTransitionHooks();
+ _router.globals.successfulTransitions.onEvict(_hooks_coreResolvables__WEBPACK_IMPORTED_MODULE_3__.treeChangesCleanup);
+ }
+ /**
+ * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
+ *
+ * Registers a transition lifecycle hook, which is invoked during transition construction.
+ *
+ * This low level hook should only be used by plugins.
+ * This can be a useful time for plugins to add resolves or mutate the transition as needed.
+ * The Sticky States plugin uses this hook to modify the treechanges.
+ *
+ * ### Lifecycle
+ *
+ * `onCreate` hooks are invoked *while a transition is being constructed*.
+ *
+ * ### Return value
+ *
+ * The hook's return value is ignored
+ *
+ * @internal
+ * @param criteria defines which Transitions the Hook should be invoked for.
+ * @param callback the hook function which will be invoked.
+ * @param options the registration options
+ * @returns a function which deregisters the hook.
+ */
+ TransitionService.prototype.onCreate = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ TransitionService.prototype.onBefore = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ TransitionService.prototype.onStart = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ TransitionService.prototype.onExit = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ TransitionService.prototype.onRetain = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ TransitionService.prototype.onEnter = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ TransitionService.prototype.onFinish = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ TransitionService.prototype.onSuccess = function (criteria, callback, options) {
+ return;
+ };
+ /** @inheritdoc */
+ TransitionService.prototype.onError = function (criteria, callback, options) {
+ return;
+ };
+ /**
+ * dispose
+ * @internal
+ */
+ TransitionService.prototype.dispose = function (router) {
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_14__.values)(this._registeredHooks).forEach(function (hooksArray) {
+ return hooksArray.forEach(function (hook) {
+ hook._deregistered = true;
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_14__.removeFrom)(hooksArray, hook);
+ });
+ });
+ };
+ /**
+ * Creates a new [[Transition]] object
+ *
+ * This is a factory function for creating new Transition objects.
+ * It is used internally by the [[StateService]] and should generally not be called by application code.
+ *
+ * @internal
+ * @param fromPath the path to the current state (the from state)
+ * @param targetState the target state (destination)
+ * @returns a Transition
+ */
+ TransitionService.prototype.create = function (fromPath, targetState) {
+ return new _transition__WEBPACK_IMPORTED_MODULE_1__.Transition(fromPath, targetState, this._router);
+ };
+ /** @internal */
+ TransitionService.prototype._defineCoreEvents = function () {
+ var Phase = _interface__WEBPACK_IMPORTED_MODULE_0__.TransitionHookPhase;
+ var TH = _transitionHook__WEBPACK_IMPORTED_MODULE_12__.TransitionHook;
+ var paths = this._criteriaPaths;
+ var NORMAL_SORT = false, REVERSE_SORT = true;
+ var SYNCHRONOUS = true;
+ this._defineEvent('onCreate', Phase.CREATE, 0, paths.to, NORMAL_SORT, TH.LOG_REJECTED_RESULT, TH.THROW_ERROR, SYNCHRONOUS);
+ this._defineEvent('onBefore', Phase.BEFORE, 0, paths.to);
+ this._defineEvent('onStart', Phase.RUN, 0, paths.to);
+ this._defineEvent('onExit', Phase.RUN, 100, paths.exiting, REVERSE_SORT);
+ this._defineEvent('onRetain', Phase.RUN, 200, paths.retained);
+ this._defineEvent('onEnter', Phase.RUN, 300, paths.entering);
+ this._defineEvent('onFinish', Phase.RUN, 400, paths.to);
+ this._defineEvent('onSuccess', Phase.SUCCESS, 0, paths.to, NORMAL_SORT, TH.LOG_REJECTED_RESULT, TH.LOG_ERROR, SYNCHRONOUS);
+ this._defineEvent('onError', Phase.ERROR, 0, paths.to, NORMAL_SORT, TH.LOG_REJECTED_RESULT, TH.LOG_ERROR, SYNCHRONOUS);
+ };
+ /** @internal */
+ TransitionService.prototype._defineCorePaths = function () {
+ var STATE = _interface__WEBPACK_IMPORTED_MODULE_0__.TransitionHookScope.STATE, TRANSITION = _interface__WEBPACK_IMPORTED_MODULE_0__.TransitionHookScope.TRANSITION;
+ this._definePathType('to', TRANSITION);
+ this._definePathType('from', TRANSITION);
+ this._definePathType('exiting', STATE);
+ this._definePathType('retained', STATE);
+ this._definePathType('entering', STATE);
+ };
+ /** @internal */
+ TransitionService.prototype._defineEvent = function (name, hookPhase, hookOrder, criteriaMatchPath, reverseSort, getResultHandler, getErrorHandler, synchronous) {
+ if (reverseSort === void 0) { reverseSort = false; }
+ if (getResultHandler === void 0) { getResultHandler = _transitionHook__WEBPACK_IMPORTED_MODULE_12__.TransitionHook.HANDLE_RESULT; }
+ if (getErrorHandler === void 0) { getErrorHandler = _transitionHook__WEBPACK_IMPORTED_MODULE_12__.TransitionHook.REJECT_ERROR; }
+ if (synchronous === void 0) { synchronous = false; }
+ var eventType = new _transitionEventType__WEBPACK_IMPORTED_MODULE_11__.TransitionEventType(name, hookPhase, hookOrder, criteriaMatchPath, reverseSort, getResultHandler, getErrorHandler, synchronous);
+ this._eventTypes.push(eventType);
+ (0,_hookRegistry__WEBPACK_IMPORTED_MODULE_2__.makeEvent)(this, this, eventType);
+ };
+ /** @internal */
+ TransitionService.prototype._getEvents = function (phase) {
+ var transitionHookTypes = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_13__.isDefined)(phase)
+ ? this._eventTypes.filter(function (type) { return type.hookPhase === phase; })
+ : this._eventTypes.slice();
+ return transitionHookTypes.sort(function (l, r) {
+ var cmpByPhase = l.hookPhase - r.hookPhase;
+ return cmpByPhase === 0 ? l.hookOrder - r.hookOrder : cmpByPhase;
+ });
+ };
+ /**
+ * Adds a Path to be used as a criterion against a TreeChanges path
+ *
+ * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.
+ * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`
+ * Each state in the exiting path is checked against the criteria and returned as part of the match.
+ *
+ * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.
+ * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`
+ * Only the tail of the `to` path is checked against the criteria and returned as part of the match.
+ *
+ * @internal
+ */
+ TransitionService.prototype._definePathType = function (name, hookScope) {
+ this._criteriaPaths[name] = { name: name, scope: hookScope };
+ };
+ /** @internal */
+ // tslint:disable-next-line
+ TransitionService.prototype._getPathTypes = function () {
+ return this._criteriaPaths;
+ };
+ /** @internal */
+ TransitionService.prototype.getHooks = function (hookName) {
+ return this._registeredHooks[hookName];
+ };
+ /** @internal */
+ TransitionService.prototype._registerCoreTransitionHooks = function () {
+ var fns = this._deregisterHookFns;
+ fns.addCoreResolves = (0,_hooks_coreResolvables__WEBPACK_IMPORTED_MODULE_3__.registerAddCoreResolvables)(this);
+ fns.ignored = (0,_hooks_ignoredTransition__WEBPACK_IMPORTED_MODULE_16__.registerIgnoredTransitionHook)(this);
+ fns.invalid = (0,_hooks_invalidTransition__WEBPACK_IMPORTED_MODULE_17__.registerInvalidTransitionHook)(this);
+ // Wire up redirectTo hook
+ fns.redirectTo = (0,_hooks_redirectTo__WEBPACK_IMPORTED_MODULE_4__.registerRedirectToHook)(this);
+ // Wire up onExit/Retain/Enter state hooks
+ fns.onExit = (0,_hooks_onEnterExitRetain__WEBPACK_IMPORTED_MODULE_5__.registerOnExitHook)(this);
+ fns.onRetain = (0,_hooks_onEnterExitRetain__WEBPACK_IMPORTED_MODULE_5__.registerOnRetainHook)(this);
+ fns.onEnter = (0,_hooks_onEnterExitRetain__WEBPACK_IMPORTED_MODULE_5__.registerOnEnterHook)(this);
+ // Wire up Resolve hooks
+ fns.eagerResolve = (0,_hooks_resolve__WEBPACK_IMPORTED_MODULE_6__.registerEagerResolvePath)(this);
+ fns.lazyResolve = (0,_hooks_resolve__WEBPACK_IMPORTED_MODULE_6__.registerLazyResolveState)(this);
+ fns.resolveAll = (0,_hooks_resolve__WEBPACK_IMPORTED_MODULE_6__.registerResolveRemaining)(this);
+ // Wire up the View management hooks
+ fns.loadViews = (0,_hooks_views__WEBPACK_IMPORTED_MODULE_7__.registerLoadEnteringViews)(this);
+ fns.activateViews = (0,_hooks_views__WEBPACK_IMPORTED_MODULE_7__.registerActivateViews)(this);
+ // Updates global state after a transition
+ fns.updateGlobals = (0,_hooks_updateGlobals__WEBPACK_IMPORTED_MODULE_8__.registerUpdateGlobalState)(this);
+ // After globals.current is updated at priority: 10000
+ fns.updateUrl = (0,_hooks_url__WEBPACK_IMPORTED_MODULE_9__.registerUpdateUrl)(this);
+ // Lazy load state trees
+ fns.lazyLoad = (0,_hooks_lazyLoad__WEBPACK_IMPORTED_MODULE_10__.registerLazyLoadHook)(this);
+ };
+ return TransitionService;
+}());
+
+//# sourceMappingURL=transitionService.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/url/index.js":
+/*!**********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/url/index.js ***!
+ \**********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UrlMatcher": () => (/* reexport safe */ _urlMatcher__WEBPACK_IMPORTED_MODULE_1__.UrlMatcher),
+/* harmony export */ "ParamFactory": () => (/* reexport safe */ _urlMatcherFactory__WEBPACK_IMPORTED_MODULE_2__.ParamFactory),
+/* harmony export */ "UrlMatcherFactory": () => (/* reexport safe */ _urlMatcherFactory__WEBPACK_IMPORTED_MODULE_2__.UrlMatcherFactory),
+/* harmony export */ "UrlRouter": () => (/* reexport safe */ _urlRouter__WEBPACK_IMPORTED_MODULE_3__.UrlRouter),
+/* harmony export */ "BaseUrlRule": () => (/* reexport safe */ _urlRule__WEBPACK_IMPORTED_MODULE_4__.BaseUrlRule),
+/* harmony export */ "UrlRuleFactory": () => (/* reexport safe */ _urlRule__WEBPACK_IMPORTED_MODULE_4__.UrlRuleFactory),
+/* harmony export */ "UrlService": () => (/* reexport safe */ _urlService__WEBPACK_IMPORTED_MODULE_5__.UrlService),
+/* harmony export */ "UrlRules": () => (/* reexport safe */ _urlRules__WEBPACK_IMPORTED_MODULE_6__.UrlRules),
+/* harmony export */ "UrlConfig": () => (/* reexport safe */ _urlConfig__WEBPACK_IMPORTED_MODULE_7__.UrlConfig)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/url/interface.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_interface__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _interface__WEBPACK_IMPORTED_MODULE_0__) if(["default","UrlRules","UrlConfig"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _interface__WEBPACK_IMPORTED_MODULE_0__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _urlMatcher__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./urlMatcher */ "./node_modules/@uirouter/core/lib-esm/url/urlMatcher.js");
+/* harmony import */ var _urlMatcherFactory__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./urlMatcherFactory */ "./node_modules/@uirouter/core/lib-esm/url/urlMatcherFactory.js");
+/* harmony import */ var _urlRouter__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./urlRouter */ "./node_modules/@uirouter/core/lib-esm/url/urlRouter.js");
+/* harmony import */ var _urlRule__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./urlRule */ "./node_modules/@uirouter/core/lib-esm/url/urlRule.js");
+/* harmony import */ var _urlService__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./urlService */ "./node_modules/@uirouter/core/lib-esm/url/urlService.js");
+/* harmony import */ var _urlRules__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./urlRules */ "./node_modules/@uirouter/core/lib-esm/url/urlRules.js");
+/* harmony import */ var _urlConfig__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./urlConfig */ "./node_modules/@uirouter/core/lib-esm/url/urlConfig.js");
+
+
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/url/interface.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/url/interface.js ***!
+ \**************************************************************/
+/***/ (() => {
+
+//# sourceMappingURL=interface.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/url/urlConfig.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/url/urlConfig.js ***!
+ \**************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UrlConfig": () => (/* binding */ UrlConfig)
+/* harmony export */ });
+/* harmony import */ var _params__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../params */ "./node_modules/@uirouter/core/lib-esm/params/index.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+
+/**
+ * An API to customize the URL behavior and retrieve URL configuration
+ *
+ * This API is used to customize the behavior of the URL.
+ * This includes optional trailing slashes ([[strictMode]]), case sensitivity ([[caseInsensitive]]),
+ * and custom parameter encoding (custom [[type]]).
+ *
+ * It also has information about the location (url) configuration such as [[port]] and [[baseHref]].
+ * This information can be used to build absolute URLs, such as
+ * `https://example.com:443/basepath/state/substate?param1=a#hashvalue`;
+ *
+ * This API is found at `router.urlService.config` (see: [[UIRouter.urlService]], [[URLService.config]])
+ */
+var UrlConfig = /** @class */ (function () {
+ /** @internal */ function UrlConfig(/** @internal */ router) {
+ var _this = this;
+ this.router = router;
+ /** @internal */ this.paramTypes = new _params__WEBPACK_IMPORTED_MODULE_0__.ParamTypes();
+ /** @internal */ this._decodeParams = true;
+ /** @internal */ this._isCaseInsensitive = false;
+ /** @internal */ this._isStrictMode = true;
+ /** @internal */ this._defaultSquashPolicy = false;
+ /** @internal */ this.dispose = function () { return _this.paramTypes.dispose(); };
+ // Delegate these calls to the current LocationConfig implementation
+ /**
+ * Gets the base Href, e.g., `http://localhost/approot/`
+ *
+ * @return the application's base href
+ */
+ this.baseHref = function () { return _this.router.locationConfig.baseHref(); };
+ /**
+ * Gets or sets the hashPrefix
+ *
+ * This only applies when not running in [[html5Mode]] (pushstate mode)
+ *
+ * If the current url is `http://localhost/app#!/uirouter/path/#anchor`, it returns `!` which is the prefix for the "hashbang" portion.
+ *
+ * @return the hash prefix
+ */
+ this.hashPrefix = function (newprefix) { return _this.router.locationConfig.hashPrefix(newprefix); };
+ /**
+ * Gets the host, e.g., `localhost`
+ *
+ * @return the protocol
+ */
+ this.host = function () { return _this.router.locationConfig.host(); };
+ /**
+ * Returns true when running in pushstate mode
+ *
+ * @return true when running in html5 mode (pushstate mode).
+ */
+ this.html5Mode = function () { return _this.router.locationConfig.html5Mode(); };
+ /**
+ * Gets the port, e.g., `80`
+ *
+ * @return the port number
+ */
+ this.port = function () { return _this.router.locationConfig.port(); };
+ /**
+ * Gets the protocol, e.g., `http`
+ *
+ * @return the protocol
+ */
+ this.protocol = function () { return _this.router.locationConfig.protocol(); };
+ }
+ /**
+ * Defines whether URL matching should be case sensitive (the default behavior), or not.
+ *
+ * #### Example:
+ * ```js
+ * // Allow case insensitive url matches
+ * urlService.config.caseInsensitive(true);
+ * ```
+ *
+ * @param value `false` to match URL in a case sensitive manner; otherwise `true`;
+ * @returns the current value of caseInsensitive
+ */
+ UrlConfig.prototype.caseInsensitive = function (value) {
+ return (this._isCaseInsensitive = (0,_common__WEBPACK_IMPORTED_MODULE_1__.isDefined)(value) ? value : this._isCaseInsensitive);
+ };
+ /**
+ * Sets the default behavior when generating or matching URLs with default parameter values.
+ *
+ * #### Example:
+ * ```js
+ * // Remove default parameter values from the url
+ * urlService.config.defaultSquashPolicy(true);
+ * ```
+ *
+ * @param value A string that defines the default parameter URL squashing behavior.
+ * - `nosquash`: When generating an href with a default parameter value, do not squash the parameter value from the URL
+ * - `slash`: When generating an href with a default parameter value, squash (remove) the parameter value, and, if the
+ * parameter is surrounded by slashes, squash (remove) one slash from the URL
+ * - any other string, e.g. "~": When generating an href with a default parameter value, squash (remove)
+ * the parameter value from the URL and replace it with this string.
+ * @returns the current value of defaultSquashPolicy
+ */
+ UrlConfig.prototype.defaultSquashPolicy = function (value) {
+ if ((0,_common__WEBPACK_IMPORTED_MODULE_1__.isDefined)(value) && value !== true && value !== false && !(0,_common__WEBPACK_IMPORTED_MODULE_1__.isString)(value))
+ throw new Error("Invalid squash policy: " + value + ". Valid policies: false, true, arbitrary-string");
+ return (this._defaultSquashPolicy = (0,_common__WEBPACK_IMPORTED_MODULE_1__.isDefined)(value) ? value : this._defaultSquashPolicy);
+ };
+ /**
+ * Defines whether URLs should match trailing slashes, or not (the default behavior).
+ *
+ * #### Example:
+ * ```js
+ * // Allow optional trailing slashes
+ * urlService.config.strictMode(false);
+ * ```
+ *
+ * @param value `false` to match trailing slashes in URLs, otherwise `true`.
+ * @returns the current value of strictMode
+ */
+ UrlConfig.prototype.strictMode = function (value) {
+ return (this._isStrictMode = (0,_common__WEBPACK_IMPORTED_MODULE_1__.isDefined)(value) ? value : this._isStrictMode);
+ };
+ /**
+ * Creates and registers a custom [[ParamType]] object
+ *
+ * A custom parameter type can be used to generate URLs with typed parameters or custom encoding/decoding.
+ *
+ * #### Note: Register custom types *before using them* in a state definition.
+ *
+ * #### Example:
+ * ```js
+ * // Encode object parameter as JSON string
+ * urlService.config.type('myjson', {
+ * encode: (obj) => JSON.stringify(obj),
+ * decode: (str) => JSON.parse(str),
+ * is: (val) => typeof(val) === 'object',
+ * pattern: /[^/]+/,
+ * equals: (a, b) => _.isEqual(a, b),
+ * });
+ * ```
+ *
+ * See [[ParamTypeDefinition]] for more examples
+ *
+ * @param name The type name.
+ * @param definition The type definition. See [[ParamTypeDefinition]] for information on the values accepted.
+ * @param definitionFn A function that is injected before the app runtime starts.
+ * The result of this function should be a [[ParamTypeDefinition]].
+ * The result is merged into the existing `definition`.
+ * See [[ParamType]] for information on the values accepted.
+ *
+ * @returns if only the `name` parameter was specified: the currently registered [[ParamType]] object, or undefined
+ */
+ UrlConfig.prototype.type = function (name, definition, definitionFn) {
+ var type = this.paramTypes.type(name, definition, definitionFn);
+ return !(0,_common__WEBPACK_IMPORTED_MODULE_1__.isDefined)(definition) ? type : this;
+ };
+ return UrlConfig;
+}());
+
+//# sourceMappingURL=urlConfig.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/url/urlMatcher.js":
+/*!***************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/url/urlMatcher.js ***!
+ \***************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UrlMatcher": () => (/* binding */ UrlMatcher)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _params_param__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../params/param */ "./node_modules/@uirouter/core/lib-esm/params/param.js");
+/* harmony import */ var _common_strings__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../common/strings */ "./node_modules/@uirouter/core/lib-esm/common/strings.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+
+
+
+
+
+function quoteRegExp(str, param) {
+ var surroundPattern = ['', ''], result = str.replace(/[\\\[\]\^$*+?.()|{}]/g, '\\$&');
+ if (!param)
+ return result;
+ switch (param.squash) {
+ case false:
+ surroundPattern = ['(', ')' + (param.isOptional ? '?' : '')];
+ break;
+ case true:
+ result = result.replace(/\/$/, '');
+ surroundPattern = ['(?:/(', ')|/)?'];
+ break;
+ default:
+ surroundPattern = ["(" + param.squash + "|", ')?'];
+ break;
+ }
+ return result + surroundPattern[0] + param.type.pattern.source + surroundPattern[1];
+}
+var memoizeTo = function (obj, _prop, fn) { return (obj[_prop] = obj[_prop] || fn()); };
+var splitOnSlash = (0,_common_strings__WEBPACK_IMPORTED_MODULE_4__.splitOnDelim)('/');
+var defaultConfig = {
+ state: { params: {} },
+ strict: true,
+ caseInsensitive: true,
+ decodeParams: true,
+};
+/**
+ * Matches URLs against patterns.
+ *
+ * Matches URLs against patterns and extracts named parameters from the path or the search
+ * part of the URL.
+ *
+ * A URL pattern consists of a path pattern, optionally followed by '?' and a list of search (query)
+ * parameters. Multiple search parameter names are separated by '&'. Search parameters
+ * do not influence whether or not a URL is matched, but their values are passed through into
+ * the matched parameters returned by [[UrlMatcher.exec]].
+ *
+ * - *Path parameters* are defined using curly brace placeholders (`/somepath/{param}`)
+ * or colon placeholders (`/somePath/:param`).
+ *
+ * - *A parameter RegExp* may be defined for a param after a colon
+ * (`/somePath/{param:[a-zA-Z0-9]+}`) in a curly brace placeholder.
+ * The regexp must match for the url to be matched.
+ * Should the regexp itself contain curly braces, they must be in matched pairs or escaped with a backslash.
+ *
+ * Note: a RegExp parameter will encode its value using either [[ParamTypes.path]] or [[ParamTypes.query]].
+ *
+ * - *Custom parameter types* may also be specified after a colon (`/somePath/{param:int}`) in curly brace parameters.
+ * See [[UrlMatcherFactory.type]] for more information.
+ *
+ * - *Catch-all parameters* are defined using an asterisk placeholder (`/somepath/*catchallparam`).
+ * A catch-all * parameter value will contain the remainder of the URL.
+ *
+ * ---
+ *
+ * Parameter names may contain only word characters (latin letters, digits, and underscore) and
+ * must be unique within the pattern (across both path and search parameters).
+ * A path parameter matches any number of characters other than '/'. For catch-all
+ * placeholders the path parameter matches any number of characters.
+ *
+ * Examples:
+ *
+ * * `'/hello/'` - Matches only if the path is exactly '/hello/'. There is no special treatment for
+ * trailing slashes, and patterns have to match the entire path, not just a prefix.
+ * * `'/user/:id'` - Matches '/user/bob' or '/user/1234!!!' or even '/user/' but not '/user' or
+ * '/user/bob/details'. The second path segment will be captured as the parameter 'id'.
+ * * `'/user/{id}'` - Same as the previous example, but using curly brace syntax.
+ * * `'/user/{id:[^/]*}'` - Same as the previous example.
+ * * `'/user/{id:[0-9a-fA-F]{1,8}}'` - Similar to the previous example, but only matches if the id
+ * parameter consists of 1 to 8 hex digits.
+ * * `'/files/{path:.*}'` - Matches any URL starting with '/files/' and captures the rest of the
+ * path into the parameter 'path'.
+ * * `'/files/*path'` - ditto.
+ * * `'/calendar/{start:date}'` - Matches "/calendar/2014-11-12" (because the pattern defined
+ * in the built-in `date` ParamType matches `2014-11-12`) and provides a Date object in $stateParams.start
+ *
+ */
+var UrlMatcher = /** @class */ (function () {
+ /**
+ * @param pattern The pattern to compile into a matcher.
+ * @param paramTypes The [[ParamTypes]] registry
+ * @param paramFactory A [[ParamFactory]] object
+ * @param config A [[UrlMatcherCompileConfig]] configuration object
+ */
+ function UrlMatcher(pattern, paramTypes, paramFactory, config) {
+ var _this = this;
+ /** @internal */
+ this._cache = { path: [this] };
+ /** @internal */
+ this._children = [];
+ /** @internal */
+ this._params = [];
+ /** @internal */
+ this._segments = [];
+ /** @internal */
+ this._compiled = [];
+ this.config = config = (0,_common__WEBPACK_IMPORTED_MODULE_5__.defaults)(config, defaultConfig);
+ this.pattern = pattern;
+ // Find all placeholders and create a compiled pattern, using either classic or curly syntax:
+ // '*' name
+ // ':' name
+ // '{' name '}'
+ // '{' name ':' regexp '}'
+ // The regular expression is somewhat complicated due to the need to allow curly braces
+ // inside the regular expression. The placeholder regexp breaks down as follows:
+ // ([:*])([\w\[\]]+) - classic placeholder ($1 / $2) (search version has - for snake-case)
+ // \{([\w\[\]]+)(?:\:\s*( ... ))?\} - curly brace placeholder ($3) with optional regexp/type ... ($4) (search version has - for snake-case
+ // (?: ... | ... | ... )+ - the regexp consists of any number of atoms, an atom being either
+ // [^{}\\]+ - anything other than curly braces or backslash
+ // \\. - a backslash escape
+ // \{(?:[^{}\\]+|\\.)*\} - a matched set of curly braces containing other atoms
+ var placeholder = /([:*])([\w\[\]]+)|\{([\w\[\]]+)(?:\:\s*((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g;
+ var searchPlaceholder = /([:]?)([\w\[\].-]+)|\{([\w\[\].-]+)(?:\:\s*((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g;
+ var patterns = [];
+ var last = 0;
+ var matchArray;
+ var checkParamErrors = function (id) {
+ if (!UrlMatcher.nameValidator.test(id))
+ throw new Error("Invalid parameter name '" + id + "' in pattern '" + pattern + "'");
+ if ((0,_common_common__WEBPACK_IMPORTED_MODULE_0__.find)(_this._params, (0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.propEq)('id', id)))
+ throw new Error("Duplicate parameter name '" + id + "' in pattern '" + pattern + "'");
+ };
+ // Split into static segments separated by path parameter placeholders.
+ // The number of segments is always 1 more than the number of parameters.
+ var matchDetails = function (m, isSearch) {
+ // IE[78] returns '' for unmatched groups instead of null
+ var id = m[2] || m[3];
+ var regexp = isSearch ? m[4] : m[4] || (m[1] === '*' ? '[\\s\\S]*' : null);
+ var makeRegexpType = function (str) {
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inherit)(paramTypes.type(isSearch ? 'query' : 'path'), {
+ pattern: new RegExp(str, _this.config.caseInsensitive ? 'i' : undefined),
+ });
+ };
+ return {
+ id: id,
+ regexp: regexp,
+ segment: pattern.substring(last, m.index),
+ type: !regexp ? null : paramTypes.type(regexp) || makeRegexpType(regexp),
+ };
+ };
+ var details;
+ var segment;
+ // tslint:disable-next-line:no-conditional-assignment
+ while ((matchArray = placeholder.exec(pattern))) {
+ details = matchDetails(matchArray, false);
+ if (details.segment.indexOf('?') >= 0)
+ break; // we're into the search part
+ checkParamErrors(details.id);
+ this._params.push(paramFactory.fromPath(details.id, details.type, config.state));
+ this._segments.push(details.segment);
+ patterns.push([details.segment, (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.tail)(this._params)]);
+ last = placeholder.lastIndex;
+ }
+ segment = pattern.substring(last);
+ // Find any search parameter names and remove them from the last segment
+ var i = segment.indexOf('?');
+ if (i >= 0) {
+ var search = segment.substring(i);
+ segment = segment.substring(0, i);
+ if (search.length > 0) {
+ last = 0;
+ // tslint:disable-next-line:no-conditional-assignment
+ while ((matchArray = searchPlaceholder.exec(search))) {
+ details = matchDetails(matchArray, true);
+ checkParamErrors(details.id);
+ this._params.push(paramFactory.fromSearch(details.id, details.type, config.state));
+ last = placeholder.lastIndex;
+ // check if ?&
+ }
+ }
+ }
+ this._segments.push(segment);
+ this._compiled = patterns.map(function (_pattern) { return quoteRegExp.apply(null, _pattern); }).concat(quoteRegExp(segment));
+ }
+ /** @internal */
+ UrlMatcher.encodeDashes = function (str) {
+ // Replace dashes with encoded "\-"
+ return encodeURIComponent(str).replace(/-/g, function (c) { return "%5C%" + c.charCodeAt(0).toString(16).toUpperCase(); });
+ };
+ /** @internal Given a matcher, return an array with the matcher's path segments and path params, in order */
+ UrlMatcher.pathSegmentsAndParams = function (matcher) {
+ var staticSegments = matcher._segments;
+ var pathParams = matcher._params.filter(function (p) { return p.location === _params_param__WEBPACK_IMPORTED_MODULE_3__.DefType.PATH; });
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.arrayTuples)(staticSegments, pathParams.concat(undefined))
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .filter(function (x) { return x !== '' && (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isDefined)(x); });
+ };
+ /** @internal Given a matcher, return an array with the matcher's query params */
+ UrlMatcher.queryParams = function (matcher) {
+ return matcher._params.filter(function (p) { return p.location === _params_param__WEBPACK_IMPORTED_MODULE_3__.DefType.SEARCH; });
+ };
+ /**
+ * Compare two UrlMatchers
+ *
+ * This comparison function converts a UrlMatcher into static and dynamic path segments.
+ * Each static path segment is a static string between a path separator (slash character).
+ * Each dynamic segment is a path parameter.
+ *
+ * The comparison function sorts static segments before dynamic ones.
+ */
+ UrlMatcher.compare = function (a, b) {
+ /**
+ * Turn a UrlMatcher and all its parent matchers into an array
+ * of slash literals '/', string literals, and Param objects
+ *
+ * This example matcher matches strings like "/foo/:param/tail":
+ * var matcher = $umf.compile("/foo").append($umf.compile("/:param")).append($umf.compile("/")).append($umf.compile("tail"));
+ * var result = segments(matcher); // [ '/', 'foo', '/', Param, '/', 'tail' ]
+ *
+ * Caches the result as `matcher._cache.segments`
+ */
+ var segments = function (matcher) {
+ return (matcher._cache.segments =
+ matcher._cache.segments ||
+ matcher._cache.path
+ .map(UrlMatcher.pathSegmentsAndParams)
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .reduce(_common_strings__WEBPACK_IMPORTED_MODULE_4__.joinNeighborsR, [])
+ .map(function (x) { return ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isString)(x) ? splitOnSlash(x) : x); })
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, []));
+ };
+ /**
+ * Gets the sort weight for each segment of a UrlMatcher
+ *
+ * Caches the result as `matcher._cache.weights`
+ */
+ var weights = function (matcher) {
+ return (matcher._cache.weights =
+ matcher._cache.weights ||
+ segments(matcher).map(function (segment) {
+ // Sort slashes first, then static strings, the Params
+ if (segment === '/')
+ return 1;
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isString)(segment))
+ return 2;
+ if (segment instanceof _params_param__WEBPACK_IMPORTED_MODULE_3__.Param)
+ return 3;
+ }));
+ };
+ /**
+ * Pads shorter array in-place (mutates)
+ */
+ var padArrays = function (l, r, padVal) {
+ var len = Math.max(l.length, r.length);
+ while (l.length < len)
+ l.push(padVal);
+ while (r.length < len)
+ r.push(padVal);
+ };
+ var weightsA = weights(a), weightsB = weights(b);
+ padArrays(weightsA, weightsB, 0);
+ var _pairs = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.arrayTuples)(weightsA, weightsB);
+ var cmp, i;
+ for (i = 0; i < _pairs.length; i++) {
+ cmp = _pairs[i][0] - _pairs[i][1];
+ if (cmp !== 0)
+ return cmp;
+ }
+ return 0;
+ };
+ /**
+ * Creates a new concatenated UrlMatcher
+ *
+ * Builds a new UrlMatcher by appending another UrlMatcher to this one.
+ *
+ * @param url A `UrlMatcher` instance to append as a child of the current `UrlMatcher`.
+ */
+ UrlMatcher.prototype.append = function (url) {
+ this._children.push(url);
+ url._cache = {
+ path: this._cache.path.concat(url),
+ parent: this,
+ pattern: null,
+ };
+ return url;
+ };
+ /** @internal */
+ UrlMatcher.prototype.isRoot = function () {
+ return this._cache.path[0] === this;
+ };
+ /** Returns the input pattern string */
+ UrlMatcher.prototype.toString = function () {
+ return this.pattern;
+ };
+ UrlMatcher.prototype._getDecodedParamValue = function (value, param) {
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isDefined)(value)) {
+ if (this.config.decodeParams && !param.type.raw) {
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isArray)(value)) {
+ value = value.map(function (paramValue) { return decodeURIComponent(paramValue); });
+ }
+ else {
+ value = decodeURIComponent(value);
+ }
+ }
+ value = param.type.decode(value);
+ }
+ return param.value(value);
+ };
+ /**
+ * Tests the specified url/path against this matcher.
+ *
+ * Tests if the given url matches this matcher's pattern, and returns an object containing the captured
+ * parameter values. Returns null if the path does not match.
+ *
+ * The returned object contains the values
+ * of any search parameters that are mentioned in the pattern, but their value may be null if
+ * they are not present in `search`. This means that search parameters are always treated
+ * as optional.
+ *
+ * #### Example:
+ * ```js
+ * new UrlMatcher('/user/{id}?q&r').exec('/user/bob', {
+ * x: '1', q: 'hello'
+ * });
+ * // returns { id: 'bob', q: 'hello', r: null }
+ * ```
+ *
+ * @param path The URL path to match, e.g. `$location.path()`.
+ * @param search URL search parameters, e.g. `$location.search()`.
+ * @param hash URL hash e.g. `$location.hash()`.
+ * @param options
+ *
+ * @returns The captured parameter values.
+ */
+ UrlMatcher.prototype.exec = function (path, search, hash, options) {
+ var _this = this;
+ if (search === void 0) { search = {}; }
+ if (options === void 0) { options = {}; }
+ var match = memoizeTo(this._cache, 'pattern', function () {
+ return new RegExp([
+ '^',
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.unnest)(_this._cache.path.map((0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.prop)('_compiled'))).join(''),
+ _this.config.strict === false ? '/?' : '',
+ '$',
+ ].join(''), _this.config.caseInsensitive ? 'i' : undefined);
+ }).exec(path);
+ if (!match)
+ return null;
+ // options = defaults(options, { isolate: false });
+ var allParams = this.parameters(), pathParams = allParams.filter(function (param) { return !param.isSearch(); }), searchParams = allParams.filter(function (param) { return param.isSearch(); }), nPathSegments = this._cache.path.map(function (urlm) { return urlm._segments.length - 1; }).reduce(function (a, x) { return a + x; }), values = {};
+ if (nPathSegments !== match.length - 1)
+ throw new Error("Unbalanced capture group in route '" + this.pattern + "'");
+ function decodePathArray(paramVal) {
+ var reverseString = function (str) { return str.split('').reverse().join(''); };
+ var unquoteDashes = function (str) { return str.replace(/\\-/g, '-'); };
+ var split = reverseString(paramVal).split(/-(?!\\)/);
+ var allReversed = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.map)(split, reverseString);
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.map)(allReversed, unquoteDashes).reverse();
+ }
+ for (var i = 0; i < nPathSegments; i++) {
+ var param = pathParams[i];
+ var value = match[i + 1];
+ // if the param value matches a pre-replace pair, replace the value before decoding.
+ for (var j = 0; j < param.replace.length; j++) {
+ if (param.replace[j].from === value)
+ value = param.replace[j].to;
+ }
+ if (value && param.array === true)
+ value = decodePathArray(value);
+ values[param.id] = this._getDecodedParamValue(value, param);
+ }
+ searchParams.forEach(function (param) {
+ var value = search[param.id];
+ for (var j = 0; j < param.replace.length; j++) {
+ if (param.replace[j].from === value)
+ value = param.replace[j].to;
+ }
+ values[param.id] = _this._getDecodedParamValue(value, param);
+ });
+ if (hash)
+ values['#'] = hash;
+ return values;
+ };
+ /**
+ * @internal
+ * Returns all the [[Param]] objects of all path and search parameters of this pattern in order of appearance.
+ *
+ * @returns {Array.<Param>} An array of [[Param]] objects. Must be treated as read-only. If the
+ * pattern has no parameters, an empty array is returned.
+ */
+ UrlMatcher.prototype.parameters = function (opts) {
+ if (opts === void 0) { opts = {}; }
+ if (opts.inherit === false)
+ return this._params;
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.unnest)(this._cache.path.map(function (matcher) { return matcher._params; }));
+ };
+ /**
+ * @internal
+ * Returns a single parameter from this UrlMatcher by id
+ *
+ * @param id
+ * @param opts
+ * @returns {T|Param|any|boolean|UrlMatcher|null}
+ */
+ UrlMatcher.prototype.parameter = function (id, opts) {
+ var _this = this;
+ if (opts === void 0) { opts = {}; }
+ var findParam = function () {
+ for (var _i = 0, _a = _this._params; _i < _a.length; _i++) {
+ var param = _a[_i];
+ if (param.id === id)
+ return param;
+ }
+ };
+ var parent = this._cache.parent;
+ return findParam() || (opts.inherit !== false && parent && parent.parameter(id, opts)) || null;
+ };
+ /**
+ * Validates the input parameter values against this UrlMatcher
+ *
+ * Checks an object hash of parameters to validate their correctness according to the parameter
+ * types of this `UrlMatcher`.
+ *
+ * @param params The object hash of parameters to validate.
+ * @returns Returns `true` if `params` validates, otherwise `false`.
+ */
+ UrlMatcher.prototype.validates = function (params) {
+ var validParamVal = function (param, val) { return !param || param.validates(val); };
+ params = params || {};
+ // I'm not sure why this checks only the param keys passed in, and not all the params known to the matcher
+ var paramSchema = this.parameters().filter(function (paramDef) { return params.hasOwnProperty(paramDef.id); });
+ return paramSchema.map(function (paramDef) { return validParamVal(paramDef, params[paramDef.id]); }).reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.allTrueR, true);
+ };
+ /**
+ * Given a set of parameter values, creates a URL from this UrlMatcher.
+ *
+ * Creates a URL that matches this pattern by substituting the specified values
+ * for the path and search parameters.
+ *
+ * #### Example:
+ * ```js
+ * new UrlMatcher('/user/{id}?q').format({ id:'bob', q:'yes' });
+ * // returns '/user/bob?q=yes'
+ * ```
+ *
+ * @param values the values to substitute for the parameters in this pattern.
+ * @returns the formatted URL (path and optionally search part).
+ */
+ UrlMatcher.prototype.format = function (values) {
+ if (values === void 0) { values = {}; }
+ // Build the full path of UrlMatchers (including all parent UrlMatchers)
+ var urlMatchers = this._cache.path;
+ // Extract all the static segments and Params (processed as ParamDetails)
+ // into an ordered array
+ var pathSegmentsAndParams = urlMatchers
+ .map(UrlMatcher.pathSegmentsAndParams)
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .map(function (x) { return ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isString)(x) ? x : getDetails(x)); });
+ // Extract the query params into a separate array
+ var queryParams = urlMatchers
+ .map(UrlMatcher.queryParams)
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .map(getDetails);
+ var isInvalid = function (param) { return param.isValid === false; };
+ if (pathSegmentsAndParams.concat(queryParams).filter(isInvalid).length) {
+ return null;
+ }
+ /**
+ * Given a Param, applies the parameter value, then returns detailed information about it
+ */
+ function getDetails(param) {
+ // Normalize to typed value
+ var value = param.value(values[param.id]);
+ var isValid = param.validates(value);
+ var isDefaultValue = param.isDefaultValue(value);
+ // Check if we're in squash mode for the parameter
+ var squash = isDefaultValue ? param.squash : false;
+ // Allow the Parameter's Type to encode the value
+ var encoded = param.type.encode(value);
+ return { param: param, value: value, isValid: isValid, isDefaultValue: isDefaultValue, squash: squash, encoded: encoded };
+ }
+ // Build up the path-portion from the list of static segments and parameters
+ var pathString = pathSegmentsAndParams.reduce(function (acc, x) {
+ // The element is a static segment (a raw string); just append it
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isString)(x))
+ return acc + x;
+ // Otherwise, it's a ParamDetails.
+ var squash = x.squash, encoded = x.encoded, param = x.param;
+ // If squash is === true, try to remove a slash from the path
+ if (squash === true)
+ return acc.match(/\/$/) ? acc.slice(0, -1) : acc;
+ // If squash is a string, use the string for the param value
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isString)(squash))
+ return acc + squash;
+ if (squash !== false)
+ return acc; // ?
+ if (encoded == null)
+ return acc;
+ // If this parameter value is an array, encode the value using encodeDashes
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isArray)(encoded))
+ return acc + (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.map)(encoded, UrlMatcher.encodeDashes).join('-');
+ // If the parameter type is "raw", then do not encodeURIComponent
+ if (param.raw)
+ return acc + encoded;
+ // Encode the value
+ return acc + encodeURIComponent(encoded);
+ }, '');
+ // Build the query string by applying parameter values (array or regular)
+ // then mapping to key=value, then flattening and joining using "&"
+ var queryString = queryParams
+ .map(function (paramDetails) {
+ var param = paramDetails.param, squash = paramDetails.squash, encoded = paramDetails.encoded, isDefaultValue = paramDetails.isDefaultValue;
+ if (encoded == null || (isDefaultValue && squash !== false))
+ return;
+ if (!(0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isArray)(encoded))
+ encoded = [encoded];
+ if (encoded.length === 0)
+ return;
+ if (!param.raw)
+ encoded = (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.map)(encoded, encodeURIComponent);
+ return encoded.map(function (val) { return param.id + "=" + val; });
+ })
+ .filter(_common_common__WEBPACK_IMPORTED_MODULE_0__.identity)
+ .reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .join('&');
+ // Concat the pathstring with the queryString (if exists) and the hashString (if exists)
+ return pathString + (queryString ? "?" + queryString : '') + (values['#'] ? '#' + values['#'] : '');
+ };
+ /** @internal */
+ UrlMatcher.nameValidator = /^\w+([-.]+\w+)*(?:\[\])?$/;
+ return UrlMatcher;
+}());
+
+//# sourceMappingURL=urlMatcher.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/url/urlMatcherFactory.js":
+/*!**********************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/url/urlMatcherFactory.js ***!
+ \**********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "ParamFactory": () => (/* binding */ ParamFactory),
+/* harmony export */ "UrlMatcherFactory": () => (/* binding */ UrlMatcherFactory)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+/* harmony import */ var _urlMatcher__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./urlMatcher */ "./node_modules/@uirouter/core/lib-esm/url/urlMatcher.js");
+/* harmony import */ var _params__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../params */ "./node_modules/@uirouter/core/lib-esm/params/index.js");
+var __assign = (undefined && undefined.__assign) || function () {
+ __assign = Object.assign || function(t) {
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
+ s = arguments[i];
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+ t[p] = s[p];
+ }
+ return t;
+ };
+ return __assign.apply(this, arguments);
+};
+
+
+
+var ParamFactory = /** @class */ (function () {
+ function ParamFactory(router) {
+ this.router = router;
+ }
+ ParamFactory.prototype.fromConfig = function (id, type, state) {
+ return new _params__WEBPACK_IMPORTED_MODULE_2__.Param(id, type, _params__WEBPACK_IMPORTED_MODULE_2__.DefType.CONFIG, this.router.urlService.config, state);
+ };
+ ParamFactory.prototype.fromPath = function (id, type, state) {
+ return new _params__WEBPACK_IMPORTED_MODULE_2__.Param(id, type, _params__WEBPACK_IMPORTED_MODULE_2__.DefType.PATH, this.router.urlService.config, state);
+ };
+ ParamFactory.prototype.fromSearch = function (id, type, state) {
+ return new _params__WEBPACK_IMPORTED_MODULE_2__.Param(id, type, _params__WEBPACK_IMPORTED_MODULE_2__.DefType.SEARCH, this.router.urlService.config, state);
+ };
+ return ParamFactory;
+}());
+
+/**
+ * Factory for [[UrlMatcher]] instances.
+ *
+ * The factory is available to ng1 services as
+ * `$urlMatcherFactory` or ng1 providers as `$urlMatcherFactoryProvider`.
+ */
+var UrlMatcherFactory = /** @class */ (function () {
+ // TODO: move implementations to UrlConfig (urlService.config)
+ function UrlMatcherFactory(/** @internal */ router) {
+ var _this = this;
+ this.router = router;
+ /** Creates a new [[Param]] for a given location (DefType) */
+ this.paramFactory = new ParamFactory(this.router);
+ // TODO: Check if removal of this will break anything, then remove these
+ this.UrlMatcher = _urlMatcher__WEBPACK_IMPORTED_MODULE_1__.UrlMatcher;
+ this.Param = _params__WEBPACK_IMPORTED_MODULE_2__.Param;
+ /** @deprecated use [[UrlConfig.caseInsensitive]] */
+ this.caseInsensitive = function (value) { return _this.router.urlService.config.caseInsensitive(value); };
+ /** @deprecated use [[UrlConfig.defaultSquashPolicy]] */
+ this.defaultSquashPolicy = function (value) { return _this.router.urlService.config.defaultSquashPolicy(value); };
+ /** @deprecated use [[UrlConfig.strictMode]] */
+ this.strictMode = function (value) { return _this.router.urlService.config.strictMode(value); };
+ /** @deprecated use [[UrlConfig.type]] */
+ this.type = function (name, definition, definitionFn) {
+ return _this.router.urlService.config.type(name, definition, definitionFn) || _this;
+ };
+ }
+ /**
+ * Creates a [[UrlMatcher]] for the specified pattern.
+ *
+ * @param pattern The URL pattern.
+ * @param config The config object hash.
+ * @returns The UrlMatcher.
+ */
+ UrlMatcherFactory.prototype.compile = function (pattern, config) {
+ var urlConfig = this.router.urlService.config;
+ // backward-compatible support for config.params -> config.state.params
+ var params = config && !config.state && config.params;
+ config = params ? __assign({ state: { params: params } }, config) : config;
+ var globalConfig = {
+ strict: urlConfig._isStrictMode,
+ caseInsensitive: urlConfig._isCaseInsensitive,
+ decodeParams: urlConfig._decodeParams,
+ };
+ return new _urlMatcher__WEBPACK_IMPORTED_MODULE_1__.UrlMatcher(pattern, urlConfig.paramTypes, this.paramFactory, (0,_common__WEBPACK_IMPORTED_MODULE_0__.extend)(globalConfig, config));
+ };
+ /**
+ * Returns true if the specified object is a [[UrlMatcher]], or false otherwise.
+ *
+ * @param object The object to perform the type check against.
+ * @returns `true` if the object matches the `UrlMatcher` interface, by
+ * implementing all the same methods.
+ */
+ UrlMatcherFactory.prototype.isMatcher = function (object) {
+ // TODO: typeof?
+ if (!(0,_common__WEBPACK_IMPORTED_MODULE_0__.isObject)(object))
+ return false;
+ var result = true;
+ (0,_common__WEBPACK_IMPORTED_MODULE_0__.forEach)(_urlMatcher__WEBPACK_IMPORTED_MODULE_1__.UrlMatcher.prototype, function (val, name) {
+ if ((0,_common__WEBPACK_IMPORTED_MODULE_0__.isFunction)(val))
+ result = result && (0,_common__WEBPACK_IMPORTED_MODULE_0__.isDefined)(object[name]) && (0,_common__WEBPACK_IMPORTED_MODULE_0__.isFunction)(object[name]);
+ });
+ return result;
+ };
+ /** @internal */
+ UrlMatcherFactory.prototype.$get = function () {
+ var urlConfig = this.router.urlService.config;
+ urlConfig.paramTypes.enqueue = false;
+ urlConfig.paramTypes._flushTypeQueue();
+ return this;
+ };
+ return UrlMatcherFactory;
+}());
+
+//# sourceMappingURL=urlMatcherFactory.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/url/urlRouter.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/url/urlRouter.js ***!
+ \**************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UrlRouter": () => (/* binding */ UrlRouter)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+/* harmony import */ var _urlRule__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./urlRule */ "./node_modules/@uirouter/core/lib-esm/url/urlRule.js");
+
+
+function appendBasePath(url, isHtml5, absolute, baseHref) {
+ if (baseHref === '/')
+ return url;
+ if (isHtml5)
+ return (0,_common__WEBPACK_IMPORTED_MODULE_0__.stripLastPathElement)(baseHref) + url;
+ if (absolute)
+ return baseHref.slice(1) + url;
+ return url;
+}
+/**
+ * Updates URL and responds to URL changes
+ *
+ * ### Deprecation warning:
+ * This class is now considered to be an internal API
+ * Use the [[UrlService]] instead.
+ * For configuring URL rules, use the [[UrlRules]] which can be found as [[UrlService.rules]].
+ */
+var UrlRouter = /** @class */ (function () {
+ /** @internal */
+ function UrlRouter(/** @internal */ router) {
+ var _this = this;
+ this.router = router;
+ // Delegate these calls to [[UrlService]]
+ /** @deprecated use [[UrlService.sync]]*/
+ this.sync = function (evt) { return _this.router.urlService.sync(evt); };
+ /** @deprecated use [[UrlService.listen]]*/
+ this.listen = function (enabled) { return _this.router.urlService.listen(enabled); };
+ /** @deprecated use [[UrlService.deferIntercept]]*/
+ this.deferIntercept = function (defer) { return _this.router.urlService.deferIntercept(defer); };
+ /** @deprecated use [[UrlService.match]]*/
+ this.match = function (urlParts) { return _this.router.urlService.match(urlParts); };
+ // Delegate these calls to [[UrlRules]]
+ /** @deprecated use [[UrlRules.initial]]*/
+ this.initial = function (handler) {
+ return _this.router.urlService.rules.initial(handler);
+ };
+ /** @deprecated use [[UrlRules.otherwise]]*/
+ this.otherwise = function (handler) {
+ return _this.router.urlService.rules.otherwise(handler);
+ };
+ /** @deprecated use [[UrlRules.removeRule]]*/
+ this.removeRule = function (rule) { return _this.router.urlService.rules.removeRule(rule); };
+ /** @deprecated use [[UrlRules.rule]]*/
+ this.rule = function (rule) { return _this.router.urlService.rules.rule(rule); };
+ /** @deprecated use [[UrlRules.rules]]*/
+ this.rules = function () { return _this.router.urlService.rules.rules(); };
+ /** @deprecated use [[UrlRules.sort]]*/
+ this.sort = function (compareFn) { return _this.router.urlService.rules.sort(compareFn); };
+ /** @deprecated use [[UrlRules.when]]*/
+ this.when = function (matcher, handler, options) { return _this.router.urlService.rules.when(matcher, handler, options); };
+ this.urlRuleFactory = new _urlRule__WEBPACK_IMPORTED_MODULE_1__.UrlRuleFactory(router);
+ }
+ /** Internal API. */
+ UrlRouter.prototype.update = function (read) {
+ var $url = this.router.locationService;
+ if (read) {
+ this.location = $url.url();
+ return;
+ }
+ if ($url.url() === this.location)
+ return;
+ $url.url(this.location, true);
+ };
+ /**
+ * Internal API.
+ *
+ * Pushes a new location to the browser history.
+ *
+ * @internal
+ * @param urlMatcher
+ * @param params
+ * @param options
+ */
+ UrlRouter.prototype.push = function (urlMatcher, params, options) {
+ var replace = options && !!options.replace;
+ this.router.urlService.url(urlMatcher.format(params || {}), replace);
+ };
+ /**
+ * Builds and returns a URL with interpolated parameters
+ *
+ * #### Example:
+ * ```js
+ * matcher = $umf.compile("/about/:person");
+ * params = { person: "bob" };
+ * $bob = $urlRouter.href(matcher, params);
+ * // $bob == "/about/bob";
+ * ```
+ *
+ * @param urlMatcher The [[UrlMatcher]] object which is used as the template of the URL to generate.
+ * @param params An object of parameter values to fill the matcher's required parameters.
+ * @param options Options object. The options are:
+ *
+ * - **`absolute`** - {boolean=false}, If true will generate an absolute url, e.g. "http://www.example.com/fullurl".
+ *
+ * @returns Returns the fully compiled URL, or `null` if `params` fail validation against `urlMatcher`
+ */
+ UrlRouter.prototype.href = function (urlMatcher, params, options) {
+ var url = urlMatcher.format(params);
+ if (url == null)
+ return null;
+ options = options || { absolute: false };
+ var cfg = this.router.urlService.config;
+ var isHtml5 = cfg.html5Mode();
+ if (!isHtml5 && url !== null) {
+ url = '#' + cfg.hashPrefix() + url;
+ }
+ url = appendBasePath(url, isHtml5, options.absolute, cfg.baseHref());
+ if (!options.absolute || !url) {
+ return url;
+ }
+ var slash = !isHtml5 && url ? '/' : '';
+ var cfgPort = cfg.port();
+ var port = (cfgPort === 80 || cfgPort === 443 ? '' : ':' + cfgPort);
+ return [cfg.protocol(), '://', cfg.host(), port, slash, url].join('');
+ };
+ Object.defineProperty(UrlRouter.prototype, "interceptDeferred", {
+ /** @deprecated use [[UrlService.interceptDeferred]]*/
+ get: function () {
+ return this.router.urlService.interceptDeferred;
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return UrlRouter;
+}());
+
+//# sourceMappingURL=urlRouter.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/url/urlRule.js":
+/*!************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/url/urlRule.js ***!
+ \************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UrlRuleFactory": () => (/* binding */ UrlRuleFactory),
+/* harmony export */ "BaseUrlRule": () => (/* binding */ BaseUrlRule)
+/* harmony export */ });
+/* harmony import */ var _urlMatcher__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./urlMatcher */ "./node_modules/@uirouter/core/lib-esm/url/urlMatcher.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _state_stateObject__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../state/stateObject */ "./node_modules/@uirouter/core/lib-esm/state/stateObject.js");
+
+
+
+
+
+/**
+ * Creates a [[UrlRule]]
+ *
+ * Creates a [[UrlRule]] from a:
+ *
+ * - `string`
+ * - [[UrlMatcher]]
+ * - `RegExp`
+ * - [[StateObject]]
+ */
+var UrlRuleFactory = /** @class */ (function () {
+ function UrlRuleFactory(router) {
+ this.router = router;
+ }
+ UrlRuleFactory.prototype.compile = function (str) {
+ return this.router.urlMatcherFactory.compile(str);
+ };
+ UrlRuleFactory.prototype.create = function (what, handler) {
+ var _this = this;
+ var isState = _state_stateObject__WEBPACK_IMPORTED_MODULE_4__.StateObject.isState, isStateDeclaration = _state_stateObject__WEBPACK_IMPORTED_MODULE_4__.StateObject.isStateDeclaration;
+ var makeRule = (0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.pattern)([
+ [_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString, function (_what) { return makeRule(_this.compile(_what)); }],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.is)(_urlMatcher__WEBPACK_IMPORTED_MODULE_0__.UrlMatcher), function (_what) { return _this.fromUrlMatcher(_what, handler); }],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.or)(isState, isStateDeclaration), function (_what) { return _this.fromState(_what, _this.router); }],
+ [(0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.is)(RegExp), function (_what) { return _this.fromRegExp(_what, handler); }],
+ [_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isFunction, function (_what) { return new BaseUrlRule(_what, handler); }],
+ ]);
+ var rule = makeRule(what);
+ if (!rule)
+ throw new Error("invalid 'what' in when()");
+ return rule;
+ };
+ /**
+ * A UrlRule which matches based on a UrlMatcher
+ *
+ * The `handler` may be either a `string`, a [[UrlRuleHandlerFn]] or another [[UrlMatcher]]
+ *
+ * ## Handler as a function
+ *
+ * If `handler` is a function, the function is invoked with:
+ *
+ * - matched parameter values ([[RawParams]] from [[UrlMatcher.exec]])
+ * - url: the current Url ([[UrlParts]])
+ * - router: the router object ([[UIRouter]])
+ *
+ * #### Example:
+ * ```js
+ * var urlMatcher = $umf.compile("/foo/:fooId/:barId");
+ * var rule = factory.fromUrlMatcher(urlMatcher, match => "/home/" + match.fooId + "/" + match.barId);
+ * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }
+ * var result = rule.handler(match); // '/home/123/456'
+ * ```
+ *
+ * ## Handler as UrlMatcher
+ *
+ * If `handler` is a UrlMatcher, the handler matcher is used to create the new url.
+ * The `handler` UrlMatcher is formatted using the matched param from the first matcher.
+ * The url is replaced with the result.
+ *
+ * #### Example:
+ * ```js
+ * var urlMatcher = $umf.compile("/foo/:fooId/:barId");
+ * var handler = $umf.compile("/home/:fooId/:barId");
+ * var rule = factory.fromUrlMatcher(urlMatcher, handler);
+ * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }
+ * var result = rule.handler(match); // '/home/123/456'
+ * ```
+ */
+ UrlRuleFactory.prototype.fromUrlMatcher = function (urlMatcher, handler) {
+ var _handler = handler;
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(handler))
+ handler = this.router.urlMatcherFactory.compile(handler);
+ if ((0,_common_hof__WEBPACK_IMPORTED_MODULE_3__.is)(_urlMatcher__WEBPACK_IMPORTED_MODULE_0__.UrlMatcher)(handler))
+ _handler = function (match) { return handler.format(match); };
+ function matchUrlParamters(url) {
+ var params = urlMatcher.exec(url.path, url.search, url.hash);
+ return urlMatcher.validates(params) && params;
+ }
+ // Prioritize URLs, lowest to highest:
+ // - Some optional URL parameters, but none matched
+ // - No optional parameters in URL
+ // - Some optional parameters, some matched
+ // - Some optional parameters, all matched
+ function matchPriority(params) {
+ var optional = urlMatcher.parameters().filter(function (param) { return param.isOptional; });
+ if (!optional.length)
+ return 0.000001;
+ var matched = optional.filter(function (param) { return params[param.id]; });
+ return matched.length / optional.length;
+ }
+ var details = { urlMatcher: urlMatcher, matchPriority: matchPriority, type: 'URLMATCHER' };
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_2__.extend)(new BaseUrlRule(matchUrlParamters, _handler), details);
+ };
+ /**
+ * A UrlRule which matches a state by its url
+ *
+ * #### Example:
+ * ```js
+ * var rule = factory.fromState($state.get('foo'), router);
+ * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }
+ * var result = rule.handler(match);
+ * // Starts a transition to 'foo' with params: { fooId: '123', barId: '456' }
+ * ```
+ */
+ UrlRuleFactory.prototype.fromState = function (stateOrDecl, router) {
+ var state = _state_stateObject__WEBPACK_IMPORTED_MODULE_4__.StateObject.isStateDeclaration(stateOrDecl) ? stateOrDecl.$$state() : stateOrDecl;
+ /**
+ * Handles match by transitioning to matched state
+ *
+ * First checks if the router should start a new transition.
+ * A new transition is not required if the current state's URL
+ * and the new URL are already identical
+ */
+ var handler = function (match) {
+ var $state = router.stateService;
+ var globals = router.globals;
+ if ($state.href(state, match) !== $state.href(globals.current, globals.params)) {
+ $state.transitionTo(state, match, { inherit: true, source: 'url' });
+ }
+ };
+ var details = { state: state, type: 'STATE' };
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_2__.extend)(this.fromUrlMatcher(state.url, handler), details);
+ };
+ /**
+ * A UrlRule which matches based on a regular expression
+ *
+ * The `handler` may be either a [[UrlRuleHandlerFn]] or a string.
+ *
+ * ## Handler as a function
+ *
+ * If `handler` is a function, the function is invoked with:
+ *
+ * - regexp match array (from `regexp`)
+ * - url: the current Url ([[UrlParts]])
+ * - router: the router object ([[UIRouter]])
+ *
+ * #### Example:
+ * ```js
+ * var rule = factory.fromRegExp(/^\/foo\/(bar|baz)$/, match => "/home/" + match[1])
+ * var match = rule.match('/foo/bar'); // results in [ '/foo/bar', 'bar' ]
+ * var result = rule.handler(match); // '/home/bar'
+ * ```
+ *
+ * ## Handler as string
+ *
+ * If `handler` is a string, the url is *replaced by the string* when the Rule is invoked.
+ * The string is first interpolated using `string.replace()` style pattern.
+ *
+ * #### Example:
+ * ```js
+ * var rule = factory.fromRegExp(/^\/foo\/(bar|baz)$/, "/home/$1")
+ * var match = rule.match('/foo/bar'); // results in [ '/foo/bar', 'bar' ]
+ * var result = rule.handler(match); // '/home/bar'
+ * ```
+ */
+ UrlRuleFactory.prototype.fromRegExp = function (regexp, handler) {
+ if (regexp.global || regexp.sticky)
+ throw new Error('Rule RegExp must not be global or sticky');
+ /**
+ * If handler is a string, the url will be replaced by the string.
+ * If the string has any String.replace() style variables in it (like `$2`),
+ * they will be replaced by the captures from [[match]]
+ */
+ var redirectUrlTo = function (match) {
+ // Interpolates matched values into $1 $2, etc using a String.replace()-style pattern
+ return handler.replace(/\$(\$|\d{1,2})/, function (m, what) { return match[what === '$' ? 0 : Number(what)]; });
+ };
+ var _handler = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isString)(handler) ? redirectUrlTo : handler;
+ var matchParamsFromRegexp = function (url) { return regexp.exec(url.path); };
+ var details = { regexp: regexp, type: 'REGEXP' };
+ return (0,_common_common__WEBPACK_IMPORTED_MODULE_2__.extend)(new BaseUrlRule(matchParamsFromRegexp, _handler), details);
+ };
+ UrlRuleFactory.isUrlRule = function (obj) { return obj && ['type', 'match', 'handler'].every(function (key) { return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_1__.isDefined)(obj[key]); }); };
+ return UrlRuleFactory;
+}());
+
+/**
+ * A base rule which calls `match`
+ *
+ * The value from the `match` function is passed through to the `handler`.
+ * @internal
+ */
+var BaseUrlRule = /** @class */ (function () {
+ function BaseUrlRule(match, handler) {
+ var _this = this;
+ this.match = match;
+ this.type = 'RAW';
+ this.matchPriority = function (match) { return 0 - _this.$id; };
+ this.handler = handler || _common_common__WEBPACK_IMPORTED_MODULE_2__.identity;
+ }
+ return BaseUrlRule;
+}());
+
+//# sourceMappingURL=urlRule.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/url/urlRules.js":
+/*!*************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/url/urlRules.js ***!
+ \*************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UrlRules": () => (/* binding */ UrlRules)
+/* harmony export */ });
+/* harmony import */ var _state__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../state */ "./node_modules/@uirouter/core/lib-esm/state/index.js");
+/* harmony import */ var _urlMatcher__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./urlMatcher */ "./node_modules/@uirouter/core/lib-esm/url/urlMatcher.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+/* harmony import */ var _urlRule__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./urlRule */ "./node_modules/@uirouter/core/lib-esm/url/urlRule.js");
+
+
+
+
+var prioritySort = function (a, b) { return (b.priority || 0) - (a.priority || 0); };
+var typeSort = function (a, b) {
+ var weights = { STATE: 4, URLMATCHER: 4, REGEXP: 3, RAW: 2, OTHER: 1 };
+ return (weights[a.type] || 0) - (weights[b.type] || 0);
+};
+var urlMatcherSort = function (a, b) {
+ return !a.urlMatcher || !b.urlMatcher ? 0 : _urlMatcher__WEBPACK_IMPORTED_MODULE_1__.UrlMatcher.compare(a.urlMatcher, b.urlMatcher);
+};
+var idSort = function (a, b) {
+ // Identically sorted STATE and URLMATCHER best rule will be chosen by `matchPriority` after each rule matches the URL
+ var useMatchPriority = { STATE: true, URLMATCHER: true };
+ var equal = useMatchPriority[a.type] && useMatchPriority[b.type];
+ return equal ? 0 : (a.$id || 0) - (b.$id || 0);
+};
+/**
+ * Default rule priority sorting function.
+ *
+ * Sorts rules by:
+ *
+ * - Explicit priority (set rule priority using [[UrlRules.when]])
+ * - Rule type (STATE: 4, URLMATCHER: 4, REGEXP: 3, RAW: 2, OTHER: 1)
+ * - `UrlMatcher` specificity ([[UrlMatcher.compare]]): works for STATE and URLMATCHER types to pick the most specific rule.
+ * - Rule registration order (for rule types other than STATE and URLMATCHER)
+ * - Equally sorted State and UrlMatcher rules will each match the URL.
+ * Then, the *best* match is chosen based on how many parameter values were matched.
+ */
+var defaultRuleSortFn;
+defaultRuleSortFn = function (a, b) {
+ var cmp = prioritySort(a, b);
+ if (cmp !== 0)
+ return cmp;
+ cmp = typeSort(a, b);
+ if (cmp !== 0)
+ return cmp;
+ cmp = urlMatcherSort(a, b);
+ if (cmp !== 0)
+ return cmp;
+ return idSort(a, b);
+};
+function getHandlerFn(handler) {
+ if (!(0,_common__WEBPACK_IMPORTED_MODULE_2__.isFunction)(handler) && !(0,_common__WEBPACK_IMPORTED_MODULE_2__.isString)(handler) && !(0,_common__WEBPACK_IMPORTED_MODULE_2__.is)(_state__WEBPACK_IMPORTED_MODULE_0__.TargetState)(handler) && !_state__WEBPACK_IMPORTED_MODULE_0__.TargetState.isDef(handler)) {
+ throw new Error("'handler' must be a string, function, TargetState, or have a state: 'newtarget' property");
+ }
+ return (0,_common__WEBPACK_IMPORTED_MODULE_2__.isFunction)(handler) ? handler : (0,_common__WEBPACK_IMPORTED_MODULE_2__.val)(handler);
+}
+/**
+ * API for managing URL rules
+ *
+ * This API is used to create and manage URL rules.
+ * URL rules are a mechanism to respond to specific URL patterns.
+ *
+ * The most commonly used methods are [[otherwise]] and [[when]].
+ *
+ * This API is found at `router.urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
+ */
+var UrlRules = /** @class */ (function () {
+ /** @internal */
+ function UrlRules(/** @internal */ router) {
+ this.router = router;
+ /** @internal */ this._sortFn = defaultRuleSortFn;
+ /** @internal */ this._rules = [];
+ /** @internal */ this._id = 0;
+ this.urlRuleFactory = new _urlRule__WEBPACK_IMPORTED_MODULE_3__.UrlRuleFactory(router);
+ }
+ /** @internal */
+ UrlRules.prototype.dispose = function (router) {
+ this._rules = [];
+ delete this._otherwiseFn;
+ };
+ /**
+ * Defines the initial state, path, or behavior to use when the app starts.
+ *
+ * This rule defines the initial/starting state for the application.
+ *
+ * This rule is triggered the first time the URL is checked (when the app initially loads).
+ * The rule is triggered only when the url matches either `""` or `"/"`.
+ *
+ * Note: The rule is intended to be used when the root of the application is directly linked to.
+ * When the URL is *not* `""` or `"/"` and doesn't match other rules, the [[otherwise]] rule is triggered.
+ * This allows 404-like behavior when an unknown URL is deep-linked.
+ *
+ * #### Example:
+ * Start app at `home` state.
+ * ```js
+ * .initial({ state: 'home' });
+ * ```
+ *
+ * #### Example:
+ * Start app at `/home` (by url)
+ * ```js
+ * .initial('/home');
+ * ```
+ *
+ * #### Example:
+ * When no other url rule matches, go to `home` state
+ * ```js
+ * .initial((matchValue, url, router) => {
+ * console.log('initial state');
+ * return { state: 'home' };
+ * })
+ * ```
+ *
+ * @param handler The initial state or url path, or a function which returns the state or url path (or performs custom logic).
+ */
+ UrlRules.prototype.initial = function (handler) {
+ var handlerFn = getHandlerFn(handler);
+ var matchFn = function (urlParts, router) {
+ return router.globals.transitionHistory.size() === 0 && !!/^\/?$/.exec(urlParts.path);
+ };
+ this.rule(this.urlRuleFactory.create(matchFn, handlerFn));
+ };
+ /**
+ * Defines the state, url, or behavior to use when no other rule matches the URL.
+ *
+ * This rule is matched when *no other rule* matches.
+ * It is generally used to handle unknown URLs (similar to "404" behavior, but on the client side).
+ *
+ * - If `handler` a string, it is treated as a url redirect
+ *
+ * #### Example:
+ * When no other url rule matches, redirect to `/index`
+ * ```js
+ * .otherwise('/index');
+ * ```
+ *
+ * - If `handler` is an object with a `state` property, the state is activated.
+ *
+ * #### Example:
+ * When no other url rule matches, redirect to `home` and provide a `dashboard` parameter value.
+ * ```js
+ * .otherwise({ state: 'home', params: { dashboard: 'default' } });
+ * ```
+ *
+ * - If `handler` is a function, the function receives the current url ([[UrlParts]]) and the [[UIRouter]] object.
+ * The function can perform actions, and/or return a value.
+ *
+ * #### Example:
+ * When no other url rule matches, manually trigger a transition to the `home` state
+ * ```js
+ * .otherwise((matchValue, urlParts, router) => {
+ * router.stateService.go('home');
+ * });
+ * ```
+ *
+ * #### Example:
+ * When no other url rule matches, go to `home` state
+ * ```js
+ * .otherwise((matchValue, urlParts, router) => {
+ * return { state: 'home' };
+ * });
+ * ```
+ *
+ * @param handler The url path to redirect to, or a function which returns the url path (or performs custom logic).
+ */
+ UrlRules.prototype.otherwise = function (handler) {
+ var handlerFn = getHandlerFn(handler);
+ this._otherwiseFn = this.urlRuleFactory.create((0,_common__WEBPACK_IMPORTED_MODULE_2__.val)(true), handlerFn);
+ this._sorted = false;
+ };
+ /**
+ * Remove a rule previously registered
+ *
+ * @param rule the matcher rule that was previously registered using [[rule]]
+ */
+ UrlRules.prototype.removeRule = function (rule) {
+ (0,_common__WEBPACK_IMPORTED_MODULE_2__.removeFrom)(this._rules, rule);
+ };
+ /**
+ * Manually adds a URL Rule.
+ *
+ * Usually, a url rule is added using [[StateDeclaration.url]] or [[when]].
+ * This api can be used directly for more control (to register a [[BaseUrlRule]], for example).
+ * Rules can be created using [[urlRuleFactory]], or created manually as simple objects.
+ *
+ * A rule should have a `match` function which returns truthy if the rule matched.
+ * It should also have a `handler` function which is invoked if the rule is the best match.
+ *
+ * @return a function that deregisters the rule
+ */
+ UrlRules.prototype.rule = function (rule) {
+ var _this = this;
+ if (!_urlRule__WEBPACK_IMPORTED_MODULE_3__.UrlRuleFactory.isUrlRule(rule))
+ throw new Error('invalid rule');
+ rule.$id = this._id++;
+ rule.priority = rule.priority || 0;
+ this._rules.push(rule);
+ this._sorted = false;
+ return function () { return _this.removeRule(rule); };
+ };
+ /**
+ * Gets all registered rules
+ *
+ * @returns an array of all the registered rules
+ */
+ UrlRules.prototype.rules = function () {
+ this.ensureSorted();
+ return this._rules.concat(this._otherwiseFn ? [this._otherwiseFn] : []);
+ };
+ /**
+ * Defines URL Rule priorities
+ *
+ * More than one rule ([[UrlRule]]) might match a given URL.
+ * This `compareFn` is used to sort the rules by priority.
+ * Higher priority rules should sort earlier.
+ *
+ * The [[defaultRuleSortFn]] is used by default.
+ *
+ * You only need to call this function once.
+ * The `compareFn` will be used to sort the rules as each is registered.
+ *
+ * If called without any parameter, it will re-sort the rules.
+ *
+ * ---
+ *
+ * Url rules may come from multiple sources: states's urls ([[StateDeclaration.url]]), [[when]], and [[rule]].
+ * Each rule has a (user-provided) [[UrlRule.priority]], a [[UrlRule.type]], and a [[UrlRule.$id]]
+ * The `$id` is is the order in which the rule was registered.
+ *
+ * The sort function should use these data, or data found on a specific type
+ * of [[UrlRule]] (such as [[StateRule.state]]), to order the rules as desired.
+ *
+ * #### Example:
+ * This compare function prioritizes rules by the order in which the rules were registered.
+ * A rule registered earlier has higher priority.
+ *
+ * ```js
+ * function compareFn(a, b) {
+ * return a.$id - b.$id;
+ * }
+ * ```
+ *
+ * @param compareFn a function that compares to [[UrlRule]] objects.
+ * The `compareFn` should abide by the `Array.sort` compare function rules.
+ * Given two rules, `a` and `b`, return a negative number if `a` should be higher priority.
+ * Return a positive number if `b` should be higher priority.
+ * Return `0` if the rules are identical.
+ *
+ * See the [mozilla reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Description)
+ * for details.
+ */
+ UrlRules.prototype.sort = function (compareFn) {
+ var sorted = this.stableSort(this._rules, (this._sortFn = compareFn || this._sortFn));
+ // precompute _sortGroup values and apply to each rule
+ var group = 0;
+ for (var i = 0; i < sorted.length; i++) {
+ sorted[i]._group = group;
+ if (i < sorted.length - 1 && this._sortFn(sorted[i], sorted[i + 1]) !== 0) {
+ group++;
+ }
+ }
+ this._rules = sorted;
+ this._sorted = true;
+ };
+ /** @internal */
+ UrlRules.prototype.ensureSorted = function () {
+ this._sorted || this.sort();
+ };
+ /** @internal */
+ UrlRules.prototype.stableSort = function (arr, compareFn) {
+ var arrOfWrapper = arr.map(function (elem, idx) { return ({ elem: elem, idx: idx }); });
+ arrOfWrapper.sort(function (wrapperA, wrapperB) {
+ var cmpDiff = compareFn(wrapperA.elem, wrapperB.elem);
+ return cmpDiff === 0 ? wrapperA.idx - wrapperB.idx : cmpDiff;
+ });
+ return arrOfWrapper.map(function (wrapper) { return wrapper.elem; });
+ };
+ /**
+ * Registers a `matcher` and `handler` for custom URLs handling.
+ *
+ * The `matcher` can be:
+ *
+ * - a [[UrlMatcher]]: See: [[UrlMatcherFactory.compile]]
+ * - a `string`: The string is compiled to a [[UrlMatcher]]
+ * - a `RegExp`: The regexp is used to match the url.
+ *
+ * The `handler` can be:
+ *
+ * - a string: The url is redirected to the value of the string.
+ * - a function: The url is redirected to the return value of the function.
+ *
+ * ---
+ *
+ * When the `handler` is a `string` and the `matcher` is a `UrlMatcher` (or string), the redirect
+ * string is interpolated with parameter values.
+ *
+ * #### Example:
+ * When the URL is `/foo/123` the rule will redirect to `/bar/123`.
+ * ```js
+ * .when("/foo/:param1", "/bar/:param1")
+ * ```
+ *
+ * ---
+ *
+ * When the `handler` is a string and the `matcher` is a `RegExp`, the redirect string is
+ * interpolated with capture groups from the RegExp.
+ *
+ * #### Example:
+ * When the URL is `/foo/123` the rule will redirect to `/bar/123`.
+ * ```js
+ * .when(new RegExp("^/foo/(.*)$"), "/bar/$1");
+ * ```
+ *
+ * ---
+ *
+ * When the handler is a function, it receives the matched value, the current URL, and the `UIRouter` object (See [[UrlRuleHandlerFn]]).
+ * The "matched value" differs based on the `matcher`.
+ * For [[UrlMatcher]]s, it will be the matched state params.
+ * For `RegExp`, it will be the match array from `regexp.exec()`.
+ *
+ * If the handler returns a string, the URL is redirected to the string.
+ *
+ * #### Example:
+ * When the URL is `/foo/123` the rule will redirect to `/bar/123`.
+ * ```js
+ * .when(new RegExp("^/foo/(.*)$"), match => "/bar/" + match[1]);
+ * ```
+ *
+ * Note: the `handler` may also invoke arbitrary code, such as `$state.go()`
+ *
+ * @param matcher A pattern `string` to match, compiled as a [[UrlMatcher]], or a `RegExp`.
+ * @param handler The path to redirect to, or a function that returns the path.
+ * @param options `{ priority: number }`
+ *
+ * @return the registered [[UrlRule]]
+ */
+ UrlRules.prototype.when = function (matcher, handler, options) {
+ var rule = this.urlRuleFactory.create(matcher, handler);
+ if ((0,_common__WEBPACK_IMPORTED_MODULE_2__.isDefined)(options && options.priority))
+ rule.priority = options.priority;
+ this.rule(rule);
+ return rule;
+ };
+ return UrlRules;
+}());
+
+//# sourceMappingURL=urlRules.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/url/urlService.js":
+/*!***************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/url/urlService.js ***!
+ \***************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UrlService": () => (/* binding */ UrlService)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+/* harmony import */ var _urlRules__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./urlRules */ "./node_modules/@uirouter/core/lib-esm/url/urlRules.js");
+/* harmony import */ var _urlConfig__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./urlConfig */ "./node_modules/@uirouter/core/lib-esm/url/urlConfig.js");
+/* harmony import */ var _state__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../state */ "./node_modules/@uirouter/core/lib-esm/state/index.js");
+
+
+
+
+/**
+ * API for URL management
+ */
+var UrlService = /** @class */ (function () {
+ /** @internal */
+ function UrlService(/** @internal */ router) {
+ var _this = this;
+ this.router = router;
+ /** @internal */ this.interceptDeferred = false;
+ /**
+ * The nested [[UrlRules]] API for managing URL rules and rewrites
+ *
+ * See: [[UrlRules]] for details
+ */
+ this.rules = new _urlRules__WEBPACK_IMPORTED_MODULE_1__.UrlRules(this.router);
+ /**
+ * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
+ *
+ * See: [[UrlConfig]] for details
+ */
+ this.config = new _urlConfig__WEBPACK_IMPORTED_MODULE_2__.UrlConfig(this.router);
+ // Delegate these calls to the current LocationServices implementation
+ /**
+ * Gets the current url, or updates the url
+ *
+ * ### Getting the current URL
+ *
+ * When no arguments are passed, returns the current URL.
+ * The URL is normalized using the internal [[path]]/[[search]]/[[hash]] values.
+ *
+ * For example, the URL may be stored in the hash ([[HashLocationServices]]) or
+ * have a base HREF prepended ([[PushStateLocationServices]]).
+ *
+ * The raw URL in the browser might be:
+ *
+ * ```
+ * http://mysite.com/somepath/index.html#/internal/path/123?param1=foo#anchor
+ * ```
+ *
+ * or
+ *
+ * ```
+ * http://mysite.com/basepath/internal/path/123?param1=foo#anchor
+ * ```
+ *
+ * then this method returns:
+ *
+ * ```
+ * /internal/path/123?param1=foo#anchor
+ * ```
+ *
+ *
+ * #### Example:
+ * ```js
+ * locationServices.url(); // "/some/path?query=value#anchor"
+ * ```
+ *
+ * ### Updating the URL
+ *
+ * When `newurl` arguments is provided, changes the URL to reflect `newurl`
+ *
+ * #### Example:
+ * ```js
+ * locationServices.url("/some/path?query=value#anchor", true);
+ * ```
+ *
+ * @param newurl The new value for the URL.
+ * This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
+ * It should not include the protocol, site, port, or base path of an absolute HREF.
+ * @param replace When true, replaces the current history entry (instead of appending it) with this new url
+ * @param state The history's state object, i.e., pushState (if the LocationServices implementation supports it)
+ *
+ * @return the url (after potentially being processed)
+ */
+ this.url = function (newurl, replace, state) {
+ return _this.router.locationService.url(newurl, replace, state);
+ };
+ /**
+ * Gets the path part of the current url
+ *
+ * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
+ *
+ * @return the path portion of the url
+ */
+ this.path = function () { return _this.router.locationService.path(); };
+ /**
+ * Gets the search part of the current url as an object
+ *
+ * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
+ *
+ * @return the search (query) portion of the url, as an object
+ */
+ this.search = function () { return _this.router.locationService.search(); };
+ /**
+ * Gets the hash part of the current url
+ *
+ * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
+ *
+ * @return the hash (anchor) portion of the url
+ */
+ this.hash = function () { return _this.router.locationService.hash(); };
+ /**
+ * @internal
+ *
+ * Registers a low level url change handler
+ *
+ * Note: Because this is a low level handler, it's not recommended for general use.
+ *
+ * #### Example:
+ * ```js
+ * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
+ * ```
+ *
+ * @param callback a function that will be called when the url is changing
+ * @return a function that de-registers the callback
+ */
+ this.onChange = function (callback) { return _this.router.locationService.onChange(callback); };
+ }
+ /** @internal */
+ UrlService.prototype.dispose = function () {
+ this.listen(false);
+ this.rules.dispose();
+ };
+ /**
+ * Gets the current URL parts
+ *
+ * This method returns the different parts of the current URL (the [[path]], [[search]], and [[hash]]) as a [[UrlParts]] object.
+ */
+ UrlService.prototype.parts = function () {
+ return { path: this.path(), search: this.search(), hash: this.hash() };
+ };
+ /**
+ * Activates the best rule for the current URL
+ *
+ * Checks the current URL for a matching [[UrlRule]], then invokes that rule's handler.
+ * This method is called internally any time the URL has changed.
+ *
+ * This effectively activates the state (or redirect, etc) which matches the current URL.
+ *
+ * #### Example:
+ * ```js
+ * urlService.deferIntercept();
+ *
+ * fetch('/states.json').then(resp => resp.json()).then(data => {
+ * data.forEach(state => $stateRegistry.register(state));
+ * urlService.listen();
+ * // Find the matching URL and invoke the handler.
+ * urlService.sync();
+ * });
+ * ```
+ */
+ UrlService.prototype.sync = function (evt) {
+ if (evt && evt.defaultPrevented)
+ return;
+ var _a = this.router, urlService = _a.urlService, stateService = _a.stateService;
+ var url = { path: urlService.path(), search: urlService.search(), hash: urlService.hash() };
+ var best = this.match(url);
+ var applyResult = (0,_common__WEBPACK_IMPORTED_MODULE_0__.pattern)([
+ [_common__WEBPACK_IMPORTED_MODULE_0__.isString, function (newurl) { return urlService.url(newurl, true); }],
+ [_state__WEBPACK_IMPORTED_MODULE_3__.TargetState.isDef, function (def) { return stateService.go(def.state, def.params, def.options); }],
+ [(0,_common__WEBPACK_IMPORTED_MODULE_0__.is)(_state__WEBPACK_IMPORTED_MODULE_3__.TargetState), function (target) { return stateService.go(target.state(), target.params(), target.options()); }],
+ ]);
+ applyResult(best && best.rule.handler(best.match, url, this.router));
+ };
+ /**
+ * Starts or stops listening for URL changes
+ *
+ * Call this sometime after calling [[deferIntercept]] to start monitoring the url.
+ * This causes UI-Router to start listening for changes to the URL, if it wasn't already listening.
+ *
+ * If called with `false`, UI-Router will stop listening (call listen(true) to start listening again).
+ *
+ * #### Example:
+ * ```js
+ * urlService.deferIntercept();
+ *
+ * fetch('/states.json').then(resp => resp.json()).then(data => {
+ * data.forEach(state => $stateRegistry.register(state));
+ * // Start responding to URL changes
+ * urlService.listen();
+ * urlService.sync();
+ * });
+ * ```
+ *
+ * @param enabled `true` or `false` to start or stop listening to URL changes
+ */
+ UrlService.prototype.listen = function (enabled) {
+ var _this = this;
+ if (enabled === false) {
+ this._stopListeningFn && this._stopListeningFn();
+ delete this._stopListeningFn;
+ }
+ else {
+ return (this._stopListeningFn =
+ this._stopListeningFn || this.router.urlService.onChange(function (evt) { return _this.sync(evt); }));
+ }
+ };
+ /**
+ * Disables monitoring of the URL.
+ *
+ * Call this method before UI-Router has bootstrapped.
+ * It will stop UI-Router from performing the initial url sync.
+ *
+ * This can be useful to perform some asynchronous initialization before the router starts.
+ * Once the initialization is complete, call [[listen]] to tell UI-Router to start watching and synchronizing the URL.
+ *
+ * #### Example:
+ * ```js
+ * // Prevent UI-Router from automatically intercepting URL changes when it starts;
+ * urlService.deferIntercept();
+ *
+ * fetch('/states.json').then(resp => resp.json()).then(data => {
+ * data.forEach(state => $stateRegistry.register(state));
+ * urlService.listen();
+ * urlService.sync();
+ * });
+ * ```
+ *
+ * @param defer Indicates whether to defer location change interception.
+ * Passing no parameter is equivalent to `true`.
+ */
+ UrlService.prototype.deferIntercept = function (defer) {
+ if (defer === undefined)
+ defer = true;
+ this.interceptDeferred = defer;
+ };
+ /**
+ * Matches a URL
+ *
+ * Given a URL (as a [[UrlParts]] object), check all rules and determine the best matching rule.
+ * Return the result as a [[MatchResult]].
+ */
+ UrlService.prototype.match = function (url) {
+ var _this = this;
+ url = (0,_common__WEBPACK_IMPORTED_MODULE_0__.extend)({ path: '', search: {}, hash: '' }, url);
+ var rules = this.rules.rules();
+ // Checks a single rule. Returns { rule: rule, match: match, weight: weight } if it matched, or undefined
+ var checkRule = function (rule) {
+ var match = rule.match(url, _this.router);
+ return match && { match: match, rule: rule, weight: rule.matchPriority(match) };
+ };
+ // The rules are pre-sorted.
+ // - Find the first matching rule.
+ // - Find any other matching rule that sorted *exactly the same*, according to `.sort()`.
+ // - Choose the rule with the highest match weight.
+ var best;
+ for (var i = 0; i < rules.length; i++) {
+ // Stop when there is a 'best' rule and the next rule sorts differently than it.
+ if (best && best.rule._group !== rules[i]._group)
+ break;
+ var current = checkRule(rules[i]);
+ // Pick the best MatchResult
+ best = !best || (current && current.weight > best.weight) ? current : best;
+ }
+ return best;
+ };
+ return UrlService;
+}());
+
+//# sourceMappingURL=urlService.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla.js":
+/*!********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla.js ***!
+ \********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _vanilla_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./vanilla/index */ "./node_modules/@uirouter/core/lib-esm/vanilla/index.js");
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _vanilla_index__WEBPACK_IMPORTED_MODULE_0__) if(__WEBPACK_IMPORT_KEY__ !== "default") __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _vanilla_index__WEBPACK_IMPORTED_MODULE_0__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+
+//# sourceMappingURL=vanilla.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/baseLocationService.js":
+/*!****************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/baseLocationService.js ***!
+ \****************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "BaseLocationServices": () => (/* binding */ BaseLocationServices)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./node_modules/@uirouter/core/lib-esm/vanilla/utils.js");
+
+
+/** A base `LocationServices` */
+var BaseLocationServices = /** @class */ (function () {
+ function BaseLocationServices(router, fireAfterUpdate) {
+ var _this = this;
+ this.fireAfterUpdate = fireAfterUpdate;
+ this._listeners = [];
+ this._listener = function (evt) { return _this._listeners.forEach(function (cb) { return cb(evt); }); };
+ this.hash = function () { return (0,_utils__WEBPACK_IMPORTED_MODULE_1__.parseUrl)(_this._get()).hash; };
+ this.path = function () { return (0,_utils__WEBPACK_IMPORTED_MODULE_1__.parseUrl)(_this._get()).path; };
+ this.search = function () { return (0,_utils__WEBPACK_IMPORTED_MODULE_1__.getParams)((0,_utils__WEBPACK_IMPORTED_MODULE_1__.parseUrl)(_this._get()).search); };
+ this._location = _common__WEBPACK_IMPORTED_MODULE_0__.root.location;
+ this._history = _common__WEBPACK_IMPORTED_MODULE_0__.root.history;
+ }
+ BaseLocationServices.prototype.url = function (url, replace) {
+ if (replace === void 0) { replace = true; }
+ if ((0,_common__WEBPACK_IMPORTED_MODULE_0__.isDefined)(url) && url !== this._get()) {
+ this._set(null, null, url, replace);
+ if (this.fireAfterUpdate) {
+ this._listeners.forEach(function (cb) { return cb({ url: url }); });
+ }
+ }
+ return (0,_utils__WEBPACK_IMPORTED_MODULE_1__.buildUrl)(this);
+ };
+ BaseLocationServices.prototype.onChange = function (cb) {
+ var _this = this;
+ this._listeners.push(cb);
+ return function () { return (0,_common__WEBPACK_IMPORTED_MODULE_0__.removeFrom)(_this._listeners, cb); };
+ };
+ BaseLocationServices.prototype.dispose = function (router) {
+ (0,_common__WEBPACK_IMPORTED_MODULE_0__.deregAll)(this._listeners);
+ };
+ return BaseLocationServices;
+}());
+
+//# sourceMappingURL=baseLocationService.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/browserLocationConfig.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/browserLocationConfig.js ***!
+ \******************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "BrowserLocationConfig": () => (/* binding */ BrowserLocationConfig)
+/* harmony export */ });
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+
+/** A `LocationConfig` that delegates to the browser's `location` object */
+var BrowserLocationConfig = /** @class */ (function () {
+ function BrowserLocationConfig(router, _isHtml5) {
+ if (_isHtml5 === void 0) { _isHtml5 = false; }
+ this._isHtml5 = _isHtml5;
+ this._baseHref = undefined;
+ this._hashPrefix = '';
+ }
+ BrowserLocationConfig.prototype.port = function () {
+ if (location.port) {
+ return Number(location.port);
+ }
+ return this.protocol() === 'https' ? 443 : 80;
+ };
+ BrowserLocationConfig.prototype.protocol = function () {
+ return location.protocol.replace(/:/g, '');
+ };
+ BrowserLocationConfig.prototype.host = function () {
+ return location.hostname;
+ };
+ BrowserLocationConfig.prototype.html5Mode = function () {
+ return this._isHtml5;
+ };
+ BrowserLocationConfig.prototype.hashPrefix = function (newprefix) {
+ return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isDefined)(newprefix) ? (this._hashPrefix = newprefix) : this._hashPrefix;
+ };
+ BrowserLocationConfig.prototype.baseHref = function (href) {
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isDefined)(href))
+ this._baseHref = href;
+ if ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isUndefined)(this._baseHref))
+ this._baseHref = this.getBaseHref();
+ return this._baseHref;
+ };
+ BrowserLocationConfig.prototype.getBaseHref = function () {
+ var baseTag = document.getElementsByTagName('base')[0];
+ if (baseTag && baseTag.href) {
+ return baseTag.href.replace(/^([^/:]*:)?\/\/[^/]*/, '');
+ }
+ return this._isHtml5 ? '/' : location.pathname || '/';
+ };
+ BrowserLocationConfig.prototype.dispose = function () { };
+ return BrowserLocationConfig;
+}());
+
+//# sourceMappingURL=browserLocationConfig.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/hashLocationService.js":
+/*!****************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/hashLocationService.js ***!
+ \****************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "HashLocationService": () => (/* binding */ HashLocationService)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+/* harmony import */ var _baseLocationService__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./baseLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/baseLocationService.js");
+var __extends = (undefined && undefined.__extends) || (function () {
+ var extendStatics = function (d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+ };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+
+
+/** A `LocationServices` that uses the browser hash "#" to get/set the current location */
+var HashLocationService = /** @class */ (function (_super) {
+ __extends(HashLocationService, _super);
+ function HashLocationService(router) {
+ var _this = _super.call(this, router, false) || this;
+ _common__WEBPACK_IMPORTED_MODULE_0__.root.addEventListener('hashchange', _this._listener, false);
+ return _this;
+ }
+ HashLocationService.prototype._get = function () {
+ return (0,_common__WEBPACK_IMPORTED_MODULE_0__.trimHashVal)(this._location.hash);
+ };
+ HashLocationService.prototype._set = function (state, title, url, replace) {
+ this._location.hash = url;
+ };
+ HashLocationService.prototype.dispose = function (router) {
+ _super.prototype.dispose.call(this, router);
+ _common__WEBPACK_IMPORTED_MODULE_0__.root.removeEventListener('hashchange', this._listener);
+ };
+ return HashLocationService;
+}(_baseLocationService__WEBPACK_IMPORTED_MODULE_1__.BaseLocationServices));
+
+//# sourceMappingURL=hashLocationService.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/index.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/index.js ***!
+ \**************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "$q": () => (/* reexport safe */ _q__WEBPACK_IMPORTED_MODULE_1__.$q),
+/* harmony export */ "$injector": () => (/* reexport safe */ _injector__WEBPACK_IMPORTED_MODULE_2__.$injector),
+/* harmony export */ "BaseLocationServices": () => (/* reexport safe */ _baseLocationService__WEBPACK_IMPORTED_MODULE_3__.BaseLocationServices),
+/* harmony export */ "HashLocationService": () => (/* reexport safe */ _hashLocationService__WEBPACK_IMPORTED_MODULE_4__.HashLocationService),
+/* harmony export */ "MemoryLocationService": () => (/* reexport safe */ _memoryLocationService__WEBPACK_IMPORTED_MODULE_5__.MemoryLocationService),
+/* harmony export */ "PushStateLocationService": () => (/* reexport safe */ _pushStateLocationService__WEBPACK_IMPORTED_MODULE_6__.PushStateLocationService),
+/* harmony export */ "MemoryLocationConfig": () => (/* reexport safe */ _memoryLocationConfig__WEBPACK_IMPORTED_MODULE_7__.MemoryLocationConfig),
+/* harmony export */ "BrowserLocationConfig": () => (/* reexport safe */ _browserLocationConfig__WEBPACK_IMPORTED_MODULE_8__.BrowserLocationConfig),
+/* harmony export */ "buildUrl": () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_9__.buildUrl),
+/* harmony export */ "getParams": () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_9__.getParams),
+/* harmony export */ "keyValsToObjectR": () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_9__.keyValsToObjectR),
+/* harmony export */ "locationPluginFactory": () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_9__.locationPluginFactory),
+/* harmony export */ "parseUrl": () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_9__.parseUrl),
+/* harmony export */ "hashLocationPlugin": () => (/* reexport safe */ _plugins__WEBPACK_IMPORTED_MODULE_10__.hashLocationPlugin),
+/* harmony export */ "memoryLocationPlugin": () => (/* reexport safe */ _plugins__WEBPACK_IMPORTED_MODULE_10__.memoryLocationPlugin),
+/* harmony export */ "pushStateLocationPlugin": () => (/* reexport safe */ _plugins__WEBPACK_IMPORTED_MODULE_10__.pushStateLocationPlugin),
+/* harmony export */ "servicesPlugin": () => (/* reexport safe */ _plugins__WEBPACK_IMPORTED_MODULE_10__.servicesPlugin)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/vanilla/interface.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_interface__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _interface__WEBPACK_IMPORTED_MODULE_0__) if(__WEBPACK_IMPORT_KEY__ !== "default") __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _interface__WEBPACK_IMPORTED_MODULE_0__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _q__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./q */ "./node_modules/@uirouter/core/lib-esm/vanilla/q.js");
+/* harmony import */ var _injector__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./injector */ "./node_modules/@uirouter/core/lib-esm/vanilla/injector.js");
+/* harmony import */ var _baseLocationService__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./baseLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/baseLocationService.js");
+/* harmony import */ var _hashLocationService__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./hashLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/hashLocationService.js");
+/* harmony import */ var _memoryLocationService__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./memoryLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/memoryLocationService.js");
+/* harmony import */ var _pushStateLocationService__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./pushStateLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/pushStateLocationService.js");
+/* harmony import */ var _memoryLocationConfig__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./memoryLocationConfig */ "./node_modules/@uirouter/core/lib-esm/vanilla/memoryLocationConfig.js");
+/* harmony import */ var _browserLocationConfig__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./browserLocationConfig */ "./node_modules/@uirouter/core/lib-esm/vanilla/browserLocationConfig.js");
+/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./utils */ "./node_modules/@uirouter/core/lib-esm/vanilla/utils.js");
+/* harmony import */ var _plugins__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./plugins */ "./node_modules/@uirouter/core/lib-esm/vanilla/plugins.js");
+/**
+ * Naive, pure JS implementation of core ui-router services
+ *
+ * @packageDocumentation
+ */
+
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/injector.js":
+/*!*****************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/injector.js ***!
+ \*****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "$injector": () => (/* binding */ $injector)
+/* harmony export */ });
+/* harmony import */ var _common_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/index */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+// globally available injectables
+var globals = {};
+var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+var ARGUMENT_NAMES = /([^\s,]+)/g;
+/**
+ * A basic angular1-like injector api
+ *
+ * This object implements four methods similar to the
+ * [angular 1 dependency injector](https://docs.angularjs.org/api/auto/service/$injector)
+ *
+ * UI-Router evolved from an angular 1 library to a framework agnostic library.
+ * However, some of the `@uirouter/core` code uses these ng1 style APIs to support ng1 style dependency injection.
+ *
+ * This object provides a naive implementation of a globally scoped dependency injection system.
+ * It supports the following DI approaches:
+ *
+ * ### Function parameter names
+ *
+ * A function's `.toString()` is called, and the parameter names are parsed.
+ * This only works when the parameter names aren't "mangled" by a minifier such as UglifyJS.
+ *
+ * ```js
+ * function injectedFunction(FooService, BarService) {
+ * // FooService and BarService are injected
+ * }
+ * ```
+ *
+ * ### Function annotation
+ *
+ * A function may be annotated with an array of dependency names as the `$inject` property.
+ *
+ * ```js
+ * injectedFunction.$inject = [ 'FooService', 'BarService' ];
+ * function injectedFunction(fs, bs) {
+ * // FooService and BarService are injected as fs and bs parameters
+ * }
+ * ```
+ *
+ * ### Array notation
+ *
+ * An array provides the names of the dependencies to inject (as strings).
+ * The function is the last element of the array.
+ *
+ * ```js
+ * [ 'FooService', 'BarService', function (fs, bs) {
+ * // FooService and BarService are injected as fs and bs parameters
+ * }]
+ * ```
+ *
+ * @type {$InjectorLike}
+ */
+var $injector = {
+ /** Gets an object from DI based on a string token */
+ get: function (name) { return globals[name]; },
+ /** Returns true if an object named `name` exists in global DI */
+ has: function (name) { return $injector.get(name) != null; },
+ /**
+ * Injects a function
+ *
+ * @param fn the function to inject
+ * @param context the function's `this` binding
+ * @param locals An object with additional DI tokens and values, such as `{ someToken: { foo: 1 } }`
+ */
+ invoke: function (fn, context, locals) {
+ var all = (0,_common_index__WEBPACK_IMPORTED_MODULE_0__.extend)({}, globals, locals || {});
+ var params = $injector.annotate(fn);
+ var ensureExist = (0,_common_index__WEBPACK_IMPORTED_MODULE_0__.assertPredicate)(function (key) { return all.hasOwnProperty(key); }, function (key) { return "DI can't find injectable: '" + key + "'"; });
+ var args = params.filter(ensureExist).map(function (x) { return all[x]; });
+ if ((0,_common_index__WEBPACK_IMPORTED_MODULE_0__.isFunction)(fn))
+ return fn.apply(context, args);
+ else
+ return fn.slice(-1)[0].apply(context, args);
+ },
+ /**
+ * Returns a function's dependencies
+ *
+ * Analyzes a function (or array) and returns an array of DI tokens that the function requires.
+ * @return an array of `string`s
+ */
+ annotate: function (fn) {
+ if (!(0,_common_index__WEBPACK_IMPORTED_MODULE_0__.isInjectable)(fn))
+ throw new Error("Not an injectable function: " + fn);
+ if (fn && fn.$inject)
+ return fn.$inject;
+ if ((0,_common_index__WEBPACK_IMPORTED_MODULE_0__.isArray)(fn))
+ return fn.slice(0, -1);
+ var fnStr = fn.toString().replace(STRIP_COMMENTS, '');
+ var result = fnStr.slice(fnStr.indexOf('(') + 1, fnStr.indexOf(')')).match(ARGUMENT_NAMES);
+ return result || [];
+ },
+};
+//# sourceMappingURL=injector.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/interface.js":
+/*!******************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/interface.js ***!
+ \******************************************************************/
+/***/ (() => {
+
+//# sourceMappingURL=interface.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/memoryLocationConfig.js":
+/*!*****************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/memoryLocationConfig.js ***!
+ \*****************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "MemoryLocationConfig": () => (/* binding */ MemoryLocationConfig)
+/* harmony export */ });
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+
+
+/** A `LocationConfig` mock that gets/sets all config from an in-memory object */
+var MemoryLocationConfig = /** @class */ (function () {
+ function MemoryLocationConfig() {
+ var _this = this;
+ this.dispose = _common_common__WEBPACK_IMPORTED_MODULE_1__.noop;
+ this._baseHref = '';
+ this._port = 80;
+ this._protocol = 'http';
+ this._host = 'localhost';
+ this._hashPrefix = '';
+ this.port = function () { return _this._port; };
+ this.protocol = function () { return _this._protocol; };
+ this.host = function () { return _this._host; };
+ this.baseHref = function () { return _this._baseHref; };
+ this.html5Mode = function () { return false; };
+ this.hashPrefix = function (newval) { return ((0,_common_predicates__WEBPACK_IMPORTED_MODULE_0__.isDefined)(newval) ? (_this._hashPrefix = newval) : _this._hashPrefix); };
+ }
+ return MemoryLocationConfig;
+}());
+
+//# sourceMappingURL=memoryLocationConfig.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/memoryLocationService.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/memoryLocationService.js ***!
+ \******************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "MemoryLocationService": () => (/* binding */ MemoryLocationService)
+/* harmony export */ });
+/* harmony import */ var _baseLocationService__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./baseLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/baseLocationService.js");
+var __extends = (undefined && undefined.__extends) || (function () {
+ var extendStatics = function (d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+ };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+
+/** A `LocationServices` that gets/sets the current location from an in-memory object */
+var MemoryLocationService = /** @class */ (function (_super) {
+ __extends(MemoryLocationService, _super);
+ function MemoryLocationService(router) {
+ return _super.call(this, router, true) || this;
+ }
+ MemoryLocationService.prototype._get = function () {
+ return this._url;
+ };
+ MemoryLocationService.prototype._set = function (state, title, url, replace) {
+ this._url = url;
+ };
+ return MemoryLocationService;
+}(_baseLocationService__WEBPACK_IMPORTED_MODULE_0__.BaseLocationServices));
+
+//# sourceMappingURL=memoryLocationService.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/plugins.js":
+/*!****************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/plugins.js ***!
+ \****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "servicesPlugin": () => (/* binding */ servicesPlugin),
+/* harmony export */ "hashLocationPlugin": () => (/* binding */ hashLocationPlugin),
+/* harmony export */ "pushStateLocationPlugin": () => (/* binding */ pushStateLocationPlugin),
+/* harmony export */ "memoryLocationPlugin": () => (/* binding */ memoryLocationPlugin)
+/* harmony export */ });
+/* harmony import */ var _browserLocationConfig__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./browserLocationConfig */ "./node_modules/@uirouter/core/lib-esm/vanilla/browserLocationConfig.js");
+/* harmony import */ var _hashLocationService__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./hashLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/hashLocationService.js");
+/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ "./node_modules/@uirouter/core/lib-esm/vanilla/utils.js");
+/* harmony import */ var _pushStateLocationService__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./pushStateLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/pushStateLocationService.js");
+/* harmony import */ var _memoryLocationService__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./memoryLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/memoryLocationService.js");
+/* harmony import */ var _memoryLocationConfig__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./memoryLocationConfig */ "./node_modules/@uirouter/core/lib-esm/vanilla/memoryLocationConfig.js");
+/* harmony import */ var _injector__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./injector */ "./node_modules/@uirouter/core/lib-esm/vanilla/injector.js");
+/* harmony import */ var _q__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./q */ "./node_modules/@uirouter/core/lib-esm/vanilla/q.js");
+/* harmony import */ var _common_coreservices__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../common/coreservices */ "./node_modules/@uirouter/core/lib-esm/common/coreservices.js");
+
+
+
+
+
+
+
+
+
+function servicesPlugin(router) {
+ _common_coreservices__WEBPACK_IMPORTED_MODULE_8__.services.$injector = _injector__WEBPACK_IMPORTED_MODULE_6__.$injector;
+ _common_coreservices__WEBPACK_IMPORTED_MODULE_8__.services.$q = _q__WEBPACK_IMPORTED_MODULE_7__.$q;
+ return { name: 'vanilla.services', $q: _q__WEBPACK_IMPORTED_MODULE_7__.$q, $injector: _injector__WEBPACK_IMPORTED_MODULE_6__.$injector, dispose: function () { return null; } };
+}
+/** A `UIRouterPlugin` uses the browser hash to get/set the current location */
+var hashLocationPlugin = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.locationPluginFactory)('vanilla.hashBangLocation', false, _hashLocationService__WEBPACK_IMPORTED_MODULE_1__.HashLocationService, _browserLocationConfig__WEBPACK_IMPORTED_MODULE_0__.BrowserLocationConfig);
+/** A `UIRouterPlugin` that gets/sets the current location using the browser's `location` and `history` apis */
+var pushStateLocationPlugin = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.locationPluginFactory)('vanilla.pushStateLocation', true, _pushStateLocationService__WEBPACK_IMPORTED_MODULE_3__.PushStateLocationService, _browserLocationConfig__WEBPACK_IMPORTED_MODULE_0__.BrowserLocationConfig);
+/** A `UIRouterPlugin` that gets/sets the current location from an in-memory object */
+var memoryLocationPlugin = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.locationPluginFactory)('vanilla.memoryLocation', false, _memoryLocationService__WEBPACK_IMPORTED_MODULE_4__.MemoryLocationService, _memoryLocationConfig__WEBPACK_IMPORTED_MODULE_5__.MemoryLocationConfig);
+//# sourceMappingURL=plugins.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/pushStateLocationService.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/pushStateLocationService.js ***!
+ \*********************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "PushStateLocationService": () => (/* binding */ PushStateLocationService)
+/* harmony export */ });
+/* harmony import */ var _baseLocationService__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./baseLocationService */ "./node_modules/@uirouter/core/lib-esm/vanilla/baseLocationService.js");
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+var __extends = (undefined && undefined.__extends) || (function () {
+ var extendStatics = function (d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+ };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+
+
+/**
+ * A `LocationServices` that gets/sets the current location using the browser's `location` and `history` apis
+ *
+ * Uses `history.pushState` and `history.replaceState`
+ */
+var PushStateLocationService = /** @class */ (function (_super) {
+ __extends(PushStateLocationService, _super);
+ function PushStateLocationService(router) {
+ var _this = _super.call(this, router, true) || this;
+ _this._config = router.urlService.config;
+ _common__WEBPACK_IMPORTED_MODULE_1__.root.addEventListener('popstate', _this._listener, false);
+ return _this;
+ }
+ /**
+ * Gets the base prefix without:
+ * - trailing slash
+ * - trailing filename
+ * - protocol and hostname
+ *
+ * If <base href='/base/'>, this returns '/base'.
+ * If <base href='/foo/base/'>, this returns '/foo/base'.
+ * If <base href='/base/index.html'>, this returns '/base'.
+ * If <base href='http://localhost:8080/base/index.html'>, this returns '/base'.
+ * If <base href='/base'>, this returns ''.
+ * If <base href='http://localhost:8080'>, this returns ''.
+ * If <base href='http://localhost:8080/'>, this returns ''.
+ *
+ * See: https://html.spec.whatwg.org/dev/semantics.html#the-base-element
+ */
+ PushStateLocationService.prototype._getBasePrefix = function () {
+ return (0,_common__WEBPACK_IMPORTED_MODULE_1__.stripLastPathElement)(this._config.baseHref());
+ };
+ PushStateLocationService.prototype._get = function () {
+ var _a = this._location, pathname = _a.pathname, hash = _a.hash, search = _a.search;
+ search = (0,_common__WEBPACK_IMPORTED_MODULE_1__.splitQuery)(search)[1]; // strip ? if found
+ hash = (0,_common__WEBPACK_IMPORTED_MODULE_1__.splitHash)(hash)[1]; // strip # if found
+ var basePrefix = this._getBasePrefix();
+ var exactBaseHrefMatch = pathname === this._config.baseHref();
+ var startsWithBase = pathname.substr(0, basePrefix.length) === basePrefix;
+ pathname = exactBaseHrefMatch ? '/' : startsWithBase ? pathname.substring(basePrefix.length) : pathname;
+ return pathname + (search ? '?' + search : '') + (hash ? '#' + hash : '');
+ };
+ PushStateLocationService.prototype._set = function (state, title, url, replace) {
+ var basePrefix = this._getBasePrefix();
+ var slash = url && url[0] !== '/' ? '/' : '';
+ var fullUrl = url === '' || url === '/' ? this._config.baseHref() : basePrefix + slash + url;
+ if (replace) {
+ this._history.replaceState(state, title, fullUrl);
+ }
+ else {
+ this._history.pushState(state, title, fullUrl);
+ }
+ };
+ PushStateLocationService.prototype.dispose = function (router) {
+ _super.prototype.dispose.call(this, router);
+ _common__WEBPACK_IMPORTED_MODULE_1__.root.removeEventListener('popstate', this._listener);
+ };
+ return PushStateLocationService;
+}(_baseLocationService__WEBPACK_IMPORTED_MODULE_0__.BaseLocationServices));
+
+//# sourceMappingURL=pushStateLocationService.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/q.js":
+/*!**********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/q.js ***!
+ \**********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "$q": () => (/* binding */ $q)
+/* harmony export */ });
+/* harmony import */ var _common_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/index */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+/**
+ * An angular1-like promise api
+ *
+ * This object implements four methods similar to the
+ * [angular 1 promise api](https://docs.angularjs.org/api/ng/service/$q)
+ *
+ * UI-Router evolved from an angular 1 library to a framework agnostic library.
+ * However, some of the `@uirouter/core` code uses these ng1 style APIs to support ng1 style dependency injection.
+ *
+ * This API provides native ES6 promise support wrapped as a $q-like API.
+ * Internally, UI-Router uses this $q object to perform promise operations.
+ * The `angular-ui-router` (ui-router for angular 1) uses the $q API provided by angular.
+ *
+ * $q-like promise api
+ */
+var $q = {
+ /** Normalizes a value as a promise */
+ when: function (val) { return new Promise(function (resolve, reject) { return resolve(val); }); },
+ /** Normalizes a value as a promise rejection */
+ reject: function (val) {
+ return new Promise(function (resolve, reject) {
+ reject(val);
+ });
+ },
+ /** @returns a deferred object, which has `resolve` and `reject` functions */
+ defer: function () {
+ var deferred = {};
+ deferred.promise = new Promise(function (resolve, reject) {
+ deferred.resolve = resolve;
+ deferred.reject = reject;
+ });
+ return deferred;
+ },
+ /** Like Promise.all(), but also supports object key/promise notation like $q */
+ all: function (promises) {
+ if ((0,_common_index__WEBPACK_IMPORTED_MODULE_0__.isArray)(promises)) {
+ return Promise.all(promises);
+ }
+ if ((0,_common_index__WEBPACK_IMPORTED_MODULE_0__.isObject)(promises)) {
+ // Convert promises map to promises array.
+ // When each promise resolves, map it to a tuple { key: key, val: val }
+ var chain = Object.keys(promises).map(function (key) { return promises[key].then(function (val) { return ({ key: key, val: val }); }); });
+ // Then wait for all promises to resolve, and convert them back to an object
+ return $q.all(chain).then(function (values) {
+ return values.reduce(function (acc, tuple) {
+ acc[tuple.key] = tuple.val;
+ return acc;
+ }, {});
+ });
+ }
+ },
+};
+//# sourceMappingURL=q.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/vanilla/utils.js":
+/*!**************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/vanilla/utils.js ***!
+ \**************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "keyValsToObjectR": () => (/* binding */ keyValsToObjectR),
+/* harmony export */ "getParams": () => (/* binding */ getParams),
+/* harmony export */ "parseUrl": () => (/* binding */ parseUrl),
+/* harmony export */ "buildUrl": () => (/* binding */ buildUrl),
+/* harmony export */ "locationPluginFactory": () => (/* binding */ locationPluginFactory)
+/* harmony export */ });
+/* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common */ "./node_modules/@uirouter/core/lib-esm/common/index.js");
+
+var keyValsToObjectR = function (accum, _a) {
+ var key = _a[0], val = _a[1];
+ if (!accum.hasOwnProperty(key)) {
+ accum[key] = val;
+ }
+ else if ((0,_common__WEBPACK_IMPORTED_MODULE_0__.isArray)(accum[key])) {
+ accum[key].push(val);
+ }
+ else {
+ accum[key] = [accum[key], val];
+ }
+ return accum;
+};
+var getParams = function (queryString) {
+ return queryString.split('&').filter(_common__WEBPACK_IMPORTED_MODULE_0__.identity).map(_common__WEBPACK_IMPORTED_MODULE_0__.splitEqual).reduce(keyValsToObjectR, {});
+};
+function parseUrl(url) {
+ var orEmptyString = function (x) { return x || ''; };
+ var _a = (0,_common__WEBPACK_IMPORTED_MODULE_0__.splitHash)(url).map(orEmptyString), beforehash = _a[0], hash = _a[1];
+ var _b = (0,_common__WEBPACK_IMPORTED_MODULE_0__.splitQuery)(beforehash).map(orEmptyString), path = _b[0], search = _b[1];
+ return { path: path, search: search, hash: hash, url: url };
+}
+var buildUrl = function (loc) {
+ var path = loc.path();
+ var searchObject = loc.search();
+ var hash = loc.hash();
+ var search = Object.keys(searchObject)
+ .map(function (key) {
+ var param = searchObject[key];
+ var vals = (0,_common__WEBPACK_IMPORTED_MODULE_0__.isArray)(param) ? param : [param];
+ return vals.map(function (val) { return key + '=' + val; });
+ })
+ .reduce(_common__WEBPACK_IMPORTED_MODULE_0__.unnestR, [])
+ .join('&');
+ return path + (search ? '?' + search : '') + (hash ? '#' + hash : '');
+};
+function locationPluginFactory(name, isHtml5, serviceClass, configurationClass) {
+ return function (uiRouter) {
+ var service = (uiRouter.locationService = new serviceClass(uiRouter));
+ var configuration = (uiRouter.locationConfig = new configurationClass(uiRouter, isHtml5));
+ function dispose(router) {
+ router.dispose(service);
+ router.dispose(configuration);
+ }
+ return { name: name, service: service, configuration: configuration, dispose: dispose };
+ };
+}
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/view/index.js":
+/*!***********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/view/index.js ***!
+ \***********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "ViewService": () => (/* reexport safe */ _view__WEBPACK_IMPORTED_MODULE_1__.ViewService)
+/* harmony export */ });
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interface */ "./node_modules/@uirouter/core/lib-esm/view/interface.js");
+/* harmony import */ var _interface__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_interface__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
+/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _interface__WEBPACK_IMPORTED_MODULE_0__) if(__WEBPACK_IMPORT_KEY__ !== "default") __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _interface__WEBPACK_IMPORTED_MODULE_0__[__WEBPACK_IMPORT_KEY__]
+/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+/* harmony import */ var _view__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./view */ "./node_modules/@uirouter/core/lib-esm/view/view.js");
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/view/interface.js":
+/*!***************************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/view/interface.js ***!
+ \***************************************************************/
+/***/ (() => {
+
+//# sourceMappingURL=interface.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@uirouter/core/lib-esm/view/view.js":
+/*!**********************************************************!*\
+ !*** ./node_modules/@uirouter/core/lib-esm/view/view.js ***!
+ \**********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "ViewService": () => (/* binding */ ViewService)
+/* harmony export */ });
+/* harmony import */ var _common_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../common/common */ "./node_modules/@uirouter/core/lib-esm/common/common.js");
+/* harmony import */ var _common_hof__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/hof */ "./node_modules/@uirouter/core/lib-esm/common/hof.js");
+/* harmony import */ var _common_predicates__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/predicates */ "./node_modules/@uirouter/core/lib-esm/common/predicates.js");
+/* harmony import */ var _common_trace__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/trace */ "./node_modules/@uirouter/core/lib-esm/common/trace.js");
+
+
+
+
+/**
+ * The View service
+ *
+ * This service pairs existing `ui-view` components (which live in the DOM)
+ * with view configs (from the state declaration objects: [[StateDeclaration.views]]).
+ *
+ * - After a successful Transition, the views from the newly entered states are activated via [[activateViewConfig]].
+ * The views from exited states are deactivated via [[deactivateViewConfig]].
+ * (See: the [[registerActivateViews]] Transition Hook)
+ *
+ * - As `ui-view` components pop in and out of existence, they register themselves using [[registerUIView]].
+ *
+ * - When the [[sync]] function is called, the registered `ui-view`(s) ([[ActiveUIView]])
+ * are configured with the matching [[ViewConfig]](s)
+ *
+ */
+var ViewService = /** @class */ (function () {
+ /** @internal */
+ function ViewService(/** @internal */ router) {
+ var _this = this;
+ this.router = router;
+ /** @internal */ this._uiViews = [];
+ /** @internal */ this._viewConfigs = [];
+ /** @internal */ this._viewConfigFactories = {};
+ /** @internal */ this._listeners = [];
+ /** @internal */
+ this._pluginapi = {
+ _rootViewContext: this._rootViewContext.bind(this),
+ _viewConfigFactory: this._viewConfigFactory.bind(this),
+ _registeredUIView: function (id) { return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.find)(_this._uiViews, function (view) { return _this.router.$id + "." + view.id === id; }); },
+ _registeredUIViews: function () { return _this._uiViews; },
+ _activeViewConfigs: function () { return _this._viewConfigs; },
+ _onSync: function (listener) {
+ _this._listeners.push(listener);
+ return function () { return (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.removeFrom)(_this._listeners, listener); };
+ },
+ };
+ }
+ /**
+ * Normalizes a view's name from a state.views configuration block.
+ *
+ * This should be used by a framework implementation to calculate the values for
+ * [[_ViewDeclaration.$uiViewName]] and [[_ViewDeclaration.$uiViewContextAnchor]].
+ *
+ * @param context the context object (state declaration) that the view belongs to
+ * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
+ *
+ * @returns the normalized uiViewName and uiViewContextAnchor that the view targets
+ */
+ ViewService.normalizeUIViewTarget = function (context, rawViewName) {
+ if (rawViewName === void 0) { rawViewName = ''; }
+ // TODO: Validate incoming view name with a regexp to allow:
+ // ex: "view.name@foo.bar" , "^.^.view.name" , "view.name@^.^" , "" ,
+ // "@" , "$default@^" , "!$default.$default" , "!foo.bar"
+ var viewAtContext = rawViewName.split('@');
+ var uiViewName = viewAtContext[0] || '$default'; // default to unnamed view
+ var uiViewContextAnchor = (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isString)(viewAtContext[1]) ? viewAtContext[1] : '^'; // default to parent context
+ // Handle relative view-name sugar syntax.
+ // Matches rawViewName "^.^.^.foo.bar" into array: ["^.^.^.foo.bar", "^.^.^", "foo.bar"],
+ var relativeViewNameSugar = /^(\^(?:\.\^)*)\.(.*$)/.exec(uiViewName);
+ if (relativeViewNameSugar) {
+ // Clobbers existing contextAnchor (rawViewName validation will fix this)
+ uiViewContextAnchor = relativeViewNameSugar[1]; // set anchor to "^.^.^"
+ uiViewName = relativeViewNameSugar[2]; // set view-name to "foo.bar"
+ }
+ if (uiViewName.charAt(0) === '!') {
+ uiViewName = uiViewName.substr(1);
+ uiViewContextAnchor = ''; // target absolutely from root
+ }
+ // handle parent relative targeting "^.^.^"
+ var relativeMatch = /^(\^(?:\.\^)*)$/;
+ if (relativeMatch.exec(uiViewContextAnchor)) {
+ var anchorState = uiViewContextAnchor.split('.').reduce(function (anchor, x) { return anchor.parent; }, context);
+ uiViewContextAnchor = anchorState.name;
+ }
+ else if (uiViewContextAnchor === '.') {
+ uiViewContextAnchor = context.name;
+ }
+ return { uiViewName: uiViewName, uiViewContextAnchor: uiViewContextAnchor };
+ };
+ /** @internal */
+ ViewService.prototype._rootViewContext = function (context) {
+ return (this._rootContext = context || this._rootContext);
+ };
+ /** @internal */
+ ViewService.prototype._viewConfigFactory = function (viewType, factory) {
+ this._viewConfigFactories[viewType] = factory;
+ };
+ ViewService.prototype.createViewConfig = function (path, decl) {
+ var cfgFactory = this._viewConfigFactories[decl.$type];
+ if (!cfgFactory)
+ throw new Error('ViewService: No view config factory registered for type ' + decl.$type);
+ var cfgs = cfgFactory(path, decl);
+ return (0,_common_predicates__WEBPACK_IMPORTED_MODULE_2__.isArray)(cfgs) ? cfgs : [cfgs];
+ };
+ /**
+ * Deactivates a ViewConfig.
+ *
+ * This function deactivates a `ViewConfig`.
+ * After calling [[sync]], it will un-pair from any `ui-view` with which it is currently paired.
+ *
+ * @param viewConfig The ViewConfig view to deregister.
+ */
+ ViewService.prototype.deactivateViewConfig = function (viewConfig) {
+ _common_trace__WEBPACK_IMPORTED_MODULE_3__.trace.traceViewServiceEvent('<- Removing', viewConfig);
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.removeFrom)(this._viewConfigs, viewConfig);
+ };
+ ViewService.prototype.activateViewConfig = function (viewConfig) {
+ _common_trace__WEBPACK_IMPORTED_MODULE_3__.trace.traceViewServiceEvent('-> Registering', viewConfig);
+ this._viewConfigs.push(viewConfig);
+ };
+ ViewService.prototype.sync = function () {
+ var _this = this;
+ var uiViewsByFqn = this._uiViews.map(function (uiv) { return [uiv.fqn, uiv]; }).reduce(_common_common__WEBPACK_IMPORTED_MODULE_0__.applyPairs, {});
+ // Return a weighted depth value for a uiView.
+ // The depth is the nesting depth of ui-views (based on FQN; times 10,000)
+ // plus the depth of the state that is populating the uiView
+ function uiViewDepth(uiView) {
+ var stateDepth = function (context) { return (context && context.parent ? stateDepth(context.parent) + 1 : 1); };
+ return uiView.fqn.split('.').length * 10000 + stateDepth(uiView.creationContext);
+ }
+ // Return the ViewConfig's context's depth in the context tree.
+ function viewConfigDepth(config) {
+ var context = config.viewDecl.$context, count = 0;
+ while (++count && context.parent)
+ context = context.parent;
+ return count;
+ }
+ // Given a depth function, returns a compare function which can return either ascending or descending order
+ var depthCompare = (0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.curry)(function (depthFn, posNeg, left, right) { return posNeg * (depthFn(left) - depthFn(right)); });
+ var matchingConfigPair = function (uiView) {
+ var matchingConfigs = _this._viewConfigs.filter(ViewService.matches(uiViewsByFqn, uiView));
+ if (matchingConfigs.length > 1) {
+ // This is OK. Child states can target a ui-view that the parent state also targets (the child wins)
+ // Sort by depth and return the match from the deepest child
+ // console.log(`Multiple matching view configs for ${uiView.fqn}`, matchingConfigs);
+ matchingConfigs.sort(depthCompare(viewConfigDepth, -1)); // descending
+ }
+ return { uiView: uiView, viewConfig: matchingConfigs[0] };
+ };
+ var configureUIView = function (tuple) {
+ // If a parent ui-view is reconfigured, it could destroy child ui-views.
+ // Before configuring a child ui-view, make sure it's still in the active uiViews array.
+ if (_this._uiViews.indexOf(tuple.uiView) !== -1)
+ tuple.uiView.configUpdated(tuple.viewConfig);
+ };
+ // Sort views by FQN and state depth. Process uiviews nearest the root first.
+ var uiViewTuples = this._uiViews.sort(depthCompare(uiViewDepth, 1)).map(matchingConfigPair);
+ var matchedViewConfigs = uiViewTuples.map(function (tuple) { return tuple.viewConfig; });
+ var unmatchedConfigTuples = this._viewConfigs
+ .filter(function (config) { return !(0,_common_common__WEBPACK_IMPORTED_MODULE_0__.inArray)(matchedViewConfigs, config); })
+ .map(function (viewConfig) { return ({ uiView: undefined, viewConfig: viewConfig }); });
+ uiViewTuples.forEach(configureUIView);
+ var allTuples = uiViewTuples.concat(unmatchedConfigTuples);
+ this._listeners.forEach(function (cb) { return cb(allTuples); });
+ _common_trace__WEBPACK_IMPORTED_MODULE_3__.trace.traceViewSync(allTuples);
+ };
+ /**
+ * Registers a `ui-view` component
+ *
+ * When a `ui-view` component is created, it uses this method to register itself.
+ * After registration the [[sync]] method is used to ensure all `ui-view` are configured with the proper [[ViewConfig]].
+ *
+ * Note: the `ui-view` component uses the `ViewConfig` to determine what view should be loaded inside the `ui-view`,
+ * and what the view's state context is.
+ *
+ * Note: There is no corresponding `deregisterUIView`.
+ * A `ui-view` should hang on to the return value of `registerUIView` and invoke it to deregister itself.
+ *
+ * @param uiView The metadata for a UIView
+ * @return a de-registration function used when the view is destroyed.
+ */
+ ViewService.prototype.registerUIView = function (uiView) {
+ _common_trace__WEBPACK_IMPORTED_MODULE_3__.trace.traceViewServiceUIViewEvent('-> Registering', uiView);
+ var uiViews = this._uiViews;
+ var fqnAndTypeMatches = function (uiv) { return uiv.fqn === uiView.fqn && uiv.$type === uiView.$type; };
+ if (uiViews.filter(fqnAndTypeMatches).length)
+ _common_trace__WEBPACK_IMPORTED_MODULE_3__.trace.traceViewServiceUIViewEvent('!!!! duplicate uiView named:', uiView);
+ uiViews.push(uiView);
+ this.sync();
+ return function () {
+ var idx = uiViews.indexOf(uiView);
+ if (idx === -1) {
+ _common_trace__WEBPACK_IMPORTED_MODULE_3__.trace.traceViewServiceUIViewEvent('Tried removing non-registered uiView', uiView);
+ return;
+ }
+ _common_trace__WEBPACK_IMPORTED_MODULE_3__.trace.traceViewServiceUIViewEvent('<- Deregistering', uiView);
+ (0,_common_common__WEBPACK_IMPORTED_MODULE_0__.removeFrom)(uiViews)(uiView);
+ };
+ };
+ /**
+ * Returns the list of views currently available on the page, by fully-qualified name.
+ *
+ * @return {Array} Returns an array of fully-qualified view names.
+ */
+ ViewService.prototype.available = function () {
+ return this._uiViews.map((0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.prop)('fqn'));
+ };
+ /**
+ * Returns the list of views on the page containing loaded content.
+ *
+ * @return {Array} Returns an array of fully-qualified view names.
+ */
+ ViewService.prototype.active = function () {
+ return this._uiViews.filter((0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.prop)('$config')).map((0,_common_hof__WEBPACK_IMPORTED_MODULE_1__.prop)('name'));
+ };
+ /**
+ * Given a ui-view and a ViewConfig, determines if they "match".
+ *
+ * A ui-view has a fully qualified name (fqn) and a context object. The fqn is built from its overall location in
+ * the DOM, describing its nesting relationship to any parent ui-view tags it is nested inside of.
+ *
+ * A ViewConfig has a target ui-view name and a context anchor. The ui-view name can be a simple name, or
+ * can be a segmented ui-view path, describing a portion of a ui-view fqn.
+ *
+ * In order for a ui-view to match ViewConfig, ui-view's $type must match the ViewConfig's $type
+ *
+ * If the ViewConfig's target ui-view name is a simple name (no dots), then a ui-view matches if:
+ * - the ui-view's name matches the ViewConfig's target name
+ * - the ui-view's context matches the ViewConfig's anchor
+ *
+ * If the ViewConfig's target ui-view name is a segmented name (with dots), then a ui-view matches if:
+ * - There exists a parent ui-view where:
+ * - the parent ui-view's name matches the first segment (index 0) of the ViewConfig's target name
+ * - the parent ui-view's context matches the ViewConfig's anchor
+ * - And the remaining segments (index 1..n) of the ViewConfig's target name match the tail of the ui-view's fqn
+ *
+ * Example:
+ *
+ * DOM:
+ * <ui-view> <!-- created in the root context (name: "") -->
+ * <ui-view name="foo"> <!-- created in the context named: "A" -->
+ * <ui-view> <!-- created in the context named: "A.B" -->
+ * <ui-view name="bar"> <!-- created in the context named: "A.B.C" -->
+ * </ui-view>
+ * </ui-view>
+ * </ui-view>
+ * </ui-view>
+ *
+ * uiViews: [
+ * { fqn: "$default", creationContext: { name: "" } },
+ * { fqn: "$default.foo", creationContext: { name: "A" } },
+ * { fqn: "$default.foo.$default", creationContext: { name: "A.B" } }
+ * { fqn: "$default.foo.$default.bar", creationContext: { name: "A.B.C" } }
+ * ]
+ *
+ * These four view configs all match the ui-view with the fqn: "$default.foo.$default.bar":
+ *
+ * - ViewConfig1: { uiViewName: "bar", uiViewContextAnchor: "A.B.C" }
+ * - ViewConfig2: { uiViewName: "$default.bar", uiViewContextAnchor: "A.B" }
+ * - ViewConfig3: { uiViewName: "foo.$default.bar", uiViewContextAnchor: "A" }
+ * - ViewConfig4: { uiViewName: "$default.foo.$default.bar", uiViewContextAnchor: "" }
+ *
+ * Using ViewConfig3 as an example, it matches the ui-view with fqn "$default.foo.$default.bar" because:
+ * - The ViewConfig's segmented target name is: [ "foo", "$default", "bar" ]
+ * - There exists a parent ui-view (which has fqn: "$default.foo") where:
+ * - the parent ui-view's name "foo" matches the first segment "foo" of the ViewConfig's target name
+ * - the parent ui-view's context "A" matches the ViewConfig's anchor context "A"
+ * - And the remaining segments [ "$default", "bar" ].join("."_ of the ViewConfig's target name match
+ * the tail of the ui-view's fqn "default.bar"
+ *
+ * @internal
+ */
+ ViewService.matches = function (uiViewsByFqn, uiView) { return function (viewConfig) {
+ // Don't supply an ng1 ui-view with an ng2 ViewConfig, etc
+ if (uiView.$type !== viewConfig.viewDecl.$type)
+ return false;
+ // Split names apart from both viewConfig and uiView into segments
+ var vc = viewConfig.viewDecl;
+ var vcSegments = vc.$uiViewName.split('.');
+ var uivSegments = uiView.fqn.split('.');
+ // Check if the tails of the segment arrays match. ex, these arrays' tails match:
+ // vc: ["foo", "bar"], uiv fqn: ["$default", "foo", "bar"]
+ if (!(0,_common_common__WEBPACK_IMPORTED_MODULE_0__.equals)(vcSegments, uivSegments.slice(0 - vcSegments.length)))
+ return false;
+ // Now check if the fqn ending at the first segment of the viewConfig matches the context:
+ // ["$default", "foo"].join(".") == "$default.foo", does the ui-view $default.foo context match?
+ var negOffset = 1 - vcSegments.length || undefined;
+ var fqnToFirstSegment = uivSegments.slice(0, negOffset).join('.');
+ var uiViewContext = uiViewsByFqn[fqnToFirstSegment].creationContext;
+ return vc.$uiViewContextAnchor === (uiViewContext && uiViewContext.name);
+ }; };
+ return ViewService;
+}());
+
+//# sourceMappingURL=view.js.map
+
+/***/ }),
+
+/***/ "./node_modules/angular-animate/angular-animate.js":
+/*!*********************************************************!*\
+ !*** ./node_modules/angular-animate/angular-animate.js ***!
+ \*********************************************************/
+/***/ (() => {
+
+/**
+ * @license AngularJS v1.8.2
+ * (c) 2010-2020 Google LLC. http://angularjs.org
+ * License: MIT
+ */
+(function(window, angular) {'use strict';
+
+var ELEMENT_NODE = 1;
+var COMMENT_NODE = 8;
+
+var ADD_CLASS_SUFFIX = '-add';
+var REMOVE_CLASS_SUFFIX = '-remove';
+var EVENT_CLASS_PREFIX = 'ng-';
+var ACTIVE_CLASS_SUFFIX = '-active';
+var PREPARE_CLASS_SUFFIX = '-prepare';
+
+var NG_ANIMATE_CLASSNAME = 'ng-animate';
+var NG_ANIMATE_CHILDREN_DATA = '$$ngAnimateChildren';
+
+// Detect proper transitionend/animationend event names.
+var CSS_PREFIX = '', TRANSITION_PROP, TRANSITIONEND_EVENT, ANIMATION_PROP, ANIMATIONEND_EVENT;
+
+// If unprefixed events are not supported but webkit-prefixed are, use the latter.
+// Otherwise, just use W3C names, browsers not supporting them at all will just ignore them.
+// Note: Chrome implements `window.onwebkitanimationend` and doesn't implement `window.onanimationend`
+// but at the same time dispatches the `animationend` event and not `webkitAnimationEnd`.
+// Register both events in case `window.onanimationend` is not supported because of that,
+// do the same for `transitionend` as Safari is likely to exhibit similar behavior.
+// Also, the only modern browser that uses vendor prefixes for transitions/keyframes is webkit
+// therefore there is no reason to test anymore for other vendor prefixes:
+// http://caniuse.com/#search=transition
+if ((window.ontransitionend === undefined) && (window.onwebkittransitionend !== undefined)) {
+ CSS_PREFIX = '-webkit-';
+ TRANSITION_PROP = 'WebkitTransition';
+ TRANSITIONEND_EVENT = 'webkitTransitionEnd transitionend';
+} else {
+ TRANSITION_PROP = 'transition';
+ TRANSITIONEND_EVENT = 'transitionend';
+}
+
+if ((window.onanimationend === undefined) && (window.onwebkitanimationend !== undefined)) {
+ CSS_PREFIX = '-webkit-';
+ ANIMATION_PROP = 'WebkitAnimation';
+ ANIMATIONEND_EVENT = 'webkitAnimationEnd animationend';
+} else {
+ ANIMATION_PROP = 'animation';
+ ANIMATIONEND_EVENT = 'animationend';
+}
+
+var DURATION_KEY = 'Duration';
+var PROPERTY_KEY = 'Property';
+var DELAY_KEY = 'Delay';
+var TIMING_KEY = 'TimingFunction';
+var ANIMATION_ITERATION_COUNT_KEY = 'IterationCount';
+var ANIMATION_PLAYSTATE_KEY = 'PlayState';
+var SAFE_FAST_FORWARD_DURATION_VALUE = 9999;
+
+var ANIMATION_DELAY_PROP = ANIMATION_PROP + DELAY_KEY;
+var ANIMATION_DURATION_PROP = ANIMATION_PROP + DURATION_KEY;
+var TRANSITION_DELAY_PROP = TRANSITION_PROP + DELAY_KEY;
+var TRANSITION_DURATION_PROP = TRANSITION_PROP + DURATION_KEY;
+
+var ngMinErr = angular.$$minErr('ng');
+function assertArg(arg, name, reason) {
+ if (!arg) {
+ throw ngMinErr('areq', 'Argument \'{0}\' is {1}', (name || '?'), (reason || 'required'));
+ }
+ return arg;
+}
+
+function mergeClasses(a,b) {
+ if (!a && !b) return '';
+ if (!a) return b;
+ if (!b) return a;
+ if (isArray(a)) a = a.join(' ');
+ if (isArray(b)) b = b.join(' ');
+ return a + ' ' + b;
+}
+
+function packageStyles(options) {
+ var styles = {};
+ if (options && (options.to || options.from)) {
+ styles.to = options.to;
+ styles.from = options.from;
+ }
+ return styles;
+}
+
+function pendClasses(classes, fix, isPrefix) {
+ var className = '';
+ classes = isArray(classes)
+ ? classes
+ : classes && isString(classes) && classes.length
+ ? classes.split(/\s+/)
+ : [];
+ forEach(classes, function(klass, i) {
+ if (klass && klass.length > 0) {
+ className += (i > 0) ? ' ' : '';
+ className += isPrefix ? fix + klass
+ : klass + fix;
+ }
+ });
+ return className;
+}
+
+function removeFromArray(arr, val) {
+ var index = arr.indexOf(val);
+ if (val >= 0) {
+ arr.splice(index, 1);
+ }
+}
+
+function stripCommentsFromElement(element) {
+ if (element instanceof jqLite) {
+ switch (element.length) {
+ case 0:
+ return element;
+
+ case 1:
+ // there is no point of stripping anything if the element
+ // is the only element within the jqLite wrapper.
+ // (it's important that we retain the element instance.)
+ if (element[0].nodeType === ELEMENT_NODE) {
+ return element;
+ }
+ break;
+
+ default:
+ return jqLite(extractElementNode(element));
+ }
+ }
+
+ if (element.nodeType === ELEMENT_NODE) {
+ return jqLite(element);
+ }
+}
+
+function extractElementNode(element) {
+ if (!element[0]) return element;
+ for (var i = 0; i < element.length; i++) {
+ var elm = element[i];
+ if (elm.nodeType === ELEMENT_NODE) {
+ return elm;
+ }
+ }
+}
+
+function $$addClass($$jqLite, element, className) {
+ forEach(element, function(elm) {
+ $$jqLite.addClass(elm, className);
+ });
+}
+
+function $$removeClass($$jqLite, element, className) {
+ forEach(element, function(elm) {
+ $$jqLite.removeClass(elm, className);
+ });
+}
+
+function applyAnimationClassesFactory($$jqLite) {
+ return function(element, options) {
+ if (options.addClass) {
+ $$addClass($$jqLite, element, options.addClass);
+ options.addClass = null;
+ }
+ if (options.removeClass) {
+ $$removeClass($$jqLite, element, options.removeClass);
+ options.removeClass = null;
+ }
+ };
+}
+
+function prepareAnimationOptions(options) {
+ options = options || {};
+ if (!options.$$prepared) {
+ var domOperation = options.domOperation || noop;
+ options.domOperation = function() {
+ options.$$domOperationFired = true;
+ domOperation();
+ domOperation = noop;
+ };
+ options.$$prepared = true;
+ }
+ return options;
+}
+
+function applyAnimationStyles(element, options) {
+ applyAnimationFromStyles(element, options);
+ applyAnimationToStyles(element, options);
+}
+
+function applyAnimationFromStyles(element, options) {
+ if (options.from) {
+ element.css(options.from);
+ options.from = null;
+ }
+}
+
+function applyAnimationToStyles(element, options) {
+ if (options.to) {
+ element.css(options.to);
+ options.to = null;
+ }
+}
+
+function mergeAnimationDetails(element, oldAnimation, newAnimation) {
+ var target = oldAnimation.options || {};
+ var newOptions = newAnimation.options || {};
+
+ var toAdd = (target.addClass || '') + ' ' + (newOptions.addClass || '');
+ var toRemove = (target.removeClass || '') + ' ' + (newOptions.removeClass || '');
+ var classes = resolveElementClasses(element.attr('class'), toAdd, toRemove);
+
+ if (newOptions.preparationClasses) {
+ target.preparationClasses = concatWithSpace(newOptions.preparationClasses, target.preparationClasses);
+ delete newOptions.preparationClasses;
+ }
+
+ // noop is basically when there is no callback; otherwise something has been set
+ var realDomOperation = target.domOperation !== noop ? target.domOperation : null;
+
+ extend(target, newOptions);
+
+ // TODO(matsko or sreeramu): proper fix is to maintain all animation callback in array and call at last,but now only leave has the callback so no issue with this.
+ if (realDomOperation) {
+ target.domOperation = realDomOperation;
+ }
+
+ if (classes.addClass) {
+ target.addClass = classes.addClass;
+ } else {
+ target.addClass = null;
+ }
+
+ if (classes.removeClass) {
+ target.removeClass = classes.removeClass;
+ } else {
+ target.removeClass = null;
+ }
+
+ oldAnimation.addClass = target.addClass;
+ oldAnimation.removeClass = target.removeClass;
+
+ return target;
+}
+
+function resolveElementClasses(existing, toAdd, toRemove) {
+ var ADD_CLASS = 1;
+ var REMOVE_CLASS = -1;
+
+ var flags = {};
+ existing = splitClassesToLookup(existing);
+
+ toAdd = splitClassesToLookup(toAdd);
+ forEach(toAdd, function(value, key) {
+ flags[key] = ADD_CLASS;
+ });
+
+ toRemove = splitClassesToLookup(toRemove);
+ forEach(toRemove, function(value, key) {
+ flags[key] = flags[key] === ADD_CLASS ? null : REMOVE_CLASS;
+ });
+
+ var classes = {
+ addClass: '',
+ removeClass: ''
+ };
+
+ forEach(flags, function(val, klass) {
+ var prop, allow;
+ if (val === ADD_CLASS) {
+ prop = 'addClass';
+ allow = !existing[klass] || existing[klass + REMOVE_CLASS_SUFFIX];
+ } else if (val === REMOVE_CLASS) {
+ prop = 'removeClass';
+ allow = existing[klass] || existing[klass + ADD_CLASS_SUFFIX];
+ }
+ if (allow) {
+ if (classes[prop].length) {
+ classes[prop] += ' ';
+ }
+ classes[prop] += klass;
+ }
+ });
+
+ function splitClassesToLookup(classes) {
+ if (isString(classes)) {
+ classes = classes.split(' ');
+ }
+
+ var obj = {};
+ forEach(classes, function(klass) {
+ // sometimes the split leaves empty string values
+ // incase extra spaces were applied to the options
+ if (klass.length) {
+ obj[klass] = true;
+ }
+ });
+ return obj;
+ }
+
+ return classes;
+}
+
+function getDomNode(element) {
+ return (element instanceof jqLite) ? element[0] : element;
+}
+
+function applyGeneratedPreparationClasses($$jqLite, element, event, options) {
+ var classes = '';
+ if (event) {
+ classes = pendClasses(event, EVENT_CLASS_PREFIX, true);
+ }
+ if (options.addClass) {
+ classes = concatWithSpace(classes, pendClasses(options.addClass, ADD_CLASS_SUFFIX));
+ }
+ if (options.removeClass) {
+ classes = concatWithSpace(classes, pendClasses(options.removeClass, REMOVE_CLASS_SUFFIX));
+ }
+ if (classes.length) {
+ options.preparationClasses = classes;
+ element.addClass(classes);
+ }
+}
+
+function clearGeneratedClasses(element, options) {
+ if (options.preparationClasses) {
+ element.removeClass(options.preparationClasses);
+ options.preparationClasses = null;
+ }
+ if (options.activeClasses) {
+ element.removeClass(options.activeClasses);
+ options.activeClasses = null;
+ }
+}
+
+function blockKeyframeAnimations(node, applyBlock) {
+ var value = applyBlock ? 'paused' : '';
+ var key = ANIMATION_PROP + ANIMATION_PLAYSTATE_KEY;
+ applyInlineStyle(node, [key, value]);
+ return [key, value];
+}
+
+function applyInlineStyle(node, styleTuple) {
+ var prop = styleTuple[0];
+ var value = styleTuple[1];
+ node.style[prop] = value;
+}
+
+function concatWithSpace(a,b) {
+ if (!a) return b;
+ if (!b) return a;
+ return a + ' ' + b;
+}
+
+var helpers = {
+ blockTransitions: function(node, duration) {
+ // we use a negative delay value since it performs blocking
+ // yet it doesn't kill any existing transitions running on the
+ // same element which makes this safe for class-based animations
+ var value = duration ? '-' + duration + 's' : '';
+ applyInlineStyle(node, [TRANSITION_DELAY_PROP, value]);
+ return [TRANSITION_DELAY_PROP, value];
+ }
+};
+
+var $$rAFSchedulerFactory = ['$$rAF', function($$rAF) {
+ var queue, cancelFn;
+
+ function scheduler(tasks) {
+ // we make a copy since RAFScheduler mutates the state
+ // of the passed in array variable and this would be difficult
+ // to track down on the outside code
+ queue = queue.concat(tasks);
+ nextTick();
+ }
+
+ queue = scheduler.queue = [];
+
+ /* waitUntilQuiet does two things:
+ * 1. It will run the FINAL `fn` value only when an uncanceled RAF has passed through
+ * 2. It will delay the next wave of tasks from running until the quiet `fn` has run.
+ *
+ * The motivation here is that animation code can request more time from the scheduler
+ * before the next wave runs. This allows for certain DOM properties such as classes to
+ * be resolved in time for the next animation to run.
+ */
+ scheduler.waitUntilQuiet = function(fn) {
+ if (cancelFn) cancelFn();
+
+ cancelFn = $$rAF(function() {
+ cancelFn = null;
+ fn();
+ nextTick();
+ });
+ };
+
+ return scheduler;
+
+ function nextTick() {
+ if (!queue.length) return;
+
+ var items = queue.shift();
+ for (var i = 0; i < items.length; i++) {
+ items[i]();
+ }
+
+ if (!cancelFn) {
+ $$rAF(function() {
+ if (!cancelFn) nextTick();
+ });
+ }
+ }
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngAnimateChildren
+ * @restrict AE
+ * @element ANY
+ *
+ * @description
+ *
+ * ngAnimateChildren allows you to specify that children of this element should animate even if any
+ * of the children's parents are currently animating. By default, when an element has an active `enter`, `leave`, or `move`
+ * (structural) animation, child elements that also have an active structural animation are not animated.
+ *
+ * Note that even if `ngAnimateChildren` is set, no child animations will run when the parent element is removed from the DOM (`leave` animation).
+ *
+ *
+ * @param {string} ngAnimateChildren If the value is empty, `true` or `on`,
+ * then child animations are allowed. If the value is `false`, child animations are not allowed.
+ *
+ * @example
+ * <example module="ngAnimateChildren" name="ngAnimateChildren" deps="angular-animate.js" animations="true">
+ <file name="index.html">
+ <div ng-controller="MainController as main">
+ <label>Show container? <input type="checkbox" ng-model="main.enterElement" /></label>
+ <label>Animate children? <input type="checkbox" ng-model="main.animateChildren" /></label>
+ <hr>
+ <div ng-animate-children="{{main.animateChildren}}">
+ <div ng-if="main.enterElement" class="container">
+ List of items:
+ <div ng-repeat="item in [0, 1, 2, 3]" class="item">Item {{item}}</div>
+ </div>
+ </div>
+ </div>
+ </file>
+ <file name="animations.css">
+
+ .container.ng-enter,
+ .container.ng-leave {
+ transition: all ease 1.5s;
+ }
+
+ .container.ng-enter,
+ .container.ng-leave-active {
+ opacity: 0;
+ }
+
+ .container.ng-leave,
+ .container.ng-enter-active {
+ opacity: 1;
+ }
+
+ .item {
+ background: firebrick;
+ color: #FFF;
+ margin-bottom: 10px;
+ }
+
+ .item.ng-enter,
+ .item.ng-leave {
+ transition: transform 1.5s ease;
+ }
+
+ .item.ng-enter {
+ transform: translateX(50px);
+ }
+
+ .item.ng-enter-active {
+ transform: translateX(0);
+ }
+ </file>
+ <file name="script.js">
+ angular.module('ngAnimateChildren', ['ngAnimate'])
+ .controller('MainController', function MainController() {
+ this.animateChildren = false;
+ this.enterElement = false;
+ });
+ </file>
+ </example>
+ */
+var $$AnimateChildrenDirective = ['$interpolate', function($interpolate) {
+ return {
+ link: function(scope, element, attrs) {
+ var val = attrs.ngAnimateChildren;
+ if (isString(val) && val.length === 0) { //empty attribute
+ element.data(NG_ANIMATE_CHILDREN_DATA, true);
+ } else {
+ // Interpolate and set the value, so that it is available to
+ // animations that run right after compilation
+ setData($interpolate(val)(scope));
+ attrs.$observe('ngAnimateChildren', setData);
+ }
+
+ function setData(value) {
+ value = value === 'on' || value === 'true';
+ element.data(NG_ANIMATE_CHILDREN_DATA, value);
+ }
+ }
+ };
+}];
+
+/* exported $AnimateCssProvider */
+
+var ANIMATE_TIMER_KEY = '$$animateCss';
+
+/**
+ * @ngdoc service
+ * @name $animateCss
+ * @kind object
+ *
+ * @description
+ * The `$animateCss` service is a useful utility to trigger customized CSS-based transitions/keyframes
+ * from a JavaScript-based animation or directly from a directive. The purpose of `$animateCss` is NOT
+ * to side-step how `$animate` and ngAnimate work, but the goal is to allow pre-existing animations or
+ * directives to create more complex animations that can be purely driven using CSS code.
+ *
+ * Note that only browsers that support CSS transitions and/or keyframe animations are capable of
+ * rendering animations triggered via `$animateCss` (bad news for IE9 and lower).
+ *
+ * ## General Use
+ * Once again, `$animateCss` is designed to be used inside of a registered JavaScript animation that
+ * is powered by ngAnimate. It is possible to use `$animateCss` directly inside of a directive, however,
+ * any automatic control over cancelling animations and/or preventing animations from being run on
+ * child elements will not be handled by AngularJS. For this to work as expected, please use `$animate` to
+ * trigger the animation and then setup a JavaScript animation that injects `$animateCss` to trigger
+ * the CSS animation.
+ *
+ * The example below shows how we can create a folding animation on an element using `ng-if`:
+ *
+ * ```html
+ * <!-- notice the `fold-animation` CSS class -->
+ * <div ng-if="onOff" class="fold-animation">
+ * This element will go BOOM
+ * </div>
+ * <button ng-click="onOff=true">Fold In</button>
+ * ```
+ *
+ * Now we create the **JavaScript animation** that will trigger the CSS transition:
+ *
+ * ```js
+ * ngModule.animation('.fold-animation', ['$animateCss', function($animateCss) {
+ * return {
+ * enter: function(element, doneFn) {
+ * var height = element[0].offsetHeight;
+ * return $animateCss(element, {
+ * from: { height:'0px' },
+ * to: { height:height + 'px' },
+ * duration: 1 // one second
+ * });
+ * }
+ * }
+ * }]);
+ * ```
+ *
+ * ## More Advanced Uses
+ *
+ * `$animateCss` is the underlying code that ngAnimate uses to power **CSS-based animations** behind the scenes. Therefore CSS hooks
+ * like `.ng-EVENT`, `.ng-EVENT-active`, `.ng-EVENT-stagger` are all features that can be triggered using `$animateCss` via JavaScript code.
+ *
+ * This also means that just about any combination of adding classes, removing classes, setting styles, dynamically setting a keyframe animation,
+ * applying a hardcoded duration or delay value, changing the animation easing or applying a stagger animation are all options that work with
+ * `$animateCss`. The service itself is smart enough to figure out the combination of options and examine the element styling properties in order
+ * to provide a working animation that will run in CSS.
+ *
+ * The example below showcases a more advanced version of the `.fold-animation` from the example above:
+ *
+ * ```js
+ * ngModule.animation('.fold-animation', ['$animateCss', function($animateCss) {
+ * return {
+ * enter: function(element, doneFn) {
+ * var height = element[0].offsetHeight;
+ * return $animateCss(element, {
+ * addClass: 'red large-text pulse-twice',
+ * easing: 'ease-out',
+ * from: { height:'0px' },
+ * to: { height:height + 'px' },
+ * duration: 1 // one second
+ * });
+ * }
+ * }
+ * }]);
+ * ```
+ *
+ * Since we're adding/removing CSS classes then the CSS transition will also pick those up:
+ *
+ * ```css
+ * /* since a hardcoded duration value of 1 was provided in the JavaScript animation code,
+ * the CSS classes below will be transitioned despite them being defined as regular CSS classes */
+ * .red { background:red; }
+ * .large-text { font-size:20px; }
+ *
+ * /* we can also use a keyframe animation and $animateCss will make it work alongside the transition */
+ * .pulse-twice {
+ * animation: 0.5s pulse linear 2;
+ * -webkit-animation: 0.5s pulse linear 2;
+ * }
+ *
+ * @keyframes pulse {
+ * from { transform: scale(0.5); }
+ * to { transform: scale(1.5); }
+ * }
+ *
+ * @-webkit-keyframes pulse {
+ * from { -webkit-transform: scale(0.5); }
+ * to { -webkit-transform: scale(1.5); }
+ * }
+ * ```
+ *
+ * Given this complex combination of CSS classes, styles and options, `$animateCss` will figure everything out and make the animation happen.
+ *
+ * ## How the Options are handled
+ *
+ * `$animateCss` is very versatile and intelligent when it comes to figuring out what configurations to apply to the element to ensure the animation
+ * works with the options provided. Say for example we were adding a class that contained a keyframe value and we wanted to also animate some inline
+ * styles using the `from` and `to` properties.
+ *
+ * ```js
+ * var animator = $animateCss(element, {
+ * from: { background:'red' },
+ * to: { background:'blue' }
+ * });
+ * animator.start();
+ * ```
+ *
+ * ```css
+ * .rotating-animation {
+ * animation:0.5s rotate linear;
+ * -webkit-animation:0.5s rotate linear;
+ * }
+ *
+ * @keyframes rotate {
+ * from { transform: rotate(0deg); }
+ * to { transform: rotate(360deg); }
+ * }
+ *
+ * @-webkit-keyframes rotate {
+ * from { -webkit-transform: rotate(0deg); }
+ * to { -webkit-transform: rotate(360deg); }
+ * }
+ * ```
+ *
+ * The missing pieces here are that we do not have a transition set (within the CSS code nor within the `$animateCss` options) and the duration of the animation is
+ * going to be detected from what the keyframe styles on the CSS class are. In this event, `$animateCss` will automatically create an inline transition
+ * style matching the duration detected from the keyframe style (which is present in the CSS class that is being added) and then prepare both the transition
+ * and keyframe animations to run in parallel on the element. Then when the animation is underway the provided `from` and `to` CSS styles will be applied
+ * and spread across the transition and keyframe animation.
+ *
+ * ## What is returned
+ *
+ * `$animateCss` works in two stages: a preparation phase and an animation phase. Therefore when `$animateCss` is first called it will NOT actually
+ * start the animation. All that is going on here is that the element is being prepared for the animation (which means that the generated CSS classes are
+ * added and removed on the element). Once `$animateCss` is called it will return an object with the following properties:
+ *
+ * ```js
+ * var animator = $animateCss(element, { ... });
+ * ```
+ *
+ * Now what do the contents of our `animator` variable look like:
+ *
+ * ```js
+ * {
+ * // starts the animation
+ * start: Function,
+ *
+ * // ends (aborts) the animation
+ * end: Function
+ * }
+ * ```
+ *
+ * To actually start the animation we need to run `animation.start()` which will then return a promise that we can hook into to detect when the animation ends.
+ * If we choose not to run the animation then we MUST run `animation.end()` to perform a cleanup on the element (since some CSS classes and styles may have been
+ * applied to the element during the preparation phase). Note that all other properties such as duration, delay, transitions and keyframes are just properties
+ * and that changing them will not reconfigure the parameters of the animation.
+ *
+ * ### runner.done() vs runner.then()
+ * It is documented that `animation.start()` will return a promise object and this is true, however, there is also an additional method available on the
+ * runner called `.done(callbackFn)`. The done method works the same as `.finally(callbackFn)`, however, it does **not trigger a digest to occur**.
+ * Therefore, for performance reasons, it's always best to use `runner.done(callback)` instead of `runner.then()`, `runner.catch()` or `runner.finally()`
+ * unless you really need a digest to kick off afterwards.
+ *
+ * Keep in mind that, to make this easier, ngAnimate has tweaked the JS animations API to recognize when a runner instance is returned from $animateCss
+ * (so there is no need to call `runner.done(doneFn)` inside of your JavaScript animation code).
+ * Check the {@link ngAnimate.$animateCss#usage animation code above} to see how this works.
+ *
+ * @param {DOMElement} element the element that will be animated
+ * @param {object} options the animation-related options that will be applied during the animation
+ *
+ * * `event` - The DOM event (e.g. enter, leave, move). When used, a generated CSS class of `ng-EVENT` and `ng-EVENT-active` will be applied
+ * to the element during the animation. Multiple events can be provided when spaces are used as a separator. (Note that this will not perform any DOM operation.)
+ * * `structural` - Indicates that the `ng-` prefix will be added to the event class. Setting to `false` or omitting will turn `ng-EVENT` and
+ * `ng-EVENT-active` in `EVENT` and `EVENT-active`. Unused if `event` is omitted.
+ * * `easing` - The CSS easing value that will be applied to the transition or keyframe animation (or both).
+ * * `transitionStyle` - The raw CSS transition style that will be used (e.g. `1s linear all`).
+ * * `keyframeStyle` - The raw CSS keyframe animation style that will be used (e.g. `1s my_animation linear`).
+ * * `from` - The starting CSS styles (a key/value object) that will be applied at the start of the animation.
+ * * `to` - The ending CSS styles (a key/value object) that will be applied across the animation via a CSS transition.
+ * * `addClass` - A space separated list of CSS classes that will be added to the element and spread across the animation.
+ * * `removeClass` - A space separated list of CSS classes that will be removed from the element and spread across the animation.
+ * * `duration` - A number value representing the total duration of the transition and/or keyframe (note that a value of 1 is 1000ms). If a value of `0`
+ * is provided then the animation will be skipped entirely.
+ * * `delay` - A number value representing the total delay of the transition and/or keyframe (note that a value of 1 is 1000ms). If a value of `true` is
+ * used then whatever delay value is detected from the CSS classes will be mirrored on the elements styles (e.g. by setting delay true then the style value
+ * of the element will be `transition-delay: DETECTED_VALUE`). Using `true` is useful when you want the CSS classes and inline styles to all share the same
+ * CSS delay value.
+ * * `stagger` - A numeric time value representing the delay between successively animated elements
+ * ({@link ngAnimate#css-staggering-animations Click here to learn how CSS-based staggering works in ngAnimate.})
+ * * `staggerIndex` - The numeric index representing the stagger item (e.g. a value of 5 is equal to the sixth item in the stagger; therefore when a
+ * `stagger` option value of `0.1` is used then there will be a stagger delay of `600ms`)
+ * * `applyClassesEarly` - Whether or not the classes being added or removed will be used when detecting the animation. This is set by `$animate` when enter/leave/move animations are fired to ensure that the CSS classes are resolved in time. (Note that this will prevent any transitions from occurring on the classes being added and removed.)
+ * * `cleanupStyles` - Whether or not the provided `from` and `to` styles will be removed once
+ * the animation is closed. This is useful for when the styles are used purely for the sake of
+ * the animation and do not have a lasting visual effect on the element (e.g. a collapse and open animation).
+ * By default this value is set to `false`.
+ *
+ * @return {object} an object with start and end methods and details about the animation.
+ *
+ * * `start` - The method to start the animation. This will return a `Promise` when called.
+ * * `end` - This method will cancel the animation and remove all applied CSS classes and styles.
+ */
+var ONE_SECOND = 1000;
+
+var ELAPSED_TIME_MAX_DECIMAL_PLACES = 3;
+var CLOSING_TIME_BUFFER = 1.5;
+
+var DETECT_CSS_PROPERTIES = {
+ transitionDuration: TRANSITION_DURATION_PROP,
+ transitionDelay: TRANSITION_DELAY_PROP,
+ transitionProperty: TRANSITION_PROP + PROPERTY_KEY,
+ animationDuration: ANIMATION_DURATION_PROP,
+ animationDelay: ANIMATION_DELAY_PROP,
+ animationIterationCount: ANIMATION_PROP + ANIMATION_ITERATION_COUNT_KEY
+};
+
+var DETECT_STAGGER_CSS_PROPERTIES = {
+ transitionDuration: TRANSITION_DURATION_PROP,
+ transitionDelay: TRANSITION_DELAY_PROP,
+ animationDuration: ANIMATION_DURATION_PROP,
+ animationDelay: ANIMATION_DELAY_PROP
+};
+
+function getCssKeyframeDurationStyle(duration) {
+ return [ANIMATION_DURATION_PROP, duration + 's'];
+}
+
+function getCssDelayStyle(delay, isKeyframeAnimation) {
+ var prop = isKeyframeAnimation ? ANIMATION_DELAY_PROP : TRANSITION_DELAY_PROP;
+ return [prop, delay + 's'];
+}
+
+function computeCssStyles($window, element, properties) {
+ var styles = Object.create(null);
+ var detectedStyles = $window.getComputedStyle(element) || {};
+ forEach(properties, function(formalStyleName, actualStyleName) {
+ var val = detectedStyles[formalStyleName];
+ if (val) {
+ var c = val.charAt(0);
+
+ // only numerical-based values have a negative sign or digit as the first value
+ if (c === '-' || c === '+' || c >= 0) {
+ val = parseMaxTime(val);
+ }
+
+ // by setting this to null in the event that the delay is not set or is set directly as 0
+ // then we can still allow for negative values to be used later on and not mistake this
+ // value for being greater than any other negative value.
+ if (val === 0) {
+ val = null;
+ }
+ styles[actualStyleName] = val;
+ }
+ });
+
+ return styles;
+}
+
+function parseMaxTime(str) {
+ var maxValue = 0;
+ var values = str.split(/\s*,\s*/);
+ forEach(values, function(value) {
+ // it's always safe to consider only second values and omit `ms` values since
+ // getComputedStyle will always handle the conversion for us
+ if (value.charAt(value.length - 1) === 's') {
+ value = value.substring(0, value.length - 1);
+ }
+ value = parseFloat(value) || 0;
+ maxValue = maxValue ? Math.max(value, maxValue) : value;
+ });
+ return maxValue;
+}
+
+function truthyTimingValue(val) {
+ return val === 0 || val != null;
+}
+
+function getCssTransitionDurationStyle(duration, applyOnlyDuration) {
+ var style = TRANSITION_PROP;
+ var value = duration + 's';
+ if (applyOnlyDuration) {
+ style += DURATION_KEY;
+ } else {
+ value += ' linear all';
+ }
+ return [style, value];
+}
+
+// we do not reassign an already present style value since
+// if we detect the style property value again we may be
+// detecting styles that were added via the `from` styles.
+// We make use of `isDefined` here since an empty string
+// or null value (which is what getPropertyValue will return
+// for a non-existing style) will still be marked as a valid
+// value for the style (a falsy value implies that the style
+// is to be removed at the end of the animation). If we had a simple
+// "OR" statement then it would not be enough to catch that.
+function registerRestorableStyles(backup, node, properties) {
+ forEach(properties, function(prop) {
+ backup[prop] = isDefined(backup[prop])
+ ? backup[prop]
+ : node.style.getPropertyValue(prop);
+ });
+}
+
+var $AnimateCssProvider = ['$animateProvider', /** @this */ function($animateProvider) {
+
+ this.$get = ['$window', '$$jqLite', '$$AnimateRunner', '$timeout', '$$animateCache',
+ '$$forceReflow', '$sniffer', '$$rAFScheduler', '$$animateQueue',
+ function($window, $$jqLite, $$AnimateRunner, $timeout, $$animateCache,
+ $$forceReflow, $sniffer, $$rAFScheduler, $$animateQueue) {
+
+ var applyAnimationClasses = applyAnimationClassesFactory($$jqLite);
+
+ function computeCachedCssStyles(node, className, cacheKey, allowNoDuration, properties) {
+ var timings = $$animateCache.get(cacheKey);
+
+ if (!timings) {
+ timings = computeCssStyles($window, node, properties);
+ if (timings.animationIterationCount === 'infinite') {
+ timings.animationIterationCount = 1;
+ }
+ }
+
+ // if a css animation has no duration we
+ // should mark that so that repeated addClass/removeClass calls are skipped
+ var hasDuration = allowNoDuration || (timings.transitionDuration > 0 || timings.animationDuration > 0);
+
+ // we keep putting this in multiple times even though the value and the cacheKey are the same
+ // because we're keeping an internal tally of how many duplicate animations are detected.
+ $$animateCache.put(cacheKey, timings, hasDuration);
+
+ return timings;
+ }
+
+ function computeCachedCssStaggerStyles(node, className, cacheKey, properties) {
+ var stagger;
+ var staggerCacheKey = 'stagger-' + cacheKey;
+
+ // if we have one or more existing matches of matching elements
+ // containing the same parent + CSS styles (which is how cacheKey works)
+ // then staggering is possible
+ if ($$animateCache.count(cacheKey) > 0) {
+ stagger = $$animateCache.get(staggerCacheKey);
+
+ if (!stagger) {
+ var staggerClassName = pendClasses(className, '-stagger');
+
+ $$jqLite.addClass(node, staggerClassName);
+
+ stagger = computeCssStyles($window, node, properties);
+
+ // force the conversion of a null value to zero incase not set
+ stagger.animationDuration = Math.max(stagger.animationDuration, 0);
+ stagger.transitionDuration = Math.max(stagger.transitionDuration, 0);
+
+ $$jqLite.removeClass(node, staggerClassName);
+
+ $$animateCache.put(staggerCacheKey, stagger, true);
+ }
+ }
+
+ return stagger || {};
+ }
+
+ var rafWaitQueue = [];
+ function waitUntilQuiet(callback) {
+ rafWaitQueue.push(callback);
+ $$rAFScheduler.waitUntilQuiet(function() {
+ $$animateCache.flush();
+
+ // DO NOT REMOVE THIS LINE OR REFACTOR OUT THE `pageWidth` variable.
+ // PLEASE EXAMINE THE `$$forceReflow` service to understand why.
+ var pageWidth = $$forceReflow();
+
+ // we use a for loop to ensure that if the queue is changed
+ // during this looping then it will consider new requests
+ for (var i = 0; i < rafWaitQueue.length; i++) {
+ rafWaitQueue[i](pageWidth);
+ }
+ rafWaitQueue.length = 0;
+ });
+ }
+
+ function computeTimings(node, className, cacheKey, allowNoDuration) {
+ var timings = computeCachedCssStyles(node, className, cacheKey, allowNoDuration, DETECT_CSS_PROPERTIES);
+ var aD = timings.animationDelay;
+ var tD = timings.transitionDelay;
+ timings.maxDelay = aD && tD
+ ? Math.max(aD, tD)
+ : (aD || tD);
+ timings.maxDuration = Math.max(
+ timings.animationDuration * timings.animationIterationCount,
+ timings.transitionDuration);
+
+ return timings;
+ }
+
+ return function init(element, initialOptions) {
+ // all of the animation functions should create
+ // a copy of the options data, however, if a
+ // parent service has already created a copy then
+ // we should stick to using that
+ var options = initialOptions || {};
+ if (!options.$$prepared) {
+ options = prepareAnimationOptions(copy(options));
+ }
+
+ var restoreStyles = {};
+ var node = getDomNode(element);
+ if (!node
+ || !node.parentNode
+ || !$$animateQueue.enabled()) {
+ return closeAndReturnNoopAnimator();
+ }
+
+ var temporaryStyles = [];
+ var classes = element.attr('class');
+ var styles = packageStyles(options);
+ var animationClosed;
+ var animationPaused;
+ var animationCompleted;
+ var runner;
+ var runnerHost;
+ var maxDelay;
+ var maxDelayTime;
+ var maxDuration;
+ var maxDurationTime;
+ var startTime;
+ var events = [];
+
+ if (options.duration === 0 || (!$sniffer.animations && !$sniffer.transitions)) {
+ return closeAndReturnNoopAnimator();
+ }
+
+ var method = options.event && isArray(options.event)
+ ? options.event.join(' ')
+ : options.event;
+
+ var isStructural = method && options.structural;
+ var structuralClassName = '';
+ var addRemoveClassName = '';
+
+ if (isStructural) {
+ structuralClassName = pendClasses(method, EVENT_CLASS_PREFIX, true);
+ } else if (method) {
+ structuralClassName = method;
+ }
+
+ if (options.addClass) {
+ addRemoveClassName += pendClasses(options.addClass, ADD_CLASS_SUFFIX);
+ }
+
+ if (options.removeClass) {
+ if (addRemoveClassName.length) {
+ addRemoveClassName += ' ';
+ }
+ addRemoveClassName += pendClasses(options.removeClass, REMOVE_CLASS_SUFFIX);
+ }
+
+ // there may be a situation where a structural animation is combined together
+ // with CSS classes that need to resolve before the animation is computed.
+ // However this means that there is no explicit CSS code to block the animation
+ // from happening (by setting 0s none in the class name). If this is the case
+ // we need to apply the classes before the first rAF so we know to continue if
+ // there actually is a detected transition or keyframe animation
+ if (options.applyClassesEarly && addRemoveClassName.length) {
+ applyAnimationClasses(element, options);
+ }
+
+ var preparationClasses = [structuralClassName, addRemoveClassName].join(' ').trim();
+ var fullClassName = classes + ' ' + preparationClasses;
+ var hasToStyles = styles.to && Object.keys(styles.to).length > 0;
+ var containsKeyframeAnimation = (options.keyframeStyle || '').length > 0;
+
+ // there is no way we can trigger an animation if no styles and
+ // no classes are being applied which would then trigger a transition,
+ // unless there a is raw keyframe value that is applied to the element.
+ if (!containsKeyframeAnimation
+ && !hasToStyles
+ && !preparationClasses) {
+ return closeAndReturnNoopAnimator();
+ }
+
+ var stagger, cacheKey = $$animateCache.cacheKey(node, method, options.addClass, options.removeClass);
+ if ($$animateCache.containsCachedAnimationWithoutDuration(cacheKey)) {
+ preparationClasses = null;
+ return closeAndReturnNoopAnimator();
+ }
+
+ if (options.stagger > 0) {
+ var staggerVal = parseFloat(options.stagger);
+ stagger = {
+ transitionDelay: staggerVal,
+ animationDelay: staggerVal,
+ transitionDuration: 0,
+ animationDuration: 0
+ };
+ } else {
+ stagger = computeCachedCssStaggerStyles(node, preparationClasses, cacheKey, DETECT_STAGGER_CSS_PROPERTIES);
+ }
+
+ if (!options.$$skipPreparationClasses) {
+ $$jqLite.addClass(element, preparationClasses);
+ }
+
+ var applyOnlyDuration;
+
+ if (options.transitionStyle) {
+ var transitionStyle = [TRANSITION_PROP, options.transitionStyle];
+ applyInlineStyle(node, transitionStyle);
+ temporaryStyles.push(transitionStyle);
+ }
+
+ if (options.duration >= 0) {
+ applyOnlyDuration = node.style[TRANSITION_PROP].length > 0;
+ var durationStyle = getCssTransitionDurationStyle(options.duration, applyOnlyDuration);
+
+ // we set the duration so that it will be picked up by getComputedStyle later
+ applyInlineStyle(node, durationStyle);
+ temporaryStyles.push(durationStyle);
+ }
+
+ if (options.keyframeStyle) {
+ var keyframeStyle = [ANIMATION_PROP, options.keyframeStyle];
+ applyInlineStyle(node, keyframeStyle);
+ temporaryStyles.push(keyframeStyle);
+ }
+
+ var itemIndex = stagger
+ ? options.staggerIndex >= 0
+ ? options.staggerIndex
+ : $$animateCache.count(cacheKey)
+ : 0;
+
+ var isFirst = itemIndex === 0;
+
+ // this is a pre-emptive way of forcing the setup classes to be added and applied INSTANTLY
+ // without causing any combination of transitions to kick in. By adding a negative delay value
+ // it forces the setup class' transition to end immediately. We later then remove the negative
+ // transition delay to allow for the transition to naturally do it's thing. The beauty here is
+ // that if there is no transition defined then nothing will happen and this will also allow
+ // other transitions to be stacked on top of each other without any chopping them out.
+ if (isFirst && !options.skipBlocking) {
+ helpers.blockTransitions(node, SAFE_FAST_FORWARD_DURATION_VALUE);
+ }
+
+ var timings = computeTimings(node, fullClassName, cacheKey, !isStructural);
+ var relativeDelay = timings.maxDelay;
+ maxDelay = Math.max(relativeDelay, 0);
+ maxDuration = timings.maxDuration;
+
+ var flags = {};
+ flags.hasTransitions = timings.transitionDuration > 0;
+ flags.hasAnimations = timings.animationDuration > 0;
+ flags.hasTransitionAll = flags.hasTransitions && timings.transitionProperty === 'all';
+ flags.applyTransitionDuration = hasToStyles && (
+ (flags.hasTransitions && !flags.hasTransitionAll)
+ || (flags.hasAnimations && !flags.hasTransitions));
+ flags.applyAnimationDuration = options.duration && flags.hasAnimations;
+ flags.applyTransitionDelay = truthyTimingValue(options.delay) && (flags.applyTransitionDuration || flags.hasTransitions);
+ flags.applyAnimationDelay = truthyTimingValue(options.delay) && flags.hasAnimations;
+ flags.recalculateTimingStyles = addRemoveClassName.length > 0;
+
+ if (flags.applyTransitionDuration || flags.applyAnimationDuration) {
+ maxDuration = options.duration ? parseFloat(options.duration) : maxDuration;
+
+ if (flags.applyTransitionDuration) {
+ flags.hasTransitions = true;
+ timings.transitionDuration = maxDuration;
+ applyOnlyDuration = node.style[TRANSITION_PROP + PROPERTY_KEY].length > 0;
+ temporaryStyles.push(getCssTransitionDurationStyle(maxDuration, applyOnlyDuration));
+ }
+
+ if (flags.applyAnimationDuration) {
+ flags.hasAnimations = true;
+ timings.animationDuration = maxDuration;
+ temporaryStyles.push(getCssKeyframeDurationStyle(maxDuration));
+ }
+ }
+
+ if (maxDuration === 0 && !flags.recalculateTimingStyles) {
+ return closeAndReturnNoopAnimator();
+ }
+
+ var activeClasses = pendClasses(preparationClasses, ACTIVE_CLASS_SUFFIX);
+
+ if (options.delay != null) {
+ var delayStyle;
+ if (typeof options.delay !== 'boolean') {
+ delayStyle = parseFloat(options.delay);
+ // number in options.delay means we have to recalculate the delay for the closing timeout
+ maxDelay = Math.max(delayStyle, 0);
+ }
+
+ if (flags.applyTransitionDelay) {
+ temporaryStyles.push(getCssDelayStyle(delayStyle));
+ }
+
+ if (flags.applyAnimationDelay) {
+ temporaryStyles.push(getCssDelayStyle(delayStyle, true));
+ }
+ }
+
+ // we need to recalculate the delay value since we used a pre-emptive negative
+ // delay value and the delay value is required for the final event checking. This
+ // property will ensure that this will happen after the RAF phase has passed.
+ if (options.duration == null && timings.transitionDuration > 0) {
+ flags.recalculateTimingStyles = flags.recalculateTimingStyles || isFirst;
+ }
+
+ maxDelayTime = maxDelay * ONE_SECOND;
+ maxDurationTime = maxDuration * ONE_SECOND;
+ if (!options.skipBlocking) {
+ flags.blockTransition = timings.transitionDuration > 0;
+ flags.blockKeyframeAnimation = timings.animationDuration > 0 &&
+ stagger.animationDelay > 0 &&
+ stagger.animationDuration === 0;
+ }
+
+ if (options.from) {
+ if (options.cleanupStyles) {
+ registerRestorableStyles(restoreStyles, node, Object.keys(options.from));
+ }
+ applyAnimationFromStyles(element, options);
+ }
+
+ if (flags.blockTransition || flags.blockKeyframeAnimation) {
+ applyBlocking(maxDuration);
+ } else if (!options.skipBlocking) {
+ helpers.blockTransitions(node, false);
+ }
+
+ // TODO(matsko): for 1.5 change this code to have an animator object for better debugging
+ return {
+ $$willAnimate: true,
+ end: endFn,
+ start: function() {
+ if (animationClosed) return;
+
+ runnerHost = {
+ end: endFn,
+ cancel: cancelFn,
+ resume: null, //this will be set during the start() phase
+ pause: null
+ };
+
+ runner = new $$AnimateRunner(runnerHost);
+
+ waitUntilQuiet(start);
+
+ // we don't have access to pause/resume the animation
+ // since it hasn't run yet. AnimateRunner will therefore
+ // set noop functions for resume and pause and they will
+ // later be overridden once the animation is triggered
+ return runner;
+ }
+ };
+
+ function endFn() {
+ close();
+ }
+
+ function cancelFn() {
+ close(true);
+ }
+
+ function close(rejected) {
+ // if the promise has been called already then we shouldn't close
+ // the animation again
+ if (animationClosed || (animationCompleted && animationPaused)) return;
+ animationClosed = true;
+ animationPaused = false;
+
+ if (preparationClasses && !options.$$skipPreparationClasses) {
+ $$jqLite.removeClass(element, preparationClasses);
+ }
+
+ if (activeClasses) {
+ $$jqLite.removeClass(element, activeClasses);
+ }
+
+ blockKeyframeAnimations(node, false);
+ helpers.blockTransitions(node, false);
+
+ forEach(temporaryStyles, function(entry) {
+ // There is only one way to remove inline style properties entirely from elements.
+ // By using `removeProperty` this works, but we need to convert camel-cased CSS
+ // styles down to hyphenated values.
+ node.style[entry[0]] = '';
+ });
+
+ applyAnimationClasses(element, options);
+ applyAnimationStyles(element, options);
+
+ if (Object.keys(restoreStyles).length) {
+ forEach(restoreStyles, function(value, prop) {
+ if (value) {
+ node.style.setProperty(prop, value);
+ } else {
+ node.style.removeProperty(prop);
+ }
+ });
+ }
+
+ // the reason why we have this option is to allow a synchronous closing callback
+ // that is fired as SOON as the animation ends (when the CSS is removed) or if
+ // the animation never takes off at all. A good example is a leave animation since
+ // the element must be removed just after the animation is over or else the element
+ // will appear on screen for one animation frame causing an overbearing flicker.
+ if (options.onDone) {
+ options.onDone();
+ }
+
+ if (events && events.length) {
+ // Remove the transitionend / animationend listener(s)
+ element.off(events.join(' '), onAnimationProgress);
+ }
+
+ //Cancel the fallback closing timeout and remove the timer data
+ var animationTimerData = element.data(ANIMATE_TIMER_KEY);
+ if (animationTimerData) {
+ $timeout.cancel(animationTimerData[0].timer);
+ element.removeData(ANIMATE_TIMER_KEY);
+ }
+
+ // if the preparation function fails then the promise is not setup
+ if (runner) {
+ runner.complete(!rejected);
+ }
+ }
+
+ function applyBlocking(duration) {
+ if (flags.blockTransition) {
+ helpers.blockTransitions(node, duration);
+ }
+
+ if (flags.blockKeyframeAnimation) {
+ blockKeyframeAnimations(node, !!duration);
+ }
+ }
+
+ function closeAndReturnNoopAnimator() {
+ runner = new $$AnimateRunner({
+ end: endFn,
+ cancel: cancelFn
+ });
+
+ // should flush the cache animation
+ waitUntilQuiet(noop);
+ close();
+
+ return {
+ $$willAnimate: false,
+ start: function() {
+ return runner;
+ },
+ end: endFn
+ };
+ }
+
+ function onAnimationProgress(event) {
+ event.stopPropagation();
+ var ev = event.originalEvent || event;
+
+ if (ev.target !== node) {
+ // Since TransitionEvent / AnimationEvent bubble up,
+ // we have to ignore events by finished child animations
+ return;
+ }
+
+ // we now always use `Date.now()` due to the recent changes with
+ // event.timeStamp in Firefox, Webkit and Chrome (see #13494 for more info)
+ var timeStamp = ev.$manualTimeStamp || Date.now();
+
+ /* Firefox (or possibly just Gecko) likes to not round values up
+ * when a ms measurement is used for the animation */
+ var elapsedTime = parseFloat(ev.elapsedTime.toFixed(ELAPSED_TIME_MAX_DECIMAL_PLACES));
+
+ /* $manualTimeStamp is a mocked timeStamp value which is set
+ * within browserTrigger(). This is only here so that tests can
+ * mock animations properly. Real events fallback to event.timeStamp,
+ * or, if they don't, then a timeStamp is automatically created for them.
+ * We're checking to see if the timeStamp surpasses the expected delay,
+ * but we're using elapsedTime instead of the timeStamp on the 2nd
+ * pre-condition since animationPauseds sometimes close off early */
+ if (Math.max(timeStamp - startTime, 0) >= maxDelayTime && elapsedTime >= maxDuration) {
+ // we set this flag to ensure that if the transition is paused then, when resumed,
+ // the animation will automatically close itself since transitions cannot be paused.
+ animationCompleted = true;
+ close();
+ }
+ }
+
+ function start() {
+ if (animationClosed) return;
+ if (!node.parentNode) {
+ close();
+ return;
+ }
+
+ // even though we only pause keyframe animations here the pause flag
+ // will still happen when transitions are used. Only the transition will
+ // not be paused since that is not possible. If the animation ends when
+ // paused then it will not complete until unpaused or cancelled.
+ var playPause = function(playAnimation) {
+ if (!animationCompleted) {
+ animationPaused = !playAnimation;
+ if (timings.animationDuration) {
+ var value = blockKeyframeAnimations(node, animationPaused);
+ if (animationPaused) {
+ temporaryStyles.push(value);
+ } else {
+ removeFromArray(temporaryStyles, value);
+ }
+ }
+ } else if (animationPaused && playAnimation) {
+ animationPaused = false;
+ close();
+ }
+ };
+
+ // checking the stagger duration prevents an accidentally cascade of the CSS delay style
+ // being inherited from the parent. If the transition duration is zero then we can safely
+ // rely that the delay value is an intentional stagger delay style.
+ var maxStagger = itemIndex > 0
+ && ((timings.transitionDuration && stagger.transitionDuration === 0) ||
+ (timings.animationDuration && stagger.animationDuration === 0))
+ && Math.max(stagger.animationDelay, stagger.transitionDelay);
+ if (maxStagger) {
+ $timeout(triggerAnimationStart,
+ Math.floor(maxStagger * itemIndex * ONE_SECOND),
+ false);
+ } else {
+ triggerAnimationStart();
+ }
+
+ // this will decorate the existing promise runner with pause/resume methods
+ runnerHost.resume = function() {
+ playPause(true);
+ };
+
+ runnerHost.pause = function() {
+ playPause(false);
+ };
+
+ function triggerAnimationStart() {
+ // just incase a stagger animation kicks in when the animation
+ // itself was cancelled entirely
+ if (animationClosed) return;
+
+ applyBlocking(false);
+
+ forEach(temporaryStyles, function(entry) {
+ var key = entry[0];
+ var value = entry[1];
+ node.style[key] = value;
+ });
+
+ applyAnimationClasses(element, options);
+ $$jqLite.addClass(element, activeClasses);
+
+ if (flags.recalculateTimingStyles) {
+ fullClassName = node.getAttribute('class') + ' ' + preparationClasses;
+ cacheKey = $$animateCache.cacheKey(node, method, options.addClass, options.removeClass);
+
+ timings = computeTimings(node, fullClassName, cacheKey, false);
+ relativeDelay = timings.maxDelay;
+ maxDelay = Math.max(relativeDelay, 0);
+ maxDuration = timings.maxDuration;
+
+ if (maxDuration === 0) {
+ close();
+ return;
+ }
+
+ flags.hasTransitions = timings.transitionDuration > 0;
+ flags.hasAnimations = timings.animationDuration > 0;
+ }
+
+ if (flags.applyAnimationDelay) {
+ relativeDelay = typeof options.delay !== 'boolean' && truthyTimingValue(options.delay)
+ ? parseFloat(options.delay)
+ : relativeDelay;
+
+ maxDelay = Math.max(relativeDelay, 0);
+ timings.animationDelay = relativeDelay;
+ delayStyle = getCssDelayStyle(relativeDelay, true);
+ temporaryStyles.push(delayStyle);
+ node.style[delayStyle[0]] = delayStyle[1];
+ }
+
+ maxDelayTime = maxDelay * ONE_SECOND;
+ maxDurationTime = maxDuration * ONE_SECOND;
+
+ if (options.easing) {
+ var easeProp, easeVal = options.easing;
+ if (flags.hasTransitions) {
+ easeProp = TRANSITION_PROP + TIMING_KEY;
+ temporaryStyles.push([easeProp, easeVal]);
+ node.style[easeProp] = easeVal;
+ }
+ if (flags.hasAnimations) {
+ easeProp = ANIMATION_PROP + TIMING_KEY;
+ temporaryStyles.push([easeProp, easeVal]);
+ node.style[easeProp] = easeVal;
+ }
+ }
+
+ if (timings.transitionDuration) {
+ events.push(TRANSITIONEND_EVENT);
+ }
+
+ if (timings.animationDuration) {
+ events.push(ANIMATIONEND_EVENT);
+ }
+
+ startTime = Date.now();
+ var timerTime = maxDelayTime + CLOSING_TIME_BUFFER * maxDurationTime;
+ var endTime = startTime + timerTime;
+
+ var animationsData = element.data(ANIMATE_TIMER_KEY) || [];
+ var setupFallbackTimer = true;
+ if (animationsData.length) {
+ var currentTimerData = animationsData[0];
+ setupFallbackTimer = endTime > currentTimerData.expectedEndTime;
+ if (setupFallbackTimer) {
+ $timeout.cancel(currentTimerData.timer);
+ } else {
+ animationsData.push(close);
+ }
+ }
+
+ if (setupFallbackTimer) {
+ var timer = $timeout(onAnimationExpired, timerTime, false);
+ animationsData[0] = {
+ timer: timer,
+ expectedEndTime: endTime
+ };
+ animationsData.push(close);
+ element.data(ANIMATE_TIMER_KEY, animationsData);
+ }
+
+ if (events.length) {
+ element.on(events.join(' '), onAnimationProgress);
+ }
+
+ if (options.to) {
+ if (options.cleanupStyles) {
+ registerRestorableStyles(restoreStyles, node, Object.keys(options.to));
+ }
+ applyAnimationToStyles(element, options);
+ }
+ }
+
+ function onAnimationExpired() {
+ var animationsData = element.data(ANIMATE_TIMER_KEY);
+
+ // this will be false in the event that the element was
+ // removed from the DOM (via a leave animation or something
+ // similar)
+ if (animationsData) {
+ for (var i = 1; i < animationsData.length; i++) {
+ animationsData[i]();
+ }
+ element.removeData(ANIMATE_TIMER_KEY);
+ }
+ }
+ }
+ };
+ }];
+}];
+
+var $$AnimateCssDriverProvider = ['$$animationProvider', /** @this */ function($$animationProvider) {
+ $$animationProvider.drivers.push('$$animateCssDriver');
+
+ var NG_ANIMATE_SHIM_CLASS_NAME = 'ng-animate-shim';
+ var NG_ANIMATE_ANCHOR_CLASS_NAME = 'ng-anchor';
+
+ var NG_OUT_ANCHOR_CLASS_NAME = 'ng-anchor-out';
+ var NG_IN_ANCHOR_CLASS_NAME = 'ng-anchor-in';
+
+ function isDocumentFragment(node) {
+ return node.parentNode && node.parentNode.nodeType === 11;
+ }
+
+ this.$get = ['$animateCss', '$rootScope', '$$AnimateRunner', '$rootElement', '$sniffer', '$$jqLite', '$document',
+ function($animateCss, $rootScope, $$AnimateRunner, $rootElement, $sniffer, $$jqLite, $document) {
+
+ // only browsers that support these properties can render animations
+ if (!$sniffer.animations && !$sniffer.transitions) return noop;
+
+ var bodyNode = $document[0].body;
+ var rootNode = getDomNode($rootElement);
+
+ var rootBodyElement = jqLite(
+ // this is to avoid using something that exists outside of the body
+ // we also special case the doc fragment case because our unit test code
+ // appends the $rootElement to the body after the app has been bootstrapped
+ isDocumentFragment(rootNode) || bodyNode.contains(rootNode) ? rootNode : bodyNode
+ );
+
+ return function initDriverFn(animationDetails) {
+ return animationDetails.from && animationDetails.to
+ ? prepareFromToAnchorAnimation(animationDetails.from,
+ animationDetails.to,
+ animationDetails.classes,
+ animationDetails.anchors)
+ : prepareRegularAnimation(animationDetails);
+ };
+
+ function filterCssClasses(classes) {
+ //remove all the `ng-` stuff
+ return classes.replace(/\bng-\S+\b/g, '');
+ }
+
+ function getUniqueValues(a, b) {
+ if (isString(a)) a = a.split(' ');
+ if (isString(b)) b = b.split(' ');
+ return a.filter(function(val) {
+ return b.indexOf(val) === -1;
+ }).join(' ');
+ }
+
+ function prepareAnchoredAnimation(classes, outAnchor, inAnchor) {
+ var clone = jqLite(getDomNode(outAnchor).cloneNode(true));
+ var startingClasses = filterCssClasses(getClassVal(clone));
+
+ outAnchor.addClass(NG_ANIMATE_SHIM_CLASS_NAME);
+ inAnchor.addClass(NG_ANIMATE_SHIM_CLASS_NAME);
+
+ clone.addClass(NG_ANIMATE_ANCHOR_CLASS_NAME);
+
+ rootBodyElement.append(clone);
+
+ var animatorIn, animatorOut = prepareOutAnimation();
+
+ // the user may not end up using the `out` animation and
+ // only making use of the `in` animation or vice-versa.
+ // In either case we should allow this and not assume the
+ // animation is over unless both animations are not used.
+ if (!animatorOut) {
+ animatorIn = prepareInAnimation();
+ if (!animatorIn) {
+ return end();
+ }
+ }
+
+ var startingAnimator = animatorOut || animatorIn;
+
+ return {
+ start: function() {
+ var runner;
+
+ var currentAnimation = startingAnimator.start();
+ currentAnimation.done(function() {
+ currentAnimation = null;
+ if (!animatorIn) {
+ animatorIn = prepareInAnimation();
+ if (animatorIn) {
+ currentAnimation = animatorIn.start();
+ currentAnimation.done(function() {
+ currentAnimation = null;
+ end();
+ runner.complete();
+ });
+ return currentAnimation;
+ }
+ }
+ // in the event that there is no `in` animation
+ end();
+ runner.complete();
+ });
+
+ runner = new $$AnimateRunner({
+ end: endFn,
+ cancel: endFn
+ });
+
+ return runner;
+
+ function endFn() {
+ if (currentAnimation) {
+ currentAnimation.end();
+ }
+ }
+ }
+ };
+
+ function calculateAnchorStyles(anchor) {
+ var styles = {};
+
+ var coords = getDomNode(anchor).getBoundingClientRect();
+
+ // we iterate directly since safari messes up and doesn't return
+ // all the keys for the coords object when iterated
+ forEach(['width','height','top','left'], function(key) {
+ var value = coords[key];
+ switch (key) {
+ case 'top':
+ value += bodyNode.scrollTop;
+ break;
+ case 'left':
+ value += bodyNode.scrollLeft;
+ break;
+ }
+ styles[key] = Math.floor(value) + 'px';
+ });
+ return styles;
+ }
+
+ function prepareOutAnimation() {
+ var animator = $animateCss(clone, {
+ addClass: NG_OUT_ANCHOR_CLASS_NAME,
+ delay: true,
+ from: calculateAnchorStyles(outAnchor)
+ });
+
+ // read the comment within `prepareRegularAnimation` to understand
+ // why this check is necessary
+ return animator.$$willAnimate ? animator : null;
+ }
+
+ function getClassVal(element) {
+ return element.attr('class') || '';
+ }
+
+ function prepareInAnimation() {
+ var endingClasses = filterCssClasses(getClassVal(inAnchor));
+ var toAdd = getUniqueValues(endingClasses, startingClasses);
+ var toRemove = getUniqueValues(startingClasses, endingClasses);
+
+ var animator = $animateCss(clone, {
+ to: calculateAnchorStyles(inAnchor),
+ addClass: NG_IN_ANCHOR_CLASS_NAME + ' ' + toAdd,
+ removeClass: NG_OUT_ANCHOR_CLASS_NAME + ' ' + toRemove,
+ delay: true
+ });
+
+ // read the comment within `prepareRegularAnimation` to understand
+ // why this check is necessary
+ return animator.$$willAnimate ? animator : null;
+ }
+
+ function end() {
+ clone.remove();
+ outAnchor.removeClass(NG_ANIMATE_SHIM_CLASS_NAME);
+ inAnchor.removeClass(NG_ANIMATE_SHIM_CLASS_NAME);
+ }
+ }
+
+ function prepareFromToAnchorAnimation(from, to, classes, anchors) {
+ var fromAnimation = prepareRegularAnimation(from, noop);
+ var toAnimation = prepareRegularAnimation(to, noop);
+
+ var anchorAnimations = [];
+ forEach(anchors, function(anchor) {
+ var outElement = anchor['out'];
+ var inElement = anchor['in'];
+ var animator = prepareAnchoredAnimation(classes, outElement, inElement);
+ if (animator) {
+ anchorAnimations.push(animator);
+ }
+ });
+
+ // no point in doing anything when there are no elements to animate
+ if (!fromAnimation && !toAnimation && anchorAnimations.length === 0) return;
+
+ return {
+ start: function() {
+ var animationRunners = [];
+
+ if (fromAnimation) {
+ animationRunners.push(fromAnimation.start());
+ }
+
+ if (toAnimation) {
+ animationRunners.push(toAnimation.start());
+ }
+
+ forEach(anchorAnimations, function(animation) {
+ animationRunners.push(animation.start());
+ });
+
+ var runner = new $$AnimateRunner({
+ end: endFn,
+ cancel: endFn // CSS-driven animations cannot be cancelled, only ended
+ });
+
+ $$AnimateRunner.all(animationRunners, function(status) {
+ runner.complete(status);
+ });
+
+ return runner;
+
+ function endFn() {
+ forEach(animationRunners, function(runner) {
+ runner.end();
+ });
+ }
+ }
+ };
+ }
+
+ function prepareRegularAnimation(animationDetails) {
+ var element = animationDetails.element;
+ var options = animationDetails.options || {};
+
+ if (animationDetails.structural) {
+ options.event = animationDetails.event;
+ options.structural = true;
+ options.applyClassesEarly = true;
+
+ // we special case the leave animation since we want to ensure that
+ // the element is removed as soon as the animation is over. Otherwise
+ // a flicker might appear or the element may not be removed at all
+ if (animationDetails.event === 'leave') {
+ options.onDone = options.domOperation;
+ }
+ }
+
+ // We assign the preparationClasses as the actual animation event since
+ // the internals of $animateCss will just suffix the event token values
+ // with `-active` to trigger the animation.
+ if (options.preparationClasses) {
+ options.event = concatWithSpace(options.event, options.preparationClasses);
+ }
+
+ var animator = $animateCss(element, options);
+
+ // the driver lookup code inside of $$animation attempts to spawn a
+ // driver one by one until a driver returns a.$$willAnimate animator object.
+ // $animateCss will always return an object, however, it will pass in
+ // a flag as a hint as to whether an animation was detected or not
+ return animator.$$willAnimate ? animator : null;
+ }
+ }];
+}];
+
+// TODO(matsko): use caching here to speed things up for detection
+// TODO(matsko): add documentation
+// by the time...
+
+var $$AnimateJsProvider = ['$animateProvider', /** @this */ function($animateProvider) {
+ this.$get = ['$injector', '$$AnimateRunner', '$$jqLite',
+ function($injector, $$AnimateRunner, $$jqLite) {
+
+ var applyAnimationClasses = applyAnimationClassesFactory($$jqLite);
+ // $animateJs(element, 'enter');
+ return function(element, event, classes, options) {
+ var animationClosed = false;
+
+ // the `classes` argument is optional and if it is not used
+ // then the classes will be resolved from the element's className
+ // property as well as options.addClass/options.removeClass.
+ if (arguments.length === 3 && isObject(classes)) {
+ options = classes;
+ classes = null;
+ }
+
+ options = prepareAnimationOptions(options);
+ if (!classes) {
+ classes = element.attr('class') || '';
+ if (options.addClass) {
+ classes += ' ' + options.addClass;
+ }
+ if (options.removeClass) {
+ classes += ' ' + options.removeClass;
+ }
+ }
+
+ var classesToAdd = options.addClass;
+ var classesToRemove = options.removeClass;
+
+ // the lookupAnimations function returns a series of animation objects that are
+ // matched up with one or more of the CSS classes. These animation objects are
+ // defined via the module.animation factory function. If nothing is detected then
+ // we don't return anything which then makes $animation query the next driver.
+ var animations = lookupAnimations(classes);
+ var before, after;
+ if (animations.length) {
+ var afterFn, beforeFn;
+ if (event === 'leave') {
+ beforeFn = 'leave';
+ afterFn = 'afterLeave'; // TODO(matsko): get rid of this
+ } else {
+ beforeFn = 'before' + event.charAt(0).toUpperCase() + event.substr(1);
+ afterFn = event;
+ }
+
+ if (event !== 'enter' && event !== 'move') {
+ before = packageAnimations(element, event, options, animations, beforeFn);
+ }
+ after = packageAnimations(element, event, options, animations, afterFn);
+ }
+
+ // no matching animations
+ if (!before && !after) return;
+
+ function applyOptions() {
+ options.domOperation();
+ applyAnimationClasses(element, options);
+ }
+
+ function close() {
+ animationClosed = true;
+ applyOptions();
+ applyAnimationStyles(element, options);
+ }
+
+ var runner;
+
+ return {
+ $$willAnimate: true,
+ end: function() {
+ if (runner) {
+ runner.end();
+ } else {
+ close();
+ runner = new $$AnimateRunner();
+ runner.complete(true);
+ }
+ return runner;
+ },
+ start: function() {
+ if (runner) {
+ return runner;
+ }
+
+ runner = new $$AnimateRunner();
+ var closeActiveAnimations;
+ var chain = [];
+
+ if (before) {
+ chain.push(function(fn) {
+ closeActiveAnimations = before(fn);
+ });
+ }
+
+ if (chain.length) {
+ chain.push(function(fn) {
+ applyOptions();
+ fn(true);
+ });
+ } else {
+ applyOptions();
+ }
+
+ if (after) {
+ chain.push(function(fn) {
+ closeActiveAnimations = after(fn);
+ });
+ }
+
+ runner.setHost({
+ end: function() {
+ endAnimations();
+ },
+ cancel: function() {
+ endAnimations(true);
+ }
+ });
+
+ $$AnimateRunner.chain(chain, onComplete);
+ return runner;
+
+ function onComplete(success) {
+ close(success);
+ runner.complete(success);
+ }
+
+ function endAnimations(cancelled) {
+ if (!animationClosed) {
+ (closeActiveAnimations || noop)(cancelled);
+ onComplete(cancelled);
+ }
+ }
+ }
+ };
+
+ function executeAnimationFn(fn, element, event, options, onDone) {
+ var args;
+ switch (event) {
+ case 'animate':
+ args = [element, options.from, options.to, onDone];
+ break;
+
+ case 'setClass':
+ args = [element, classesToAdd, classesToRemove, onDone];
+ break;
+
+ case 'addClass':
+ args = [element, classesToAdd, onDone];
+ break;
+
+ case 'removeClass':
+ args = [element, classesToRemove, onDone];
+ break;
+
+ default:
+ args = [element, onDone];
+ break;
+ }
+
+ args.push(options);
+
+ var value = fn.apply(fn, args);
+ if (value) {
+ if (isFunction(value.start)) {
+ value = value.start();
+ }
+
+ if (value instanceof $$AnimateRunner) {
+ value.done(onDone);
+ } else if (isFunction(value)) {
+ // optional onEnd / onCancel callback
+ return value;
+ }
+ }
+
+ return noop;
+ }
+
+ function groupEventedAnimations(element, event, options, animations, fnName) {
+ var operations = [];
+ forEach(animations, function(ani) {
+ var animation = ani[fnName];
+ if (!animation) return;
+
+ // note that all of these animations will run in parallel
+ operations.push(function() {
+ var runner;
+ var endProgressCb;
+
+ var resolved = false;
+ var onAnimationComplete = function(rejected) {
+ if (!resolved) {
+ resolved = true;
+ (endProgressCb || noop)(rejected);
+ runner.complete(!rejected);
+ }
+ };
+
+ runner = new $$AnimateRunner({
+ end: function() {
+ onAnimationComplete();
+ },
+ cancel: function() {
+ onAnimationComplete(true);
+ }
+ });
+
+ endProgressCb = executeAnimationFn(animation, element, event, options, function(result) {
+ var cancelled = result === false;
+ onAnimationComplete(cancelled);
+ });
+
+ return runner;
+ });
+ });
+
+ return operations;
+ }
+
+ function packageAnimations(element, event, options, animations, fnName) {
+ var operations = groupEventedAnimations(element, event, options, animations, fnName);
+ if (operations.length === 0) {
+ var a, b;
+ if (fnName === 'beforeSetClass') {
+ a = groupEventedAnimations(element, 'removeClass', options, animations, 'beforeRemoveClass');
+ b = groupEventedAnimations(element, 'addClass', options, animations, 'beforeAddClass');
+ } else if (fnName === 'setClass') {
+ a = groupEventedAnimations(element, 'removeClass', options, animations, 'removeClass');
+ b = groupEventedAnimations(element, 'addClass', options, animations, 'addClass');
+ }
+
+ if (a) {
+ operations = operations.concat(a);
+ }
+ if (b) {
+ operations = operations.concat(b);
+ }
+ }
+
+ if (operations.length === 0) return;
+
+ // TODO(matsko): add documentation
+ return function startAnimation(callback) {
+ var runners = [];
+ if (operations.length) {
+ forEach(operations, function(animateFn) {
+ runners.push(animateFn());
+ });
+ }
+
+ if (runners.length) {
+ $$AnimateRunner.all(runners, callback);
+ } else {
+ callback();
+ }
+
+ return function endFn(reject) {
+ forEach(runners, function(runner) {
+ if (reject) {
+ runner.cancel();
+ } else {
+ runner.end();
+ }
+ });
+ };
+ };
+ }
+ };
+
+ function lookupAnimations(classes) {
+ classes = isArray(classes) ? classes : classes.split(' ');
+ var matches = [], flagMap = {};
+ for (var i = 0; i < classes.length; i++) {
+ var klass = classes[i],
+ animationFactory = $animateProvider.$$registeredAnimations[klass];
+ if (animationFactory && !flagMap[klass]) {
+ matches.push($injector.get(animationFactory));
+ flagMap[klass] = true;
+ }
+ }
+ return matches;
+ }
+ }];
+}];
+
+var $$AnimateJsDriverProvider = ['$$animationProvider', /** @this */ function($$animationProvider) {
+ $$animationProvider.drivers.push('$$animateJsDriver');
+ this.$get = ['$$animateJs', '$$AnimateRunner', function($$animateJs, $$AnimateRunner) {
+ return function initDriverFn(animationDetails) {
+ if (animationDetails.from && animationDetails.to) {
+ var fromAnimation = prepareAnimation(animationDetails.from);
+ var toAnimation = prepareAnimation(animationDetails.to);
+ if (!fromAnimation && !toAnimation) return;
+
+ return {
+ start: function() {
+ var animationRunners = [];
+
+ if (fromAnimation) {
+ animationRunners.push(fromAnimation.start());
+ }
+
+ if (toAnimation) {
+ animationRunners.push(toAnimation.start());
+ }
+
+ $$AnimateRunner.all(animationRunners, done);
+
+ var runner = new $$AnimateRunner({
+ end: endFnFactory(),
+ cancel: endFnFactory()
+ });
+
+ return runner;
+
+ function endFnFactory() {
+ return function() {
+ forEach(animationRunners, function(runner) {
+ // at this point we cannot cancel animations for groups just yet. 1.5+
+ runner.end();
+ });
+ };
+ }
+
+ function done(status) {
+ runner.complete(status);
+ }
+ }
+ };
+ } else {
+ return prepareAnimation(animationDetails);
+ }
+ };
+
+ function prepareAnimation(animationDetails) {
+ // TODO(matsko): make sure to check for grouped animations and delegate down to normal animations
+ var element = animationDetails.element;
+ var event = animationDetails.event;
+ var options = animationDetails.options;
+ var classes = animationDetails.classes;
+ return $$animateJs(element, event, classes, options);
+ }
+ }];
+}];
+
+var NG_ANIMATE_ATTR_NAME = 'data-ng-animate';
+var NG_ANIMATE_PIN_DATA = '$ngAnimatePin';
+var $$AnimateQueueProvider = ['$animateProvider', /** @this */ function($animateProvider) {
+ var PRE_DIGEST_STATE = 1;
+ var RUNNING_STATE = 2;
+ var ONE_SPACE = ' ';
+
+ var rules = this.rules = {
+ skip: [],
+ cancel: [],
+ join: []
+ };
+
+ function getEventData(options) {
+ return {
+ addClass: options.addClass,
+ removeClass: options.removeClass,
+ from: options.from,
+ to: options.to
+ };
+ }
+
+ function makeTruthyCssClassMap(classString) {
+ if (!classString) {
+ return null;
+ }
+
+ var keys = classString.split(ONE_SPACE);
+ var map = Object.create(null);
+
+ forEach(keys, function(key) {
+ map[key] = true;
+ });
+ return map;
+ }
+
+ function hasMatchingClasses(newClassString, currentClassString) {
+ if (newClassString && currentClassString) {
+ var currentClassMap = makeTruthyCssClassMap(currentClassString);
+ return newClassString.split(ONE_SPACE).some(function(className) {
+ return currentClassMap[className];
+ });
+ }
+ }
+
+ function isAllowed(ruleType, currentAnimation, previousAnimation) {
+ return rules[ruleType].some(function(fn) {
+ return fn(currentAnimation, previousAnimation);
+ });
+ }
+
+ function hasAnimationClasses(animation, and) {
+ var a = (animation.addClass || '').length > 0;
+ var b = (animation.removeClass || '').length > 0;
+ return and ? a && b : a || b;
+ }
+
+ rules.join.push(function(newAnimation, currentAnimation) {
+ // if the new animation is class-based then we can just tack that on
+ return !newAnimation.structural && hasAnimationClasses(newAnimation);
+ });
+
+ rules.skip.push(function(newAnimation, currentAnimation) {
+ // there is no need to animate anything if no classes are being added and
+ // there is no structural animation that will be triggered
+ return !newAnimation.structural && !hasAnimationClasses(newAnimation);
+ });
+
+ rules.skip.push(function(newAnimation, currentAnimation) {
+ // why should we trigger a new structural animation if the element will
+ // be removed from the DOM anyway?
+ return currentAnimation.event === 'leave' && newAnimation.structural;
+ });
+
+ rules.skip.push(function(newAnimation, currentAnimation) {
+ // if there is an ongoing current animation then don't even bother running the class-based animation
+ return currentAnimation.structural && currentAnimation.state === RUNNING_STATE && !newAnimation.structural;
+ });
+
+ rules.cancel.push(function(newAnimation, currentAnimation) {
+ // there can never be two structural animations running at the same time
+ return currentAnimation.structural && newAnimation.structural;
+ });
+
+ rules.cancel.push(function(newAnimation, currentAnimation) {
+ // if the previous animation is already running, but the new animation will
+ // be triggered, but the new animation is structural
+ return currentAnimation.state === RUNNING_STATE && newAnimation.structural;
+ });
+
+ rules.cancel.push(function(newAnimation, currentAnimation) {
+ // cancel the animation if classes added / removed in both animation cancel each other out,
+ // but only if the current animation isn't structural
+
+ if (currentAnimation.structural) return false;
+
+ var nA = newAnimation.addClass;
+ var nR = newAnimation.removeClass;
+ var cA = currentAnimation.addClass;
+ var cR = currentAnimation.removeClass;
+
+ // early detection to save the global CPU shortage :)
+ if ((isUndefined(nA) && isUndefined(nR)) || (isUndefined(cA) && isUndefined(cR))) {
+ return false;
+ }
+
+ return hasMatchingClasses(nA, cR) || hasMatchingClasses(nR, cA);
+ });
+
+ this.$get = ['$$rAF', '$rootScope', '$rootElement', '$document', '$$Map',
+ '$$animation', '$$AnimateRunner', '$templateRequest', '$$jqLite', '$$forceReflow',
+ '$$isDocumentHidden',
+ function($$rAF, $rootScope, $rootElement, $document, $$Map,
+ $$animation, $$AnimateRunner, $templateRequest, $$jqLite, $$forceReflow,
+ $$isDocumentHidden) {
+
+ var activeAnimationsLookup = new $$Map();
+ var disabledElementsLookup = new $$Map();
+ var animationsEnabled = null;
+
+ function removeFromDisabledElementsLookup(evt) {
+ disabledElementsLookup.delete(evt.target);
+ }
+
+ function postDigestTaskFactory() {
+ var postDigestCalled = false;
+ return function(fn) {
+ // we only issue a call to postDigest before
+ // it has first passed. This prevents any callbacks
+ // from not firing once the animation has completed
+ // since it will be out of the digest cycle.
+ if (postDigestCalled) {
+ fn();
+ } else {
+ $rootScope.$$postDigest(function() {
+ postDigestCalled = true;
+ fn();
+ });
+ }
+ };
+ }
+
+ // Wait until all directive and route-related templates are downloaded and
+ // compiled. The $templateRequest.totalPendingRequests variable keeps track of
+ // all of the remote templates being currently downloaded. If there are no
+ // templates currently downloading then the watcher will still fire anyway.
+ var deregisterWatch = $rootScope.$watch(
+ function() { return $templateRequest.totalPendingRequests === 0; },
+ function(isEmpty) {
+ if (!isEmpty) return;
+ deregisterWatch();
+
+ // Now that all templates have been downloaded, $animate will wait until
+ // the post digest queue is empty before enabling animations. By having two
+ // calls to $postDigest calls we can ensure that the flag is enabled at the
+ // very end of the post digest queue. Since all of the animations in $animate
+ // use $postDigest, it's important that the code below executes at the end.
+ // This basically means that the page is fully downloaded and compiled before
+ // any animations are triggered.
+ $rootScope.$$postDigest(function() {
+ $rootScope.$$postDigest(function() {
+ // we check for null directly in the event that the application already called
+ // .enabled() with whatever arguments that it provided it with
+ if (animationsEnabled === null) {
+ animationsEnabled = true;
+ }
+ });
+ });
+ }
+ );
+
+ var callbackRegistry = Object.create(null);
+
+ // remember that the `customFilter`/`classNameFilter` are set during the
+ // provider/config stage therefore we can optimize here and setup helper functions
+ var customFilter = $animateProvider.customFilter();
+ var classNameFilter = $animateProvider.classNameFilter();
+ var returnTrue = function() { return true; };
+
+ var isAnimatableByFilter = customFilter || returnTrue;
+ var isAnimatableClassName = !classNameFilter ? returnTrue : function(node, options) {
+ var className = [node.getAttribute('class'), options.addClass, options.removeClass].join(' ');
+ return classNameFilter.test(className);
+ };
+
+ var applyAnimationClasses = applyAnimationClassesFactory($$jqLite);
+
+ function normalizeAnimationDetails(element, animation) {
+ return mergeAnimationDetails(element, animation, {});
+ }
+
+ // IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
+ var contains = window.Node.prototype.contains || /** @this */ function(arg) {
+ // eslint-disable-next-line no-bitwise
+ return this === arg || !!(this.compareDocumentPosition(arg) & 16);
+ };
+
+ function findCallbacks(targetParentNode, targetNode, event) {
+ var matches = [];
+ var entries = callbackRegistry[event];
+ if (entries) {
+ forEach(entries, function(entry) {
+ if (contains.call(entry.node, targetNode)) {
+ matches.push(entry.callback);
+ } else if (event === 'leave' && contains.call(entry.node, targetParentNode)) {
+ matches.push(entry.callback);
+ }
+ });
+ }
+
+ return matches;
+ }
+
+ function filterFromRegistry(list, matchContainer, matchCallback) {
+ var containerNode = extractElementNode(matchContainer);
+ return list.filter(function(entry) {
+ var isMatch = entry.node === containerNode &&
+ (!matchCallback || entry.callback === matchCallback);
+ return !isMatch;
+ });
+ }
+
+ function cleanupEventListeners(phase, node) {
+ if (phase === 'close' && !node.parentNode) {
+ // If the element is not attached to a parentNode, it has been removed by
+ // the domOperation, and we can safely remove the event callbacks
+ $animate.off(node);
+ }
+ }
+
+ var $animate = {
+ on: function(event, container, callback) {
+ var node = extractElementNode(container);
+ callbackRegistry[event] = callbackRegistry[event] || [];
+ callbackRegistry[event].push({
+ node: node,
+ callback: callback
+ });
+
+ // Remove the callback when the element is removed from the DOM
+ jqLite(container).on('$destroy', function() {
+ var animationDetails = activeAnimationsLookup.get(node);
+
+ if (!animationDetails) {
+ // If there's an animation ongoing, the callback calling code will remove
+ // the event listeners. If we'd remove here, the callbacks would be removed
+ // before the animation ends
+ $animate.off(event, container, callback);
+ }
+ });
+ },
+
+ off: function(event, container, callback) {
+ if (arguments.length === 1 && !isString(arguments[0])) {
+ container = arguments[0];
+ for (var eventType in callbackRegistry) {
+ callbackRegistry[eventType] = filterFromRegistry(callbackRegistry[eventType], container);
+ }
+
+ return;
+ }
+
+ var entries = callbackRegistry[event];
+ if (!entries) return;
+
+ callbackRegistry[event] = arguments.length === 1
+ ? null
+ : filterFromRegistry(entries, container, callback);
+ },
+
+ pin: function(element, parentElement) {
+ assertArg(isElement(element), 'element', 'not an element');
+ assertArg(isElement(parentElement), 'parentElement', 'not an element');
+ element.data(NG_ANIMATE_PIN_DATA, parentElement);
+ },
+
+ push: function(element, event, options, domOperation) {
+ options = options || {};
+ options.domOperation = domOperation;
+ return queueAnimation(element, event, options);
+ },
+
+ // this method has four signatures:
+ // () - global getter
+ // (bool) - global setter
+ // (element) - element getter
+ // (element, bool) - element setter<F37>
+ enabled: function(element, bool) {
+ var argCount = arguments.length;
+
+ if (argCount === 0) {
+ // () - Global getter
+ bool = !!animationsEnabled;
+ } else {
+ var hasElement = isElement(element);
+
+ if (!hasElement) {
+ // (bool) - Global setter
+ bool = animationsEnabled = !!element;
+ } else {
+ var node = getDomNode(element);
+
+ if (argCount === 1) {
+ // (element) - Element getter
+ bool = !disabledElementsLookup.get(node);
+ } else {
+ // (element, bool) - Element setter
+ if (!disabledElementsLookup.has(node)) {
+ // The element is added to the map for the first time.
+ // Create a listener to remove it on `$destroy` (to avoid memory leak).
+ jqLite(element).on('$destroy', removeFromDisabledElementsLookup);
+ }
+ disabledElementsLookup.set(node, !bool);
+ }
+ }
+ }
+
+ return bool;
+ }
+ };
+
+ return $animate;
+
+ function queueAnimation(originalElement, event, initialOptions) {
+ // we always make a copy of the options since
+ // there should never be any side effects on
+ // the input data when running `$animateCss`.
+ var options = copy(initialOptions);
+
+ var element = stripCommentsFromElement(originalElement);
+ var node = getDomNode(element);
+ var parentNode = node && node.parentNode;
+
+ options = prepareAnimationOptions(options);
+
+ // we create a fake runner with a working promise.
+ // These methods will become available after the digest has passed
+ var runner = new $$AnimateRunner();
+
+ // this is used to trigger callbacks in postDigest mode
+ var runInNextPostDigestOrNow = postDigestTaskFactory();
+
+ if (isArray(options.addClass)) {
+ options.addClass = options.addClass.join(' ');
+ }
+
+ if (options.addClass && !isString(options.addClass)) {
+ options.addClass = null;
+ }
+
+ if (isArray(options.removeClass)) {
+ options.removeClass = options.removeClass.join(' ');
+ }
+
+ if (options.removeClass && !isString(options.removeClass)) {
+ options.removeClass = null;
+ }
+
+ if (options.from && !isObject(options.from)) {
+ options.from = null;
+ }
+
+ if (options.to && !isObject(options.to)) {
+ options.to = null;
+ }
+
+ // If animations are hard-disabled for the whole application there is no need to continue.
+ // There are also situations where a directive issues an animation for a jqLite wrapper that
+ // contains only comment nodes. In this case, there is no way we can perform an animation.
+ if (!animationsEnabled ||
+ !node ||
+ !isAnimatableByFilter(node, event, initialOptions) ||
+ !isAnimatableClassName(node, options)) {
+ close();
+ return runner;
+ }
+
+ var isStructural = ['enter', 'move', 'leave'].indexOf(event) >= 0;
+
+ var documentHidden = $$isDocumentHidden();
+
+ // This is a hard disable of all animations the element itself, therefore there is no need to
+ // continue further past this point if not enabled
+ // Animations are also disabled if the document is currently hidden (page is not visible
+ // to the user), because browsers slow down or do not flush calls to requestAnimationFrame
+ var skipAnimations = documentHidden || disabledElementsLookup.get(node);
+ var existingAnimation = (!skipAnimations && activeAnimationsLookup.get(node)) || {};
+ var hasExistingAnimation = !!existingAnimation.state;
+
+ // there is no point in traversing the same collection of parent ancestors if a followup
+ // animation will be run on the same element that already did all that checking work
+ if (!skipAnimations && (!hasExistingAnimation || existingAnimation.state !== PRE_DIGEST_STATE)) {
+ skipAnimations = !areAnimationsAllowed(node, parentNode, event);
+ }
+
+ if (skipAnimations) {
+ // Callbacks should fire even if the document is hidden (regression fix for issue #14120)
+ if (documentHidden) notifyProgress(runner, event, 'start', getEventData(options));
+ close();
+ if (documentHidden) notifyProgress(runner, event, 'close', getEventData(options));
+ return runner;
+ }
+
+ if (isStructural) {
+ closeChildAnimations(node);
+ }
+
+ var newAnimation = {
+ structural: isStructural,
+ element: element,
+ event: event,
+ addClass: options.addClass,
+ removeClass: options.removeClass,
+ close: close,
+ options: options,
+ runner: runner
+ };
+
+ if (hasExistingAnimation) {
+ var skipAnimationFlag = isAllowed('skip', newAnimation, existingAnimation);
+ if (skipAnimationFlag) {
+ if (existingAnimation.state === RUNNING_STATE) {
+ close();
+ return runner;
+ } else {
+ mergeAnimationDetails(element, existingAnimation, newAnimation);
+ return existingAnimation.runner;
+ }
+ }
+ var cancelAnimationFlag = isAllowed('cancel', newAnimation, existingAnimation);
+ if (cancelAnimationFlag) {
+ if (existingAnimation.state === RUNNING_STATE) {
+ // this will end the animation right away and it is safe
+ // to do so since the animation is already running and the
+ // runner callback code will run in async
+ existingAnimation.runner.end();
+ } else if (existingAnimation.structural) {
+ // this means that the animation is queued into a digest, but
+ // hasn't started yet. Therefore it is safe to run the close
+ // method which will call the runner methods in async.
+ existingAnimation.close();
+ } else {
+ // this will merge the new animation options into existing animation options
+ mergeAnimationDetails(element, existingAnimation, newAnimation);
+
+ return existingAnimation.runner;
+ }
+ } else {
+ // a joined animation means that this animation will take over the existing one
+ // so an example would involve a leave animation taking over an enter. Then when
+ // the postDigest kicks in the enter will be ignored.
+ var joinAnimationFlag = isAllowed('join', newAnimation, existingAnimation);
+ if (joinAnimationFlag) {
+ if (existingAnimation.state === RUNNING_STATE) {
+ normalizeAnimationDetails(element, newAnimation);
+ } else {
+ applyGeneratedPreparationClasses($$jqLite, element, isStructural ? event : null, options);
+
+ event = newAnimation.event = existingAnimation.event;
+ options = mergeAnimationDetails(element, existingAnimation, newAnimation);
+
+ //we return the same runner since only the option values of this animation will
+ //be fed into the `existingAnimation`.
+ return existingAnimation.runner;
+ }
+ }
+ }
+ } else {
+ // normalization in this case means that it removes redundant CSS classes that
+ // already exist (addClass) or do not exist (removeClass) on the element
+ normalizeAnimationDetails(element, newAnimation);
+ }
+
+ // when the options are merged and cleaned up we may end up not having to do
+ // an animation at all, therefore we should check this before issuing a post
+ // digest callback. Structural animations will always run no matter what.
+ var isValidAnimation = newAnimation.structural;
+ if (!isValidAnimation) {
+ // animate (from/to) can be quickly checked first, otherwise we check if any classes are present
+ isValidAnimation = (newAnimation.event === 'animate' && Object.keys(newAnimation.options.to || {}).length > 0)
+ || hasAnimationClasses(newAnimation);
+ }
+
+ if (!isValidAnimation) {
+ close();
+ clearElementAnimationState(node);
+ return runner;
+ }
+
+ // the counter keeps track of cancelled animations
+ var counter = (existingAnimation.counter || 0) + 1;
+ newAnimation.counter = counter;
+
+ markElementAnimationState(node, PRE_DIGEST_STATE, newAnimation);
+
+ $rootScope.$$postDigest(function() {
+ // It is possible that the DOM nodes inside `originalElement` have been replaced. This can
+ // happen if the animated element is a transcluded clone and also has a `templateUrl`
+ // directive on it. Therefore, we must recreate `element` in order to interact with the
+ // actual DOM nodes.
+ // Note: We still need to use the old `node` for certain things, such as looking up in
+ // HashMaps where it was used as the key.
+
+ element = stripCommentsFromElement(originalElement);
+
+ var animationDetails = activeAnimationsLookup.get(node);
+ var animationCancelled = !animationDetails;
+ animationDetails = animationDetails || {};
+
+ // if addClass/removeClass is called before something like enter then the
+ // registered parent element may not be present. The code below will ensure
+ // that a final value for parent element is obtained
+ var parentElement = element.parent() || [];
+
+ // animate/structural/class-based animations all have requirements. Otherwise there
+ // is no point in performing an animation. The parent node must also be set.
+ var isValidAnimation = parentElement.length > 0
+ && (animationDetails.event === 'animate'
+ || animationDetails.structural
+ || hasAnimationClasses(animationDetails));
+
+ // this means that the previous animation was cancelled
+ // even if the follow-up animation is the same event
+ if (animationCancelled || animationDetails.counter !== counter || !isValidAnimation) {
+ // if another animation did not take over then we need
+ // to make sure that the domOperation and options are
+ // handled accordingly
+ if (animationCancelled) {
+ applyAnimationClasses(element, options);
+ applyAnimationStyles(element, options);
+ }
+
+ // if the event changed from something like enter to leave then we do
+ // it, otherwise if it's the same then the end result will be the same too
+ if (animationCancelled || (isStructural && animationDetails.event !== event)) {
+ options.domOperation();
+ runner.end();
+ }
+
+ // in the event that the element animation was not cancelled or a follow-up animation
+ // isn't allowed to animate from here then we need to clear the state of the element
+ // so that any future animations won't read the expired animation data.
+ if (!isValidAnimation) {
+ clearElementAnimationState(node);
+ }
+
+ return;
+ }
+
+ // this combined multiple class to addClass / removeClass into a setClass event
+ // so long as a structural event did not take over the animation
+ event = !animationDetails.structural && hasAnimationClasses(animationDetails, true)
+ ? 'setClass'
+ : animationDetails.event;
+
+ markElementAnimationState(node, RUNNING_STATE);
+ var realRunner = $$animation(element, event, animationDetails.options);
+
+ // this will update the runner's flow-control events based on
+ // the `realRunner` object.
+ runner.setHost(realRunner);
+ notifyProgress(runner, event, 'start', getEventData(options));
+
+ realRunner.done(function(status) {
+ close(!status);
+ var animationDetails = activeAnimationsLookup.get(node);
+ if (animationDetails && animationDetails.counter === counter) {
+ clearElementAnimationState(node);
+ }
+ notifyProgress(runner, event, 'close', getEventData(options));
+ });
+ });
+
+ return runner;
+
+ function notifyProgress(runner, event, phase, data) {
+ runInNextPostDigestOrNow(function() {
+ var callbacks = findCallbacks(parentNode, node, event);
+ if (callbacks.length) {
+ // do not optimize this call here to RAF because
+ // we don't know how heavy the callback code here will
+ // be and if this code is buffered then this can
+ // lead to a performance regression.
+ $$rAF(function() {
+ forEach(callbacks, function(callback) {
+ callback(element, phase, data);
+ });
+ cleanupEventListeners(phase, node);
+ });
+ } else {
+ cleanupEventListeners(phase, node);
+ }
+ });
+ runner.progress(event, phase, data);
+ }
+
+ function close(reject) {
+ clearGeneratedClasses(element, options);
+ applyAnimationClasses(element, options);
+ applyAnimationStyles(element, options);
+ options.domOperation();
+ runner.complete(!reject);
+ }
+ }
+
+ function closeChildAnimations(node) {
+ var children = node.querySelectorAll('[' + NG_ANIMATE_ATTR_NAME + ']');
+ forEach(children, function(child) {
+ var state = parseInt(child.getAttribute(NG_ANIMATE_ATTR_NAME), 10);
+ var animationDetails = activeAnimationsLookup.get(child);
+ if (animationDetails) {
+ switch (state) {
+ case RUNNING_STATE:
+ animationDetails.runner.end();
+ /* falls through */
+ case PRE_DIGEST_STATE:
+ activeAnimationsLookup.delete(child);
+ break;
+ }
+ }
+ });
+ }
+
+ function clearElementAnimationState(node) {
+ node.removeAttribute(NG_ANIMATE_ATTR_NAME);
+ activeAnimationsLookup.delete(node);
+ }
+
+ /**
+ * This fn returns false if any of the following is true:
+ * a) animations on any parent element are disabled, and animations on the element aren't explicitly allowed
+ * b) a parent element has an ongoing structural animation, and animateChildren is false
+ * c) the element is not a child of the body
+ * d) the element is not a child of the $rootElement
+ */
+ function areAnimationsAllowed(node, parentNode, event) {
+ var bodyNode = $document[0].body;
+ var rootNode = getDomNode($rootElement);
+
+ var bodyNodeDetected = (node === bodyNode) || node.nodeName === 'HTML';
+ var rootNodeDetected = (node === rootNode);
+ var parentAnimationDetected = false;
+ var elementDisabled = disabledElementsLookup.get(node);
+ var animateChildren;
+
+ var parentHost = jqLite.data(node, NG_ANIMATE_PIN_DATA);
+ if (parentHost) {
+ parentNode = getDomNode(parentHost);
+ }
+
+ while (parentNode) {
+ if (!rootNodeDetected) {
+ // AngularJS doesn't want to attempt to animate elements outside of the application
+ // therefore we need to ensure that the rootElement is an ancestor of the current element
+ rootNodeDetected = (parentNode === rootNode);
+ }
+
+ if (parentNode.nodeType !== ELEMENT_NODE) {
+ // no point in inspecting the #document element
+ break;
+ }
+
+ var details = activeAnimationsLookup.get(parentNode) || {};
+ // either an enter, leave or move animation will commence
+ // therefore we can't allow any animations to take place
+ // but if a parent animation is class-based then that's ok
+ if (!parentAnimationDetected) {
+ var parentNodeDisabled = disabledElementsLookup.get(parentNode);
+
+ if (parentNodeDisabled === true && elementDisabled !== false) {
+ // disable animations if the user hasn't explicitly enabled animations on the
+ // current element
+ elementDisabled = true;
+ // element is disabled via parent element, no need to check anything else
+ break;
+ } else if (parentNodeDisabled === false) {
+ elementDisabled = false;
+ }
+ parentAnimationDetected = details.structural;
+ }
+
+ if (isUndefined(animateChildren) || animateChildren === true) {
+ var value = jqLite.data(parentNode, NG_ANIMATE_CHILDREN_DATA);
+ if (isDefined(value)) {
+ animateChildren = value;
+ }
+ }
+
+ // there is no need to continue traversing at this point
+ if (parentAnimationDetected && animateChildren === false) break;
+
+ if (!bodyNodeDetected) {
+ // we also need to ensure that the element is or will be a part of the body element
+ // otherwise it is pointless to even issue an animation to be rendered
+ bodyNodeDetected = (parentNode === bodyNode);
+ }
+
+ if (bodyNodeDetected && rootNodeDetected) {
+ // If both body and root have been found, any other checks are pointless,
+ // as no animation data should live outside the application
+ break;
+ }
+
+ if (!rootNodeDetected) {
+ // If `rootNode` is not detected, check if `parentNode` is pinned to another element
+ parentHost = jqLite.data(parentNode, NG_ANIMATE_PIN_DATA);
+ if (parentHost) {
+ // The pin target element becomes the next parent element
+ parentNode = getDomNode(parentHost);
+ continue;
+ }
+ }
+
+ parentNode = parentNode.parentNode;
+ }
+
+ var allowAnimation = (!parentAnimationDetected || animateChildren) && elementDisabled !== true;
+ return allowAnimation && rootNodeDetected && bodyNodeDetected;
+ }
+
+ function markElementAnimationState(node, state, details) {
+ details = details || {};
+ details.state = state;
+
+ node.setAttribute(NG_ANIMATE_ATTR_NAME, state);
+
+ var oldValue = activeAnimationsLookup.get(node);
+ var newValue = oldValue
+ ? extend(oldValue, details)
+ : details;
+ activeAnimationsLookup.set(node, newValue);
+ }
+ }];
+}];
+
+/** @this */
+var $$AnimateCacheProvider = function() {
+
+ var KEY = '$$ngAnimateParentKey';
+ var parentCounter = 0;
+ var cache = Object.create(null);
+
+ this.$get = [function() {
+ return {
+ cacheKey: function(node, method, addClass, removeClass) {
+ var parentNode = node.parentNode;
+ var parentID = parentNode[KEY] || (parentNode[KEY] = ++parentCounter);
+ var parts = [parentID, method, node.getAttribute('class')];
+ if (addClass) {
+ parts.push(addClass);
+ }
+ if (removeClass) {
+ parts.push(removeClass);
+ }
+ return parts.join(' ');
+ },
+
+ containsCachedAnimationWithoutDuration: function(key) {
+ var entry = cache[key];
+
+ // nothing cached, so go ahead and animate
+ // otherwise it should be a valid animation
+ return (entry && !entry.isValid) || false;
+ },
+
+ flush: function() {
+ cache = Object.create(null);
+ },
+
+ count: function(key) {
+ var entry = cache[key];
+ return entry ? entry.total : 0;
+ },
+
+ get: function(key) {
+ var entry = cache[key];
+ return entry && entry.value;
+ },
+
+ put: function(key, value, isValid) {
+ if (!cache[key]) {
+ cache[key] = { total: 1, value: value, isValid: isValid };
+ } else {
+ cache[key].total++;
+ cache[key].value = value;
+ }
+ }
+ };
+ }];
+};
+
+/* exported $$AnimationProvider */
+
+var $$AnimationProvider = ['$animateProvider', /** @this */ function($animateProvider) {
+ var NG_ANIMATE_REF_ATTR = 'ng-animate-ref';
+
+ var drivers = this.drivers = [];
+
+ var RUNNER_STORAGE_KEY = '$$animationRunner';
+ var PREPARE_CLASSES_KEY = '$$animatePrepareClasses';
+
+ function setRunner(element, runner) {
+ element.data(RUNNER_STORAGE_KEY, runner);
+ }
+
+ function removeRunner(element) {
+ element.removeData(RUNNER_STORAGE_KEY);
+ }
+
+ function getRunner(element) {
+ return element.data(RUNNER_STORAGE_KEY);
+ }
+
+ this.$get = ['$$jqLite', '$rootScope', '$injector', '$$AnimateRunner', '$$Map', '$$rAFScheduler', '$$animateCache',
+ function($$jqLite, $rootScope, $injector, $$AnimateRunner, $$Map, $$rAFScheduler, $$animateCache) {
+
+ var animationQueue = [];
+ var applyAnimationClasses = applyAnimationClassesFactory($$jqLite);
+
+ function sortAnimations(animations) {
+ var tree = { children: [] };
+ var i, lookup = new $$Map();
+
+ // this is done first beforehand so that the map
+ // is filled with a list of the elements that will be animated
+ for (i = 0; i < animations.length; i++) {
+ var animation = animations[i];
+ lookup.set(animation.domNode, animations[i] = {
+ domNode: animation.domNode,
+ element: animation.element,
+ fn: animation.fn,
+ children: []
+ });
+ }
+
+ for (i = 0; i < animations.length; i++) {
+ processNode(animations[i]);
+ }
+
+ return flatten(tree);
+
+ function processNode(entry) {
+ if (entry.processed) return entry;
+ entry.processed = true;
+
+ var elementNode = entry.domNode;
+ var parentNode = elementNode.parentNode;
+ lookup.set(elementNode, entry);
+
+ var parentEntry;
+ while (parentNode) {
+ parentEntry = lookup.get(parentNode);
+ if (parentEntry) {
+ if (!parentEntry.processed) {
+ parentEntry = processNode(parentEntry);
+ }
+ break;
+ }
+ parentNode = parentNode.parentNode;
+ }
+
+ (parentEntry || tree).children.push(entry);
+ return entry;
+ }
+
+ function flatten(tree) {
+ var result = [];
+ var queue = [];
+ var i;
+
+ for (i = 0; i < tree.children.length; i++) {
+ queue.push(tree.children[i]);
+ }
+
+ var remainingLevelEntries = queue.length;
+ var nextLevelEntries = 0;
+ var row = [];
+
+ for (i = 0; i < queue.length; i++) {
+ var entry = queue[i];
+ if (remainingLevelEntries <= 0) {
+ remainingLevelEntries = nextLevelEntries;
+ nextLevelEntries = 0;
+ result.push(row);
+ row = [];
+ }
+ row.push(entry);
+ entry.children.forEach(function(childEntry) {
+ nextLevelEntries++;
+ queue.push(childEntry);
+ });
+ remainingLevelEntries--;
+ }
+
+ if (row.length) {
+ result.push(row);
+ }
+
+ return result;
+ }
+ }
+
+ // TODO(matsko): document the signature in a better way
+ return function(element, event, options) {
+ options = prepareAnimationOptions(options);
+ var isStructural = ['enter', 'move', 'leave'].indexOf(event) >= 0;
+
+ // there is no animation at the current moment, however
+ // these runner methods will get later updated with the
+ // methods leading into the driver's end/cancel methods
+ // for now they just stop the animation from starting
+ var runner = new $$AnimateRunner({
+ end: function() { close(); },
+ cancel: function() { close(true); }
+ });
+
+ if (!drivers.length) {
+ close();
+ return runner;
+ }
+
+ var classes = mergeClasses(element.attr('class'), mergeClasses(options.addClass, options.removeClass));
+ var tempClasses = options.tempClasses;
+ if (tempClasses) {
+ classes += ' ' + tempClasses;
+ options.tempClasses = null;
+ }
+
+ if (isStructural) {
+ element.data(PREPARE_CLASSES_KEY, 'ng-' + event + PREPARE_CLASS_SUFFIX);
+ }
+
+ setRunner(element, runner);
+
+ animationQueue.push({
+ // this data is used by the postDigest code and passed into
+ // the driver step function
+ element: element,
+ classes: classes,
+ event: event,
+ structural: isStructural,
+ options: options,
+ beforeStart: beforeStart,
+ close: close
+ });
+
+ element.on('$destroy', handleDestroyedElement);
+
+ // we only want there to be one function called within the post digest
+ // block. This way we can group animations for all the animations that
+ // were apart of the same postDigest flush call.
+ if (animationQueue.length > 1) return runner;
+
+ $rootScope.$$postDigest(function() {
+ var animations = [];
+ forEach(animationQueue, function(entry) {
+ // the element was destroyed early on which removed the runner
+ // form its storage. This means we can't animate this element
+ // at all and it already has been closed due to destruction.
+ if (getRunner(entry.element)) {
+ animations.push(entry);
+ } else {
+ entry.close();
+ }
+ });
+
+ // now any future animations will be in another postDigest
+ animationQueue.length = 0;
+
+ var groupedAnimations = groupAnimations(animations);
+ var toBeSortedAnimations = [];
+
+ forEach(groupedAnimations, function(animationEntry) {
+ var element = animationEntry.from ? animationEntry.from.element : animationEntry.element;
+ var extraClasses = options.addClass;
+
+ extraClasses = (extraClasses ? (extraClasses + ' ') : '') + NG_ANIMATE_CLASSNAME;
+ var cacheKey = $$animateCache.cacheKey(element[0], animationEntry.event, extraClasses, options.removeClass);
+
+ toBeSortedAnimations.push({
+ element: element,
+ domNode: getDomNode(element),
+ fn: function triggerAnimationStart() {
+ var startAnimationFn, closeFn = animationEntry.close;
+
+ // in the event that we've cached the animation status for this element
+ // and it's in fact an invalid animation (something that has duration = 0)
+ // then we should skip all the heavy work from here on
+ if ($$animateCache.containsCachedAnimationWithoutDuration(cacheKey)) {
+ closeFn();
+ return;
+ }
+
+ // it's important that we apply the `ng-animate` CSS class and the
+ // temporary classes before we do any driver invoking since these
+ // CSS classes may be required for proper CSS detection.
+ animationEntry.beforeStart();
+
+ // in the event that the element was removed before the digest runs or
+ // during the RAF sequencing then we should not trigger the animation.
+ var targetElement = animationEntry.anchors
+ ? (animationEntry.from.element || animationEntry.to.element)
+ : animationEntry.element;
+
+ if (getRunner(targetElement)) {
+ var operation = invokeFirstDriver(animationEntry);
+ if (operation) {
+ startAnimationFn = operation.start;
+ }
+ }
+
+ if (!startAnimationFn) {
+ closeFn();
+ } else {
+ var animationRunner = startAnimationFn();
+ animationRunner.done(function(status) {
+ closeFn(!status);
+ });
+ updateAnimationRunners(animationEntry, animationRunner);
+ }
+ }
+ });
+ });
+
+ // we need to sort each of the animations in order of parent to child
+ // relationships. This ensures that the child classes are applied at the
+ // right time.
+ var finalAnimations = sortAnimations(toBeSortedAnimations);
+ for (var i = 0; i < finalAnimations.length; i++) {
+ var innerArray = finalAnimations[i];
+ for (var j = 0; j < innerArray.length; j++) {
+ var entry = innerArray[j];
+ var element = entry.element;
+
+ // the RAFScheduler code only uses functions
+ finalAnimations[i][j] = entry.fn;
+
+ // the first row of elements shouldn't have a prepare-class added to them
+ // since the elements are at the top of the animation hierarchy and they
+ // will be applied without a RAF having to pass...
+ if (i === 0) {
+ element.removeData(PREPARE_CLASSES_KEY);
+ continue;
+ }
+
+ var prepareClassName = element.data(PREPARE_CLASSES_KEY);
+ if (prepareClassName) {
+ $$jqLite.addClass(element, prepareClassName);
+ }
+ }
+ }
+
+ $$rAFScheduler(finalAnimations);
+ });
+
+ return runner;
+
+ // TODO(matsko): change to reference nodes
+ function getAnchorNodes(node) {
+ var SELECTOR = '[' + NG_ANIMATE_REF_ATTR + ']';
+ var items = node.hasAttribute(NG_ANIMATE_REF_ATTR)
+ ? [node]
+ : node.querySelectorAll(SELECTOR);
+ var anchors = [];
+ forEach(items, function(node) {
+ var attr = node.getAttribute(NG_ANIMATE_REF_ATTR);
+ if (attr && attr.length) {
+ anchors.push(node);
+ }
+ });
+ return anchors;
+ }
+
+ function groupAnimations(animations) {
+ var preparedAnimations = [];
+ var refLookup = {};
+ forEach(animations, function(animation, index) {
+ var element = animation.element;
+ var node = getDomNode(element);
+ var event = animation.event;
+ var enterOrMove = ['enter', 'move'].indexOf(event) >= 0;
+ var anchorNodes = animation.structural ? getAnchorNodes(node) : [];
+
+ if (anchorNodes.length) {
+ var direction = enterOrMove ? 'to' : 'from';
+
+ forEach(anchorNodes, function(anchor) {
+ var key = anchor.getAttribute(NG_ANIMATE_REF_ATTR);
+ refLookup[key] = refLookup[key] || {};
+ refLookup[key][direction] = {
+ animationID: index,
+ element: jqLite(anchor)
+ };
+ });
+ } else {
+ preparedAnimations.push(animation);
+ }
+ });
+
+ var usedIndicesLookup = {};
+ var anchorGroups = {};
+ forEach(refLookup, function(operations, key) {
+ var from = operations.from;
+ var to = operations.to;
+
+ if (!from || !to) {
+ // only one of these is set therefore we can't have an
+ // anchor animation since all three pieces are required
+ var index = from ? from.animationID : to.animationID;
+ var indexKey = index.toString();
+ if (!usedIndicesLookup[indexKey]) {
+ usedIndicesLookup[indexKey] = true;
+ preparedAnimations.push(animations[index]);
+ }
+ return;
+ }
+
+ var fromAnimation = animations[from.animationID];
+ var toAnimation = animations[to.animationID];
+ var lookupKey = from.animationID.toString();
+ if (!anchorGroups[lookupKey]) {
+ var group = anchorGroups[lookupKey] = {
+ structural: true,
+ beforeStart: function() {
+ fromAnimation.beforeStart();
+ toAnimation.beforeStart();
+ },
+ close: function() {
+ fromAnimation.close();
+ toAnimation.close();
+ },
+ classes: cssClassesIntersection(fromAnimation.classes, toAnimation.classes),
+ from: fromAnimation,
+ to: toAnimation,
+ anchors: [] // TODO(matsko): change to reference nodes
+ };
+
+ // the anchor animations require that the from and to elements both have at least
+ // one shared CSS class which effectively marries the two elements together to use
+ // the same animation driver and to properly sequence the anchor animation.
+ if (group.classes.length) {
+ preparedAnimations.push(group);
+ } else {
+ preparedAnimations.push(fromAnimation);
+ preparedAnimations.push(toAnimation);
+ }
+ }
+
+ anchorGroups[lookupKey].anchors.push({
+ 'out': from.element, 'in': to.element
+ });
+ });
+
+ return preparedAnimations;
+ }
+
+ function cssClassesIntersection(a,b) {
+ a = a.split(' ');
+ b = b.split(' ');
+ var matches = [];
+
+ for (var i = 0; i < a.length; i++) {
+ var aa = a[i];
+ if (aa.substring(0,3) === 'ng-') continue;
+
+ for (var j = 0; j < b.length; j++) {
+ if (aa === b[j]) {
+ matches.push(aa);
+ break;
+ }
+ }
+ }
+
+ return matches.join(' ');
+ }
+
+ function invokeFirstDriver(animationDetails) {
+ // we loop in reverse order since the more general drivers (like CSS and JS)
+ // may attempt more elements, but custom drivers are more particular
+ for (var i = drivers.length - 1; i >= 0; i--) {
+ var driverName = drivers[i];
+ var factory = $injector.get(driverName);
+ var driver = factory(animationDetails);
+ if (driver) {
+ return driver;
+ }
+ }
+ }
+
+ function beforeStart() {
+ tempClasses = (tempClasses ? (tempClasses + ' ') : '') + NG_ANIMATE_CLASSNAME;
+ $$jqLite.addClass(element, tempClasses);
+
+ var prepareClassName = element.data(PREPARE_CLASSES_KEY);
+ if (prepareClassName) {
+ $$jqLite.removeClass(element, prepareClassName);
+ prepareClassName = null;
+ }
+ }
+
+ function updateAnimationRunners(animation, newRunner) {
+ if (animation.from && animation.to) {
+ update(animation.from.element);
+ update(animation.to.element);
+ } else {
+ update(animation.element);
+ }
+
+ function update(element) {
+ var runner = getRunner(element);
+ if (runner) runner.setHost(newRunner);
+ }
+ }
+
+ function handleDestroyedElement() {
+ var runner = getRunner(element);
+ if (runner && (event !== 'leave' || !options.$$domOperationFired)) {
+ runner.end();
+ }
+ }
+
+ function close(rejected) {
+ element.off('$destroy', handleDestroyedElement);
+ removeRunner(element);
+
+ applyAnimationClasses(element, options);
+ applyAnimationStyles(element, options);
+ options.domOperation();
+
+ if (tempClasses) {
+ $$jqLite.removeClass(element, tempClasses);
+ }
+
+ runner.complete(!rejected);
+ }
+ };
+ }];
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngAnimateSwap
+ * @restrict A
+ * @scope
+ *
+ * @description
+ *
+ * ngAnimateSwap is a animation-oriented directive that allows for the container to
+ * be removed and entered in whenever the associated expression changes. A
+ * common usecase for this directive is a rotating banner or slider component which
+ * contains one image being present at a time. When the active image changes
+ * then the old image will perform a `leave` animation and the new element
+ * will be inserted via an `enter` animation.
+ *
+ * @animations
+ * | Animation | Occurs |
+ * |----------------------------------|--------------------------------------|
+ * | {@link ng.$animate#enter enter} | when the new element is inserted to the DOM |
+ * | {@link ng.$animate#leave leave} | when the old element is removed from the DOM |
+ *
+ * @example
+ * <example name="ngAnimateSwap-directive" module="ngAnimateSwapExample"
+ * deps="angular-animate.js"
+ * animations="true" fixBase="true">
+ * <file name="index.html">
+ * <div class="container" ng-controller="AppCtrl">
+ * <div ng-animate-swap="number" class="cell swap-animation" ng-class="colorClass(number)">
+ * {{ number }}
+ * </div>
+ * </div>
+ * </file>
+ * <file name="script.js">
+ * angular.module('ngAnimateSwapExample', ['ngAnimate'])
+ * .controller('AppCtrl', ['$scope', '$interval', function($scope, $interval) {
+ * $scope.number = 0;
+ * $interval(function() {
+ * $scope.number++;
+ * }, 1000);
+ *
+ * var colors = ['red','blue','green','yellow','orange'];
+ * $scope.colorClass = function(number) {
+ * return colors[number % colors.length];
+ * };
+ * }]);
+ * </file>
+ * <file name="animations.css">
+ * .container {
+ * height:250px;
+ * width:250px;
+ * position:relative;
+ * overflow:hidden;
+ * border:2px solid black;
+ * }
+ * .container .cell {
+ * font-size:150px;
+ * text-align:center;
+ * line-height:250px;
+ * position:absolute;
+ * top:0;
+ * left:0;
+ * right:0;
+ * border-bottom:2px solid black;
+ * }
+ * .swap-animation.ng-enter, .swap-animation.ng-leave {
+ * transition:0.5s linear all;
+ * }
+ * .swap-animation.ng-enter {
+ * top:-250px;
+ * }
+ * .swap-animation.ng-enter-active {
+ * top:0px;
+ * }
+ * .swap-animation.ng-leave {
+ * top:0px;
+ * }
+ * .swap-animation.ng-leave-active {
+ * top:250px;
+ * }
+ * .red { background:red; }
+ * .green { background:green; }
+ * .blue { background:blue; }
+ * .yellow { background:yellow; }
+ * .orange { background:orange; }
+ * </file>
+ * </example>
+ */
+var ngAnimateSwapDirective = ['$animate', function($animate) {
+ return {
+ restrict: 'A',
+ transclude: 'element',
+ terminal: true,
+ priority: 550, // We use 550 here to ensure that the directive is caught before others,
+ // but after `ngIf` (at priority 600).
+ link: function(scope, $element, attrs, ctrl, $transclude) {
+ var previousElement, previousScope;
+ scope.$watchCollection(attrs.ngAnimateSwap || attrs['for'], function(value) {
+ if (previousElement) {
+ $animate.leave(previousElement);
+ }
+ if (previousScope) {
+ previousScope.$destroy();
+ previousScope = null;
+ }
+ if (value || value === 0) {
+ $transclude(function(clone, childScope) {
+ previousElement = clone;
+ previousScope = childScope;
+ $animate.enter(clone, null, $element);
+ });
+ }
+ });
+ }
+ };
+}];
+
+/**
+ * @ngdoc module
+ * @name ngAnimate
+ * @description
+ *
+ * The `ngAnimate` module provides support for CSS-based animations (keyframes and transitions) as well as JavaScript-based animations via
+ * callback hooks. Animations are not enabled by default, however, by including `ngAnimate` the animation hooks are enabled for an AngularJS app.
+ *
+ * ## Usage
+ * Simply put, there are two ways to make use of animations when ngAnimate is used: by using **CSS** and **JavaScript**. The former works purely based
+ * using CSS (by using matching CSS selectors/styles) and the latter triggers animations that are registered via `module.animation()`. For
+ * both CSS and JS animations the sole requirement is to have a matching `CSS class` that exists both in the registered animation and within
+ * the HTML element that the animation will be triggered on.
+ *
+ * ## Directive Support
+ * The following directives are "animation aware":
+ *
+ * | Directive | Supported Animations |
+ * |-------------------------------------------------------------------------------|---------------------------------------------------------------------------|
+ * | {@link ng.directive:form#animations form / ngForm} | add and remove ({@link ng.directive:form#css-classes various classes}) |
+ * | {@link ngAnimate.directive:ngAnimateSwap#animations ngAnimateSwap} | enter and leave |
+ * | {@link ng.directive:ngClass#animations ngClass / {{class}​}} | add and remove |
+ * | {@link ng.directive:ngClassEven#animations ngClassEven} | add and remove |
+ * | {@link ng.directive:ngClassOdd#animations ngClassOdd} | add and remove |
+ * | {@link ng.directive:ngHide#animations ngHide} | add and remove (the `ng-hide` class) |
+ * | {@link ng.directive:ngIf#animations ngIf} | enter and leave |
+ * | {@link ng.directive:ngInclude#animations ngInclude} | enter and leave |
+ * | {@link module:ngMessages#animations ngMessage / ngMessageExp} | enter and leave |
+ * | {@link module:ngMessages#animations ngMessages} | add and remove (the `ng-active`/`ng-inactive` classes) |
+ * | {@link ng.directive:ngModel#animations ngModel} | add and remove ({@link ng.directive:ngModel#css-classes various classes}) |
+ * | {@link ng.directive:ngRepeat#animations ngRepeat} | enter, leave, and move |
+ * | {@link ng.directive:ngShow#animations ngShow} | add and remove (the `ng-hide` class) |
+ * | {@link ng.directive:ngSwitch#animations ngSwitch} | enter and leave |
+ * | {@link ngRoute.directive:ngView#animations ngView} | enter and leave |
+ *
+ * (More information can be found by visiting the documentation associated with each directive.)
+ *
+ * For a full breakdown of the steps involved during each animation event, refer to the
+ * {@link ng.$animate `$animate` API docs}.
+ *
+ * ## CSS-based Animations
+ *
+ * CSS-based animations with ngAnimate are unique since they require no JavaScript code at all. By using a CSS class that we reference between our HTML
+ * and CSS code we can create an animation that will be picked up by AngularJS when an underlying directive performs an operation.
+ *
+ * The example below shows how an `enter` animation can be made possible on an element using `ng-if`:
+ *
+ * ```html
+ * <div ng-if="bool" class="fade">
+ * Fade me in out
+ * </div>
+ * <button ng-click="bool=true">Fade In!</button>
+ * <button ng-click="bool=false">Fade Out!</button>
+ * ```
+ *
+ * Notice the CSS class **fade**? We can now create the CSS transition code that references this class:
+ *
+ * ```css
+ * /* The starting CSS styles for the enter animation */
+ * .fade.ng-enter {
+ * transition:0.5s linear all;
+ * opacity:0;
+ * }
+ *
+ * /* The finishing CSS styles for the enter animation */
+ * .fade.ng-enter.ng-enter-active {
+ * opacity:1;
+ * }
+ * ```
+ *
+ * The key thing to remember here is that, depending on the animation event (which each of the directives above trigger depending on what's going on) two
+ * generated CSS classes will be applied to the element; in the example above we have `.ng-enter` and `.ng-enter-active`. For CSS transitions, the transition
+ * code **must** be defined within the starting CSS class (in this case `.ng-enter`). The destination class is what the transition will animate towards.
+ *
+ * If for example we wanted to create animations for `leave` and `move` (ngRepeat triggers move) then we can do so using the same CSS naming conventions:
+ *
+ * ```css
+ * /* now the element will fade out before it is removed from the DOM */
+ * .fade.ng-leave {
+ * transition:0.5s linear all;
+ * opacity:1;
+ * }
+ * .fade.ng-leave.ng-leave-active {
+ * opacity:0;
+ * }
+ * ```
+ *
+ * We can also make use of **CSS Keyframes** by referencing the keyframe animation within the starting CSS class:
+ *
+ * ```css
+ * /* there is no need to define anything inside of the destination
+ * CSS class since the keyframe will take charge of the animation */
+ * .fade.ng-leave {
+ * animation: my_fade_animation 0.5s linear;
+ * -webkit-animation: my_fade_animation 0.5s linear;
+ * }
+ *
+ * @keyframes my_fade_animation {
+ * from { opacity:1; }
+ * to { opacity:0; }
+ * }
+ *
+ * @-webkit-keyframes my_fade_animation {
+ * from { opacity:1; }
+ * to { opacity:0; }
+ * }
+ * ```
+ *
+ * Feel free also mix transitions and keyframes together as well as any other CSS classes on the same element.
+ *
+ * ### CSS Class-based Animations
+ *
+ * Class-based animations (animations that are triggered via `ngClass`, `ngShow`, `ngHide` and some other directives) have a slightly different
+ * naming convention. Class-based animations are basic enough that a standard transition or keyframe can be referenced on the class being added
+ * and removed.
+ *
+ * For example if we wanted to do a CSS animation for `ngHide` then we place an animation on the `.ng-hide` CSS class:
+ *
+ * ```html
+ * <div ng-show="bool" class="fade">
+ * Show and hide me
+ * </div>
+ * <button ng-click="bool=!bool">Toggle</button>
+ *
+ * <style>
+ * .fade.ng-hide {
+ * transition:0.5s linear all;
+ * opacity:0;
+ * }
+ * </style>
+ * ```
+ *
+ * All that is going on here with ngShow/ngHide behind the scenes is the `.ng-hide` class is added/removed (when the hidden state is valid). Since
+ * ngShow and ngHide are animation aware then we can match up a transition and ngAnimate handles the rest.
+ *
+ * In addition the addition and removal of the CSS class, ngAnimate also provides two helper methods that we can use to further decorate the animation
+ * with CSS styles.
+ *
+ * ```html
+ * <div ng-class="{on:onOff}" class="highlight">
+ * Highlight this box
+ * </div>
+ * <button ng-click="onOff=!onOff">Toggle</button>
+ *
+ * <style>
+ * .highlight {
+ * transition:0.5s linear all;
+ * }
+ * .highlight.on-add {
+ * background:white;
+ * }
+ * .highlight.on {
+ * background:yellow;
+ * }
+ * .highlight.on-remove {
+ * background:black;
+ * }
+ * </style>
+ * ```
+ *
+ * We can also make use of CSS keyframes by placing them within the CSS classes.
+ *
+ *
+ * ### CSS Staggering Animations
+ * A Staggering animation is a collection of animations that are issued with a slight delay in between each successive operation resulting in a
+ * curtain-like effect. The ngAnimate module (versions >=1.2) supports staggering animations and the stagger effect can be
+ * performed by creating a **ng-EVENT-stagger** CSS class and attaching that class to the base CSS class used for
+ * the animation. The style property expected within the stagger class can either be a **transition-delay** or an
+ * **animation-delay** property (or both if your animation contains both transitions and keyframe animations).
+ *
+ * ```css
+ * .my-animation.ng-enter {
+ * /* standard transition code */
+ * transition: 1s linear all;
+ * opacity:0;
+ * }
+ * .my-animation.ng-enter-stagger {
+ * /* this will have a 100ms delay between each successive leave animation */
+ * transition-delay: 0.1s;
+ *
+ * /* As of 1.4.4, this must always be set: it signals ngAnimate
+ * to not accidentally inherit a delay property from another CSS class */
+ * transition-duration: 0s;
+ *
+ * /* if you are using animations instead of transitions you should configure as follows:
+ * animation-delay: 0.1s;
+ * animation-duration: 0s; */
+ * }
+ * .my-animation.ng-enter.ng-enter-active {
+ * /* standard transition styles */
+ * opacity:1;
+ * }
+ * ```
+ *
+ * Staggering animations work by default in ngRepeat (so long as the CSS class is defined). Outside of ngRepeat, to use staggering animations
+ * on your own, they can be triggered by firing multiple calls to the same event on $animate. However, the restrictions surrounding this
+ * are that each of the elements must have the same CSS className value as well as the same parent element. A stagger operation
+ * will also be reset if one or more animation frames have passed since the multiple calls to `$animate` were fired.
+ *
+ * The following code will issue the **ng-leave-stagger** event on the element provided:
+ *
+ * ```js
+ * var kids = parent.children();
+ *
+ * $animate.leave(kids[0]); //stagger index=0
+ * $animate.leave(kids[1]); //stagger index=1
+ * $animate.leave(kids[2]); //stagger index=2
+ * $animate.leave(kids[3]); //stagger index=3
+ * $animate.leave(kids[4]); //stagger index=4
+ *
+ * window.requestAnimationFrame(function() {
+ * //stagger has reset itself
+ * $animate.leave(kids[5]); //stagger index=0
+ * $animate.leave(kids[6]); //stagger index=1
+ *
+ * $scope.$digest();
+ * });
+ * ```
+ *
+ * Stagger animations are currently only supported within CSS-defined animations.
+ *
+ * ### The `ng-animate` CSS class
+ *
+ * When ngAnimate is animating an element it will apply the `ng-animate` CSS class to the element for the duration of the animation.
+ * This is a temporary CSS class and it will be removed once the animation is over (for both JavaScript and CSS-based animations).
+ *
+ * Therefore, animations can be applied to an element using this temporary class directly via CSS.
+ *
+ * ```css
+ * .zipper.ng-animate {
+ * transition:0.5s linear all;
+ * }
+ * .zipper.ng-enter {
+ * opacity:0;
+ * }
+ * .zipper.ng-enter.ng-enter-active {
+ * opacity:1;
+ * }
+ * .zipper.ng-leave {
+ * opacity:1;
+ * }
+ * .zipper.ng-leave.ng-leave-active {
+ * opacity:0;
+ * }
+ * ```
+ *
+ * (Note that the `ng-animate` CSS class is reserved and it cannot be applied on an element directly since ngAnimate will always remove
+ * the CSS class once an animation has completed.)
+ *
+ *
+ * ### The `ng-[event]-prepare` class
+ *
+ * This is a special class that can be used to prevent unwanted flickering / flash of content before
+ * the actual animation starts. The class is added as soon as an animation is initialized, but removed
+ * before the actual animation starts (after waiting for a $digest).
+ * It is also only added for *structural* animations (`enter`, `move`, and `leave`).
+ *
+ * In practice, flickering can appear when nesting elements with structural animations such as `ngIf`
+ * into elements that have class-based animations such as `ngClass`.
+ *
+ * ```html
+ * <div ng-class="{red: myProp}">
+ * <div ng-class="{blue: myProp}">
+ * <div class="message" ng-if="myProp"></div>
+ * </div>
+ * </div>
+ * ```
+ *
+ * It is possible that during the `enter` animation, the `.message` div will be briefly visible before it starts animating.
+ * In that case, you can add styles to the CSS that make sure the element stays hidden before the animation starts:
+ *
+ * ```css
+ * .message.ng-enter-prepare {
+ * opacity: 0;
+ * }
+ * ```
+ *
+ * ### Animating between value changes
+ *
+ * Sometimes you need to animate between different expression states, whose values
+ * don't necessary need to be known or referenced in CSS styles.
+ * Unless possible with another {@link ngAnimate#directive-support "animation aware" directive},
+ * that specific use case can always be covered with {@link ngAnimate.directive:ngAnimateSwap} as
+ * can be seen in {@link ngAnimate.directive:ngAnimateSwap#examples this example}.
+ *
+ * Note that {@link ngAnimate.directive:ngAnimateSwap} is a *structural directive*, which means it
+ * creates a new instance of the element (including any other/child directives it may have) and
+ * links it to a new scope every time *swap* happens. In some cases this might not be desirable
+ * (e.g. for performance reasons, or when you wish to retain internal state on the original
+ * element instance).
+ *
+ * ## JavaScript-based Animations
+ *
+ * ngAnimate also allows for animations to be consumed by JavaScript code. The approach is similar to CSS-based animations (where there is a shared
+ * CSS class that is referenced in our HTML code) but in addition we need to register the JavaScript animation on the module. By making use of the
+ * `module.animation()` module function we can register the animation.
+ *
+ * Let's see an example of a enter/leave animation using `ngRepeat`:
+ *
+ * ```html
+ * <div ng-repeat="item in items" class="slide">
+ * {{ item }}
+ * </div>
+ * ```
+ *
+ * See the **slide** CSS class? Let's use that class to define an animation that we'll structure in our module code by using `module.animation`:
+ *
+ * ```js
+ * myModule.animation('.slide', [function() {
+ * return {
+ * // make note that other events (like addClass/removeClass)
+ * // have different function input parameters
+ * enter: function(element, doneFn) {
+ * jQuery(element).fadeIn(1000, doneFn);
+ *
+ * // remember to call doneFn so that AngularJS
+ * // knows that the animation has concluded
+ * },
+ *
+ * move: function(element, doneFn) {
+ * jQuery(element).fadeIn(1000, doneFn);
+ * },
+ *
+ * leave: function(element, doneFn) {
+ * jQuery(element).fadeOut(1000, doneFn);
+ * }
+ * }
+ * }]);
+ * ```
+ *
+ * The nice thing about JS-based animations is that we can inject other services and make use of advanced animation libraries such as
+ * greensock.js and velocity.js.
+ *
+ * If our animation code class-based (meaning that something like `ngClass`, `ngHide` and `ngShow` triggers it) then we can still define
+ * our animations inside of the same registered animation, however, the function input arguments are a bit different:
+ *
+ * ```html
+ * <div ng-class="color" class="colorful">
+ * this box is moody
+ * </div>
+ * <button ng-click="color='red'">Change to red</button>
+ * <button ng-click="color='blue'">Change to blue</button>
+ * <button ng-click="color='green'">Change to green</button>
+ * ```
+ *
+ * ```js
+ * myModule.animation('.colorful', [function() {
+ * return {
+ * addClass: function(element, className, doneFn) {
+ * // do some cool animation and call the doneFn
+ * },
+ * removeClass: function(element, className, doneFn) {
+ * // do some cool animation and call the doneFn
+ * },
+ * setClass: function(element, addedClass, removedClass, doneFn) {
+ * // do some cool animation and call the doneFn
+ * }
+ * }
+ * }]);
+ * ```
+ *
+ * ## CSS + JS Animations Together
+ *
+ * AngularJS 1.4 and higher has taken steps to make the amalgamation of CSS and JS animations more flexible. However, unlike earlier versions of AngularJS,
+ * defining CSS and JS animations to work off of the same CSS class will not work anymore. Therefore the example below will only result in **JS animations taking
+ * charge of the animation**:
+ *
+ * ```html
+ * <div ng-if="bool" class="slide">
+ * Slide in and out
+ * </div>
+ * ```
+ *
+ * ```js
+ * myModule.animation('.slide', [function() {
+ * return {
+ * enter: function(element, doneFn) {
+ * jQuery(element).slideIn(1000, doneFn);
+ * }
+ * }
+ * }]);
+ * ```
+ *
+ * ```css
+ * .slide.ng-enter {
+ * transition:0.5s linear all;
+ * transform:translateY(-100px);
+ * }
+ * .slide.ng-enter.ng-enter-active {
+ * transform:translateY(0);
+ * }
+ * ```
+ *
+ * Does this mean that CSS and JS animations cannot be used together? Do JS-based animations always have higher priority? We can make up for the
+ * lack of CSS animations by using the `$animateCss` service to trigger our own tweaked-out, CSS-based animations directly from
+ * our own JS-based animation code:
+ *
+ * ```js
+ * myModule.animation('.slide', ['$animateCss', function($animateCss) {
+ * return {
+ * enter: function(element) {
+* // this will trigger `.slide.ng-enter` and `.slide.ng-enter-active`.
+ * return $animateCss(element, {
+ * event: 'enter',
+ * structural: true
+ * });
+ * }
+ * }
+ * }]);
+ * ```
+ *
+ * The nice thing here is that we can save bandwidth by sticking to our CSS-based animation code and we don't need to rely on a 3rd-party animation framework.
+ *
+ * The `$animateCss` service is very powerful since we can feed in all kinds of extra properties that will be evaluated and fed into a CSS transition or
+ * keyframe animation. For example if we wanted to animate the height of an element while adding and removing classes then we can do so by providing that
+ * data into `$animateCss` directly:
+ *
+ * ```js
+ * myModule.animation('.slide', ['$animateCss', function($animateCss) {
+ * return {
+ * enter: function(element) {
+ * return $animateCss(element, {
+ * event: 'enter',
+ * structural: true,
+ * addClass: 'maroon-setting',
+ * from: { height:0 },
+ * to: { height: 200 }
+ * });
+ * }
+ * }
+ * }]);
+ * ```
+ *
+ * Now we can fill in the rest via our transition CSS code:
+ *
+ * ```css
+ * /* the transition tells ngAnimate to make the animation happen */
+ * .slide.ng-enter { transition:0.5s linear all; }
+ *
+ * /* this extra CSS class will be absorbed into the transition
+ * since the $animateCss code is adding the class */
+ * .maroon-setting { background:red; }
+ * ```
+ *
+ * And `$animateCss` will figure out the rest. Just make sure to have the `done()` callback fire the `doneFn` function to signal when the animation is over.
+ *
+ * To learn more about what's possible be sure to visit the {@link ngAnimate.$animateCss $animateCss service}.
+ *
+ * ## Animation Anchoring (via `ng-animate-ref`)
+ *
+ * ngAnimate in AngularJS 1.4 comes packed with the ability to cross-animate elements between
+ * structural areas of an application (like views) by pairing up elements using an attribute
+ * called `ng-animate-ref`.
+ *
+ * Let's say for example we have two views that are managed by `ng-view` and we want to show
+ * that there is a relationship between two components situated in within these views. By using the
+ * `ng-animate-ref` attribute we can identify that the two components are paired together and we
+ * can then attach an animation, which is triggered when the view changes.
+ *
+ * Say for example we have the following template code:
+ *
+ * ```html
+ * <!-- index.html -->
+ * <div ng-view class="view-animation">
+ * </div>
+ *
+ * <!-- home.html -->
+ * <a href="#/banner-page">
+ * <img src="./banner.jpg" class="banner" ng-animate-ref="banner">
+ * </a>
+ *
+ * <!-- banner-page.html -->
+ * <img src="./banner.jpg" class="banner" ng-animate-ref="banner">
+ * ```
+ *
+ * Now, when the view changes (once the link is clicked), ngAnimate will examine the
+ * HTML contents to see if there is a match reference between any components in the view
+ * that is leaving and the view that is entering. It will scan both the view which is being
+ * removed (leave) and inserted (enter) to see if there are any paired DOM elements that
+ * contain a matching ref value.
+ *
+ * The two images match since they share the same ref value. ngAnimate will now create a
+ * transport element (which is a clone of the first image element) and it will then attempt
+ * to animate to the position of the second image element in the next view. For the animation to
+ * work a special CSS class called `ng-anchor` will be added to the transported element.
+ *
+ * We can now attach a transition onto the `.banner.ng-anchor` CSS class and then
+ * ngAnimate will handle the entire transition for us as well as the addition and removal of
+ * any changes of CSS classes between the elements:
+ *
+ * ```css
+ * .banner.ng-anchor {
+ * /* this animation will last for 1 second since there are
+ * two phases to the animation (an `in` and an `out` phase) */
+ * transition:0.5s linear all;
+ * }
+ * ```
+ *
+ * We also **must** include animations for the views that are being entered and removed
+ * (otherwise anchoring wouldn't be possible since the new view would be inserted right away).
+ *
+ * ```css
+ * .view-animation.ng-enter, .view-animation.ng-leave {
+ * transition:0.5s linear all;
+ * position:fixed;
+ * left:0;
+ * top:0;
+ * width:100%;
+ * }
+ * .view-animation.ng-enter {
+ * transform:translateX(100%);
+ * }
+ * .view-animation.ng-leave,
+ * .view-animation.ng-enter.ng-enter-active {
+ * transform:translateX(0%);
+ * }
+ * .view-animation.ng-leave.ng-leave-active {
+ * transform:translateX(-100%);
+ * }
+ * ```
+ *
+ * Now we can jump back to the anchor animation. When the animation happens, there are two stages that occur:
+ * an `out` and an `in` stage. The `out` stage happens first and that is when the element is animated away
+ * from its origin. Once that animation is over then the `in` stage occurs which animates the
+ * element to its destination. The reason why there are two animations is to give enough time
+ * for the enter animation on the new element to be ready.
+ *
+ * The example above sets up a transition for both the in and out phases, but we can also target the out or
+ * in phases directly via `ng-anchor-out` and `ng-anchor-in`.
+ *
+ * ```css
+ * .banner.ng-anchor-out {
+ * transition: 0.5s linear all;
+ *
+ * /* the scale will be applied during the out animation,
+ * but will be animated away when the in animation runs */
+ * transform: scale(1.2);
+ * }
+ *
+ * .banner.ng-anchor-in {
+ * transition: 1s linear all;
+ * }
+ * ```
+ *
+ *
+ *
+ *
+ * ### Anchoring Demo
+ *
+ <example module="anchoringExample"
+ name="anchoringExample"
+ id="anchoringExample"
+ deps="angular-animate.js;angular-route.js"
+ animations="true">
+ <file name="index.html">
+ <a href="#!/">Home</a>
+ <hr />
+ <div class="view-container">
+ <div ng-view class="view"></div>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('anchoringExample', ['ngAnimate', 'ngRoute'])
+ .config(['$routeProvider', function($routeProvider) {
+ $routeProvider.when('/', {
+ templateUrl: 'home.html',
+ controller: 'HomeController as home'
+ });
+ $routeProvider.when('/profile/:id', {
+ templateUrl: 'profile.html',
+ controller: 'ProfileController as profile'
+ });
+ }])
+ .run(['$rootScope', function($rootScope) {
+ $rootScope.records = [
+ { id: 1, title: 'Miss Beulah Roob' },
+ { id: 2, title: 'Trent Morissette' },
+ { id: 3, title: 'Miss Ava Pouros' },
+ { id: 4, title: 'Rod Pouros' },
+ { id: 5, title: 'Abdul Rice' },
+ { id: 6, title: 'Laurie Rutherford Sr.' },
+ { id: 7, title: 'Nakia McLaughlin' },
+ { id: 8, title: 'Jordon Blanda DVM' },
+ { id: 9, title: 'Rhoda Hand' },
+ { id: 10, title: 'Alexandrea Sauer' }
+ ];
+ }])
+ .controller('HomeController', [function() {
+ //empty
+ }])
+ .controller('ProfileController', ['$rootScope', '$routeParams',
+ function ProfileController($rootScope, $routeParams) {
+ var index = parseInt($routeParams.id, 10);
+ var record = $rootScope.records[index - 1];
+
+ this.title = record.title;
+ this.id = record.id;
+ }]);
+ </file>
+ <file name="home.html">
+ <h2>Welcome to the home page</h1>
+ <p>Please click on an element</p>
+ <a class="record"
+ ng-href="#!/profile/{{ record.id }}"
+ ng-animate-ref="{{ record.id }}"
+ ng-repeat="record in records">
+ {{ record.title }}
+ </a>
+ </file>
+ <file name="profile.html">
+ <div class="profile record" ng-animate-ref="{{ profile.id }}">
+ {{ profile.title }}
+ </div>
+ </file>
+ <file name="animations.css">
+ .record {
+ display:block;
+ font-size:20px;
+ }
+ .profile {
+ background:black;
+ color:white;
+ font-size:100px;
+ }
+ .view-container {
+ position:relative;
+ }
+ .view-container > .view.ng-animate {
+ position:absolute;
+ top:0;
+ left:0;
+ width:100%;
+ min-height:500px;
+ }
+ .view.ng-enter, .view.ng-leave,
+ .record.ng-anchor {
+ transition:0.5s linear all;
+ }
+ .view.ng-enter {
+ transform:translateX(100%);
+ }
+ .view.ng-enter.ng-enter-active, .view.ng-leave {
+ transform:translateX(0%);
+ }
+ .view.ng-leave.ng-leave-active {
+ transform:translateX(-100%);
+ }
+ .record.ng-anchor-out {
+ background:red;
+ }
+ </file>
+ </example>
+ *
+ * ### How is the element transported?
+ *
+ * When an anchor animation occurs, ngAnimate will clone the starting element and position it exactly where the starting
+ * element is located on screen via absolute positioning. The cloned element will be placed inside of the root element
+ * of the application (where ng-app was defined) and all of the CSS classes of the starting element will be applied. The
+ * element will then animate into the `out` and `in` animations and will eventually reach the coordinates and match
+ * the dimensions of the destination element. During the entire animation a CSS class of `.ng-animate-shim` will be applied
+ * to both the starting and destination elements in order to hide them from being visible (the CSS styling for the class
+ * is: `visibility:hidden`). Once the anchor reaches its destination then it will be removed and the destination element
+ * will become visible since the shim class will be removed.
+ *
+ * ### How is the morphing handled?
+ *
+ * CSS Anchoring relies on transitions and keyframes and the internal code is intelligent enough to figure out
+ * what CSS classes differ between the starting element and the destination element. These different CSS classes
+ * will be added/removed on the anchor element and a transition will be applied (the transition that is provided
+ * in the anchor class). Long story short, ngAnimate will figure out what classes to add and remove which will
+ * make the transition of the element as smooth and automatic as possible. Be sure to use simple CSS classes that
+ * do not rely on DOM nesting structure so that the anchor element appears the same as the starting element (since
+ * the cloned element is placed inside of root element which is likely close to the body element).
+ *
+ * Note that if the root element is on the `<html>` element then the cloned node will be placed inside of body.
+ *
+ *
+ * ## Using $animate in your directive code
+ *
+ * So far we've explored how to feed in animations into an AngularJS application, but how do we trigger animations within our own directives in our application?
+ * By injecting the `$animate` service into our directive code, we can trigger structural and class-based hooks which can then be consumed by animations. Let's
+ * imagine we have a greeting box that shows and hides itself when the data changes
+ *
+ * ```html
+ * <greeting-box active="onOrOff">Hi there</greeting-box>
+ * ```
+ *
+ * ```js
+ * ngModule.directive('greetingBox', ['$animate', function($animate) {
+ * return function(scope, element, attrs) {
+ * attrs.$observe('active', function(value) {
+ * value ? $animate.addClass(element, 'on') : $animate.removeClass(element, 'on');
+ * });
+ * });
+ * }]);
+ * ```
+ *
+ * Now the `on` CSS class is added and removed on the greeting box component. Now if we add a CSS class on top of the greeting box element
+ * in our HTML code then we can trigger a CSS or JS animation to happen.
+ *
+ * ```css
+ * /* normally we would create a CSS class to reference on the element */
+ * greeting-box.on { transition:0.5s linear all; background:green; color:white; }
+ * ```
+ *
+ * The `$animate` service contains a variety of other methods like `enter`, `leave`, `animate` and `setClass`. To learn more about what's
+ * possible be sure to visit the {@link ng.$animate $animate service API page}.
+ *
+ *
+ * ## Callbacks and Promises
+ *
+ * When `$animate` is called it returns a promise that can be used to capture when the animation has ended. Therefore if we were to trigger
+ * an animation (within our directive code) then we can continue performing directive and scope related activities after the animation has
+ * ended by chaining onto the returned promise that animation method returns.
+ *
+ * ```js
+ * // somewhere within the depths of the directive
+ * $animate.enter(element, parent).then(function() {
+ * //the animation has completed
+ * });
+ * ```
+ *
+ * (Note that earlier versions of AngularJS prior to v1.4 required the promise code to be wrapped using `$scope.$apply(...)`. This is not the case
+ * anymore.)
+ *
+ * In addition to the animation promise, we can also make use of animation-related callbacks within our directives and controller code by registering
+ * an event listener using the `$animate` service. Let's say for example that an animation was triggered on our view
+ * routing controller to hook into that:
+ *
+ * ```js
+ * ngModule.controller('HomePageController', ['$animate', function($animate) {
+ * $animate.on('enter', ngViewElement, function(element) {
+ * // the animation for this route has completed
+ * }]);
+ * }])
+ * ```
+ *
+ * (Note that you will need to trigger a digest within the callback to get AngularJS to notice any scope-related changes.)
+ */
+
+var copy;
+var extend;
+var forEach;
+var isArray;
+var isDefined;
+var isElement;
+var isFunction;
+var isObject;
+var isString;
+var isUndefined;
+var jqLite;
+var noop;
+
+/**
+ * @ngdoc service
+ * @name $animate
+ * @kind object
+ *
+ * @description
+ * The ngAnimate `$animate` service documentation is the same for the core `$animate` service.
+ *
+ * Click here {@link ng.$animate to learn more about animations with `$animate`}.
+ */
+angular.module('ngAnimate', [], function initAngularHelpers() {
+ // Access helpers from AngularJS core.
+ // Do it inside a `config` block to ensure `window.angular` is available.
+ noop = angular.noop;
+ copy = angular.copy;
+ extend = angular.extend;
+ jqLite = angular.element;
+ forEach = angular.forEach;
+ isArray = angular.isArray;
+ isString = angular.isString;
+ isObject = angular.isObject;
+ isUndefined = angular.isUndefined;
+ isDefined = angular.isDefined;
+ isFunction = angular.isFunction;
+ isElement = angular.isElement;
+})
+ .info({ angularVersion: '1.8.2' })
+ .directive('ngAnimateSwap', ngAnimateSwapDirective)
+
+ .directive('ngAnimateChildren', $$AnimateChildrenDirective)
+ .factory('$$rAFScheduler', $$rAFSchedulerFactory)
+
+ .provider('$$animateQueue', $$AnimateQueueProvider)
+ .provider('$$animateCache', $$AnimateCacheProvider)
+ .provider('$$animation', $$AnimationProvider)
+
+ .provider('$animateCss', $AnimateCssProvider)
+ .provider('$$animateCssDriver', $$AnimateCssDriverProvider)
+
+ .provider('$$animateJs', $$AnimateJsProvider)
+ .provider('$$animateJsDriver', $$AnimateJsDriverProvider);
+
+
+})(window, window.angular);
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-animate/index.js":
+/*!***********************************************!*\
+ !*** ./node_modules/angular-animate/index.js ***!
+ \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+__webpack_require__(/*! ./angular-animate */ "./node_modules/angular-animate/angular-animate.js");
+module.exports = 'ngAnimate';
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-aria/angular-aria.js":
+/*!***************************************************!*\
+ !*** ./node_modules/angular-aria/angular-aria.js ***!
+ \***************************************************/
+/***/ (() => {
+
+/**
+ * @license AngularJS v1.8.2
+ * (c) 2010-2020 Google LLC. http://angularjs.org
+ * License: MIT
+ */
+(function(window, angular) {'use strict';
+
+/**
+ * @ngdoc module
+ * @name ngAria
+ * @description
+ *
+ * The `ngAria` module provides support for common
+ * [<abbr title="Accessible Rich Internet Applications">ARIA</abbr>](http://www.w3.org/TR/wai-aria/)
+ * attributes that convey state or semantic information about the application for users
+ * of assistive technologies, such as screen readers.
+ *
+ * ## Usage
+ *
+ * For ngAria to do its magic, simply include the module `ngAria` as a dependency. The following
+ * directives are supported:
+ * `ngModel`, `ngChecked`, `ngReadonly`, `ngRequired`, `ngValue`, `ngDisabled`, `ngShow`, `ngHide`,
+ * `ngClick`, `ngDblClick`, and `ngMessages`.
+ *
+ * Below is a more detailed breakdown of the attributes handled by ngAria:
+ *
+ * | Directive | Supported Attributes |
+ * |---------------------------------------------|-----------------------------------------------------------------------------------------------------|
+ * | {@link ng.directive:ngModel ngModel} | aria-checked, aria-valuemin, aria-valuemax, aria-valuenow, aria-invalid, aria-required, input roles |
+ * | {@link ng.directive:ngDisabled ngDisabled} | aria-disabled |
+ * | {@link ng.directive:ngRequired ngRequired} | aria-required |
+ * | {@link ng.directive:ngChecked ngChecked} | aria-checked |
+ * | {@link ng.directive:ngReadonly ngReadonly} | aria-readonly |
+ * | {@link ng.directive:ngValue ngValue} | aria-checked |
+ * | {@link ng.directive:ngShow ngShow} | aria-hidden |
+ * | {@link ng.directive:ngHide ngHide} | aria-hidden |
+ * | {@link ng.directive:ngDblclick ngDblclick} | tabindex |
+ * | {@link module:ngMessages ngMessages} | aria-live |
+ * | {@link ng.directive:ngClick ngClick} | tabindex, keydown event, button role |
+ *
+ * Find out more information about each directive by reading the
+ * {@link guide/accessibility ngAria Developer Guide}.
+ *
+ * ## Example
+ * Using ngDisabled with ngAria:
+ * ```html
+ * <md-checkbox ng-disabled="disabled">
+ * ```
+ * Becomes:
+ * ```html
+ * <md-checkbox ng-disabled="disabled" aria-disabled="true">
+ * ```
+ *
+ * ## Disabling Specific Attributes
+ * It is possible to disable individual attributes added by ngAria with the
+ * {@link ngAria.$ariaProvider#config config} method. For more details, see the
+ * {@link guide/accessibility Developer Guide}.
+ *
+ * ## Disabling `ngAria` on Specific Elements
+ * It is possible to make `ngAria` ignore a specific element, by adding the `ng-aria-disable`
+ * attribute on it. Note that only the element itself (and not its child elements) will be ignored.
+ */
+var ARIA_DISABLE_ATTR = 'ngAriaDisable';
+
+var ngAriaModule = angular.module('ngAria', ['ng']).
+ info({ angularVersion: '1.8.2' }).
+ provider('$aria', $AriaProvider);
+
+/**
+* Internal Utilities
+*/
+var nativeAriaNodeNames = ['BUTTON', 'A', 'INPUT', 'TEXTAREA', 'SELECT', 'DETAILS', 'SUMMARY'];
+
+var isNodeOneOf = function(elem, nodeTypeArray) {
+ if (nodeTypeArray.indexOf(elem[0].nodeName) !== -1) {
+ return true;
+ }
+};
+/**
+ * @ngdoc provider
+ * @name $ariaProvider
+ * @this
+ *
+ * @description
+ *
+ * Used for configuring the ARIA attributes injected and managed by ngAria.
+ *
+ * ```js
+ * angular.module('myApp', ['ngAria'], function config($ariaProvider) {
+ * $ariaProvider.config({
+ * ariaValue: true,
+ * tabindex: false
+ * });
+ * });
+ *```
+ *
+ * ## Dependencies
+ * Requires the {@link ngAria} module to be installed.
+ *
+ */
+function $AriaProvider() {
+ var config = {
+ ariaHidden: true,
+ ariaChecked: true,
+ ariaReadonly: true,
+ ariaDisabled: true,
+ ariaRequired: true,
+ ariaInvalid: true,
+ ariaValue: true,
+ tabindex: true,
+ bindKeydown: true,
+ bindRoleForClick: true
+ };
+
+ /**
+ * @ngdoc method
+ * @name $ariaProvider#config
+ *
+ * @param {object} config object to enable/disable specific ARIA attributes
+ *
+ * - **ariaHidden** – `{boolean}` – Enables/disables aria-hidden tags
+ * - **ariaChecked** – `{boolean}` – Enables/disables aria-checked tags
+ * - **ariaReadonly** – `{boolean}` – Enables/disables aria-readonly tags
+ * - **ariaDisabled** – `{boolean}` – Enables/disables aria-disabled tags
+ * - **ariaRequired** – `{boolean}` – Enables/disables aria-required tags
+ * - **ariaInvalid** – `{boolean}` – Enables/disables aria-invalid tags
+ * - **ariaValue** – `{boolean}` – Enables/disables aria-valuemin, aria-valuemax and
+ * aria-valuenow tags
+ * - **tabindex** – `{boolean}` – Enables/disables tabindex tags
+ * - **bindKeydown** – `{boolean}` – Enables/disables keyboard event binding on non-interactive
+ * elements (such as `div` or `li`) using ng-click, making them more accessible to users of
+ * assistive technologies
+ * - **bindRoleForClick** – `{boolean}` – Adds role=button to non-interactive elements (such as
+ * `div` or `li`) using ng-click, making them more accessible to users of assistive
+ * technologies
+ *
+ * @description
+ * Enables/disables various ARIA attributes
+ */
+ this.config = function(newConfig) {
+ config = angular.extend(config, newConfig);
+ };
+
+ function watchExpr(attrName, ariaAttr, nativeAriaNodeNames, negate) {
+ return function(scope, elem, attr) {
+ if (attr.hasOwnProperty(ARIA_DISABLE_ATTR)) return;
+
+ var ariaCamelName = attr.$normalize(ariaAttr);
+ if (config[ariaCamelName] && !isNodeOneOf(elem, nativeAriaNodeNames) && !attr[ariaCamelName]) {
+ scope.$watch(attr[attrName], function(boolVal) {
+ // ensure boolean value
+ boolVal = negate ? !boolVal : !!boolVal;
+ elem.attr(ariaAttr, boolVal);
+ });
+ }
+ };
+ }
+ /**
+ * @ngdoc service
+ * @name $aria
+ *
+ * @description
+ *
+ * The $aria service contains helper methods for applying common
+ * [ARIA](http://www.w3.org/TR/wai-aria/) attributes to HTML directives.
+ *
+ * ngAria injects common accessibility attributes that tell assistive technologies when HTML
+ * elements are enabled, selected, hidden, and more. To see how this is performed with ngAria,
+ * let's review a code snippet from ngAria itself:
+ *
+ *```js
+ * ngAriaModule.directive('ngDisabled', ['$aria', function($aria) {
+ * return $aria.$$watchExpr('ngDisabled', 'aria-disabled', nativeAriaNodeNames, false);
+ * }])
+ *```
+ * Shown above, the ngAria module creates a directive with the same signature as the
+ * traditional `ng-disabled` directive. But this ngAria version is dedicated to
+ * solely managing accessibility attributes on custom elements. The internal `$aria` service is
+ * used to watch the boolean attribute `ngDisabled`. If it has not been explicitly set by the
+ * developer, `aria-disabled` is injected as an attribute with its value synchronized to the
+ * value in `ngDisabled`.
+ *
+ * Because ngAria hooks into the `ng-disabled` directive, developers do not have to do
+ * anything to enable this feature. The `aria-disabled` attribute is automatically managed
+ * simply as a silent side-effect of using `ng-disabled` with the ngAria module.
+ *
+ * The full list of directives that interface with ngAria:
+ * * **ngModel**
+ * * **ngChecked**
+ * * **ngReadonly**
+ * * **ngRequired**
+ * * **ngDisabled**
+ * * **ngValue**
+ * * **ngShow**
+ * * **ngHide**
+ * * **ngClick**
+ * * **ngDblclick**
+ * * **ngMessages**
+ *
+ * Read the {@link guide/accessibility ngAria Developer Guide} for a thorough explanation of each
+ * directive.
+ *
+ *
+ * ## Dependencies
+ * Requires the {@link ngAria} module to be installed.
+ */
+ this.$get = function() {
+ return {
+ config: function(key) {
+ return config[key];
+ },
+ $$watchExpr: watchExpr
+ };
+ };
+}
+
+
+ngAriaModule.directive('ngShow', ['$aria', function($aria) {
+ return $aria.$$watchExpr('ngShow', 'aria-hidden', [], true);
+}])
+.directive('ngHide', ['$aria', function($aria) {
+ return $aria.$$watchExpr('ngHide', 'aria-hidden', [], false);
+}])
+.directive('ngValue', ['$aria', function($aria) {
+ return $aria.$$watchExpr('ngValue', 'aria-checked', nativeAriaNodeNames, false);
+}])
+.directive('ngChecked', ['$aria', function($aria) {
+ return $aria.$$watchExpr('ngChecked', 'aria-checked', nativeAriaNodeNames, false);
+}])
+.directive('ngReadonly', ['$aria', function($aria) {
+ return $aria.$$watchExpr('ngReadonly', 'aria-readonly', nativeAriaNodeNames, false);
+}])
+.directive('ngRequired', ['$aria', function($aria) {
+ return $aria.$$watchExpr('ngRequired', 'aria-required', nativeAriaNodeNames, false);
+}])
+.directive('ngModel', ['$aria', function($aria) {
+
+ function shouldAttachAttr(attr, normalizedAttr, elem, allowNonAriaNodes) {
+ return $aria.config(normalizedAttr) &&
+ !elem.attr(attr) &&
+ (allowNonAriaNodes || !isNodeOneOf(elem, nativeAriaNodeNames)) &&
+ (elem.attr('type') !== 'hidden' || elem[0].nodeName !== 'INPUT');
+ }
+
+ function shouldAttachRole(role, elem) {
+ // if element does not have role attribute
+ // AND element type is equal to role (if custom element has a type equaling shape) <-- remove?
+ // AND element is not in nativeAriaNodeNames
+ return !elem.attr('role') && (elem.attr('type') === role) && !isNodeOneOf(elem, nativeAriaNodeNames);
+ }
+
+ function getShape(attr, elem) {
+ var type = attr.type,
+ role = attr.role;
+
+ return ((type || role) === 'checkbox' || role === 'menuitemcheckbox') ? 'checkbox' :
+ ((type || role) === 'radio' || role === 'menuitemradio') ? 'radio' :
+ (type === 'range' || role === 'progressbar' || role === 'slider') ? 'range' : '';
+ }
+
+ return {
+ restrict: 'A',
+ require: 'ngModel',
+ priority: 200, //Make sure watches are fired after any other directives that affect the ngModel value
+ compile: function(elem, attr) {
+ if (attr.hasOwnProperty(ARIA_DISABLE_ATTR)) return;
+
+ var shape = getShape(attr, elem);
+
+ return {
+ post: function(scope, elem, attr, ngModel) {
+ var needsTabIndex = shouldAttachAttr('tabindex', 'tabindex', elem, false);
+
+ function ngAriaWatchModelValue() {
+ return ngModel.$modelValue;
+ }
+
+ function getRadioReaction(newVal) {
+ // Strict comparison would cause a BC
+ // eslint-disable-next-line eqeqeq
+ var boolVal = (attr.value == ngModel.$viewValue);
+ elem.attr('aria-checked', boolVal);
+ }
+
+ function getCheckboxReaction() {
+ elem.attr('aria-checked', !ngModel.$isEmpty(ngModel.$viewValue));
+ }
+
+ switch (shape) {
+ case 'radio':
+ case 'checkbox':
+ if (shouldAttachRole(shape, elem)) {
+ elem.attr('role', shape);
+ }
+ if (shouldAttachAttr('aria-checked', 'ariaChecked', elem, false)) {
+ scope.$watch(ngAriaWatchModelValue, shape === 'radio' ?
+ getRadioReaction : getCheckboxReaction);
+ }
+ if (needsTabIndex) {
+ elem.attr('tabindex', 0);
+ }
+ break;
+ case 'range':
+ if (shouldAttachRole(shape, elem)) {
+ elem.attr('role', 'slider');
+ }
+ if ($aria.config('ariaValue')) {
+ var needsAriaValuemin = !elem.attr('aria-valuemin') &&
+ (attr.hasOwnProperty('min') || attr.hasOwnProperty('ngMin'));
+ var needsAriaValuemax = !elem.attr('aria-valuemax') &&
+ (attr.hasOwnProperty('max') || attr.hasOwnProperty('ngMax'));
+ var needsAriaValuenow = !elem.attr('aria-valuenow');
+
+ if (needsAriaValuemin) {
+ attr.$observe('min', function ngAriaValueMinReaction(newVal) {
+ elem.attr('aria-valuemin', newVal);
+ });
+ }
+ if (needsAriaValuemax) {
+ attr.$observe('max', function ngAriaValueMinReaction(newVal) {
+ elem.attr('aria-valuemax', newVal);
+ });
+ }
+ if (needsAriaValuenow) {
+ scope.$watch(ngAriaWatchModelValue, function ngAriaValueNowReaction(newVal) {
+ elem.attr('aria-valuenow', newVal);
+ });
+ }
+ }
+ if (needsTabIndex) {
+ elem.attr('tabindex', 0);
+ }
+ break;
+ }
+
+ if (!attr.hasOwnProperty('ngRequired') && ngModel.$validators.required
+ && shouldAttachAttr('aria-required', 'ariaRequired', elem, false)) {
+ // ngModel.$error.required is undefined on custom controls
+ attr.$observe('required', function() {
+ elem.attr('aria-required', !!attr['required']);
+ });
+ }
+
+ if (shouldAttachAttr('aria-invalid', 'ariaInvalid', elem, true)) {
+ scope.$watch(function ngAriaInvalidWatch() {
+ return ngModel.$invalid;
+ }, function ngAriaInvalidReaction(newVal) {
+ elem.attr('aria-invalid', !!newVal);
+ });
+ }
+ }
+ };
+ }
+ };
+}])
+.directive('ngDisabled', ['$aria', function($aria) {
+ return $aria.$$watchExpr('ngDisabled', 'aria-disabled', nativeAriaNodeNames, false);
+}])
+.directive('ngMessages', function() {
+ return {
+ restrict: 'A',
+ require: '?ngMessages',
+ link: function(scope, elem, attr, ngMessages) {
+ if (attr.hasOwnProperty(ARIA_DISABLE_ATTR)) return;
+
+ if (!elem.attr('aria-live')) {
+ elem.attr('aria-live', 'assertive');
+ }
+ }
+ };
+})
+.directive('ngClick',['$aria', '$parse', function($aria, $parse) {
+ return {
+ restrict: 'A',
+ compile: function(elem, attr) {
+ if (attr.hasOwnProperty(ARIA_DISABLE_ATTR)) return;
+
+ var fn = $parse(attr.ngClick);
+ return function(scope, elem, attr) {
+
+ if (!isNodeOneOf(elem, nativeAriaNodeNames)) {
+
+ if ($aria.config('bindRoleForClick') && !elem.attr('role')) {
+ elem.attr('role', 'button');
+ }
+
+ if ($aria.config('tabindex') && !elem.attr('tabindex')) {
+ elem.attr('tabindex', 0);
+ }
+
+ if ($aria.config('bindKeydown') && !attr.ngKeydown && !attr.ngKeypress && !attr.ngKeyup) {
+ elem.on('keydown', function(event) {
+ var keyCode = event.which || event.keyCode;
+
+ if (keyCode === 13 || keyCode === 32) {
+ // If the event is triggered on a non-interactive element ...
+ if (nativeAriaNodeNames.indexOf(event.target.nodeName) === -1 && !event.target.isContentEditable) {
+ // ... prevent the default browser behavior (e.g. scrolling when pressing spacebar)
+ // See https://github.com/angular/angular.js/issues/16664
+ event.preventDefault();
+ }
+ scope.$apply(callback);
+ }
+
+ function callback() {
+ fn(scope, { $event: event });
+ }
+ });
+ }
+ }
+ };
+ }
+ };
+}])
+.directive('ngDblclick', ['$aria', function($aria) {
+ return function(scope, elem, attr) {
+ if (attr.hasOwnProperty(ARIA_DISABLE_ATTR)) return;
+
+ if ($aria.config('tabindex') && !elem.attr('tabindex') && !isNodeOneOf(elem, nativeAriaNodeNames)) {
+ elem.attr('tabindex', 0);
+ }
+ };
+}]);
+
+
+})(window, window.angular);
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-aria/index.js":
+/*!********************************************!*\
+ !*** ./node_modules/angular-aria/index.js ***!
+ \********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+__webpack_require__(/*! ./angular-aria */ "./node_modules/angular-aria/angular-aria.js");
+module.exports = 'ngAria';
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-local-storage/dist/angular-local-storage.js":
+/*!**************************************************************************!*\
+ !*** ./node_modules/angular-local-storage/dist/angular-local-storage.js ***!
+ \**************************************************************************/
+/***/ (() => {
+
+/**
+ * An Angular module that gives you access to the browsers local storage
+ * @version v0.7.1 - 2017-06-21
+ * @link https://github.com/grevory/angular-local-storage
+ * @author grevory <greg@gregpike.ca>
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+(function (window, angular) {
+var isDefined = angular.isDefined,
+ isUndefined = angular.isUndefined,
+ isNumber = angular.isNumber,
+ isObject = angular.isObject,
+ isArray = angular.isArray,
+ isString = angular.isString,
+ extend = angular.extend,
+ toJson = angular.toJson;
+
+angular
+ .module('LocalStorageModule', [])
+ .provider('localStorageService', function() {
+ // You should set a prefix to avoid overwriting any local storage variables from the rest of your app
+ // e.g. localStorageServiceProvider.setPrefix('yourAppName');
+ // With provider you can use config as this:
+ // myApp.config(function (localStorageServiceProvider) {
+ // localStorageServiceProvider.prefix = 'yourAppName';
+ // });
+ this.prefix = 'ls';
+
+ // You could change web storage type localstorage or sessionStorage
+ this.storageType = 'localStorage';
+
+ // Cookie options (usually in case of fallback)
+ // expiry = Number of days before cookies expire // 0 = Does not expire
+ // path = The web path the cookie represents
+ // secure = Wether the cookies should be secure (i.e only sent on HTTPS requests)
+ this.cookie = {
+ expiry: 30,
+ path: '/',
+ secure: false
+ };
+
+ // Decides wether we should default to cookies if localstorage is not supported.
+ this.defaultToCookie = true;
+
+ // Send signals for each of the following actions?
+ this.notify = {
+ setItem: true,
+ removeItem: false
+ };
+
+ // Setter for the prefix
+ this.setPrefix = function(prefix) {
+ this.prefix = prefix;
+ return this;
+ };
+
+ // Setter for the storageType
+ this.setStorageType = function(storageType) {
+ this.storageType = storageType;
+ return this;
+ };
+ // Setter for defaultToCookie value, default is true.
+ this.setDefaultToCookie = function (shouldDefault) {
+ this.defaultToCookie = !!shouldDefault; // Double-not to make sure it's a bool value.
+ return this;
+ };
+ // Setter for cookie config
+ this.setStorageCookie = function(exp, path, secure) {
+ this.cookie.expiry = exp;
+ this.cookie.path = path;
+ this.cookie.secure = secure;
+ return this;
+ };
+
+ // Setter for cookie domain
+ this.setStorageCookieDomain = function(domain) {
+ this.cookie.domain = domain;
+ return this;
+ };
+
+ // Setter for notification config
+ // itemSet & itemRemove should be booleans
+ this.setNotify = function(itemSet, itemRemove) {
+ this.notify = {
+ setItem: itemSet,
+ removeItem: itemRemove
+ };
+ return this;
+ };
+
+ this.$get = ['$rootScope', '$window', '$document', '$parse','$timeout', function($rootScope, $window, $document, $parse, $timeout) {
+ var self = this;
+ var prefix = self.prefix;
+ var cookie = self.cookie;
+ var notify = self.notify;
+ var storageType = self.storageType;
+ var webStorage;
+
+ // When Angular's $document is not available
+ if (!$document) {
+ $document = document;
+ } else if ($document[0]) {
+ $document = $document[0];
+ }
+
+ // If there is a prefix set in the config lets use that with an appended period for readability
+ if (prefix.substr(-1) !== '.') {
+ prefix = !!prefix ? prefix + '.' : '';
+ }
+ var deriveQualifiedKey = function(key) {
+ return prefix + key;
+ };
+
+ // Removes prefix from the key.
+ var underiveQualifiedKey = function (key) {
+ return key.replace(new RegExp('^' + prefix, 'g'), '');
+ };
+
+ // Check if the key is within our prefix namespace.
+ var isKeyPrefixOurs = function (key) {
+ return key.indexOf(prefix) === 0;
+ };
+
+ // Checks the browser to see if local storage is supported
+ var checkSupport = function () {
+ try {
+ var supported = (storageType in $window && $window[storageType] !== null);
+
+ // When Safari (OS X or iOS) is in private browsing mode, it appears as though localStorage
+ // is available, but trying to call .setItem throws an exception.
+ //
+ // "QUOTA_EXCEEDED_ERR: DOM Exception 22: An attempt was made to add something to storage
+ // that exceeded the quota."
+ var key = deriveQualifiedKey('__' + Math.round(Math.random() * 1e7));
+ if (supported) {
+ webStorage = $window[storageType];
+ webStorage.setItem(key, '');
+ webStorage.removeItem(key);
+ }
+
+ return supported;
+ } catch (e) {
+ // Only change storageType to cookies if defaulting is enabled.
+ if (self.defaultToCookie)
+ storageType = 'cookie';
+ $rootScope.$broadcast('LocalStorageModule.notification.error', e.message);
+ return false;
+ }
+ };
+ var browserSupportsLocalStorage = checkSupport();
+
+ // Directly adds a value to local storage
+ // If local storage is not available in the browser use cookies
+ // Example use: localStorageService.add('library','angular');
+ var addToLocalStorage = function (key, value, type) {
+ var previousType = getStorageType();
+
+ try {
+ setStorageType(type);
+
+ // Let's convert undefined values to null to get the value consistent
+ if (isUndefined(value)) {
+ value = null;
+ } else {
+ value = toJson(value);
+ }
+
+ // If this browser does not support local storage use cookies
+ if (!browserSupportsLocalStorage && self.defaultToCookie || self.storageType === 'cookie') {
+ if (!browserSupportsLocalStorage) {
+ $rootScope.$broadcast('LocalStorageModule.notification.warning', 'LOCAL_STORAGE_NOT_SUPPORTED');
+ }
+
+ if (notify.setItem) {
+ $rootScope.$broadcast('LocalStorageModule.notification.setitem', {key: key, newvalue: value, storageType: 'cookie'});
+ }
+ return addToCookies(key, value);
+ }
+
+ try {
+ if (webStorage) {
+ webStorage.setItem(deriveQualifiedKey(key), value);
+ }
+ if (notify.setItem) {
+ $rootScope.$broadcast('LocalStorageModule.notification.setitem', {key: key, newvalue: value, storageType: self.storageType});
+ }
+ } catch (e) {
+ $rootScope.$broadcast('LocalStorageModule.notification.error', e.message);
+ return addToCookies(key, value);
+ }
+ return true;
+ } finally {
+ setStorageType(previousType);
+ }
+ };
+
+ // Directly get a value from local storage
+ // Example use: localStorageService.get('library'); // returns 'angular'
+ var getFromLocalStorage = function (key, type) {
+ var previousType = getStorageType();
+
+ try {
+ setStorageType(type);
+
+ if (!browserSupportsLocalStorage && self.defaultToCookie || self.storageType === 'cookie') {
+ if (!browserSupportsLocalStorage) {
+ $rootScope.$broadcast('LocalStorageModule.notification.warning', 'LOCAL_STORAGE_NOT_SUPPORTED');
+ }
+
+ return getFromCookies(key);
+ }
+
+ var item = webStorage ? webStorage.getItem(deriveQualifiedKey(key)) : null;
+ // angular.toJson will convert null to 'null', so a proper conversion is needed
+ // FIXME not a perfect solution, since a valid 'null' string can't be stored
+ if (!item || item === 'null') {
+ return null;
+ }
+
+ try {
+ return JSON.parse(item);
+ } catch (e) {
+ return item;
+ }
+ } finally {
+ setStorageType(previousType);
+ }
+ };
+
+ // Remove an item from local storage
+ // Example use: localStorageService.remove('library'); // removes the key/value pair of library='angular'
+ //
+ // This is var-arg removal, check the last argument to see if it is a storageType
+ // and set type accordingly before removing.
+ //
+ var removeFromLocalStorage = function () {
+ var previousType = getStorageType();
+
+ try {
+ // can't pop on arguments, so we do this
+ var consumed = 0;
+ if (arguments.length >= 1 &&
+ (arguments[arguments.length - 1] === 'localStorage' ||
+ arguments[arguments.length - 1] === 'sessionStorage')) {
+ consumed = 1;
+ setStorageType(arguments[arguments.length - 1]);
+ }
+
+ var i, key;
+ for (i = 0; i < arguments.length - consumed; i++) {
+ key = arguments[i];
+ if (!browserSupportsLocalStorage && self.defaultToCookie || self.storageType === 'cookie') {
+ if (!browserSupportsLocalStorage) {
+ $rootScope.$broadcast('LocalStorageModule.notification.warning', 'LOCAL_STORAGE_NOT_SUPPORTED');
+ }
+
+ if (notify.removeItem) {
+ $rootScope.$broadcast('LocalStorageModule.notification.removeitem', {key: key, storageType: 'cookie'});
+ }
+ removeFromCookies(key);
+ }
+ else {
+ try {
+ webStorage.removeItem(deriveQualifiedKey(key));
+ if (notify.removeItem) {
+ $rootScope.$broadcast('LocalStorageModule.notification.removeitem', {
+ key: key,
+ storageType: self.storageType
+ });
+ }
+ } catch (e) {
+ $rootScope.$broadcast('LocalStorageModule.notification.error', e.message);
+ removeFromCookies(key);
+ }
+ }
+ }
+ } finally {
+ setStorageType(previousType);
+ }
+ };
+
+ // Return array of keys for local storage
+ // Example use: var keys = localStorageService.keys()
+ var getKeysForLocalStorage = function (type) {
+ var previousType = getStorageType();
+
+ try {
+ setStorageType(type);
+
+ if (!browserSupportsLocalStorage) {
+ $rootScope.$broadcast('LocalStorageModule.notification.warning', 'LOCAL_STORAGE_NOT_SUPPORTED');
+ return [];
+ }
+
+ var prefixLength = prefix.length;
+ var keys = [];
+ for (var key in webStorage) {
+ // Only return keys that are for this app
+ if (key.substr(0, prefixLength) === prefix) {
+ try {
+ keys.push(key.substr(prefixLength));
+ } catch (e) {
+ $rootScope.$broadcast('LocalStorageModule.notification.error', e.Description);
+ return [];
+ }
+ }
+ }
+
+ return keys;
+ } finally {
+ setStorageType(previousType);
+ }
+ };
+
+ // Remove all data for this app from local storage
+ // Also optionally takes a regular expression string and removes the matching key-value pairs
+ // Example use: localStorageService.clearAll();
+ // Should be used mostly for development purposes
+ var clearAllFromLocalStorage = function (regularExpression, type) {
+ var previousType = getStorageType();
+
+ try {
+ setStorageType(type);
+
+ // Setting both regular expressions independently
+ // Empty strings result in catchall RegExp
+ var prefixRegex = !!prefix ? new RegExp('^' + prefix) : new RegExp();
+ var testRegex = !!regularExpression ? new RegExp(regularExpression) : new RegExp();
+
+ if (!browserSupportsLocalStorage && self.defaultToCookie || self.storageType === 'cookie') {
+ if (!browserSupportsLocalStorage) {
+ $rootScope.$broadcast('LocalStorageModule.notification.warning', 'LOCAL_STORAGE_NOT_SUPPORTED');
+ }
+ return clearAllFromCookies();
+ }
+ if (!browserSupportsLocalStorage && !self.defaultToCookie)
+ return false;
+ var prefixLength = prefix.length;
+
+ for (var key in webStorage) {
+ // Only remove items that are for this app and match the regular expression
+ if (prefixRegex.test(key) && testRegex.test(key.substr(prefixLength))) {
+ try {
+ removeFromLocalStorage(key.substr(prefixLength));
+ } catch (e) {
+ $rootScope.$broadcast('LocalStorageModule.notification.error', e.message);
+ return clearAllFromCookies();
+ }
+ }
+ }
+
+ return true;
+ } finally {
+ setStorageType(previousType);
+ }
+ };
+
+ // Checks the browser to see if cookies are supported
+ var browserSupportsCookies = (function() {
+ try {
+ return $window.navigator.cookieEnabled ||
+ ("cookie" in $document && ($document.cookie.length > 0 ||
+ ($document.cookie = "test").indexOf.call($document.cookie, "test") > -1));
+ } catch (e) {
+ $rootScope.$broadcast('LocalStorageModule.notification.error', e.message);
+ return false;
+ }
+ }());
+
+ // Directly adds a value to cookies
+ // Typically used as a fallback if local storage is not available in the browser
+ // Example use: localStorageService.cookie.add('library','angular');
+ var addToCookies = function (key, value, daysToExpiry, secure) {
+
+ if (isUndefined(value)) {
+ return false;
+ } else if(isArray(value) || isObject(value)) {
+ value = toJson(value);
+ }
+
+ if (!browserSupportsCookies) {
+ $rootScope.$broadcast('LocalStorageModule.notification.error', 'COOKIES_NOT_SUPPORTED');
+ return false;
+ }
+
+ try {
+ var expiry = '',
+ expiryDate = new Date(),
+ cookieDomain = '';
+
+ if (value === null) {
+ // Mark that the cookie has expired one day ago
+ expiryDate.setTime(expiryDate.getTime() + (-1 * 24 * 60 * 60 * 1000));
+ expiry = "; expires=" + expiryDate.toGMTString();
+ value = '';
+ } else if (isNumber(daysToExpiry) && daysToExpiry !== 0) {
+ expiryDate.setTime(expiryDate.getTime() + (daysToExpiry * 24 * 60 * 60 * 1000));
+ expiry = "; expires=" + expiryDate.toGMTString();
+ } else if (cookie.expiry !== 0) {
+ expiryDate.setTime(expiryDate.getTime() + (cookie.expiry * 24 * 60 * 60 * 1000));
+ expiry = "; expires=" + expiryDate.toGMTString();
+ }
+ if (!!key) {
+ var cookiePath = "; path=" + cookie.path;
+ if (cookie.domain) {
+ cookieDomain = "; domain=" + cookie.domain;
+ }
+ /* Providing the secure parameter always takes precedence over config
+ * (allows developer to mix and match secure + non-secure) */
+ if (typeof secure === 'boolean') {
+ if (secure === true) {
+ /* We've explicitly specified secure,
+ * add the secure attribute to the cookie (after domain) */
+ cookieDomain += "; secure";
+ }
+ // else - secure has been supplied but isn't true - so don't set secure flag, regardless of what config says
+ }
+ else if (cookie.secure === true) {
+ // secure parameter wasn't specified, get default from config
+ cookieDomain += "; secure";
+ }
+ $document.cookie = deriveQualifiedKey(key) + "=" + encodeURIComponent(value) + expiry + cookiePath + cookieDomain;
+ }
+ } catch (e) {
+ $rootScope.$broadcast('LocalStorageModule.notification.error', e.message);
+ return false;
+ }
+ return true;
+ };
+
+ // Directly get a value from a cookie
+ // Example use: localStorageService.cookie.get('library'); // returns 'angular'
+ var getFromCookies = function (key) {
+ if (!browserSupportsCookies) {
+ $rootScope.$broadcast('LocalStorageModule.notification.error', 'COOKIES_NOT_SUPPORTED');
+ return false;
+ }
+
+ var cookies = $document.cookie && $document.cookie.split(';') || [];
+ for(var i=0; i < cookies.length; i++) {
+ var thisCookie = cookies[i];
+ while (thisCookie.charAt(0) === ' ') {
+ thisCookie = thisCookie.substring(1,thisCookie.length);
+ }
+ if (thisCookie.indexOf(deriveQualifiedKey(key) + '=') === 0) {
+ var storedValues = decodeURIComponent(thisCookie.substring(prefix.length + key.length + 1, thisCookie.length));
+ try {
+ var parsedValue = JSON.parse(storedValues);
+ return typeof(parsedValue) === 'number' ? storedValues : parsedValue;
+ } catch(e) {
+ return storedValues;
+ }
+ }
+ }
+ return null;
+ };
+
+ var removeFromCookies = function (key) {
+ addToCookies(key,null);
+ };
+
+ var clearAllFromCookies = function () {
+ var thisCookie = null;
+ var prefixLength = prefix.length;
+ var cookies = $document.cookie.split(';');
+ for(var i = 0; i < cookies.length; i++) {
+ thisCookie = cookies[i];
+
+ while (thisCookie.charAt(0) === ' ') {
+ thisCookie = thisCookie.substring(1, thisCookie.length);
+ }
+
+ var key = thisCookie.substring(prefixLength, thisCookie.indexOf('='));
+ removeFromCookies(key);
+ }
+ };
+
+ var getStorageType = function() {
+ return storageType;
+ };
+
+ var setStorageType = function(type) {
+ if (type && storageType !== type) {
+ storageType = type;
+ browserSupportsLocalStorage = checkSupport();
+ }
+ return browserSupportsLocalStorage;
+ };
+
+ // Add a listener on scope variable to save its changes to local storage
+ // Return a function which when called cancels binding
+ var bindToScope = function(scope, key, def, lsKey, type) {
+ lsKey = lsKey || key;
+ var value = getFromLocalStorage(lsKey, type);
+
+ if (value === null && isDefined(def)) {
+ value = def;
+ } else if (isObject(value) && isObject(def)) {
+ value = extend(value, def);
+ }
+
+ $parse(key).assign(scope, value);
+
+ return scope.$watch(key, function(newVal) {
+ addToLocalStorage(lsKey, newVal, type);
+ }, isObject(scope[key]));
+ };
+
+ // Add listener to local storage, for update callbacks.
+ if (browserSupportsLocalStorage) {
+ if ($window.addEventListener) {
+ $window.addEventListener("storage", handleStorageChangeCallback, false);
+ $rootScope.$on('$destroy', function() {
+ $window.removeEventListener("storage", handleStorageChangeCallback);
+ });
+ } else if($window.attachEvent){
+ // attachEvent and detachEvent are proprietary to IE v6-10
+ $window.attachEvent("onstorage", handleStorageChangeCallback);
+ $rootScope.$on('$destroy', function() {
+ $window.detachEvent("onstorage", handleStorageChangeCallback);
+ });
+ }
+ }
+
+ // Callback handler for storage changed.
+ function handleStorageChangeCallback(e) {
+ if (!e) { e = $window.event; }
+ if (notify.setItem) {
+ if (isString(e.key) && isKeyPrefixOurs(e.key)) {
+ var key = underiveQualifiedKey(e.key);
+ // Use timeout, to avoid using $rootScope.$apply.
+ $timeout(function () {
+ $rootScope.$broadcast('LocalStorageModule.notification.changed', { key: key, newvalue: e.newValue, storageType: self.storageType });
+ });
+ }
+ }
+ }
+
+ // Return localStorageService.length
+ // ignore keys that not owned
+ var lengthOfLocalStorage = function(type) {
+ var previousType = getStorageType();
+
+ try {
+ setStorageType(type);
+
+ var count = 0;
+ var storage = $window[storageType];
+ for(var i = 0; i < storage.length; i++) {
+ if(storage.key(i).indexOf(prefix) === 0 ) {
+ count++;
+ }
+ }
+
+ return count;
+ } finally {
+ setStorageType(previousType);
+ }
+ };
+
+ var changePrefix = function(localStoragePrefix) {
+ prefix = localStoragePrefix;
+ };
+
+ return {
+ isSupported: browserSupportsLocalStorage,
+ getStorageType: getStorageType,
+ setStorageType: setStorageType,
+ setPrefix: changePrefix,
+ set: addToLocalStorage,
+ add: addToLocalStorage, //DEPRECATED
+ get: getFromLocalStorage,
+ keys: getKeysForLocalStorage,
+ remove: removeFromLocalStorage,
+ clearAll: clearAllFromLocalStorage,
+ bind: bindToScope,
+ deriveKey: deriveQualifiedKey,
+ underiveKey: underiveQualifiedKey,
+ length: lengthOfLocalStorage,
+ defaultToCookie: this.defaultToCookie,
+ cookie: {
+ isSupported: browserSupportsCookies,
+ set: addToCookies,
+ add: addToCookies, //DEPRECATED
+ get: getFromCookies,
+ remove: removeFromCookies,
+ clearAll: clearAllFromCookies
+ }
+ };
+ }];
+ });
+})(window, window.angular);
+
+/***/ }),
+
+/***/ "./node_modules/angular-local-storage/index.js":
+/*!*****************************************************!*\
+ !*** ./node_modules/angular-local-storage/index.js ***!
+ \*****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+__webpack_require__(/*! ./dist/angular-local-storage.js */ "./node_modules/angular-local-storage/dist/angular-local-storage.js");
+module.exports = 'LocalStorageModule';
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-material/angular-material.js":
+/*!***********************************************************!*\
+ !*** ./node_modules/angular-material/angular-material.js ***!
+ \***********************************************************/
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+/* provided dependency */ var __webpack_provided_window_dot_jQuery = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js");
+/*!
+ * AngularJS Material Design
+ * https://github.com/angular/material
+ * @license MIT
+ * v1.2.3
+ */
+(function( window, angular, undefined ){
+"use strict";
+
+(function(){
+"use strict";
+
+angular.module('ngMaterial', ["ng","ngAnimate","ngAria","material.core","material.core.animate","material.core.gestures","material.core.interaction","material.core.layout","material.core.meta","material.core.theming.palette","material.core.theming","material.components.autocomplete","material.components.backdrop","material.components.bottomSheet","material.components.button","material.components.card","material.components.checkbox","material.components.chips","material.components.colors","material.components.content","material.components.datepicker","material.components.dialog","material.components.divider","material.components.fabActions","material.components.fabShared","material.components.fabSpeedDial","material.components.fabToolbar","material.components.gridList","material.components.icon","material.components.input","material.components.list","material.components.menu","material.components.menuBar","material.components.navBar","material.components.panel","material.components.progressCircular","material.components.progressLinear","material.components.radioButton","material.components.select","material.components.showHide","material.components.sidenav","material.components.slider","material.components.sticky","material.components.subheader","material.components.swipe","material.components.switch","material.components.tabs","material.components.toast","material.components.toolbar","material.components.tooltip","material.components.truncate","material.components.virtualRepeat","material.components.whiteframe"]);
+})();
+(function(){
+"use strict";
+
+/**
+ * Initialization function that validates environment
+ * requirements.
+ */
+DetectNgTouch.$inject = ["$log", "$injector"];
+MdCoreConfigure.$inject = ["$provide", "$mdThemingProvider"];
+rAFDecorator.$inject = ["$delegate"];
+qDecorator.$inject = ["$delegate"];
+angular
+ .module('material.core', [
+ 'ngAnimate',
+ 'material.core.animate',
+ 'material.core.layout',
+ 'material.core.interaction',
+ 'material.core.gestures',
+ 'material.core.theming'
+ ])
+ .config(MdCoreConfigure)
+ .run(DetectNgTouch);
+
+
+/**
+ * Detect if the ng-Touch module is also being used.
+ * Warn if detected.
+ * @ngInject
+ */
+function DetectNgTouch($log, $injector) {
+ if ($injector.has('$swipe')) {
+ var msg = "" +
+ "You are using the ngTouch module. \n" +
+ "AngularJS Material already has mobile click, tap, and swipe support... \n" +
+ "ngTouch is not supported with AngularJS Material!";
+ $log.warn(msg);
+ }
+}
+
+/**
+ * @ngInject
+ */
+function MdCoreConfigure($provide, $mdThemingProvider) {
+
+ $provide.decorator('$$rAF', ['$delegate', rAFDecorator]);
+ $provide.decorator('$q', ['$delegate', qDecorator]);
+
+ $mdThemingProvider.theme('default')
+ .primaryPalette('indigo')
+ .accentPalette('pink')
+ .warnPalette('deep-orange')
+ .backgroundPalette('grey');
+}
+
+/**
+ * @ngInject
+ */
+function rAFDecorator($delegate) {
+ /**
+ * Use this to throttle events that come in often.
+ * The throttled function will always use the *last* invocation before the
+ * coming frame.
+ *
+ * For example, window resize events that fire many times a second:
+ * If we set to use an raf-throttled callback on window resize, then
+ * our callback will only be fired once per frame, with the last resize
+ * event that happened before that frame.
+ *
+ * @param {function} cb function to debounce
+ */
+ $delegate.throttle = function(cb) {
+ var queuedArgs, alreadyQueued, queueCb, context;
+ return function debounced() {
+ queuedArgs = arguments;
+ context = this;
+ queueCb = cb;
+ if (!alreadyQueued) {
+ alreadyQueued = true;
+ $delegate(function() {
+ queueCb.apply(context, Array.prototype.slice.call(queuedArgs));
+ alreadyQueued = false;
+ });
+ }
+ };
+ };
+ return $delegate;
+}
+
+/**
+ * @ngInject
+ */
+function qDecorator($delegate) {
+ /**
+ * Adds a shim for $q.resolve for AngularJS version that don't have it,
+ * so we don't have to think about it.
+ *
+ * via https://github.com/angular/angular.js/pull/11987
+ */
+
+ // TODO(crisbeto): this won't be necessary once we drop AngularJS 1.3
+ if (!$delegate.resolve) {
+ $delegate.resolve = $delegate.when;
+ }
+ return $delegate;
+}
+
+})();
+(function(){
+"use strict";
+
+
+MdAutofocusDirective.$inject = ["$parse"];angular.module('material.core')
+ .directive('mdAutofocus', MdAutofocusDirective);
+
+/**
+ * @ngdoc directive
+ * @name mdAutofocus
+ * @module material.core.util
+ *
+ * @description
+ *
+ * `[md-autofocus]` provides an optional way to identify the focused element when a `$mdDialog`,
+ * `$mdBottomSheet`, `$mdMenu` or `$mdSidenav` opens or upon page load for input-like elements.
+ *
+ * When one of these opens, it will find the first nested element with the `[md-autofocus]`
+ * attribute directive and optional expression. An expression may be specified as the directive
+ * value to enable conditional activation of the autofocus.
+ *
+ * @usage
+ *
+ * ### Dialog
+ * <hljs lang="html">
+ * <md-dialog>
+ * <form>
+ * <md-input-container>
+ * <label for="testInput">Label</label>
+ * <input id="testInput" type="text" md-autofocus>
+ * </md-input-container>
+ * </form>
+ * </md-dialog>
+ * </hljs>
+ *
+ * ### Bottomsheet
+ * <hljs lang="html">
+ * <md-bottom-sheet class="md-list md-has-header">
+ * <md-subheader>Comment Actions</md-subheader>
+ * <md-list>
+ * <md-list-item ng-repeat="item in items">
+ *
+ * <md-button md-autofocus="$index == 2">
+ * <md-icon md-svg-src="{{item.icon}}"></md-icon>
+ * <span class="md-inline-list-icon-label">{{ item.name }}</span>
+ * </md-button>
+ *
+ * </md-list-item>
+ * </md-list>
+ * </md-bottom-sheet>
+ * </hljs>
+ *
+ * ### Autocomplete
+ * <hljs lang="html">
+ * <md-autocomplete
+ * md-autofocus
+ * md-selected-item="selectedItem"
+ * md-search-text="searchText"
+ * md-items="item in getMatches(searchText)"
+ * md-item-text="item.display">
+ * <span md-highlight-text="searchText">{{item.display}}</span>
+ * </md-autocomplete>
+ * </hljs>
+ *
+ * ### Sidenav
+ * <hljs lang="html">
+ * <div layout="row" ng-controller="MyController">
+ * <md-sidenav md-component-id="left" class="md-sidenav-left">
+ * Left Nav!
+ * </md-sidenav>
+ *
+ * <md-content>
+ * Center Content
+ * <md-button ng-click="openLeftMenu()">
+ * Open Left Menu
+ * </md-button>
+ * </md-content>
+ *
+ * <md-sidenav md-component-id="right"
+ * md-is-locked-open="$mdMedia('min-width: 333px')"
+ * class="md-sidenav-right">
+ * <form>
+ * <md-input-container>
+ * <label for="testInput">Test input</label>
+ * <input id="testInput" type="text"
+ * ng-model="data" md-autofocus>
+ * </md-input-container>
+ * </form>
+ * </md-sidenav>
+ * </div>
+ * </hljs>
+ **/
+function MdAutofocusDirective($parse) {
+ return {
+ restrict: 'A',
+ link: {
+ pre: preLink
+ }
+ };
+
+ function preLink(scope, element, attr) {
+ var attrExp = attr.mdAutoFocus || attr.mdAutofocus || attr.mdSidenavFocus;
+
+ // Initially update the expression by manually parsing the expression as per $watch source.
+ updateExpression($parse(attrExp)(scope));
+
+ // Only watch the expression if it is not empty.
+ if (attrExp) {
+ scope.$watch(attrExp, updateExpression);
+ }
+
+ /**
+ * Updates the autofocus class which is used to determine whether the attribute
+ * expression evaluates to true or false.
+ * @param {string|boolean} value Attribute Value
+ */
+ function updateExpression(value) {
+
+ // Rather than passing undefined to the jqLite toggle class function we explicitly set the
+ // value to true. Otherwise the class will be just toggled instead of being forced.
+ if (angular.isUndefined(value)) {
+ value = true;
+ }
+
+ element.toggleClass('md-autofocus', !!value);
+ }
+ }
+
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.core.colorUtil
+ * @description
+ * Color Util
+ */
+angular
+ .module('material.core')
+ .factory('$mdColorUtil', ColorUtilFactory);
+
+function ColorUtilFactory() {
+ /**
+ * Converts hex value to RGBA string
+ * @param color {string}
+ * @returns {string}
+ */
+ function hexToRgba (color) {
+ var hex = color[ 0 ] === '#' ? color.substr(1) : color,
+ dig = hex.length / 3,
+ red = hex.substr(0, dig),
+ green = hex.substr(dig, dig),
+ blue = hex.substr(dig * 2);
+ if (dig === 1) {
+ red += red;
+ green += green;
+ blue += blue;
+ }
+ return 'rgba(' + parseInt(red, 16) + ',' + parseInt(green, 16) + ',' + parseInt(blue, 16) + ',0.1)';
+ }
+
+ /**
+ * Converts rgba value to hex string
+ * @param {string} color
+ * @returns {string}
+ */
+ function rgbaToHex(color) {
+ color = color.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);
+
+ var hex = (color && color.length === 4) ? "#" +
+ ("0" + parseInt(color[1],10).toString(16)).slice(-2) +
+ ("0" + parseInt(color[2],10).toString(16)).slice(-2) +
+ ("0" + parseInt(color[3],10).toString(16)).slice(-2) : '';
+
+ return hex.toUpperCase();
+ }
+
+ /**
+ * Converts an RGB color to RGBA
+ * @param {string} color
+ * @returns {string}
+ */
+ function rgbToRgba (color) {
+ return color.replace(')', ', 0.1)').replace('(', 'a(');
+ }
+
+ /**
+ * Converts an RGBA color to RGB
+ * @param {string} color
+ * @returns {string}
+ */
+ function rgbaToRgb (color) {
+ return color
+ ? color.replace('rgba', 'rgb').replace(/,[^),]+\)/, ')')
+ : 'rgb(0,0,0)';
+ }
+
+ return {
+ rgbaToHex: rgbaToHex,
+ hexToRgba: hexToRgba,
+ rgbToRgba: rgbToRgba,
+ rgbaToRgb: rgbaToRgb
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+angular.module('material.core')
+.factory('$mdConstant', MdConstantFactory);
+
+/**
+ * Factory function that creates the grab-bag $mdConstant service.
+ * @ngInject
+ */
+function MdConstantFactory() {
+
+ var prefixTestEl = document.createElement('div');
+ var vendorPrefix = getVendorPrefix(prefixTestEl);
+ var isWebkit = /webkit/i.test(vendorPrefix);
+ var SPECIAL_CHARS_REGEXP = /([:\-_]+(.))/g;
+
+ /**
+ * @param {string} name CSS property name
+ * @return {string} the property name supported by the browser
+ */
+ function vendorProperty(name) {
+ // Add a dash between the prefix and name, to be able to transform the string into camelcase.
+ var prefixedName = vendorPrefix + '-' + name;
+ var ucPrefix = camelCase(prefixedName);
+ var lcPrefix = ucPrefix.charAt(0).toLowerCase() + ucPrefix.substring(1);
+
+ return hasStyleProperty(prefixTestEl, name) ? name : // The current browser supports the un-prefixed property
+ hasStyleProperty(prefixTestEl, ucPrefix) ? ucPrefix : // The current browser only supports the prefixed property.
+ hasStyleProperty(prefixTestEl, lcPrefix) ? lcPrefix : name; // Some browsers are only supporting the prefix in lowercase.
+ }
+
+ function hasStyleProperty(testElement, property) {
+ return angular.isDefined(testElement.style[property]);
+ }
+
+ /**
+ * @param {!string} input value to convert to camelCase
+ * @return {string} camelCased version of the input string
+ */
+ function camelCase(input) {
+ return input.replace(SPECIAL_CHARS_REGEXP, function(matches, separator, letter, offset) {
+ return offset ? letter.toUpperCase() : letter;
+ });
+ }
+
+ function getVendorPrefix(testElement) {
+ var prop, match;
+ var vendorRegex = /^(Moz|webkit|ms)(?=[A-Z])/;
+
+ for (prop in testElement.style) {
+ if (match = vendorRegex.exec(prop)) {
+ return match[0];
+ }
+ }
+ }
+
+ var self = {
+ isInputKey : function(e) { return (e.keyCode >= 31 && e.keyCode <= 90); },
+ isNumPadKey : function(e) { return (3 === e.location && e.keyCode >= 97 && e.keyCode <= 105); },
+ isMetaKey: function(e) { return (e.keyCode >= 91 && e.keyCode <= 93); },
+ isFnLockKey: function(e) { return (e.keyCode >= 112 && e.keyCode <= 145); },
+ isNavigationKey : function(e) {
+ var kc = self.KEY_CODE, NAVIGATION_KEYS = [kc.SPACE, kc.ENTER, kc.UP_ARROW, kc.DOWN_ARROW];
+ return (NAVIGATION_KEYS.indexOf(e.keyCode) != -1);
+ },
+ hasModifierKey: function(e) {
+ return e.ctrlKey || e.metaKey || e.altKey;
+ },
+
+ /**
+ * Maximum size, in pixels, that can be explicitly set to an element. The actual value varies
+ * between browsers, but IE11 has the very lowest size at a mere 1,533,917px. Ideally we could
+ * compute this value, but Firefox always reports an element to have a size of zero if it
+ * goes over the max, meaning that we'd have to binary search for the value.
+ */
+ ELEMENT_MAX_PIXELS: 1533917,
+
+ /**
+ * Priority for a directive that should run before the directives from ngAria.
+ */
+ BEFORE_NG_ARIA: 210,
+
+ /**
+ * Common Keyboard actions and their associated keycode.
+ */
+ KEY_CODE: {
+ COMMA: 188,
+ SEMICOLON : 186,
+ ENTER: 13,
+ ESCAPE: 27,
+ SPACE: 32,
+ PAGE_UP: 33,
+ PAGE_DOWN: 34,
+ END: 35,
+ HOME: 36,
+ LEFT_ARROW : 37,
+ UP_ARROW : 38,
+ RIGHT_ARROW : 39,
+ DOWN_ARROW : 40,
+ TAB : 9,
+ BACKSPACE: 8,
+ DELETE: 46
+ },
+
+ /**
+ * Vendor prefixed CSS properties to be used to support the given functionality in older browsers
+ * as well.
+ */
+ CSS: {
+ /* Constants */
+ TRANSITIONEND: 'transitionend' + (isWebkit ? ' webkitTransitionEnd' : ''),
+ ANIMATIONEND: 'animationend' + (isWebkit ? ' webkitAnimationEnd' : ''),
+
+ TRANSFORM: vendorProperty('transform'),
+ TRANSFORM_ORIGIN: vendorProperty('transformOrigin'),
+ TRANSITION: vendorProperty('transition'),
+ TRANSITION_DURATION: vendorProperty('transitionDuration'),
+ ANIMATION_PLAY_STATE: vendorProperty('animationPlayState'),
+ ANIMATION_DURATION: vendorProperty('animationDuration'),
+ ANIMATION_NAME: vendorProperty('animationName'),
+ ANIMATION_TIMING: vendorProperty('animationTimingFunction'),
+ ANIMATION_DIRECTION: vendorProperty('animationDirection')
+ },
+
+ /**
+ * As defined in core/style/_variables.scss
+ *
+ * $layout-breakpoint-xs: 600px !default;
+ * $layout-breakpoint-sm: 960px !default;
+ * $layout-breakpoint-md: 1280px !default;
+ * $layout-breakpoint-lg: 1920px !default;
+ *
+ */
+ MEDIA: {
+ 'xs' : '(max-width: 599px)' ,
+ 'gt-xs' : '(min-width: 600px)' ,
+ 'sm' : '(min-width: 600px) and (max-width: 959px)' ,
+ 'gt-sm' : '(min-width: 960px)' ,
+ 'md' : '(min-width: 960px) and (max-width: 1279px)' ,
+ 'gt-md' : '(min-width: 1280px)' ,
+ 'lg' : '(min-width: 1280px) and (max-width: 1919px)',
+ 'gt-lg' : '(min-width: 1920px)' ,
+ 'xl' : '(min-width: 1920px)' ,
+ 'landscape' : '(orientation: landscape)' ,
+ 'portrait' : '(orientation: portrait)' ,
+ 'print' : 'print'
+ },
+
+ MEDIA_PRIORITY: [
+ 'xl',
+ 'gt-lg',
+ 'lg',
+ 'gt-md',
+ 'md',
+ 'gt-sm',
+ 'sm',
+ 'gt-xs',
+ 'xs',
+ 'landscape',
+ 'portrait',
+ 'print'
+ ]
+ };
+
+ return self;
+}
+
+})();
+(function(){
+"use strict";
+
+ angular
+ .module('material.core')
+ .config(["$provide", function($provide){
+ $provide.decorator('$mdUtil', ['$delegate', function ($delegate){
+ /**
+ * Inject the iterator facade to easily support iteration and accessors
+ * @see iterator below
+ */
+ $delegate.iterator = MdIterator;
+
+ return $delegate;
+ }
+ ]);
+ }]);
+
+ /**
+ * iterator is a list facade to easily support iteration and accessors/
+ *
+ * @param {any[]} items Array list which this iterator will enumerate
+ * @param {boolean=} reloop enables iterator to consider the list as an endless loop
+ * @return {{add: add, next: (function()), last: (function(): any|null), previous: (function()), count: (function(): number), hasNext: (function(*=): Array.length|*|number|boolean), inRange: (function(*): boolean), remove: remove, contains: (function(*=): *|boolean), itemAt: (function(*=): any|null), findBy: (function(*, *): *[]), hasPrevious: (function(*=): Array.length|*|number|boolean), items: (function(): *[]), indexOf: (function(*=): number), first: (function(): any|null)}}
+ * @constructor
+ */
+ function MdIterator(items, reloop) {
+ var trueFn = function() { return true; };
+
+ if (items && !angular.isArray(items)) {
+ items = Array.prototype.slice.call(items);
+ }
+
+ reloop = !!reloop;
+ var _items = items || [];
+
+ // Published API
+ return {
+ items: getItems,
+ count: count,
+
+ inRange: inRange,
+ contains: contains,
+ indexOf: indexOf,
+ itemAt: itemAt,
+
+ findBy: findBy,
+
+ add: add,
+ remove: remove,
+
+ first: first,
+ last: last,
+ next: angular.bind(null, findSubsequentItem, false),
+ previous: angular.bind(null, findSubsequentItem, true),
+
+ hasPrevious: hasPrevious,
+ hasNext: hasNext
+ };
+
+ /**
+ * Publish copy of the enumerable set
+ * @returns {Array|*}
+ */
+ function getItems() {
+ return [].concat(_items);
+ }
+
+ /**
+ * Determine length of the list
+ * @returns {Array.length|*|number}
+ */
+ function count() {
+ return _items.length;
+ }
+
+ /**
+ * Is the index specified valid
+ * @param index
+ * @returns {Array.length|*|number|boolean}
+ */
+ function inRange(index) {
+ return _items.length && (index > -1) && (index < _items.length);
+ }
+
+ /**
+ * Can the iterator proceed to the next item in the list; relative to
+ * the specified item.
+ *
+ * @param item
+ * @returns {Array.length|*|number|boolean}
+ */
+ function hasNext(item) {
+ return item ? inRange(indexOf(item) + 1) : false;
+ }
+
+ /**
+ * Can the iterator proceed to the previous item in the list; relative to
+ * the specified item.
+ *
+ * @param item
+ * @returns {Array.length|*|number|boolean}
+ */
+ function hasPrevious(item) {
+ return item ? inRange(indexOf(item) - 1) : false;
+ }
+
+ /**
+ * Get item at specified index/position
+ * @param index
+ * @returns {*}
+ */
+ function itemAt(index) {
+ return inRange(index) ? _items[index] : null;
+ }
+
+ /**
+ * Find all elements matching the key/value pair
+ * otherwise return null
+ *
+ * @param val
+ * @param key
+ *
+ * @return array
+ */
+ function findBy(key, val) {
+ return _items.filter(function(item) {
+ return item[key] === val;
+ });
+ }
+
+ /**
+ * Add item to list
+ * @param item
+ * @param index
+ * @returns {*}
+ */
+ function add(item, index) {
+ if (!item) return -1;
+
+ if (!angular.isNumber(index)) {
+ index = _items.length;
+ }
+
+ _items.splice(index, 0, item);
+
+ return indexOf(item);
+ }
+
+ /**
+ * Remove item from list...
+ * @param item
+ */
+ function remove(item) {
+ if (contains(item)){
+ _items.splice(indexOf(item), 1);
+ }
+ }
+
+ /**
+ * Get the zero-based index of the target item
+ * @param item
+ * @returns {*}
+ */
+ function indexOf(item) {
+ return _items.indexOf(item);
+ }
+
+ /**
+ * Boolean existence check
+ * @param item
+ * @returns {boolean}
+ */
+ function contains(item) {
+ return item && (indexOf(item) > -1);
+ }
+
+ /**
+ * Return first item in the list
+ * @returns {*}
+ */
+ function first() {
+ return _items.length ? _items[0] : null;
+ }
+
+ /**
+ * Return last item in the list...
+ * @returns {*}
+ */
+ function last() {
+ return _items.length ? _items[_items.length - 1] : null;
+ }
+
+ /**
+ * Find the next item. If reloop is true and at the end of the list, it will go back to the
+ * first item. If given, the `validate` callback will be used to determine whether the next item
+ * is valid. If not valid, it will try to find the next item again.
+ *
+ * @param {boolean} backwards Specifies the direction of searching (forwards/backwards)
+ * @param {*} item The item whose subsequent item we are looking for
+ * @param {Function=} validate The `validate` function
+ * @param {integer=} limit The recursion limit
+ *
+ * @returns {*} The subsequent item or null
+ */
+ function findSubsequentItem(backwards, item, validate, limit) {
+ validate = validate || trueFn;
+
+ var curIndex = indexOf(item);
+ while (true) {
+ if (!inRange(curIndex)) return null;
+
+ var nextIndex = curIndex + (backwards ? -1 : 1);
+ var foundItem = null;
+ if (inRange(nextIndex)) {
+ foundItem = _items[nextIndex];
+ } else if (reloop) {
+ foundItem = backwards ? last() : first();
+ nextIndex = indexOf(foundItem);
+ }
+
+ if ((foundItem === null) || (nextIndex === limit)) return null;
+ if (validate(foundItem)) return foundItem;
+
+ if (angular.isUndefined(limit)) limit = nextIndex;
+
+ curIndex = nextIndex;
+ }
+ }
+ }
+
+
+})();
+(function(){
+"use strict";
+
+
+mdMediaFactory.$inject = ["$mdConstant", "$rootScope", "$window"];angular.module('material.core')
+.factory('$mdMedia', mdMediaFactory);
+
+/**
+ * @ngdoc service
+ * @name $mdMedia
+ * @module material.core
+ *
+ * @description
+ * `$mdMedia` is used to evaluate whether a given media query is true or false given the
+ * current device's screen / window size. The media query will be re-evaluated on resize, allowing
+ * you to register a watch.
+ *
+ * `$mdMedia` also has pre-programmed support for media queries that match the layout breakpoints:
+ *
+ * <table class="md-api-table">
+ * <thead>
+ * <tr>
+ * <th>Breakpoint</th>
+ * <th>mediaQuery</th>
+ * </tr>
+ * </thead>
+ * <tbody>
+ * <tr>
+ * <td>xs</td>
+ * <td>(max-width: 599px)</td>
+ * </tr>
+ * <tr>
+ * <td>gt-xs</td>
+ * <td>(min-width: 600px)</td>
+ * </tr>
+ * <tr>
+ * <td>sm</td>
+ * <td>(min-width: 600px) and (max-width: 959px)</td>
+ * </tr>
+ * <tr>
+ * <td>gt-sm</td>
+ * <td>(min-width: 960px)</td>
+ * </tr>
+ * <tr>
+ * <td>md</td>
+ * <td>(min-width: 960px) and (max-width: 1279px)</td>
+ * </tr>
+ * <tr>
+ * <td>gt-md</td>
+ * <td>(min-width: 1280px)</td>
+ * </tr>
+ * <tr>
+ * <td>lg</td>
+ * <td>(min-width: 1280px) and (max-width: 1919px)</td>
+ * </tr>
+ * <tr>
+ * <td>gt-lg</td>
+ * <td>(min-width: 1920px)</td>
+ * </tr>
+ * <tr>
+ * <td>xl</td>
+ * <td>(min-width: 1920px)</td>
+ * </tr>
+ * <tr>
+ * <td>landscape</td>
+ * <td>landscape</td>
+ * </tr>
+ * <tr>
+ * <td>portrait</td>
+ * <td>portrait</td>
+ * </tr>
+ * <tr>
+ * <td>print</td>
+ * <td>print</td>
+ * </tr>
+ * </tbody>
+ * </table>
+ *
+ * See Material Design's <a href="https://material.google.com/layout/responsive-ui.html">Layout - Adaptive UI</a> for more details.
+ *
+ * <a href="https://material.io/archive/guidelines/layout/responsive-ui.html#">
+ * <img src="https://material-design.storage.googleapis.com/publish/material_v_4/material_ext_publish/0B8olV15J7abPSGFxemFiQVRtb1k/layout_adaptive_breakpoints_01.png" width="100%" height="100%"></img>
+ * </a>
+ *
+ * @returns {boolean} a boolean representing whether or not the given media query is true or false.
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.controller('MyController', function($mdMedia, $scope) {
+ * $scope.$watch(function() { return $mdMedia('lg'); }, function(big) {
+ * $scope.bigScreen = big;
+ * });
+ *
+ * $scope.screenIsSmall = $mdMedia('sm');
+ * $scope.customQuery = $mdMedia('(min-width: 1234px)');
+ * $scope.anotherCustom = $mdMedia('max-width: 300px');
+ * });
+ * </hljs>
+ */
+
+/* @ngInject */
+function mdMediaFactory($mdConstant, $rootScope, $window) {
+ var queries = {};
+ var mqls = {};
+ var results = {};
+ var normalizeCache = {};
+
+ $mdMedia.getResponsiveAttribute = getResponsiveAttribute;
+ $mdMedia.getQuery = getQuery;
+ $mdMedia.watchResponsiveAttributes = watchResponsiveAttributes;
+
+ return $mdMedia;
+
+ function $mdMedia(query) {
+ var validated = queries[query];
+ if (angular.isUndefined(validated)) {
+ validated = queries[query] = validate(query);
+ }
+
+ var result = results[validated];
+ if (angular.isUndefined(result)) {
+ result = add(validated);
+ }
+
+ return result;
+ }
+
+ function validate(query) {
+ return $mdConstant.MEDIA[query] ||
+ ((query.charAt(0) !== '(') ? ('(' + query + ')') : query);
+ }
+
+ function add(query) {
+ var result = mqls[query];
+ if (!result) {
+ result = mqls[query] = $window.matchMedia(query);
+ }
+
+ result.addListener(onQueryChange);
+ return (results[result.media] = !!result.matches);
+ }
+
+ function onQueryChange(query) {
+ $rootScope.$evalAsync(function() {
+ results[query.media] = !!query.matches;
+ });
+ }
+
+ function getQuery(name) {
+ return mqls[name];
+ }
+
+ function getResponsiveAttribute(attrs, attrName) {
+ for (var i = 0; i < $mdConstant.MEDIA_PRIORITY.length; i++) {
+ var mediaName = $mdConstant.MEDIA_PRIORITY[i];
+ if (!mqls[queries[mediaName]].matches) {
+ continue;
+ }
+
+ var normalizedName = getNormalizedName(attrs, attrName + '-' + mediaName);
+ if (attrs[normalizedName]) {
+ return attrs[normalizedName];
+ }
+ }
+
+ // fallback on unprefixed
+ return attrs[getNormalizedName(attrs, attrName)];
+ }
+
+ function watchResponsiveAttributes(attrNames, attrs, watchFn) {
+ var unwatchFns = [];
+ attrNames.forEach(function(attrName) {
+ var normalizedName = getNormalizedName(attrs, attrName);
+ if (angular.isDefined(attrs[normalizedName])) {
+ unwatchFns.push(
+ attrs.$observe(normalizedName, angular.bind(void 0, watchFn, null)));
+ }
+
+ for (var mediaName in $mdConstant.MEDIA) {
+ normalizedName = getNormalizedName(attrs, attrName + '-' + mediaName);
+ if (angular.isDefined(attrs[normalizedName])) {
+ unwatchFns.push(
+ attrs.$observe(normalizedName, angular.bind(void 0, watchFn, mediaName)));
+ }
+ }
+ });
+
+ return function unwatch() {
+ unwatchFns.forEach(function(fn) { fn(); });
+ };
+ }
+
+ // Improves performance dramatically
+ function getNormalizedName(attrs, attrName) {
+ return normalizeCache[attrName] ||
+ (normalizeCache[attrName] = attrs.$normalize(attrName));
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+angular
+ .module('material.core')
+ .config(["$provide", function($provide) {
+ $provide.decorator('$mdUtil', ['$delegate', function ($delegate) {
+
+ // Inject the prefixer into our original $mdUtil service.
+ $delegate.prefixer = MdPrefixer;
+
+ return $delegate;
+ }]);
+ }]);
+
+/**
+ * @param {string|string[]} initialAttributes
+ * @param {boolean} buildSelector
+ * @return {string|string[]|{buildSelector: (function(string|string[]): string),
+ * buildList: (function(string|string[]): string[]),
+ * hasAttribute: (function(JQLite|Element, string): HTMLElement),
+ * removeAttribute: (function(JQLite|Element, string): void)}}
+ * @constructor
+ */
+function MdPrefixer(initialAttributes, buildSelector) {
+ var PREFIXES = ['data', 'x'];
+
+ if (initialAttributes) {
+ // The prefixer also accepts attributes as a parameter, and immediately builds a list or selector for
+ // the specified attributes.
+ return buildSelector ? _buildSelector(initialAttributes) : _buildList(initialAttributes);
+ }
+
+ return {
+ buildList: _buildList,
+ buildSelector: _buildSelector,
+ hasAttribute: _hasAttribute,
+ removeAttribute: _removeAttribute
+ };
+
+ function _buildList(attributes) {
+ attributes = angular.isArray(attributes) ? attributes : [attributes];
+
+ attributes.forEach(function(item) {
+ PREFIXES.forEach(function(prefix) {
+ attributes.push(prefix + '-' + item);
+ });
+ });
+
+ return attributes;
+ }
+
+ function _buildSelector(attributes) {
+ attributes = angular.isArray(attributes) ? attributes : [attributes];
+
+ return _buildList(attributes)
+ .map(function(item) {
+ return '[' + item + ']';
+ })
+ .join(',');
+ }
+
+ function _hasAttribute(element, attribute) {
+ element = _getNativeElement(element);
+
+ if (!element) {
+ return false;
+ }
+
+ var prefixedAttrs = _buildList(attribute);
+
+ for (var i = 0; i < prefixedAttrs.length; i++) {
+ if (element.hasAttribute(prefixedAttrs[i])) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function _removeAttribute(element, attribute) {
+ element = _getNativeElement(element);
+
+ if (!element) {
+ return;
+ }
+
+ _buildList(attribute).forEach(function(prefixedAttribute) {
+ element.removeAttribute(prefixedAttribute);
+ });
+ }
+
+ /**
+ * Transforms a jqLite or DOM element into a HTML element.
+ * This is useful when supporting jqLite elements and DOM elements at
+ * same time.
+ * @param element {JQLite|Element} Element to be parsed
+ * @returns {HTMLElement} Parsed HTMLElement
+ */
+ function _getNativeElement(element) {
+ element = element[0] || element;
+
+ if (element.nodeType) {
+ return element;
+ }
+ }
+
+}
+
+})();
+(function(){
+"use strict";
+
+/*
+ * This var has to be outside the angular factory, otherwise when
+ * there are multiple material apps on the same page, each app
+ * will create its own instance of this array and the app's IDs
+ * will not be unique.
+ */
+UtilFactory.$inject = ["$document", "$timeout", "$compile", "$rootScope", "$$mdAnimate", "$interpolate", "$log", "$rootElement", "$window", "$$rAF"];
+var nextUniqueId = 0, isIos, isAndroid, isFirefox;
+
+// Support material-tools builds.
+if (window.navigator) {
+ var userAgent = window.navigator.userAgent || window.navigator.vendor || window.opera;
+ isIos = userAgent.match(/ipad|iphone|ipod/i);
+ isAndroid = userAgent.match(/android/i);
+ isFirefox = userAgent.match(/(firefox|minefield)/i);
+}
+
+/**
+ * @ngdoc module
+ * @name material.core.util
+ * @description
+ * Util
+ */
+angular
+.module('material.core')
+.factory('$mdUtil', UtilFactory);
+
+/**
+ * @ngInject
+ */
+function UtilFactory($document, $timeout, $compile, $rootScope, $$mdAnimate, $interpolate, $log,
+ $rootElement, $window, $$rAF) {
+ // Setup some core variables for the processTemplate method
+ var startSymbol = $interpolate.startSymbol(),
+ endSymbol = $interpolate.endSymbol(),
+ usesStandardSymbols = ((startSymbol === '{{') && (endSymbol === '}}'));
+
+ // Polyfill document.contains for IE11.
+ document.contains || (document.contains = function (node) {
+ return document.body.contains(node);
+ });
+
+ /**
+ * Checks if the target element has the requested style by key
+ * @param {DOMElement|JQLite} target Target element
+ * @param {string} key Style key
+ * @param {string=} expectedVal Optional expected value
+ * @returns {boolean} Whether the target element has the style or not
+ */
+ var hasComputedStyle = function (target, key, expectedVal) {
+ var hasValue = false;
+
+ if (target && target.length) {
+ var computedStyles = $window.getComputedStyle(target[0]);
+ hasValue = angular.isDefined(computedStyles[key]) &&
+ (expectedVal ? computedStyles[key] == expectedVal : true);
+ }
+
+ return hasValue;
+ };
+
+ function validateCssValue(value) {
+ return !value ? '0' :
+ hasPx(value) || hasPercent(value) ? value : value + 'px';
+ }
+
+ function hasPx(value) {
+ return String(value).indexOf('px') > -1;
+ }
+
+ function hasPercent(value) {
+ return String(value).indexOf('%') > -1;
+ }
+
+ var $mdUtil = {
+ dom: {},
+ isIos: isIos,
+ isAndroid: isAndroid,
+ now: window.performance && window.performance.now ?
+ angular.bind(window.performance, window.performance.now) : Date.now || function() {
+ return new Date().getTime();
+ },
+
+ /**
+ * Cross-version compatibility method to retrieve an option of a ngModel controller,
+ * which supports the breaking changes in the AngularJS snapshot (SHA 87a2ff76af5d0a9268d8eb84db5755077d27c84c).
+ * @param {!ngModel.NgModelController} ngModelCtrl
+ * @param {!string} optionName
+ * @returns {string|number|boolean|Object|undefined}
+ */
+ getModelOption: function (ngModelCtrl, optionName) {
+ if (!ngModelCtrl.$options) {
+ return;
+ }
+
+ var $options = ngModelCtrl.$options;
+
+ // The newer versions of AngularJS introduced a getOption function and made the option values
+ // no longer visible on the $options object.
+ return $options.getOption ? $options.getOption(optionName) : $options[optionName];
+ },
+
+ /**
+ * Determines the current 'dir'ectional value based on the value of 'dir'
+ * attribute of the element. If that is not defined, it will try to use
+ * a 'dir' attribute of the body or html tag.
+ *
+ * @param {Object=} attrs a hash object with key-value pairs of normalized
+ * attribute names and their corresponding attribute values.
+ * @returns {boolean} true if the element's passed in attributes,
+ * the document, or the body indicates RTL mode, false otherwise.
+ */
+ isRtl: function(attrs) {
+ var dir = angular.isDefined(attrs) && attrs.hasOwnProperty('dir') && attrs.dir;
+
+ switch (dir) {
+ case 'ltr':
+ return false;
+
+ case 'rtl':
+ return true;
+ }
+
+ return ($document[0].dir === 'rtl' || $document[0].body.dir === 'rtl');
+ },
+
+ /**
+ * Bi-directional accessor/mutator used to easily update an element's
+ * property based on the current 'dir'ectional value.
+ */
+ bidi: function(element, property, lValue, rValue) {
+ var ltr = !this.isRtl();
+
+ // If accessor
+ if (arguments.length == 0) return ltr ? 'ltr' : 'rtl';
+
+ // If mutator
+ var elem = angular.element(element);
+
+ if (ltr && angular.isDefined(lValue)) {
+ elem.css(property, validateCssValue(lValue));
+ }
+ else if (!ltr && angular.isDefined(rValue)) {
+ elem.css(property, validateCssValue(rValue));
+ }
+ },
+
+ bidiProperty: function (element, lProperty, rProperty, value) {
+ var ltr = !this.isRtl();
+
+ var elem = angular.element(element);
+
+ if (ltr && angular.isDefined(lProperty)) {
+ elem.css(lProperty, validateCssValue(value));
+ elem.css(rProperty, '');
+ }
+ else if (!ltr && angular.isDefined(rProperty)) {
+ elem.css(rProperty, validateCssValue(value));
+ elem.css(lProperty, '');
+ }
+ },
+
+ clientRect: function(element, offsetParent, isOffsetRect) {
+ var node = getNode(element);
+ offsetParent = getNode(offsetParent || node.offsetParent || document.body);
+ var nodeRect = node.getBoundingClientRect();
+
+ // The user can ask for an offsetRect: a rect relative to the offsetParent,
+ // or a clientRect: a rect relative to the page
+ var offsetRect = isOffsetRect ?
+ offsetParent.getBoundingClientRect() :
+ {left: 0, top: 0, width: 0, height: 0};
+ return {
+ left: nodeRect.left - offsetRect.left,
+ top: nodeRect.top - offsetRect.top,
+ width: nodeRect.width,
+ height: nodeRect.height
+ };
+ },
+ offsetRect: function(element, offsetParent) {
+ return $mdUtil.clientRect(element, offsetParent, true);
+ },
+
+ /**
+ * Annoying method to copy nodes to an array, thanks to IE.
+ * @param nodes
+ * @return {Array}
+ */
+ nodesToArray: function(nodes) {
+ var results = [], i;
+ nodes = nodes || [];
+
+ for (i = 0; i < nodes.length; ++i) {
+ results.push(nodes.item(i));
+ }
+ return results;
+ },
+
+ /**
+ * Determines the absolute position of the viewport.
+ * Useful when making client rectangles absolute.
+ * @returns {number}
+ */
+ getViewportTop: function() {
+ // If body scrolling is disabled, then use the cached viewport top value, otherwise get it
+ // fresh from the $window.
+ if ($mdUtil.disableScrollAround._count && $mdUtil.disableScrollAround._viewPortTop) {
+ return $mdUtil.disableScrollAround._viewPortTop;
+ } else {
+ return $window.scrollY || $window.pageYOffset || 0;
+ }
+ },
+
+ /**
+ * Finds the proper focus target by searching the DOM.
+ *
+ * @param {!JQLite} containerEl
+ * @param {string=} attributeVal
+ * @returns {JQLite|undefined}
+ */
+ findFocusTarget: function(containerEl, attributeVal) {
+ var AUTO_FOCUS = this.prefixer('md-autofocus', true);
+ var elToFocus;
+
+ elToFocus = scanForFocusable(containerEl, attributeVal || AUTO_FOCUS);
+
+ // Scan for fallback to 'universal' API
+ if (!elToFocus) {
+ elToFocus = scanForFocusable(containerEl, AUTO_FOCUS);
+ }
+
+ return elToFocus;
+
+ /**
+ * Can target and nested children for specified Selector (attribute)
+ * whose value may be an expression that evaluates to True/False.
+ * @param {!JQLite} target
+ * @param {!string} selector
+ * @return {JQLite|undefined}
+ */
+ function scanForFocusable(target, selector) {
+ var elFound, items = target[0].querySelectorAll(selector);
+
+ // Find the last child element with the focus attribute
+ if (items && items.length) {
+ items.length && angular.forEach(items, function(it) {
+ it = angular.element(it);
+
+ // Check the element for the md-autofocus class to ensure any associated expression
+ // evaluated to true.
+ var isFocusable = it.hasClass('md-autofocus');
+ if (isFocusable) elFound = it;
+ });
+ }
+ return elFound;
+ }
+ },
+
+ /**
+ * Disables scroll around the passed parent element.
+ * @param {Element|JQLite=} element Origin Element (not used)
+ * @param {Element|JQLite=} parent Element to disable scrolling within.
+ * Defaults to body if none supplied.
+ * @param {Object=} options Object of options to modify functionality
+ * - disableScrollMask Boolean of whether or not to create a scroll mask element or
+ * use the passed parent element.
+ */
+ disableScrollAround: function(element, parent, options) {
+ options = options || {};
+
+ $mdUtil.disableScrollAround._count = Math.max(0, $mdUtil.disableScrollAround._count || 0);
+ $mdUtil.disableScrollAround._count++;
+
+ if ($mdUtil.disableScrollAround._restoreScroll) {
+ return $mdUtil.disableScrollAround._restoreScroll;
+ }
+
+ var body = $document[0].body;
+ var restoreBody = disableBodyScroll();
+ var restoreElement = disableElementScroll(parent, options);
+
+ return $mdUtil.disableScrollAround._restoreScroll = function() {
+ if (--$mdUtil.disableScrollAround._count <= 0) {
+ delete $mdUtil.disableScrollAround._viewPortTop;
+ restoreBody();
+ restoreElement();
+ delete $mdUtil.disableScrollAround._restoreScroll;
+ }
+ };
+
+ /**
+ * Creates a virtual scrolling mask to prevent touchmove, keyboard, scrollbar clicking,
+ * and wheel events.
+ * @param {!Element|!JQLite} elementToDisable
+ * @param {Object=} scrollMaskOptions Object of options to modify functionality
+ * - disableScrollMask Boolean of whether or not to create a scroll mask element or
+ * use the passed parent element.
+ * @returns {Function}
+ */
+ function disableElementScroll(elementToDisable, scrollMaskOptions) {
+ var scrollMask;
+ var wrappedElementToDisable = angular.element(elementToDisable || body);
+
+ if (scrollMaskOptions.disableScrollMask) {
+ scrollMask = wrappedElementToDisable;
+ } else {
+ scrollMask = angular.element(
+ '<div class="md-scroll-mask">' +
+ ' <div class="md-scroll-mask-bar"></div>' +
+ '</div>');
+ wrappedElementToDisable.append(scrollMask);
+ }
+
+ /**
+ * @param {Event} $event
+ */
+ function preventDefault($event) {
+ $event.preventDefault();
+ }
+
+ scrollMask.on('wheel touchmove', preventDefault);
+
+ return function restoreElementScroll() {
+ scrollMask.off('wheel touchmove', preventDefault);
+
+ if (!scrollMaskOptions.disableScrollMask && scrollMask[0].parentNode) {
+ scrollMask[0].parentNode.removeChild(scrollMask[0]);
+ }
+ };
+ }
+
+ // Converts the body to a position fixed block and translate it to the proper scroll position
+ function disableBodyScroll() {
+ var documentElement = $document[0].documentElement;
+
+ var prevDocumentStyle = documentElement.style.cssText || '';
+ var prevBodyStyle = body.style.cssText || '';
+
+ var viewportTop = $mdUtil.getViewportTop();
+ $mdUtil.disableScrollAround._viewPortTop = viewportTop;
+ var clientWidth = body.clientWidth;
+ var hasVerticalScrollbar = body.scrollHeight > body.clientHeight + 1;
+
+ // Scroll may be set on <html> element (for example by overflow-y: scroll)
+ // but Chrome is reporting the scrollTop position always on <body>.
+ // scrollElement will allow to restore the scrollTop position to proper target.
+ var scrollElement = documentElement.scrollTop > 0 ? documentElement : body;
+
+ if (hasVerticalScrollbar) {
+ angular.element(body).css({
+ position: 'fixed',
+ width: '100%',
+ top: -viewportTop + 'px'
+ });
+ }
+
+ if (body.clientWidth < clientWidth) {
+ body.style.overflow = 'hidden';
+ }
+
+ return function restoreScroll() {
+ // Reset the inline style CSS to the previous.
+ body.style.cssText = prevBodyStyle;
+ documentElement.style.cssText = prevDocumentStyle;
+
+ // The scroll position while being fixed
+ scrollElement.scrollTop = viewportTop;
+ };
+ }
+
+ },
+
+ enableScrolling: function() {
+ var restoreFn = this.disableScrollAround._restoreScroll;
+ restoreFn && restoreFn();
+ },
+
+ floatingScrollbars: function() {
+ if (this.floatingScrollbars.cached === undefined) {
+ var tempNode = angular.element('<div><div></div></div>').css({
+ width: '100%',
+ 'z-index': -1,
+ position: 'absolute',
+ height: '35px',
+ 'overflow-y': 'scroll'
+ });
+ tempNode.children().css('height', '60px');
+
+ $document[0].body.appendChild(tempNode[0]);
+ this.floatingScrollbars.cached =
+ (tempNode[0].offsetWidth === tempNode[0].childNodes[0].offsetWidth);
+ tempNode.remove();
+ }
+ return this.floatingScrollbars.cached;
+ },
+
+ /**
+ * Mobile safari only allows you to set focus in click event listeners.
+ * @param {Element|JQLite} element to focus
+ */
+ forceFocus: function(element) {
+ var node = element[0] || element;
+
+ document.addEventListener('click', function focusOnClick(ev) {
+ if (ev.target === node && ev.$focus) {
+ node.focus();
+ ev.stopImmediatePropagation();
+ ev.preventDefault();
+ node.removeEventListener('click', focusOnClick);
+ }
+ }, true);
+
+ var newEvent = document.createEvent('MouseEvents');
+ newEvent.initMouseEvent('click', false, true, window, {}, 0, 0, 0, 0,
+ false, false, false, false, 0, null);
+ newEvent.$material = true;
+ newEvent.$focus = true;
+ node.dispatchEvent(newEvent);
+ },
+
+ /**
+ * facade to build md-backdrop element with desired styles
+ * NOTE: Use $compile to trigger backdrop postLink function
+ */
+ createBackdrop: function(scope, addClass) {
+ return $compile($mdUtil.supplant('<md-backdrop class="{0}">', [addClass]))(scope);
+ },
+
+ /**
+ * supplant() method from Crockford's `Remedial Javascript`
+ * Equivalent to use of $interpolate; without dependency on
+ * interpolation symbols and scope. Note: the '{<token>}' can
+ * be property names, property chains, or array indices.
+ */
+ supplant: function(template, values, pattern) {
+ pattern = pattern || /\{([^{}]*)\}/g;
+ return template.replace(pattern, function(a, b) {
+ var p = b.split('.'),
+ r = values;
+ try {
+ for (var s in p) {
+ if (p.hasOwnProperty(s)) {
+ r = r[p[s]];
+ }
+ }
+ } catch (e) {
+ r = a;
+ }
+ return (typeof r === 'string' || typeof r === 'number') ? r : a;
+ });
+ },
+
+ fakeNgModel: function() {
+ return {
+ $fake: true,
+ $setTouched: angular.noop,
+ $setViewValue: function(value) {
+ this.$viewValue = value;
+ this.$render(value);
+ this.$viewChangeListeners.forEach(function(cb) {
+ cb();
+ });
+ },
+ $isEmpty: function(value) {
+ return ('' + value).length === 0;
+ },
+ $parsers: [],
+ $formatters: [],
+ $viewChangeListeners: [],
+ $render: angular.noop
+ };
+ },
+
+ /**
+ * @param {Function} func original function to be debounced
+ * @param {number} wait number of milliseconds to delay (since last debounce reset).
+ * Default value 10 msecs.
+ * @param {Object} scope in which to apply the function after debouncing ends
+ * @param {boolean} invokeApply should the $timeout trigger $digest() dirty checking
+ * @return {Function} A function, that, as long as it continues to be invoked, will not be
+ * triggered. The function will be called after it stops being called for N milliseconds.
+ */
+ debounce: function(func, wait, scope, invokeApply) {
+ var timer;
+
+ return function debounced() {
+ var context = scope,
+ args = Array.prototype.slice.call(arguments);
+
+ $timeout.cancel(timer);
+ timer = $timeout(function() {
+
+ timer = undefined;
+ func.apply(context, args);
+
+ }, wait || 10, invokeApply);
+ };
+ },
+
+ /**
+ * The function will not be called unless it has been more than `delay` milliseconds since the
+ * last call.
+ * @param {Function} func original function to throttle
+ * @param {number} delay number of milliseconds to delay
+ * @return {Function} a function that can only be triggered every `delay` milliseconds.
+ */
+ throttle: function throttle(func, delay) {
+ var recent;
+ return function throttled() {
+ var context = this;
+ var args = arguments;
+ var now = $mdUtil.now();
+
+ if (!recent || (now - recent > delay)) {
+ func.apply(context, args);
+ recent = now;
+ }
+ };
+ },
+
+ /**
+ * Measures the number of milliseconds taken to run the provided callback
+ * function. Uses a high-precision timer if available.
+ */
+ time: function time(cb) {
+ var start = $mdUtil.now();
+ cb();
+ return $mdUtil.now() - start;
+ },
+
+ /**
+ * Create an implicit getter that caches its `getter()`
+ * lookup value
+ */
+ valueOnUse : function (scope, key, getter) {
+ var value = null, args = Array.prototype.slice.call(arguments);
+ var params = (args.length > 3) ? args.slice(3) : [];
+
+ Object.defineProperty(scope, key, {
+ get: function () {
+ if (value === null) value = getter.apply(scope, params);
+ return value;
+ }
+ });
+ },
+
+ /**
+ * Get a unique ID.
+ *
+ * @returns {string} an unique numeric string
+ */
+ nextUid: function() {
+ return '' + nextUniqueId++;
+ },
+
+ /**
+ * Stop watchers and events from firing on a scope without destroying it,
+ * by disconnecting it from its parent and its siblings' linked lists.
+ * @param {Object} scope to disconnect
+ */
+ disconnectScope: function disconnectScope(scope) {
+ if (!scope) return;
+
+ // we can't destroy the root scope or a scope that has been already destroyed
+ if (scope.$root === scope) return;
+ if (scope.$$destroyed) return;
+
+ var parent = scope.$parent;
+ scope.$$disconnected = true;
+
+ // See Scope.$destroy
+ if (parent.$$childHead === scope) parent.$$childHead = scope.$$nextSibling;
+ if (parent.$$childTail === scope) parent.$$childTail = scope.$$prevSibling;
+ if (scope.$$prevSibling) scope.$$prevSibling.$$nextSibling = scope.$$nextSibling;
+ if (scope.$$nextSibling) scope.$$nextSibling.$$prevSibling = scope.$$prevSibling;
+
+ scope.$$nextSibling = scope.$$prevSibling = null;
+
+ },
+
+ /**
+ * Undo the effects of disconnectScope().
+ * @param {Object} scope to reconnect
+ */
+ reconnectScope: function reconnectScope(scope) {
+ if (!scope) return;
+
+ // we can't disconnect the root node or scope already disconnected
+ if (scope.$root === scope) return;
+ if (!scope.$$disconnected) return;
+
+ var child = scope;
+
+ var parent = child.$parent;
+ child.$$disconnected = false;
+ // See Scope.$new for this logic...
+ child.$$prevSibling = parent.$$childTail;
+ if (parent.$$childHead) {
+ parent.$$childTail.$$nextSibling = child;
+ parent.$$childTail = child;
+ } else {
+ parent.$$childHead = parent.$$childTail = child;
+ }
+ },
+
+ /**
+ * Get an element's siblings matching a given tag name.
+ *
+ * @param {JQLite|angular.element|HTMLElement} element Element to start walking the DOM from
+ * @param {string} tagName HTML tag name to match against
+ * @returns {Object[]} JQLite
+ */
+ getSiblings: function getSiblings(element, tagName) {
+ var upperCasedTagName = tagName.toUpperCase();
+ if (element instanceof angular.element) {
+ element = element[0];
+ }
+ var siblings = Array.prototype.filter.call(element.parentNode.children, function(node) {
+ return element !== node && node.tagName.toUpperCase() === upperCasedTagName;
+ });
+ return siblings.map(function (sibling) {
+ return angular.element(sibling);
+ });
+ },
+
+ /**
+ * getClosest replicates jQuery.closest() to walk up the DOM tree until it finds a matching
+ * nodeName.
+ *
+ * @param {Node} el Element to start walking the DOM from
+ * @param {string|function} validateWith If a string is passed, it will be evaluated against
+ * each of the parent nodes' tag name. If a function is passed, the loop will call it with each
+ * of the parents and will use the return value to determine whether the node is a match.
+ * @param {boolean=} onlyParent Only start checking from the parent element, not `el`.
+ * @returns {Node|null} closest matching parent Node or null if not found
+ */
+ getClosest: function getClosest(el, validateWith, onlyParent) {
+ if (angular.isString(validateWith)) {
+ var tagName = validateWith.toUpperCase();
+ validateWith = function(el) {
+ return el.nodeName.toUpperCase() === tagName;
+ };
+ }
+
+ if (el instanceof angular.element) el = el[0];
+ if (onlyParent) el = el.parentNode;
+ if (!el) return null;
+
+ do {
+ if (validateWith(el)) {
+ return el;
+ }
+ } while (el = el.parentNode);
+
+ return null;
+ },
+
+ /**
+ * Build polyfill for the Node.contains feature (if needed)
+ * @param {Node} node
+ * @param {Node} child
+ * @returns {Node}
+ */
+ elementContains: function(node, child) {
+ var hasContains = (window.Node && window.Node.prototype && Node.prototype.contains);
+ var findFn = hasContains ? angular.bind(node, node.contains) : angular.bind(node, function(arg) {
+ // compares the positions of two nodes and returns a bitmask
+ return (node === child) || !!(this.compareDocumentPosition(arg) & 16);
+ });
+
+ return findFn(child);
+ },
+
+ /**
+ * Functional equivalent for $element.filter(‘md-bottom-sheet’)
+ * useful with interimElements where the element and its container are important...
+ *
+ * @param {JQLite} element to scan
+ * @param {string} nodeName of node to find (e.g. 'md-dialog')
+ * @param {boolean=} scanDeep optional flag to allow deep scans; defaults to 'false'.
+ * @param {boolean=} warnNotFound optional flag to enable log warnings; defaults to false
+ */
+ extractElementByName: function(element, nodeName, scanDeep, warnNotFound) {
+ var found = scanTree(element);
+ if (!found && !!warnNotFound) {
+ $log.warn($mdUtil.supplant("Unable to find node '{0}' in element '{1}'.",[nodeName, element[0].outerHTML]));
+ }
+
+ return angular.element(found || element);
+
+ /**
+ * Breadth-First tree scan for element with matching `nodeName`
+ */
+ function scanTree(element) {
+ return scanLevel(element) || (scanDeep ? scanChildren(element) : null);
+ }
+
+ /**
+ * Case-insensitive scan of current elements only (do not descend).
+ */
+ function scanLevel(element) {
+ if (element) {
+ for (var i = 0, len = element.length; i < len; i++) {
+ if (element[i].nodeName.toLowerCase() === nodeName) {
+ return element[i];
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Scan children of specified node
+ */
+ function scanChildren(element) {
+ var found;
+ if (element) {
+ for (var i = 0, len = element.length; i < len; i++) {
+ var target = element[i];
+ if (!found) {
+ for (var j = 0, numChild = target.childNodes.length; j < numChild; j++) {
+ found = found || scanTree([target.childNodes[j]]);
+ }
+ }
+ }
+ }
+ return found;
+ }
+
+ },
+
+ /**
+ * Give optional properties with no value a boolean true if attr provided or false otherwise
+ */
+ initOptionalProperties: function(scope, attr, defaults) {
+ defaults = defaults || {};
+ angular.forEach(scope.$$isolateBindings, function(binding, key) {
+ if (binding.optional && angular.isUndefined(scope[key])) {
+ var attrIsDefined = angular.isDefined(attr[binding.attrName]);
+ scope[key] = angular.isDefined(defaults[key]) ? defaults[key] : attrIsDefined;
+ }
+ });
+ },
+
+ /**
+ * Alternative to $timeout calls with 0 delay.
+ * nextTick() coalesces all calls within a single frame
+ * to minimize $digest thrashing
+ *
+ * @param {Function} callback function to be called after the tick
+ * @param {boolean=} digest true to call $rootScope.$digest() after callback
+ * @param {Object=} scope associated with callback. If the scope is destroyed, the callback will
+ * be skipped.
+ * @returns {*}
+ */
+ nextTick: function(callback, digest, scope) {
+ // grab function reference for storing state details
+ var nextTick = $mdUtil.nextTick;
+ var timeout = nextTick.timeout;
+ var queue = nextTick.queue || [];
+
+ // add callback to the queue
+ queue.push({scope: scope, callback: callback});
+
+ // set default value for digest
+ if (digest == null) digest = true;
+
+ // store updated digest/queue values
+ nextTick.digest = nextTick.digest || digest;
+ nextTick.queue = queue;
+
+ // either return existing timeout or create a new one
+ return timeout || (nextTick.timeout = $timeout(processQueue, 0, false));
+
+ /**
+ * Grab a copy of the current queue
+ * Clear the queue for future use
+ * Process the existing queue
+ * Trigger digest if necessary
+ */
+ function processQueue() {
+ var queue = nextTick.queue;
+ var digest = nextTick.digest;
+
+ nextTick.queue = [];
+ nextTick.timeout = null;
+ nextTick.digest = false;
+
+ queue.forEach(function(queueItem) {
+ var skip = queueItem.scope && queueItem.scope.$$destroyed;
+ if (!skip) {
+ queueItem.callback();
+ }
+ });
+
+ if (digest) $rootScope.$digest();
+ }
+ },
+
+ /**
+ * Processes a template and replaces the start/end symbols if the application has
+ * overridden them.
+ *
+ * @param template The template to process whose start/end tags may be replaced.
+ * @returns {*}
+ */
+ processTemplate: function(template) {
+ if (usesStandardSymbols) {
+ return template;
+ } else {
+ if (!template || !angular.isString(template)) return template;
+ return template.replace(/\{\{/g, startSymbol).replace(/}}/g, endSymbol);
+ }
+ },
+
+ /**
+ * Scan up dom hierarchy for enabled parent;
+ */
+ getParentWithPointerEvents: function (element) {
+ var parent = element.parent();
+
+ // jqLite might return a non-null, but still empty, parent; so check for parent and length
+ while (hasComputedStyle(parent, 'pointer-events', 'none')) {
+ parent = parent.parent();
+ }
+
+ return parent;
+ },
+
+ getNearestContentElement: function (element) {
+ var current = element.parent()[0];
+ // Look for the nearest parent md-content, stopping at the rootElement.
+ while (current && current !== $rootElement[0] && current !== document.body && current.nodeName.toUpperCase() !== 'MD-CONTENT') {
+ current = current.parentNode;
+ }
+ return current;
+ },
+
+ /**
+ * Checks if the current browser is natively supporting the `sticky` position.
+ * @returns {string} supported sticky property name
+ */
+ checkStickySupport: function() {
+ var stickyProp;
+ var testEl = angular.element('<div>');
+ $document[0].body.appendChild(testEl[0]);
+
+ var stickyProps = ['sticky', '-webkit-sticky'];
+ for (var i = 0; i < stickyProps.length; ++i) {
+ testEl.css({
+ position: stickyProps[i],
+ top: 0,
+ 'z-index': 2
+ });
+
+ if (testEl.css('position') == stickyProps[i]) {
+ stickyProp = stickyProps[i];
+ break;
+ }
+ }
+
+ testEl.remove();
+
+ return stickyProp;
+ },
+
+ /**
+ * Parses an attribute value, mostly a string.
+ * By default checks for negated values and returns `false´ if present.
+ * Negated values are: (native falsy) and negative strings like:
+ * `false` or `0`.
+ * @param value Attribute value which should be parsed.
+ * @param negatedCheck When set to false, won't check for negated values.
+ * @returns {boolean}
+ */
+ parseAttributeBoolean: function(value, negatedCheck) {
+ return value === '' || !!value && (negatedCheck === false || value !== 'false' && value !== '0');
+ },
+
+ hasComputedStyle: hasComputedStyle,
+
+ /**
+ * Returns true if the parent form of the element has been submitted.
+ * @param element An AngularJS or HTML5 element.
+ * @returns {boolean}
+ */
+ isParentFormSubmitted: function(element) {
+ var parent = $mdUtil.getClosest(element, 'form');
+ var form = parent ? angular.element(parent).controller('form') : null;
+
+ return form ? form.$submitted : false;
+ },
+
+ /**
+ * Animate the requested element's scrollTop to the requested scrollPosition with basic easing.
+ * @param {!Element} element The element to scroll.
+ * @param {number} scrollEnd The new/final scroll position.
+ * @param {number=} duration Duration of the scroll. Default is 1000ms.
+ */
+ animateScrollTo: function(element, scrollEnd, duration) {
+ var scrollStart = element.scrollTop;
+ var scrollChange = scrollEnd - scrollStart;
+ var scrollingDown = scrollStart < scrollEnd;
+ var startTime = $mdUtil.now();
+
+ $$rAF(scrollChunk);
+
+ function scrollChunk() {
+ var newPosition = calculateNewPosition();
+
+ element.scrollTop = newPosition;
+
+ if (scrollingDown ? newPosition < scrollEnd : newPosition > scrollEnd) {
+ $$rAF(scrollChunk);
+ }
+ }
+
+ function calculateNewPosition() {
+ var easeDuration = duration || 1000;
+ var currentTime = $mdUtil.now() - startTime;
+
+ return ease(currentTime, scrollStart, scrollChange, easeDuration);
+ }
+
+ function ease(currentTime, start, change, duration) {
+ // If the duration has passed (which can occur if our app loses focus due to $$rAF), jump
+ // straight to the proper position
+ if (currentTime > duration) {
+ return start + change;
+ }
+
+ var ts = (currentTime /= duration) * currentTime;
+ var tc = ts * currentTime;
+
+ return start + change * (-2 * tc + 3 * ts);
+ }
+ },
+
+ /**
+ * Provides an easy mechanism for removing duplicates from an array.
+ *
+ * var myArray = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4];
+ *
+ * $mdUtil.uniq(myArray) => [1, 2, 3, 4]
+ *
+ * @param {Array} array The array whose unique values should be returned.
+ * @returns {Array|void} A copy of the array containing only unique values.
+ */
+ uniq: function(array) {
+ if (!array) { return; }
+
+ return array.filter(function(value, index, self) {
+ return self.indexOf(value) === index;
+ });
+ },
+
+ /**
+ * Gets the inner HTML content of the given HTMLElement.
+ * Only intended for use with SVG or Symbol elements in IE11.
+ * @param {Element} element
+ * @returns {string} the inner HTML of the element passed in
+ */
+ getInnerHTML: function(element) {
+ // For SVG or Symbol elements, innerHTML returns `undefined` in IE.
+ // Reference: https://stackoverflow.com/q/28129956/633107
+ // The XMLSerializer API is supported on IE11 and is the recommended workaround.
+ var serializer = new XMLSerializer();
+
+ return Array.prototype.map.call(element.childNodes, function (child) {
+ return serializer.serializeToString(child);
+ }).join('');
+ },
+
+ /**
+ * Gets the outer HTML content of the given HTMLElement.
+ * Only intended for use with SVG or Symbol elements in IE11.
+ * @param {Element} element
+ * @returns {string} the outer HTML of the element passed in
+ */
+ getOuterHTML: function(element) {
+ // For SVG or Symbol elements, outerHTML returns `undefined` in IE.
+ // Reference: https://stackoverflow.com/q/29888050/633107
+ // The XMLSerializer API is supported on IE11 and is the recommended workaround.
+ var serializer = new XMLSerializer();
+ return serializer.serializeToString(element);
+ },
+
+ /**
+ * Support: IE 9-11 only
+ * documentMode is an IE-only property
+ * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
+ */
+ msie: window.document.documentMode,
+
+ getTouchAction: function() {
+ var testEl = document.createElement('div');
+ var vendorPrefixes = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
+
+ for (var i = 0; i < vendorPrefixes.length; i++) {
+ var prefix = vendorPrefixes[i];
+ var property = prefix ? prefix + 'TouchAction' : 'touchAction';
+ if (angular.isDefined(testEl.style[property])) {
+ return property;
+ }
+ }
+ },
+
+ /**
+ * @param {Event} event the event to calculate the bubble path for
+ * @return {EventTarget[]} the set of nodes that this event could bubble up to
+ */
+ getEventPath: function(event) {
+ var path = [];
+ var currentTarget = event.target;
+ while (currentTarget) {
+ path.push(currentTarget);
+ currentTarget = currentTarget.parentElement;
+ }
+ if (path.indexOf(window) === -1 && path.indexOf(document) === -1)
+ path.push(document);
+ if (path.indexOf(window) === -1)
+ path.push(window);
+ return path;
+ },
+
+ /**
+ * Gets the string the user has entered and removes Regex identifiers
+ * @param {string} term
+ * @returns {string} sanitized string
+ */
+ sanitize: function(term) {
+ if (!term) return term;
+ return term.replace(/[\\^$*+?.()|{}[]/g, '\\$&');
+ },
+
+ /**********************************************************************************************
+ * The following functions were sourced from
+ * https://github.com/angular/components/blob/3c37e4b1c1cb74a3d0a90d173240fc730d21d9d4/src/cdk/a11y/interactivity-checker/interactivity-checker.ts
+ **********************************************************************************************/
+
+ /**
+ * Gets whether an element is disabled.
+ * @param {HTMLElement} element Element to be checked.
+ * @returns {boolean} Whether the element is disabled.
+ */
+ isDisabled: function(element) {
+ // This does not capture some cases, such as a non-form control with a disabled attribute or
+ // a form control inside of a disabled form, but should capture the most common cases.
+ return element.hasAttribute('disabled');
+ },
+
+ /**
+ * Gets whether an element is visible for the purposes of interactivity.
+ *
+ * This will capture states like `display: none` and `visibility: hidden`, but not things like
+ * being clipped by an `overflow: hidden` parent or being outside the viewport.
+ *
+ * @param {HTMLElement} element
+ * @returns {boolean} Whether the element is visible.
+ */
+ isVisible: function(element) {
+ return $mdUtil.hasGeometry(element) && getComputedStyle(element).visibility === 'visible';
+ },
+
+ /**
+ * Gets whether an element can be reached via Tab key.
+ * Assumes that the element has already been checked with isFocusable.
+ * @param {HTMLElement} element Element to be checked.
+ * @returns {boolean} Whether the element is tabbable.
+ */
+ isTabbable: function(element) {
+ var frameElement = $mdUtil.getFrameElement($mdUtil.getWindow(element));
+
+ if (frameElement) {
+ // Frame elements inherit their tabindex onto all child elements.
+ if ($mdUtil.getTabIndexValue(frameElement) === -1) {
+ return false;
+ }
+
+ // Browsers disable tabbing to an element inside of an invisible frame.
+ if (!$mdUtil.isVisible(frameElement)) {
+ return false;
+ }
+ }
+
+ var nodeName = element.nodeName.toLowerCase();
+ var tabIndexValue = $mdUtil.getTabIndexValue(element);
+
+ if (element.hasAttribute('contenteditable')) {
+ return tabIndexValue !== -1;
+ }
+
+ if (nodeName === 'iframe' || nodeName === 'object') {
+ // The frame or object's content may be tabbable depending on the content, but it's
+ // not possibly to reliably detect the content of the frames. We always consider such
+ // elements as non-tabbable.
+ return false;
+ }
+
+ // In iOS, the browser only considers some specific elements as tabbable.
+ if (isIos && !$mdUtil.isPotentiallyTabbableIOS(element)) {
+ return false;
+ }
+
+ if (nodeName === 'audio') {
+ // Audio elements without controls enabled are never tabbable, regardless
+ // of the tabindex attribute explicitly being set.
+ if (!element.hasAttribute('controls')) {
+ return false;
+ }
+ // Audio elements with controls are by default tabbable unless the
+ // tabindex attribute is set to `-1` explicitly.
+ return tabIndexValue !== -1;
+ }
+
+ if (nodeName === 'video') {
+ // For all video elements, if the tabindex attribute is set to `-1`, the video
+ // is not tabbable. Note: We cannot rely on the default `HTMLElement.tabIndex`
+ // property as that one is set to `-1` in Chrome, Edge and Safari v13.1. The
+ // tabindex attribute is the source of truth here.
+ if (tabIndexValue === -1) {
+ return false;
+ }
+ // If the tabindex is explicitly set, and not `-1` (as per check before), the
+ // video element is always tabbable (regardless of whether it has controls or not).
+ if (tabIndexValue !== null) {
+ return true;
+ }
+ // Otherwise (when no explicit tabindex is set), a video is only tabbable if it
+ // has controls enabled. Firefox is special as videos are always tabbable regardless
+ // of whether there are controls or not.
+ return isFirefox || element.hasAttribute('controls');
+ }
+
+ return element.tabIndex >= 0;
+ },
+
+ /**
+ * Gets whether an element can be focused by the user.
+ * @param {HTMLElement} element Element to be checked.
+ * @returns {boolean} Whether the element is focusable.
+ */
+ isFocusable: function(element) {
+ // Perform checks in order of left to most expensive.
+ // Again, naive approach that does not capture many edge cases and browser quirks.
+ return $mdUtil.isPotentiallyFocusable(element) && !$mdUtil.isDisabled(element) &&
+ $mdUtil.isVisible(element);
+ },
+
+ /**
+ * Gets whether an element is potentially focusable without taking current visible/disabled
+ * state into account.
+ * @param {HTMLElement} element
+ * @returns {boolean}
+ */
+ isPotentiallyFocusable: function(element) {
+ // Inputs are potentially focusable *unless* they're type="hidden".
+ if ($mdUtil.isHiddenInput(element)) {
+ return false;
+ }
+
+ return $mdUtil.isNativeFormElement(element) ||
+ $mdUtil.isAnchorWithHref(element) ||
+ element.hasAttribute('contenteditable') ||
+ $mdUtil.hasValidTabIndex(element);
+ },
+
+ /**
+ * Checks whether the specified element is potentially tabbable on iOS.
+ * @param {HTMLElement} element
+ * @returns {boolean}
+ */
+ isPotentiallyTabbableIOS: function(element) {
+ var nodeName = element.nodeName.toLowerCase();
+ var inputType = nodeName === 'input' && element.type;
+
+ return inputType === 'text'
+ || inputType === 'password'
+ || nodeName === 'select'
+ || nodeName === 'textarea';
+ },
+
+ /**
+ * Returns the parsed tabindex from the element attributes instead of returning the
+ * evaluated tabindex from the browsers defaults.
+ * @param {HTMLElement} element
+ * @returns {null|number}
+ */
+ getTabIndexValue: function(element) {
+ if (!$mdUtil.hasValidTabIndex(element)) {
+ return null;
+ }
+
+ // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
+ var tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);
+
+ return isNaN(tabIndex) ? -1 : tabIndex;
+ },
+
+ /**
+ * Gets whether an element has a valid tabindex.
+ * @param {HTMLElement} element
+ * @returns {boolean}
+ */
+ hasValidTabIndex: function(element) {
+ if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {
+ return false;
+ }
+
+ var tabIndex = element.getAttribute('tabindex');
+
+ // IE11 parses tabindex="" as the value "-32768"
+ if (tabIndex == '-32768') {
+ return false;
+ }
+
+ return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
+ },
+
+ /**
+ * Checks whether the specified element has any geometry / rectangles.
+ * @param {HTMLElement} element
+ * @returns {boolean}
+ */
+ hasGeometry: function(element) {
+ // Use logic from jQuery to check for an invisible element.
+ // See https://github.com/jquery/jquery/blob/8969732518470a7f8e654d5bc5be0b0076cb0b87/src/css/hiddenVisibleSelectors.js#L9
+ return !!(element.offsetWidth || element.offsetHeight ||
+ (typeof element.getClientRects === 'function' && element.getClientRects().length));
+ },
+
+ /**
+ * Returns the frame element from a window object. Since browsers like MS Edge throw errors if
+ * the frameElement property is being accessed from a different host address, this property
+ * should be accessed carefully.
+ * @param {Window} window
+ * @returns {null|HTMLElement}
+ */
+ getFrameElement: function(window) {
+ try {
+ return window.frameElement;
+ } catch (error) {
+ return null;
+ }
+ },
+
+ /**
+ * Gets the parent window of a DOM node with regards of being inside of an iframe.
+ * @param {HTMLElement} node
+ * @returns {Window}
+ */
+ getWindow: function(node) {
+ // ownerDocument is null if `node` itself *is* a document.
+ return node.ownerDocument && node.ownerDocument.defaultView || window;
+ },
+
+ /**
+ * Gets whether an element's
+ * @param {Node} element
+ * @returns {boolean}
+ */
+ isNativeFormElement: function(element) {
+ var nodeName = element.nodeName.toLowerCase();
+ return nodeName === 'input' ||
+ nodeName === 'select' ||
+ nodeName === 'button' ||
+ nodeName === 'textarea';
+ },
+
+ /**
+ * Gets whether an element is an `<input type="hidden">`.
+ * @param {HTMLElement} element
+ * @returns {boolean}
+ */
+ isHiddenInput: function(element) {
+ return $mdUtil.isInputElement(element) && element.type == 'hidden';
+ },
+
+ /**
+ * Gets whether an element is an anchor that has an href attribute.
+ * @param {HTMLElement} element
+ * @returns {boolean}
+ */
+ isAnchorWithHref: function(element) {
+ return $mdUtil.isAnchorElement(element) && element.hasAttribute('href');
+ },
+
+ /**
+ * Gets whether an element is an input element.
+ * @param {HTMLElement} element
+ * @returns {boolean}
+ */
+ isInputElement: function(element) {
+ return element.nodeName.toLowerCase() == 'input';
+ },
+
+ /**
+ * Gets whether an element is an anchor element.
+ * @param {HTMLElement} element
+ * @returns {boolean}
+ */
+ isAnchorElement: function(element) {
+ return element.nodeName.toLowerCase() == 'a';
+ },
+
+ /**********************************************************************************************
+ * The following two functions were sourced from
+ * https://github.com/angular/components/blob/3c37e4b1c1cb74a3d0a90d173240fc730d21d9d4/src/cdk/a11y/focus-trap/focus-trap.ts#L268-L311
+ **********************************************************************************************/
+
+ /**
+ * Get the first tabbable element from a DOM subtree (inclusive).
+ * @param {HTMLElement} root
+ * @returns {HTMLElement|null}
+ */
+ getFirstTabbableElement: function(root) {
+ if ($mdUtil.isFocusable(root) && $mdUtil.isTabbable(root)) {
+ return root;
+ }
+
+ // Iterate in DOM order. Note that IE doesn't have `children` for SVG so we fall
+ // back to `childNodes` which includes text nodes, comments etc.
+ var children = root.children || root.childNodes;
+
+ for (var i = 0; i < children.length; i++) {
+ var tabbableChild = children[i].nodeType === $document[0].ELEMENT_NODE ?
+ $mdUtil.getFirstTabbableElement(children[i]) : null;
+
+ if (tabbableChild) {
+ return tabbableChild;
+ }
+ }
+
+ return null;
+ },
+
+ /**
+ * Get the last tabbable element from a DOM subtree (inclusive).
+ * @param {HTMLElement} root
+ * @returns {HTMLElement|null}
+ */
+ getLastTabbableElement: function(root) {
+ if ($mdUtil.isFocusable(root) && $mdUtil.isTabbable(root)) {
+ return root;
+ }
+
+ // Iterate in reverse DOM order.
+ var children = root.children || root.childNodes;
+
+ for (var i = children.length - 1; i >= 0; i--) {
+ var tabbableChild = children[i].nodeType === $document[0].ELEMENT_NODE ?
+ $mdUtil.getLastTabbableElement(children[i]) : null;
+
+ if (tabbableChild) {
+ return tabbableChild;
+ }
+ }
+
+ return null;
+ }
+ };
+
+ // Instantiate other namespace utility methods
+
+ $mdUtil.dom.animator = $$mdAnimate($mdUtil);
+
+ return $mdUtil;
+
+ function getNode(el) {
+ return el[0] || el;
+ }
+}
+
+/**
+ * Since removing jQuery from the demos, some code that uses `element.focus()` is broken.
+ * We need to add `element.focus()`, because it's testable unlike `element[0].focus`.
+ */
+angular.element.prototype.focus = angular.element.prototype.focus || function() {
+ if (this.length) {
+ this[0].focus();
+ }
+ return this;
+};
+
+angular.element.prototype.blur = angular.element.prototype.blur || function() {
+ if (this.length) {
+ this[0].blur();
+ }
+ return this;
+};
+
+})();
+(function(){
+"use strict";
+
+// Polyfill angular < 1.4 (provide $animateCss)
+angular
+ .module('material.core')
+ .factory('$$mdAnimate', ["$q", "$timeout", "$mdConstant", "$animateCss", function($q, $timeout, $mdConstant, $animateCss) {
+ // Since $$mdAnimate is injected into $mdUtil... use a wrapper function
+ // to subsequently inject $mdUtil as an argument to the AnimateDomUtils
+ return function($mdUtil) {
+ return AnimateDomUtils($mdUtil, $q, $timeout, $mdConstant, $animateCss);
+ };
+ }]);
+
+/**
+ * Factory function that requires special injections
+ */
+function AnimateDomUtils($mdUtil, $q, $timeout, $mdConstant, $animateCss) {
+ var self;
+ return self = {
+ translate3d : function(target, from, to, options) {
+ return $animateCss(target, {
+ from: from,
+ to: to,
+ addClass: options.transitionInClass,
+ removeClass: options.transitionOutClass,
+ duration: options.duration
+ })
+ .start()
+ .then(function() {
+ // Resolve with reverser function...
+ return reverseTranslate;
+ });
+
+ /**
+ * Specific reversal of the request translate animation above...
+ */
+ function reverseTranslate (newFrom) {
+ return $animateCss(target, {
+ to: newFrom || from,
+ addClass: options.transitionOutClass,
+ removeClass: options.transitionInClass,
+ duration: options.duration
+ }).start();
+ }
+ },
+
+ /**
+ * Listen for transitionEnd event (with optional timeout)
+ * Announce completion or failure via promise handlers
+ */
+ waitTransitionEnd: function (element, opts) {
+ var TIMEOUT = 3000; // fallback is 3 secs
+
+ return $q(function(resolve, reject){
+ opts = opts || { };
+
+ // If there is no transition is found, resolve immediately
+ //
+ // NOTE: using $mdUtil.nextTick() causes delays/issues
+ if (noTransitionFound(opts.cachedTransitionStyles)) {
+ TIMEOUT = 0;
+ }
+
+ var timer = $timeout(finished, opts.timeout || TIMEOUT);
+ element.on($mdConstant.CSS.TRANSITIONEND, finished);
+
+ /**
+ * Upon timeout or transitionEnd, reject or resolve (respectively) this promise.
+ * NOTE: Make sure this transitionEnd didn't bubble up from a child
+ */
+ function finished(ev) {
+ if (ev && ev.target !== element[0]) return;
+
+ if (ev) $timeout.cancel(timer);
+ element.off($mdConstant.CSS.TRANSITIONEND, finished);
+
+ // Never reject since ngAnimate may cause timeouts due missed transitionEnd events
+ resolve();
+ }
+
+ /**
+ * Checks whether or not there is a transition.
+ *
+ * @param styles The cached styles to use for the calculation. If null, getComputedStyle()
+ * will be used.
+ *
+ * @returns {boolean} True if there is no transition/duration; false otherwise.
+ */
+ function noTransitionFound(styles) {
+ styles = styles || window.getComputedStyle(element[0]);
+
+ return styles.transitionDuration === '0s' ||
+ (!styles.transition && !styles.transitionProperty);
+ }
+ });
+ },
+
+ calculateTransformValues: function (element, originator) {
+ var origin = originator.element;
+ var bounds = originator.bounds;
+
+ if (origin || bounds) {
+ var originBnds = origin ? self.clientRect(origin) || currentBounds() : self.copyRect(bounds);
+ var dialogRect = self.copyRect(element[0].getBoundingClientRect());
+ var dialogCenterPt = self.centerPointFor(dialogRect);
+ var originCenterPt = self.centerPointFor(originBnds);
+
+ return {
+ centerX: originCenterPt.x - dialogCenterPt.x,
+ centerY: originCenterPt.y - dialogCenterPt.y,
+ scaleX: Math.round(100 * Math.min(0.5, originBnds.width / dialogRect.width)) / 100,
+ scaleY: Math.round(100 * Math.min(0.5, originBnds.height / dialogRect.height)) / 100
+ };
+ }
+ return {centerX: 0, centerY: 0, scaleX: 0.5, scaleY: 0.5};
+
+ /**
+ * This is a fallback if the origin information is no longer valid, then the
+ * origin bounds simply becomes the current bounds for the dialogContainer's parent.
+ * @returns {null|DOMRect}
+ */
+ function currentBounds() {
+ var container = element ? element.parent() : null;
+ var parent = container ? container.parent() : null;
+
+ return parent ? self.clientRect(parent) : null;
+ }
+ },
+
+ /**
+ * Calculate the zoom transform from dialog to origin.
+ *
+ * We use this to set the dialog position immediately;
+ * then the md-transition-in actually translates back to
+ * `translate3d(0,0,0) scale(1.0)`...
+ *
+ * NOTE: all values are rounded to the nearest integer
+ */
+ calculateZoomToOrigin: function (element, originator) {
+ var zoomTemplate = "translate3d( {centerX}px, {centerY}px, 0 ) scale( {scaleX}, {scaleY} )";
+ var buildZoom = angular.bind(null, $mdUtil.supplant, zoomTemplate);
+
+ return buildZoom(self.calculateTransformValues(element, originator));
+ },
+
+ /**
+ * Calculate the slide transform from panel to origin.
+ * NOTE: all values are rounded to the nearest integer
+ */
+ calculateSlideToOrigin: function (element, originator) {
+ var slideTemplate = "translate3d( {centerX}px, {centerY}px, 0 )";
+ var buildSlide = angular.bind(null, $mdUtil.supplant, slideTemplate);
+
+ return buildSlide(self.calculateTransformValues(element, originator));
+ },
+
+ /**
+ * Enhance raw values to represent valid css stylings...
+ */
+ toCss : function(raw) {
+ var css = { };
+ var lookups = 'left top right bottom width height x y min-width min-height max-width max-height';
+
+ angular.forEach(raw, function(value,key) {
+ if (angular.isUndefined(value)) return;
+
+ if (lookups.indexOf(key) >= 0) {
+ css[key] = value + 'px';
+ } else {
+ switch (key) {
+ case 'transition':
+ convertToVendor(key, $mdConstant.CSS.TRANSITION, value);
+ break;
+ case 'transform':
+ convertToVendor(key, $mdConstant.CSS.TRANSFORM, value);
+ break;
+ case 'transformOrigin':
+ convertToVendor(key, $mdConstant.CSS.TRANSFORM_ORIGIN, value);
+ break;
+ case 'font-size':
+ css['font-size'] = value; // font sizes aren't always in px
+ break;
+ }
+ }
+ });
+
+ return css;
+
+ function convertToVendor(key, vendor, value) {
+ angular.forEach(vendor.split(' '), function (key) {
+ css[key] = value;
+ });
+ }
+ },
+
+ /**
+ * Convert the translate CSS value to key/value pair(s).
+ * @param {string} transform
+ * @param {boolean=} addTransition
+ * @param {string=} transition
+ * @return {Object} object containing CSS translate key/value pair(s)
+ */
+ toTransformCss: function (transform, addTransition, transition) {
+ var css = {};
+ angular.forEach($mdConstant.CSS.TRANSFORM.split(' '), function (key) {
+ css[key] = transform;
+ });
+
+ if (addTransition) {
+ transition = transition || "all 0.4s cubic-bezier(0.25, 0.8, 0.25, 1) !important";
+ css.transition = transition;
+ }
+
+ return css;
+ },
+
+ /**
+ * Clone the Rect and calculate the height/width if needed.
+ * @param {DOMRect} source
+ * @param {DOMRect=} destination
+ * @returns {null|DOMRect}
+ */
+ copyRect: function (source, destination) {
+ if (!source) return null;
+
+ destination = destination || {};
+
+ angular.forEach('left top right bottom width height'.split(' '), function (key) {
+ destination[key] = Math.round(source[key]);
+ });
+
+ destination.width = destination.width || (destination.right - destination.left);
+ destination.height = destination.height || (destination.bottom - destination.top);
+
+ return destination;
+ },
+
+ /**
+ * Calculate ClientRect of element; return null if hidden or zero size.
+ * @param {Element|string} element
+ * @returns {null|DOMRect}
+ */
+ clientRect: function (element) {
+ var bounds = angular.element(element)[0].getBoundingClientRect();
+ var isPositiveSizeClientRect = function (rect) {
+ return rect && (rect.width > 0) && (rect.height > 0);
+ };
+
+ // If the event origin element has zero size, it has probably been hidden.
+ return isPositiveSizeClientRect(bounds) ? self.copyRect(bounds) : null;
+ },
+
+ /**
+ * Calculate 'rounded' center point of Rect
+ * @param {DOMRect} targetRect
+ * @returns {{x: number, y: number}}
+ */
+ centerPointFor: function (targetRect) {
+ return targetRect ? {
+ x: Math.round(targetRect.left + (targetRect.width / 2)),
+ y: Math.round(targetRect.top + (targetRect.height / 2))
+ } : { x : 0, y : 0 };
+ }
+ };
+}
+
+
+})();
+(function(){
+"use strict";
+
+if (angular.version.minor >= 4) {
+ angular.module('material.core.animate', []);
+} else {
+(function() {
+ "use strict";
+
+ var forEach = angular.forEach;
+
+ var WEBKIT = angular.isDefined(document.documentElement.style.WebkitAppearance);
+ var TRANSITION_PROP = WEBKIT ? 'WebkitTransition' : 'transition';
+ var ANIMATION_PROP = WEBKIT ? 'WebkitAnimation' : 'animation';
+ var PREFIX = WEBKIT ? '-webkit-' : '';
+
+ var TRANSITION_EVENTS = (WEBKIT ? 'webkitTransitionEnd ' : '') + 'transitionend';
+ var ANIMATION_EVENTS = (WEBKIT ? 'webkitAnimationEnd ' : '') + 'animationend';
+
+ var $$ForceReflowFactory = ['$document', function($document) {
+ return function() {
+ return $document[0].body.clientWidth + 1;
+ };
+ }];
+
+ var $$rAFMutexFactory = ['$$rAF', function($$rAF) {
+ return function() {
+ var passed = false;
+ $$rAF(function() {
+ passed = true;
+ });
+ return function(fn) {
+ passed ? fn() : $$rAF(fn);
+ };
+ };
+ }];
+
+ var $$AnimateRunnerFactory = ['$q', '$$rAFMutex', function($q, $$rAFMutex) {
+ var INITIAL_STATE = 0;
+ var DONE_PENDING_STATE = 1;
+ var DONE_COMPLETE_STATE = 2;
+
+ function AnimateRunner(host) {
+ this.setHost(host);
+
+ this._doneCallbacks = [];
+ this._runInAnimationFrame = $$rAFMutex();
+ this._state = 0;
+ }
+
+ AnimateRunner.prototype = {
+ setHost: function(host) {
+ this.host = host || {};
+ },
+
+ done: function(fn) {
+ if (this._state === DONE_COMPLETE_STATE) {
+ fn();
+ } else {
+ this._doneCallbacks.push(fn);
+ }
+ },
+
+ progress: angular.noop,
+
+ getPromise: function() {
+ if (!this.promise) {
+ var self = this;
+ this.promise = $q(function(resolve, reject) {
+ self.done(function(status) {
+ status === false ? reject() : resolve();
+ });
+ });
+ }
+ return this.promise;
+ },
+
+ then: function(resolveHandler, rejectHandler) {
+ return this.getPromise().then(resolveHandler, rejectHandler);
+ },
+
+ 'catch': function(handler) {
+ return this.getPromise()['catch'](handler);
+ },
+
+ 'finally': function(handler) {
+ return this.getPromise()['finally'](handler);
+ },
+
+ pause: function() {
+ if (this.host.pause) {
+ this.host.pause();
+ }
+ },
+
+ resume: function() {
+ if (this.host.resume) {
+ this.host.resume();
+ }
+ },
+
+ end: function() {
+ if (this.host.end) {
+ this.host.end();
+ }
+ this._resolve(true);
+ },
+
+ cancel: function() {
+ if (this.host.cancel) {
+ this.host.cancel();
+ }
+ this._resolve(false);
+ },
+
+ complete: function(response) {
+ var self = this;
+ if (self._state === INITIAL_STATE) {
+ self._state = DONE_PENDING_STATE;
+ self._runInAnimationFrame(function() {
+ self._resolve(response);
+ });
+ }
+ },
+
+ _resolve: function(response) {
+ if (this._state !== DONE_COMPLETE_STATE) {
+ forEach(this._doneCallbacks, function(fn) {
+ fn(response);
+ });
+ this._doneCallbacks.length = 0;
+ this._state = DONE_COMPLETE_STATE;
+ }
+ }
+ };
+
+ // Polyfill AnimateRunner.all which is used by input animations
+ AnimateRunner.all = function(runners, callback) {
+ var count = 0;
+ var status = true;
+ forEach(runners, function(runner) {
+ runner.done(onProgress);
+ });
+
+ function onProgress(response) {
+ status = status && response;
+ if (++count === runners.length) {
+ callback(status);
+ }
+ }
+ };
+
+ return AnimateRunner;
+ }];
+
+ angular
+ .module('material.core.animate', [])
+ .factory('$$forceReflow', $$ForceReflowFactory)
+ .factory('$$AnimateRunner', $$AnimateRunnerFactory)
+ .factory('$$rAFMutex', $$rAFMutexFactory)
+ .factory('$animateCss', ['$window', '$$rAF', '$$AnimateRunner', '$$forceReflow', '$$jqLite', '$timeout', '$animate',
+ function($window, $$rAF, $$AnimateRunner, $$forceReflow, $$jqLite, $timeout, $animate) {
+
+ function init(element, options) {
+
+ var temporaryStyles = [];
+ var node = getDomNode(element);
+ var areAnimationsAllowed = node && $animate.enabled();
+
+ var hasCompleteStyles = false;
+ var hasCompleteClasses = false;
+
+ if (areAnimationsAllowed) {
+ if (options.transitionStyle) {
+ temporaryStyles.push([PREFIX + 'transition', options.transitionStyle]);
+ }
+
+ if (options.keyframeStyle) {
+ temporaryStyles.push([PREFIX + 'animation', options.keyframeStyle]);
+ }
+
+ if (options.delay) {
+ temporaryStyles.push([PREFIX + 'transition-delay', options.delay + 's']);
+ }
+
+ if (options.duration) {
+ temporaryStyles.push([PREFIX + 'transition-duration', options.duration + 's']);
+ }
+
+ hasCompleteStyles = options.keyframeStyle ||
+ (options.to && (options.duration > 0 || options.transitionStyle));
+ hasCompleteClasses = !!options.addClass || !!options.removeClass;
+
+ blockTransition(element, true);
+ }
+
+ var hasCompleteAnimation = areAnimationsAllowed && (hasCompleteStyles || hasCompleteClasses);
+
+ applyAnimationFromStyles(element, options);
+
+ var animationClosed = false;
+ var events, eventFn;
+
+ return {
+ close: $window.close,
+ start: function() {
+ var runner = new $$AnimateRunner();
+ waitUntilQuiet(function() {
+ blockTransition(element, false);
+ if (!hasCompleteAnimation) {
+ return close();
+ }
+
+ forEach(temporaryStyles, function(entry) {
+ var key = entry[0];
+ var value = entry[1];
+ node.style[camelCase(key)] = value;
+ });
+
+ applyClasses(element, options);
+
+ var timings = computeTimings(element);
+ if (timings.duration === 0) {
+ return close();
+ }
+
+ var moreStyles = [];
+
+ if (options.easing) {
+ if (timings.transitionDuration) {
+ moreStyles.push([PREFIX + 'transition-timing-function', options.easing]);
+ }
+ if (timings.animationDuration) {
+ moreStyles.push([PREFIX + 'animation-timing-function', options.easing]);
+ }
+ }
+
+ if (options.delay && timings.animationDelay) {
+ moreStyles.push([PREFIX + 'animation-delay', options.delay + 's']);
+ }
+
+ if (options.duration && timings.animationDuration) {
+ moreStyles.push([PREFIX + 'animation-duration', options.duration + 's']);
+ }
+
+ forEach(moreStyles, function(entry) {
+ var key = entry[0];
+ var value = entry[1];
+ node.style[camelCase(key)] = value;
+ temporaryStyles.push(entry);
+ });
+
+ var maxDelay = timings.delay;
+ var maxDelayTime = maxDelay * 1000;
+ var maxDuration = timings.duration;
+ var maxDurationTime = maxDuration * 1000;
+ var startTime = Date.now();
+
+ events = [];
+ if (timings.transitionDuration) {
+ events.push(TRANSITION_EVENTS);
+ }
+ if (timings.animationDuration) {
+ events.push(ANIMATION_EVENTS);
+ }
+ events = events.join(' ');
+ eventFn = function(event) {
+ event.stopPropagation();
+ var ev = event.originalEvent || event;
+ var timeStamp = ev.timeStamp || Date.now();
+ var elapsedTime = parseFloat(ev.elapsedTime.toFixed(3));
+ if (Math.max(timeStamp - startTime, 0) >= maxDelayTime && elapsedTime >= maxDuration) {
+ close();
+ }
+ };
+ element.on(events, eventFn);
+
+ applyAnimationToStyles(element, options);
+
+ $timeout(close, maxDelayTime + maxDurationTime * 1.5, false);
+ });
+
+ return runner;
+
+ function close() {
+ if (animationClosed) return;
+ animationClosed = true;
+
+ if (events && eventFn) {
+ element.off(events, eventFn);
+ }
+ applyClasses(element, options);
+ applyAnimationStyles(element, options);
+ forEach(temporaryStyles, function(entry) {
+ node.style[camelCase(entry[0])] = '';
+ });
+ runner.complete(true);
+ return runner;
+ }
+ }
+ };
+ }
+
+ function applyClasses(element, options) {
+ if (options.addClass) {
+ $$jqLite.addClass(element, options.addClass);
+ options.addClass = null;
+ }
+ if (options.removeClass) {
+ $$jqLite.removeClass(element, options.removeClass);
+ options.removeClass = null;
+ }
+ }
+
+ function computeTimings(element) {
+ var node = getDomNode(element);
+ var cs = $window.getComputedStyle(node);
+ var tdr = parseMaxTime(cs[prop('transitionDuration')]);
+ var adr = parseMaxTime(cs[prop('animationDuration')]);
+ var tdy = parseMaxTime(cs[prop('transitionDelay')]);
+ var ady = parseMaxTime(cs[prop('animationDelay')]);
+
+ adr *= (parseInt(cs[prop('animationIterationCount')], 10) || 1);
+ var duration = Math.max(adr, tdr);
+ var delay = Math.max(ady, tdy);
+
+ return {
+ duration: duration,
+ delay: delay,
+ animationDuration: adr,
+ transitionDuration: tdr,
+ animationDelay: ady,
+ transitionDelay: tdy
+ };
+
+ function prop(key) {
+ return WEBKIT ? 'Webkit' + key.charAt(0).toUpperCase() + key.substr(1)
+ : key;
+ }
+ }
+
+ function parseMaxTime(str) {
+ var maxValue = 0;
+ var values = (str || "").split(/\s*,\s*/);
+ forEach(values, function(value) {
+ // it's always safe to consider only second values and omit `ms` values since
+ // getComputedStyle will always handle the conversion for us
+ if (value.charAt(value.length - 1) == 's') {
+ value = value.substring(0, value.length - 1);
+ }
+ value = parseFloat(value) || 0;
+ maxValue = maxValue ? Math.max(value, maxValue) : value;
+ });
+ return maxValue;
+ }
+
+ var cancelLastRAFRequest;
+ var rafWaitQueue = [];
+ function waitUntilQuiet(callback) {
+ if (cancelLastRAFRequest) {
+ cancelLastRAFRequest(); // cancels the request
+ }
+ rafWaitQueue.push(callback);
+ cancelLastRAFRequest = $$rAF(function() {
+ cancelLastRAFRequest = null;
+
+ // DO NOT REMOVE THIS LINE OR REFACTOR OUT THE `pageWidth` variable.
+ // PLEASE EXAMINE THE `$$forceReflow` service to understand why.
+ var pageWidth = $$forceReflow();
+
+ // we use a for loop to ensure that if the queue is changed
+ // during this looping then it will consider new requests
+ for (var i = 0; i < rafWaitQueue.length; i++) {
+ rafWaitQueue[i](pageWidth);
+ }
+ rafWaitQueue.length = 0;
+ });
+ }
+
+ function applyAnimationStyles(element, options) {
+ applyAnimationFromStyles(element, options);
+ applyAnimationToStyles(element, options);
+ }
+
+ function applyAnimationFromStyles(element, options) {
+ if (options.from) {
+ element.css(options.from);
+ options.from = null;
+ }
+ }
+
+ function applyAnimationToStyles(element, options) {
+ if (options.to) {
+ element.css(options.to);
+ options.to = null;
+ }
+ }
+
+ function getDomNode(element) {
+ for (var i = 0; i < element.length; i++) {
+ if (element[i].nodeType === 1) return element[i];
+ }
+ }
+
+ function blockTransition(element, bool) {
+ var node = getDomNode(element);
+ var key = camelCase(PREFIX + 'transition-delay');
+ node.style[key] = bool ? '-9999s' : '';
+ }
+
+ return init;
+ }]);
+
+ /**
+ * Older browsers [FF31] expect camelCase
+ * property keys.
+ * e.g.
+ * animation-duration --> animationDuration
+ */
+ function camelCase(str) {
+ return str.replace(/-[a-z]/g, function(str) {
+ return str.charAt(1).toUpperCase();
+ });
+ }
+
+})();
+
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.core.aria
+ * @description
+ * Aria Expectations for AngularJS Material components.
+ */
+MdAriaService.$inject = ["$$rAF", "$log", "$window", "$interpolate"];
+angular
+ .module('material.core')
+ .provider('$mdAria', MdAriaProvider);
+
+/**
+ * @ngdoc service
+ * @name $mdAriaProvider
+ * @module material.core.aria
+ *
+ * @description
+ *
+ * Modify options of the `$mdAria` service, which will be used by most of the AngularJS Material
+ * components.
+ *
+ * You are able to disable `$mdAria` warnings, by using the following markup.
+ *
+ * <hljs lang="js">
+ * app.config(function($mdAriaProvider) {
+ * // Globally disables all ARIA warnings.
+ * $mdAriaProvider.disableWarnings();
+ * });
+ * </hljs>
+ *
+ */
+function MdAriaProvider() {
+
+ var config = {
+ /** Whether we should show ARIA warnings in the console if labels are missing on the element */
+ showWarnings: true
+ };
+
+ return {
+ disableWarnings: disableWarnings,
+ $get: ["$$rAF", "$log", "$window", "$interpolate", function($$rAF, $log, $window, $interpolate) {
+ return MdAriaService.apply(config, arguments);
+ }]
+ };
+
+ /**
+ * @ngdoc method
+ * @name $mdAriaProvider#disableWarnings
+ * @description Disables all ARIA warnings generated by AngularJS Material.
+ */
+ function disableWarnings() {
+ config.showWarnings = false;
+ }
+}
+
+/*
+ * @ngInject
+ */
+function MdAriaService($$rAF, $log, $window, $interpolate) {
+
+ // Load the showWarnings option from the current context and store it inside of a scope variable,
+ // because the context will be probably lost in some function calls.
+ var showWarnings = this.showWarnings;
+
+ return {
+ expect: expect,
+ expectAsync: expectAsync,
+ expectWithText: expectWithText,
+ expectWithoutText: expectWithoutText,
+ getText: getText,
+ hasAriaLabel: hasAriaLabel,
+ parentHasAriaLabel: parentHasAriaLabel
+ };
+
+ /**
+ * Check if expected attribute has been specified on the target element or child
+ * @param {string|JQLite} element
+ * @param {string} attrName
+ * @param {string=} defaultValue What to set the attr to if no value is found
+ */
+ function expect(element, attrName, defaultValue) {
+
+ var node = angular.element(element)[0] || element;
+
+ // if node exists and neither it nor its children have the attribute
+ if (node &&
+ ((!node.hasAttribute(attrName) ||
+ node.getAttribute(attrName).length === 0) &&
+ !childHasAttribute(node, attrName))) {
+
+ defaultValue = angular.isString(defaultValue) ? defaultValue.trim() : '';
+ if (defaultValue.length) {
+ element.attr(attrName, defaultValue);
+ } else if (showWarnings) {
+ $log.warn('ARIA: Attribute "', attrName, '", required for accessibility, is missing on node:', node);
+ }
+
+ }
+ }
+
+ function expectAsync(element, attrName, defaultValueGetter) {
+ // Problem: when retrieving the element's contents synchronously to find the label,
+ // the text may not be defined yet in the case of a binding.
+ // There is a higher chance that a binding will be defined if we wait one frame.
+ $$rAF(function() {
+ expect(element, attrName, defaultValueGetter());
+ });
+ }
+
+ function expectWithText(element, attrName) {
+ var content = getText(element) || "";
+ var hasBinding = content.indexOf($interpolate.startSymbol()) > -1;
+
+ if (hasBinding) {
+ expectAsync(element, attrName, function() {
+ return getText(element);
+ });
+ } else {
+ expect(element, attrName, content);
+ }
+ }
+
+ function expectWithoutText(element, attrName) {
+ var content = getText(element);
+ var hasBinding = content.indexOf($interpolate.startSymbol()) > -1;
+
+ if (!hasBinding && !content) {
+ expect(element, attrName, content);
+ }
+ }
+
+ /**
+ * @param {Element|JQLite} element
+ * @returns {string}
+ */
+ function getText(element) {
+ element = element[0] || element;
+ var walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT, null, false);
+ var text = '';
+
+ var node;
+ while (node = walker.nextNode()) {
+ if (!isAriaHiddenNode(node)) {
+ text += node.textContent;
+ }
+ }
+
+ return text.trim() || '';
+
+ /**
+ * @param {Node} node
+ * @returns {boolean}
+ */
+ function isAriaHiddenNode(node) {
+ while (node.parentNode && (node = node.parentNode) !== element) {
+ if (node.getAttribute && node.getAttribute('aria-hidden') === 'true') {
+ return true;
+ }
+ }
+ }
+ }
+
+ function childHasAttribute(node, attrName) {
+ var hasChildren = node.hasChildNodes(),
+ hasAttr = false;
+
+ function isHidden(el) {
+ var style = el.currentStyle ? el.currentStyle : $window.getComputedStyle(el);
+ return (style.display === 'none');
+ }
+
+ if (hasChildren) {
+ var children = node.childNodes;
+ for (var i=0; i < children.length; i++) {
+ var child = children[i];
+ if (child.nodeType === 1 && child.hasAttribute(attrName)) {
+ if (!isHidden(child)) {
+ hasAttr = true;
+ }
+ }
+ }
+ }
+ return hasAttr;
+ }
+
+ /**
+ * Check if expected element has aria label attribute
+ * @param element
+ */
+ function hasAriaLabel(element) {
+ var node = angular.element(element)[0] || element;
+
+ /* Check if compatible node type (ie: not HTML Document node) */
+ if (!node.hasAttribute) {
+ return false;
+ }
+
+ /* Check label or description attributes */
+ return node.hasAttribute('aria-label') || node.hasAttribute('aria-labelledby') || node.hasAttribute('aria-describedby');
+ }
+
+ /**
+ * Check if expected element's parent has aria label attribute and has valid role and tagName
+ * @param {string|JQLite|Node & ParentNode} element
+ * @param {number=} level Number of levels deep search should be performed
+ */
+ function parentHasAriaLabel(element, level) {
+ level = level || 1;
+ var node = angular.element(element)[0] || element;
+ if (!node.parentNode) {
+ return false;
+ }
+ if (performCheck(node.parentNode)) {
+ return true;
+ }
+ level--;
+ if (level) {
+ return parentHasAriaLabel(node.parentNode, level);
+ }
+ return false;
+
+ function performCheck(parentNode) {
+ if (!hasAriaLabel(parentNode)) {
+ return false;
+ }
+ /* Perform role block-list check */
+ if (parentNode.hasAttribute('role')) {
+ switch (parentNode.getAttribute('role').toLowerCase()) {
+ case 'command':
+ case 'definition':
+ case 'directory':
+ case 'grid':
+ case 'list':
+ case 'listitem':
+ case 'log':
+ case 'marquee':
+ case 'menu':
+ case 'menubar':
+ case 'note':
+ case 'presentation':
+ case 'separator':
+ case 'scrollbar':
+ case 'status':
+ case 'tablist':
+ return false;
+ }
+ }
+ /* Perform tagName block-list check */
+ switch (parentNode.tagName.toLowerCase()) {
+ case 'abbr':
+ case 'acronym':
+ case 'address':
+ case 'applet':
+ case 'audio':
+ case 'b':
+ case 'bdi':
+ case 'bdo':
+ case 'big':
+ case 'blockquote':
+ case 'br':
+ case 'canvas':
+ case 'caption':
+ case 'center':
+ case 'cite':
+ case 'code':
+ case 'col':
+ case 'data':
+ case 'dd':
+ case 'del':
+ case 'dfn':
+ case 'dir':
+ case 'div':
+ case 'dl':
+ case 'em':
+ case 'embed':
+ case 'fieldset':
+ case 'figcaption':
+ case 'font':
+ case 'h1':
+ case 'h2':
+ case 'h3':
+ case 'h4':
+ case 'h5':
+ case 'h6':
+ case 'hgroup':
+ case 'html':
+ case 'i':
+ case 'ins':
+ case 'isindex':
+ case 'kbd':
+ case 'keygen':
+ case 'label':
+ case 'legend':
+ case 'li':
+ case 'map':
+ case 'mark':
+ case 'menu':
+ case 'object':
+ case 'ol':
+ case 'output':
+ case 'pre':
+ case 'presentation':
+ case 'q':
+ case 'rt':
+ case 'ruby':
+ case 'samp':
+ case 'small':
+ case 'source':
+ case 'span':
+ case 'status':
+ case 'strike':
+ case 'strong':
+ case 'sub':
+ case 'sup':
+ case 'svg':
+ case 'tbody':
+ case 'td':
+ case 'th':
+ case 'thead':
+ case 'time':
+ case 'tr':
+ case 'track':
+ case 'tt':
+ case 'ul':
+ case 'var':
+ return false;
+ }
+ return true;
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.core.compiler
+ * @description
+ * AngularJS Material template and element compiler.
+ */
+angular
+ .module('material.core')
+ .provider('$mdCompiler', MdCompilerProvider);
+
+MdCompilerProvider.$inject = ['$compileProvider'];
+function MdCompilerProvider() {
+
+ this.$get = ["$q", "$templateRequest", "$injector", "$compile", "$controller",
+ function($q, $templateRequest, $injector, $compile, $controller) {
+ return new MdCompilerService($q, $templateRequest, $injector, $compile, $controller);
+ }];
+
+ /**
+ * @ngdoc service
+ * @name $mdCompiler
+ * @module material.core.compiler
+ * @description
+ * The $mdCompiler service is an abstraction of AngularJS's compiler, that allows developers
+ * to compile an element with options like in a Directive Definition Object.
+ *
+ * > The compiler powers a lot of components inside of AngularJS Material.
+ * > Like the `$mdPanel` or `$mdDialog` services.
+ *
+ * @usage
+ *
+ * Basic Usage with a template
+ *
+ * <hljs lang="js">
+ * $mdCompiler.compile({
+ * templateUrl: 'modal.html',
+ * controller: 'ModalCtrl',
+ * locals: {
+ * modal: myModalInstance;
+ * }
+ * }).then(function (compileData) {
+ * compileData.element; // Compiled DOM element
+ * compileData.link(myScope); // Instantiate controller and link element to scope.
+ * });
+ * </hljs>
+ *
+ * Example with a content element
+ *
+ * <hljs lang="js">
+ *
+ * // Create a virtual element and link it manually.
+ * // The compiler doesn't need to recompile the element each time.
+ * var myElement = $compile('<span>Test</span>')(myScope);
+ *
+ * $mdCompiler.compile({
+ * contentElement: myElement
+ * }).then(function (compileData) {
+ * compileData.element // Content Element (same as above)
+ * compileData.link // This does nothing when using a contentElement.
+ * });
+ * </hljs>
+ *
+ * > Content Element is a significant performance improvement when the developer already knows
+ * > that the compiled element will be always the same and the scope will not change either.
+ *
+ * The `contentElement` option also supports DOM elements which will be temporary removed and
+ * restored at its old position.
+ *
+ * <hljs lang="js">
+ * var domElement = document.querySelector('#myElement');
+ *
+ * $mdCompiler.compile({
+ * contentElement: myElement
+ * }).then(function (compileData) {
+ * compileData.element // Content Element (same as above)
+ * compileData.link // This does nothing when using a contentElement.
+ * });
+ * </hljs>
+ *
+ * The `$mdCompiler` can also query for the element in the DOM itself.
+ *
+ * <hljs lang="js">
+ * $mdCompiler.compile({
+ * contentElement: '#myElement'
+ * }).then(function (compileData) {
+ * compileData.element // Content Element (same as above)
+ * compileData.link // This does nothing when using a contentElement.
+ * });
+ * </hljs>
+ *
+ */
+ function MdCompilerService($q, $templateRequest, $injector, $compile, $controller) {
+
+ /**
+ * @private @const
+ * @type {!IQService}
+ */
+ this.$q = $q;
+
+ /**
+ * @private @const
+ * @type {!ITemplateRequestService}
+ */
+ this.$templateRequest = $templateRequest;
+
+ /**
+ * @private @const
+ * @type {!IInjectorService}
+ */
+ this.$injector = $injector;
+
+ /**
+ * @private @const
+ * @type{!ICompileService}
+ */
+ this.$compile = $compile;
+
+ /**
+ * @private @const
+ * @type {!IControllerService}
+ */
+ this.$controller = $controller;
+ }
+
+ /**
+ * @ngdoc method
+ * @name $mdCompiler#compile
+ * @description
+ *
+ * A method to compile a HTML template with the AngularJS compiler.
+ * The `$mdCompiler` is wrapper around the AngularJS compiler and provides extra functionality
+ * like controller instantiation or async resolves.
+ *
+ * @param {!Object} options An options object, with the following properties:
+ *
+ * - `controller` - `{string|function}` Controller fn that should be associated with
+ * newly created scope or the name of a registered controller if passed as a string.
+ * - `controllerAs` - `{string=}` A controller alias name. If present the controller will be
+ * published to scope under the `controllerAs` name.
+ * - `contentElement` - `{string|Element}`: Instead of using a template, which will be
+ * compiled each time, you can also use a DOM element.<br/>
+ * - `template` - `{string=}` An html template as a string.
+ * - `templateUrl` - `{string=}` A path to an html template.
+ * - `transformTemplate` - `{function(template)=}` A function which transforms the template after
+ * it is loaded. It will be given the template string as a parameter, and should
+ * return a a new string representing the transformed template.
+ * - `resolve` - `{Object.<string, function>=}` - An optional map of dependencies which should
+ * be injected into the controller. If any of these dependencies are promises, the compiler
+ * will wait for them all to be resolved, or if one is rejected before the controller is
+ * instantiated `compile()` will fail..
+ * * `key` - `{string}`: a name of a dependency to be injected into the controller.
+ * * `factory` - `{string|function}`: If `string` then it is an alias for a service.
+ * Otherwise if function, then it is injected and the return value is treated as the
+ * dependency. If the result is a promise, it is resolved before its value is
+ * injected into the controller.
+ *
+ * @returns {Q.Promise<{element: JQLite, link: Function, locals: Object, cleanup: any,
+ * controller: Object=}>} promise A promise, which will be resolved with a `compileData` object.
+ * `compileData` has the following properties:
+ *
+ * - `element` - `{JQLite}`: an uncompiled element matching the provided template.
+ * - `link` - `{function(scope)}`: A link function, which, when called, will compile
+ * the element and instantiate the provided controller (if given).
+ * - `locals` - `{Object}`: The locals which will be passed into the controller once `link` is
+ * called. If `bindToController` is true, they will be copied to the ctrl instead
+ */
+ MdCompilerService.prototype.compile = function(options) {
+ if (options.contentElement) {
+ return this._prepareContentElement(options);
+ } else {
+ return this._compileTemplate(options);
+ }
+ };
+
+ /**
+ * Instead of compiling any template, the compiler just fetches an existing HTML element from the
+ * DOM and provides a restore function to put the element back it old DOM position.
+ * @param {!Object} options Options to be used for the compiler.
+ * @returns {Q.Promise<{element: JQLite, link: Function, locals: Object, cleanup: any}>}
+ */
+ MdCompilerService.prototype._prepareContentElement = function(options) {
+
+ var contentElement = this._fetchContentElement(options);
+
+ return this.$q.resolve({
+ element: contentElement.element,
+ cleanup: contentElement.restore,
+ locals: {},
+ link: function() {
+ return contentElement.element;
+ }
+ });
+
+ };
+
+ /**
+ * Compiles a template by considering all options and waiting for all resolves to be ready.
+ * @param {!Object} options Compile options
+ * @returns {!Q.Promise<{element: JQLite, link: Function, locals: Object, cleanup: any}>} Compile
+ * data with link function.
+ */
+ MdCompilerService.prototype._compileTemplate = function(options) {
+
+ var self = this;
+ var templateUrl = options.templateUrl;
+ var template = options.template || '';
+ var resolve = angular.extend({}, options.resolve);
+ var locals = angular.extend({}, options.locals);
+ var transformTemplate = options.transformTemplate || angular.identity;
+
+ // Take resolve values and invoke them.
+ // Resolves can either be a string (value: 'MyRegisteredAngularConst'),
+ // or an invokable 'factory' of sorts: (value: function ValueGetter($dependency) {})
+ angular.forEach(resolve, function(value, key) {
+ if (angular.isString(value)) {
+ resolve[key] = self.$injector.get(value);
+ } else {
+ resolve[key] = self.$injector.invoke(value);
+ }
+ });
+
+ // Add the locals, which are just straight values to inject
+ // eg locals: { three: 3 }, will inject three into the controller
+ angular.extend(resolve, locals);
+
+ if (templateUrl) {
+ resolve.$$ngTemplate = this.$templateRequest(templateUrl);
+ } else {
+ resolve.$$ngTemplate = this.$q.when(template);
+ }
+
+
+ // Wait for all the resolves to finish if they are promises
+ return this.$q.all(resolve).then(function(locals) {
+
+ var template = transformTemplate(locals.$$ngTemplate, options);
+ var element = options.element || angular.element('<div>').html(template.trim()).contents();
+
+ return self._compileElement(locals, element, options);
+ });
+
+ };
+
+ /**
+ * Method to compile an element with the given options.
+ * @param {!Object} locals Locals to be injected to the controller if present
+ * @param {!JQLite} element Element to be compiled and linked
+ * @param {!Object} options Options to be used for linking.
+ * @returns {!{element: JQLite, link: Function, locals: Object, cleanup: any, controller: Object}} Compile data with link function.
+ */
+ MdCompilerService.prototype._compileElement = function(locals, element, options) {
+ var self = this;
+ var ngLinkFn = this.$compile(element);
+
+ var compileData = {
+ element: element,
+ cleanup: element.remove.bind(element),
+ locals: locals,
+ link: linkFn
+ };
+
+ function linkFn(scope) {
+ locals.$scope = scope;
+
+ // Instantiate controller if the developer provided one.
+ if (options.controller) {
+
+ var injectLocals = angular.extend({}, locals, {
+ $element: element
+ });
+
+ // Create the specified controller instance.
+ var ctrl = self._createController(options, injectLocals, locals);
+
+ // Registering extra $destroy listeners should be avoided.
+ // Only register the listener if the controller implements a $onDestroy hook.
+ if (angular.isFunction(ctrl.$onDestroy)) {
+ scope.$on('$destroy', function() {
+ // Call the $onDestroy hook if it's present on the controller.
+ angular.isFunction(ctrl.$onDestroy) && ctrl.$onDestroy();
+ });
+ }
+
+ // Unique identifier for AngularJS Route ngView controllers.
+ element.data('$ngControllerController', ctrl);
+ element.children().data('$ngControllerController', ctrl);
+
+ // Expose the instantiated controller to the compile data
+ compileData.controller = ctrl;
+ }
+
+ // Invoke the AngularJS $compile link function.
+ return ngLinkFn(scope);
+ }
+
+ return compileData;
+
+ };
+
+ /**
+ * Creates and instantiates a new controller with the specified options.
+ * @param {!Object} options Options that include the controller function or string.
+ * @param {!Object} injectLocals Locals to to be provided in the controller DI.
+ * @param {!Object} locals Locals to be injected to the controller.
+ * @returns {!Object} Created controller instance.
+ */
+ MdCompilerService.prototype._createController = function(options, injectLocals, locals) {
+ var ctrl = this.$controller(options.controller, injectLocals);
+
+ if (options.bindToController) {
+ angular.extend(ctrl, locals);
+ }
+
+ if (options.controllerAs) {
+ injectLocals.$scope[options.controllerAs] = ctrl;
+ }
+
+ // Call the $onInit hook if it's present on the controller.
+ angular.isFunction(ctrl.$onInit) && ctrl.$onInit();
+
+ return ctrl;
+ };
+
+ /**
+ * Fetches an element removing it from the DOM and using it temporary for the compiler.
+ * Elements which were fetched will be restored after use.
+ * @param {!Object} options Options to be used for the compilation.
+ * @returns {{element: !JQLite, restore: !function}}
+ */
+ MdCompilerService.prototype._fetchContentElement = function(options) {
+ var contentEl = options.contentElement;
+ var restoreFn;
+
+ if (angular.isString(contentEl)) {
+ contentEl = document.querySelector(contentEl);
+ restoreFn = createRestoreFn(contentEl);
+ } else {
+ contentEl = contentEl[0] || contentEl;
+
+ // When the element is visible in the DOM, then we restore it at close of the dialog.
+ // Otherwise it will be removed from the DOM after close.
+ if (document.contains(contentEl)) {
+ restoreFn = createRestoreFn(contentEl);
+ } else {
+ restoreFn = function() {
+ if (contentEl.parentNode) {
+ contentEl.parentNode.removeChild(contentEl);
+ }
+ };
+ }
+ }
+
+ return {
+ element: angular.element(contentEl),
+ restore: restoreFn
+ };
+
+ function createRestoreFn(element) {
+ var parent = element.parentNode;
+ var nextSibling = element.nextElementSibling;
+
+ return function() {
+ if (!nextSibling) {
+ // When the element didn't had any sibling, then it can be simply appended to the
+ // parent, because it plays no role, which index it had before.
+ parent.appendChild(element);
+ } else {
+ // When the element had a sibling, which marks the previous position of the element
+ // in the DOM, we insert it correctly before the sibling, to have the same index as
+ // before.
+ parent.insertBefore(element, nextSibling);
+ }
+ };
+ }
+ };
+}
+
+
+})();
+(function(){
+"use strict";
+
+
+MdGesture.$inject = ["$$MdGestureHandler", "$$rAF", "$timeout", "$mdUtil"];
+attachToDocument.$inject = ["$mdGesture", "$$MdGestureHandler", "$mdUtil"];var HANDLERS = {};
+
+/**
+ * The state of the current 'pointer'. The pointer represents the state of the current touch.
+ * It contains normalized x and y coordinates from DOM events,
+ * as well as other information abstracted from the DOM.
+ */
+var pointer, lastPointer, maxClickDistance = 6;
+var forceSkipClickHijack = false, disableAllGestures = false;
+
+/**
+ * The position of the most recent click if that click was on a label element.
+ * @type {{x: number, y: number}|null}
+ */
+var lastLabelClickPos = null;
+
+/**
+ * Used to attach event listeners once when multiple ng-apps are running.
+ * @type {boolean}
+ */
+var isInitialized = false;
+
+/**
+ * @ngdoc module
+ * @name material.core.gestures
+ * @description
+ * AngularJS Material Gesture handling for touch devices.
+ * This module replaced the usage of the HammerJS library.
+ */
+angular
+ .module('material.core.gestures', [])
+ .provider('$mdGesture', MdGestureProvider)
+ .factory('$$MdGestureHandler', MdGestureHandler)
+ .run(attachToDocument);
+
+/**
+ * @ngdoc service
+ * @name $mdGestureProvider
+ * @module material.core.gestures
+ *
+ * @description
+ * In some scenarios on mobile devices (without jQuery), the click events should NOT be hijacked.
+ * `$mdGestureProvider` is used to configure the Gesture module to ignore or skip click hijacking
+ * on mobile devices.
+ *
+ * You can also change the max click distance, `6px` by default, if you have issues on some touch
+ * screens.
+ *
+ * <hljs lang="js">
+ * app.config(function($mdGestureProvider) {
+ *
+ * // For mobile devices without jQuery loaded, do not
+ * // intercept click events during the capture phase.
+ * $mdGestureProvider.skipClickHijack();
+ *
+ * // If hijacking clicks, you may want to change the default click distance
+ * $mdGestureProvider.setMaxClickDistance(12);
+ * });
+ * </hljs>
+ *
+ */
+function MdGestureProvider() { }
+
+MdGestureProvider.prototype = {
+
+ /**
+ * @ngdoc method
+ * @name $mdGestureProvider#disableAll
+ *
+ * @description
+ * Disable all gesture detection. This can be beneficial to application performance
+ * and memory usage.
+ */
+ disableAll: function () {
+ disableAllGestures = true;
+ },
+
+ // Publish access to setter to configure a variable BEFORE the
+ // $mdGesture service is instantiated...
+ /**
+ * @ngdoc method
+ * @name $mdGestureProvider#skipClickHijack
+ *
+ * @description
+ * Tell the AngularJS Material Gesture module to skip (or ignore) click hijacking on mobile devices.
+ */
+ skipClickHijack: function() {
+ return forceSkipClickHijack = true;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $mdGestureProvider#setMaxClickDistance
+ * @param clickDistance {string} Distance in pixels. I.e. `12px`.
+ * @description
+ * Set the max distance from the origin of the touch event to trigger touch handlers.
+ */
+ setMaxClickDistance: function(clickDistance) {
+ maxClickDistance = parseInt(clickDistance);
+ },
+
+ /**
+ * $get is used to build an instance of $mdGesture
+ * @ngInject
+ */
+ $get : ["$$MdGestureHandler", "$$rAF", "$timeout", "$mdUtil", function($$MdGestureHandler, $$rAF, $timeout, $mdUtil) {
+ return new MdGesture($$MdGestureHandler, $$rAF, $timeout, $mdUtil);
+ }]
+};
+
+
+
+/**
+ * MdGesture factory construction function
+ * @ngInject
+ */
+function MdGesture($$MdGestureHandler, $$rAF, $timeout, $mdUtil) {
+ var touchActionProperty = $mdUtil.getTouchAction();
+ var hasJQuery = (typeof __webpack_provided_window_dot_jQuery !== 'undefined') && (angular.element === __webpack_provided_window_dot_jQuery);
+
+ var self = {
+ handler: addHandler,
+ register: register,
+ isAndroid: $mdUtil.isAndroid,
+ isIos: $mdUtil.isIos,
+ // On mobile w/out jQuery, we normally intercept clicks. Should we skip that?
+ isHijackingClicks: ($mdUtil.isIos || $mdUtil.isAndroid) && !hasJQuery && !forceSkipClickHijack
+ };
+
+ if (self.isHijackingClicks) {
+ self.handler('click', {
+ options: {
+ maxDistance: maxClickDistance
+ },
+ onEnd: checkDistanceAndEmit('click')
+ });
+
+ self.handler('focus', {
+ options: {
+ maxDistance: maxClickDistance
+ },
+ onEnd: function(ev, pointer) {
+ if (pointer.distance < this.state.options.maxDistance && canFocus(ev.target)) {
+ this.dispatchEvent(ev, 'focus', pointer);
+ ev.target.focus();
+ }
+ }
+ });
+
+ self.handler('mouseup', {
+ options: {
+ maxDistance: maxClickDistance
+ },
+ onEnd: checkDistanceAndEmit('mouseup')
+ });
+
+ self.handler('mousedown', {
+ onStart: function(ev) {
+ this.dispatchEvent(ev, 'mousedown');
+ }
+ });
+ }
+
+ function checkDistanceAndEmit(eventName) {
+ return function(ev, pointer) {
+ if (pointer.distance < this.state.options.maxDistance) {
+ this.dispatchEvent(ev, eventName, pointer);
+ }
+ };
+ }
+
+ /**
+ * Register an element to listen for a handler.
+ * This allows an element to override the default options for a handler.
+ * Additionally, some handlers like drag and hold only dispatch events if
+ * the domEvent happens inside an element that's registered to listen for these events.
+ *
+ * @see GestureHandler for how overriding of default options works.
+ * @example $mdGesture.register(myElement, 'drag', { minDistance: 20, horizontal: false })
+ */
+ function register(element, handlerName, options) {
+ var handler = HANDLERS[handlerName.replace(/^\$md./, '')];
+ if (!handler) {
+ throw new Error('Failed to register element with handler ' + handlerName + '. ' +
+ 'Available handlers: ' + Object.keys(HANDLERS).join(', '));
+ }
+ return handler.registerElement(element, options);
+ }
+
+ /*
+ * add a handler to $mdGesture. see below.
+ */
+ function addHandler(name, definition) {
+ var handler = new $$MdGestureHandler(name);
+ angular.extend(handler, definition);
+ HANDLERS[name] = handler;
+
+ return self;
+ }
+
+ /**
+ * Register handlers. These listen to touch/start/move events, interpret them,
+ * and dispatch gesture events depending on options & conditions. These are all
+ * instances of GestureHandler.
+ * @see GestureHandler
+ */
+ return self
+ /*
+ * The press handler dispatches an event on touchdown/touchend.
+ * It's a simple abstraction of touch/mouse/pointer start and end.
+ */
+ .handler('press', {
+ onStart: function (ev, pointer) {
+ this.dispatchEvent(ev, '$md.pressdown');
+ },
+ onEnd: function (ev, pointer) {
+ this.dispatchEvent(ev, '$md.pressup');
+ }
+ })
+
+ /*
+ * The hold handler dispatches an event if the user keeps their finger within
+ * the same <maxDistance> area for <delay> ms.
+ * The hold handler will only run if a parent of the touch target is registered
+ * to listen for hold events through $mdGesture.register()
+ */
+ .handler('hold', {
+ options: {
+ maxDistance: 6,
+ delay: 500
+ },
+ onCancel: function () {
+ $timeout.cancel(this.state.timeout);
+ },
+ onStart: function (ev, pointer) {
+ // For hold, require a parent to be registered with $mdGesture.register()
+ // Because we prevent scroll events, this is necessary.
+ if (!this.state.registeredParent) return this.cancel();
+
+ this.state.pos = {x: pointer.x, y: pointer.y};
+ this.state.timeout = $timeout(angular.bind(this, function holdDelayFn() {
+ this.dispatchEvent(ev, '$md.hold');
+ this.cancel(); // we're done!
+ }), this.state.options.delay, false);
+ },
+ onMove: function (ev, pointer) {
+ // Don't scroll while waiting for hold.
+ // If we don't preventDefault touchmove events here, Android will assume we don't
+ // want to listen to anymore touch events. It will start scrolling and stop sending
+ // touchmove events.
+ if (!touchActionProperty && ev.type === 'touchmove') ev.preventDefault();
+
+ // If the user moves greater than <maxDistance> pixels, stop the hold timer
+ // set in onStart
+ var dx = this.state.pos.x - pointer.x;
+ var dy = this.state.pos.y - pointer.y;
+ if (Math.sqrt(dx * dx + dy * dy) > this.options.maxDistance) {
+ this.cancel();
+ }
+ },
+ onEnd: function () {
+ this.onCancel();
+ }
+ })
+
+ /*
+ * The drag handler dispatches a drag event if the user holds and moves his finger greater than
+ * <minDistance> px in the x or y direction, depending on options.horizontal.
+ * The drag will be cancelled if the user moves his finger greater than <minDistance>*<cancelMultiplier> in
+ * the perpendicular direction. Eg if the drag is horizontal and the user moves his finger <minDistance>*<cancelMultiplier>
+ * pixels vertically, this handler won't consider the move part of a drag.
+ */
+ .handler('drag', {
+ options: {
+ minDistance: 6,
+ horizontal: true,
+ cancelMultiplier: 1.5
+ },
+ /**
+ * @param {angular.JQLite} element where touch action styles need to be adjusted
+ * @param {{horizontal: boolean}=} options object whose horizontal property can specify to
+ * apply 'pan-y' or 'pan-x' touch actions.
+ */
+ onSetup: function(element, options) {
+ if (touchActionProperty) {
+ // We check for horizontal to be false, because otherwise we would overwrite the default opts.
+ this.oldTouchAction = element[0].style[touchActionProperty];
+ element[0].style[touchActionProperty] = options.horizontal ? 'pan-y' : 'pan-x';
+ }
+ },
+ /**
+ * @param {angular.JQLite} element where styles need to be cleaned up
+ */
+ onCleanup: function(element) {
+ if (this.oldTouchAction) {
+ element[0].style[touchActionProperty] = this.oldTouchAction;
+ } else {
+ element[0].style[touchActionProperty] = null;
+ }
+ },
+ onStart: function (ev) {
+ // For drag, require a parent to be registered with $mdGesture.register()
+ if (!this.state.registeredParent) this.cancel();
+ },
+ onMove: function (ev, pointer) {
+ var shouldStartDrag, shouldCancel;
+ // Don't scroll while deciding if this touchmove qualifies as a drag event.
+ // If we don't preventDefault touchmove events here, Android will assume we don't
+ // want to listen to anymore touch events. It will start scrolling and stop sending
+ // touchmove events.
+ if (!touchActionProperty && ev.type === 'touchmove') ev.preventDefault();
+
+ if (!this.state.dragPointer) {
+ if (this.state.options.horizontal) {
+ shouldStartDrag = Math.abs(pointer.distanceX) > this.state.options.minDistance;
+ shouldCancel = Math.abs(pointer.distanceY) > this.state.options.minDistance * this.state.options.cancelMultiplier;
+ } else {
+ shouldStartDrag = Math.abs(pointer.distanceY) > this.state.options.minDistance;
+ shouldCancel = Math.abs(pointer.distanceX) > this.state.options.minDistance * this.state.options.cancelMultiplier;
+ }
+
+ if (shouldStartDrag) {
+ // Create a new pointer representing this drag, starting at this point where the drag started.
+ this.state.dragPointer = makeStartPointer(ev);
+ updatePointerState(ev, this.state.dragPointer);
+ this.dispatchEvent(ev, '$md.dragstart', this.state.dragPointer);
+
+ } else if (shouldCancel) {
+ this.cancel();
+ }
+ } else {
+ this.dispatchDragMove(ev);
+ }
+ },
+ // Only dispatch dragmove events every frame; any more is unnecessary
+ dispatchDragMove: $$rAF.throttle(function (ev) {
+ // Make sure the drag didn't stop while waiting for the next frame
+ if (this.state.isRunning) {
+ updatePointerState(ev, this.state.dragPointer);
+ this.dispatchEvent(ev, '$md.drag', this.state.dragPointer);
+ }
+ }),
+ onEnd: function (ev, pointer) {
+ if (this.state.dragPointer) {
+ updatePointerState(ev, this.state.dragPointer);
+ this.dispatchEvent(ev, '$md.dragend', this.state.dragPointer);
+ }
+ }
+ })
+
+ /*
+ * The swipe handler will dispatch a swipe event if, on the end of a touch,
+ * the velocity and distance were high enough.
+ */
+ .handler('swipe', {
+ options: {
+ minVelocity: 0.65,
+ minDistance: 10
+ },
+ onEnd: function (ev, pointer) {
+ var eventType;
+
+ if (Math.abs(pointer.velocityX) > this.state.options.minVelocity &&
+ Math.abs(pointer.distanceX) > this.state.options.minDistance) {
+ eventType = pointer.directionX == 'left' ? '$md.swipeleft' : '$md.swiperight';
+ this.dispatchEvent(ev, eventType);
+ }
+ else if (Math.abs(pointer.velocityY) > this.state.options.minVelocity &&
+ Math.abs(pointer.distanceY) > this.state.options.minDistance) {
+ eventType = pointer.directionY == 'up' ? '$md.swipeup' : '$md.swipedown';
+ this.dispatchEvent(ev, eventType);
+ }
+ }
+ });
+}
+
+/**
+ * MdGestureHandler
+ * A GestureHandler is an object which is able to dispatch custom dom events
+ * based on native dom {touch,pointer,mouse}{start,move,end} events.
+ *
+ * A gesture will manage its lifecycle through the start,move,end, and cancel
+ * functions, which are called by native dom events.
+ *
+ * A gesture has the concept of 'options' (eg. a swipe's required velocity), which can be
+ * overridden by elements registering through $mdGesture.register().
+ */
+function GestureHandler (name) {
+ this.name = name;
+ this.state = {};
+}
+
+function MdGestureHandler() {
+ var hasJQuery = (typeof __webpack_provided_window_dot_jQuery !== 'undefined') && (angular.element === __webpack_provided_window_dot_jQuery);
+
+ GestureHandler.prototype = {
+ options: {},
+ // jQuery listeners don't work with custom DOMEvents, so we have to dispatch events
+ // differently when jQuery is loaded
+ dispatchEvent: hasJQuery ? jQueryDispatchEvent : nativeDispatchEvent,
+
+ // These are overridden by the registered handler
+ onSetup: angular.noop,
+ onCleanup: angular.noop,
+ onStart: angular.noop,
+ onMove: angular.noop,
+ onEnd: angular.noop,
+ onCancel: angular.noop,
+
+ // onStart sets up a new state for the handler, which includes options from the
+ // nearest registered parent element of ev.target.
+ start: function (ev, pointer) {
+ if (this.state.isRunning) return;
+ var parentTarget = this.getNearestParent(ev.target);
+ // Get the options from the nearest registered parent
+ var parentTargetOptions = parentTarget && parentTarget.$mdGesture[this.name] || {};
+
+ this.state = {
+ isRunning: true,
+ // Override the default options with the nearest registered parent's options
+ options: angular.extend({}, this.options, parentTargetOptions),
+ // Pass in the registered parent node to the state so the onStart listener can use
+ registeredParent: parentTarget
+ };
+ this.onStart(ev, pointer);
+ },
+ move: function (ev, pointer) {
+ if (!this.state.isRunning) return;
+ this.onMove(ev, pointer);
+ },
+ end: function (ev, pointer) {
+ if (!this.state.isRunning) return;
+ this.state.isRunning = false;
+ this.onEnd(ev, pointer);
+ },
+ cancel: function (ev, pointer) {
+ this.onCancel(ev, pointer);
+ this.state = {};
+ },
+
+ // Find and return the nearest parent element that has been registered to
+ // listen for this handler via $mdGesture.register(element, 'handlerName').
+ getNearestParent: function (node) {
+ var current = node;
+ while (current) {
+ if ((current.$mdGesture || {})[this.name]) {
+ return current;
+ }
+ current = current.parentNode;
+ }
+ return null;
+ },
+
+ // Called from $mdGesture.register when an element registers itself with a handler.
+ // Store the options the user gave on the DOMElement itself. These options will
+ // be retrieved with getNearestParent when the handler starts.
+ registerElement: function (element, options) {
+ var self = this;
+ element[0].$mdGesture = element[0].$mdGesture || {};
+ element[0].$mdGesture[this.name] = options || {};
+ element.on('$destroy', onDestroy);
+
+ self.onSetup(element, options || {});
+
+ return onDestroy;
+
+ function onDestroy() {
+ delete element[0].$mdGesture[self.name];
+ element.off('$destroy', onDestroy);
+
+ self.onCleanup(element, options || {});
+ }
+ }
+ };
+
+ return GestureHandler;
+
+ /**
+ * Dispatch an event with jQuery
+ * TODO: Make sure this sends bubbling events
+ *
+ * @param srcEvent the original DOM touch event that started this.
+ * @param eventType the name of the custom event to send (eg 'click' or '$md.drag')
+ * @param eventPointer the pointer object that matches this event.
+ */
+ function jQueryDispatchEvent(srcEvent, eventType, eventPointer) {
+ eventPointer = eventPointer || pointer;
+ var eventObj = new angular.element.Event(eventType);
+
+ eventObj.$material = true;
+ eventObj.pointer = eventPointer;
+ eventObj.srcEvent = srcEvent;
+
+ angular.extend(eventObj, {
+ clientX: eventPointer.x,
+ clientY: eventPointer.y,
+ screenX: eventPointer.x,
+ screenY: eventPointer.y,
+ pageX: eventPointer.x,
+ pageY: eventPointer.y,
+ ctrlKey: srcEvent.ctrlKey,
+ altKey: srcEvent.altKey,
+ shiftKey: srcEvent.shiftKey,
+ metaKey: srcEvent.metaKey
+ });
+ angular.element(eventPointer.target).trigger(eventObj);
+ }
+
+ /**
+ * NOTE: nativeDispatchEvent is very performance sensitive.
+ * @param srcEvent the original DOM touch event that started this.
+ * @param eventType the name of the custom event to send (eg 'click' or '$md.drag')
+ * @param eventPointer the pointer object that matches this event.
+ */
+ function nativeDispatchEvent(srcEvent, eventType, eventPointer) {
+ eventPointer = eventPointer || pointer;
+ var eventObj;
+
+ if (eventType === 'click' || eventType === 'mouseup' || eventType === 'mousedown') {
+ if (typeof window.MouseEvent === "function") {
+ eventObj = new MouseEvent(eventType, {
+ bubbles: true,
+ cancelable: true,
+ screenX: Number(srcEvent.screenX),
+ screenY: Number(srcEvent.screenY),
+ clientX: Number(eventPointer.x),
+ clientY: Number(eventPointer.y),
+ ctrlKey: srcEvent.ctrlKey,
+ altKey: srcEvent.altKey,
+ shiftKey: srcEvent.shiftKey,
+ metaKey: srcEvent.metaKey,
+ button: srcEvent.button,
+ buttons: srcEvent.buttons,
+ relatedTarget: srcEvent.relatedTarget || null
+ });
+ } else {
+ eventObj = document.createEvent('MouseEvents');
+ // This has been deprecated
+ // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/initMouseEvent
+ eventObj.initMouseEvent(
+ eventType, true, true, window, srcEvent.detail,
+ eventPointer.x, eventPointer.y, eventPointer.x, eventPointer.y,
+ srcEvent.ctrlKey, srcEvent.altKey, srcEvent.shiftKey, srcEvent.metaKey,
+ srcEvent.button, srcEvent.relatedTarget || null
+ );
+ }
+ } else {
+ if (typeof window.CustomEvent === "function") {
+ eventObj = new CustomEvent(eventType, {
+ bubbles: true,
+ cancelable: true,
+ detail: {}
+ });
+ } else {
+ // This has been deprecated
+ // https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/initCustomEvent
+ eventObj = document.createEvent('CustomEvent');
+ eventObj.initCustomEvent(eventType, true, true, {});
+ }
+ }
+ eventObj.$material = true;
+ eventObj.pointer = eventPointer;
+ eventObj.srcEvent = srcEvent;
+ eventPointer.target.dispatchEvent(eventObj);
+ }
+}
+
+/**
+ * Attach Gestures: hook document and check shouldHijack clicks
+ * @ngInject
+ */
+function attachToDocument($mdGesture, $$MdGestureHandler, $mdUtil) {
+ if (disableAllGestures) {
+ return;
+ }
+
+ if (!isInitialized && $mdGesture.isHijackingClicks) {
+ /*
+ * If hijack clicks is true, we preventDefault any click that wasn't
+ * sent by AngularJS Material. This is because on older Android & iOS, a false, or 'ghost',
+ * click event will be sent ~400ms after a touchend event happens.
+ * The only way to know if this click is real is to prevent any normal
+ * click events, and add a flag to events sent by material so we know not to prevent those.
+ *
+ * Two exceptions to click events that should be prevented are:
+ * - click events sent by the keyboard (eg form submit)
+ * - events that originate from an Ionic app
+ */
+ document.addEventListener('click' , clickHijacker , true);
+ document.addEventListener('mouseup' , mouseInputHijacker, true);
+ document.addEventListener('mousedown', mouseInputHijacker, true);
+ document.addEventListener('focus' , mouseInputHijacker, true);
+
+ isInitialized = true;
+ }
+
+ function mouseInputHijacker(ev) {
+ var isKeyClick = !ev.clientX && !ev.clientY;
+
+ if (
+ !isKeyClick &&
+ !ev.$material &&
+ !ev.isIonicTap &&
+ !isInputEventFromLabelClick(ev) &&
+ (ev.type !== 'mousedown' || (!canFocus(ev.target) && !canFocus(document.activeElement)))
+ ) {
+ ev.preventDefault();
+ ev.stopPropagation();
+ }
+ }
+
+ /**
+ * Ignore click events that don't come from AngularJS Material, Ionic, Input Label clicks,
+ * or key presses that generate click events. This helps to ignore the ghost tap events on
+ * older mobile browsers that get sent after a 300-400ms delay.
+ * @param ev MouseEvent or modified MouseEvent with $material, pointer, and other fields
+ */
+ function clickHijacker(ev) {
+ var isKeyClick;
+ if ($mdUtil.isIos) {
+ isKeyClick = angular.isDefined(ev.webkitForce) && ev.webkitForce === 0;
+ } else {
+ isKeyClick = ev.clientX === 0 && ev.clientY === 0;
+ }
+ if (!isKeyClick && !ev.$material && !ev.isIonicTap && !isInputEventFromLabelClick(ev)) {
+ ev.preventDefault();
+ ev.stopPropagation();
+ lastLabelClickPos = null;
+ } else {
+ lastLabelClickPos = null;
+ if (ev.target.tagName.toLowerCase() === 'label') {
+ lastLabelClickPos = {x: ev.x, y: ev.y};
+ }
+ }
+ }
+
+
+ // Listen to all events to cover all platforms.
+ var START_EVENTS = 'mousedown touchstart pointerdown';
+ var MOVE_EVENTS = 'mousemove touchmove pointermove';
+ var END_EVENTS = 'mouseup mouseleave touchend touchcancel pointerup pointercancel';
+
+ angular.element(document)
+ .on(START_EVENTS, gestureStart)
+ .on(MOVE_EVENTS, gestureMove)
+ .on(END_EVENTS, gestureEnd)
+ // For testing
+ .on('$$mdGestureReset', function gestureClearCache () {
+ lastPointer = pointer = null;
+ });
+
+ /**
+ * When a DOM event happens, run all registered gesture handlers' lifecycle
+ * methods which match the DOM event.
+ * Eg. when a 'touchstart' event happens, runHandlers('start') will call and
+ * run `handler.cancel()` and `handler.start()` on all registered handlers.
+ */
+ function runHandlers(handlerEvent, event) {
+ var handler;
+ for (var name in HANDLERS) {
+ handler = HANDLERS[name];
+ if (handler instanceof $$MdGestureHandler) {
+
+ if (handlerEvent === 'start') {
+ // Run cancel to reset any handlers' state
+ handler.cancel();
+ }
+ handler[handlerEvent](event, pointer);
+ }
+ }
+ }
+
+ /*
+ * gestureStart vets if a start event is legitimate (and not part of a 'ghost click' from iOS/Android)
+ * If it is legitimate, we initiate the pointer state and mark the current pointer's type
+ * For example, for a touchstart event, mark the current pointer as a 'touch' pointer, so mouse events
+ * won't effect it.
+ */
+ function gestureStart(ev) {
+ // If we're already touched down, abort
+ if (pointer) return;
+
+ var now = +Date.now();
+
+ // iOS & old android bug: after a touch event, a click event is sent 350 ms later.
+ // If <400ms have passed, don't allow an event of a different type than the previous event
+ if (lastPointer && !typesMatch(ev, lastPointer) && (now - lastPointer.endTime < 1500)) {
+ return;
+ }
+
+ pointer = makeStartPointer(ev);
+
+ runHandlers('start', ev);
+ }
+
+ /**
+ * If a move event happens of the right type, update the pointer and run all the move handlers.
+ * "of the right type": if a mousemove happens but our pointer started with a touch event, do
+ * nothing.
+ */
+ function gestureMove(ev) {
+ if (!pointer || !typesMatch(ev, pointer)) return;
+
+ updatePointerState(ev, pointer);
+ runHandlers('move', ev);
+ }
+
+ /**
+ * If an end event happens of the right type, update the pointer, run endHandlers, and save the
+ * pointer as 'lastPointer'.
+ */
+ function gestureEnd(ev) {
+ if (!pointer || !typesMatch(ev, pointer)) return;
+
+ updatePointerState(ev, pointer);
+ pointer.endTime = +Date.now();
+
+ if (ev.type !== 'pointercancel') {
+ runHandlers('end', ev);
+ }
+
+ lastPointer = pointer;
+ pointer = null;
+ }
+
+}
+
+// ********************
+// Module Functions
+// ********************
+
+/*
+ * Initiate the pointer. x, y, and the pointer's type.
+ */
+function makeStartPointer(ev) {
+ var point = getEventPoint(ev);
+ var startPointer = {
+ startTime: +Date.now(),
+ target: ev.target,
+ // 'p' for pointer events, 'm' for mouse, 't' for touch
+ type: ev.type.charAt(0)
+ };
+ startPointer.startX = startPointer.x = point.pageX;
+ startPointer.startY = startPointer.y = point.pageY;
+ return startPointer;
+}
+
+/*
+ * return whether the pointer's type matches the event's type.
+ * Eg if a touch event happens but the pointer has a mouse type, return false.
+ */
+function typesMatch(ev, pointer) {
+ return ev && pointer && ev.type.charAt(0) === pointer.type;
+}
+
+/**
+ * Gets whether the given event is an input event that was caused by clicking on an
+ * associated label element.
+ *
+ * This is necessary because the browser will, upon clicking on a label element, fire an
+ * *extra* click event on its associated input (if any). mdGesture is able to flag the label
+ * click as with `$material` correctly, but not the second input click.
+ *
+ * In order to determine whether an input event is from a label click, we compare the (x, y) for
+ * the event to the (x, y) for the most recent label click (which is cleared whenever a non-label
+ * click occurs). Unfortunately, there are no event properties that tie the input and the label
+ * together (such as relatedTarget).
+ *
+ * @param {MouseEvent} event
+ * @returns {boolean}
+ */
+function isInputEventFromLabelClick(event) {
+ return lastLabelClickPos
+ && lastLabelClickPos.x === event.x
+ && lastLabelClickPos.y === event.y;
+}
+
+/*
+ * Update the given pointer based upon the given DOMEvent.
+ * Distance, velocity, direction, duration, etc
+ */
+function updatePointerState(ev, pointer) {
+ var point = getEventPoint(ev);
+ var x = pointer.x = point.pageX;
+ var y = pointer.y = point.pageY;
+
+ pointer.distanceX = x - pointer.startX;
+ pointer.distanceY = y - pointer.startY;
+ pointer.distance = Math.sqrt(
+ pointer.distanceX * pointer.distanceX + pointer.distanceY * pointer.distanceY
+ );
+
+ pointer.directionX = pointer.distanceX > 0 ? 'right' : pointer.distanceX < 0 ? 'left' : '';
+ pointer.directionY = pointer.distanceY > 0 ? 'down' : pointer.distanceY < 0 ? 'up' : '';
+
+ pointer.duration = +Date.now() - pointer.startTime;
+ pointer.velocityX = pointer.distanceX / pointer.duration;
+ pointer.velocityY = pointer.distanceY / pointer.duration;
+}
+
+/**
+ * Normalize the point where the DOM event happened whether it's touch or mouse.
+ * @returns point event obj with pageX and pageY on it.
+ */
+function getEventPoint(ev) {
+ ev = ev.originalEvent || ev; // support jQuery events
+ return (ev.touches && ev.touches[0]) ||
+ (ev.changedTouches && ev.changedTouches[0]) ||
+ ev;
+}
+
+/** Checks whether an element can be focused. */
+function canFocus(element) {
+ return (
+ !!element &&
+ element.getAttribute('tabindex') !== '-1' &&
+ !element.hasAttribute('disabled') &&
+ (
+ element.hasAttribute('tabindex') ||
+ element.hasAttribute('href') ||
+ element.isContentEditable ||
+ ['INPUT', 'SELECT', 'BUTTON', 'TEXTAREA', 'VIDEO', 'AUDIO'].indexOf(element.nodeName) !== -1
+ )
+ );
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.core.interaction
+ * @description
+ * User interaction detection to provide proper accessibility.
+ */
+MdInteractionService.$inject = ["$timeout", "$mdUtil", "$rootScope"];
+angular
+ .module('material.core.interaction', [])
+ .service('$mdInteraction', MdInteractionService);
+
+
+/**
+ * @ngdoc service
+ * @name $mdInteraction
+ * @module material.core.interaction
+ *
+ * @description
+ *
+ * Service which keeps track of the last interaction type and validates them for several browsers.
+ * The service hooks into the document's body and listens for touch, mouse and keyboard events.
+ *
+ * The most recent interaction type can be retrieved by calling the `getLastInteractionType` method.
+ *
+ * Here is an example markup for using the interaction service.
+ *
+ * <hljs lang="js">
+ * var lastType = $mdInteraction.getLastInteractionType();
+ *
+ * if (lastType === 'keyboard') {
+ * // We only restore the focus for keyboard users.
+ * restoreFocus();
+ * }
+ * </hljs>
+ *
+ */
+function MdInteractionService($timeout, $mdUtil, $rootScope) {
+ this.$timeout = $timeout;
+ this.$mdUtil = $mdUtil;
+ this.$rootScope = $rootScope;
+
+ // IE browsers can also trigger pointer events, which also leads to an interaction.
+ this.pointerEvent = 'MSPointerEvent' in window ? 'MSPointerDown' : 'PointerEvent' in window ? 'pointerdown' : null;
+ this.bodyElement = angular.element(document.body);
+ this.isBuffering = false;
+ this.bufferTimeout = null;
+ this.lastInteractionType = null;
+ this.lastInteractionTime = null;
+ this.inputHandler = this.onInputEvent.bind(this);
+ this.bufferedInputHandler = this.onBufferInputEvent.bind(this);
+
+ // Type Mappings for the different events
+ // There will be three three interaction types
+ // `keyboard`, `mouse` and `touch`
+ // type `pointer` will be evaluated in `pointerMap` for IE Browser events
+ this.inputEventMap = {
+ 'keydown': 'keyboard',
+ 'mousedown': 'mouse',
+ 'mouseenter': 'mouse',
+ 'touchstart': 'touch',
+ 'pointerdown': 'pointer',
+ 'MSPointerDown': 'pointer'
+ };
+
+ // IE PointerDown events will be validated in `touch` or `mouse`
+ // Index numbers referenced here: https://msdn.microsoft.com/library/windows/apps/hh466130.aspx
+ this.iePointerMap = {
+ 2: 'touch',
+ 3: 'touch',
+ 4: 'mouse'
+ };
+
+ this.initializeEvents();
+ this.$rootScope.$on('$destroy', this.deregister.bind(this));
+}
+
+/**
+ * Removes all event listeners created by $mdInteration on the
+ * body element.
+ */
+MdInteractionService.prototype.deregister = function() {
+
+ this.bodyElement.off('keydown mousedown', this.inputHandler);
+
+ if ('ontouchstart' in document.documentElement) {
+ this.bodyElement.off('touchstart', this.bufferedInputHandler);
+ }
+
+ if (this.pointerEvent) {
+ this.bodyElement.off(this.pointerEvent, this.inputHandler);
+ }
+
+};
+
+/**
+ * Initializes the interaction service, by registering all interaction events to the
+ * body element.
+ */
+MdInteractionService.prototype.initializeEvents = function() {
+
+ this.bodyElement.on('keydown mousedown', this.inputHandler);
+
+ if ('ontouchstart' in document.documentElement) {
+ this.bodyElement.on('touchstart', this.bufferedInputHandler);
+ }
+
+ if (this.pointerEvent) {
+ this.bodyElement.on(this.pointerEvent, this.inputHandler);
+ }
+
+};
+
+/**
+ * Event listener for normal interaction events, which should be tracked.
+ * @param event {MouseEvent|KeyboardEvent|PointerEvent|TouchEvent}
+ */
+MdInteractionService.prototype.onInputEvent = function(event) {
+ if (this.isBuffering) {
+ return;
+ }
+
+ var type = this.inputEventMap[event.type];
+
+ if (type === 'pointer') {
+ type = this.iePointerMap[event.pointerType] || event.pointerType;
+ }
+
+ this.lastInteractionType = type;
+ this.lastInteractionTime = this.$mdUtil.now();
+};
+
+/**
+ * Event listener for interaction events which should be buffered (touch events).
+ * @param event {TouchEvent}
+ */
+MdInteractionService.prototype.onBufferInputEvent = function(event) {
+ this.$timeout.cancel(this.bufferTimeout);
+
+ this.onInputEvent(event);
+ this.isBuffering = true;
+
+ // The timeout of 650ms is needed to delay the touchstart, because otherwise the touch will call
+ // the `onInput` function multiple times.
+ this.bufferTimeout = this.$timeout(function() {
+ this.isBuffering = false;
+ }.bind(this), 650, false);
+
+};
+
+/**
+ * @ngdoc method
+ * @name $mdInteraction#getLastInteractionType
+ * @description Retrieves the last interaction type triggered in body.
+ * @returns {string|null} Last interaction type.
+ */
+MdInteractionService.prototype.getLastInteractionType = function() {
+ return this.lastInteractionType;
+};
+
+/**
+ * @ngdoc method
+ * @name $mdInteraction#isUserInvoked
+ * @description Method to detect whether any interaction happened recently or not.
+ * @param {number=} checkDelay Time to check for any interaction to have been triggered.
+ * @returns {boolean} Whether there was any interaction or not.
+ */
+MdInteractionService.prototype.isUserInvoked = function(checkDelay) {
+ var delay = angular.isNumber(checkDelay) ? checkDelay : 15;
+
+ // Check for any interaction to be within the specified check time.
+ return this.lastInteractionTime >= this.$mdUtil.now() - delay;
+};
+
+})();
+(function(){
+"use strict";
+
+angular.module('material.core')
+ .provider('$$interimElement', InterimElementProvider);
+
+/**
+ * @ngdoc service
+ * @name $$interimElementProvider
+ * @module material.core.interimElement
+ *
+ * @description
+ *
+ * Factory that constructs `$$interimElement.$service` services.
+ * Used internally in material design for elements that appear on screen temporarily.
+ * The service provides a promise-like API for interacting with the temporary
+ * elements.
+ *
+ * <hljs lang="js">
+ * app.service('$mdToast', function($$interimElement) {
+ * var $mdToast = $$interimElement(toastDefaultOptions);
+ * return $mdToast;
+ * });
+ * </hljs>
+ *
+ * @param {object=} defaultOptions Options used by default for the `show` method on the service.
+ *
+ * @returns {$$interimElement.$service}
+ */
+
+function InterimElementProvider() {
+ InterimElementFactory.$inject = ["$document", "$q", "$rootScope", "$timeout", "$rootElement", "$animate", "$mdUtil", "$mdCompiler", "$mdTheming", "$injector", "$exceptionHandler"];
+ createInterimElementProvider.$get = InterimElementFactory;
+ return createInterimElementProvider;
+
+ /**
+ * Returns a new provider which allows configuration of a new interimElement
+ * service. Allows configuration of default options & methods for options,
+ * as well as configuration of 'preset' methods (eg dialog.basic(): basic is a preset method)
+ */
+ function createInterimElementProvider(interimFactoryName) {
+ factory.$inject = ["$$interimElement", "$injector"];
+ var EXPOSED_METHODS = ['onHide', 'onShow', 'onRemove'];
+
+ var customMethods = {};
+ var providerConfig = {
+ presets: {}
+ };
+
+ var provider = {
+ setDefaults: setDefaults,
+ addPreset: addPreset,
+ addMethod: addMethod,
+ $get: factory
+ };
+
+ /**
+ * all interim elements will come with the 'build' preset
+ */
+ provider.addPreset('build', {
+ methods: ['controller', 'controllerAs', 'resolve', 'multiple',
+ 'template', 'templateUrl', 'themable', 'transformTemplate', 'parent', 'contentElement']
+ });
+
+ return provider;
+
+ /**
+ * Save the configured defaults to be used when the factory is instantiated
+ */
+ function setDefaults(definition) {
+ providerConfig.optionsFactory = definition.options;
+ providerConfig.methods = (definition.methods || []).concat(EXPOSED_METHODS);
+ return provider;
+ }
+
+ /**
+ * Add a method to the factory that isn't specific to any interim element operations
+ */
+ function addMethod(name, fn) {
+ customMethods[name] = fn;
+ return provider;
+ }
+
+ /**
+ * Save the configured preset to be used when the factory is instantiated
+ */
+ function addPreset(name, definition) {
+ definition = definition || {};
+ definition.methods = definition.methods || [];
+ definition.options = definition.options || function() { return {}; };
+
+ if (/^cancel|hide|show$/.test(name)) {
+ throw new Error("Preset '" + name + "' in " + interimFactoryName + " is reserved!");
+ }
+ if (definition.methods.indexOf('_options') > -1) {
+ throw new Error("Method '_options' in " + interimFactoryName + " is reserved!");
+ }
+ providerConfig.presets[name] = {
+ methods: definition.methods.concat(EXPOSED_METHODS),
+ optionsFactory: definition.options,
+ argOption: definition.argOption
+ };
+ return provider;
+ }
+
+ function addPresetMethod(presetName, methodName, method) {
+ providerConfig.presets[presetName][methodName] = method;
+ }
+
+ /**
+ * Create a factory that has the given methods & defaults implementing interimElement
+ */
+ /* @ngInject */
+ function factory($$interimElement, $injector) {
+ var defaultMethods;
+ var defaultOptions;
+ var interimElementService = $$interimElement();
+
+ /*
+ * publicService is what the developer will be using.
+ * It has methods hide(), cancel(), show(), build(), and any other
+ * presets which were set during the config phase.
+ */
+ var publicService = {
+ hide: interimElementService.hide,
+ cancel: interimElementService.cancel,
+ show: showInterimElement,
+
+ // Special internal method to destroy an interim element without animations
+ // used when navigation changes causes a $scope.$destroy() action
+ destroy : destroyInterimElement
+ };
+
+
+ defaultMethods = providerConfig.methods || [];
+ // This must be invoked after the publicService is initialized
+ defaultOptions = invokeFactory(providerConfig.optionsFactory, {});
+
+ // Copy over the simple custom methods
+ angular.forEach(customMethods, function(fn, name) {
+ publicService[name] = fn;
+ });
+
+ angular.forEach(providerConfig.presets, function(definition, name) {
+ var presetDefaults = invokeFactory(definition.optionsFactory, {});
+ var presetMethods = (definition.methods || []).concat(defaultMethods);
+
+ // Every interimElement built with a preset has a field called `$type`,
+ // which matches the name of the preset.
+ // Eg in preset 'confirm', options.$type === 'confirm'
+ angular.extend(presetDefaults, { $type: name });
+
+ // This creates a preset class which has setter methods for every
+ // method given in the `.addPreset()` function, as well as every
+ // method given in the `.setDefaults()` function.
+ //
+ // @example
+ // .setDefaults({
+ // methods: ['hasBackdrop', 'clickOutsideToClose', 'escapeToClose', 'targetEvent'],
+ // options: dialogDefaultOptions
+ // })
+ // .addPreset('alert', {
+ // methods: ['title', 'ok'],
+ // options: alertDialogOptions
+ // })
+ //
+ // Set values will be passed to the options when interimElement.show() is called.
+ function Preset(opts) {
+ this._options = angular.extend({}, presetDefaults, opts);
+ }
+ angular.forEach(presetMethods, function(name) {
+ Preset.prototype[name] = function(value) {
+ this._options[name] = value;
+ return this;
+ };
+ });
+
+ // Create shortcut method for one-linear methods
+ if (definition.argOption) {
+ var methodName = 'show' + name.charAt(0).toUpperCase() + name.slice(1);
+ publicService[methodName] = function(arg) {
+ var config = publicService[name](arg);
+ return publicService.show(config);
+ };
+ }
+
+ // eg $mdDialog.alert() will return a new alert preset
+ publicService[name] = function(arg) {
+ // If argOption is supplied, eg `argOption: 'content'`, then we assume
+ // if the argument is not an options object then it is the `argOption` option.
+ //
+ // @example `$mdToast.simple('hello')` // sets options.content to hello
+ // // because argOption === 'content'
+ if (arguments.length && definition.argOption &&
+ !angular.isObject(arg) && !angular.isArray(arg)) {
+
+ return (new Preset())[definition.argOption](arg);
+
+ } else {
+ return new Preset(arg);
+ }
+
+ };
+ });
+
+ return publicService;
+
+ /**
+ *
+ */
+ function showInterimElement(opts) {
+ // opts is either a preset which stores its options on an _options field,
+ // or just an object made up of options
+ opts = opts || { };
+ if (opts._options) opts = opts._options;
+
+ return interimElementService.show(
+ angular.extend({}, defaultOptions, opts)
+ );
+ }
+
+ /**
+ * Special method to hide and destroy an interimElement WITHOUT
+ * any 'leave` or hide animations ( an immediate force hide/remove )
+ *
+ * NOTE: This calls the onRemove() subclass method for each component...
+ * which must have code to respond to `options.$destroy == true`
+ */
+ function destroyInterimElement(opts) {
+ return interimElementService.destroy(opts);
+ }
+
+ /**
+ * Helper to call $injector.invoke with a local of the factory name for
+ * this provider.
+ * If an $mdDialog is providing options for a dialog and tries to inject
+ * $mdDialog, a circular dependency error will happen.
+ * We get around that by manually injecting $mdDialog as a local.
+ */
+ function invokeFactory(factory, defaultVal) {
+ var locals = {};
+ locals[interimFactoryName] = publicService;
+ return $injector.invoke(factory || function() { return defaultVal; }, {}, locals);
+ }
+ }
+ }
+
+ /* @ngInject */
+ function InterimElementFactory($document, $q, $rootScope, $timeout, $rootElement, $animate,
+ $mdUtil, $mdCompiler, $mdTheming, $injector, $exceptionHandler) {
+ return function createInterimElementService() {
+ var SHOW_CANCELLED = false;
+
+ /**
+ * @ngdoc service
+ * @name $$interimElementProvider.$service
+ *
+ * @description
+ * A service used to control inserting and removing of an element from the DOM.
+ * It is used by $mdBottomSheet, $mdDialog, $mdToast, $mdMenu, $mdPanel, and $mdSelect.
+ */
+ var service;
+
+ var showPromises = []; // Promises for the interim's which are currently opening.
+ var hidePromises = []; // Promises for the interim's which are currently hiding.
+ var showingInterims = []; // Interim elements which are currently showing up.
+
+ // Publish instance $$interimElement service;
+ return service = {
+ show: show,
+ hide: waitForInterim(hide),
+ cancel: waitForInterim(cancel),
+ destroy : destroy,
+ $injector_: $injector
+ };
+
+ /**
+ * @ngdoc method
+ * @name $$interimElementProvider.$service#show
+ * @kind function
+ *
+ * @description
+ * Adds the `$interimElement` to the DOM and returns a special promise that will be resolved
+ * or rejected with hide or cancel, respectively.
+ *
+ * @param {Object} options map of options and values
+ * @returns {Promise} a Promise that will be resolved when hide() is called or rejected when
+ * cancel() is called.
+ */
+ function show(options) {
+ options = options || {};
+ var interimElement = new InterimElement(options || {});
+
+ // When an interim element is currently showing, we have to cancel it.
+ // Just hiding it, will resolve the InterimElement's promise, the promise should be
+ // rejected instead.
+ var hideAction = options.multiple ? $q.resolve() : $q.all(showPromises);
+
+ if (!options.multiple) {
+ // Wait for all opening interim's to finish their transition.
+ hideAction = hideAction.then(function() {
+ // Wait for all closing and showing interim's to be completely closed.
+ var promiseArray = hidePromises.concat(showingInterims.map(service.cancel));
+ return $q.all(promiseArray);
+ });
+ }
+
+ var showAction = hideAction.then(function() {
+
+ return interimElement
+ .show()
+ .then(function () {
+ showingInterims.push(interimElement);
+ })
+ .catch(function (reason) {
+ return reason;
+ })
+ .finally(function() {
+ showPromises.splice(showPromises.indexOf(showAction), 1);
+ });
+
+ });
+
+ showPromises.push(showAction);
+
+ // In AngularJS 1.6+, exceptions inside promises will cause a rejection. We need to handle
+ // the rejection and only log it if it's an error.
+ interimElement.deferred.promise.catch(function(fault) {
+ if (fault instanceof Error) {
+ $exceptionHandler(fault);
+ }
+
+ return fault;
+ });
+
+ // Return a promise that will be resolved when the interim
+ // element is hidden or cancelled...
+ return interimElement.deferred.promise;
+ }
+
+ /**
+ * @ngdoc method
+ * @name $$interimElementProvider.$service#hide
+ * @kind function
+ *
+ * @description
+ * Removes the `$interimElement` from the DOM and resolves the Promise returned from `show()`.
+ *
+ * @param {*} reason Data used to resolve the Promise
+ * @param {object} options map of options and values
+ * @returns {Promise} a Promise that will be resolved after the element has been removed
+ * from the DOM.
+ */
+ function hide(reason, options) {
+ options = options || {};
+
+ if (options.closeAll) {
+ // We have to make a shallow copy of the array, because otherwise the map will break.
+ return $q.all(showingInterims.slice().reverse().map(closeElement));
+ } else if (options.closeTo !== undefined) {
+ return $q.all(showingInterims.slice(options.closeTo).map(closeElement));
+ }
+
+ // Hide the latest showing interim element.
+ return closeElement(showingInterims[showingInterims.length - 1]);
+
+ /**
+ * @param {InterimElement} interim element to close
+ * @returns {Promise<InterimElement>}
+ */
+ function closeElement(interim) {
+ if (!interim) {
+ return $q.when(reason);
+ }
+
+ var hideAction = interim
+ .remove(reason, false, options || { })
+ .catch(function(reason) { return reason; })
+ .finally(function() {
+ hidePromises.splice(hidePromises.indexOf(hideAction), 1);
+ });
+
+ showingInterims.splice(showingInterims.indexOf(interim), 1);
+ hidePromises.push(hideAction);
+
+ return interim.deferred.promise;
+ }
+ }
+
+ /**
+ * @ngdoc method
+ * @name $$interimElementProvider.$service#cancel
+ * @kind function
+ *
+ * @description
+ * Removes the `$interimElement` from the DOM and rejects the Promise returned from `show()`.
+ *
+ * @param {*} reason Data used to resolve the Promise
+ * @param {object} options map of options and values
+ * @returns {Promise} Promise that will be resolved after the element has been removed
+ * from the DOM.
+ */
+ function cancel(reason, options) {
+ var interim = showingInterims.pop();
+ if (!interim) {
+ return $q.when(reason);
+ }
+
+ var cancelAction = interim
+ .remove(reason, true, options || {})
+ .catch(function(reason) { return reason; })
+ .finally(function() {
+ hidePromises.splice(hidePromises.indexOf(cancelAction), 1);
+ });
+
+ hidePromises.push(cancelAction);
+
+ // Since AngularJS 1.6.7, promises will be logged to $exceptionHandler when the promise
+ // is not handling the rejection. We create a pseudo catch handler, which will prevent the
+ // promise from being logged to the $exceptionHandler.
+ return interim.deferred.promise.catch(angular.noop);
+ }
+
+ /**
+ * Creates a function to wait for at least one interim element to be available.
+ * @param callbackFn Function to be used as callback
+ * @returns {Function}
+ */
+ function waitForInterim(callbackFn) {
+ return function() {
+ var fnArguments = arguments;
+
+ if (!showingInterims.length) {
+ // When there are still interim's opening, then wait for the first interim element to
+ // finish its open animation.
+ if (showPromises.length) {
+ return showPromises[0].finally(function () {
+ return callbackFn.apply(service, fnArguments);
+ });
+ }
+
+ return $q.when("No interim elements currently showing up.");
+ }
+
+ return callbackFn.apply(service, fnArguments);
+ };
+ }
+
+ /**
+ * @ngdoc method
+ * @name $$interimElementProvider.$service#destroy
+ * @kind function
+ *
+ * Special method to quick-remove the interim element without running animations. This is
+ * useful when the parent component has been or is being destroyed.
+ *
+ * Note: interim elements are in "interim containers".
+ */
+ function destroy(targetEl) {
+ var interim = !targetEl ? showingInterims.shift() : null;
+
+ var parentEl = angular.element(targetEl).length && angular.element(targetEl)[0].parentNode;
+
+ if (parentEl) {
+ // Try to find the interim in the stack which corresponds to the supplied DOM element.
+ var filtered = showingInterims.filter(function(entry) {
+ return entry.options.element[0] === parentEl;
+ });
+
+ // Note: This function might be called when the element already has been removed,
+ // in which case we won't find any matches.
+ if (filtered.length) {
+ interim = filtered[0];
+ showingInterims.splice(showingInterims.indexOf(interim), 1);
+ }
+ }
+
+ return interim ? interim.remove(SHOW_CANCELLED, false, { '$destroy': true }) :
+ $q.when(SHOW_CANCELLED);
+ }
+
+ /*
+ * Internal Interim Element Object
+ * Used internally to manage the DOM element and related data
+ */
+ function InterimElement(options) {
+ var self, element, showAction = $q.when(true);
+
+ options = configureScopeAndTransitions(options);
+
+ return self = {
+ options : options,
+ deferred: $q.defer(),
+ show : createAndTransitionIn,
+ remove : transitionOutAndRemove
+ };
+
+ /**
+ * Compile, link, and show this interim element. Use optional autoHide and transition-in
+ * effects.
+ * @return {Q.Promise}
+ */
+ function createAndTransitionIn() {
+ return $q(function(resolve, reject) {
+
+ // Trigger onCompiling callback before the compilation starts.
+ // This is useful, when modifying options, which can be influenced by developers.
+ options.onCompiling && options.onCompiling(options);
+
+ compileElement(options)
+ .then(function(compiledData) {
+ element = linkElement(compiledData, options);
+
+ // Expose the cleanup function from the compiler.
+ options.cleanupElement = compiledData.cleanup;
+
+ showAction = showElement(element, options, compiledData.controller)
+ .then(resolve, rejectAll);
+ }).catch(rejectAll);
+
+ function rejectAll(fault) {
+ // Force the '$md<xxx>.show()' promise to reject
+ self.deferred.reject(fault);
+
+ // Continue rejection propagation
+ reject(fault);
+ }
+ });
+ }
+
+ /**
+ * After the show process has finished/rejected:
+ * - announce 'removing',
+ * - perform the transition-out, and
+ * - perform optional clean up scope.
+ */
+ function transitionOutAndRemove(response, isCancelled, opts) {
+
+ // abort if the show() and compile failed
+ if (!element) return $q.when(false);
+
+ options = angular.extend(options || {}, opts || {});
+ options.cancelAutoHide && options.cancelAutoHide();
+ options.element.triggerHandler('$mdInterimElementRemove');
+
+ if (options.$destroy === true) {
+
+ return hideElement(options.element, options).then(function(){
+ (isCancelled && rejectAll(response)) || resolveAll(response);
+ });
+
+ } else {
+ $q.when(showAction).finally(function() {
+ hideElement(options.element, options).then(function() {
+ isCancelled ? rejectAll(response) : resolveAll(response);
+ }, rejectAll);
+ });
+
+ return self.deferred.promise;
+ }
+
+
+ /**
+ * The `show()` returns a promise that will be resolved when the interim
+ * element is hidden or cancelled...
+ */
+ function resolveAll(response) {
+ self.deferred.resolve(response);
+ }
+
+ /**
+ * Force the '$md<xxx>.show()' promise to reject
+ */
+ function rejectAll(fault) {
+ self.deferred.reject(fault);
+ }
+ }
+
+ /**
+ * Prepare optional isolated scope and prepare $animate with default enter and leave
+ * transitions for the new element instance.
+ */
+ function configureScopeAndTransitions(options) {
+ options = options || { };
+ if (options.template) {
+ options.template = $mdUtil.processTemplate(options.template);
+ }
+
+ return angular.extend({
+ preserveScope: false,
+ cancelAutoHide : angular.noop,
+ scope: options.scope || $rootScope.$new(options.isolateScope),
+
+ /**
+ * Default usage to enable $animate to transition-in; can be easily overridden via 'options'
+ */
+ onShow: function transitionIn(scope, element, options) {
+ return $animate.enter(element, options.parent);
+ },
+
+ /**
+ * Default usage to enable $animate to transition-out; can be easily overridden via 'options'
+ */
+ onRemove: function transitionOut(scope, element) {
+ // Element could be undefined if a new element is shown before
+ // the old one finishes compiling.
+ return element && $animate.leave(element) || $q.when();
+ }
+ }, options);
+
+ }
+
+ /**
+ * Compile an element with a templateUrl, controller, and locals
+ * @param {Object} options
+ * @return {Q.Promise<{element: JQLite=, link: Function, locals: Object, cleanup: any=,
+ * controller: Object=}>}
+ */
+ function compileElement(options) {
+
+ var compiled = !options.skipCompile ? $mdCompiler.compile(options) : null;
+
+ return compiled || $q(function (resolve) {
+ resolve({
+ locals: {},
+ link: function () {
+ return options.element;
+ }
+ });
+ });
+ }
+
+ /**
+ * Link an element with compiled configuration
+ * @param {{element: JQLite=, link: Function, locals: Object, controller: Object=}} compileData
+ * @param {Object} options
+ * @return {JQLite}
+ */
+ function linkElement(compileData, options) {
+ angular.extend(compileData.locals, options);
+
+ var element = compileData.link(options.scope);
+
+ // Search for parent at insertion time, if not specified
+ options.element = element;
+ options.parent = findParent(element, options);
+ if (options.themable) $mdTheming(element);
+
+ return element;
+ }
+
+ /**
+ * Search for parent at insertion time, if not specified.
+ * @param {JQLite} element
+ * @param {Object} options
+ * @return {JQLite}
+ */
+ function findParent(element, options) {
+ var parent = options.parent;
+
+ // Search for parent at insertion time, if not specified
+ if (angular.isFunction(parent)) {
+ parent = parent(options.scope, element, options);
+ } else if (angular.isString(parent)) {
+ parent = angular.element($document[0].querySelector(parent));
+ } else {
+ parent = angular.element(parent);
+ }
+
+ // If parent querySelector/getter function fails, or it's just null,
+ // find a default.
+ if (!(parent || {}).length) {
+ var el;
+ if ($rootElement[0] && $rootElement[0].querySelector) {
+ el = $rootElement[0].querySelector(':not(svg) > body');
+ }
+ if (!el) el = $rootElement[0];
+ if (el.nodeName === '#comment') {
+ el = $document[0].body;
+ }
+ return angular.element(el);
+ }
+
+ return parent;
+ }
+
+ /**
+ * If auto-hide is enabled, start timer and prepare cancel function
+ */
+ function startAutoHide() {
+ var autoHideTimer, cancelAutoHide = angular.noop;
+
+ if (options.hideDelay) {
+ autoHideTimer = $timeout(service.hide, options.hideDelay) ;
+ cancelAutoHide = function() {
+ $timeout.cancel(autoHideTimer);
+ };
+ }
+
+ // Cache for subsequent use
+ options.cancelAutoHide = function() {
+ cancelAutoHide();
+ options.cancelAutoHide = undefined;
+ };
+ }
+
+ /**
+ * Show the element (with transitions), notify complete and start optional auto hiding
+ * timer.
+ * @param {JQLite} element
+ * @param {Object} options
+ * @param {Object} controller
+ * @return {Q.Promise<JQLite>}
+ */
+ function showElement(element, options, controller) {
+ // Trigger onShowing callback before the `show()` starts
+ var notifyShowing = options.onShowing || angular.noop;
+ // Trigger onComplete callback when the `show()` finishes
+ var notifyComplete = options.onComplete || angular.noop;
+
+ // Necessary for consistency between AngularJS 1.5 and 1.6.
+ try {
+ // This fourth controller parameter is used by $mdDialog in beforeShow().
+ notifyShowing(options.scope, element, options, controller);
+ } catch (e) {
+ return $q.reject(e);
+ }
+
+ return $q(function (resolve, reject) {
+ try {
+ // Start transitionIn
+ $q.when(options.onShow(options.scope, element, options))
+ .then(function () {
+ notifyComplete(options.scope, element, options);
+ startAutoHide();
+
+ resolve(element);
+ }, reject);
+
+ } catch (e) {
+ reject(e.message);
+ }
+ });
+ }
+
+ function hideElement(element, options) {
+ var announceRemoving = options.onRemoving || angular.noop;
+
+ return $q(function (resolve, reject) {
+ try {
+ // Start transitionIn
+ var action = $q.when(options.onRemove(options.scope, element, options) || true);
+
+ // Trigger callback *before* the remove operation starts
+ announceRemoving(element, action);
+
+ if (options.$destroy) {
+ // For $destroy, onRemove should be synchronous
+ resolve(element);
+
+ if (!options.preserveScope && options.scope) {
+ // scope destroy should still be be done after the current digest is done
+ action.then(function() { options.scope.$destroy(); });
+ }
+ } else {
+ // Wait until transition-out is done
+ action.then(function () {
+ if (!options.preserveScope && options.scope) {
+ options.scope.$destroy();
+ }
+
+ resolve(element);
+ }, reject);
+ }
+ } catch (e) {
+ reject(e.message);
+ }
+ });
+ }
+
+ }
+ };
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ var $mdUtil, $interpolate, $log;
+
+ var SUFFIXES = /(-gt)?-(sm|md|lg|print)/g;
+ var WHITESPACE = /\s+/g;
+
+ var FLEX_OPTIONS = ['grow', 'initial', 'auto', 'none', 'noshrink', 'nogrow'];
+ var LAYOUT_OPTIONS = ['row', 'column'];
+ var ALIGNMENT_MAIN_AXIS= ["", "start", "center", "end", "stretch", "space-around", "space-between"];
+ var ALIGNMENT_CROSS_AXIS= ["", "start", "center", "end", "stretch"];
+
+ var config = {
+ /**
+ * Enable directive attribute-to-class conversions
+ * Developers can use `<body md-layout-css />` to quickly
+ * disable the Layout directives and prohibit the injection of Layout classNames
+ */
+ enabled: true,
+
+ /**
+ * List of mediaQuery breakpoints and associated suffixes
+ * [
+ * { suffix: "sm", mediaQuery: "screen and (max-width: 599px)" },
+ * { suffix: "md", mediaQuery: "screen and (min-width: 600px) and (max-width: 959px)" }
+ * ]
+ */
+ breakpoints: []
+ };
+
+ registerLayoutAPI(angular.module('material.core.layout', ['ng']));
+
+ /**
+ * registerLayoutAPI()
+ *
+ * The original AngularJS Material Layout solution used attribute selectors and CSS.
+ *
+ * ```html
+ * <div layout="column"> My Content </div>
+ * ```
+ *
+ * ```css
+ * [layout] {
+ * box-sizing: border-box;
+ * display:flex;
+ * }
+ * [layout=column] {
+ * flex-direction : column
+ * }
+ * ```
+ *
+ * Use of attribute selectors creates significant performance impacts in some
+ * browsers... mainly IE.
+ *
+ * This module registers directives that allow the same layout attributes to be
+ * interpreted and converted to class selectors. The directive will add equivalent classes to
+ * each element that contains a Layout directive.
+ *
+ * ```html
+ * <div layout="column" class="layout layout-column"> My Content </div>
+ * ```
+ *
+ * ```css
+ * .layout {
+ * box-sizing: border-box;
+ * display:flex;
+ * }
+ * .layout-column {
+ * flex-direction : column
+ * }
+ * ```
+ */
+ function registerLayoutAPI(module){
+ var PREFIX_REGEXP = /^((?:x|data)[:\-_])/i;
+ var SPECIAL_CHARS_REGEXP = /([:\-_]+(.))/g;
+
+ // NOTE: these are also defined in constants::MEDIA_PRIORITY and constants::MEDIA
+ var BREAKPOINTS = ["", "xs", "gt-xs", "sm", "gt-sm", "md", "gt-md", "lg", "gt-lg", "xl", "print"];
+ var API_WITH_VALUES = ["layout", "flex", "flex-order", "flex-offset", "layout-align"];
+ var API_NO_VALUES = ["show", "hide", "layout-padding", "layout-margin"];
+
+
+ // Build directive registration functions for the standard Layout API... for all breakpoints.
+ angular.forEach(BREAKPOINTS, function(mqb) {
+
+ // Attribute directives with expected, observable value(s)
+ angular.forEach(API_WITH_VALUES, function(name){
+ var fullName = mqb ? name + "-" + mqb : name;
+ module.directive(directiveNormalize(fullName), attributeWithObserve(fullName));
+ });
+
+ // Attribute directives with no expected value(s)
+ angular.forEach(API_NO_VALUES, function(name){
+ var fullName = mqb ? name + "-" + mqb : name;
+ module.directive(directiveNormalize(fullName), attributeWithoutValue(fullName));
+ });
+
+ });
+
+ // Register other, special directive functions for the Layout features:
+ module
+ .provider('$$mdLayout', function() {
+ // Publish internal service for Layouts
+ return {
+ $get : angular.noop,
+ validateAttributeValue : validateAttributeValue,
+ validateAttributeUsage : validateAttributeUsage,
+ /**
+ * Easy way to disable/enable the Layout API.
+ * When disabled, this stops all attribute-to-classname generations
+ */
+ disableLayouts : function(isDisabled) {
+ config.enabled = (isDisabled !== true);
+ }
+ };
+ })
+
+ .directive('mdLayoutCss' , disableLayoutDirective)
+ .directive('ngCloak' , buildCloakInterceptor('ng-cloak'))
+
+ .directive('layoutWrap' , attributeWithoutValue('layout-wrap'))
+ .directive('layoutNowrap' , attributeWithoutValue('layout-nowrap'))
+ .directive('layoutNoWrap' , attributeWithoutValue('layout-no-wrap'))
+ .directive('layoutFill' , attributeWithoutValue('layout-fill'))
+
+ // Determine if
+ .config(detectDisabledLayouts);
+
+ /**
+ * Converts snake_case to camelCase.
+ * Also there is special case for Moz prefix starting with upper case letter.
+ * @param name Name to normalize
+ */
+ function directiveNormalize(name) {
+ return name
+ .replace(PREFIX_REGEXP, '')
+ .replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {
+ return offset ? letter.toUpperCase() : letter;
+ });
+ }
+ }
+
+
+ /**
+ * Detect if any of the HTML tags has a [md-layouts-disabled] attribute;
+ * If yes, then immediately disable all layout API features
+ *
+ * Note: this attribute should be specified on either the HTML or BODY tags
+ * @ngInject
+ */
+ function detectDisabledLayouts() {
+ var isDisabled = !!document.querySelector('[md-layouts-disabled]');
+ config.enabled = !isDisabled;
+ }
+
+ /**
+ * Special directive that will disable ALL Layout conversions of layout
+ * attribute(s) to classname(s).
+ *
+ * <link rel="stylesheet" href="angular-material.min.css">
+ * <link rel="stylesheet" href="angular-material.layout.css">
+ *
+ * <body md-layout-css>
+ * ...
+ * </body>
+ *
+ * Note: Using md-layout-css directive requires the developer to load the Material
+ * Layout Attribute stylesheet (which only uses attribute selectors):
+ *
+ * `angular-material.layout.css`
+ *
+ * Another option is to use the LayoutProvider to configure and disable the attribute
+ * conversions; this would obviate the use of the `md-layout-css` directive
+ */
+ function disableLayoutDirective() {
+ // Return a 1x-only, first-match attribute directive
+ config.enabled = false;
+
+ return {
+ restrict : 'A',
+ priority : '900'
+ };
+ }
+
+ /**
+ * Tail-hook ngCloak to delay the uncloaking while Layout transformers
+ * finish processing. Eliminates flicker with Material.Layouts
+ */
+ function buildCloakInterceptor(className) {
+ return ['$timeout', function($timeout){
+ return {
+ restrict : 'A',
+ priority : -10, // run after normal ng-cloak
+ compile : function(element) {
+ if (!config.enabled) return angular.noop;
+
+ // Re-add the cloak
+ element.addClass(className);
+
+ return function(scope, element) {
+ // Wait while layout injectors configure, then uncloak
+ // NOTE: $rAF does not delay enough... and this is a 1x-only event,
+ // $timeout is acceptable.
+ $timeout(function(){
+ element.removeClass(className);
+ }, 10, false);
+ };
+ }
+ };
+ }];
+ }
+
+
+ // *********************************************************************************
+ //
+ // These functions create registration functions for AngularJS Material Layout attribute
+ // directives. This provides easy translation to switch AngularJS Material attribute selectors to
+ // CLASS selectors and directives; which has huge performance implications for IE Browsers.
+ //
+ // *********************************************************************************
+
+ /**
+ * Creates a directive registration function where a possible dynamic attribute
+ * value will be observed/watched.
+ * @param {string} className attribute name; eg `layout-gt-md` with value ="row"
+ */
+ function attributeWithObserve(className) {
+
+ return ['$mdUtil', '$interpolate', "$log", function(_$mdUtil_, _$interpolate_, _$log_) {
+ $mdUtil = _$mdUtil_;
+ $interpolate = _$interpolate_;
+ $log = _$log_;
+
+ return {
+ restrict: 'A',
+ compile: function(element, attr) {
+ var linkFn;
+ if (config.enabled) {
+ // immediately replace static (non-interpolated) invalid values...
+
+ validateAttributeUsage(className, attr, element, $log);
+
+ validateAttributeValue(className,
+ getNormalizedAttrValue(className, attr, ""),
+ buildUpdateFn(element, className, attr)
+ );
+
+ linkFn = translateWithValueToCssClass;
+ }
+
+ // Use for postLink to account for transforms after ng-transclude.
+ return linkFn || angular.noop;
+ }
+ };
+ }];
+
+ /**
+ * Observe deprecated layout attributes and update the element's layout classes to match.
+ */
+ function translateWithValueToCssClass(scope, element, attrs) {
+ var updateFn = updateClassWithValue(element, className, attrs);
+ var unwatch = attrs.$observe(attrs.$normalize(className), updateFn);
+
+ updateFn(getNormalizedAttrValue(className, attrs, ""));
+ scope.$on("$destroy", function() { unwatch(); });
+ }
+ }
+
+ /**
+ * Creates a registration function for AngularJS Material Layout attribute directive.
+ * This is a `simple` transpose of attribute usage to class usage; where we ignore
+ * any attribute value.
+ */
+ function attributeWithoutValue(className) {
+ return ['$mdUtil', '$interpolate', "$log", function(_$mdUtil_, _$interpolate_, _$log_) {
+ $mdUtil = _$mdUtil_;
+ $interpolate = _$interpolate_;
+ $log = _$log_;
+
+ return {
+ restrict: 'A',
+ compile: function(element, attr) {
+ var linkFn;
+ if (config.enabled) {
+ // immediately replace static (non-interpolated) invalid values...
+
+ validateAttributeValue(className,
+ getNormalizedAttrValue(className, attr, ""),
+ buildUpdateFn(element, className, attr)
+ );
+
+ translateToCssClass(null, element);
+
+ // Use for postLink to account for transforms after ng-transclude.
+ linkFn = translateToCssClass;
+ }
+
+ return linkFn || angular.noop;
+ }
+ };
+ }];
+
+ /**
+ * Add transformed class selector.
+ */
+ function translateToCssClass(scope, element) {
+ element.addClass(className);
+ }
+ }
+
+ /**
+ * After link-phase, do NOT remove deprecated layout attribute selector.
+ * Instead watch the attribute so interpolated data-bindings to layout
+ * selectors will continue to be supported.
+ *
+ * $observe() the className and update with new class (after removing the last one)
+ *
+ * e.g. `layout="{{layoutDemo.direction}}"` will update...
+ *
+ * NOTE: The value must match one of the specified styles in the CSS.
+ * For example `flex-gt-md="{{size}}` where `scope.size == 47` will NOT work since
+ * only breakpoints for 0, 5, 10, 15... 100, 33, 34, 66, 67 are defined.
+ */
+ function updateClassWithValue(element, className) {
+ var lastClass;
+
+ return function updateClassFn(newValue) {
+ var value = validateAttributeValue(className, newValue || "");
+ if (angular.isDefined(value)) {
+ if (lastClass) element.removeClass(lastClass);
+ lastClass = !value ? className : className + "-" + value.trim().replace(WHITESPACE, "-");
+ element.addClass(lastClass);
+ }
+ };
+ }
+
+ /**
+ * Centralize warnings for known flexbox issues (especially IE-related issues)
+ */
+ function validateAttributeUsage(className, attr, element, $log){
+ var message, usage, url;
+ var nodeName = element[0].nodeName.toLowerCase();
+
+ switch (className.replace(SUFFIXES,"")) {
+ case "flex":
+ if ((nodeName === "md-button") || (nodeName === "fieldset")){
+ // @see https://github.com/philipwalton/flexbugs#9-some-html-elements-cant-be-flex-containers
+ // Use <div flex> wrapper inside (preferred) or outside
+
+ usage = "<" + nodeName + " " + className + "></" + nodeName + ">";
+ url = "https://github.com/philipwalton/flexbugs#9-some-html-elements-cant-be-flex-containers";
+ message = "Markup '{0}' may not work as expected in IE Browsers. Consult '{1}' for details.";
+
+ $log.warn($mdUtil.supplant(message, [usage, url]));
+ }
+ }
+ }
+
+
+ /**
+ * For the Layout attribute value, validate or replace with default fallback value.
+ */
+ function validateAttributeValue(className, value, updateFn) {
+ var origValue = value;
+
+ if (!needsInterpolation(value)) {
+ switch (className.replace(SUFFIXES,"")) {
+ case 'layout' :
+ if (!findIn(value, LAYOUT_OPTIONS)) {
+ value = LAYOUT_OPTIONS[0]; // 'row';
+ }
+ break;
+
+ case 'flex' :
+ if (!findIn(value, FLEX_OPTIONS)) {
+ if (isNaN(value)) {
+ value = '';
+ }
+ }
+ break;
+
+ case 'flex-offset' :
+ case 'flex-order' :
+ if (!value || isNaN(+value)) {
+ value = '0';
+ }
+ break;
+
+ case 'layout-align' :
+ var axis = extractAlignAxis(value);
+ value = $mdUtil.supplant("{main}-{cross}",axis);
+ break;
+
+ case 'layout-padding' :
+ case 'layout-margin' :
+ case 'layout-fill' :
+ case 'layout-wrap' :
+ case 'layout-nowrap' :
+ value = '';
+ break;
+ }
+
+ if (value !== origValue) {
+ (updateFn || angular.noop)(value);
+ }
+ }
+
+ return value ? value.trim() : "";
+ }
+
+ /**
+ * Replace current attribute value with fallback value
+ */
+ function buildUpdateFn(element, className, attrs) {
+ return function updateAttrValue(fallback) {
+ if (!needsInterpolation(fallback)) {
+ // Do not modify the element's attribute value; so
+ // uses '<ui-layout layout="/api/sidebar.html" />' will not
+ // be affected. Just update the attrs value.
+ attrs[attrs.$normalize(className)] = fallback;
+ }
+ };
+ }
+
+ /**
+ * See if the original value has interpolation symbols:
+ * e.g. flex-gt-md="{{triggerPoint}}"
+ */
+ function needsInterpolation(value) {
+ return (value || "").indexOf($interpolate.startSymbol()) > -1;
+ }
+
+ function getNormalizedAttrValue(className, attrs, defaultVal) {
+ var normalizedAttr = attrs.$normalize(className);
+ return attrs[normalizedAttr] ? attrs[normalizedAttr].trim().replace(WHITESPACE, "-") :
+ defaultVal || null;
+ }
+
+ function findIn(item, list, replaceWith) {
+ item = replaceWith && item ? item.replace(WHITESPACE, replaceWith) : item;
+
+ var found = false;
+ if (item) {
+ list.forEach(function(it) {
+ it = replaceWith ? it.replace(WHITESPACE, replaceWith) : it;
+ found = found || (it === item);
+ });
+ }
+ return found;
+ }
+
+ function extractAlignAxis(attrValue) {
+ var axis = {
+ main : "start",
+ cross: "stretch"
+ }, values;
+
+ attrValue = (attrValue || "");
+
+ if (attrValue.indexOf("-") === 0 || attrValue.indexOf(" ") === 0) {
+ // For missing main-axis values
+ attrValue = "none" + attrValue;
+ }
+
+ values = attrValue.toLowerCase().trim().replace(WHITESPACE, "-").split("-");
+ if (values.length && (values[0] === "space")) {
+ // for main-axis values of "space-around" or "space-between"
+ values = [values[0]+"-"+values[1],values[2]];
+ }
+
+ if (values.length > 0) axis.main = values[0] || axis.main;
+ if (values.length > 1) axis.cross = values[1] || axis.cross;
+
+ if (ALIGNMENT_MAIN_AXIS.indexOf(axis.main) < 0) axis.main = "start";
+ if (ALIGNMENT_CROSS_AXIS.indexOf(axis.cross) < 0) axis.cross = "stretch";
+
+ return axis;
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.core.liveannouncer
+ * @description
+ * AngularJS Material Live Announcer to provide accessibility for Voice Readers.
+ */
+MdLiveAnnouncer.$inject = ["$timeout"];
+angular
+ .module('material.core')
+ .service('$mdLiveAnnouncer', MdLiveAnnouncer);
+
+/**
+ * @ngdoc service
+ * @name $mdLiveAnnouncer
+ * @module material.core.liveannouncer
+ *
+ * @description
+ *
+ * Service to announce messages to supported screenreaders.
+ *
+ * > The `$mdLiveAnnouncer` service is internally used for components to provide proper accessibility.
+ *
+ * <hljs lang="js">
+ * module.controller('AppCtrl', function($mdLiveAnnouncer) {
+ * // Basic announcement (Polite Mode)
+ * $mdLiveAnnouncer.announce('Hey Google');
+ *
+ * // Custom announcement (Assertive Mode)
+ * $mdLiveAnnouncer.announce('Hey Google', 'assertive');
+ * });
+ * </hljs>
+ *
+ */
+function MdLiveAnnouncer($timeout) {
+ /** @private @const @type {!angular.$timeout} */
+ this._$timeout = $timeout;
+
+ /** @private @const @type {!HTMLElement} */
+ this._liveElement = this._createLiveElement();
+
+ /** @private @const @type {!number} */
+ this._announceTimeout = 100;
+}
+
+/**
+ * @ngdoc method
+ * @name $mdLiveAnnouncer#announce
+ * @description Announces messages to supported screenreaders.
+ * @param {string} message Message to be announced to the screenreader
+ * @param {'off'|'polite'|'assertive'} politeness The politeness of the announcer element.
+ */
+MdLiveAnnouncer.prototype.announce = function(message, politeness) {
+ if (!politeness) {
+ politeness = 'polite';
+ }
+
+ var self = this;
+
+ self._liveElement.textContent = '';
+ self._liveElement.setAttribute('aria-live', politeness);
+
+ // This 100ms timeout is necessary for some browser + screen-reader combinations:
+ // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.
+ // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a
+ // second time without clearing and then using a non-zero delay.
+ // (using JAWS 17 at time of this writing).
+ self._$timeout(function() {
+ self._liveElement.textContent = message;
+ }, self._announceTimeout, false);
+};
+
+/**
+ * Creates a live announcer element, which listens for DOM changes and announces them
+ * to the screenreaders.
+ * @returns {!HTMLElement}
+ * @private
+ */
+MdLiveAnnouncer.prototype._createLiveElement = function() {
+ var liveEl = document.createElement('div');
+
+ liveEl.classList.add('md-visually-hidden');
+ liveEl.setAttribute('role', 'status');
+ liveEl.setAttribute('aria-atomic', 'true');
+ liveEl.setAttribute('aria-live', 'polite');
+
+ document.body.appendChild(liveEl);
+
+ return liveEl;
+};
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc service
+ * @name $$mdMeta
+ * @module material.core.meta
+ *
+ * @description
+ *
+ * A provider and a service that simplifies meta tags access
+ *
+ * Note: This is intended only for use with dynamic meta tags such as browser color and title.
+ * Tags that are only processed when the page is rendered (such as `charset`, and `http-equiv`)
+ * will not work since `$$mdMeta` adds the tags after the page has already been loaded.
+ *
+ * ```js
+ * app.config(function($$mdMetaProvider) {
+ * var removeMeta = $$mdMetaProvider.setMeta('meta-name', 'content');
+ * var metaValue = $$mdMetaProvider.getMeta('meta-name'); // -> 'content'
+ *
+ * removeMeta();
+ * });
+ *
+ * app.controller('myController', function($$mdMeta) {
+ * var removeMeta = $$mdMeta.setMeta('meta-name', 'content');
+ * var metaValue = $$mdMeta.getMeta('meta-name'); // -> 'content'
+ *
+ * removeMeta();
+ * });
+ * ```
+ *
+ * @returns {$$mdMeta.$service}
+ *
+ */
+angular.module('material.core.meta', [])
+ .provider('$$mdMeta', function () {
+ var head = angular.element(document.head);
+ var metaElements = {};
+
+ /**
+ * Checks if the requested element was written manually and maps it
+ *
+ * @param {string} name meta tag 'name' attribute value
+ * @returns {boolean} returns true if there is an element with the requested name
+ */
+ function mapExistingElement(name) {
+ if (metaElements[name]) {
+ return true;
+ }
+
+ var element = document.getElementsByName(name)[0];
+
+ if (!element) {
+ return false;
+ }
+
+ metaElements[name] = angular.element(element);
+
+ return true;
+ }
+
+ /**
+ * @ngdoc method
+ * @name $$mdMeta#setMeta
+ *
+ * @description
+ * Creates meta element with the 'name' and 'content' attributes,
+ * if the meta tag is already created than we replace the 'content' value
+ *
+ * @param {string} name meta tag 'name' attribute value
+ * @param {string} content meta tag 'content' attribute value
+ * @returns {function} remove function
+ *
+ */
+ function setMeta(name, content) {
+ mapExistingElement(name);
+
+ if (!metaElements[name]) {
+ var newMeta = angular.element('<meta name="' + name + '" content="' + content + '"/>');
+ head.append(newMeta);
+ metaElements[name] = newMeta;
+ }
+ else {
+ metaElements[name].attr('content', content);
+ }
+
+ return function () {
+ metaElements[name].attr('content', '');
+ metaElements[name].remove();
+ delete metaElements[name];
+ };
+ }
+
+ /**
+ * @ngdoc method
+ * @name $$mdMeta#getMeta
+ *
+ * @description
+ * Gets the 'content' attribute value of the wanted meta element
+ *
+ * @param {string} name meta tag 'name' attribute value
+ * @returns {string} content attribute value
+ */
+ function getMeta(name) {
+ if (!mapExistingElement(name)) {
+ throw Error('$$mdMeta: could not find a meta tag with the name \'' + name + '\'');
+ }
+
+ return metaElements[name].attr('content');
+ }
+
+ var module = {
+ setMeta: setMeta,
+ getMeta: getMeta
+ };
+
+ return angular.extend({}, module, {
+ $get: function () {
+ return module;
+ }
+ });
+ });
+})();
+(function(){
+"use strict";
+
+ /**
+ * @ngdoc module
+ * @name material.core.componentRegistry
+ *
+ * @description
+ * A component instance registration service.
+ * Note: currently this as a private service in the SideNav component.
+ */
+ ComponentRegistry.$inject = ["$log", "$q"];
+ angular.module('material.core')
+ .factory('$mdComponentRegistry', ComponentRegistry);
+
+ /*
+ * @private
+ * @ngdoc factory
+ * @name ComponentRegistry
+ * @module material.core.componentRegistry
+ *
+ */
+ function ComponentRegistry($log, $q) {
+
+ var self;
+ var instances = [];
+ var pendings = { };
+
+ return self = {
+ /**
+ * Used to print an error when an instance for a handle isn't found.
+ */
+ notFoundError: function(handle, msgContext) {
+ $log.error((msgContext || "") + 'No instance found for handle', handle);
+ },
+ /**
+ * Return all registered instances as an array.
+ */
+ getInstances: function() {
+ return instances;
+ },
+
+ /**
+ * Get a registered instance.
+ * @param handle the String handle to look up for a registered instance.
+ */
+ get: function(handle) {
+ if (!isValidID(handle)) return null;
+
+ var i, j, instance;
+ for (i = 0, j = instances.length; i < j; i++) {
+ instance = instances[i];
+ if (instance.$$mdHandle === handle) {
+ return instance;
+ }
+ }
+ return null;
+ },
+
+ /**
+ * Register an instance.
+ * @param instance the instance to register
+ * @param handle the handle to identify the instance under.
+ */
+ register: function(instance, handle) {
+ if (!handle) return angular.noop;
+
+ instance.$$mdHandle = handle;
+ instances.push(instance);
+ resolveWhen();
+
+ return deregister;
+
+ /**
+ * Remove registration for an instance
+ */
+ function deregister() {
+ var index = instances.indexOf(instance);
+ if (index !== -1) {
+ instances.splice(index, 1);
+ }
+ }
+
+ /**
+ * Resolve any pending promises for this instance
+ */
+ function resolveWhen() {
+ var dfd = pendings[handle];
+ if (dfd) {
+ dfd.forEach(function (promise) {
+ promise.resolve(instance);
+ });
+ delete pendings[handle];
+ }
+ }
+ },
+
+ /**
+ * Async accessor to registered component instance
+ * If not available then a promise is created to notify
+ * all listeners when the instance is registered.
+ */
+ when : function(handle) {
+ if (isValidID(handle)) {
+ var deferred = $q.defer();
+ var instance = self.get(handle);
+
+ if (instance) {
+ deferred.resolve(instance);
+ } else {
+ if (pendings[handle] === undefined) {
+ pendings[handle] = [];
+ }
+ pendings[handle].push(deferred);
+ }
+
+ return deferred.promise;
+ }
+ return $q.reject("Invalid `md-component-id` value.");
+ }
+
+ };
+
+ function isValidID(handle){
+ return handle && (handle !== "");
+ }
+
+ }
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * @ngdoc service
+ * @name $mdButtonInkRipple
+ * @module material.core
+ *
+ * @description
+ * Provides ripple effects for md-button. See $mdInkRipple service for all possible configuration options.
+ *
+ * @param {object=} scope Scope within the current context
+ * @param {object=} element The element the ripple effect should be applied to
+ * @param {object=} options (Optional) Configuration options to override the default ripple configuration
+ */
+
+ MdButtonInkRipple.$inject = ["$mdInkRipple"];
+ angular.module('material.core')
+ .factory('$mdButtonInkRipple', MdButtonInkRipple);
+
+ function MdButtonInkRipple($mdInkRipple) {
+ return {
+ attach: function attachRipple(scope, element, options) {
+ options = angular.extend(optionsForElement(element), options);
+
+ return $mdInkRipple.attach(scope, element, options);
+ }
+ };
+
+ function optionsForElement(element) {
+ if (element.hasClass('md-icon-button')) {
+ return {
+ isMenuItem: element.hasClass('md-menu-item'),
+ fitRipple: true,
+ center: true
+ };
+ } else {
+ return {
+ isMenuItem: element.hasClass('md-menu-item'),
+ dimBackground: true
+ };
+ }
+ }
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * @ngdoc service
+ * @name $mdCheckboxInkRipple
+ * @module material.core
+ *
+ * @description
+ * Provides ripple effects for md-checkbox. See $mdInkRipple service for all possible configuration options.
+ *
+ * @param {object=} scope Scope within the current context
+ * @param {object=} element The element the ripple effect should be applied to
+ * @param {object=} options (Optional) Configuration options to override the defaultripple configuration
+ */
+
+ MdCheckboxInkRipple.$inject = ["$mdInkRipple"];
+ angular.module('material.core')
+ .factory('$mdCheckboxInkRipple', MdCheckboxInkRipple);
+
+ function MdCheckboxInkRipple($mdInkRipple) {
+ return {
+ attach: attach
+ };
+
+ function attach(scope, element, options) {
+ return $mdInkRipple.attach(scope, element, angular.extend({
+ center: true,
+ dimBackground: false,
+ fitRipple: true
+ }, options));
+ }
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * @ngdoc service
+ * @name $mdListInkRipple
+ * @module material.core
+ *
+ * @description
+ * Provides ripple effects for md-list. See $mdInkRipple service for all possible configuration options.
+ *
+ * @param {object=} scope Scope within the current context
+ * @param {object=} element The element the ripple effect should be applied to
+ * @param {object=} options (Optional) Configuration options to override the defaultripple configuration
+ */
+
+ MdListInkRipple.$inject = ["$mdInkRipple"];
+ angular.module('material.core')
+ .factory('$mdListInkRipple', MdListInkRipple);
+
+ function MdListInkRipple($mdInkRipple) {
+ return {
+ attach: attach
+ };
+
+ function attach(scope, element, options) {
+ return $mdInkRipple.attach(scope, element, angular.extend({
+ center: false,
+ dimBackground: true,
+ outline: false,
+ rippleSize: 'full'
+ }, options));
+ }
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.core.ripple
+ * @description
+ * Ripple
+ */
+InkRippleCtrl.$inject = ["$scope", "$element", "rippleOptions", "$window", "$timeout", "$mdUtil", "$mdColorUtil"];
+InkRippleDirective.$inject = ["$mdButtonInkRipple", "$mdCheckboxInkRipple"];
+angular.module('material.core')
+ .provider('$mdInkRipple', InkRippleProvider)
+ .directive('mdInkRipple', InkRippleDirective)
+ .directive('mdNoInk', attrNoDirective)
+ .directive('mdNoBar', attrNoDirective)
+ .directive('mdNoStretch', attrNoDirective);
+
+var DURATION = 450;
+
+/**
+ * @ngdoc directive
+ * @name mdInkRipple
+ * @module material.core.ripple
+ *
+ * @description
+ * The `md-ink-ripple` directive allows you to specify the ripple color or if a ripple is allowed.
+ *
+ * @param {string|boolean} md-ink-ripple A color string `#FF0000` or boolean (`false` or `0`) for
+ * preventing ripple
+ *
+ * @usage
+ * ### String values
+ * <hljs lang="html">
+ * <ANY md-ink-ripple="#FF0000">
+ * Ripples in red
+ * </ANY>
+ *
+ * <ANY md-ink-ripple="false">
+ * Not rippling
+ * </ANY>
+ * </hljs>
+ *
+ * ### Interpolated values
+ * <hljs lang="html">
+ * <ANY md-ink-ripple="{{ randomColor() }}">
+ * Ripples with the return value of 'randomColor' function
+ * </ANY>
+ *
+ * <ANY md-ink-ripple="{{ canRipple() }}">
+ * Ripples if 'canRipple' function return value is not 'false' or '0'
+ * </ANY>
+ * </hljs>
+ */
+function InkRippleDirective ($mdButtonInkRipple, $mdCheckboxInkRipple) {
+ return {
+ controller: angular.noop,
+ link: function (scope, element, attr) {
+ attr.hasOwnProperty('mdInkRippleCheckbox')
+ ? $mdCheckboxInkRipple.attach(scope, element)
+ : $mdButtonInkRipple.attach(scope, element);
+ }
+ };
+}
+
+/**
+ * @ngdoc service
+ * @name $mdInkRipple
+ * @module material.core.ripple
+ *
+ * @description
+ * `$mdInkRipple` is a service for adding ripples to any element.
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.factory('$myElementInkRipple', function($mdInkRipple) {
+ * return {
+ * attach: function (scope, element, options) {
+ * return $mdInkRipple.attach(scope, element, angular.extend({
+ * center: false,
+ * dimBackground: true
+ * }, options));
+ * }
+ * };
+ * });
+ *
+ * app.controller('myController', function ($scope, $element, $myElementInkRipple) {
+ * $scope.onClick = function (ev) {
+ * $myElementInkRipple.attach($scope, angular.element(ev.target), { center: true });
+ * }
+ * });
+ * </hljs>
+ */
+
+/**
+ * @ngdoc service
+ * @name $mdInkRippleProvider
+ * @module material.core.ripple
+ *
+ * @description
+ * If you want to disable ink ripples globally, for all components, you can call the
+ * `disableInkRipple` method in your app's config.
+ *
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.config(function ($mdInkRippleProvider) {
+ * $mdInkRippleProvider.disableInkRipple();
+ * });
+ * </hljs>
+ */
+
+function InkRippleProvider () {
+ var isDisabledGlobally = false;
+
+ return {
+ disableInkRipple: disableInkRipple,
+ $get: ["$injector", function($injector) {
+ return { attach: attach };
+
+ /**
+ * @ngdoc method
+ * @name $mdInkRipple#attach
+ *
+ * @description
+ * Attaching given scope, element and options to inkRipple controller
+ *
+ * @param {object=} scope Scope within the current context
+ * @param {object=} element The element the ripple effect should be applied to
+ * @param {object=} options (Optional) Configuration options to override the defaultRipple configuration
+ * * `center` - Whether the ripple should start from the center of the container element
+ * * `dimBackground` - Whether the background should be dimmed with the ripple color
+ * * `colorElement` - The element the ripple should take its color from, defined by css property `color`
+ * * `fitRipple` - Whether the ripple should fill the element
+ */
+ function attach (scope, element, options) {
+ if (isDisabledGlobally || element.controller('mdNoInk')) return angular.noop;
+ return $injector.instantiate(InkRippleCtrl, {
+ $scope: scope,
+ $element: element,
+ rippleOptions: options
+ });
+ }
+ }]
+ };
+
+ /**
+ * @ngdoc method
+ * @name $mdInkRippleProvider#disableInkRipple
+ *
+ * @description
+ * A config-time method that, when called, disables ripples globally.
+ */
+ function disableInkRipple () {
+ isDisabledGlobally = true;
+ }
+}
+
+/**
+ * Controller used by the ripple service in order to apply ripples
+ * @ngInject
+ */
+function InkRippleCtrl ($scope, $element, rippleOptions, $window, $timeout, $mdUtil, $mdColorUtil) {
+ this.$window = $window;
+ this.$timeout = $timeout;
+ this.$mdUtil = $mdUtil;
+ this.$mdColorUtil = $mdColorUtil;
+ this.$scope = $scope;
+ this.$element = $element;
+ this.options = rippleOptions;
+ this.mousedown = false;
+ this.ripples = [];
+ this.timeout = null; // Stores a reference to the most-recent ripple timeout
+ this.lastRipple = null;
+
+ $mdUtil.valueOnUse(this, 'container', this.createContainer);
+
+ this.$element.addClass('md-ink-ripple');
+
+ // attach method for unit tests
+ ($element.controller('mdInkRipple') || {}).createRipple = angular.bind(this, this.createRipple);
+ ($element.controller('mdInkRipple') || {}).setColor = angular.bind(this, this.color);
+
+ this.bindEvents();
+}
+
+
+/**
+ * Either remove or unlock any remaining ripples when the user mouses off of the element (either by
+ * mouseup or mouseleave event)
+ */
+function autoCleanup (self, cleanupFn) {
+ if (self.mousedown || self.lastRipple) {
+ self.mousedown = false;
+ self.$mdUtil.nextTick(angular.bind(self, cleanupFn), false);
+ }
+}
+
+
+/**
+ * Returns the color that the ripple should be (either based on CSS or hard-coded)
+ * @returns {string}
+ */
+InkRippleCtrl.prototype.color = function (value) {
+ var self = this;
+
+ // If assigning a color value, apply it to background and the ripple color
+ if (angular.isDefined(value)) {
+ self._color = self._parseColor(value);
+ }
+
+ // If color lookup, use assigned, defined, or inherited
+ return self._color || self._parseColor(self.inkRipple()) || self._parseColor(getElementColor());
+
+ /**
+ * Finds the color element and returns its text color for use as default ripple color
+ * @returns {string}
+ */
+ function getElementColor () {
+ var items = self.options && self.options.colorElement ? self.options.colorElement : [];
+ var elem = items.length ? items[ 0 ] : self.$element[ 0 ];
+
+ return elem ? self.$window.getComputedStyle(elem).color : 'rgb(0,0,0)';
+ }
+};
+
+/**
+ * Updating the ripple colors based on the current inkRipple value
+ * or the element's computed style color
+ */
+InkRippleCtrl.prototype.calculateColor = function () {
+ return this.color();
+};
+
+
+/**
+ * Takes a string color and converts it to RGBA format
+ * @param {string} color
+ * @param {number} multiplier
+ * @returns {string}
+ */
+InkRippleCtrl.prototype._parseColor = function parseColor (color, multiplier) {
+ multiplier = multiplier || 1;
+ var colorUtil = this.$mdColorUtil;
+
+ if (!color) return;
+ if (color.indexOf('rgba') === 0) return color.replace(/\d?\.?\d*\s*\)\s*$/, (0.1 * multiplier).toString() + ')');
+ if (color.indexOf('rgb') === 0) return colorUtil.rgbToRgba(color);
+ if (color.indexOf('#') === 0) return colorUtil.hexToRgba(color);
+
+};
+
+/**
+ * Binds events to the root element for
+ */
+InkRippleCtrl.prototype.bindEvents = function () {
+ this.$element.on('mousedown', angular.bind(this, this.handleMousedown));
+ this.$element.on('mouseup touchend', angular.bind(this, this.handleMouseup));
+ this.$element.on('mouseleave', angular.bind(this, this.handleMouseup));
+ this.$element.on('touchmove', angular.bind(this, this.handleTouchmove));
+};
+
+/**
+ * Create a new ripple on every mousedown event from the root element
+ * @param event {MouseEvent}
+ */
+InkRippleCtrl.prototype.handleMousedown = function (event) {
+ if (this.mousedown) return;
+
+ // When jQuery is loaded, we have to get the original event
+ if (event.hasOwnProperty('originalEvent')) event = event.originalEvent;
+ this.mousedown = true;
+ if (this.options.center) {
+ this.createRipple(this.container.prop('clientWidth') / 2, this.container.prop('clientWidth') / 2);
+ } else {
+
+ // We need to calculate the relative coordinates if the target is a sublayer of the ripple element
+ if (event.srcElement !== this.$element[0]) {
+ var layerRect = this.$element[0].getBoundingClientRect();
+ var layerX = event.clientX - layerRect.left;
+ var layerY = event.clientY - layerRect.top;
+
+ this.createRipple(layerX, layerY);
+ } else {
+ this.createRipple(event.offsetX, event.offsetY);
+ }
+ }
+};
+
+/**
+ * Either remove or unlock any remaining ripples when the user mouses off of the element (either by
+ * mouseup, touchend or mouseleave event)
+ */
+InkRippleCtrl.prototype.handleMouseup = function () {
+ this.$timeout(function () {
+ autoCleanup(this, this.clearRipples);
+ }.bind(this));
+};
+
+/**
+ * Either remove or unlock any remaining ripples when the user mouses off of the element (by
+ * touchmove)
+ */
+InkRippleCtrl.prototype.handleTouchmove = function () {
+ autoCleanup(this, this.deleteRipples);
+};
+
+/**
+ * Cycles through all ripples and attempts to remove them.
+ */
+InkRippleCtrl.prototype.deleteRipples = function () {
+ for (var i = 0; i < this.ripples.length; i++) {
+ this.ripples[ i ].remove();
+ }
+};
+
+/**
+ * Cycles through all ripples and attempts to remove them with fade.
+ * Depending on logic within `fadeInComplete`, some removals will be postponed.
+ */
+InkRippleCtrl.prototype.clearRipples = function () {
+ for (var i = 0; i < this.ripples.length; i++) {
+ this.fadeInComplete(this.ripples[ i ]);
+ }
+};
+
+/**
+ * Creates the ripple container element
+ * @returns {*}
+ */
+InkRippleCtrl.prototype.createContainer = function () {
+ var container = angular.element('<div class="md-ripple-container"></div>');
+ this.$element.append(container);
+ return container;
+};
+
+InkRippleCtrl.prototype.clearTimeout = function () {
+ if (this.timeout) {
+ this.$timeout.cancel(this.timeout);
+ this.timeout = null;
+ }
+};
+
+InkRippleCtrl.prototype.isRippleAllowed = function () {
+ var element = this.$element[0];
+ do {
+ if (!element.tagName || element.tagName === 'BODY') break;
+
+ if (element && angular.isFunction(element.hasAttribute)) {
+ if (element.hasAttribute('disabled')) return false;
+ if (this.inkRipple() === 'false' || this.inkRipple() === '0') return false;
+ }
+
+ } while (element = element.parentNode);
+ return true;
+};
+
+/**
+ * The attribute `md-ink-ripple` may be a static or interpolated
+ * color value OR a boolean indicator (used to disable ripples)
+ */
+InkRippleCtrl.prototype.inkRipple = function () {
+ return this.$element.attr('md-ink-ripple');
+};
+
+/**
+ * Creates a new ripple and adds it to the container. Also tracks ripple in `this.ripples`.
+ * @param left
+ * @param top
+ */
+InkRippleCtrl.prototype.createRipple = function (left, top) {
+ if (!this.isRippleAllowed()) return;
+
+ var ctrl = this;
+ var colorUtil = ctrl.$mdColorUtil;
+ var ripple = angular.element('<div class="md-ripple"></div>');
+ var width = this.$element.prop('clientWidth');
+ var height = this.$element.prop('clientHeight');
+ var x = Math.max(Math.abs(width - left), left) * 2;
+ var y = Math.max(Math.abs(height - top), top) * 2;
+ var size = getSize(this.options.fitRipple, x, y);
+ var color = this.calculateColor();
+
+ ripple.css({
+ left: left + 'px',
+ top: top + 'px',
+ background: 'black',
+ width: size + 'px',
+ height: size + 'px',
+ backgroundColor: colorUtil.rgbaToRgb(color),
+ borderColor: colorUtil.rgbaToRgb(color)
+ });
+ this.lastRipple = ripple;
+
+ // we only want one timeout to be running at a time
+ this.clearTimeout();
+ this.timeout = this.$timeout(function () {
+ ctrl.clearTimeout();
+ if (!ctrl.mousedown) ctrl.fadeInComplete(ripple);
+ }, DURATION * 0.35, false);
+
+ if (this.options.dimBackground) this.container.css({ backgroundColor: color });
+ this.container.append(ripple);
+ this.ripples.push(ripple);
+ ripple.addClass('md-ripple-placed');
+
+ this.$mdUtil.nextTick(function () {
+
+ ripple.addClass('md-ripple-scaled md-ripple-active');
+ ctrl.$timeout(function () {
+ ctrl.clearRipples();
+ }, DURATION, false);
+
+ }, false);
+
+ function getSize (fit, x, y) {
+ return fit
+ ? Math.max(x, y)
+ : Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
+ }
+};
+
+
+
+/**
+ * After fadeIn finishes, either kicks off the fade-out animation or queues the element for removal on mouseup
+ * @param ripple
+ */
+InkRippleCtrl.prototype.fadeInComplete = function (ripple) {
+ if (this.lastRipple === ripple) {
+ if (!this.timeout && !this.mousedown) {
+ this.removeRipple(ripple);
+ }
+ } else {
+ this.removeRipple(ripple);
+ }
+};
+
+/**
+ * Kicks off the animation for removing a ripple
+ * @param ripple {Element}
+ */
+InkRippleCtrl.prototype.removeRipple = function (ripple) {
+ var ctrl = this;
+ var index = this.ripples.indexOf(ripple);
+ if (index < 0) return;
+ this.ripples.splice(this.ripples.indexOf(ripple), 1);
+ ripple.removeClass('md-ripple-active');
+ ripple.addClass('md-ripple-remove');
+ if (this.ripples.length === 0) this.container.css({ backgroundColor: '' });
+ // use a 2-second timeout in order to allow for the animation to finish
+ // we don't actually care how long the animation takes
+ this.$timeout(function () {
+ ctrl.fadeOutComplete(ripple);
+ }, DURATION, false);
+};
+
+/**
+ * Removes the provided ripple from the DOM
+ * @param ripple
+ */
+InkRippleCtrl.prototype.fadeOutComplete = function (ripple) {
+ ripple.remove();
+ this.lastRipple = null;
+};
+
+/**
+ * Used to create an empty directive. This is used to track flag-directives whose children may have
+ * functionality based on them.
+ *
+ * Example: `md-no-ink` will potentially be used by all child directives.
+ */
+function attrNoDirective () {
+ return { controller: angular.noop };
+}
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * @ngdoc service
+ * @name $mdTabInkRipple
+ * @module material.core
+ *
+ * @description
+ * Provides ripple effects for md-tabs. See $mdInkRipple service for all possible configuration options.
+ *
+ * @param {object=} scope Scope within the current context
+ * @param {object=} element The element the ripple effect should be applied to
+ * @param {object=} options (Optional) Configuration options to override the defaultripple configuration
+ */
+
+ MdTabInkRipple.$inject = ["$mdInkRipple"];
+ angular.module('material.core')
+ .factory('$mdTabInkRipple', MdTabInkRipple);
+
+ function MdTabInkRipple($mdInkRipple) {
+ return {
+ attach: attach
+ };
+
+ function attach(scope, element, options) {
+ return $mdInkRipple.attach(scope, element, angular.extend({
+ center: false,
+ dimBackground: true,
+ outline: false,
+ rippleSize: 'full'
+ }, options));
+ }
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+angular.module('material.core.theming.palette', [])
+.constant('$mdColorPalette', {
+ 'red': {
+ '50': '#ffebee',
+ '100': '#ffcdd2',
+ '200': '#ef9a9a',
+ '300': '#e57373',
+ '400': '#ef5350',
+ '500': '#f44336',
+ '600': '#e53935',
+ '700': '#d32f2f',
+ '800': '#c62828',
+ '900': '#b71c1c',
+ 'A100': '#ff8a80',
+ 'A200': '#ff5252',
+ 'A400': '#ff1744',
+ 'A700': '#d50000',
+ 'contrastDefaultColor': 'light',
+ 'contrastDarkColors': '50 100 200 300 400 500 600 A100 A200 A400',
+ 'contrastStrongLightColors': '700 800 900 A700'
+ },
+ 'pink': {
+ '50': '#fce4ec',
+ '100': '#f8bbd0',
+ '200': '#f48fb1',
+ '300': '#f06292',
+ '400': '#ec407a',
+ '500': '#e91e63',
+ '600': '#d81b60',
+ '700': '#c2185b',
+ '800': '#ad1457',
+ '900': '#880e4f',
+ 'A100': '#ff80ab',
+ 'A200': '#ff4081',
+ 'A400': '#f50057',
+ 'A700': '#c51162',
+ 'contrastDefaultColor': 'light',
+ 'contrastDarkColors': '50 100 200 300 400 A100 A200 A400',
+ // White on 500 does not meet the minimum 4.5 contrast ratio (at 4.34),
+ // but it's worse with a dark foreground (3.61).
+ 'contrastStrongLightColors': '500 600 700 800 900 A700'
+ },
+ 'purple': {
+ '50': '#f3e5f5',
+ '100': '#e1bee7',
+ '200': '#ce93d8',
+ '300': '#ba68c8',
+ '400': '#ab47bc',
+ '500': '#9c27b0',
+ '600': '#8e24aa',
+ '700': '#7b1fa2',
+ '800': '#6a1b9a',
+ '900': '#4a148c',
+ 'A100': '#ea80fc',
+ 'A200': '#e040fb',
+ 'A400': '#d500f9',
+ 'A700': '#aa00ff',
+ 'contrastDefaultColor': 'light',
+ 'contrastDarkColors': '50 100 200 300 A100 A200 A400',
+ 'contrastStrongLightColors': '400 500 600 700 800 900 A700'
+ },
+ 'deep-purple': {
+ '50': '#ede7f6',
+ '100': '#d1c4e9',
+ '200': '#b39ddb',
+ '300': '#9575cd',
+ '400': '#7e57c2',
+ '500': '#673ab7',
+ '600': '#5e35b1',
+ '700': '#512da8',
+ '800': '#4527a0',
+ '900': '#311b92',
+ 'A100': '#b388ff',
+ 'A200': '#7c4dff',
+ 'A400': '#651fff',
+ 'A700': '#6200ea',
+ 'contrastDefaultColor': 'light',
+ 'contrastDarkColors': '50 100 200 300 A100',
+ 'contrastStrongLightColors': '400 500 600 700 800 900 A200 A400 A700'
+ },
+ 'indigo': {
+ '50': '#e8eaf6',
+ '100': '#c5cae9',
+ '200': '#9fa8da',
+ '300': '#7986cb',
+ '400': '#5c6bc0',
+ '500': '#3f51b5',
+ '600': '#3949ab',
+ '700': '#303f9f',
+ '800': '#283593',
+ '900': '#1a237e',
+ 'A100': '#8c9eff',
+ 'A200': '#536dfe',
+ 'A400': '#3d5afe',
+ 'A700': '#304ffe',
+ 'contrastDefaultColor': 'light',
+ 'contrastDarkColors': '50 100 200 300 A100 A200',
+ 'contrastStrongLightColors': '400 500 600 700 800 900 A400 A700'
+ },
+ 'blue': {
+ '50': '#e3f2fd',
+ '100': '#bbdefb',
+ '200': '#90caf9',
+ '300': '#64b5f6',
+ '400': '#42a5f5',
+ '500': '#2196f3',
+ '600': '#1e88e5',
+ '700': '#1976d2',
+ '800': '#1565c0',
+ '900': '#0d47a1',
+ 'A100': '#82b1ff',
+ 'A200': '#448aff',
+ 'A400': '#2979ff',
+ 'A700': '#2962ff',
+ 'contrastDefaultColor': 'light',
+ // White on A400 does not meet the minimum 4.5 contrast ratio (at 3.98),
+ // but it's worse with a dark foreground (3.94).
+ 'contrastDarkColors': '50 100 200 300 400 500 600 A100 A200',
+ 'contrastStrongLightColors': '700 800 900 A400 A700'
+ },
+ 'light-blue': {
+ '50': '#e1f5fe',
+ '100': '#b3e5fc',
+ '200': '#81d4fa',
+ '300': '#4fc3f7',
+ '400': '#29b6f6',
+ '500': '#03a9f4',
+ '600': '#039be5',
+ '700': '#0288d1',
+ '800': '#0277bd',
+ '900': '#01579b',
+ 'A100': '#80d8ff',
+ 'A200': '#40c4ff',
+ 'A400': '#00b0ff',
+ 'A700': '#0091ea',
+ 'contrastDefaultColor': 'dark',
+ // Dark on 700 does not meet the minimum 4.5 contrast ratio (at 4.07),
+ // but it's worse with a white foreground (3.85).
+ 'contrastStrongLightColors': '800 900 A700'
+ },
+ 'cyan': {
+ '50': '#e0f7fa',
+ '100': '#b2ebf2',
+ '200': '#80deea',
+ '300': '#4dd0e1',
+ '400': '#26c6da',
+ '500': '#00bcd4',
+ '600': '#00acc1',
+ '700': '#0097a7',
+ '800': '#00838f',
+ '900': '#006064',
+ 'A100': '#84ffff',
+ 'A200': '#18ffff',
+ 'A400': '#00e5ff',
+ 'A700': '#00b8d4',
+ 'contrastDefaultColor': 'dark',
+ // Dark on 700 does not meet the minimum 4.5 contrast ratio (at 4.47),
+ // but it's worse with a white foreground (3.5).
+ 'contrastStrongLightColors': '800 900'
+ },
+ 'teal': {
+ '50': '#e0f2f1',
+ '100': '#b2dfdb',
+ '200': '#80cbc4',
+ '300': '#4db6ac',
+ '400': '#26a69a',
+ '500': '#009688',
+ '600': '#00897b',
+ '700': '#00796b',
+ '800': '#00695c',
+ '900': '#004d40',
+ 'A100': '#a7ffeb',
+ 'A200': '#64ffda',
+ 'A400': '#1de9b6',
+ 'A700': '#00bfa5',
+ 'contrastDefaultColor': 'dark',
+ // Dark on 500 does not meet the minimum 4.5 contrast ratio (at 4.27),
+ // but it's worse with a white foreground (3.67).
+ // White on 600 does not meet the minimum 4.5 contrast ratio (at 4.31),
+ // but it's worse with a dark foreground (3.64).
+ 'contrastStrongLightColors': '600 700 800 900'
+ },
+ 'green': {
+ '50': '#e8f5e9',
+ '100': '#c8e6c9',
+ '200': '#a5d6a7',
+ '300': '#81c784',
+ '400': '#66bb6a',
+ '500': '#4caf50',
+ '600': '#43a047',
+ '700': '#388e3c',
+ '800': '#2e7d32',
+ '900': '#1b5e20',
+ 'A100': '#b9f6ca',
+ 'A200': '#69f0ae',
+ 'A400': '#00e676',
+ 'A700': '#00c853',
+ 'contrastDefaultColor': 'dark',
+ // White on 700 does not meet the minimum 4.5 contrast ratio (at 4.11),
+ // but it's worse with a dark foreground (3.81).
+ 'contrastStrongLightColors': '700 800 900'
+ },
+ 'light-green': {
+ '50': '#f1f8e9',
+ '100': '#dcedc8',
+ '200': '#c5e1a5',
+ '300': '#aed581',
+ '400': '#9ccc65',
+ '500': '#8bc34a',
+ '600': '#7cb342',
+ '700': '#689f38',
+ '800': '#558b2f',
+ '900': '#33691e',
+ 'A100': '#ccff90',
+ 'A200': '#b2ff59',
+ 'A400': '#76ff03',
+ 'A700': '#64dd17',
+ 'contrastDefaultColor': 'dark',
+ 'contrastStrongLightColors': '800 900'
+ },
+ 'lime': {
+ '50': '#f9fbe7',
+ '100': '#f0f4c3',
+ '200': '#e6ee9c',
+ '300': '#dce775',
+ '400': '#d4e157',
+ '500': '#cddc39',
+ '600': '#c0ca33',
+ '700': '#afb42b',
+ '800': '#9e9d24',
+ '900': '#827717',
+ 'A100': '#f4ff81',
+ 'A200': '#eeff41',
+ 'A400': '#c6ff00',
+ 'A700': '#aeea00',
+ 'contrastDefaultColor': 'dark',
+ 'contrastStrongLightColors': '900'
+ },
+ 'yellow': {
+ '50': '#fffde7',
+ '100': '#fff9c4',
+ '200': '#fff59d',
+ '300': '#fff176',
+ '400': '#ffee58',
+ '500': '#ffeb3b',
+ '600': '#fdd835',
+ '700': '#fbc02d',
+ '800': '#f9a825',
+ '900': '#f57f17',
+ 'A100': '#ffff8d',
+ 'A200': '#ffff00',
+ 'A400': '#ffea00',
+ 'A700': '#ffd600',
+ 'contrastDefaultColor': 'dark'
+ },
+ 'amber': {
+ '50': '#fff8e1',
+ '100': '#ffecb3',
+ '200': '#ffe082',
+ '300': '#ffd54f',
+ '400': '#ffca28',
+ '500': '#ffc107',
+ '600': '#ffb300',
+ '700': '#ffa000',
+ '800': '#ff8f00',
+ '900': '#ff6f00',
+ 'A100': '#ffe57f',
+ 'A200': '#ffd740',
+ 'A400': '#ffc400',
+ 'A700': '#ffab00',
+ 'contrastDefaultColor': 'dark'
+ },
+ 'orange': {
+ '50': '#fff3e0',
+ '100': '#ffe0b2',
+ '200': '#ffcc80',
+ '300': '#ffb74d',
+ '400': '#ffa726',
+ '500': '#ff9800',
+ '600': '#fb8c00',
+ '700': '#f57c00',
+ '800': '#ef6c00',
+ '900': '#e65100',
+ 'A100': '#ffd180',
+ 'A200': '#ffab40',
+ 'A400': '#ff9100',
+ 'A700': '#ff6d00',
+ 'contrastDefaultColor': 'dark',
+ 'contrastStrongLightColors': '900'
+ },
+ 'deep-orange': {
+ '50': '#fbe9e7',
+ '100': '#ffccbc',
+ '200': '#ffab91',
+ '300': '#ff8a65',
+ '400': '#ff7043',
+ '500': '#ff5722',
+ '600': '#f4511e',
+ '700': '#e64a19',
+ '800': '#d84315',
+ '900': '#bf360c',
+ 'A100': '#ff9e80',
+ 'A200': '#ff6e40',
+ 'A400': '#ff3d00',
+ 'A700': '#dd2c00',
+ 'contrastDefaultColor': 'dark',
+ // Dark on 700 does not meet the minimum 4.5 contrast ratio (at 4.01),
+ // but it's worse with a white foreground (3.91).
+ // White on 800 does not meet the minimum 4.5 contrast ratio (at 4.43),
+ // but it's worse with a dark foreground (3.54).
+ 'contrastStrongLightColors': '800 900 A400 A700',
+ },
+ 'brown': {
+ '50': '#efebe9',
+ '100': '#d7ccc8',
+ '200': '#bcaaa4',
+ '300': '#a1887f',
+ '400': '#8d6e63',
+ '500': '#795548',
+ '600': '#6d4c41',
+ '700': '#5d4037',
+ '800': '#4e342e',
+ '900': '#3e2723',
+ 'A100': '#d7ccc8',
+ 'A200': '#bcaaa4',
+ 'A400': '#8d6e63',
+ 'A700': '#5d4037',
+ 'contrastDefaultColor': 'light',
+ 'contrastDarkColors': '50 100 200 300 A100 A200',
+ 'contrastStrongLightColors': '400 500 600 700 800 900 A400 A700'
+ },
+ 'grey': {
+ '50': '#fafafa',
+ '100': '#f5f5f5',
+ '200': '#eeeeee',
+ '300': '#e0e0e0',
+ '400': '#bdbdbd',
+ '500': '#9e9e9e',
+ '600': '#757575',
+ '700': '#616161',
+ '800': '#424242',
+ '900': '#212121',
+ 'A100': '#ffffff',
+ 'A200': '#000000',
+ 'A400': '#303030',
+ 'A700': '#616161',
+ 'contrastDefaultColor': 'dark',
+ 'contrastLightColors': '700 800 900 A200 A400 A700',
+ 'contrastStrongLightColors': '600'
+ },
+ 'blue-grey': {
+ '50': '#eceff1',
+ '100': '#cfd8dc',
+ '200': '#b0bec5',
+ '300': '#90a4ae',
+ '400': '#78909c',
+ '500': '#607d8b',
+ '600': '#546e7a',
+ '700': '#455a64',
+ '800': '#37474f',
+ '900': '#263238',
+ 'A100': '#cfd8dc',
+ 'A200': '#b0bec5',
+ 'A400': '#78909c',
+ 'A700': '#455a64',
+ 'contrastDefaultColor': 'light',
+ 'contrastDarkColors': '50 100 200 300 400 A100 A200 A400',
+ // White on 500 does not meet the minimum 4.5 contrast ratio (at 4.37),
+ // but it's worse with a dark foreground.
+ 'contrastStrongLightColors': '500 600 700 800 900 A700'
+ }
+});
+
+})();
+(function(){
+"use strict";
+
+(function(angular) {
+ 'use strict';
+/**
+ * @ngdoc module
+ * @name material.core.theming
+ * @description
+ * Theming
+ */
+detectDisabledThemes.$inject = ["$mdThemingProvider"];
+ThemingDirective.$inject = ["$mdTheming", "$interpolate", "$parse", "$mdUtil", "$q", "$log"];
+ThemableDirective.$inject = ["$mdTheming"];
+ThemingProvider.$inject = ["$mdColorPalette", "$$mdMetaProvider"];
+generateAllThemes.$inject = ["$injector", "$mdTheming"];
+angular.module('material.core.theming', ['material.core.theming.palette', 'material.core.meta'])
+ .directive('mdTheme', ThemingDirective)
+ .directive('mdThemable', ThemableDirective)
+ .directive('mdThemesDisabled', disableThemesDirective)
+ .provider('$mdTheming', ThemingProvider)
+ .config(detectDisabledThemes)
+ .run(generateAllThemes);
+
+/**
+ * Detect if the HTML or the BODY tags has a [md-themes-disabled] attribute
+ * If yes, then immediately disable all theme stylesheet generation and DOM injection
+ */
+/**
+ * @ngInject
+ */
+function detectDisabledThemes($mdThemingProvider) {
+ var isDisabled = !!document.querySelector('[md-themes-disabled]');
+ $mdThemingProvider.disableTheming(isDisabled);
+}
+
+/**
+ * @ngdoc service
+ * @name $mdThemingProvider
+ * @module material.core.theming
+ *
+ * @description Provider to configure the `$mdTheming` service.
+ *
+ * ### Default Theme
+ * The `$mdThemingProvider` uses by default the following theme configuration:
+ *
+ * - Primary Palette: `Blue`
+ * - Accent Palette: `Pink`
+ * - Warn Palette: `Deep-Orange`
+ * - Background Palette: `Grey`
+ *
+ * If you don't want to use the `md-theme` directive on the elements itself, you may want to overwrite
+ * the default theme.<br/>
+ * This can be done by using the following markup.
+ *
+ * <hljs lang="js">
+ * myAppModule.config(function($mdThemingProvider) {
+ * $mdThemingProvider
+ * .theme('default')
+ * .primaryPalette('blue')
+ * .accentPalette('teal')
+ * .warnPalette('red')
+ * .backgroundPalette('grey');
+ * });
+ * </hljs>
+ *
+
+ * ### Dynamic Themes
+ *
+ * By default, if you change a theme at runtime, the `$mdTheming` service will not detect those changes.<br/>
+ * If you have an application, which changes its theme on runtime, you have to enable theme watching.
+ *
+ * <hljs lang="js">
+ * myAppModule.config(function($mdThemingProvider) {
+ * // Enable theme watching.
+ * $mdThemingProvider.alwaysWatchTheme(true);
+ * });
+ * </hljs>
+ *
+ * ### Custom Theme Styles
+ *
+ * Sometimes you may want to use your own theme styles for some custom components.<br/>
+ * You are able to register your own styles by using the following markup.
+ *
+ * <hljs lang="js">
+ * myAppModule.config(function($mdThemingProvider) {
+ * // Register our custom stylesheet into the theming provider.
+ * $mdThemingProvider.registerStyles(STYLESHEET);
+ * });
+ * </hljs>
+ *
+ * The `registerStyles` method only accepts strings as value, so you're actually not able to load an external
+ * stylesheet file into the `$mdThemingProvider`.
+ *
+ * If it's necessary to load an external stylesheet, we suggest using a bundler, which supports including raw content,
+ * like [raw-loader](https://github.com/webpack/raw-loader) for `webpack`.
+ *
+ * <hljs lang="js">
+ * myAppModule.config(function($mdThemingProvider) {
+ * // Register your custom stylesheet into the theming provider.
+ * $mdThemingProvider.registerStyles(require('../styles/my-component.theme.css'));
+ * });
+ * </hljs>
+ *
+ * ### Browser color
+ *
+ * Enables browser header coloring
+ * for more info please visit:
+ * https://developers.google.com/web/fundamentals/design-and-ui/browser-customization/theme-color
+ *
+ * Options parameter: <br/>
+ * `theme` - A defined theme via `$mdThemeProvider` to use the palettes from. Default is `default` theme. <br/>
+ * `palette` - Can be any one of the basic material design palettes, extended defined palettes and 'primary',
+ * 'accent', 'background' and 'warn'. Default is `primary`. <br/>
+ * `hue` - The hue from the selected palette. Default is `800`<br/>
+ *
+ * <hljs lang="js">
+ * myAppModule.config(function($mdThemingProvider) {
+ * // Enable browser color
+ * $mdThemingProvider.enableBrowserColor({
+ * theme: 'myTheme', // Default is 'default'
+ * palette: 'accent', // Default is 'primary', any basic material palette and extended palettes are available
+ * hue: '200' // Default is '800'
+ * });
+ * });
+ * </hljs>
+ */
+
+/**
+ * Some Example Valid Theming Expressions
+ * =======================================
+ *
+ * Intention group expansion: (valid for primary, accent, warn, background)
+ *
+ * {{primary-100}} - grab shade 100 from the primary palette
+ * {{primary-100-0.7}} - grab shade 100, apply opacity of 0.7
+ * {{primary-100-contrast}} - grab shade 100's contrast color
+ * {{primary-hue-1}} - grab the shade assigned to hue-1 from the primary palette
+ * {{primary-hue-1-0.7}} - apply 0.7 opacity to primary-hue-1
+ * {{primary-color}} - Generates .md-hue-1, .md-hue-2, .md-hue-3 with configured shades set for each hue
+ * {{primary-color-0.7}} - Apply 0.7 opacity to each of the above rules
+ * {{primary-contrast}} - Generates .md-hue-1, .md-hue-2, .md-hue-3 with configured contrast (ie. text) color shades set for each hue
+ * {{primary-contrast-0.7}} - Apply 0.7 opacity to each of the above rules
+ * {{primary-contrast-divider}} - Apply divider opacity to contrast color
+ *
+ * Foreground expansion: Applies rgba to black/white foreground text
+ *
+ * Old Foreground Expressions:
+ * {{foreground-1}} - used for primary text
+ * {{foreground-2}} - used for secondary text/divider
+ * {{foreground-3}} - used for disabled text
+ * {{foreground-4}} - used for dividers
+ *
+ * New Foreground Expressions:
+ *
+ * Apply primary text color for contrasting with default background
+ * {{background-default-contrast}} - default opacity
+ * {{background-default-contrast-secondary}} - opacity for secondary text
+ * {{background-default-contrast-hint}} - opacity for hints and placeholders
+ * {{background-default-contrast-disabled}} - opacity for disabled text
+ * {{background-default-contrast-divider}} - opacity for dividers
+ *
+ * Apply contrast color for specific shades
+ * {{background-50-contrast-icon}} - Apply contrast color for icon on background's shade 50 hue
+ */
+
+// In memory generated CSS rules; registered by theme.name
+var GENERATED = { };
+
+// In memory storage of defined themes and color palettes (both loaded by CSS, and user specified)
+var PALETTES;
+
+// Text colors are automatically generated based on background color when not specified
+// Custom palettes can provide override colors
+// @see https://material.io/archive/guidelines/style/color.html#color-usability
+var DARK_FOREGROUND = {
+ name: 'dark',
+};
+var LIGHT_FOREGROUND = {
+ name: 'light',
+};
+
+var DARK_SHADOW = '1px 1px 0px rgba(0,0,0,0.4), -1px -1px 0px rgba(0,0,0,0.4)';
+var LIGHT_SHADOW = '';
+
+var DARK_CONTRAST_COLOR = colorToRgbaArray('rgba(0,0,0,0.87)');
+var LIGHT_CONTRAST_COLOR = colorToRgbaArray('rgba(255,255,255,0.87)');
+var STRONG_LIGHT_CONTRAST_COLOR = colorToRgbaArray('rgb(255,255,255)');
+
+var THEME_COLOR_TYPES = ['primary', 'accent', 'warn', 'background'];
+var DEFAULT_COLOR_TYPE = 'primary';
+
+// A color in a theme will use these hues by default, if not specified by user.
+var LIGHT_DEFAULT_HUES = {
+ 'accent': {
+ 'default': 'A200',
+ 'hue-1': 'A100',
+ 'hue-2': 'A400',
+ 'hue-3': 'A700'
+ },
+ 'background': {
+ 'default': '50',
+ 'hue-1': 'A100',
+ 'hue-2': '100',
+ 'hue-3': '300'
+ }
+};
+
+var DARK_DEFAULT_HUES = {
+ 'background': {
+ 'default': 'A400',
+ 'hue-1': '800',
+ 'hue-2': '900',
+ 'hue-3': 'A200'
+ }
+};
+
+// Icon opacity values (active/inactive) from
+// https://material.io/archive/guidelines/style/color.html#color-usability
+var DARK_CONTRAST_OPACITY = {
+ 'icon': 0.54,
+ 'secondary': 0.54,
+ 'disabled': 0.38,
+ 'hint': 0.38,
+ 'divider': 0.12,
+};
+
+var LIGHT_CONTRAST_OPACITY = {
+ 'icon': 0.87,
+ 'secondary': 0.7,
+ 'disabled': 0.5,
+ 'hint': 0.5,
+ 'divider': 0.12
+};
+
+// Icon opacity values (active/inactive) from
+// https://material.io/archive/guidelines/style/color.html#color-usability
+var STRONG_LIGHT_CONTRAST_OPACITY = {
+ 'icon': 1.0,
+ 'secondary': 0.7,
+ 'disabled': 0.5,
+ 'hint': 0.5,
+ 'divider': 0.12
+};
+
+THEME_COLOR_TYPES.forEach(function(colorType) {
+ // Color types with unspecified default hues will use these default hue values
+ var defaultDefaultHues = {
+ 'default': '500',
+ 'hue-1': '300',
+ 'hue-2': '800',
+ 'hue-3': 'A100'
+ };
+ if (!LIGHT_DEFAULT_HUES[colorType]) LIGHT_DEFAULT_HUES[colorType] = defaultDefaultHues;
+ if (!DARK_DEFAULT_HUES[colorType]) DARK_DEFAULT_HUES[colorType] = defaultDefaultHues;
+});
+
+var VALID_HUE_VALUES = [
+ '50', '100', '200', '300', '400', '500', '600',
+ '700', '800', '900', 'A100', 'A200', 'A400', 'A700'
+];
+
+var themeConfig = {
+ disableTheming : false, // Generate our themes at run time; also disable stylesheet DOM injection
+ generateOnDemand : false, // Whether or not themes are to be generated on-demand (vs. eagerly).
+ registeredStyles : [], // Custom styles registered to be used in the theming of custom components.
+ nonce : null // Nonce to be added as an attribute to the generated themes style tags.
+};
+
+/**
+ *
+ */
+function ThemingProvider($mdColorPalette, $$mdMetaProvider) {
+ ThemingService.$inject = ["$rootScope", "$mdUtil", "$q", "$log"];
+ PALETTES = { };
+ var THEMES = { };
+
+ var themingProvider;
+
+ var alwaysWatchTheme = false;
+ var defaultTheme = 'default';
+
+ // Load JS Defined Palettes
+ angular.extend(PALETTES, $mdColorPalette);
+
+ // Default theme defined in core.js
+
+ /**
+ * Adds `theme-color` and `msapplication-navbutton-color` meta tags with the color parameter
+ * @param {string} color Hex value of the wanted browser color
+ * @returns {function} Remove function of the meta tags
+ */
+ var setBrowserColor = function (color) {
+ // Chrome, Firefox OS and Opera
+ var removeChrome = $$mdMetaProvider.setMeta('theme-color', color);
+ // Windows Phone
+ var removeWindows = $$mdMetaProvider.setMeta('msapplication-navbutton-color', color);
+
+ return function () {
+ removeChrome();
+ removeWindows();
+ };
+ };
+
+ /**
+ * @ngdoc method
+ * @name $mdThemingProvider#enableBrowserColor
+ * @description
+ * Enables browser header coloring. For more info please visit
+ * <a href="https://developers.google.com/web/fundamentals/design-and-ui/browser-customization/theme-color">
+ * Web Fundamentals</a>.
+ * @param {object=} options Options for the browser color, which include:<br/>
+ * - `theme` - `{string}`: A defined theme via `$mdThemeProvider` to use the palettes from. Default is `default` theme. <br/>
+ * - `palette` - `{string}`: Can be any one of the basic material design palettes, extended defined palettes, or `primary`,
+ * `accent`, `background`, and `warn`. Default is `primary`.<br/>
+ * - `hue` - `{string}`: The hue from the selected palette. Default is `800`.<br/>
+ * @returns {function} Function that removes the browser coloring when called.
+ */
+ var enableBrowserColor = function (options) {
+ options = angular.isObject(options) ? options : {};
+
+ var theme = options.theme || 'default';
+ var hue = options.hue || '800';
+
+ var palette = PALETTES[options.palette] ||
+ PALETTES[THEMES[theme].colors[options.palette || 'primary'].name];
+
+ var color = angular.isObject(palette[hue]) ? palette[hue].hex : palette[hue];
+ if (color.substr(0, 1) !== '#') color = '#' + color;
+
+ return setBrowserColor(color);
+ };
+
+ return themingProvider = {
+ definePalette: definePalette,
+ extendPalette: extendPalette,
+ theme: registerTheme,
+
+ /**
+ * return a read-only clone of the current theme configuration
+ */
+ configuration : function() {
+ return angular.extend({ }, themeConfig, {
+ defaultTheme : defaultTheme,
+ alwaysWatchTheme : alwaysWatchTheme,
+ registeredStyles : [].concat(themeConfig.registeredStyles)
+ });
+ },
+
+ /**
+ * @ngdoc method
+ * @name $mdThemingProvider#disableTheming
+ * @description
+ * An easier way to disable theming without having to use `.constant("$MD_THEME_CSS","");`.
+ * This disables all dynamic theme style sheet generations and injections.
+ * @param {boolean=} isDisabled Disable all dynamic theme style sheet generations and injections
+ * if `true` or `undefined`.
+ */
+ disableTheming: function(isDisabled) {
+ themeConfig.disableTheming = angular.isUndefined(isDisabled) || !!isDisabled;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $mdThemingProvider#registerStyles
+ * @param {string} styles The styles to be appended to AngularJS Material's built in theme CSS.
+ */
+ registerStyles: function(styles) {
+ themeConfig.registeredStyles.push(styles);
+ },
+
+ /**
+ * @ngdoc method
+ * @name $mdThemingProvider#setNonce
+ * @param {string} nonceValue The nonce to be added as an attribute to the theme style tags.
+ * Setting a value allows the use of CSP policy without using the `'unsafe-inline'` directive.
+ * The string must already be base64 encoded. You can use `btoa(string)` to do this encoding.
+ * In your CSP's `style-src`, you would then add an entry for `'nonce-nonceValue'`.
+ */
+ setNonce: function(nonceValue) {
+ themeConfig.nonce = nonceValue;
+ },
+
+ generateThemesOnDemand: function(onDemand) {
+ themeConfig.generateOnDemand = onDemand;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $mdThemingProvider#setDefaultTheme
+ * @param {string} theme Default theme name to be applied to elements.
+ * Default value is `default`.
+ */
+ setDefaultTheme: function(theme) {
+ defaultTheme = theme;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $mdThemingProvider#alwaysWatchTheme
+ * @param {boolean} alwaysWatch Whether or not to always watch themes for changes and re-apply
+ * classes when they change. Default is `false`. Enabling can reduce performance.
+ */
+ alwaysWatchTheme: function(alwaysWatch) {
+ alwaysWatchTheme = alwaysWatch;
+ },
+
+ enableBrowserColor: enableBrowserColor,
+
+ $get: ThemingService,
+ _LIGHT_DEFAULT_HUES: LIGHT_DEFAULT_HUES,
+ _DARK_DEFAULT_HUES: DARK_DEFAULT_HUES,
+ _PALETTES: PALETTES,
+ _THEMES: THEMES,
+ _parseRules: parseRules,
+ _rgba: rgba
+ };
+
+ /**
+ * @ngdoc method
+ * @name $mdThemingProvider#definePalette
+ * @description
+ * In the event that you need to define a custom color palette, you can use this function to
+ * make it available to your theme for use in its intention groups.<br>
+ * Note that you must specify all hues in the definition map.
+ * @param {string} name Name of palette being defined
+ * @param {object} map Palette definition that includes hue definitions and contrast colors:
+ * - `'50'` - `{string}`: HEX color
+ * - `'100'` - `{string}`: HEX color
+ * - `'200'` - `{string}`: HEX color
+ * - `'300'` - `{string}`: HEX color
+ * - `'400'` - `{string}`: HEX color
+ * - `'500'` - `{string}`: HEX color
+ * - `'600'` - `{string}`: HEX color
+ * - `'700'` - `{string}`: HEX color
+ * - `'800'` - `{string}`: HEX color
+ * - `'900'` - `{string}`: HEX color
+ * - `'A100'` - `{string}`: HEX color
+ * - `'A200'` - `{string}`: HEX color
+ * - `'A400'` - `{string}`: HEX color
+ * - `'A700'` - `{string}`: HEX color
+ * - `'contrastDefaultColor'` - `{string}`: `light` or `dark`
+ * - `'contrastDarkColors'` - `{string[]}`: Hues which should use dark contrast colors (i.e. raised button text).
+ * For example: `['50', '100', '200', '300', '400', 'A100']`.
+ * - `'contrastLightColors'` - `{string[]}`: Hues which should use light contrast colors (i.e. raised button text).
+ * For example: `['500', '600', '700', '800', '900', 'A200', 'A400', 'A700']`.
+ */
+ function definePalette(name, map) {
+ map = map || {};
+ PALETTES[name] = checkPaletteValid(name, map);
+ return themingProvider;
+ }
+
+ /**
+ * @ngdoc method
+ * @name $mdThemingProvider#extendPalette
+ * @description
+ * Sometimes it is easier to extend an existing color palette and then change a few properties,
+ * rather than defining a whole new palette.
+ * @param {string} name Name of palette being extended
+ * @param {object} map Palette definition that includes optional hue definitions and contrast colors:
+ * - `'50'` - `{string}`: HEX color
+ * - `'100'` - `{string}`: HEX color
+ * - `'200'` - `{string}`: HEX color
+ * - `'300'` - `{string}`: HEX color
+ * - `'400'` - `{string}`: HEX color
+ * - `'500'` - `{string}`: HEX color
+ * - `'600'` - `{string}`: HEX color
+ * - `'700'` - `{string}`: HEX color
+ * - `'800'` - `{string}`: HEX color
+ * - `'900'` - `{string}`: HEX color
+ * - `'A100'` - `{string}`: HEX color
+ * - `'A200'` - `{string}`: HEX color
+ * - `'A400'` - `{string}`: HEX color
+ * - `'A700'` - `{string}`: HEX color
+ * - `'contrastDefaultColor'` - `{string}`: `light` or `dark`
+ * - `'contrastDarkColors'` - `{string[]}`: Hues which should use dark contrast colors (i.e. raised button text).
+ * For example: `['50', '100', '200', '300', '400', 'A100']`.
+ * - `'contrastLightColors'` - `{string[]}`: Hues which should use light contrast colors (i.e. raised button text).
+ * For example: `['500', '600', '700', '800', '900', 'A200', 'A400', 'A700']`.
+ * @returns {object} A new object which is a copy of the given palette, `name`,
+ * with variables from `map` overwritten.
+ */
+ function extendPalette(name, map) {
+ return checkPaletteValid(name, angular.extend({}, PALETTES[name] || {}, map));
+ }
+
+ // Make sure that palette has all required hues
+ function checkPaletteValid(name, map) {
+ var missingColors = VALID_HUE_VALUES.filter(function(field) {
+ return !map[field];
+ });
+ if (missingColors.length) {
+ throw new Error("Missing colors %1 in palette %2!"
+ .replace('%1', missingColors.join(', '))
+ .replace('%2', name));
+ }
+
+ return map;
+ }
+
+ /**
+ * @ngdoc method
+ * @name $mdThemingProvider#theme
+ * @description
+ * Register a theme (which is a collection of color palettes); i.e. `warn`, `accent`,
+ * `background`, and `primary`.<br>
+ * Optionally inherit from an existing theme.
+ * @param {string} name Name of theme being registered
+ * @param {string=} inheritFrom Existing theme name to inherit from
+ */
+ function registerTheme(name, inheritFrom) {
+ if (THEMES[name]) return THEMES[name];
+
+ inheritFrom = inheritFrom || 'default';
+
+ var parentTheme = typeof inheritFrom === 'string' ? THEMES[inheritFrom] : inheritFrom;
+ var theme = new Theme(name);
+
+ if (parentTheme) {
+ angular.forEach(parentTheme.colors, function(color, colorType) {
+ theme.colors[colorType] = {
+ name: color.name,
+ // Make sure a COPY of the hues is given to the child color,
+ // not the same reference.
+ hues: angular.extend({}, color.hues)
+ };
+ });
+ }
+ THEMES[name] = theme;
+
+ return theme;
+ }
+
+ function Theme(name) {
+ var self = this;
+ self.name = name;
+ self.colors = {};
+
+ self.dark = setDark;
+ setDark(false);
+
+ function setDark(isDark) {
+ isDark = arguments.length === 0 ? true : !!isDark;
+
+ // If no change, abort
+ if (isDark === self.isDark) return;
+
+ self.isDark = isDark;
+
+ self.foregroundPalette = self.isDark ? LIGHT_FOREGROUND : DARK_FOREGROUND;
+ self.foregroundShadow = self.isDark ? DARK_SHADOW : LIGHT_SHADOW;
+
+ // Light and dark themes have different default hues.
+ // Go through each existing color type for this theme, and for every
+ // hue value that is still the default hue value from the previous light/dark setting,
+ // set it to the default hue value from the new light/dark setting.
+ var newDefaultHues = self.isDark ? DARK_DEFAULT_HUES : LIGHT_DEFAULT_HUES;
+ var oldDefaultHues = self.isDark ? LIGHT_DEFAULT_HUES : DARK_DEFAULT_HUES;
+ angular.forEach(newDefaultHues, function(newDefaults, colorType) {
+ var color = self.colors[colorType];
+ var oldDefaults = oldDefaultHues[colorType];
+ if (color) {
+ for (var hueName in color.hues) {
+ if (color.hues[hueName] === oldDefaults[hueName]) {
+ color.hues[hueName] = newDefaults[hueName];
+ }
+ }
+ }
+ });
+
+ return self;
+ }
+
+ THEME_COLOR_TYPES.forEach(function(colorType) {
+ var defaultHues = (self.isDark ? DARK_DEFAULT_HUES : LIGHT_DEFAULT_HUES)[colorType];
+ self[colorType + 'Palette'] = function setPaletteType(paletteName, hues) {
+ var color = self.colors[colorType] = {
+ name: paletteName,
+ hues: angular.extend({}, defaultHues, hues)
+ };
+
+ Object.keys(color.hues).forEach(function(name) {
+ if (!defaultHues[name]) {
+ throw new Error("Invalid hue name '%1' in theme %2's %3 color %4. Available hue names: %4"
+ .replace('%1', name)
+ .replace('%2', self.name)
+ .replace('%3', paletteName)
+ .replace('%4', Object.keys(defaultHues).join(', '))
+ );
+ }
+ });
+ Object.keys(color.hues).map(function(key) {
+ return color.hues[key];
+ }).forEach(function(hueValue) {
+ if (VALID_HUE_VALUES.indexOf(hueValue) === -1) {
+ throw new Error("Invalid hue value '%1' in theme %2's %3 color %4. Available hue values: %5"
+ .replace('%1', hueValue)
+ .replace('%2', self.name)
+ .replace('%3', colorType)
+ .replace('%4', paletteName)
+ .replace('%5', VALID_HUE_VALUES.join(', '))
+ );
+ }
+ });
+ return self;
+ };
+ });
+ }
+
+ /**
+ * @ngdoc service
+ * @name $mdTheming
+ * @module material.core.theming
+ * @description
+ * Service that makes an element apply theming related <b>classes</b> to itself.
+ *
+ * For more information on the hue objects, their default values, as well as valid hue values, please visit <a ng-href="Theming/03_configuring_a_theme#specifying-custom-hues-for-color-intentions">the custom hues section of Configuring a Theme</a>.
+ *
+ * <hljs lang="js">
+ * // Example component directive that we want to apply theming classes to.
+ * app.directive('myFancyDirective', function($mdTheming) {
+ * return {
+ * restrict: 'AE',
+ * link: function(scope, element, attrs) {
+ * // Initialize the service using our directive's element
+ * $mdTheming(element);
+ *
+ * $mdTheming.defineTheme('myTheme', {
+ * primary: 'blue',
+ * primaryHues: {
+ * default: '500',
+ * hue-1: '300',
+ * hue-2: '900',
+ * hue-3: 'A100'
+ * },
+ * accent: 'pink',
+ * accentHues: {
+ * default: '600',
+ * hue-1: '300',
+ * hue-2: '200',
+ * hue-3: 'A500'
+ * },
+ * warn: 'red',
+ * // It's not necessary to specify all hues in the object.
+ * warnHues: {
+ * default: '200',
+ * hue-3: 'A100'
+ * },
+ * // It's not necessary to specify custom hues at all.
+ * background: 'grey',
+ * dark: true
+ * });
+ * // Your directive's custom code here.
+ * }
+ * };
+ * });
+ * </hljs>
+ * @param {element=} element Element that will have theming classes applied to it.
+ */
+
+ /**
+ * @ngdoc property
+ * @name $mdTheming#THEMES
+ * @description
+ * Property to get all the themes defined
+ * @returns {object} All the themes defined with their properties.
+ */
+
+ /**
+ * @ngdoc property
+ * @name $mdTheming#PALETTES
+ * @description
+ * Property to get all the palettes defined
+ * @returns {object} All the palettes defined with their colors.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $mdTheming#registered
+ * @description
+ * Determine is specified theme name is a valid, registered theme
+ * @param {string} themeName the theme to check if registered
+ * @returns {boolean} whether the theme is registered or not
+ */
+
+ /**
+ * @ngdoc method
+ * @name $mdTheming#defaultTheme
+ * @description
+ * Returns the default theme
+ * @returns {string} The default theme
+ */
+
+ /**
+ * @ngdoc method
+ * @name $mdTheming#generateTheme
+ * @description
+ * Lazy generate themes - by default, every theme is generated when defined.
+ * You can disable this in the configuration section using the
+ * `$mdThemingProvider.generateThemesOnDemand(true);`
+ *
+ * The theme name that is passed in must match the name of the theme that was defined as part of
+ * the configuration block.
+ *
+ * @param {string} name theme name to generate
+ */
+
+ /**
+ * @ngdoc method
+ * @name $mdTheming#setBrowserColor
+ * @description
+ * Enables browser header coloring. For more info please visit
+ * <a href="https://developers.google.com/web/fundamentals/design-and-ui/browser-customization/theme-color">
+ * Web Fundamentals</a>.
+ * @param {object=} options Options for the browser color, which include:<br/>
+ * - `theme` - `{string}`: A defined theme via `$mdThemeProvider` to use the palettes from.
+ * Default is `default` theme. <br/>
+ * - `palette` - `{string}`: Can be any one of the basic material design palettes, extended
+ * defined palettes, or `primary`, `accent`, `background`, and `warn`. Default is `primary`.
+ * <br/>
+ * - `hue` - `{string}`: The hue from the selected palette. Default is `800`.<br/>
+ * @returns {function} Function that removes the browser coloring when called.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $mdTheming#defineTheme
+ * @description
+ * Dynamically define a theme by using an options object that contains palette names.
+ *
+ * @param {string} name Theme name to define
+ * @param {object} options Theme definition options
+ *
+ * Options are:<br/>
+ * - `primary` - `{string}`: The name of the primary palette to use in the theme.<br/>
+ * - `primaryHues` - `{object=}`: Override hues for primary palette.<br/>
+ * - `accent` - `{string}`: The name of the accent palette to use in the theme.<br/>
+ * - `accentHues` - `{object=}`: Override hues for accent palette.<br/>
+ * - `warn` - `{string}`: The name of the warn palette to use in the theme.<br/>
+ * - `warnHues` - `{object=}`: Override hues for warn palette.<br/>
+ * - `background` - `{string}`: The name of the background palette to use in the theme.<br/>
+ * - `backgroundHues` - `{object=}`: Override hues for background palette.<br/>
+ * - `dark` - `{boolean}`: Indicates if it's a dark theme.<br/>
+ * @returns {Promise<string>} A resolved promise with the new theme name.
+ */
+
+ /* @ngInject */
+ function ThemingService($rootScope, $mdUtil, $q, $log) {
+ // Allow us to be invoked via a linking function signature.
+ var applyTheme = function (scope, el) {
+ if (el === undefined) { el = scope; scope = undefined; }
+ if (scope === undefined) { scope = $rootScope; }
+ applyTheme.inherit(el, el);
+ };
+
+ Object.defineProperty(applyTheme, 'THEMES', {
+ get: function () {
+ return angular.extend({}, THEMES);
+ }
+ });
+ Object.defineProperty(applyTheme, 'PALETTES', {
+ get: function () {
+ return angular.extend({}, PALETTES);
+ }
+ });
+ Object.defineProperty(applyTheme, 'ALWAYS_WATCH', {
+ get: function () {
+ return alwaysWatchTheme;
+ }
+ });
+ applyTheme.inherit = inheritTheme;
+ applyTheme.registered = registered;
+ applyTheme.defaultTheme = function() { return defaultTheme; };
+ applyTheme.generateTheme = function(name) { generateTheme(THEMES[name], name, themeConfig.nonce); };
+ applyTheme.defineTheme = function(name, options) {
+ options = options || {};
+
+ var theme = registerTheme(name);
+
+ if (options.primary) {
+ theme.primaryPalette(options.primary, options.primaryHues);
+ }
+ if (options.accent) {
+ theme.accentPalette(options.accent, options.accentHues);
+ }
+ if (options.warn) {
+ theme.warnPalette(options.warn, options.warnHues);
+ }
+ if (options.background) {
+ theme.backgroundPalette(options.background, options.backgroundHues);
+ }
+ if (options.dark){
+ theme.dark();
+ }
+
+ this.generateTheme(name);
+
+ return $q.resolve(name);
+ };
+ applyTheme.setBrowserColor = enableBrowserColor;
+
+ return applyTheme;
+
+ /**
+ * Determine is specified theme name is a valid, registered theme
+ */
+ function registered(themeName) {
+ if (themeName === undefined || themeName === '') return true;
+ return applyTheme.THEMES[themeName] !== undefined;
+ }
+
+ /**
+ * Get theme name for the element, then update with Theme CSS class
+ */
+ function inheritTheme (el, parent) {
+ var ctrl = parent.controller('mdTheme') || el.data('$mdThemeController');
+ var scope = el.scope();
+
+ updateThemeClass(lookupThemeName());
+
+ if (ctrl) {
+ var watchTheme = alwaysWatchTheme ||
+ ctrl.$shouldWatch ||
+ $mdUtil.parseAttributeBoolean(el.attr('md-theme-watch'));
+
+ if (watchTheme || ctrl.isAsyncTheme) {
+ var clearNameWatcher = function () {
+ if (unwatch) {
+ unwatch();
+ unwatch = undefined;
+ }
+ };
+
+ var unwatch = ctrl.registerChanges(function(name) {
+ updateThemeClass(name);
+
+ if (!watchTheme) {
+ clearNameWatcher();
+ }
+ });
+
+ if (scope) {
+ scope.$on('$destroy', clearNameWatcher);
+ } else {
+ el.on('$destroy', clearNameWatcher);
+ }
+ }
+ }
+
+ /**
+ * Find the theme name from the parent controller or element data
+ */
+ function lookupThemeName() {
+ // As a few components (dialog) add their controllers later, we should also watch for a controller init.
+ return ctrl && ctrl.$mdTheme || (defaultTheme === 'default' ? '' : defaultTheme);
+ }
+
+ /**
+ * Remove old theme class and apply a new one
+ * NOTE: if not a valid theme name, then the current name is not changed
+ */
+ function updateThemeClass(theme) {
+ if (!theme) return;
+ if (!registered(theme)) {
+ $log.warn('Attempted to use unregistered theme \'' + theme + '\'. ' +
+ 'Register it with $mdThemingProvider.theme().');
+ }
+
+ var oldTheme = el.data('$mdThemeName');
+ if (oldTheme) el.removeClass('md-' + oldTheme +'-theme');
+ el.addClass('md-' + theme + '-theme');
+ el.data('$mdThemeName', theme);
+ if (ctrl) {
+ el.data('$mdThemeController', ctrl);
+ }
+ }
+ }
+
+ }
+}
+
+function ThemingDirective($mdTheming, $interpolate, $parse, $mdUtil, $q, $log) {
+ return {
+ priority: 101, // has to be more than 100 to be before interpolation (issue on IE)
+ link: {
+ pre: function(scope, el, attrs) {
+ var registeredCallbacks = [];
+
+ var startSymbol = $interpolate.startSymbol();
+ var endSymbol = $interpolate.endSymbol();
+
+ var theme = attrs.mdTheme.trim();
+
+ var hasInterpolation =
+ theme.substr(0, startSymbol.length) === startSymbol &&
+ theme.lastIndexOf(endSymbol) === theme.length - endSymbol.length;
+
+ var oneTimeOperator = '::';
+ var oneTimeBind = attrs.mdTheme
+ .split(startSymbol).join('')
+ .split(endSymbol).join('')
+ .trim()
+ .substr(0, oneTimeOperator.length) === oneTimeOperator;
+
+ var getTheme = function () {
+ var interpolation = $interpolate(attrs.mdTheme)(scope);
+ return $parse(interpolation)(scope) || interpolation;
+ };
+
+ var ctrl = {
+ isAsyncTheme: angular.isFunction(getTheme()) || angular.isFunction(getTheme().then),
+ registerChanges: function (cb, context) {
+ if (context) {
+ cb = angular.bind(context, cb);
+ }
+
+ registeredCallbacks.push(cb);
+
+ return function () {
+ var index = registeredCallbacks.indexOf(cb);
+
+ if (index > -1) {
+ registeredCallbacks.splice(index, 1);
+ }
+ };
+ },
+ $setTheme: function (theme) {
+ if (!$mdTheming.registered(theme)) {
+ $log.warn('attempted to use unregistered theme \'' + theme + '\'');
+ }
+
+ ctrl.$mdTheme = theme;
+
+ // Iterating backwards to support unregistering during iteration
+ // http://stackoverflow.com/a/9882349/890293
+ // we don't use `reverse()` of array because it mutates the array and we don't want it
+ // to get re-indexed
+ for (var i = registeredCallbacks.length; i--;) {
+ registeredCallbacks[i](theme);
+ }
+ },
+ $shouldWatch: $mdUtil.parseAttributeBoolean(el.attr('md-theme-watch')) ||
+ $mdTheming.ALWAYS_WATCH ||
+ (hasInterpolation && !oneTimeBind)
+ };
+
+ el.data('$mdThemeController', ctrl);
+
+ var setParsedTheme = function (theme) {
+ if (typeof theme === 'string') {
+ return ctrl.$setTheme(theme);
+ }
+
+ $q.when(angular.isFunction(theme) ? theme() : theme)
+ .then(function(name) {
+ ctrl.$setTheme(name);
+ });
+ };
+
+ setParsedTheme(getTheme());
+
+ var unwatch = scope.$watch(getTheme, function(theme) {
+ if (theme) {
+ setParsedTheme(theme);
+
+ if (!ctrl.$shouldWatch) {
+ unwatch();
+ }
+ }
+ });
+ }
+ }
+ };
+}
+
+/**
+ * Special directive that will disable ALL runtime Theme style generation and DOM injection
+ *
+ * <link rel="stylesheet" href="angular-material.min.css">
+ * <link rel="stylesheet" href="angular-material.themes.css">
+ *
+ * <body md-themes-disabled>
+ * ...
+ * </body>
+ *
+ * Note: Using md-themes-css directive requires the developer to load external
+ * theme stylesheets; e.g. custom themes from Material-Tools:
+ *
+ * `angular-material.themes.css`
+ *
+ * Another option is to use the ThemingProvider to configure and disable the attribute
+ * conversions; this would obviate the use of the `md-themes-css` directive
+ *
+ */
+function disableThemesDirective() {
+ themeConfig.disableTheming = true;
+
+ // Return a 1x-only, first-match attribute directive
+ return {
+ restrict : 'A',
+ priority : '900'
+ };
+}
+
+function ThemableDirective($mdTheming) {
+ return $mdTheming;
+}
+
+function parseRules(theme, colorType, rules) {
+ checkValidPalette(theme, colorType);
+
+ rules = rules.replace(/THEME_NAME/g, theme.name);
+ var themeNameRegex = new RegExp('\\.md-' + theme.name + '-theme', 'g');
+ // Matches '{{ primary-color }}', etc
+ var hueRegex = new RegExp('([\'"])?{{\\s*([a-zA-Z]+)-?(color|default)?-?(contrast)?-?((?:\\d\\.?\\d*)|(?:[a-zA-Z]+))?\\s*}}(["\'])?','g');
+ var simpleVariableRegex = /'?"?{{\s*([a-zA-Z]+)-(A?\d+|hue-[0-3]|shadow|default)-?(contrast)?-?((?:\d\.?\d*)|(?:[a-zA-Z]+))?\s*}}'?"?/g;
+ var defaultBgHue = theme.colors['background'].hues['default'];
+ var defaultBgContrastType = PALETTES[theme.colors['background'].name][defaultBgHue].contrastType;
+
+ // find and replace simple variables where we use a specific hue, not an entire palette
+ // eg. "{{primary-100}}"
+ // \(' + THEME_COLOR_TYPES.join('\|') + '\)'
+ rules = rules.replace(simpleVariableRegex, function(match, colorType, hue, contrast, opacity) {
+ var regexColorType = colorType;
+ if (colorType === 'foreground') {
+ if (hue === 'shadow') {
+ return theme.foregroundShadow;
+ } else if (theme.foregroundPalette[hue]) {
+ // Use user defined palette number (ie: foreground-2)
+ return rgba(colorToRgbaArray(theme.foregroundPalette[hue]));
+ } else if (theme.foregroundPalette['1']){
+ return rgba(colorToRgbaArray(theme.foregroundPalette['1']));
+ }
+ // Default to background-default-contrast-{opacity}
+ colorType = 'background';
+ contrast = 'contrast';
+ if (!opacity && hue) {
+ // Convert references to legacy hues to opacities (i.e. foreground-4 to *-divider)
+ switch (hue) {
+ // hue-1 uses default opacity
+ case '2':
+ opacity = 'secondary';
+ break;
+ case '3':
+ opacity = 'disabled';
+ break;
+ case '4':
+ opacity = 'divider';
+ }
+ }
+ hue = 'default';
+ }
+
+ // `default` is also accepted as a hue-value, because the background palettes are
+ // using it as a name for the default hue.
+ if (hue.indexOf('hue') === 0 || hue === 'default') {
+ hue = theme.colors[colorType].hues[hue];
+ }
+
+ var colorDetails = (PALETTES[ theme.colors[colorType].name ][hue] || '');
+
+ // If user has specified a foreground color, use those
+ if (colorType === 'background' && contrast && regexColorType !== 'foreground' &&
+ colorDetails.contrastType === defaultBgContrastType) {
+ // Don't process if colorType was changed
+ switch (opacity) {
+ case 'secondary':
+ case 'icon':
+ if (theme.foregroundPalette['2']) {
+ return rgba(colorToRgbaArray(theme.foregroundPalette['2']));
+ }
+ break;
+ case 'disabled':
+ case 'hint':
+ if (theme.foregroundPalette['3']) {
+ return rgba(colorToRgbaArray(theme.foregroundPalette['3']));
+ }
+ break;
+ case 'divider':
+ if (theme.foregroundPalette['4']) {
+ return rgba(colorToRgbaArray(theme.foregroundPalette['4']));
+ }
+ break;
+ default:
+ if (theme.foregroundPalette['1']) {
+ return rgba(colorToRgbaArray(theme.foregroundPalette['1']));
+ }
+ break;
+ }
+ }
+
+ if (contrast && opacity) {
+ opacity = colorDetails.opacity[opacity] || opacity;
+ }
+
+ return rgba(colorDetails[contrast ? 'contrast' : 'value'], opacity);
+ });
+
+ var generatedRules = [];
+
+ // For each type, generate rules for each hue (ie. default, md-hue-1, md-hue-2, md-hue-3)
+ angular.forEach(['default', 'hue-1', 'hue-2', 'hue-3'], function(hueName) {
+ var newRule = rules
+ .replace(hueRegex, function(match, _, matchedColorType, hueType, contrast, opacity) {
+ var color = theme.colors[matchedColorType];
+ var palette = PALETTES[color.name];
+ var hueValue = color.hues[hueName];
+ if (contrast && opacity) {
+ opacity = palette[hueValue].opacity[opacity] || opacity;
+ }
+ return rgba(palette[hueValue][hueType === 'color' ? 'value' : 'contrast'], opacity);
+ });
+ if (hueName !== 'default') {
+ newRule = newRule.replace(themeNameRegex, '.md-' + theme.name + '-theme.md-' + hueName);
+ }
+
+ // Don't apply a selector rule to the default theme, making it easier to override
+ // styles of the base-component
+ if (theme.name === 'default') {
+ var themeRuleRegex = /((?:\s|>|\.|\w|-|:|\(|\)|\[|]|"|'|=)*)\.md-default-theme((?:\s|>|\.|\w|-|:|\(|\)|\[|]|"|'|=)*)/g;
+
+ newRule = newRule.replace(themeRuleRegex, function(match, start, end) {
+ return match + ', ' + start + end;
+ });
+ }
+ generatedRules.push(newRule);
+ });
+
+ return generatedRules;
+}
+
+var rulesByType = {};
+
+// Generate our themes at run time given the state of THEMES and PALETTES
+function generateAllThemes($injector, $mdTheming) {
+ var head = document.head;
+ var firstChild = head ? head.firstElementChild : null;
+ var themeCss = !themeConfig.disableTheming && $injector.has('$MD_THEME_CSS') ? $injector.get('$MD_THEME_CSS') : '';
+
+ // Append our custom registered styles to the theme stylesheet.
+ themeCss += themeConfig.registeredStyles.join('');
+
+ if (!firstChild) return;
+ if (themeCss.length === 0) return; // no rules, so no point in running this expensive task
+
+ // Expose contrast colors for palettes to ensure that text is always readable
+ angular.forEach(PALETTES, sanitizePalette);
+
+ // MD_THEME_CSS is a string generated by the build process that includes all the themeable
+ // components as templates
+
+ // Break the CSS into individual rules
+ var rules = splitCss(themeCss).map(function(rule) {
+ return rule.trim();
+ });
+
+ THEME_COLOR_TYPES.forEach(function(type) {
+ rulesByType[type] = '';
+ });
+
+ // Sort the rules based on type, allowing us to do color substitution on a per-type basis
+ rules.forEach(function(rule) {
+ // First: test that if the rule has '.md-accent', it goes into the accent set of rules
+ for (var i = 0, type; type = THEME_COLOR_TYPES[i]; i++) {
+ if (rule.indexOf('.md-' + type) > -1) {
+ return rulesByType[type] += rule;
+ }
+ }
+
+ // If no eg 'md-accent' class is found, try to just find 'accent' in the rule and guess from
+ // there
+ for (i = 0; type = THEME_COLOR_TYPES[i]; i++) {
+ if (rule.indexOf(type) > -1) {
+ return rulesByType[type] += rule;
+ }
+ }
+
+ // Default to the primary array
+ return rulesByType[DEFAULT_COLOR_TYPE] += rule;
+ });
+
+ // If themes are being generated on-demand, quit here. The user will later manually
+ // call generateTheme to do this on a theme-by-theme basis.
+ if (themeConfig.generateOnDemand) return;
+
+ angular.forEach($mdTheming.THEMES, function(theme) {
+ if (!GENERATED[theme.name] && !($mdTheming.defaultTheme() !== 'default' && theme.name === 'default')) {
+ generateTheme(theme, theme.name, themeConfig.nonce);
+ }
+ });
+
+
+ // *************************
+ // Internal functions
+ // *************************
+
+ /**
+ * The user specifies a 'default' contrast color as either light or dark, then explicitly lists
+ * which hues are the opposite contrast (eg. A100 has dark, A200 has light).
+ * @param {!object} palette to sanitize
+ */
+ function sanitizePalette(palette) {
+ var defaultContrast = palette.contrastDefaultColor;
+ var lightColors = palette.contrastLightColors || [];
+ var strongLightColors = palette.contrastStrongLightColors || [];
+ var darkColors = palette.contrastDarkColors || [];
+
+ // These colors are provided as space-separated lists
+ if (typeof lightColors === 'string') lightColors = lightColors.split(' ');
+ if (typeof strongLightColors === 'string') strongLightColors = strongLightColors.split(' ');
+ if (typeof darkColors === 'string') darkColors = darkColors.split(' ');
+
+ // Cleanup after ourselves
+ delete palette.contrastDefaultColor;
+ delete palette.contrastLightColors;
+ delete palette.contrastStrongLightColors;
+ delete palette.contrastDarkColors;
+
+ /**
+ * @param {string} hueName
+ * @return {'dark'|'light'|'strongLight'}
+ */
+ function getContrastType(hueName) {
+ if (defaultContrast === 'light' ? darkColors.indexOf(hueName) !== -1 :
+ (lightColors.indexOf(hueName) === -1 && strongLightColors.indexOf(hueName) === -1)) {
+ return 'dark';
+ }
+ if (strongLightColors.indexOf(hueName) !== -1) {
+ return 'strongLight';
+ }
+ return 'light';
+ }
+
+ /**
+ * @param {'dark'|'light'|'strongLight'} contrastType
+ * @return {[number, number, number]} [red, green, blue] array
+ */
+ function getContrastColor(contrastType) {
+ switch (contrastType) {
+ default:
+ case 'strongLight':
+ return STRONG_LIGHT_CONTRAST_COLOR;
+ case 'light':
+ return LIGHT_CONTRAST_COLOR;
+ case 'dark':
+ return DARK_CONTRAST_COLOR;
+ }
+ }
+
+ /**
+ * @param {'dark'|'light'|'strongLight'} contrastType
+ * @return {{secondary: number, divider: number, hint: number, icon: number, disabled: number}}
+ */
+ function getOpacityValues(contrastType) {
+ switch (contrastType) {
+ default:
+ case 'strongLight':
+ return STRONG_LIGHT_CONTRAST_OPACITY;
+ case 'light':
+ return LIGHT_CONTRAST_OPACITY;
+ case 'dark':
+ return DARK_CONTRAST_OPACITY;
+ }
+ }
+ // Change { 'A100': '#fffeee' } to { 'A100': { value: '#fffeee', contrast:DARK_CONTRAST_COLOR }
+ angular.forEach(palette, function(hueValue, hueName) {
+ if (angular.isObject(hueValue)) return; // Already converted
+ // Map everything to rgb colors
+ var rgbValue = colorToRgbaArray(hueValue);
+ if (!rgbValue) {
+ throw new Error("Color %1, in palette %2's hue %3, is invalid. Hex or rgb(a) color expected."
+ .replace('%1', hueValue)
+ .replace('%2', palette.name)
+ .replace('%3', hueName));
+ }
+
+ var contrastType = getContrastType(hueName);
+ palette[hueName] = {
+ hex: palette[hueName],
+ value: rgbValue,
+ contrastType: contrastType,
+ contrast: getContrastColor(contrastType),
+ opacity: getOpacityValues(contrastType)
+ };
+ });
+ }
+
+ /**
+ * @param {string} themeCss
+ * @returns {[]} a string representing a CSS file that is split, producing an array with a rule
+ * at each index.
+ */
+ function splitCss(themeCss) {
+ var result = [];
+ var currentRule = '';
+ var openedCurlyBrackets = 0;
+ var closedCurlyBrackets = 0;
+
+ for (var i = 0; i < themeCss.length; i++) {
+ var character = themeCss.charAt(i);
+
+ // Check for content in quotes
+ if (character === '\'' || character === '"') {
+ // Append text in quotes to current rule
+ var textInQuotes = themeCss.substring(i, themeCss.indexOf(character, i + 1));
+ currentRule += textInQuotes;
+
+ // Jump to the closing quote char
+ i += textInQuotes.length;
+ } else {
+ currentRule += character;
+
+ if (character === '}') {
+ closedCurlyBrackets++;
+ if (closedCurlyBrackets === openedCurlyBrackets) {
+ closedCurlyBrackets = 0;
+ openedCurlyBrackets = 0;
+ result.push(currentRule);
+ currentRule = '';
+ }
+ } else if (character === '{') {
+ openedCurlyBrackets++;
+ }
+ }
+ }
+ // Add comments added after last valid rule.
+ if (currentRule !== '') {
+ result.push(currentRule);
+ }
+
+ return result;
+ }
+}
+
+function generateTheme(theme, name, nonce) {
+ var head = document.head;
+ var firstChild = head ? head.firstElementChild : null;
+
+ if (!GENERATED[name]) {
+ // For each theme, use the color palettes specified for
+ // `primary`, `warn` and `accent` to generate CSS rules.
+ THEME_COLOR_TYPES.forEach(function(colorType) {
+ var styleStrings = parseRules(theme, colorType, rulesByType[colorType]);
+ while (styleStrings.length) {
+ var styleContent = styleStrings.shift();
+ if (styleContent) {
+ var style = document.createElement('style');
+ style.setAttribute('md-theme-style', '');
+ if (nonce) {
+ style.setAttribute('nonce', nonce);
+ }
+ style.appendChild(document.createTextNode(styleContent));
+ head.insertBefore(style, firstChild);
+ }
+ }
+ });
+
+ GENERATED[theme.name] = true;
+ }
+
+}
+
+
+function checkValidPalette(theme, colorType) {
+ // If theme attempts to use a palette that doesnt exist, throw error
+ if (!PALETTES[ (theme.colors[colorType] || {}).name ]) {
+ throw new Error(
+ "You supplied an invalid color palette for theme %1's %2 palette. Available palettes: %3"
+ .replace('%1', theme.name)
+ .replace('%2', colorType)
+ .replace('%3', Object.keys(PALETTES).join(', '))
+ );
+ }
+}
+
+/**
+ * @param {string} clr rbg or rgba color
+ * @return {number[]|undefined} [red, green, blue] array if it can be computed
+ */
+function colorToRgbaArray(clr) {
+ if (angular.isArray(clr) && clr.length === 3) return clr;
+ if (/^rgb/.test(clr)) {
+ return clr.replace(/(^\s*rgba?\(|\)\s*$)/g, '').split(',').map(function(value, i) {
+ return i === 3 ? parseFloat(value) : parseInt(value, 10);
+ });
+ }
+ if (clr.charAt(0) === '#') clr = clr.substring(1);
+ if (!/^([a-fA-F0-9]{3}){1,2}$/g.test(clr)) return;
+
+ var dig = clr.length / 3;
+ var red = clr.substr(0, dig);
+ var grn = clr.substr(dig, dig);
+ var blu = clr.substr(dig * 2);
+ if (dig === 1) {
+ red += red;
+ grn += grn;
+ blu += blu;
+ }
+ return [parseInt(red, 16), parseInt(grn, 16), parseInt(blu, 16)];
+}
+
+function rgba(rgbArray, opacity) {
+ if (!rgbArray) return "rgb('0,0,0')";
+
+ if (rgbArray.length === 4) {
+ rgbArray = angular.copy(rgbArray);
+ opacity ? rgbArray.pop() : opacity = rgbArray.pop();
+ }
+ return opacity && (typeof opacity == 'number' || (typeof opacity == 'string' && opacity.length)) ?
+ 'rgba(' + rgbArray.join(',') + ',' + opacity + ')' :
+ 'rgb(' + rgbArray.join(',') + ')';
+}
+
+
+})(window.angular);
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.autocomplete
+ */
+/*
+ * @see js folder for autocomplete implementation
+ */
+angular.module('material.components.autocomplete', [
+ 'material.core',
+ 'material.components.icon',
+ 'material.components.virtualRepeat'
+]);
+
+})();
+(function(){
+"use strict";
+
+
+MdAutocompleteCtrl.$inject = ["$scope", "$element", "$mdUtil", "$mdConstant", "$mdTheming", "$window", "$animate", "$rootElement", "$attrs", "$q", "$log", "$mdLiveAnnouncer"];angular
+ .module('material.components.autocomplete')
+ .controller('MdAutocompleteCtrl', MdAutocompleteCtrl);
+
+var ITEM_HEIGHT = 48,
+ MAX_ITEMS = 5,
+ MENU_PADDING = 8,
+ INPUT_PADDING = 2, // Padding provided by `md-input-container`
+ MODE_STANDARD = 'standard',
+ MODE_VIRTUAL = 'virtual';
+
+function MdAutocompleteCtrl ($scope, $element, $mdUtil, $mdConstant, $mdTheming, $window,
+ $animate, $rootElement, $attrs, $q, $log, $mdLiveAnnouncer) {
+
+ // Internal Variables.
+ var ctrl = this,
+ itemParts = $scope.itemsExpr.split(/ in /i),
+ itemExpr = itemParts[ 1 ],
+ elements = null,
+ cache = {},
+ noBlur = false,
+ selectedItemWatchers = [],
+ hasFocus = false,
+ fetchesInProgress = 0,
+ enableWrapScroll = null,
+ inputModelCtrl = null,
+ debouncedOnResize = $mdUtil.debounce(onWindowResize),
+ mode = MODE_VIRTUAL; // default
+
+ /**
+ * The root document element. This is used for attaching a top-level click handler to
+ * close the options panel when a click outside said panel occurs. We use `documentElement`
+ * instead of body because, when scrolling is disabled, some browsers consider the body element
+ * to be completely off the screen and propagate events directly to the html element.
+ * @type {!Object} angular.JQLite
+ */
+ ctrl.documentElement = angular.element(document.documentElement);
+
+ // Public Exported Variables with handlers
+ defineProperty('hidden', handleHiddenChange, true);
+
+ // Public Exported Variables
+ ctrl.scope = $scope;
+ ctrl.parent = $scope.$parent;
+ ctrl.itemName = itemParts[0];
+ ctrl.matches = [];
+ ctrl.loading = false;
+ ctrl.hidden = true;
+ ctrl.index = -1;
+ ctrl.activeOption = null;
+ ctrl.id = $mdUtil.nextUid();
+ ctrl.isDisabled = null;
+ ctrl.isRequired = null;
+ ctrl.isReadonly = null;
+ ctrl.hasNotFound = false;
+ ctrl.selectedMessage = $scope.selectedMessage || 'selected';
+ ctrl.noMatchMessage = $scope.noMatchMessage || 'There are no matches available.';
+ ctrl.singleMatchMessage = $scope.singleMatchMessage || 'There is 1 match available.';
+ ctrl.multipleMatchStartMessage = $scope.multipleMatchStartMessage || 'There are ';
+ ctrl.multipleMatchEndMessage = $scope.multipleMatchEndMessage || ' matches available.';
+ ctrl.defaultEscapeOptions = 'clear';
+
+ // Public Exported Methods
+ ctrl.keydown = keydown;
+ ctrl.blur = blur;
+ ctrl.focus = focus;
+ ctrl.clear = clearValue;
+ ctrl.select = select;
+ ctrl.listEnter = onListEnter;
+ ctrl.listLeave = onListLeave;
+ ctrl.focusInput = focusInputElement;
+ ctrl.getCurrentDisplayValue = getCurrentDisplayValue;
+ ctrl.registerSelectedItemWatcher = registerSelectedItemWatcher;
+ ctrl.unregisterSelectedItemWatcher = unregisterSelectedItemWatcher;
+ ctrl.notFoundVisible = notFoundVisible;
+ ctrl.loadingIsVisible = loadingIsVisible;
+ ctrl.positionDropdown = positionDropdown;
+
+ /**
+ * Report types to be used for the $mdLiveAnnouncer
+ * @enum {number} Unique flag id.
+ */
+ var ReportType = {
+ Count: 1,
+ Selected: 2
+ };
+
+ return init();
+
+ // initialization methods
+
+ /**
+ * Initialize the controller, setup watchers, gather elements
+ */
+ function init () {
+
+ $mdUtil.initOptionalProperties($scope, $attrs, {
+ searchText: '',
+ selectedItem: null,
+ clearButton: false,
+ disableVirtualRepeat: false,
+ });
+
+ $mdTheming($element);
+ configureWatchers();
+ $mdUtil.nextTick(function () {
+
+ gatherElements();
+ moveDropdown();
+
+ // Touch devices often do not send a click event on tap. We still want to focus the input
+ // and open the options pop-up in these cases.
+ $element.on('touchstart', focusInputElement);
+
+ // Forward all focus events to the input element when autofocus is enabled
+ if ($scope.autofocus) {
+ $element.on('focus', focusInputElement);
+ }
+ if ($scope.inputAriaDescribedBy) {
+ elements.input.setAttribute('aria-describedby', $scope.inputAriaDescribedBy);
+ }
+ if (!$scope.floatingLabel) {
+ if ($scope.inputAriaLabel) {
+ elements.input.setAttribute('aria-label', $scope.inputAriaLabel);
+ } else if ($scope.inputAriaLabelledBy) {
+ elements.input.setAttribute('aria-labelledby', $scope.inputAriaLabelledBy);
+ } else if ($scope.placeholder) {
+ // If no aria-label or aria-labelledby references are defined, then just label using the
+ // placeholder.
+ elements.input.setAttribute('aria-label', $scope.placeholder);
+ }
+ }
+ });
+ }
+
+ function updateModelValidators() {
+ if (!$scope.requireMatch || !inputModelCtrl) return;
+
+ inputModelCtrl.$setValidity('md-require-match', !!$scope.selectedItem || !$scope.searchText);
+ }
+
+ /**
+ * Calculates the dropdown's position and applies the new styles to the menu element
+ * @returns {*}
+ */
+ function positionDropdown () {
+ if (!elements) {
+ return $mdUtil.nextTick(positionDropdown, false, $scope);
+ }
+
+ var dropdownHeight = ($scope.dropdownItems || MAX_ITEMS) * ITEM_HEIGHT;
+ var hrect = elements.wrap.getBoundingClientRect(),
+ vrect = elements.snap.getBoundingClientRect(),
+ root = elements.root.getBoundingClientRect(),
+ top = vrect.bottom - root.top,
+ bot = root.bottom - vrect.top,
+ left = hrect.left - root.left,
+ width = hrect.width,
+ offset = getVerticalOffset(),
+ position = $scope.dropdownPosition,
+ styles, enoughBottomSpace, enoughTopSpace;
+ var bottomSpace = root.bottom - vrect.bottom - MENU_PADDING + $mdUtil.getViewportTop();
+ var topSpace = vrect.top - MENU_PADDING;
+
+ // Automatically determine dropdown placement based on available space in viewport.
+ if (!position) {
+ enoughTopSpace = topSpace > dropdownHeight;
+ enoughBottomSpace = bottomSpace > dropdownHeight;
+ if (enoughBottomSpace) {
+ position = 'bottom';
+ } else if (enoughTopSpace) {
+ position = 'top';
+ } else {
+ position = topSpace > bottomSpace ? 'top' : 'bottom';
+ }
+ }
+ // Adjust the width to account for the padding provided by `md-input-container`
+ if ($attrs.mdFloatingLabel) {
+ left += INPUT_PADDING;
+ width -= INPUT_PADDING * 2;
+ }
+ styles = {
+ left: left + 'px',
+ minWidth: width + 'px',
+ maxWidth: Math.max(hrect.right - root.left, root.right - hrect.left) - MENU_PADDING + 'px'
+ };
+
+ if (position === 'top') {
+ styles.top = 'auto';
+ styles.bottom = bot + 'px';
+ styles.maxHeight = Math.min(dropdownHeight, topSpace) + 'px';
+ } else {
+ bottomSpace = root.bottom - hrect.bottom - MENU_PADDING + $mdUtil.getViewportTop();
+
+ styles.top = (top - offset) + 'px';
+ styles.bottom = 'auto';
+ styles.maxHeight = Math.min(dropdownHeight, bottomSpace) + 'px';
+ }
+
+ elements.$.scrollContainer.css(styles);
+ $mdUtil.nextTick(correctHorizontalAlignment, false, $scope);
+
+ /**
+ * Calculates the vertical offset for floating label examples to account for ngMessages
+ * @returns {number}
+ */
+ function getVerticalOffset () {
+ var offset = 0;
+ var inputContainer = $element.find('md-input-container');
+ if (inputContainer.length) {
+ var input = inputContainer.find('input');
+ offset = inputContainer.prop('offsetHeight');
+ offset -= input.prop('offsetTop');
+ offset -= input.prop('offsetHeight');
+ // add in the height left up top for the floating label text
+ offset += inputContainer.prop('offsetTop');
+ }
+ return offset;
+ }
+
+ /**
+ * Makes sure that the menu doesn't go off of the screen on either side.
+ */
+ function correctHorizontalAlignment () {
+ var dropdown = elements.scrollContainer.getBoundingClientRect(),
+ styles = {};
+ if (dropdown.right > root.right) {
+ styles.left = (hrect.right - dropdown.width) + 'px';
+ }
+ elements.$.scrollContainer.css(styles);
+ }
+ }
+
+ /**
+ * Moves the dropdown menu to the body tag in order to avoid z-index and overflow issues.
+ */
+ function moveDropdown () {
+ if (!elements.$.root.length) return;
+ $mdTheming(elements.$.scrollContainer);
+ elements.$.scrollContainer.detach();
+ elements.$.root.append(elements.$.scrollContainer);
+ if ($animate.pin) $animate.pin(elements.$.scrollContainer, $rootElement);
+ }
+
+ /**
+ * Sends focus to the input element.
+ */
+ function focusInputElement () {
+ elements.input.focus();
+ }
+
+ /**
+ * Update the activeOption based on the selected item in the listbox.
+ * The activeOption is used in the template to set the aria-activedescendant attribute, which
+ * enables screen readers to properly handle visual focus within the listbox and announce the
+ * item's place in the list. I.e. "List item 3 of 50". Anytime that `ctrl.index` changes, this
+ * function needs to be called to update the activeOption.
+ */
+ function updateActiveOption() {
+ var selectedOption = elements.scroller.querySelector('.selected');
+ if (selectedOption) {
+ ctrl.activeOption = selectedOption.id;
+ } else {
+ ctrl.activeOption = null;
+ }
+ }
+
+ /**
+ * Sets up any watchers used by autocomplete
+ */
+ function configureWatchers () {
+ var wait = parseInt($scope.delay, 10) || 0;
+
+ $attrs.$observe('disabled', function (value) { ctrl.isDisabled = $mdUtil.parseAttributeBoolean(value, false); });
+ $attrs.$observe('required', function (value) { ctrl.isRequired = $mdUtil.parseAttributeBoolean(value, false); });
+ $attrs.$observe('readonly', function (value) { ctrl.isReadonly = $mdUtil.parseAttributeBoolean(value, false); });
+
+ $scope.$watch('searchText', wait ? $mdUtil.debounce(handleSearchText, wait) : handleSearchText);
+ $scope.$watch('selectedItem', selectedItemChange);
+
+ angular.element($window).on('resize', debouncedOnResize);
+
+ $scope.$on('$destroy', cleanup);
+ }
+
+ /**
+ * Removes any events or leftover elements created by this controller
+ */
+ function cleanup () {
+ if (!ctrl.hidden) {
+ $mdUtil.enableScrolling();
+ }
+
+ angular.element($window).off('resize', debouncedOnResize);
+
+ if (elements){
+ var items = ['ul', 'scroller', 'scrollContainer', 'input'];
+ angular.forEach(items, function(key){
+ elements.$[key].remove();
+ });
+ }
+ }
+
+ /**
+ * Event handler to be called whenever the window resizes.
+ */
+ function onWindowResize() {
+ if (!ctrl.hidden) {
+ positionDropdown();
+ }
+ }
+
+ /**
+ * Gathers all of the elements needed for this controller
+ */
+ function gatherElements () {
+
+ var snapWrap = gatherSnapWrap();
+
+ elements = {
+ main: $element[0],
+ scrollContainer: $element[0].querySelector('.md-virtual-repeat-container, .md-standard-list-container'),
+ scroller: $element[0].querySelector('.md-virtual-repeat-scroller, .md-standard-list-scroller'),
+ ul: $element.find('ul')[0],
+ input: $element.find('input')[0],
+ wrap: snapWrap.wrap,
+ snap: snapWrap.snap,
+ root: document.body,
+ };
+
+ elements.li = elements.ul.getElementsByTagName('li');
+ elements.$ = getAngularElements(elements);
+ mode = elements.scrollContainer.classList.contains('md-standard-list-container') ? MODE_STANDARD : MODE_VIRTUAL;
+ inputModelCtrl = elements.$.input.controller('ngModel');
+ }
+
+ /**
+ * Gathers the snap and wrap elements
+ *
+ */
+ function gatherSnapWrap() {
+ var element;
+ var value;
+ for (element = $element; element.length; element = element.parent()) {
+ value = element.attr('md-autocomplete-snap');
+ if (angular.isDefined(value)) break;
+ }
+
+ if (element.length) {
+ return {
+ snap: element[0],
+ wrap: (value.toLowerCase() === 'width') ? element[0] : $element.find('md-autocomplete-wrap')[0]
+ };
+ }
+
+ var wrap = $element.find('md-autocomplete-wrap')[0];
+ return {
+ snap: wrap,
+ wrap: wrap
+ };
+ }
+
+ /**
+ * Gathers angular-wrapped versions of each element
+ * @param elements
+ * @returns {{}}
+ */
+ function getAngularElements (elements) {
+ var obj = {};
+ for (var key in elements) {
+ if (elements.hasOwnProperty(key)) obj[ key ] = angular.element(elements[ key ]);
+ }
+ return obj;
+ }
+
+ // event/change handlers
+
+ /**
+ * @param {Event} $event
+ */
+ function preventDefault($event) {
+ $event.preventDefault();
+ }
+
+ /**
+ * @param {Event} $event
+ */
+ function stopPropagation($event) {
+ $event.stopPropagation();
+ }
+
+ /**
+ * Handles changes to the `hidden` property.
+ * @param {boolean} hidden true to hide the options pop-up, false to show it.
+ * @param {boolean} oldHidden the previous value of hidden
+ */
+ function handleHiddenChange (hidden, oldHidden) {
+ var scrollContainerElement;
+
+ if (elements) {
+ scrollContainerElement = angular.element(elements.scrollContainer);
+ }
+ if (!hidden && oldHidden) {
+ positionDropdown();
+
+ // Report in polite mode, because the screen reader should finish the default description of
+ // the input element.
+ reportMessages(true, ReportType.Count | ReportType.Selected);
+
+ if (elements) {
+ $mdUtil.disableScrollAround(elements.scrollContainer);
+ enableWrapScroll = disableElementScrollEvents(elements.wrap);
+ if ($mdUtil.isIos) {
+ ctrl.documentElement.on('touchend', handleTouchOutsidePanel);
+ if (scrollContainerElement) {
+ scrollContainerElement.on('touchstart touchmove touchend', stopPropagation);
+ }
+ }
+ ctrl.index = getDefaultIndex();
+ $mdUtil.nextTick(function() {
+ updateActiveOption();
+ updateScroll();
+ });
+ }
+ } else if (hidden && !oldHidden) {
+ if ($mdUtil.isIos) {
+ ctrl.documentElement.off('touchend', handleTouchOutsidePanel);
+ if (scrollContainerElement) {
+ scrollContainerElement.off('touchstart touchmove touchend', stopPropagation);
+ }
+ }
+ $mdUtil.enableScrolling();
+
+ if (enableWrapScroll) {
+ enableWrapScroll();
+ enableWrapScroll = null;
+ }
+ }
+ }
+
+ /**
+ * Handling touch events that bubble up to the document is required for closing the dropdown
+ * panel on touch outside of the options pop-up panel on iOS.
+ * @param {Event} $event
+ */
+ function handleTouchOutsidePanel($event) {
+ ctrl.hidden = true;
+ // iOS does not blur the pop-up for touches on the scroll mask, so we have to do it.
+ doBlur(true);
+ }
+
+ /**
+ * Disables scrolling for a specific element.
+ * @param {!string|!DOMElement} element to disable scrolling
+ * @return {Function} function to call to re-enable scrolling for the element
+ */
+ function disableElementScrollEvents(element) {
+ var elementToDisable = angular.element(element);
+ elementToDisable.on('wheel touchmove', preventDefault);
+
+ return function() {
+ elementToDisable.off('wheel touchmove', preventDefault);
+ };
+ }
+
+ /**
+ * When the user mouses over the dropdown menu, ignore blur events.
+ */
+ function onListEnter () {
+ noBlur = true;
+ }
+
+ /**
+ * When the user's mouse leaves the menu, blur events may hide the menu again.
+ */
+ function onListLeave () {
+ if (!hasFocus && !ctrl.hidden) elements.input.focus();
+ noBlur = false;
+ ctrl.hidden = shouldHide();
+ }
+
+ /**
+ * Handles changes to the selected item.
+ * @param selectedItem
+ * @param previousSelectedItem
+ */
+ function selectedItemChange (selectedItem, previousSelectedItem) {
+
+ updateModelValidators();
+
+ if (selectedItem) {
+ getDisplayValue(selectedItem).then(function (val) {
+ $scope.searchText = val;
+ handleSelectedItemChange(selectedItem, previousSelectedItem);
+ });
+ } else if (previousSelectedItem && $scope.searchText) {
+ getDisplayValue(previousSelectedItem).then(function(displayValue) {
+ // Clear the searchText, when the selectedItem is set to null.
+ // Do not clear the searchText, when the searchText isn't matching with the previous
+ // selected item.
+ if (angular.isString($scope.searchText)
+ && displayValue.toString().toLowerCase() === $scope.searchText.toLowerCase()) {
+ $scope.searchText = '';
+ }
+ });
+ }
+
+ if (selectedItem !== previousSelectedItem) {
+ announceItemChange();
+ }
+ }
+
+ /**
+ * Use the user-defined expression to announce changes each time a new item is selected
+ */
+ function announceItemChange () {
+ angular.isFunction($scope.itemChange) &&
+ $scope.itemChange(getItemAsNameVal($scope.selectedItem));
+ }
+
+ /**
+ * Use the user-defined expression to announce changes each time the search text is changed
+ */
+ function announceTextChange () {
+ angular.isFunction($scope.textChange) && $scope.textChange();
+ }
+
+ /**
+ * Calls any external watchers listening for the selected item. Used in conjunction with
+ * `registerSelectedItemWatcher`.
+ * @param selectedItem
+ * @param previousSelectedItem
+ */
+ function handleSelectedItemChange (selectedItem, previousSelectedItem) {
+ selectedItemWatchers.forEach(function (watcher) {
+ watcher(selectedItem, previousSelectedItem);
+ });
+ }
+
+ /**
+ * Register a function to be called when the selected item changes.
+ * @param cb
+ */
+ function registerSelectedItemWatcher (cb) {
+ if (selectedItemWatchers.indexOf(cb) === -1) {
+ selectedItemWatchers.push(cb);
+ }
+ }
+
+ /**
+ * Unregister a function previously registered for selected item changes.
+ * @param cb
+ */
+ function unregisterSelectedItemWatcher (cb) {
+ var i = selectedItemWatchers.indexOf(cb);
+ if (i !== -1) {
+ selectedItemWatchers.splice(i, 1);
+ }
+ }
+
+ /**
+ * Handles changes to the searchText property.
+ * @param {string} searchText
+ * @param {string} previousSearchText
+ */
+ function handleSearchText (searchText, previousSearchText) {
+ ctrl.index = getDefaultIndex();
+
+ // do nothing on init
+ if (searchText === previousSearchText) return;
+
+ updateModelValidators();
+
+ getDisplayValue($scope.selectedItem).then(function (val) {
+ // clear selected item if search text no longer matches it
+ if (searchText !== val) {
+ $scope.selectedItem = null;
+
+ // trigger change event if available
+ if (searchText !== previousSearchText) {
+ announceTextChange();
+ }
+
+ // cancel results if search text is not long enough
+ if (!isMinLengthMet()) {
+ ctrl.matches = [];
+
+ setLoading(false);
+ reportMessages(true, ReportType.Count);
+
+ } else {
+ handleQuery();
+ }
+ }
+ });
+
+ }
+
+ /**
+ * Handles input blur event, determines if the dropdown should hide.
+ * @param {Event=} $event
+ */
+ function blur($event) {
+ hasFocus = false;
+
+ if (!noBlur) {
+ ctrl.hidden = shouldHide();
+ evalAttr('ngBlur', { $event: $event });
+ } else if (angular.isObject($event)) {
+ $event.stopImmediatePropagation();
+ }
+ }
+
+ /**
+ * Force blur on input element
+ * @param {boolean} forceBlur
+ */
+ function doBlur(forceBlur) {
+ if (forceBlur) {
+ noBlur = false;
+ hasFocus = false;
+ }
+ elements.input.blur();
+ }
+
+ /**
+ * Handles input focus event, determines if the dropdown should show.
+ */
+ function focus($event) {
+ hasFocus = true;
+
+ if (isSearchable() && isMinLengthMet()) {
+ handleQuery();
+ }
+
+ ctrl.hidden = shouldHide();
+
+ evalAttr('ngFocus', { $event: $event });
+ }
+
+ /**
+ * Handles keyboard input.
+ * @param event
+ */
+ function keydown (event) {
+ switch (event.keyCode) {
+ case $mdConstant.KEY_CODE.DOWN_ARROW:
+ if (ctrl.loading || hasSelection()) return;
+ event.stopPropagation();
+ event.preventDefault();
+ ctrl.index = ctrl.index + 1 > ctrl.matches.length - 1 ? 0 : Math.min(ctrl.index + 1, ctrl.matches.length - 1);
+ $mdUtil.nextTick(updateActiveOption);
+ updateScroll();
+ break;
+ case $mdConstant.KEY_CODE.UP_ARROW:
+ if (ctrl.loading || hasSelection()) return;
+ event.stopPropagation();
+ event.preventDefault();
+ ctrl.index = ctrl.index - 1 < 0 ? ctrl.matches.length - 1 : Math.max(0, ctrl.index - 1);
+ $mdUtil.nextTick(updateActiveOption);
+ updateScroll();
+ break;
+ case $mdConstant.KEY_CODE.TAB:
+ // If we hit tab, assume that we've left the list so it will close
+ onListLeave();
+
+ if (ctrl.hidden || ctrl.loading || ctrl.index < 0 || ctrl.matches.length < 1) return;
+ select(ctrl.index);
+ break;
+ case $mdConstant.KEY_CODE.ENTER:
+ if (ctrl.hidden || ctrl.loading || ctrl.index < 0 || ctrl.matches.length < 1) return;
+ if (hasSelection()) return;
+ event.stopImmediatePropagation();
+ event.preventDefault();
+ select(ctrl.index);
+ break;
+ case $mdConstant.KEY_CODE.ESCAPE:
+ event.preventDefault(); // Prevent browser from always clearing input
+ if (!shouldProcessEscape()) return;
+ event.stopPropagation();
+
+ clearSelectedItem();
+ if ($scope.searchText && hasEscapeOption('clear')) {
+ clearSearchText();
+ }
+
+ // Manually hide (needed for mdNotFound support)
+ ctrl.hidden = true;
+
+ if (hasEscapeOption('blur')) {
+ // Force the component to blur if they hit escape
+ doBlur(true);
+ }
+
+ break;
+ default:
+ }
+ }
+
+ // getters
+
+ /**
+ * Returns the minimum length needed to display the dropdown.
+ * @returns {*}
+ */
+ function getMinLength () {
+ return angular.isNumber($scope.minLength) ? $scope.minLength : 1;
+ }
+
+ /**
+ * Returns the display value for an item.
+ * @param {*} item
+ * @returns {*}
+ */
+ function getDisplayValue (item) {
+ return $q.when(getItemText(item) || item).then(function(itemText) {
+ if (itemText && !angular.isString(itemText)) {
+ $log.warn('md-autocomplete: Could not resolve display value to a string. ' +
+ 'Please check the `md-item-text` attribute.');
+ }
+
+ return itemText;
+ });
+
+ /**
+ * Getter function to invoke user-defined expression (in the directive)
+ * to convert your object to a single string.
+ * @param {*} item
+ * @returns {string|null}
+ */
+ function getItemText (item) {
+ return (item && $scope.itemText) ? $scope.itemText(getItemAsNameVal(item)) : null;
+ }
+ }
+
+ /**
+ * Returns the locals object for compiling item templates.
+ * @param {*} item
+ * @returns {Object|undefined}
+ */
+ function getItemAsNameVal (item) {
+ if (!item) {
+ return undefined;
+ }
+
+ var locals = {};
+ if (ctrl.itemName) {
+ locals[ ctrl.itemName ] = item;
+ }
+
+ return locals;
+ }
+
+ /**
+ * Returns the default index based on whether or not autoselect is enabled.
+ * @returns {number} 0 if autoselect is enabled, -1 if not.
+ */
+ function getDefaultIndex () {
+ return $scope.autoselect ? 0 : -1;
+ }
+
+ /**
+ * Sets the loading parameter and updates the hidden state.
+ * @param value {boolean} Whether or not the component is currently loading.
+ */
+ function setLoading(value) {
+ if (ctrl.loading !== value) {
+ ctrl.loading = value;
+ }
+
+ // Always refresh the hidden variable as something else might have changed
+ ctrl.hidden = shouldHide();
+ }
+
+ /**
+ * Determines if the menu should be hidden.
+ * @returns {boolean} true if the menu should be hidden
+ */
+ function shouldHide () {
+ return !shouldShow();
+ }
+
+ /**
+ * Determines whether the autocomplete is able to query within the current state.
+ * @returns {boolean} true if the query can be run
+ */
+ function isSearchable() {
+ if (ctrl.loading && !hasMatches()) {
+ // No query when query is in progress.
+ return false;
+ } else if (hasSelection()) {
+ // No query if there is already a selection
+ return false;
+ }
+ else if (!hasFocus) {
+ // No query if the input does not have focus
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * @returns {boolean} if the escape keydown should be processed, return true.
+ * Otherwise return false.
+ */
+ function shouldProcessEscape() {
+ return hasEscapeOption('blur') || !ctrl.hidden || ctrl.loading || hasEscapeOption('clear') && $scope.searchText;
+ }
+
+ /**
+ * @param {string} option check if this option is set
+ * @returns {boolean} if the specified escape option is set, return true. Return false otherwise.
+ */
+ function hasEscapeOption(option) {
+ if (!angular.isString($scope.escapeOptions)) {
+ return ctrl.defaultEscapeOptions.indexOf(option) !== -1;
+ } else {
+ return $scope.escapeOptions.toLowerCase().indexOf(option) !== -1;
+ }
+ }
+
+ /**
+ * Determines if the menu should be shown.
+ * @returns {boolean} true if the menu should be shown
+ */
+ function shouldShow() {
+ if (ctrl.isReadonly) {
+ // Don't show if read only is set
+ return false;
+ } else if (!isSearchable()) {
+ // Don't show if a query is in progress, there is already a selection,
+ // or the input is not focused.
+ return false;
+ }
+ return (isMinLengthMet() && hasMatches()) || notFoundVisible();
+ }
+
+ /**
+ * @returns {boolean} true if the search text has matches.
+ */
+ function hasMatches() {
+ return ctrl.matches.length ? true : false;
+ }
+
+ /**
+ * @returns {boolean} true if the autocomplete has a valid selection.
+ */
+ function hasSelection() {
+ return ctrl.scope.selectedItem ? true : false;
+ }
+
+ /**
+ * @returns {boolean} true if the loading indicator is, or should be, visible.
+ */
+ function loadingIsVisible() {
+ return ctrl.loading && !hasSelection();
+ }
+
+ /**
+ * @returns {*} the display value of the current item.
+ */
+ function getCurrentDisplayValue () {
+ return getDisplayValue(ctrl.matches[ ctrl.index ]);
+ }
+
+ /**
+ * Determines if the minimum length is met by the search text.
+ * @returns {*} true if the minimum length is met by the search text
+ */
+ function isMinLengthMet () {
+ return ($scope.searchText || '').length >= getMinLength();
+ }
+
+ // actions
+
+ /**
+ * Defines a public property with a handler and a default value.
+ * @param {string} key
+ * @param {Function} handler function
+ * @param {*} defaultValue default value
+ */
+ function defineProperty (key, handler, defaultValue) {
+ Object.defineProperty(ctrl, key, {
+ get: function () { return defaultValue; },
+ set: function (newValue) {
+ var oldValue = defaultValue;
+ defaultValue = newValue;
+ handler(newValue, oldValue);
+ }
+ });
+ }
+
+ /**
+ * Selects the item at the given index.
+ * @param {number} index to select
+ */
+ function select (index) {
+ // force form to update state for validation
+ $mdUtil.nextTick(function () {
+ getDisplayValue(ctrl.matches[ index ]).then(function (val) {
+ var ngModel = elements.$.input.controller('ngModel');
+ $mdLiveAnnouncer.announce(val + ' ' + ctrl.selectedMessage, 'assertive');
+ ngModel.$setViewValue(val);
+ ngModel.$render();
+ }).finally(function () {
+ $scope.selectedItem = ctrl.matches[ index ];
+ setLoading(false);
+ });
+ }, false);
+ }
+
+ /**
+ * Clears the searchText value and selected item.
+ * @param {Event} $event
+ */
+ function clearValue ($event) {
+ if ($event) {
+ $event.stopPropagation();
+ }
+ clearSelectedItem();
+ clearSearchText();
+ }
+
+ /**
+ * Clears the selected item
+ */
+ function clearSelectedItem () {
+ // Reset our variables
+ ctrl.index = -1;
+ $mdUtil.nextTick(updateActiveOption);
+ ctrl.matches = [];
+ }
+
+ /**
+ * Clears the searchText value
+ */
+ function clearSearchText () {
+ // Set the loading to true so we don't see flashes of content.
+ // The flashing will only occur when an async request is running.
+ // So the loading process will stop when the results had been retrieved.
+ setLoading(true);
+
+ $scope.searchText = '';
+
+ // Normally, triggering the change / input event is unnecessary, because the browser detects it properly.
+ // But some browsers are not detecting it properly, which means that we have to trigger the event.
+ // Using the `input` is not working properly, because for example IE11 is not supporting the `input` event.
+ // The `change` event is a good alternative and is supported by all supported browsers.
+ var eventObj = document.createEvent('CustomEvent');
+ eventObj.initCustomEvent('change', true, true, { value: '' });
+ elements.input.dispatchEvent(eventObj);
+
+ // For some reason, firing the above event resets the value of $scope.searchText if
+ // $scope.searchText has a space character at the end, so we blank it one more time and then
+ // focus.
+ elements.input.blur();
+ $scope.searchText = '';
+ elements.input.focus();
+ }
+
+ /**
+ * Fetches the results for the provided search text.
+ * @param searchText
+ */
+ function fetchResults (searchText) {
+ var items = $scope.$parent.$eval(itemExpr),
+ term = searchText.toLowerCase(),
+ isList = angular.isArray(items),
+ isPromise = !!items.then; // Every promise should contain a `then` property
+
+ if (isList) onResultsRetrieved(items);
+ else if (isPromise) handleAsyncResults(items);
+
+ function handleAsyncResults(items) {
+ if (!items) return;
+
+ items = $q.when(items);
+ fetchesInProgress++;
+ setLoading(true);
+
+ $mdUtil.nextTick(function () {
+ items
+ .then(onResultsRetrieved)
+ .finally(function(){
+ if (--fetchesInProgress === 0) {
+ setLoading(false);
+ }
+ });
+ },true, $scope);
+ }
+
+ function onResultsRetrieved(matches) {
+ cache[term] = matches;
+
+ // Just cache the results if the request is now outdated.
+ // The request becomes outdated, when the new searchText has changed during the result fetching.
+ if ((searchText || '') !== ($scope.searchText || '')) {
+ return;
+ }
+
+ handleResults(matches);
+ }
+ }
+
+
+ /**
+ * Reports given message types to supported screen readers.
+ * @param {boolean} isPolite Whether the announcement should be polite.
+ * @param {!number} types Message flags to be reported to the screen reader.
+ */
+ function reportMessages(isPolite, types) {
+ var politeness = isPolite ? 'polite' : 'assertive';
+ var messages = [];
+
+ if (types & ReportType.Selected && ctrl.index !== -1) {
+ messages.push(getCurrentDisplayValue());
+ }
+
+ if (types & ReportType.Count) {
+ messages.push($q.resolve(getCountMessage()));
+ }
+
+ $q.all(messages).then(function(data) {
+ $mdLiveAnnouncer.announce(data.join(' '), politeness);
+ });
+ }
+
+ /**
+ * @returns {string} the ARIA message for how many results match the current query.
+ */
+ function getCountMessage () {
+ switch (ctrl.matches.length) {
+ case 0:
+ return ctrl.noMatchMessage;
+ case 1:
+ return ctrl.singleMatchMessage;
+ default:
+ return ctrl.multipleMatchStartMessage + ctrl.matches.length + ctrl.multipleMatchEndMessage;
+ }
+ }
+
+ /**
+ * Makes sure that the focused element is within view.
+ */
+ function updateScroll () {
+ if (!elements.li[0]) return;
+ if (mode === MODE_STANDARD) {
+ updateStandardScroll();
+ } else {
+ updateVirtualScroll();
+ }
+ }
+
+ function updateVirtualScroll() {
+ // elements in virtual scroll have consistent heights
+ var optionHeight = elements.li[0].offsetHeight,
+ top = optionHeight * Math.max(0, ctrl.index),
+ bottom = top + optionHeight,
+ containerHeight = elements.scroller.clientHeight,
+ scrollTop = elements.scroller.scrollTop;
+
+ if (top < scrollTop) {
+ scrollTo(top);
+ } else if (bottom > scrollTop + containerHeight) {
+ scrollTo(bottom - containerHeight);
+ }
+ }
+
+ function updateStandardScroll() {
+ // elements in standard scroll have variable heights
+ var selected = elements.li[Math.max(0, ctrl.index)];
+ var containerHeight = elements.scrollContainer.offsetHeight,
+ top = selected && selected.offsetTop || 0,
+ bottom = top + selected.clientHeight,
+ scrollTop = elements.scrollContainer.scrollTop;
+
+ if (top < scrollTop) {
+ scrollTo(top);
+ } else if (bottom > scrollTop + containerHeight) {
+ scrollTo(bottom - containerHeight);
+ }
+ }
+
+ function isPromiseFetching() {
+ return fetchesInProgress !== 0;
+ }
+
+ function scrollTo (offset) {
+ if (mode === MODE_STANDARD) {
+ elements.scrollContainer.scrollTop = offset;
+ } else {
+ elements.$.scrollContainer.controller('mdVirtualRepeatContainer').scrollTo(offset);
+ }
+ }
+
+ function notFoundVisible () {
+ var textLength = (ctrl.scope.searchText || '').length;
+
+ return ctrl.hasNotFound && !hasMatches() && (!ctrl.loading || isPromiseFetching()) && textLength >= getMinLength() && (hasFocus || noBlur) && !hasSelection();
+ }
+
+ /**
+ * Starts the query to gather the results for the current searchText. Attempts to return cached
+ * results first, then forwards the process to `fetchResults` if necessary.
+ */
+ function handleQuery () {
+ var searchText = $scope.searchText || '';
+ var term = searchText.toLowerCase();
+
+ // If caching is enabled and the current searchText is stored in the cache
+ if (!$scope.noCache && cache[term]) {
+ // The results should be handled as same as a normal un-cached request does.
+ handleResults(cache[term]);
+ } else {
+ fetchResults(searchText);
+ }
+
+ ctrl.hidden = shouldHide();
+ }
+
+ /**
+ * Handles the retrieved results by showing them in the autocompletes dropdown.
+ * @param results Retrieved results
+ */
+ function handleResults(results) {
+ ctrl.matches = results;
+ ctrl.hidden = shouldHide();
+
+ // If loading is in progress, then we'll end the progress. This is needed for example,
+ // when the `clear` button was clicked, because there we always show the loading process, to prevent flashing.
+ if (ctrl.loading) setLoading(false);
+
+ if ($scope.selectOnMatch) selectItemOnMatch();
+
+ positionDropdown();
+ reportMessages(true, ReportType.Count);
+ }
+
+ /**
+ * If there is only one matching item and the search text matches its display value exactly,
+ * automatically select that item. Note: This function is only called if the user uses the
+ * `md-select-on-match` flag.
+ */
+ function selectItemOnMatch () {
+ var searchText = $scope.searchText,
+ matches = ctrl.matches,
+ item = matches[ 0 ];
+ if (matches.length === 1) getDisplayValue(item).then(function (displayValue) {
+ var isMatching = searchText === displayValue;
+ if ($scope.matchInsensitive && !isMatching) {
+ isMatching = searchText.toLowerCase() === displayValue.toLowerCase();
+ }
+
+ if (isMatching) {
+ select(0);
+ }
+ });
+ }
+
+ /**
+ * Evaluates an attribute expression against the parent scope.
+ * @param {String} attr Name of the attribute to be evaluated.
+ * @param {Object?} locals Properties to be injected into the evaluation context.
+ */
+ function evalAttr(attr, locals) {
+ if ($attrs[attr]) {
+ $scope.$parent.$eval($attrs[attr], locals || {});
+ }
+ }
+
+}
+
+})();
+(function(){
+"use strict";
+
+
+MdAutocomplete.$inject = ["$$mdSvgRegistry"];angular
+ .module('material.components.autocomplete')
+ .directive('mdAutocomplete', MdAutocomplete);
+
+/**
+ * @ngdoc directive
+ * @name mdAutocomplete
+ * @module material.components.autocomplete
+ *
+ * @description
+ * `<md-autocomplete>` is a special input component with a drop-down of all possible matches to a
+ * custom query. This component allows you to provide real-time suggestions as the user types
+ * in the input area.
+ *
+ * To start, you will need to specify the required parameters and provide a template for your
+ * results. The content inside `md-autocomplete` will be treated as a template.
+ *
+ * In more complex cases, you may want to include other content such as a message to display when
+ * no matches were found. You can do this by wrapping your template in `md-item-template` and
+ * adding a tag for `md-not-found`. An example of this is shown below.
+ *
+ * To reset the displayed value you must clear both values for `md-search-text` and
+ * `md-selected-item`.
+ *
+ * ### Validation
+ *
+ * You can use `ng-messages` to include validation the same way that you would normally validate;
+ * however, if you want to replicate a standard input with a floating label, you will have to
+ * do the following:
+ *
+ * - Make sure that your template is wrapped in `md-item-template`
+ * - Add your `ng-messages` code inside of `md-autocomplete`
+ * - Add your validation properties to `md-autocomplete` (ie. `required`)
+ * - Add a `name` to `md-autocomplete` (to be used on the generated `input`)
+ *
+ * There is an example below of how this should look.
+ *
+ * ### Snapping Drop-Down
+ *
+ * You can cause the autocomplete drop-down to snap to an ancestor element by applying the
+ * `md-autocomplete-snap` attribute to that element. You can also snap to the width of
+ * the `md-autocomplete-snap` element by setting the attribute's value to `width`
+ * (ie. `md-autocomplete-snap="width"`).
+ *
+ * ### Notes
+ *
+ * **Autocomplete Dropdown Items Rendering**
+ *
+ * The `md-autocomplete` uses the the <a ng-href="api/directive/mdVirtualRepeat">
+ * mdVirtualRepeat</a> directive for displaying the results inside of the dropdown.<br/>
+ *
+ * > When encountering issues regarding the item template please take a look at the
+ * <a ng-href="api/directive/mdVirtualRepeatContainer">VirtualRepeatContainer</a> documentation.
+ *
+ * **Autocomplete inside of a Virtual Repeat**
+ *
+ * When using the `md-autocomplete` directive inside of a
+ * <a ng-href="api/directive/mdVirtualRepeatContainer">VirtualRepeatContainer</a> the dropdown items
+ * might not update properly, because caching of the results is enabled by default.
+ *
+ * The autocomplete will then show invalid dropdown items, because the Virtual Repeat only updates
+ * the scope bindings rather than re-creating the `md-autocomplete`. This means that the previous
+ * cached results will be used.
+ *
+ * > To avoid such problems, ensure that the autocomplete does not cache any results via
+ * `md-no-cache="true"`:
+ *
+ * <hljs lang="html">
+ * <md-autocomplete
+ * md-no-cache="true"
+ * md-selected-item="selectedItem"
+ * md-items="item in items"
+ * md-search-text="searchText"
+ * md-item-text="item.display">
+ * <span>{{ item.display }}</span>
+ * </md-autocomplete>
+ * </hljs>
+ *
+ *
+ * @param {expression} md-items An expression in the format of `item in results` to iterate over
+ * matches for your search.<br/><br/>
+ * The `results` expression can be also a function, which returns the results synchronously
+ * or asynchronously (per Promise).
+ * @param {expression=} md-selected-item-change An expression to be run each time a new item is
+ * selected.
+ * @param {expression=} md-search-text-change An expression to be run each time the search text
+ * updates.
+ * @param {expression=} md-search-text A model to bind the search query text to.
+ * @param {object=} md-selected-item A model to bind the selected item to.
+ * @param {expression=} md-item-text An expression that will convert your object to a single string.
+ * @param {string=} placeholder Placeholder text that will be forwarded to the input.
+ * @param {boolean=} md-no-cache Disables the internal caching that happens in autocomplete.
+ * @param {boolean=} ng-disabled Determines whether or not to disable the input field.
+ * @param {boolean=} md-require-match When set to true, the autocomplete will add a validator,
+ * which will evaluate to false, when no item is currently selected.
+ * @param {number=} md-min-length Specifies the minimum length of text before autocomplete will
+ * make suggestions.
+ * @param {number=} md-delay Specifies the amount of time (in milliseconds) to wait before looking
+ * for results.
+ * @param {boolean=} md-clear-button Whether the clear button for the autocomplete input should show
+ * up or not. When `md-floating-label` is set, defaults to false, defaults to true otherwise.
+ * @param {boolean=} md-autofocus If true, the autocomplete will be automatically focused when a
+ * `$mdDialog`, `$mdBottomsheet` or `$mdSidenav`, which contains the autocomplete, is opening.
+ * <br/><br/>
+ * Also the autocomplete will immediately focus the input element.
+ * @param {boolean=} md-no-asterisk When present, asterisk will not be appended to the floating
+ * label.
+ * @param {boolean=} md-autoselect If set to true, the first item will be automatically selected
+ * in the dropdown upon open.
+ * @param {string=} md-input-name The name attribute given to the input element to be used with
+ * FormController.
+ * @param {string=} md-menu-class This class will be applied to the dropdown menu for styling.
+ * @param {string=} md-menu-container-class This class will be applied to the parent container
+ * of the dropdown panel.
+ * @param {string=} md-input-class This will be applied to the input for styling. This attribute
+ * is only valid when a `md-floating-label` is defined.
+ * @param {string=} md-floating-label This will add a floating label to autocomplete and wrap it in
+ * `md-input-container`.
+ * @param {string=} md-select-on-focus When present the input's text will be automatically selected
+ * on focus.
+ * @param {string=} md-input-id An ID to be added to the input element.
+ * @param {number=} md-input-minlength The minimum length for the input's value for validation.
+ * @param {number=} md-input-maxlength The maximum length for the input's value for validation.
+ * @param {boolean=} md-select-on-match When set, autocomplete will automatically select
+ * the item if the search text is an exact match. <br/><br/>
+ * An exact match is when only one match is displayed.
+ * @param {boolean=} md-match-case-insensitive When set and using `md-select-on-match`, autocomplete
+ * will select on case-insensitive match.
+ * @param {string=} md-escape-options Override escape key logic. Default is `clear`.<br/>
+ * Options: `blur`, `clear`, `none`.
+ * @param {string=} md-dropdown-items Specifies the maximum amount of items to be shown in
+ * the dropdown.<br/><br/>
+ * When the dropdown doesn't fit into the viewport, the dropdown will shrink
+ * as much as possible.
+ * @param {string=} md-dropdown-position Overrides the default dropdown position. Options: `top`,
+ * `bottom`.
+ * @param {string=} input-aria-describedby A space-separated list of element IDs. This should
+ * contain the IDs of any elements that describe this autocomplete. Screen readers will read the
+ * content of these elements at the end of announcing that the autocomplete has been selected
+ * and describing its current state. The descriptive elements do not need to be visible on the
+ * page.
+ * @param {string=} input-aria-labelledby A space-separated list of element IDs. The ideal use case
+ * is that this would contain the ID of a `<label>` element that is associated with this
+ * autocomplete. This will only have affect when `md-floating-label` is not defined.<br><br>
+ * For `<label id="state">US State</label>`, you would set this to
+ * `input-aria-labelledby="state"`.
+ * @param {string=} input-aria-label A label that will be applied to the autocomplete's input.
+ * This will be announced by screen readers before the placeholder.
+ * This will only have affect when `md-floating-label` is not defined. If you define both
+ * `input-aria-label` and `input-aria-labelledby`, then `input-aria-label` will take precedence.
+ * @param {string=} md-selected-message Attribute to specify the text that the screen reader will
+ * announce after a value is selected. Default is: "selected". If `Alaska` is selected in the
+ * options panel, it will read "Alaska selected". You will want to override this when your app
+ * runs in a non-English locale.
+ * @param {string=} md-no-match-message Attribute to specify the text that the screen reader will
+ * announce after a query returns no matching results.
+ * Default is: "There are no matches available.". You will want to override this when your app
+ * runs in a non-English locale.
+ * @param {string=} md-single-match-message Attribute to specify the text that the screen reader
+ * will announce after a query returns a single matching result.
+ * Default is: "There is 1 match available.". You will want to override this when your app
+ * runs in a non-English locale.
+ * @param {string=} md-multiple-match-start-message Attribute to specify the text that the screen
+ * reader will announce after a query returns multiple matching results. The number of matching
+ * results will be read after this text. Default is: "There are ". You will want to override this
+ * when your app runs in a non-English locale.
+ * @param {string=} md-multiple-match-end-message Attribute to specify the text that the screen
+ * reader will announce after a query returns multiple matching results. The number of matching
+ * results will be read before this text. Default is: " matches available.". You will want to
+ * override this when your app runs in a non-English locale.
+ * @param {boolean=} ng-trim If set to false, the search text will be not trimmed automatically.
+ * Defaults to true.
+ * @param {string=} ng-pattern Adds the pattern validator to the ngModel of the search text.
+ * See the [ngPattern Directive](https://docs.angularjs.org/api/ng/directive/ngPattern)
+ * for more details.
+ * @param {string=} md-mode Specify the repeat mode for suggestion lists. Acceptable values include
+ * `virtual` (md-virtual-repeat) and `standard` (ng-repeat). See the
+ * `Specifying Repeat Mode` example for mode details. Default is `virtual`.
+ *
+ * @usage
+ * ### Basic Example
+ * <hljs lang="html">
+ * <md-autocomplete
+ * md-selected-item="selectedItem"
+ * md-search-text="searchText"
+ * md-items="item in getMatches(searchText)"
+ * md-item-text="item.display">
+ * <span md-highlight-text="searchText">{{item.display}}</span>
+ * </md-autocomplete>
+ * </hljs>
+ *
+ * ### Example with "not found" message
+ * <hljs lang="html">
+ * <md-autocomplete
+ * md-selected-item="selectedItem"
+ * md-search-text="searchText"
+ * md-items="item in getMatches(searchText)"
+ * md-item-text="item.display">
+ * <md-item-template>
+ * <span md-highlight-text="searchText">{{item.display}}</span>
+ * </md-item-template>
+ * <md-not-found>
+ * No matches found.
+ * </md-not-found>
+ * </md-autocomplete>
+ * </hljs>
+ *
+ * In this example, our code utilizes `md-item-template` and `md-not-found` to specify the
+ * different parts that make up our component.
+ *
+ * ### Clear button for the input
+ * By default, the clear button is displayed when there is input. This aligns with the spec's
+ * [Search Pattern](https://material.io/archive/guidelines/patterns/search.html#search-in-app-search).
+ * In floating label mode, when `md-floating-label="My Label"` is applied, the clear button is not
+ * displayed by default (see the spec's
+ * [Autocomplete Text Field](https://material.io/archive/guidelines/components/text-fields.html#text-fields-layout)).
+ *
+ * Nevertheless, developers are able to explicitly toggle the clear button for all autocomplete
+ * components with `md-clear-button`.
+ *
+ * <hljs lang="html">
+ * <md-autocomplete ... md-clear-button="true"></md-autocomplete>
+ * <md-autocomplete ... md-clear-button="false"></md-autocomplete>
+ * </hljs>
+ *
+ * In previous versions, the clear button was always hidden when the component was disabled.
+ * This changed in `1.1.5` to give the developer control of this behavior. This example
+ * will hide the clear button only when the component is disabled.
+ *
+ * <hljs lang="html">
+ * <md-autocomplete ... ng-disabled="disabled" md-clear-button="!disabled"></md-autocomplete>
+ * </hljs>
+ *
+ * ### Example with validation
+ * <hljs lang="html">
+ * <form name="autocompleteForm">
+ * <md-autocomplete
+ * required
+ * md-input-name="autocomplete"
+ * md-selected-item="selectedItem"
+ * md-search-text="searchText"
+ * md-items="item in getMatches(searchText)"
+ * md-item-text="item.display">
+ * <md-item-template>
+ * <span md-highlight-text="searchText">{{item.display}}</span>
+ * </md-item-template>
+ * <div ng-messages="autocompleteForm.autocomplete.$error">
+ * <div ng-message="required">This field is required</div>
+ * </div>
+ * </md-autocomplete>
+ * </form>
+ * </hljs>
+ *
+ * In this example, our code utilizes `md-item-template` and `ng-messages` to specify
+ * input validation for the field.
+ *
+ * ### Asynchronous Results
+ * The autocomplete items expression also supports promises, which will resolve with the query
+ * results.
+ *
+ * <hljs lang="js">
+ * function AppController($scope, $http) {
+ * $scope.query = function(searchText) {
+ * return $http
+ * .get(BACKEND_URL + '/items/' + searchText)
+ * .then(function(data) {
+ * // Map the response object to the data object.
+ * return data;
+ * });
+ * };
+ * }
+ * </hljs>
+ *
+ * <hljs lang="html">
+ * <md-autocomplete
+ * md-selected-item="selectedItem"
+ * md-search-text="searchText"
+ * md-items="item in query(searchText)">
+ * <md-item-template>
+ * <span md-highlight-text="searchText">{{item}}</span>
+ * </md-item-template>
+ * </md-autocomplete>
+ * </hljs>
+ *
+ * ### Specifying Repeat Mode
+ * You can use `md-mode` to specify whether to use standard or virtual lists for
+ * rendering autocomplete options.
+ * The `md-mode` accepts two values:
+ * - `virtual` (default) Uses `md-virtual-repeat` to render list items. Virtual
+ * mode requires you to have consistent heights for all suggestions.
+ * - `standard` uses `ng-repeat` to render list items. This allows you to have
+ * options of varying heights.
+ *
+ * Note that using 'standard' mode will require you to address any list
+ * performance issues (e.g. pagination) separately within your application.
+ *
+ * <hljs lang="html">
+ * <md-autocomplete
+ * md-selected-item="selectedItem"
+ * md-search-text="searchText"
+ * md-items="item in getMatches(searchText)"
+ * md-item-text="item.display"
+ * md-mode="standard">
+ * <span md-highlight-text="searchText">{{item.display}}</span>
+ * </md-autocomplete>
+ * </hljs>
+ */
+function MdAutocomplete ($$mdSvgRegistry) {
+ var REPEAT_STANDARD = 'standard';
+ var REPEAT_VIRTUAL = 'virtual';
+ var REPEAT_MODES = [REPEAT_STANDARD, REPEAT_VIRTUAL];
+
+ /** get a valid repeat mode from an md-mode attribute string. */
+ function getRepeatMode(modeStr) {
+ if (!modeStr) { return REPEAT_VIRTUAL; }
+ modeStr = modeStr.toLowerCase();
+ return REPEAT_MODES.indexOf(modeStr) > -1 ? modeStr : REPEAT_VIRTUAL;
+ }
+
+ return {
+ controller: 'MdAutocompleteCtrl',
+ controllerAs: '$mdAutocompleteCtrl',
+ scope: {
+ inputName: '@mdInputName',
+ inputMinlength: '@mdInputMinlength',
+ inputMaxlength: '@mdInputMaxlength',
+ searchText: '=?mdSearchText',
+ selectedItem: '=?mdSelectedItem',
+ itemsExpr: '@mdItems',
+ itemText: '&mdItemText',
+ placeholder: '@placeholder',
+ inputAriaDescribedBy: '@?inputAriaDescribedby',
+ inputAriaLabelledBy: '@?inputAriaLabelledby',
+ inputAriaLabel: '@?inputAriaLabel',
+ noCache: '=?mdNoCache',
+ requireMatch: '=?mdRequireMatch',
+ selectOnMatch: '=?mdSelectOnMatch',
+ matchInsensitive: '=?mdMatchCaseInsensitive',
+ itemChange: '&?mdSelectedItemChange',
+ textChange: '&?mdSearchTextChange',
+ minLength: '=?mdMinLength',
+ delay: '=?mdDelay',
+ autofocus: '=?mdAutofocus',
+ floatingLabel: '@?mdFloatingLabel',
+ autoselect: '=?mdAutoselect',
+ menuClass: '@?mdMenuClass',
+ menuContainerClass: '@?mdMenuContainerClass',
+ inputClass: '@?mdInputClass',
+ inputId: '@?mdInputId',
+ escapeOptions: '@?mdEscapeOptions',
+ dropdownItems: '=?mdDropdownItems',
+ dropdownPosition: '@?mdDropdownPosition',
+ clearButton: '=?mdClearButton',
+ selectedMessage: '@?mdSelectedMessage',
+ noMatchMessage: '@?mdNoMatchMessage',
+ singleMatchMessage: '@?mdSingleMatchMessage',
+ multipleMatchStartMessage: '@?mdMultipleMatchStartMessage',
+ multipleMatchEndMessage: '@?mdMultipleMatchEndMessage',
+ mdMode: '=?mdMode'
+ },
+ compile: function(tElement, tAttrs) {
+ var attributes = ['md-select-on-focus', 'md-no-asterisk', 'ng-trim', 'ng-pattern'];
+ var input = tElement.find('input');
+
+ attributes.forEach(function(attribute) {
+ var attrValue = tAttrs[tAttrs.$normalize(attribute)];
+
+ if (attrValue !== null) {
+ input.attr(attribute, attrValue);
+ }
+ });
+
+ return function(scope, element, attrs, ctrl) {
+ // Retrieve the state of using a md-not-found template by using our attribute, which will
+ // be added to the element in the template function.
+ ctrl.hasNotFound = !!element.attr('md-has-not-found');
+
+ // By default the inset autocomplete should show the clear button when not explicitly
+ // overwritten or in floating label mode.
+ if (!angular.isDefined(attrs.mdClearButton) && !scope.floatingLabel) {
+ scope.clearButton = true;
+ }
+
+ scope.mdMode = getRepeatMode(attrs.mdMode);
+
+ // Stop click events from bubbling up to the document and triggering a flicker of the
+ // options panel while still supporting ng-click to be placed on md-autocomplete.
+ element.on('click touchstart touchend', function(event) {
+ event.stopPropagation();
+ });
+ };
+ },
+ template: function (element, attr) {
+ var noItemsTemplate = getNoItemsTemplate(),
+ itemTemplate = getItemTemplate(),
+ leftover = element.html(),
+ tabindex = attr.tabindex;
+
+ // Set our attribute for the link function above which runs later.
+ // We will set an attribute, because otherwise the stored variables will be trashed when
+ // removing the element is hidden while retrieving the template. For example when using ngIf.
+ if (noItemsTemplate) element.attr('md-has-not-found', true);
+
+ // Always set our tabindex of the autocomplete directive to -1, because our input
+ // will hold the actual tabindex.
+ element.attr('tabindex', '-1');
+
+ return '\
+ <md-autocomplete-wrap\
+ ng-class="{ \'md-whiteframe-z1\': !floatingLabel, \
+ \'md-menu-showing\': !$mdAutocompleteCtrl.hidden, \
+ \'md-show-clear-button\': !!clearButton }">\
+ ' + getInputElement() + '\
+ ' + getClearButton() + '\
+ <md-progress-linear\
+ class="' + (attr.mdFloatingLabel ? 'md-inline' : '') + '"\
+ ng-if="$mdAutocompleteCtrl.loadingIsVisible()"\
+ md-mode="indeterminate"></md-progress-linear>\
+ ' + getContainer(attr.mdMenuContainerClass, attr.mdMode) + '\
+ <ul class="md-autocomplete-suggestions"\
+ ng-class="::menuClass"\
+ id="ul-{{$mdAutocompleteCtrl.id}}"\
+ ng-mouseup="$mdAutocompleteCtrl.focusInput()"\
+ role="listbox">\
+ <li class="md-autocomplete-suggestion" ' + getRepeatType(attr.mdMode) + ' ="item in $mdAutocompleteCtrl.matches"\
+ ng-class="{ selected: $index === $mdAutocompleteCtrl.index }"\
+ ng-attr-id="{{\'md-option-\' + $mdAutocompleteCtrl.id + \'-\' + $index}}"\
+ ng-click="$mdAutocompleteCtrl.select($index)"\
+ role="option"\
+ aria-setsize="{{$mdAutocompleteCtrl.matches.length}}"\
+ aria-posinset="{{$index+1}}"\
+ aria-selected="{{$index === $mdAutocompleteCtrl.index ? true : false}}" \
+ md-extra-name="$mdAutocompleteCtrl.itemName">\
+ ' + itemTemplate + '\
+ </li>' + noItemsTemplate + '\
+ </ul>\
+ ' + getContainerClosingTags(attr.mdMode) + '\
+ </md-autocomplete-wrap>';
+
+ function getItemTemplate() {
+ var templateTag = element.find('md-item-template').detach(),
+ html = templateTag.length ? templateTag.html() : element.html();
+ if (!templateTag.length) element.empty();
+ return '<md-autocomplete-parent-scope md-autocomplete-replace>' + html +
+ '</md-autocomplete-parent-scope>';
+ }
+
+ function getNoItemsTemplate() {
+ var templateTag = element.find('md-not-found').detach(),
+ template = templateTag.length ? templateTag.html() : '';
+ return template
+ ? '<li ng-if="$mdAutocompleteCtrl.notFoundVisible()" class="md-autocomplete-suggestion"\
+ md-autocomplete-parent-scope>' + template + '</li>'
+ : '';
+ }
+
+ function getContainer(menuContainerClass, repeatMode) {
+ // prepend a space if needed
+ menuContainerClass = menuContainerClass ? ' ' + menuContainerClass : '';
+
+ if (isVirtualRepeatDisabled(repeatMode)) {
+ return '\
+ <div \
+ ng-hide="$mdAutocompleteCtrl.hidden"\
+ class="md-standard-list-container md-autocomplete-suggestions-container md-whiteframe-z1' + menuContainerClass + '"\
+ ng-class="{ \'md-not-found\': $mdAutocompleteCtrl.notFoundVisible() }"\
+ ng-mouseenter="$mdAutocompleteCtrl.listEnter()"\
+ ng-mouseleave="$mdAutocompleteCtrl.listLeave()"\
+ role="presentation">\
+ <div class="md-standard-list-scroller" role="presentation">';
+ }
+
+ return '\
+ <md-virtual-repeat-container\
+ md-auto-shrink\
+ md-auto-shrink-min="1"\
+ ng-hide="$mdAutocompleteCtrl.hidden"\
+ class="md-virtual-repeat-container md-autocomplete-suggestions-container md-whiteframe-z1' + menuContainerClass + '"\
+ ng-class="{ \'md-not-found\': $mdAutocompleteCtrl.notFoundVisible() }"\
+ ng-mouseenter="$mdAutocompleteCtrl.listEnter()"\
+ ng-mouseleave="$mdAutocompleteCtrl.listLeave()"\
+ role="presentation">';
+ }
+
+ function getContainerClosingTags(repeatMode) {
+ return isVirtualRepeatDisabled(repeatMode) ?
+ ' </div>\
+ </div>\
+ </div>' : '</md-virtual-repeat-container>';
+ }
+
+ function getRepeatType(repeatMode) {
+ return isVirtualRepeatDisabled(repeatMode) ?
+ 'ng-repeat' : 'md-virtual-repeat';
+ }
+
+ function isVirtualRepeatDisabled(repeatMode) {
+ // ensure we have a valid repeat mode
+ var correctedRepeatMode = getRepeatMode(repeatMode);
+ return correctedRepeatMode !== REPEAT_VIRTUAL;
+ }
+
+ function getInputElement () {
+ if (attr.mdFloatingLabel) {
+ return '\
+ <md-input-container ng-if="floatingLabel">\
+ <label>{{floatingLabel}}</label>\
+ <input type="text"\
+ ' + (tabindex != null ? 'tabindex="' + tabindex + '"' : '') + '\
+ id="{{inputId || \'fl-input-\' + $mdAutocompleteCtrl.id}}"\
+ name="{{inputName || \'fl-input-\' + $mdAutocompleteCtrl.id }}"\
+ ng-class="::inputClass"\
+ autocomplete="off"\
+ ng-required="$mdAutocompleteCtrl.isRequired"\
+ ng-readonly="$mdAutocompleteCtrl.isReadonly"\
+ ng-minlength="inputMinlength"\
+ ng-maxlength="inputMaxlength"\
+ ng-disabled="$mdAutocompleteCtrl.isDisabled"\
+ ng-model="$mdAutocompleteCtrl.scope.searchText"\
+ ng-model-options="{ allowInvalid: true }"\
+ ng-mousedown="$mdAutocompleteCtrl.focusInput()"\
+ ng-keydown="$mdAutocompleteCtrl.keydown($event)"\
+ ng-blur="$mdAutocompleteCtrl.blur($event)"\
+ ng-focus="$mdAutocompleteCtrl.focus($event)"\
+ aria-label="{{floatingLabel}}"\
+ ng-attr-aria-autocomplete="{{$mdAutocompleteCtrl.isDisabled ? undefined : \'list\'}}"\
+ ng-attr-role="{{$mdAutocompleteCtrl.isDisabled ? undefined : \'combobox\'}}"\
+ aria-haspopup="{{!$mdAutocompleteCtrl.isDisabled}}"\
+ aria-expanded="{{!$mdAutocompleteCtrl.hidden}}"\
+ ng-attr-aria-owns="{{$mdAutocompleteCtrl.hidden || $mdAutocompleteCtrl.isDisabled ? undefined : \'ul-\' + $mdAutocompleteCtrl.id}}"\
+ ng-attr-aria-activedescendant="{{!$mdAutocompleteCtrl.hidden && $mdAutocompleteCtrl.activeOption ? $mdAutocompleteCtrl.activeOption : undefined}}">\
+ <div md-autocomplete-parent-scope md-autocomplete-replace>' + leftover + '</div>\
+ </md-input-container>';
+ } else {
+ return '\
+ <input type="text"\
+ ' + (tabindex != null ? 'tabindex="' + tabindex + '"' : '') + '\
+ id="{{inputId || \'input-\' + $mdAutocompleteCtrl.id}}"\
+ name="{{inputName || \'input-\' + $mdAutocompleteCtrl.id }}"\
+ ng-class="::inputClass"\
+ ng-if="!floatingLabel"\
+ autocomplete="off"\
+ ng-required="$mdAutocompleteCtrl.isRequired"\
+ ng-disabled="$mdAutocompleteCtrl.isDisabled"\
+ ng-readonly="$mdAutocompleteCtrl.isReadonly"\
+ ng-minlength="inputMinlength"\
+ ng-maxlength="inputMaxlength"\
+ ng-model="$mdAutocompleteCtrl.scope.searchText"\
+ ng-mousedown="$mdAutocompleteCtrl.focusInput()"\
+ ng-keydown="$mdAutocompleteCtrl.keydown($event)"\
+ ng-blur="$mdAutocompleteCtrl.blur($event)"\
+ ng-focus="$mdAutocompleteCtrl.focus($event)"\
+ placeholder="{{placeholder}}"\
+ aria-label="{{placeholder}}"\
+ ng-attr-aria-autocomplete="{{$mdAutocompleteCtrl.isDisabled ? undefined : \'list\'}}"\
+ ng-attr-role="{{$mdAutocompleteCtrl.isDisabled ? undefined : \'combobox\'}}"\
+ aria-haspopup="{{!$mdAutocompleteCtrl.isDisabled}}"\
+ aria-expanded="{{!$mdAutocompleteCtrl.hidden}}"\
+ ng-attr-aria-owns="{{$mdAutocompleteCtrl.hidden || $mdAutocompleteCtrl.isDisabled ? undefined : \'ul-\' + $mdAutocompleteCtrl.id}}"\
+ ng-attr-aria-activedescendant="{{!$mdAutocompleteCtrl.hidden && $mdAutocompleteCtrl.activeOption ? $mdAutocompleteCtrl.activeOption : undefined}}">';
+ }
+ }
+
+ function getClearButton() {
+ return '' +
+ '<button ' +
+ 'type="button" ' +
+ 'aria-label="Clear Input" ' +
+ 'tabindex="0" ' +
+ 'ng-if="clearButton && $mdAutocompleteCtrl.scope.searchText" ' +
+ 'ng-click="$mdAutocompleteCtrl.clear($event)">' +
+ '<md-icon md-svg-src="' + $$mdSvgRegistry.mdClose + '"></md-icon>' +
+ '</button>';
+ }
+ }
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+
+MdAutocompleteItemScopeDirective.$inject = ["$compile", "$mdUtil"];angular
+ .module('material.components.autocomplete')
+ .directive('mdAutocompleteParentScope', MdAutocompleteItemScopeDirective);
+
+function MdAutocompleteItemScopeDirective($compile, $mdUtil) {
+ return {
+ restrict: 'AE',
+ compile: compile,
+ terminal: true,
+ transclude: 'element'
+ };
+
+ function compile(tElement, tAttr, transclude) {
+ return function postLink(scope, element, attr) {
+ var ctrl = scope.$mdAutocompleteCtrl;
+ var newScope = ctrl.parent.$new();
+ var itemName = ctrl.itemName;
+
+ // Watch for changes to our scope's variables and copy them to the new scope
+ watchVariable('$index', '$index');
+ watchVariable('item', itemName);
+
+ // Ensure that $digest calls on our scope trigger $digest on newScope.
+ connectScopes();
+
+ // Link the element against newScope.
+ transclude(newScope, function(clone) {
+ element.after(clone);
+ });
+
+ /**
+ * Creates a watcher for variables that are copied from the parent scope
+ * @param variable
+ * @param alias
+ */
+ function watchVariable(variable, alias) {
+ newScope[alias] = scope[variable];
+
+ scope.$watch(variable, function(value) {
+ $mdUtil.nextTick(function() {
+ newScope[alias] = value;
+ });
+ });
+ }
+
+ /**
+ * Creates watchers on scope and newScope that ensure that for any
+ * $digest of scope, newScope is also $digested.
+ */
+ function connectScopes() {
+ var scopeDigesting = false;
+ var newScopeDigesting = false;
+
+ scope.$watch(function() {
+ if (newScopeDigesting || scopeDigesting) {
+ return;
+ }
+
+ scopeDigesting = true;
+ scope.$$postDigest(function() {
+ if (!newScopeDigesting) {
+ newScope.$digest();
+ }
+
+ scopeDigesting = newScopeDigesting = false;
+ });
+ });
+
+ newScope.$watch(function() {
+ newScopeDigesting = true;
+ });
+ }
+ };
+ }
+}
+})();
+(function(){
+"use strict";
+
+
+MdHighlightCtrl.$inject = ["$scope", "$element", "$attrs", "$mdUtil"];angular
+ .module('material.components.autocomplete')
+ .controller('MdHighlightCtrl', MdHighlightCtrl);
+
+function MdHighlightCtrl ($scope, $element, $attrs, $mdUtil) {
+ this.$scope = $scope;
+ this.$element = $element;
+ this.$attrs = $attrs;
+ this.$mdUtil = $mdUtil;
+
+ // Cache the Regex to avoid rebuilding each time.
+ this.regex = null;
+}
+
+MdHighlightCtrl.prototype.init = function(unsafeTermFn, unsafeContentFn) {
+
+ this.flags = this.$attrs.mdHighlightFlags || '';
+
+ this.unregisterFn = this.$scope.$watch(function($scope) {
+ return {
+ term: unsafeTermFn($scope),
+ contentText: unsafeContentFn($scope)
+ };
+ }.bind(this), this.onRender.bind(this), true);
+
+ this.$element.on('$destroy', this.unregisterFn);
+};
+
+/**
+ * Triggered once a new change has been recognized and the highlighted
+ * text needs to be updated.
+ */
+MdHighlightCtrl.prototype.onRender = function(state, prevState) {
+
+ var contentText = state.contentText;
+
+ /* Update the regex if it's outdated, because we don't want to rebuilt it constantly. */
+ if (this.regex === null || state.term !== prevState.term) {
+ this.regex = this.createRegex(state.term, this.flags);
+ }
+
+ /* If a term is available apply the regex to the content */
+ if (state.term) {
+ this.applyRegex(contentText);
+ } else {
+ this.$element.text(contentText);
+ }
+
+};
+
+/**
+ * Decomposes the specified text into different tokens (whether match or not).
+ * Breaking down the string guarantees proper XSS protection due to the native browser
+ * escaping of unsafe text.
+ */
+MdHighlightCtrl.prototype.applyRegex = function(text) {
+ var tokens = this.resolveTokens(text);
+
+ this.$element.empty();
+
+ tokens.forEach(function (token) {
+
+ if (token.isMatch) {
+ var tokenEl = angular.element('<span class="highlight">').text(token.text);
+
+ this.$element.append(tokenEl);
+ } else {
+ this.$element.append(document.createTextNode(token));
+ }
+
+ }.bind(this));
+
+};
+
+ /**
+ * Decomposes the specified text into different tokens by running the regex against the text.
+ */
+MdHighlightCtrl.prototype.resolveTokens = function(string) {
+ var tokens = [];
+ var lastIndex = 0;
+
+ // Use replace here, because it supports global and single regular expressions at same time.
+ string.replace(this.regex, function(match, index) {
+ appendToken(lastIndex, index);
+
+ tokens.push({
+ text: match,
+ isMatch: true
+ });
+
+ lastIndex = index + match.length;
+ });
+
+ // Append the missing text as a token.
+ appendToken(lastIndex);
+
+ return tokens;
+
+ function appendToken(from, to) {
+ var targetText = string.slice(from, to);
+ targetText && tokens.push(targetText);
+ }
+};
+
+/** Creates a regex for the specified text with the given flags. */
+MdHighlightCtrl.prototype.createRegex = function(term, flags) {
+ var startFlag = '', endFlag = '';
+ var regexTerm = this.$mdUtil.sanitize(term);
+
+ if (flags.indexOf('^') >= 0) startFlag = '^';
+ if (flags.indexOf('$') >= 0) endFlag = '$';
+
+ return new RegExp(startFlag + regexTerm + endFlag, flags.replace(/[$^]/g, ''));
+};
+
+})();
+(function(){
+"use strict";
+
+
+MdHighlight.$inject = ["$interpolate", "$parse"];angular
+ .module('material.components.autocomplete')
+ .directive('mdHighlightText', MdHighlight);
+
+/**
+ * @ngdoc directive
+ * @name mdHighlightText
+ * @module material.components.autocomplete
+ *
+ * @description
+ * The `md-highlight-text` directive allows you to specify text that should be highlighted within
+ * an element. Highlighted text will be wrapped in `<span class="highlight"></span>` which can
+ * be styled through CSS. Please note that child elements may not be used with this directive.
+ *
+ * @param {string} md-highlight-text A model to be searched for
+ * @param {string=} md-highlight-flags A list of flags (loosely based on JavaScript RexExp flags).
+ * #### **Supported flags**:
+ * - `g`: Find all matches within the provided text
+ * - `i`: Ignore case when searching for matches
+ * - `$`: Only match if the text ends with the search term
+ * - `^`: Only match if the text begins with the search term
+ *
+ * @usage
+ * <hljs lang="html">
+ * <input placeholder="Enter a search term..." ng-model="searchTerm" type="text" />
+ * <ul>
+ * <li ng-repeat="result in results" md-highlight-text="searchTerm" md-highlight-flags="i">
+ * {{result.text}}
+ * </li>
+ * </ul>
+ * </hljs>
+ */
+
+function MdHighlight ($interpolate, $parse) {
+ return {
+ terminal: true,
+ controller: 'MdHighlightCtrl',
+ compile: function mdHighlightCompile(tElement, tAttr) {
+ var termExpr = $parse(tAttr.mdHighlightText);
+ var unsafeContentExpr = $interpolate(tElement.html());
+
+ return function mdHighlightLink(scope, element, attr, ctrl) {
+ ctrl.init(termExpr, unsafeContentExpr);
+ };
+ }
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+/*
+ * @ngdoc module
+ * @name material.components.backdrop
+ * @description Backdrop
+ */
+
+/**
+ * @ngdoc directive
+ * @name mdBackdrop
+ * @module material.components.backdrop
+ *
+ * @restrict E
+ *
+ * @description
+ * `<md-backdrop>` is a backdrop element used by other components, such as dialog and bottom sheet.
+ * Apply class `opaque` to make the backdrop use the theme backdrop color.
+ *
+ */
+
+angular
+ .module('material.components.backdrop', ['material.core'])
+ .directive('mdBackdrop', ["$mdTheming", "$mdUtil", "$animate", "$rootElement", "$window", "$log", "$$rAF", "$document", function BackdropDirective($mdTheming, $mdUtil, $animate, $rootElement, $window, $log, $$rAF, $document) {
+ var ERROR_CSS_POSITION = '<md-backdrop> may not work properly in a scrolled, static-positioned parent container.';
+
+ return {
+ restrict: 'E',
+ link: postLink
+ };
+
+ function postLink(scope, element, attrs) {
+ // backdrop may be outside the $rootElement, tell ngAnimate to animate regardless
+ if ($animate.pin) $animate.pin(element, $rootElement);
+
+ var bodyStyles;
+
+ $$rAF(function() {
+ // If body scrolling has been disabled using mdUtil.disableBodyScroll(),
+ // adjust the 'backdrop' height to account for the fixed 'body' top offset.
+ // Note that this can be pretty expensive and is better done inside the $$rAF.
+ bodyStyles = $window.getComputedStyle($document[0].body);
+
+ if (bodyStyles.position === 'fixed') {
+ var resizeHandler = $mdUtil.debounce(function(){
+ bodyStyles = $window.getComputedStyle($document[0].body);
+ resize();
+ }, 60, null, false);
+
+ resize();
+ angular.element($window).on('resize', resizeHandler);
+
+ scope.$on('$destroy', function() {
+ angular.element($window).off('resize', resizeHandler);
+ });
+ }
+
+ // Often $animate.enter() is used to append the backDrop element
+ // so let's wait until $animate is done...
+ var parent = element.parent();
+
+ if (parent.length) {
+ if (parent[0].nodeName === 'BODY') {
+ element.css('position', 'fixed');
+ }
+
+ var styles = $window.getComputedStyle(parent[0]);
+
+ if (styles.position === 'static') {
+ // backdrop uses position:absolute and will not work properly with parent position:static (default)
+ $log.warn(ERROR_CSS_POSITION);
+ }
+
+ // Only inherit the parent if the backdrop has a parent.
+ $mdTheming.inherit(element, parent);
+ }
+ });
+
+ function resize() {
+ var viewportHeight = parseInt(bodyStyles.height, 10) + Math.abs(parseInt(bodyStyles.top, 10));
+ element.css('height', viewportHeight + 'px');
+ }
+ }
+
+ }]);
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.bottomSheet
+ * @description
+ * BottomSheet
+ */
+MdBottomSheetDirective.$inject = ["$mdBottomSheet"];
+MdBottomSheetProvider.$inject = ["$$interimElementProvider"];
+angular
+ .module('material.components.bottomSheet', [
+ 'material.core',
+ 'material.components.backdrop'
+ ])
+ .directive('mdBottomSheet', MdBottomSheetDirective)
+ .provider('$mdBottomSheet', MdBottomSheetProvider);
+
+/* @ngInject */
+function MdBottomSheetDirective($mdBottomSheet) {
+ return {
+ restrict: 'E',
+ link : function postLink(scope, element) {
+ element.addClass('_md'); // private md component indicator for styling
+
+ // When navigation force destroys an interimElement, then
+ // listen and $destroy() that interim instance...
+ scope.$on('$destroy', function() {
+ $mdBottomSheet.destroy();
+ });
+ }
+ };
+}
+
+
+/**
+ * @ngdoc service
+ * @name $mdBottomSheet
+ * @module material.components.bottomSheet
+ *
+ * @description
+ * `$mdBottomSheet` opens a bottom sheet over the app and provides a simple promise API.
+ *
+ * ## Restrictions
+ *
+ * - The bottom sheet's template must have an outer `<md-bottom-sheet>` element.
+ * - Add the `md-grid` class to the bottom sheet for a grid layout.
+ * - Add the `md-list` class to the bottom sheet for a list layout.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div ng-controller="MyController">
+ * <md-button ng-click="openBottomSheet()">
+ * Open a Bottom Sheet!
+ * </md-button>
+ * </div>
+ * </hljs>
+ * <hljs lang="js">
+ * var app = angular.module('app', ['ngMaterial']);
+ * app.controller('MyController', function($scope, $mdBottomSheet) {
+ * $scope.openBottomSheet = function() {
+ * $mdBottomSheet.show({
+ * template: '<md-bottom-sheet>' +
+ * 'Hello! <md-button ng-click="closeBottomSheet()">Close</md-button>' +
+ * '</md-bottom-sheet>'
+ * })
+ *
+ * // Fires when the hide() method is used
+ * .then(function() {
+ * console.log('You clicked the button to close the bottom sheet!');
+ * })
+ *
+ * // Fires when the cancel() method is used
+ * .catch(function() {
+ * console.log('You hit escape or clicked the backdrop to close.');
+ * });
+ * };
+ *
+ * $scope.closeBottomSheet = function($scope, $mdBottomSheet) {
+ * $mdBottomSheet.hide();
+ * }
+ *
+ * });
+ * </hljs>
+ *
+ * ### Custom Presets
+ * Developers are also able to create their own preset, which can be easily used without repeating
+ * their options each time.
+ *
+ * <hljs lang="js">
+ * $mdBottomSheetProvider.addPreset('testPreset', {
+ * options: function() {
+ * return {
+ * template:
+ * '<md-bottom-sheet>' +
+ * 'This is a custom preset' +
+ * '</md-bottom-sheet>',
+ * controllerAs: 'bottomSheet',
+ * bindToController: true,
+ * clickOutsideToClose: true,
+ * escapeToClose: true
+ * };
+ * }
+ * });
+ * </hljs>
+ *
+ * After you create your preset during the config phase, you can easily access it.
+ *
+ * <hljs lang="js">
+ * $mdBottomSheet.show(
+ * $mdBottomSheet.testPreset()
+ * );
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdBottomSheet#show
+ *
+ * @description
+ * Show a bottom sheet with the specified options.
+ *
+ * <em><b>Note:</b> You should <b>always</b> provide a `.catch()` method in case the user hits the
+ * `esc` key or clicks the background to close. In this case, the `cancel()` method will
+ * automatically be called on the bottom sheet which will `reject()` the promise. See the @usage
+ * section above for an example.
+ *
+ * Newer versions of Angular will throw a `Possibly unhandled rejection` exception if you forget
+ * this.</em>
+ *
+ * @param {Object} optionsOrPreset Either provide an `$mdBottomSheetPreset` defined during the
+ * config phase or an options object, with the following properties:
+ *
+ * - `templateUrl` - `{string=}`: The url of an html template file that will
+ * be used as the content of the bottom sheet. Restrictions: the template must
+ * have an outer `md-bottom-sheet` element.
+ * - `template` - `{string=}`: Same as templateUrl, except this is an actual
+ * template string.
+ * - `scope` - `{Object=}`: the scope to link the template / controller to. If none is specified,
+ * it will create a new child scope. This scope will be destroyed when the bottom sheet is
+ * removed unless `preserveScope` is set to true.
+ * - `preserveScope` - `{boolean=}`: whether to preserve the scope when the element is removed.
+ * Default is false
+ * - `controller` - `{string=}`: The controller to associate with this bottom sheet.
+ * - `locals` - `{string=}`: An object containing key/value pairs. The keys will be used as names
+ * of values to inject into the controller. For example, `locals: {three: 3}` would inject
+ * `three` into the controller with the value of 3.
+ * - `clickOutsideToClose` - `{boolean=}`: Whether the user can click outside the bottom sheet to
+ * close it. Default true.
+ * - `bindToController` - `{boolean=}`: When set to true, the locals will be bound to the
+ * controller instance and available in it's $onInit function.
+ * - `disableBackdrop` - `{boolean=}`: When set to true, the bottomsheet will not show a backdrop.
+ * - `escapeToClose` - `{boolean=}`: Whether the user can press escape to close the bottom sheet.
+ * Default true.
+ * - `isLockedOpen` - `{boolean=}`: Disables all default ways of closing the bottom sheet.
+ * **Note:** this will override the `clickOutsideToClose` and `escapeToClose` options, leaving
+ * only the `hide` and `cancel` methods as ways of closing the bottom sheet. Defaults to false.
+ * - `resolve` - `{Object=}`: Similar to locals, except it takes promises as values
+ * and the bottom sheet will not open until the promises resolve.
+ * - `controllerAs` - `{string=}`: An alias to assign the controller to on the scope.
+ * - `parent` - `{element=}`: The element to append the bottom sheet to. The `parent` may be a
+ * `function`, `string`, `Object`, or null. Defaults to appending to the body of the root element
+ * (or the root element) of the application.
+ * e.g. angular.element(document.getElementById('content')) or "#content"
+ * - `disableParentScroll` - `{boolean=}`: Whether to disable scrolling while the bottom sheet is
+ * open. Default true.
+ *
+ * @returns {promise} A promise that can be resolved with `$mdBottomSheet.hide()` or
+ * rejected with `$mdBottomSheet.cancel()`.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdBottomSheet#hide
+ *
+ * @description
+ * Hide the existing bottom sheet and resolve the promise returned from
+ * `$mdBottomSheet.show()`. This call will close the most recently opened/current bottom sheet (if
+ * any).
+ *
+ * <em><b>Note:</b> Use a `.then()` on your `.show()` to handle this callback.</em>
+ *
+ * @param {*=} response An argument for the resolved promise.
+ *
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdBottomSheet#cancel
+ *
+ * @description
+ * Hide the existing bottom sheet and reject the promise returned from
+ * `$mdBottomSheet.show()`.
+ *
+ * <em><b>Note:</b> Use a `.catch()` on your `.show()` to handle this callback.</em>
+ *
+ * @param {*=} response An argument for the rejected promise.
+ *
+ */
+
+function MdBottomSheetProvider($$interimElementProvider) {
+ // how fast we need to flick down to close the sheet, pixels/ms
+ bottomSheetDefaults.$inject = ["$animate", "$mdConstant", "$mdUtil", "$mdTheming", "$mdBottomSheet", "$rootElement", "$mdGesture", "$log"];
+ var CLOSING_VELOCITY = 0.5;
+ var PADDING = 80; // same as css
+
+ return $$interimElementProvider('$mdBottomSheet')
+ .setDefaults({
+ methods: ['disableParentScroll', 'escapeToClose', 'clickOutsideToClose'],
+ options: bottomSheetDefaults
+ });
+
+ /* @ngInject */
+ function bottomSheetDefaults($animate, $mdConstant, $mdUtil, $mdTheming, $mdBottomSheet, $rootElement,
+ $mdGesture, $log) {
+ var backdrop;
+
+ return {
+ themable: true,
+ onShow: onShow,
+ onRemove: onRemove,
+ disableBackdrop: false,
+ escapeToClose: true,
+ clickOutsideToClose: true,
+ disableParentScroll: true,
+ isLockedOpen: false
+ };
+
+ function onShow(scope, element, options) {
+ element = $mdUtil.extractElementByName(element, 'md-bottom-sheet');
+
+ // prevent tab focus or click focus on the bottom-sheet container
+ element.attr('tabindex', '-1');
+
+ // Once the md-bottom-sheet has `ng-cloak` applied on his template the opening animation will not work properly.
+ // This is a very common problem, so we have to notify the developer about this.
+ if (element.hasClass('ng-cloak')) {
+ var message = '$mdBottomSheet: using `<md-bottom-sheet ng-cloak>` will affect the bottom-sheet opening animations.';
+ $log.warn(message, element[0]);
+ }
+
+ if (options.isLockedOpen) {
+ options.clickOutsideToClose = false;
+ options.escapeToClose = false;
+ } else {
+ options.cleanupGestures = registerGestures(element, options.parent);
+ }
+
+ if (!options.disableBackdrop) {
+ // Add a backdrop that will close on click
+ backdrop = $mdUtil.createBackdrop(scope, "md-bottom-sheet-backdrop md-opaque");
+
+ // Prevent mouse focus on backdrop; ONLY programmatic focus allowed.
+ // This allows clicks on backdrop to propagate to the $rootElement and
+ // ESC key events to be detected properly.
+ backdrop[0].tabIndex = -1;
+
+ if (options.clickOutsideToClose) {
+ backdrop.on('click', function() {
+ $mdUtil.nextTick($mdBottomSheet.cancel, true);
+ });
+ }
+
+ $mdTheming.inherit(backdrop, options.parent);
+
+ $animate.enter(backdrop, options.parent, null);
+ }
+
+ $mdTheming.inherit(element, options.parent);
+
+ if (options.disableParentScroll) {
+ options.restoreScroll = $mdUtil.disableScrollAround(element, options.parent);
+ }
+
+ return $animate.enter(element, options.parent, backdrop)
+ .then(function() {
+ var focusable = $mdUtil.findFocusTarget(element) || angular.element(
+ element[0].querySelector('button') ||
+ element[0].querySelector('a') ||
+ element[0].querySelector($mdUtil.prefixer('ng-click', true))
+ ) || backdrop;
+
+ if (options.escapeToClose) {
+ options.rootElementKeyupCallback = function(e) {
+ if (e.keyCode === $mdConstant.KEY_CODE.ESCAPE) {
+ $mdUtil.nextTick($mdBottomSheet.cancel, true);
+ }
+ };
+
+ $rootElement.on('keyup', options.rootElementKeyupCallback);
+ focusable && focusable.focus();
+ }
+ });
+
+ }
+
+ function onRemove(scope, element, options) {
+ if (!options.disableBackdrop) $animate.leave(backdrop);
+
+ return $animate.leave(element).then(function() {
+ if (options.disableParentScroll) {
+ options.restoreScroll();
+ delete options.restoreScroll;
+ }
+
+ options.cleanupGestures && options.cleanupGestures();
+ });
+ }
+
+ /**
+ * Adds the drag gestures to the bottom sheet.
+ * @param {JQLite} element where CSS transitions will be applied
+ * @param {JQLite} parent used for registering gesture listeners
+ * @return {Function} function that removes gesture listeners that were set up by
+ * registerGestures()
+ */
+ function registerGestures(element, parent) {
+ var deregister = $mdGesture.register(parent, 'drag', { horizontal: false });
+ parent.on('$md.dragstart', onDragStart)
+ .on('$md.drag', onDrag)
+ .on('$md.dragend', onDragEnd);
+
+ return function cleanupGestures() {
+ deregister();
+ parent.off('$md.dragstart', onDragStart);
+ parent.off('$md.drag', onDrag);
+ parent.off('$md.dragend', onDragEnd);
+ };
+
+ function onDragStart() {
+ // Disable transitions on transform so that it feels fast
+ element.css($mdConstant.CSS.TRANSITION_DURATION, '0ms');
+ }
+
+ function onDrag(ev) {
+ var transform = ev.pointer.distanceY;
+ if (transform < 5) {
+ // Slow down drag when trying to drag up, and stop after PADDING
+ transform = Math.max(-PADDING, transform / 2);
+ }
+ element.css($mdConstant.CSS.TRANSFORM, 'translate3d(0,' + (PADDING + transform) + 'px,0)');
+ }
+
+ function onDragEnd(ev) {
+ if (ev.pointer.distanceY > 0 &&
+ (ev.pointer.distanceY > 20 || Math.abs(ev.pointer.velocityY) > CLOSING_VELOCITY)) {
+ var distanceRemaining = element.prop('offsetHeight') - ev.pointer.distanceY;
+ var transitionDuration = Math.min(distanceRemaining / ev.pointer.velocityY * 0.75, 500);
+ element.css($mdConstant.CSS.TRANSITION_DURATION, transitionDuration + 'ms');
+ $mdUtil.nextTick($mdBottomSheet.cancel, true);
+ } else {
+ element.css($mdConstant.CSS.TRANSITION_DURATION, '');
+ element.css($mdConstant.CSS.TRANSFORM, '');
+ }
+ }
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.button
+ * @description
+ *
+ * Button
+ */
+MdButtonDirective.$inject = ["$mdButtonInkRipple", "$mdTheming", "$mdAria", "$mdInteraction"];
+MdAnchorDirective.$inject = ["$mdTheming"];
+angular
+ .module('material.components.button', ['material.core'])
+ .directive('mdButton', MdButtonDirective)
+ .directive('a', MdAnchorDirective);
+
+
+/**
+ * @private
+ * @restrict E
+ *
+ * @description
+ * `a` is an anchor directive used to inherit theme colors for md-primary, md-accent, etc.
+ *
+ * @usage
+ *
+ * <hljs lang="html">
+ * <md-content md-theme="myTheme">
+ * <a href="#chapter1" class="md-accent"></a>
+ * </md-content>
+ * </hljs>
+ */
+function MdAnchorDirective($mdTheming) {
+ return {
+ restrict : 'E',
+ link : function postLink(scope, element) {
+ // Make sure to inherit theme so stand-alone anchors
+ // support theme colors for md-primary, md-accent, etc.
+ $mdTheming(element);
+ }
+ };
+}
+
+
+/**
+ * @ngdoc directive
+ * @name mdButton
+ * @module material.components.button
+ *
+ * @restrict E
+ *
+ * @description
+ * `<md-button>` is a button directive with optional ink ripples (default enabled).
+ *
+ * If you supply a `href` or `ng-href` attribute, it will become an `<a>` element. Otherwise, it
+ * will become a `<button>` element. As per the
+ * [Material Design specifications](https://material.google.com/style/color.html#color-color-palette)
+ * the FAB button background is filled with the accent color [by default]. The primary color palette
+ * may be used with the `md-primary` class.
+ *
+ * Developers can also change the color palette of the button, by using the following classes
+ * - `md-primary`
+ * - `md-accent`
+ * - `md-warn`
+ *
+ * See for example
+ *
+ * <hljs lang="html">
+ * <md-button class="md-primary">Primary Button</md-button>
+ * </hljs>
+ *
+ * Button can be also raised, which means that they will use the current color palette to fill the button.
+ *
+ * <hljs lang="html">
+ * <md-button class="md-accent md-raised">Raised and Accent Button</md-button>
+ * </hljs>
+ *
+ * It is also possible to disable the focus effect on the button, by using the following markup.
+ *
+ * <hljs lang="html">
+ * <md-button class="md-no-focus">No Focus Style</md-button>
+ * </hljs>
+ *
+ * @param {string=} aria-label Adds alternative text to button for accessibility, useful for icon buttons.
+ * If no default text is found, a warning will be logged.
+ * @param {boolean=} md-no-ink If present, disable ink ripple effects.
+ * @param {string=} md-ripple-size Overrides the default ripple size logic. Options: `full`, `partial`, `auto`.
+ * @param {expression=} ng-disabled Disable the button when the expression is truthy.
+ * @param {expression=} ng-blur Expression evaluated when focus is removed from the button.
+ *
+ * @usage
+ *
+ * Regular buttons:
+ *
+ * <hljs lang="html">
+ * <md-button> Flat Button </md-button>
+ * <md-button href="http://google.com"> Flat link </md-button>
+ * <md-button class="md-raised"> Raised Button </md-button>
+ * <md-button ng-disabled="true"> Disabled Button </md-button>
+ * <md-button>
+ * <md-icon md-svg-src="your/icon.svg"></md-icon>
+ * Register Now
+ * </md-button>
+ * </hljs>
+ *
+ * FAB buttons:
+ *
+ * <hljs lang="html">
+ * <md-button class="md-fab" aria-label="FAB">
+ * <md-icon md-svg-src="your/icon.svg"></md-icon>
+ * </md-button>
+ * <!-- mini-FAB -->
+ * <md-button class="md-fab md-mini" aria-label="Mini FAB">
+ * <md-icon md-svg-src="your/icon.svg"></md-icon>
+ * </md-button>
+ * <!-- Button with SVG Icon -->
+ * <md-button class="md-icon-button" aria-label="Custom Icon Button">
+ * <md-icon md-svg-icon="path/to/your.svg"></md-icon>
+ * </md-button>
+ * </hljs>
+ */
+function MdButtonDirective($mdButtonInkRipple, $mdTheming, $mdAria, $mdInteraction) {
+
+ return {
+ restrict: 'EA',
+ replace: true,
+ transclude: true,
+ template: getTemplate,
+ link: postLink
+ };
+
+ function isAnchor(attr) {
+ return angular.isDefined(attr.href) || angular.isDefined(attr.ngHref) || angular.isDefined(attr.ngLink) || angular.isDefined(attr.uiSref);
+ }
+
+ function getTemplate(element, attr) {
+ if (isAnchor(attr)) {
+ return '<a class="md-button" ng-transclude></a>';
+ } else {
+ // If buttons don't have type="button", they will submit forms automatically.
+ var btnType = (typeof attr.type === 'undefined') ? 'button' : attr.type;
+ return '<button class="md-button" type="' + btnType + '" ng-transclude></button>';
+ }
+ }
+
+ function postLink(scope, element, attr) {
+ $mdTheming(element);
+ $mdButtonInkRipple.attach(scope, element);
+
+ // Use async expect to support possible bindings in the button label
+ $mdAria.expectWithoutText(element, 'aria-label');
+
+ // For anchor elements, we have to set tabindex manually when the element is disabled.
+ // We don't do this for md-nav-bar anchors as the component manages its own tabindex values.
+ if (isAnchor(attr) && angular.isDefined(attr.ngDisabled) &&
+ !element.hasClass('_md-nav-button')) {
+ scope.$watch(attr.ngDisabled, function(isDisabled) {
+ element.attr('tabindex', isDisabled ? -1 : 0);
+ });
+ }
+
+ // disabling click event when disabled is true
+ element.on('click', function(e){
+ if (attr.disabled === true) {
+ e.preventDefault();
+ e.stopImmediatePropagation();
+ }
+ });
+
+ if (!element.hasClass('md-no-focus')) {
+
+ element.on('focus', function() {
+
+ // Only show the focus effect when being focused through keyboard interaction or programmatically
+ if (!$mdInteraction.isUserInvoked() || $mdInteraction.getLastInteractionType() === 'keyboard') {
+ element.addClass('md-focused');
+ }
+
+ });
+
+ element.on('blur', function() {
+ element.removeClass('md-focused');
+ });
+ }
+
+ }
+
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.card
+ *
+ * @description
+ * Card components.
+ */
+mdCardDirective.$inject = ["$mdTheming"];
+angular.module('material.components.card', [
+ 'material.core'
+ ])
+ .directive('mdCard', mdCardDirective);
+
+
+/**
+ * @ngdoc directive
+ * @name mdCard
+ * @module material.components.card
+ *
+ * @restrict E
+ *
+ * @description
+ * The `<md-card>` directive is a container element used within `<md-content>` containers.
+ *
+ * An image included as a direct descendant will fill the card's width. If you want to avoid this,
+ * you can add the `md-image-no-fill` class to the parent element. The `<md-card-content>`
+ * container will wrap text content and provide padding. An `<md-card-footer>` element can be
+ * optionally included to put content flush against the bottom edge of the card.
+ *
+ * Action buttons can be included in an `<md-card-actions>` element, similar to `<md-dialog-actions>`.
+ * You can then position buttons using layout attributes.
+ *
+ * Card is built with:
+ * * `<md-card-header>` - Header for the card, holds avatar, text and squared image
+ * - `<md-card-avatar>` - Card avatar
+ * - `md-user-avatar` - Class for user image
+ * - `<md-icon>`
+ * - `<md-card-header-text>` - Contains elements for the card description
+ * - `md-title` - Class for the card title
+ * - `md-subhead` - Class for the card sub header
+ * * `<img>` - Image for the card
+ * * `<md-card-title>` - Card content title
+ * - `<md-card-title-text>`
+ * - `md-headline` - Class for the card content title
+ * - `md-subhead` - Class for the card content sub header
+ * - `<md-card-title-media>` - Squared image within the title
+ * - `md-media-sm` - Class for small image
+ * - `md-media-md` - Class for medium image
+ * - `md-media-lg` - Class for large image
+ * - `md-media-xl` - Class for extra large image
+ * * `<md-card-content>` - Card content
+ * * `<md-card-actions>` - Card actions
+ * - `<md-card-icon-actions>` - Icon actions
+ *
+ * Cards have constant width and variable heights; where the maximum height is limited to what can
+ * fit within a single view on a platform, but it can temporarily expand as needed.
+ *
+ * @usage
+ * ### Card with optional footer
+ * <hljs lang="html">
+ * <md-card>
+ * <img src="card-image.png" class="md-card-image" alt="image caption">
+ * <md-card-content>
+ * <h2>Card headline</h2>
+ * <p>Card content</p>
+ * </md-card-content>
+ * <md-card-footer>
+ * Card footer
+ * </md-card-footer>
+ * </md-card>
+ * </hljs>
+ *
+ * ### Card with actions
+ * <hljs lang="html">
+ * <md-card>
+ * <img src="card-image.png" class="md-card-image" alt="image caption">
+ * <md-card-content>
+ * <h2>Card headline</h2>
+ * <p>Card content</p>
+ * </md-card-content>
+ * <md-card-actions layout="row" layout-align="end center">
+ * <md-button>Action 1</md-button>
+ * <md-button>Action 2</md-button>
+ * </md-card-actions>
+ * </md-card>
+ * </hljs>
+ *
+ * ### Card with header, image, title actions and content
+ * <hljs lang="html">
+ * <md-card>
+ * <md-card-header>
+ * <md-card-avatar>
+ * <img class="md-user-avatar" src="avatar.png"/>
+ * </md-card-avatar>
+ * <md-card-header-text>
+ * <span class="md-title">Title</span>
+ * <span class="md-subhead">Sub header</span>
+ * </md-card-header-text>
+ * </md-card-header>
+ * <img ng-src="card-image.png" class="md-card-image" alt="image caption">
+ * <md-card-title>
+ * <md-card-title-text>
+ * <span class="md-headline">Card headline</span>
+ * <span class="md-subhead">Card subheader</span>
+ * </md-card-title-text>
+ * </md-card-title>
+ * <md-card-actions layout="row" layout-align="start center">
+ * <md-button>Action 1</md-button>
+ * <md-button>Action 2</md-button>
+ * <md-card-icon-actions>
+ * <md-button class="md-icon-button" aria-label="icon">
+ * <md-icon md-svg-icon="icon"></md-icon>
+ * </md-button>
+ * </md-card-icon-actions>
+ * </md-card-actions>
+ * <md-card-content>
+ * <p>
+ * Card content
+ * </p>
+ * </md-card-content>
+ * </md-card>
+ * </hljs>
+ */
+function mdCardDirective($mdTheming) {
+ return {
+ restrict: 'E',
+ link: function ($scope, $element, attr) {
+ $element.addClass('_md'); // private md component indicator for styling
+ $mdTheming($element);
+ }
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.checkbox
+ * @description Checkbox module!
+ */
+MdCheckboxDirective.$inject = ["inputDirective", "$mdAria", "$mdConstant", "$mdTheming", "$mdUtil", "$mdInteraction"];
+angular
+ .module('material.components.checkbox', ['material.core'])
+ .directive('mdCheckbox', MdCheckboxDirective);
+
+/**
+ * @ngdoc directive
+ * @name mdCheckbox
+ * @module material.components.checkbox
+ * @restrict E
+ *
+ * @description
+ * The checkbox directive is used like the normal
+ * [angular checkbox](https://docs.angularjs.org/api/ng/input/input%5Bcheckbox%5D).
+ *
+ * As per the [Material Design spec](https://material.io/archive/guidelines/style/color.html#color-color-palette)
+ * the checkbox is in the accent color by default. The primary color palette may be used with
+ * the `md-primary` class.
+ *
+ * @param {expression} ng-model Assignable angular expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {expression=} ng-true-value The value to which the expression should be set when selected.
+ * @param {expression=} ng-false-value The value to which the expression should be set when not
+ * selected.
+ * @param {expression=} ng-change Expression to be executed when the model value changes.
+ * @param {boolean=} md-no-ink If present, disable ink ripple effects.
+ * @param {string=} aria-label Adds label to checkbox for accessibility.
+ * Defaults to checkbox's text. If no default text is found, a warning will be logged.
+ * @param {expression=} md-indeterminate This determines when the checkbox should be rendered as
+ * 'indeterminate'. If a truthy expression or no value is passed in the checkbox renders in the
+ * md-indeterminate state. If falsy expression is passed in it just looks like a normal unchecked
+ * checkbox. The indeterminate, checked, and unchecked states are mutually exclusive. A box
+ * cannot be in any two states at the same time. Adding the 'md-indeterminate' attribute
+ * overrides any checked/unchecked rendering logic. When using the 'md-indeterminate' attribute
+ * use 'ng-checked' to define rendering logic instead of using 'ng-model'.
+ * @param {expression=} ng-checked If this expression evaluates as truthy, the 'md-checked' css
+ * class is added to the checkbox and it will appear checked.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-checkbox ng-model="isChecked" aria-label="Finished?">
+ * Finished ?
+ * </md-checkbox>
+ *
+ * <md-checkbox md-no-ink ng-model="hasInk" aria-label="No Ink Effects">
+ * No Ink Effects
+ * </md-checkbox>
+ *
+ * <md-checkbox ng-disabled="true" ng-model="isDisabled" aria-label="Disabled">
+ * Disabled
+ * </md-checkbox>
+ *
+ * </hljs>
+ *
+ */
+function MdCheckboxDirective(inputDirective, $mdAria, $mdConstant, $mdTheming, $mdUtil, $mdInteraction) {
+ inputDirective = inputDirective[0];
+
+ return {
+ restrict: 'E',
+ transclude: true,
+ require: ['^?mdInputContainer', '?ngModel', '?^form'],
+ priority: $mdConstant.BEFORE_NG_ARIA,
+ template:
+ '<div class="md-container" md-ink-ripple md-ink-ripple-checkbox>' +
+ '<div class="md-icon"></div>' +
+ '</div>' +
+ '<div ng-transclude class="md-label"></div>',
+ compile: compile
+ };
+
+ // **********************************************************
+ // Private Methods
+ // **********************************************************
+
+ function compile (tElement, tAttrs) {
+ tAttrs.$set('tabindex', tAttrs.tabindex || '0');
+ tAttrs.$set('type', 'checkbox');
+ tAttrs.$set('role', tAttrs.type);
+ tElement.addClass('md-auto-horizontal-margin');
+
+ return {
+ pre: function(scope, element) {
+ // Attach a click handler during preLink, in order to immediately stop propagation
+ // (especially for ng-click) when the checkbox is disabled.
+ element.on('click', function(e) {
+ if (this.hasAttribute('disabled')) {
+ e.stopImmediatePropagation();
+ }
+ });
+ },
+ post: postLink
+ };
+
+ function postLink(scope, element, attr, ctrls) {
+ var isIndeterminate;
+ var containerCtrl = ctrls[0];
+ var ngModelCtrl = ctrls[1] || $mdUtil.fakeNgModel();
+ var formCtrl = ctrls[2];
+ var labelHasLink = element.find('a').length > 0;
+
+ // The original component structure is not accessible when the checkbox's label contains a link.
+ // In order to keep backwards compatibility, we're only changing the structure of the component
+ // when we detect a link within the label. Using a span after the md-checkbox and attaching it
+ // via aria-labelledby allows screen readers to find and work with the link within the label.
+ if (labelHasLink) {
+ var labelId = 'label-' + $mdUtil.nextUid();
+ attr.$set('aria-labelledby', labelId);
+
+ var label = element.children()[1];
+ // Use jQLite here since ChildNode.remove() is not supported in IE11.
+ angular.element(label).remove();
+ label.removeAttribute('ng-transclude');
+ label.className = 'md-checkbox-link-label';
+ label.setAttribute('id', labelId);
+ element.after(label);
+ // Make sure that clicking on the label still causes the checkbox to be toggled, when appropriate.
+ var externalLabel = element.next();
+ externalLabel.on('click', listener);
+ }
+
+ if (containerCtrl) {
+ var isErrorGetter = containerCtrl.isErrorGetter || function() {
+ return ngModelCtrl.$invalid && (ngModelCtrl.$touched || (formCtrl && formCtrl.$submitted));
+ };
+
+ containerCtrl.input = element;
+
+ scope.$watch(isErrorGetter, containerCtrl.setInvalid);
+ }
+
+ $mdTheming(element);
+
+ // Redirect focus events to the root element, because IE11 is always focusing the container element instead
+ // of the md-checkbox element. This causes issues when using ngModelOptions: `updateOnBlur`
+ element.children().on('focus', function() {
+ element.focus();
+ });
+
+ if ($mdUtil.parseAttributeBoolean(attr.mdIndeterminate)) {
+ setIndeterminateState();
+ scope.$watch(attr.mdIndeterminate, setIndeterminateState);
+ }
+
+ if (attr.ngChecked) {
+ scope.$watch(scope.$eval.bind(scope, attr.ngChecked), function(value) {
+ ngModelCtrl.$setViewValue(value);
+ ngModelCtrl.$render();
+ });
+ }
+
+ $$watchExpr('ngDisabled', 'tabindex', {
+ true: '-1',
+ false: attr.tabindex
+ });
+
+ // Don't emit a warning when the label has a link within it. In that case we'll use
+ // aria-labelledby to point to another span that should be read as the label.
+ if (!labelHasLink) {
+ $mdAria.expectWithText(element, 'aria-label');
+ }
+
+ // Reuse the original input[type=checkbox] directive from AngularJS core.
+ // This is a bit hacky as we need our own event listener and own render
+ // function.
+ inputDirective.link.pre(scope, {
+ on: angular.noop,
+ 0: {}
+ }, attr, [ngModelCtrl]);
+
+ element.on('click', listener)
+ .on('keypress', keypressHandler)
+ .on('focus', function() {
+ if ($mdInteraction.getLastInteractionType() === 'keyboard') {
+ element.addClass('md-focused');
+ }
+ })
+ .on('blur', function() {
+ element.removeClass('md-focused');
+ });
+
+ ngModelCtrl.$render = render;
+
+ function $$watchExpr(expr, htmlAttr, valueOpts) {
+ if (attr[expr]) {
+ scope.$watch(attr[expr], function(val) {
+ if (valueOpts[val]) {
+ element.attr(htmlAttr, valueOpts[val]);
+ }
+ });
+ }
+ }
+
+ /**
+ * @param {KeyboardEvent} ev 'keypress' event to handle
+ */
+ function keypressHandler(ev) {
+ var keyCode = ev.which || ev.keyCode;
+ var submit, form;
+
+ ev.preventDefault();
+ switch (keyCode) {
+ case $mdConstant.KEY_CODE.SPACE:
+ element.addClass('md-focused');
+ listener(ev);
+ break;
+ case $mdConstant.KEY_CODE.ENTER:
+ // Match the behavior of the native <input type="checkbox">.
+ // When the enter key is pressed while focusing a native checkbox inside a form,
+ // the browser will trigger a `click` on the first non-disabled submit button/input
+ // in the form. Note that this is different from text inputs, which
+ // will directly submit the form without needing a submit button/input to be present.
+ form = $mdUtil.getClosest(ev.target, 'form');
+ if (form) {
+ submit = form.querySelector('button[type="submit"]:enabled, input[type="submit"]:enabled');
+ if (submit) {
+ submit.click();
+ }
+ }
+ break;
+ }
+ }
+
+ function listener(ev) {
+ // skipToggle boolean is used by the switch directive to prevent the click event
+ // when releasing the drag. There will be always a click if releasing the drag over the checkbox.
+ // If the click came from a link in the checkbox, don't toggle the value.
+ // We want the link to be opened without changing the value in this case.
+ if (element[0].hasAttribute('disabled') || scope.skipToggle || ev.target.tagName === 'A') {
+ return;
+ }
+
+ scope.$apply(function() {
+ // Toggle the checkbox value...
+ var viewValue = attr.ngChecked && attr.ngClick ? attr.checked : !ngModelCtrl.$viewValue;
+
+ ngModelCtrl.$setViewValue(viewValue, ev && ev.type);
+ ngModelCtrl.$render();
+ });
+ }
+
+ function render() {
+ // Cast the $viewValue to a boolean since it could be undefined
+ var checked = !!ngModelCtrl.$viewValue && !isIndeterminate;
+ element.toggleClass('md-checked', checked);
+ if (!isIndeterminate) {
+ if (checked) {
+ element.attr('aria-checked', 'true');
+ } else {
+ element.attr('aria-checked', 'false');
+ }
+ }
+ }
+
+ /**
+ * @param {string=} newValue
+ */
+ function setIndeterminateState(newValue) {
+ isIndeterminate = newValue !== false;
+ if (isIndeterminate) {
+ element.attr('aria-checked', 'mixed');
+ }
+ element.toggleClass('md-indeterminate', isIndeterminate);
+ ngModelCtrl.$render();
+ }
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.chips
+ */
+/*
+ * @see js folder for chips implementation
+ */
+angular.module('material.components.chips', [
+ 'material.core',
+ 'material.components.autocomplete'
+]);
+
+})();
+(function(){
+"use strict";
+
+
+MdChipCtrl.$inject = ["$scope", "$element", "$mdConstant", "$timeout", "$mdUtil"];angular
+ .module('material.components.chips')
+ .controller('MdChipCtrl', MdChipCtrl);
+
+/**
+ * Controller for the MdChip component. Responsible for handling keyboard
+ * events and editing the chip if needed.
+ *
+ * @param $scope
+ * @param $element
+ * @param $mdConstant
+ * @param $timeout
+ * @param $mdUtil
+ * @constructor
+ */
+function MdChipCtrl ($scope, $element, $mdConstant, $timeout, $mdUtil) {
+ /**
+ * @type {$scope}
+ */
+ this.$scope = $scope;
+
+ /**
+ * @type {$element}
+ */
+ this.$element = $element;
+
+ /**
+ * @type {$mdConstant}
+ */
+ this.$mdConstant = $mdConstant;
+
+ /**
+ * @type {$timeout}
+ */
+ this.$timeout = $timeout;
+
+ /**
+ * @type {$mdUtil}
+ */
+ this.$mdUtil = $mdUtil;
+
+ /**
+ * @type {boolean}
+ */
+ this.isEditing = false;
+
+ /**
+ * @type {MdChipsCtrl}
+ */
+ this.parentController = undefined;
+
+ /**
+ * @type {boolean}
+ */
+ this.enableChipEdit = false;
+}
+
+
+/**
+ * @param {MdChipsCtrl} controller
+ */
+MdChipCtrl.prototype.init = function(controller) {
+ this.parentController = controller;
+ this.enableChipEdit = this.parentController.enableChipEdit;
+
+ if (this.enableChipEdit) {
+ this.$element.on('keydown', this.chipKeyDown.bind(this));
+ this.$element.on('dblclick', this.chipMouseDoubleClick.bind(this));
+ this.getChipContent().addClass('_md-chip-content-edit-is-enabled');
+ }
+};
+
+
+/**
+ * @return {Object} first element with the md-chip-content class
+ */
+MdChipCtrl.prototype.getChipContent = function() {
+ var chipContents = this.$element[0].getElementsByClassName('md-chip-content');
+ return angular.element(chipContents[0]);
+};
+
+
+/**
+ * When editing the chip, if the user modifies the existing contents, we'll get a span back and
+ * need to ignore text elements as they only contain blank space.
+ * `children()` ignores text elements.
+ *
+ * When editing the chip, if the user deletes the contents and then enters some new content
+ * we'll only get a text element back.
+ * @return {Object} jQuery object representing the content element of the chip
+ */
+MdChipCtrl.prototype.getContentElement = function() {
+ var contentElement = angular.element(this.getChipContent().children()[0]);
+ if (!contentElement || contentElement.length === 0) {
+ contentElement = angular.element(this.getChipContent().contents()[0]);
+ }
+ return contentElement;
+};
+
+
+/**
+ * @return {number} index of this chip
+ */
+MdChipCtrl.prototype.getChipIndex = function() {
+ return parseInt(this.$element.attr('index'));
+};
+
+
+/**
+ * Update the chip's contents, focus the chip if it's selected, and exit edit mode.
+ * If the contents were updated to be empty, remove the chip and re-focus the input element.
+ */
+MdChipCtrl.prototype.goOutOfEditMode = function() {
+ if (!this.isEditing) {
+ return;
+ }
+
+ this.isEditing = false;
+ this.$element.removeClass('_md-chip-editing');
+ this.getChipContent()[0].contentEditable = 'false';
+ var chipIndex = this.getChipIndex();
+
+ var content = this.getContentElement().text();
+ if (content) {
+ this.parentController.updateChipContents(chipIndex, content);
+
+ this.$mdUtil.nextTick(function() {
+ if (this.parentController.selectedChip === chipIndex) {
+ this.parentController.focusChip(chipIndex);
+ }
+ }.bind(this));
+ } else {
+ this.parentController.removeChipAndFocusInput(chipIndex);
+ }
+};
+
+
+/**
+ * Given an HTML element. Selects contents of it.
+ * @param {Element} node
+ */
+MdChipCtrl.prototype.selectNodeContents = function(node) {
+ var range, selection;
+ if (document.body.createTextRange) {
+ range = document.body.createTextRange();
+ range.moveToElementText(node);
+ range.select();
+ } else if (window.getSelection) {
+ selection = window.getSelection();
+ range = document.createRange();
+ range.selectNodeContents(node);
+ selection.removeAllRanges();
+ selection.addRange(range);
+ }
+};
+
+
+/**
+ * Presents an input element to edit the contents of the chip.
+ */
+MdChipCtrl.prototype.goInEditMode = function() {
+ this.isEditing = true;
+ this.$element.addClass('_md-chip-editing');
+ this.getChipContent()[0].contentEditable = 'true';
+ this.getChipContent().on('blur', function() {
+ this.goOutOfEditMode();
+ }.bind(this));
+
+ this.selectNodeContents(this.getChipContent()[0]);
+};
+
+
+/**
+ * Handles the keydown event on the chip element. If enable-chip-edit attribute is
+ * set to true, space or enter keys can trigger going into edit mode. Enter can also
+ * trigger submitting if the chip is already being edited.
+ * @param {KeyboardEvent} event
+ */
+MdChipCtrl.prototype.chipKeyDown = function(event) {
+ if (!this.isEditing &&
+ (event.keyCode === this.$mdConstant.KEY_CODE.ENTER ||
+ event.keyCode === this.$mdConstant.KEY_CODE.SPACE)) {
+ event.preventDefault();
+ this.goInEditMode();
+ } else if (this.isEditing && event.keyCode === this.$mdConstant.KEY_CODE.ENTER) {
+ event.preventDefault();
+ this.goOutOfEditMode();
+ }
+};
+
+
+/**
+ * Enter edit mode if we're not already editing and the enable-chip-edit attribute is enabled.
+ */
+MdChipCtrl.prototype.chipMouseDoubleClick = function() {
+ if (this.enableChipEdit && !this.isEditing) {
+ this.goInEditMode();
+ }
+};
+
+})();
+(function(){
+"use strict";
+
+
+MdChip.$inject = ["$mdTheming", "$mdUtil", "$compile", "$timeout"];angular
+ .module('material.components.chips')
+ .directive('mdChip', MdChip);
+
+/**
+ * @ngdoc directive
+ * @name mdChip
+ * @module material.components.chips
+ *
+ * @description
+ * `<md-chip>` is a component used within `<md-chips>`. It is responsible for rendering an
+ * individual chip.
+ *
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-chips>
+ * <md-chip>{{$chip}}</md-chip>
+ * </md-chips>
+ * </hljs>
+ *
+ */
+
+/**
+ * MDChip Directive Definition
+ *
+ * @param $mdTheming
+ * @param $mdUtil
+ * @param $compile
+ * @param $timeout
+ * @ngInject
+ */
+function MdChip($mdTheming, $mdUtil, $compile, $timeout) {
+ return {
+ restrict: 'E',
+ require: ['^?mdChips', 'mdChip'],
+ link: postLink,
+ controller: 'MdChipCtrl'
+ };
+
+ function postLink(scope, element, attr, ctrls) {
+ var chipsController = ctrls.shift();
+ var chipController = ctrls.shift();
+ var chipContentElement = angular.element(element[0].querySelector('.md-chip-content'));
+
+ $mdTheming(element);
+
+ if (chipsController) {
+ chipController.init(chipsController);
+
+ // When a chip is blurred, make sure to unset (or reset) the selected chip so that tabbing
+ // through elements works properly
+ chipContentElement.on('blur', function() {
+ chipsController.resetSelectedChip();
+ chipsController.$scope.$applyAsync();
+ });
+ }
+
+ // Use $timeout to ensure we run AFTER the element has been added to the DOM so we can focus it.
+ $timeout(function() {
+ if (!chipsController) {
+ return;
+ }
+
+ if (chipsController.shouldFocusLastChip) {
+ chipsController.focusLastChipThenInput();
+ }
+ });
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+
+MdChipRemove.$inject = ["$timeout"];angular
+ .module('material.components.chips')
+ .directive('mdChipRemove', MdChipRemove);
+
+/**
+ * @ngdoc directive
+ * @name mdChipRemove
+ * @restrict A
+ * @module material.components.chips
+ *
+ * @description
+ * Indicates that the associated element should be used as the delete button template for all chips.
+ * The associated element must be a child of `md-chips`.
+ *
+ * The provided button template will be appended to each chip and will remove the associated chip
+ * on click.
+ *
+ * The button is not styled or themed based on the theme set on the `md-chips` component. A theme
+ * class and custom icon can be specified in your template.
+ *
+ * You can also specify the `type` of the button in your template.
+ *
+ * @usage
+ * ### With Standard Chips
+ * <hljs lang="html">
+ * <md-chips ...>
+ * <button md-chip-remove type="button" aria-label="Remove {{$chip}}">
+ * <md-icon md-svg-icon="md-cancel"></md-icon>
+ * </button>
+ * </md-chips>
+ * </hljs>
+ *
+ * ### With Object Chips
+ * <hljs lang="html">
+ * <md-chips ...>
+ * <button md-chip-remove type="button" aria-label="Remove {{$chip.name}}">
+ * <md-icon md-svg-icon="md-cancel"></md-icon>
+ * </button>
+ * </md-chips>
+ * </hljs>
+ */
+
+
+/**
+ * MdChipRemove Directive Definition.
+ *
+ * @param $timeout
+ * @returns {{restrict: string, require: string[], link: Function, scope: boolean}}
+ * @constructor
+ */
+function MdChipRemove ($timeout) {
+ return {
+ restrict: 'A',
+ require: '^mdChips',
+ scope: false,
+ link: postLink
+ };
+
+ function postLink(scope, element, attr, ctrl) {
+ element.on('click', function() {
+ scope.$apply(function() {
+ ctrl.removeChip(scope.$$replacedScope.$index);
+ });
+ });
+
+ // Child elements aren't available until after a $timeout tick as they are hidden by an
+ // `ng-if`. see http://goo.gl/zIWfuw
+ $timeout(function() {
+ element.attr({ 'tabindex': '-1', 'aria-hidden': 'true' });
+ element.find('button').attr('tabindex', '-1');
+ });
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+
+MdChipTransclude.$inject = ["$compile"];angular
+ .module('material.components.chips')
+ .directive('mdChipTransclude', MdChipTransclude);
+
+function MdChipTransclude ($compile) {
+ return {
+ restrict: 'EA',
+ terminal: true,
+ link: link,
+ scope: false
+ };
+ function link (scope, element, attr) {
+ var ctrl = scope.$parent.$mdChipsCtrl,
+ newScope = ctrl.parent.$new(false, ctrl.parent);
+ newScope.$$replacedScope = scope;
+ newScope.$chip = scope.$chip;
+ newScope.$index = scope.$index;
+ newScope.$mdChipsCtrl = ctrl;
+
+ var newHtml = ctrl.$scope.$eval(attr.mdChipTransclude);
+
+ element.html(newHtml);
+ $compile(element.contents())(newScope);
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * The default chip append delay.
+ *
+ * @type {number}
+ */
+MdChipsCtrl.$inject = ["$scope", "$attrs", "$mdConstant", "$log", "$element", "$timeout", "$mdUtil", "$mdLiveAnnouncer", "$exceptionHandler"];
+var DEFAULT_CHIP_APPEND_DELAY = 300;
+
+angular
+ .module('material.components.chips')
+ .controller('MdChipsCtrl', MdChipsCtrl);
+
+/**
+ * Controller for the MdChips component. Responsible for adding to and
+ * removing from the list of chips, marking chips as selected, and binding to
+ * the models of various input components.
+ *
+ * @param $scope
+ * @param $attrs
+ * @param $mdConstant
+ * @param $log
+ * @param $element
+ * @param $timeout
+ * @param $mdUtil
+ * @param $mdLiveAnnouncer
+ * @param $exceptionHandler
+ * @constructor
+ */
+function MdChipsCtrl ($scope, $attrs, $mdConstant, $log, $element, $timeout, $mdUtil,
+ $mdLiveAnnouncer, $exceptionHandler) {
+ /** @type {Function} **/
+ this.$timeout = $timeout;
+
+ /** @type {Object} */
+ this.$mdConstant = $mdConstant;
+
+ /** @type {angular.$scope} */
+ this.$scope = $scope;
+
+ /** @type {angular.$scope} */
+ this.parent = $scope.$parent;
+
+ /** @type {$mdUtil} */
+ this.$mdUtil = $mdUtil;
+
+ /** @type {$log} */
+ this.$log = $log;
+
+ /** @type {$mdLiveAnnouncer} */
+ this.$mdLiveAnnouncer = $mdLiveAnnouncer;
+
+ /** @type {$exceptionHandler} */
+ this.$exceptionHandler = $exceptionHandler;
+
+ /** @type {$element} */
+ this.$element = $element;
+
+ /** @type {$attrs} */
+ this.$attrs = $attrs;
+
+ /** @type {angular.NgModelController} */
+ this.ngModelCtrl = null;
+
+ /** @type {angular.NgModelController} */
+ this.userInputNgModelCtrl = null;
+
+ /** @type {MdAutocompleteCtrl} */
+ this.autocompleteCtrl = null;
+
+ /** @type {Element} */
+ this.userInputElement = null;
+
+ /** @type {Array.<Object>} */
+ this.items = [];
+
+ /** @type {number} */
+ this.selectedChip = -1;
+
+ /** @type {string} */
+ this.enableChipEdit = $mdUtil.parseAttributeBoolean($attrs.mdEnableChipEdit);
+
+ /** @type {string} */
+ this.addOnBlur = $mdUtil.parseAttributeBoolean($attrs.mdAddOnBlur);
+
+ /**
+ * The class names to apply to the autocomplete or input.
+ * @type {string}
+ */
+ this.inputClass = '';
+
+ /**
+ * The text to be used as the aria-label for the input.
+ * @type {string}
+ */
+ this.inputAriaLabel = 'Chips input.';
+
+ /**
+ * Label text to describe the chips container. Used to give context and instructions to screen
+ * reader users when the chips container is selected.
+ * @type {string}
+ */
+ this.containerHint = 'Chips container. Use arrow keys to select chips.';
+
+ /**
+ * Label text to describe the chips container when it is empty. Used to give context and
+ * instructions to screen reader users when the chips container is selected and it contains
+ * no chips.
+ * @type {string}
+ */
+ this.containerEmptyHint =
+ 'Chips container. Enter the text area, then type text, and press enter to add a chip.';
+
+ /**
+ * Hidden hint text for how to delete a chip. Used to give context to screen readers.
+ * @type {string}
+ */
+ this.deleteHint = 'Press delete to remove this chip.';
+
+ /**
+ * Hidden label for the delete button. Used to give context to screen readers.
+ * @type {string}
+ */
+ this.deleteButtonLabel = 'Remove';
+
+ /**
+ * Model used by the input element.
+ * @type {string}
+ */
+ this.chipBuffer = '';
+
+ /**
+ * Whether to use the transformChip expression to transform the chip buffer
+ * before appending it to the list.
+ * @type {boolean}
+ */
+ this.useTransformChip = false;
+
+ /**
+ * Whether to use the onAdd expression to notify of chip additions.
+ * @type {boolean}
+ */
+ this.useOnAdd = false;
+
+ /**
+ * Whether to use the onRemove expression to notify of chip removals.
+ * @type {boolean}
+ */
+ this.useOnRemove = false;
+
+ /**
+ * The ID of the chips wrapper which is used to build unique IDs for the chips and the aria-owns
+ * attribute.
+ *
+ * Defaults to '_md-chips-wrapper-' plus a unique number.
+ *
+ * @type {string}
+ */
+ this.wrapperId = '';
+
+ /**
+ * Array of unique numbers which will be auto-generated any time the items change, and is used to
+ * create unique IDs for the aria-owns attribute.
+ *
+ * @type {Array<number>}
+ */
+ this.contentIds = [];
+
+ /**
+ * The index of the chip that should have it's `tabindex` property set to `0` so it is selectable
+ * via the keyboard.
+ *
+ * @type {number|null}
+ */
+ this.ariaTabIndex = null;
+
+ /**
+ * After appending a chip, the chip will be focused for this number of milliseconds before the
+ * input is refocused.
+ *
+ * **Note:** This is **required** for compatibility with certain screen readers in order for
+ * them to properly allow keyboard access.
+ *
+ * @type {number}
+ */
+ this.chipAppendDelay = DEFAULT_CHIP_APPEND_DELAY;
+
+ /**
+ * Collection of functions to call to un-register watchers
+ *
+ * @type {Array}
+ */
+ this.deRegister = [];
+
+ /**
+ * The screen reader will announce the chip content followed by this message when a chip is added.
+ * @type {string}
+ */
+ this.addedMessage = 'added';
+
+ /**
+ * The screen reader will announce the chip content followed by this message when a chip is
+ * removed.
+ * @type {string}
+ */
+ this.removedMessage = 'removed';
+
+ this.init();
+}
+
+/**
+ * Initializes variables and sets up watchers
+ */
+MdChipsCtrl.prototype.init = function() {
+ var ctrl = this;
+
+ // Set the wrapper ID
+ this.wrapperId = '_md-chips-wrapper-' + this.$mdUtil.nextUid();
+
+ // If we're using static chips, then we need to initialize a few things.
+ if (!this.$element.attr('ng-model')) {
+ this.setupStaticChips();
+ }
+
+ // Setup a watcher which manages the role and aria-owns attributes.
+ // This is never called for static chips since items is not defined.
+ this.deRegister.push(
+ this.$scope.$watchCollection('$mdChipsCtrl.items', function() {
+ // Make sure our input and wrapper have the correct ARIA attributes
+ ctrl.setupInputAria();
+ ctrl.setupWrapperAria();
+ })
+ );
+
+ this.deRegister.push(
+ this.$attrs.$observe('mdChipAppendDelay', function(newValue) {
+ ctrl.chipAppendDelay = parseInt(newValue) || DEFAULT_CHIP_APPEND_DELAY;
+ })
+ );
+};
+
+/**
+ * Destructor for cleanup
+ */
+MdChipsCtrl.prototype.$onDestroy = function $onDestroy() {
+ var $destroyFn;
+ while (($destroyFn = this.deRegister.pop())) {
+ $destroyFn.call(this);
+ }
+};
+
+/**
+ * If we have an input, ensure it has the appropriate ARIA attributes.
+ */
+MdChipsCtrl.prototype.setupInputAria = function() {
+ var input = this.$element.find('input');
+
+ // If we have no input, just return
+ if (!input) {
+ return;
+ }
+
+ input.attr('role', 'textbox');
+ input.attr('aria-multiline', true);
+ if (this.inputAriaDescribedBy) {
+ input.attr('aria-describedby', this.inputAriaDescribedBy);
+ }
+ if (this.inputAriaLabelledBy) {
+ input.attr('aria-labelledby', this.inputAriaLabelledBy);
+ input.removeAttr('aria-label');
+ } else {
+ input.attr('aria-label', this.inputAriaLabel);
+ }
+};
+
+/**
+ * Ensure our wrapper has the appropriate ARIA attributes.
+ */
+MdChipsCtrl.prototype.setupWrapperAria = function() {
+ var ctrl = this,
+ wrapper = this.$element.find('md-chips-wrap');
+
+ if (this.items && this.items.length) {
+ // Dynamically add the listbox role on every change because it must be removed when there are
+ // no items.
+ wrapper.attr('role', 'listbox');
+
+ // Generate some random (but unique) IDs for each chip
+ this.contentIds = this.items.map(function() {
+ return ctrl.wrapperId + '-chip-' + ctrl.$mdUtil.nextUid();
+ });
+
+ // Use the contentIDs above to generate the aria-owns attribute
+ wrapper.attr('aria-owns', this.contentIds.join(' '));
+ wrapper.attr('aria-label', this.containerHint);
+ } else {
+ // If we have no items, then the role and aria-owns attributes MUST be removed
+ wrapper.removeAttr('role');
+ wrapper.removeAttr('aria-owns');
+ wrapper.attr('aria-label', this.containerEmptyHint);
+ }
+};
+
+/**
+ * Apply specific roles and aria attributes for static chips
+ */
+MdChipsCtrl.prototype.setupStaticChips = function() {
+ var ctrl = this, i, staticChips;
+ var wrapper = this.$element.find('md-chips-wrap');
+
+ this.$timeout(function() {
+ wrapper.attr('role', 'list');
+ staticChips = wrapper[0].children;
+ for (i = 0; i < staticChips.length; i++) {
+ staticChips[i].setAttribute('role', 'listitem');
+ staticChips[i].setAttribute('aria-setsize', staticChips.length);
+ }
+ if (ctrl.inputAriaDescribedBy) {
+ wrapper.attr('aria-describedby', ctrl.inputAriaDescribedBy);
+ }
+ if (ctrl.inputAriaLabelledBy) {
+ wrapper.attr('aria-labelledby', ctrl.inputAriaLabelledBy);
+ wrapper.removeAttr('aria-label');
+ } else {
+ wrapper.attr('aria-label', ctrl.inputAriaLabel);
+ }
+ }, 10);
+};
+
+/**
+ * Handles the keydown event on the input element: by default <enter> appends
+ * the buffer to the chip list, while backspace removes the last chip in the
+ * list if the current buffer is empty.
+ * @param {jQuery.Event|KeyboardEvent} event
+ */
+MdChipsCtrl.prototype.inputKeydown = function(event) {
+ var chipBuffer = this.getChipBuffer();
+
+ // If we have an autocomplete, and it handled the event, we have nothing to do
+ if (this.autocompleteCtrl && event.isDefaultPrevented && event.isDefaultPrevented()) {
+ return;
+ }
+
+ if (event.keyCode === this.$mdConstant.KEY_CODE.BACKSPACE) {
+ // Only select and focus the previous chip, if the current caret position of the
+ // input element is at the beginning.
+ if (this.getCursorPosition(event.target) !== 0) {
+ return;
+ }
+
+ event.preventDefault();
+ event.stopPropagation();
+
+ if (this.items.length) {
+ this.selectAndFocusChipSafe(this.items.length - 1);
+ }
+
+ return;
+ }
+
+ // By default <enter> appends the buffer to the chip list.
+ if (!this.separatorKeys || this.separatorKeys.length < 1) {
+ this.separatorKeys = [this.$mdConstant.KEY_CODE.ENTER];
+ }
+
+ // Support additional separator key codes in an array of `md-separator-keys`.
+ if (this.separatorKeys.indexOf(event.keyCode) !== -1) {
+ if ((this.autocompleteCtrl && this.requireMatch) || !chipBuffer) return;
+ event.preventDefault();
+
+ // Only append the chip and reset the chip buffer if the max chips limit isn't reached.
+ if (this.hasMaxChipsReached()) return;
+
+ this.appendChip(chipBuffer.trim());
+ this.resetChipBuffer();
+
+ return false;
+ }
+};
+
+/**
+ * Returns the cursor position of the specified input element.
+ * @param {HTMLInputElement} element relevant input element
+ * @returns {Number} Cursor Position of the input.
+ */
+MdChipsCtrl.prototype.getCursorPosition = function(element) {
+ /*
+ * Figure out whether the current input for the chips buffer is valid for using
+ * the selectionStart / end property to retrieve the cursor position.
+ * Some browsers do not allow the use of those attributes, on different input types.
+ */
+ try {
+ if (element.selectionStart === element.selectionEnd) {
+ return element.selectionStart;
+ }
+ } catch (e) {
+ if (!element.value) {
+ return 0;
+ }
+ }
+};
+
+
+/**
+ * Updates the content of the chip at given index
+ * @param {number} chipIndex
+ * @param {string} chipContents
+ */
+MdChipsCtrl.prototype.updateChipContents = function(chipIndex, chipContents) {
+ if (chipIndex >= 0 && chipIndex < this.items.length) {
+ this.items[chipIndex] = chipContents;
+ this.updateNgModel(true);
+ }
+};
+
+
+/**
+ * @return {boolean} true if a chip is currently being edited. False otherwise.
+ */
+MdChipsCtrl.prototype.isEditingChip = function() {
+ return !!this.$element[0].querySelector('._md-chip-editing');
+};
+
+/**
+ * @param {string|Object} chip contents of a single chip
+ * @returns {boolean} true if the chip is an Object, false otherwise.
+ * @private
+ */
+MdChipsCtrl.prototype._isChipObject = function(chip) {
+ return angular.isObject(chip);
+};
+
+/**
+ * @returns {boolean} true if chips can be removed, false otherwise.
+ */
+MdChipsCtrl.prototype.isRemovable = function() {
+ // Return false if we have static chips
+ if (!this.ngModelCtrl) {
+ return false;
+ }
+
+ return this.readonly ? this.removable :
+ angular.isDefined(this.removable) ? this.removable : true;
+};
+
+/**
+ * Handles the keydown event on the chip elements: backspace removes the selected chip, arrow
+ * keys switch which chip is active.
+ * @param {KeyboardEvent} event
+ */
+MdChipsCtrl.prototype.chipKeydown = function (event) {
+ if (this.getChipBuffer()) return;
+ if (this.isEditingChip()) return;
+
+ switch (event.keyCode) {
+ case this.$mdConstant.KEY_CODE.BACKSPACE:
+ case this.$mdConstant.KEY_CODE.DELETE:
+ if (this.selectedChip < 0) return;
+ event.preventDefault();
+ // Cancel the delete action only after the event cancel. Otherwise the page will go back.
+ if (!this.isRemovable()) return;
+ this.removeAndSelectAdjacentChip(this.selectedChip, event);
+ break;
+ case this.$mdConstant.KEY_CODE.LEFT_ARROW:
+ event.preventDefault();
+ // By default, allow selection of -1 which will focus the input; if we're readonly, don't go
+ // below 0.
+ if (this.selectedChip < 0 || (this.readonly && this.selectedChip === 0)) {
+ this.selectedChip = this.items.length;
+ }
+ if (this.items.length) this.selectAndFocusChipSafe(this.selectedChip - 1);
+ break;
+ case this.$mdConstant.KEY_CODE.RIGHT_ARROW:
+ event.preventDefault();
+ this.selectAndFocusChipSafe(this.selectedChip + 1);
+ break;
+ case this.$mdConstant.KEY_CODE.ESCAPE:
+ case this.$mdConstant.KEY_CODE.TAB:
+ if (this.selectedChip < 0) return;
+ event.preventDefault();
+ this.onFocus();
+ break;
+ }
+};
+
+/**
+ * Get the input's placeholder - uses `placeholder` when list is empty and `secondary-placeholder`
+ * when the list is non-empty. If `secondary-placeholder` is not provided, `placeholder` is used
+ * always.
+ * @returns {string}
+ */
+MdChipsCtrl.prototype.getPlaceholder = function() {
+ // Allow `secondary-placeholder` to be blank.
+ var useSecondary = (this.items && this.items.length &&
+ (this.secondaryPlaceholder === '' || this.secondaryPlaceholder));
+ return useSecondary ? this.secondaryPlaceholder : this.placeholder;
+};
+
+/**
+ * Removes chip at {@code index} and selects the adjacent chip.
+ * @param {number} index adjacent chip to select
+ * @param {Event=} event
+ */
+MdChipsCtrl.prototype.removeAndSelectAdjacentChip = function(index, event) {
+ var self = this;
+ var selIndex = self.getAdjacentChipIndex(index);
+ var wrap = this.$element[0].querySelector('md-chips-wrap');
+ var chip = this.$element[0].querySelector('md-chip[index="' + index + '"]');
+
+ self.removeChip(index, event);
+
+ // The double-timeout is currently necessary to ensure that the DOM has finalized and the select()
+ // will find the proper chip since the selection is index-based.
+ //
+ // TODO: Investigate calling from within chip $scope.$on('$destroy') to reduce/remove timeouts
+ self.$timeout(function() {
+ self.$timeout(function() {
+ self.selectAndFocusChipSafe(selIndex);
+ });
+ });
+};
+
+/**
+ * Sets the selected chip index to -1.
+ */
+MdChipsCtrl.prototype.resetSelectedChip = function() {
+ this.selectedChip = -1;
+ this.ariaTabIndex = null;
+};
+
+/**
+ * Gets the index of an adjacent chip to select after deletion. Adjacency is
+ * determined as the next chip in the list, unless the target chip is the
+ * last in the list, then it is the chip immediately preceding the target. If
+ * there is only one item in the list, -1 is returned (select none).
+ * The number returned is the index to select AFTER the target has been removed.
+ * If the current chip is not selected, then -1 is returned to select none.
+ * @param {number} index
+ * @returns {number}
+ */
+MdChipsCtrl.prototype.getAdjacentChipIndex = function(index) {
+ var len = this.items.length - 1;
+ return (len === 0) ? -1 :
+ (index === len) ? index - 1 : index;
+};
+
+/**
+ * Append the contents of the buffer to the chip list. This method will first
+ * call out to the md-transform-chip method, if provided.
+ * @param {string} newChip chip buffer contents that will be used to create the new chip
+ */
+MdChipsCtrl.prototype.appendChip = function(newChip) {
+ this.shouldFocusLastChip = !this.addOnBlur;
+ if (this.useTransformChip && this.transformChip) {
+ var transformedChip = this.transformChip({'$chip': newChip});
+
+ // Check to make sure the chip is defined before assigning it, otherwise, we'll just assume
+ // they want the string version.
+ if (angular.isDefined(transformedChip)) {
+ newChip = transformedChip;
+ }
+ }
+
+ // If items contains an identical object to newChip, do not append
+ if (angular.isObject(newChip)) {
+ var identical = this.items.some(function(item) {
+ return angular.equals(newChip, item);
+ });
+ if (identical) return;
+ }
+
+ // Check for a null (but not undefined), or existing chip and cancel appending
+ if (newChip == null || this.items.indexOf(newChip) + 1) return;
+
+ // Append the new chip onto our list
+ var length = this.items.push(newChip);
+ var index = length - 1;
+
+ this.updateNgModel();
+
+ // Tell screen reader users that the chip was successfully added.
+ // TODO add a way for developers to specify which field of the object should be announced here.
+ var chipContent = angular.isObject(newChip) ? '' : newChip;
+ this.$mdLiveAnnouncer.announce(chipContent + ' ' + this.addedMessage, 'assertive');
+
+ // If the md-on-add attribute is specified, send a chip addition event
+ if (this.useOnAdd && this.onAdd) {
+ this.onAdd({ '$chip': newChip, '$index': index });
+ }
+};
+
+/**
+ * Sets whether to use the md-transform-chip expression. This expression is
+ * bound to scope and controller in {@code MdChipsDirective} as
+ * {@code transformChip}. Due to the nature of directive scope bindings, the
+ * controller cannot know on its own/from the scope whether an expression was
+ * actually provided.
+ */
+MdChipsCtrl.prototype.useTransformChipExpression = function() {
+ this.useTransformChip = true;
+};
+
+/**
+ * Sets whether to use the md-on-add expression. This expression is
+ * bound to scope and controller in {@code MdChipsDirective} as
+ * {@code onAdd}. Due to the nature of directive scope bindings, the
+ * controller cannot know on its own/from the scope whether an expression was
+ * actually provided.
+ */
+MdChipsCtrl.prototype.useOnAddExpression = function() {
+ this.useOnAdd = true;
+};
+
+/**
+ * Sets whether to use the md-on-remove expression. This expression is
+ * bound to scope and controller in {@code MdChipsDirective} as
+ * {@code onRemove}. Due to the nature of directive scope bindings, the
+ * controller cannot know on its own/from the scope whether an expression was
+ * actually provided.
+ */
+MdChipsCtrl.prototype.useOnRemoveExpression = function() {
+ this.useOnRemove = true;
+};
+
+/**
+ * Sets whether to use the md-on-select expression. This expression is
+ * bound to scope and controller in {@code MdChipsDirective} as
+ * {@code onSelect}. Due to the nature of directive scope bindings, the
+ * controller cannot know on its own/from the scope whether an expression was
+ * actually provided.
+ */
+MdChipsCtrl.prototype.useOnSelectExpression = function() {
+ this.useOnSelect = true;
+};
+
+/**
+ * Gets the input buffer. The input buffer can be the model bound to the
+ * default input item {@code this.chipBuffer}, the {@code selectedItem}
+ * model of an {@code md-autocomplete}, or, through some magic, the model
+ * bound to any input or text area element found within a
+ * {@code md-input-container} element.
+ * @return {string} the input buffer
+ */
+MdChipsCtrl.prototype.getChipBuffer = function() {
+ var chipBuffer = !this.userInputElement ? this.chipBuffer :
+ this.userInputNgModelCtrl ? this.userInputNgModelCtrl.$viewValue :
+ this.userInputElement[0].value;
+
+ // Ensure that the chip buffer is always a string. For example, the input element buffer
+ // might be falsy.
+ return angular.isString(chipBuffer) ? chipBuffer : '';
+};
+
+/**
+ * Resets the input buffer for either the internal input or user provided input element.
+ */
+MdChipsCtrl.prototype.resetChipBuffer = function() {
+ if (this.userInputElement) {
+ if (this.userInputNgModelCtrl) {
+ this.userInputNgModelCtrl.$setViewValue('');
+ this.userInputNgModelCtrl.$render();
+ } else {
+ this.userInputElement[0].value = '';
+ }
+ } else {
+ this.chipBuffer = '';
+ }
+};
+
+/**
+ * @returns {boolean} true if the max chips limit has been reached, false otherwise.
+ */
+MdChipsCtrl.prototype.hasMaxChipsReached = function() {
+ if (angular.isString(this.maxChips)) {
+ this.maxChips = parseInt(this.maxChips, 10) || 0;
+ }
+
+ return this.maxChips > 0 && this.items.length >= this.maxChips;
+};
+
+/**
+ * Updates the validity properties for the ngModel.
+ *
+ * TODO add the md-max-chips validator to this.ngModelCtrl.validators so that the validation will
+ * be performed automatically.
+ */
+MdChipsCtrl.prototype.validateModel = function() {
+ this.ngModelCtrl.$setValidity('md-max-chips', !this.hasMaxChipsReached());
+ this.ngModelCtrl.$validate(); // rerun any registered validators
+};
+
+/**
+ * Function to handle updating the model, validation, and change notification when a chip
+ * is added, removed, or changed.
+ * @param {boolean=} skipValidation true to skip calling validateModel()
+ */
+MdChipsCtrl.prototype.updateNgModel = function(skipValidation) {
+ if (!skipValidation) {
+ this.validateModel();
+ }
+ // This will trigger ng-change to fire, even in cases where $setViewValue() would not.
+ angular.forEach(this.ngModelCtrl.$viewChangeListeners, function(listener) {
+ try {
+ listener();
+ } catch (e) {
+ this.$exceptionHandler(e);
+ }
+ });
+};
+
+/**
+ * Removes the chip at the given index.
+ * @param {number} index of chip to remove
+ * @param {Event=} event optionally passed to the onRemove callback
+ */
+MdChipsCtrl.prototype.removeChip = function(index, event) {
+ var removed = this.items.splice(index, 1);
+
+ this.updateNgModel();
+ this.ngModelCtrl.$setDirty();
+
+ // Tell screen reader users that the chip was successfully removed.
+ // TODO add a way for developers to specify which field of the object should be announced here.
+ var chipContent = angular.isObject(removed[0]) ? '' : removed[0];
+ this.$mdLiveAnnouncer.announce(chipContent + ' ' + this.removedMessage, 'assertive');
+
+ if (removed && removed.length && this.useOnRemove && this.onRemove) {
+ this.onRemove({ '$chip': removed[0], '$index': index, '$event': event });
+ }
+};
+
+/**
+ * @param {number} index location of chip to remove
+ * @param {Event=} $event
+ */
+MdChipsCtrl.prototype.removeChipAndFocusInput = function (index, $event) {
+ this.removeChip(index, $event);
+
+ if (this.autocompleteCtrl) {
+ // Always hide the autocomplete dropdown before focusing the autocomplete input.
+ // Wait for the input to move horizontally, because the chip was removed.
+ // This can lead to an incorrect dropdown position.
+ this.autocompleteCtrl.hidden = true;
+ this.$mdUtil.nextTick(this.onFocus.bind(this));
+ } else {
+ this.onFocus();
+ }
+
+};
+/**
+ * Selects the chip at `index`,
+ * @param {number} index location of chip to select and focus
+ */
+MdChipsCtrl.prototype.selectAndFocusChipSafe = function(index) {
+ // If we have no chips, or are asked to select a chip before the first, just focus the input
+ if (!this.items.length || index === -1) {
+ return this.focusInput();
+ }
+
+ // If we are asked to select a chip greater than the number of chips...
+ if (index >= this.items.length) {
+ if (this.readonly) {
+ // If we are readonly, jump back to the start (because we have no input)
+ index = 0;
+ } else {
+ // If we are not readonly, we should attempt to focus the input
+ return this.onFocus();
+ }
+ }
+
+ index = Math.max(index, 0);
+ index = Math.min(index, this.items.length - 1);
+
+ this.selectChip(index);
+ this.focusChip(index);
+};
+
+/**
+ * Focus last chip, then focus the input. This is needed for screen reader support.
+ */
+MdChipsCtrl.prototype.focusLastChipThenInput = function() {
+ var ctrl = this;
+
+ ctrl.shouldFocusLastChip = false;
+
+ ctrl.focusChip(this.items.length - 1);
+
+ ctrl.$timeout(function() {
+ ctrl.focusInput();
+ }, ctrl.chipAppendDelay);
+};
+
+/**
+ * Focus the input element.
+ */
+MdChipsCtrl.prototype.focusInput = function() {
+ this.selectChip(-1);
+ this.onFocus();
+};
+
+/**
+ * Marks the chip at the given index as selected.
+ * @param {number} index location of chip to select
+ */
+MdChipsCtrl.prototype.selectChip = function(index) {
+ if (index >= -1 && index <= this.items.length) {
+ this.selectedChip = index;
+
+ // Fire the onSelect if provided
+ if (this.useOnSelect && this.onSelect) {
+ this.onSelect({'$chip': this.items[index] });
+ }
+ } else {
+ this.$log.warn('Selected Chip index out of bounds; ignoring.');
+ }
+};
+
+/**
+ * Call {@code focus()} on the chip at {@code index}
+ * @param {number} index location of chip to focus
+ */
+MdChipsCtrl.prototype.focusChip = function(index) {
+ var chipContent = this.$element[0].querySelector(
+ 'md-chip[index="' + index + '"] .md-chip-content'
+ );
+
+ this.ariaTabIndex = index;
+
+ chipContent.focus();
+};
+
+/**
+ * Configures the required interactions with the ngModel Controller.
+ * Specifically, set {@code this.items} to the {@code NgModelController#$viewValue}.
+ * @param {NgModelController} ngModelCtrl
+ */
+MdChipsCtrl.prototype.configureNgModel = function(ngModelCtrl) {
+ this.ngModelCtrl = ngModelCtrl;
+
+ var self = this;
+
+ // in chips the meaning of $isEmpty changes
+ ngModelCtrl.$isEmpty = function(value) {
+ return !value || value.length === 0;
+ };
+
+ ngModelCtrl.$render = function() {
+ // model is updated. do something.
+ self.items = self.ngModelCtrl.$viewValue;
+ };
+};
+
+MdChipsCtrl.prototype.onFocus = function () {
+ var input = this.$element[0].querySelector('input');
+ input && input.focus();
+ this.resetSelectedChip();
+};
+
+MdChipsCtrl.prototype.onInputFocus = function () {
+ this.inputHasFocus = true;
+
+ // Make sure we have the appropriate ARIA attributes
+ this.setupInputAria();
+
+ // Make sure we don't have any chips selected
+ this.resetSelectedChip();
+};
+
+MdChipsCtrl.prototype.onInputBlur = function () {
+ this.inputHasFocus = false;
+
+ if (this.shouldAddOnBlur()) {
+ this.appendChip(this.getChipBuffer().trim());
+ this.resetChipBuffer();
+ }
+};
+
+/**
+ * Configure event bindings on input element.
+ * @param {angular.element} inputElement
+ */
+MdChipsCtrl.prototype.configureInput = function configureInput(inputElement) {
+ // Find the NgModelCtrl for the input element
+ var ngModelCtrl = inputElement.controller('ngModel');
+ var ctrl = this;
+
+ if (ngModelCtrl) {
+
+ // sync touched-state from inner input to chips-element
+ this.deRegister.push(
+ this.$scope.$watch(
+ function() {
+ return ngModelCtrl.$touched;
+ },
+ function(isTouched) {
+ isTouched && ctrl.ngModelCtrl.$setTouched();
+ }
+ )
+ );
+
+ // sync dirty-state from inner input to chips-element
+ this.deRegister.push(
+ this.$scope.$watch(
+ function() {
+ return ngModelCtrl.$dirty;
+ },
+ function(isDirty) {
+ isDirty && ctrl.ngModelCtrl.$setDirty();
+ }
+ )
+ );
+ }
+};
+
+/**
+ * Configure event bindings on a user-provided input element.
+ * @param {angular.element} inputElement
+ */
+MdChipsCtrl.prototype.configureUserInput = function(inputElement) {
+ this.userInputElement = inputElement;
+
+ // Find the NgModelCtrl for the input element
+ var ngModelCtrl = inputElement.controller('ngModel');
+ // `.controller` will look in the parent as well.
+ if (ngModelCtrl !== this.ngModelCtrl) {
+ this.userInputNgModelCtrl = ngModelCtrl;
+ }
+
+ var scope = this.$scope;
+ var ctrl = this;
+
+ // Run all of the events using evalAsync because a focus may fire a blur in the same digest loop
+ var scopeApplyFn = function(event, fn) {
+ scope.$evalAsync(angular.bind(ctrl, fn, event));
+ };
+
+ // Bind to keydown and focus events of input
+ inputElement
+ .attr({ tabindex: 0 })
+ .on('keydown', function(event) { scopeApplyFn(event, ctrl.inputKeydown); })
+ .on('focus', function(event) { scopeApplyFn(event, ctrl.onInputFocus); })
+ .on('blur', function(event) { scopeApplyFn(event, ctrl.onInputBlur); });
+};
+
+/**
+ * @param {MdAutocompleteCtrl} ctrl controller from the autocomplete component
+ */
+MdChipsCtrl.prototype.configureAutocomplete = function(ctrl) {
+ if (ctrl) {
+ this.autocompleteCtrl = ctrl;
+ // Update the default container empty hint when we're inside of an autocomplete.
+ if (!this.$element.attr('container-empty-hint')) {
+ this.containerEmptyHint = 'Chips container with autocompletion. Enter the text area, ' +
+ 'type text to search, and then use the up and down arrow keys to select an option. ' +
+ 'Press enter to add the selected option as a chip.';
+ this.setupWrapperAria();
+ }
+
+ ctrl.registerSelectedItemWatcher(angular.bind(this, function (item) {
+ if (item) {
+ // Only append the chip and reset the chip buffer if the max chips limit isn't reached.
+ if (this.hasMaxChipsReached()) return;
+
+ this.appendChip(item);
+ this.resetChipBuffer();
+ }
+ }));
+
+ this.$element.find('input')
+ .on('focus',angular.bind(this, this.onInputFocus))
+ .on('blur', angular.bind(this, this.onInputBlur));
+ }
+};
+
+/**
+ * @returns {boolean} Whether the current chip buffer should be added on input blur or not.
+ */
+MdChipsCtrl.prototype.shouldAddOnBlur = function() {
+
+ // Update the custom ngModel validators from the chips component.
+ this.validateModel();
+
+ var chipBuffer = this.getChipBuffer().trim();
+ // If the model value is empty and required is set on the element, then the model will be invalid.
+ // In that case, we still want to allow adding the chip. The main (but not only) case we want
+ // to disallow is adding a chip on blur when md-max-chips validation fails.
+ var isModelValid = this.ngModelCtrl.$isEmpty(this.ngModelCtrl.$modelValue) ||
+ this.ngModelCtrl.$valid;
+ var isAutocompleteShowing = this.autocompleteCtrl && !this.autocompleteCtrl.hidden;
+
+ if (this.userInputNgModelCtrl) {
+ isModelValid = isModelValid && this.userInputNgModelCtrl.$valid;
+ }
+
+ return this.addOnBlur && !this.requireMatch && chipBuffer && isModelValid &&
+ !isAutocompleteShowing;
+};
+
+/**
+ * @returns {boolean} true if the input or a chip is focused. False otherwise.
+ */
+MdChipsCtrl.prototype.hasFocus = function () {
+ return this.inputHasFocus || this.selectedChip >= 0;
+};
+
+/**
+ * @param {number} index location of content id
+ * @returns {number} unique id for the aria-owns attribute
+ */
+MdChipsCtrl.prototype.contentIdFor = function(index) {
+ return this.contentIds[index];
+};
+
+})();
+(function(){
+"use strict";
+
+
+ MdChips.$inject = ["$mdTheming", "$mdUtil", "$compile", "$log", "$timeout", "$$mdSvgRegistry"];angular
+ .module('material.components.chips')
+ .directive('mdChips', MdChips);
+
+ /**
+ * @ngdoc directive
+ * @name mdChips
+ * @module material.components.chips
+ *
+ * @description
+ * `<md-chips>` is an input component for building lists of strings or objects. The list items are
+ * displayed as 'chips'. This component can make use of an `<input>` element or an
+ * `<md-autocomplete>` element.
+ *
+ * ### Custom templates
+ * A custom template may be provided to render the content of each chip. This is achieved by
+ * specifying an `<md-chip-template>` element containing the custom content as a child of
+ * `<md-chips>`.
+ *
+ * Note: Any attributes on
+ * `<md-chip-template>` will be dropped as only the innerHTML is used for the chip template. The
+ * variables `$chip` and `$index` are available in the scope of `<md-chip-template>`, representing
+ * the chip object and its index in the list of chips, respectively.
+ * To override the chip delete control, include an element (ideally a button) with the attribute
+ * `md-chip-remove`. A click listener to remove the chip will be added automatically. The element
+ * is also placed as a sibling to the chip content (on which there are also click listeners) to
+ * avoid a nested ng-click situation.
+ *
+ * <!-- Note: We no longer want to include this in the site docs; but it should remain here for
+ * future developers and those looking at the documentation.
+ *
+ * <h3> Pending Features </h3>
+ * <ul style="padding-left:20px;">
+ *
+ * <ul>Style
+ * <li>Colors for hover, press states (ripple?).</li>
+ * </ul>
+ *
+ * <ul>Validation
+ * <li>allow a validation callback</li>
+ * <li>highlighting style for invalid chips</li>
+ * </ul>
+ *
+ * <ul>Item mutation
+ * <li>Support `
+ * <md-chip-edit>` template, show/hide the edit element on tap/click? double tap/double
+ * click?
+ * </li>
+ * </ul>
+ *
+ * <ul>Truncation and Disambiguation (?)
+ * <li>Truncate chip text where possible, but do not truncate entries such that two are
+ * indistinguishable.</li>
+ * </ul>
+ *
+ * <ul>Drag and Drop
+ * <li>Drag and drop chips between related `<md-chips>` elements.
+ * </li>
+ * </ul>
+ * </ul>
+ *
+ * //-->
+ *
+ * Sometimes developers want to limit the amount of possible chips.<br/>
+ * You can specify the maximum amount of chips by using the following markup.
+ *
+ * <hljs lang="html">
+ * <md-chips
+ * ng-model="myItems"
+ * placeholder="Add an item"
+ * md-max-chips="5">
+ * </md-chips>
+ * </hljs>
+ *
+ * In some cases, you have an autocomplete inside of the `md-chips`.<br/>
+ * When the maximum amount of chips has been reached, you can also disable the autocomplete
+ * selection.<br/>
+ * Here is an example markup.
+ *
+ * <hljs lang="html">
+ * <md-chips ng-model="myItems" md-max-chips="5">
+ * <md-autocomplete ng-hide="myItems.length > 5" ...></md-autocomplete>
+ * </md-chips>
+ * </hljs>
+ *
+ * ### Accessibility
+ *
+ * The `md-chips` component supports keyboard and screen reader users since Version 1.1.2. In
+ * order to achieve this, we modified the chips behavior to select newly appended chips for
+ * `300ms` before re-focusing the input and allowing the user to type.
+ *
+ * For most users, this delay is small enough that it will not be noticeable but allows certain
+ * screen readers to function properly (JAWS and NVDA in particular).
+ *
+ * We introduced a new `md-chip-append-delay` option to allow developers to better control this
+ * behavior.
+ *
+ * Please refer to the documentation of this option (below) for more information.
+ *
+ * @param {expression} ng-model Assignable AngularJS expression to be data-bound to the list of
+ * chips. The expression should evaluate to a `string` or `Object` Array. The type of this
+ * array should align with the return value of `md-transform-chip`.
+ * @param {expression=} ng-change AngularJS expression to be executed on chip addition, removal,
+ * or content change.
+ * @param {string=} placeholder Placeholder text that will be forwarded to the input.
+ * @param {string=} secondary-placeholder Placeholder text that will be forwarded to the input,
+ * displayed when there is at least one item in the list
+ * @param {boolean=} md-removable Enables or disables the deletion of chips through the
+ * removal icon or the Delete/Backspace key. Defaults to true.
+ * @param {boolean=} readonly Disables list manipulation (deleting or adding list items), hiding
+ * the input and delete buttons. If no `ng-model` is provided, the chips will automatically be
+ * marked as readonly.<br/><br/>
+ * When `md-removable` is not defined, the `md-remove` behavior will be overwritten and
+ * disabled.
+ * @param {boolean=} md-enable-chip-edit Set this to `"true"` to enable editing of chip contents.
+ * The user can go into edit mode by pressing the `space` or `enter` keys, or by double
+ * clicking on the chip. Chip editing is only supported for chips using the basic template.
+ * **Note:** This attribute is only evaluated once; it is not watched.
+ * @param {boolean=} ng-required Whether ng-model is allowed to be empty or not.
+ * @param {number=} md-max-chips The maximum number of chips allowed to add through user input.
+ * <br/><br/>The validation property `md-max-chips` can be used when the max chips
+ * amount is reached.
+ * @param {boolean=} md-add-on-blur When set to `"true"`, the remaining text inside of the input
+ * will be converted into a new chip on blur.
+ * **Note:** This attribute is only evaluated once; it is not watched.
+ * @param {expression} md-transform-chip An expression of form `myFunction($chip)` that when
+ * called expects one of the following return values:
+ * - an object representing the `$chip` input string
+ * - `undefined` to simply add the `$chip` input string, or
+ * - `null` to prevent the chip from being appended
+ * @param {expression=} md-on-add An expression which will be called when a chip has been
+ * added with `$chip` and `$index` available as parameters.
+ * @param {expression=} md-on-remove An expression which will be called when a chip has been
+ * removed with `$chip`, `$index`, and `$event` available as parameters.
+ * @param {expression=} md-on-select An expression which will be called when a chip is selected.
+ * @param {boolean=} md-require-match If true, and the chips template contains an autocomplete,
+ * only allow selection of pre-defined chips (i.e. you cannot add new ones).
+ * @param {string=} md-input-class This class will be applied to the child input for custom
+ * styling. If you are using an `md-autocomplete`, then you need to put this attribute on the
+ * `md-autocomplete` rather than the `md-chips`.
+ * @param {string=} input-aria-describedby A space-separated list of element IDs. This should
+ * contain the IDs of any elements that describe this autocomplete. Screen readers will read
+ * the content of these elements at the end of announcing that the chips input has been
+ * selected and describing its current state. The descriptive elements do not need to be
+ * visible on the page.
+ * @param {string=} input-aria-labelledby A space-separated list of element IDs. The ideal use
+ * case is that this would contain the ID of a `<label>` element that is associated with these
+ * chips.<br><br>
+ * For `<label id="state">US State</label>`, you would set this to
+ * `input-aria-labelledby="state"`.
+ * @param {string=} input-aria-label A string read by screen readers to identify the input.
+ * For static chips, this will be applied to the chips container.
+ * @param {string=} container-hint A string read by screen readers informing users of how to
+ * navigate the chips when there are chips. Only applies when `ng-model` is defined.
+ * @param {string=} container-empty-hint A string read by screen readers informing users of how to
+ * add chips when there are no chips. You will want to use this to override the default when
+ * in a non-English locale. Only applies when `ng-model` is defined.
+ * @param {string=} delete-hint A string read by screen readers instructing users that pressing
+ * the delete key will remove the chip. You will want to use this to override the default when
+ * in a non-English locale.
+ * @param {string=} delete-button-label Text for the `aria-label` of the button with the
+ * `md-chip-remove` class. If the chip is an Object, then this will be the only text in the
+ * label. Otherwise, this is prepended to the string representation of the chip. Defaults to
+ * "Remove", which would be "Remove Apple" for a chip that contained the string "Apple".
+ * You will want to use this to override the default when in a non-English locale.
+ * @param {string=} md-removed-message Screen readers will announce this message following the
+ * chips contents. The default is `"removed"`. If a chip with the content of "Apple" was
+ * removed, the screen reader would read "Apple removed". You will want to use this to override
+ * the default when in a non-English locale.
+ * @param {string=} md-added-message Screen readers will announce this message following the
+ * chips contents. The default is `"added"`. If a chip with the content of "Apple" was
+ * created, the screen reader would read "Apple added". You will want to use this to override
+ * the default when in a non-English locale.
+ * @param {expression=} md-separator-keys An array of key codes used to separate chips.
+ * @param {string=} md-chip-append-delay The number of milliseconds that the component will select
+ * a newly appended chip before allowing a user to type into the input. This is **necessary**
+ * for keyboard accessibility for screen readers. It defaults to 300ms and any number less than
+ * 300 can cause issues with screen readers (particularly JAWS and sometimes NVDA).
+ *
+ * _Available since Version 1.1.2._
+ *
+ * **Note:** You can safely set this to `0` in one of the following two instances:
+ *
+ * 1. You are targeting an iOS or Safari-only application (where users would use VoiceOver) or
+ * only ChromeVox users.
+ *
+ * 2. If you have utilized the `md-separator-keys` to disable the `enter` keystroke in
+ * favor of another one (such as `,` or `;`).
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-chips
+ * ng-model="myItems"
+ * placeholder="Add an item"
+ * readonly="isReadOnly">
+ * </md-chips>
+ * </hljs>
+ *
+ * <h3>Validation</h3>
+ * When using [ngMessages](https://docs.angularjs.org/api/ngMessages), you can show errors based
+ * on our custom validators.
+ * <hljs lang="html">
+ * <form name="userForm">
+ * <md-chips
+ * name="fruits"
+ * ng-model="myItems"
+ * placeholder="Add an item"
+ * md-max-chips="5">
+ * </md-chips>
+ * <div ng-messages="userForm.fruits.$error" ng-if="userForm.$dirty">
+ * <div ng-message="md-max-chips">You reached the maximum amount of chips</div>
+ * </div>
+ * </form>
+ * </hljs>
+ *
+ */
+
+ // TODO add a way for developers to specify which field of the object should used in the
+ // aria-label.
+ var MD_CHIPS_TEMPLATE = '\
+ <md-chips-wrap\
+ id="{{$mdChipsCtrl.wrapperId}}"\
+ tabindex="{{$mdChipsCtrl.readonly ? 0 : -1}}"\
+ ng-keydown="$mdChipsCtrl.chipKeydown($event)"\
+ ng-class="{ \'md-focused\': $mdChipsCtrl.hasFocus(), \
+ \'md-readonly\': !$mdChipsCtrl.ngModelCtrl || $mdChipsCtrl.readonly,\
+ \'md-removable\': $mdChipsCtrl.isRemovable() }"\
+ class="md-chips">\
+ <md-chip ng-repeat="$chip in $mdChipsCtrl.items"\
+ index="{{$index}}" \
+ ng-class="{\'md-focused\': $mdChipsCtrl.selectedChip == $index, \'md-readonly\': !$mdChipsCtrl.ngModelCtrl || $mdChipsCtrl.readonly}">\
+ <div class="md-chip-content"\
+ tabindex="{{$mdChipsCtrl.ariaTabIndex === $index ? 0 : -1}}"\
+ id="{{$mdChipsCtrl.contentIdFor($index)}}"\
+ role="option"\
+ aria-selected="{{$mdChipsCtrl.selectedChip === $index}}"\
+ aria-setsize="{{$mdChipsCtrl.items.length}}"\
+ aria-posinset="{{$index+1}}"\
+ ng-click="!$mdChipsCtrl.readonly && $mdChipsCtrl.focusChip($index)"\
+ aria-label="{{$mdChipsCtrl._isChipObject($chip) ? \'\' : $chip + \'. \'}}{{$mdChipsCtrl.isRemovable() ? \'\' + $mdChipsCtrl.deleteHint : \'\'}}" \
+ ng-focus="!$mdChipsCtrl.readonly && $mdChipsCtrl.selectChip($index)"\
+ md-chip-transclude="$mdChipsCtrl.chipContentsTemplate"></div>\
+ <div ng-if="$mdChipsCtrl.isRemovable()"\
+ class="md-chip-remove-container"\
+ tabindex="-1"\
+ md-chip-transclude="$mdChipsCtrl.chipRemoveTemplate"></div>\
+ </md-chip>\
+ <div class="md-chip-input-container" ng-if="!$mdChipsCtrl.readonly && $mdChipsCtrl.ngModelCtrl">\
+ <div md-chip-transclude="$mdChipsCtrl.chipInputTemplate"></div>\
+ </div>\
+ </md-chips-wrap>';
+
+ var CHIP_INPUT_TEMPLATE = '\
+ <input\
+ class="md-input{{ $mdChipsCtrl.inputClass ? \' \' + $mdChipsCtrl.inputClass: \'\'}}"\
+ tabindex="0"\
+ aria-label="{{$mdChipsCtrl.inputAriaLabel}}"\
+ placeholder="{{$mdChipsCtrl.getPlaceholder()}}"\
+ ng-model="$mdChipsCtrl.chipBuffer"\
+ ng-focus="$mdChipsCtrl.onInputFocus()"\
+ ng-blur="$mdChipsCtrl.onInputBlur()"\
+ ng-keydown="$mdChipsCtrl.inputKeydown($event)">';
+
+ var CHIP_DEFAULT_TEMPLATE = '\
+ <span>{{$chip}}</span>';
+
+ var CHIP_REMOVE_TEMPLATE = '\
+ <button\
+ class="md-chip-remove"\
+ ng-if="$mdChipsCtrl.isRemovable()"\
+ ng-click="$mdChipsCtrl.removeChipAndFocusInput($$replacedScope.$index, $event)"\
+ type="button"\
+ tabindex="-1"\
+ aria-label="{{$mdChipsCtrl.deleteButtonLabel}}{{$mdChipsCtrl._isChipObject($chip) ? \'\' : \' \' + $chip}}">\
+ <md-icon md-svg-src="{{$mdChipsCtrl.mdCloseIcon}}" aria-hidden="true"></md-icon>\
+ </button>';
+
+ /**
+ * MDChips Directive Definition
+ */
+ function MdChips ($mdTheming, $mdUtil, $compile, $log, $timeout, $$mdSvgRegistry) {
+ // Run our templates through $mdUtil.processTemplate() to allow custom start/end symbols
+ var templates = getTemplates();
+
+ return {
+ template: function(element, attrs) {
+ // Clone the element into an attribute. By prepending the attribute
+ // name with '$', AngularJS won't write it into the DOM. The cloned
+ // element propagates to the link function via the attrs argument,
+ // where various contained-elements can be consumed.
+ attrs['$mdUserTemplate'] = element.clone();
+ return templates.chips;
+ },
+ require: ['mdChips'],
+ restrict: 'E',
+ controller: 'MdChipsCtrl',
+ controllerAs: '$mdChipsCtrl',
+ bindToController: true,
+ compile: compile,
+ scope: {
+ readonly: '=?readonly',
+ removable: '=?mdRemovable',
+ placeholder: '@?',
+ secondaryPlaceholder: '@?',
+ maxChips: '@?mdMaxChips',
+ transformChip: '&mdTransformChip',
+ onAdd: '&?mdOnAdd',
+ onRemove: '&?mdOnRemove',
+ addedMessage: '@?mdAddedMessage',
+ removedMessage: '@?mdRemovedMessage',
+ onSelect: '&?mdOnSelect',
+ inputClass: '@?mdInputClass',
+ inputAriaDescribedBy: '@?inputAriaDescribedby',
+ inputAriaLabelledBy: '@?inputAriaLabelledby',
+ inputAriaLabel: '@?',
+ containerHint: '@?',
+ containerEmptyHint: '@?',
+ deleteHint: '@?',
+ deleteButtonLabel: '@?',
+ separatorKeys: '=?mdSeparatorKeys',
+ requireMatch: '=?mdRequireMatch',
+ chipAppendDelayString: '@?mdChipAppendDelay',
+ ngChange: '&?'
+ }
+ };
+
+ /**
+ * Builds the final template for `md-chips` and returns the postLink function.
+ *
+ * Building the template involves 3 key components:
+ * static chips
+ * chip template
+ * input control
+ *
+ * If no `ng-model` is provided, only the static chip work needs to be done.
+ *
+ * If no user-passed `md-chip-template` exists, the default template is used. This resulting
+ * template is appended to the chip content element.
+ *
+ * The remove button may be overridden by passing an element with an md-chip-remove attribute.
+ *
+ * If an `input` or `md-autocomplete` element is provided by the caller, it is set aside for
+ * transclusion later. The transclusion happens in `postLink` as the parent scope is required.
+ * If no user input is provided, a default one is appended to the input container node in the
+ * template.
+ *
+ * Static Chips (i.e. `md-chip` elements passed from the caller) are gathered and set aside for
+ * transclusion in the `postLink` function.
+ *
+ *
+ * @param element
+ * @param attr
+ * @returns {Function}
+ */
+ function compile(element, attr) {
+ // Grab the user template from attr and reset the attribute to null.
+ var userTemplate = attr['$mdUserTemplate'];
+ attr['$mdUserTemplate'] = null;
+
+ var chipTemplate = getTemplateByQuery('md-chips>md-chip-template');
+
+ var chipRemoveSelector = $mdUtil
+ .prefixer()
+ .buildList('md-chip-remove')
+ .map(function(attr) {
+ return 'md-chips>*[' + attr + ']';
+ })
+ .join(',');
+
+ // Set the chip remove, chip contents and chip input templates. The link function will put
+ // them on the scope for transclusion later.
+ var chipRemoveTemplate = getTemplateByQuery(chipRemoveSelector) || templates.remove,
+ chipContentsTemplate = chipTemplate || templates.default,
+ chipInputTemplate = getTemplateByQuery('md-chips>md-autocomplete')
+ || getTemplateByQuery('md-chips>input')
+ || templates.input,
+ staticChips = userTemplate.find('md-chip');
+
+ // Warn of malformed template. See #2545
+ if (userTemplate[0].querySelector('md-chip-template>*[md-chip-remove]')) {
+ $log.warn('invalid placement of md-chip-remove within md-chip-template.');
+ }
+
+ function getTemplateByQuery (query) {
+ if (!attr.ngModel) return;
+ var element = userTemplate[0].querySelector(query);
+ return element && element.outerHTML;
+ }
+
+ /**
+ * Configures controller and transcludes.
+ */
+ return function postLink(scope, element, attrs, controllers) {
+ $mdUtil.initOptionalProperties(scope, attr);
+
+ $mdTheming(element);
+ var mdChipsCtrl = controllers[0];
+ if (chipTemplate) {
+ // Chip editing functionality assumes we are using the default chip template.
+ mdChipsCtrl.enableChipEdit = false;
+ }
+
+ mdChipsCtrl.chipContentsTemplate = chipContentsTemplate;
+ mdChipsCtrl.chipRemoveTemplate = chipRemoveTemplate;
+ mdChipsCtrl.chipInputTemplate = chipInputTemplate;
+
+ mdChipsCtrl.mdCloseIcon = $$mdSvgRegistry.mdCancel;
+
+ element
+ .attr({ tabindex: -1 })
+ .on('focus', function () { mdChipsCtrl.onFocus(); })
+ .on('click', function () {
+ if (!mdChipsCtrl.readonly && mdChipsCtrl.selectedChip === -1) {
+ mdChipsCtrl.onFocus();
+ }
+ });
+
+ if (attr.ngModel) {
+ mdChipsCtrl.configureNgModel(element.controller('ngModel'));
+
+ // If an `md-transform-chip` attribute was set, tell the controller to use the expression
+ // before appending chips.
+ if (attrs.mdTransformChip) mdChipsCtrl.useTransformChipExpression();
+
+ // If an `md-on-add` attribute was set, tell the controller to use the expression
+ // when adding chips.
+ if (attrs.mdOnAdd) mdChipsCtrl.useOnAddExpression();
+
+ // If an `md-on-remove` attribute was set, tell the controller to use the expression
+ // when removing chips.
+ if (attrs.mdOnRemove) mdChipsCtrl.useOnRemoveExpression();
+
+ // If an `md-on-select` attribute was set, tell the controller to use the expression
+ // when selecting chips.
+ if (attrs.mdOnSelect) mdChipsCtrl.useOnSelectExpression();
+
+ // The md-autocomplete and input elements won't be compiled until after this directive
+ // is complete (due to their nested nature). Wait a tick before looking for them to
+ // configure the controller.
+ if (chipInputTemplate !== templates.input) {
+ // The autocomplete will not appear until the readonly attribute is not true (i.e.
+ // false or undefined), so we have to watch the readonly and then on the next tick
+ // after the chip transclusion has run, we can configure the autocomplete and user
+ // input.
+ scope.$watch('$mdChipsCtrl.readonly', function(readonly) {
+ if (!readonly) {
+
+ $mdUtil.nextTick(function(){
+
+ if (chipInputTemplate.indexOf('<md-autocomplete') === 0) {
+ var autocompleteEl = element.find('md-autocomplete');
+ mdChipsCtrl.configureAutocomplete(autocompleteEl.controller('mdAutocomplete'));
+ }
+
+ mdChipsCtrl.configureUserInput(element.find('input'));
+ });
+ }
+ });
+ }
+
+ // At the next tick, if we find an input, make sure it has the md-input class
+ $mdUtil.nextTick(function() {
+ var input = element.find('input');
+
+ if (input) {
+ mdChipsCtrl.configureInput(input);
+ input.toggleClass('md-input', true);
+ }
+ });
+ }
+
+ // Compile with the parent's scope and prepend any static chips to the wrapper.
+ if (staticChips.length > 0) {
+ var compiledStaticChips = $compile(staticChips.clone())(scope.$parent);
+ $timeout(function() { element.find('md-chips-wrap').prepend(compiledStaticChips); });
+ }
+ };
+ }
+
+ function getTemplates() {
+ return {
+ chips: $mdUtil.processTemplate(MD_CHIPS_TEMPLATE),
+ input: $mdUtil.processTemplate(CHIP_INPUT_TEMPLATE),
+ default: $mdUtil.processTemplate(CHIP_DEFAULT_TEMPLATE),
+ remove: $mdUtil.processTemplate(CHIP_REMOVE_TEMPLATE)
+ };
+ }
+ }
+
+})();
+(function(){
+"use strict";
+
+
+MdContactChipsCtrl.$inject = ["$attrs", "$element", "$timeout"];angular
+ .module('material.components.chips')
+ .controller('MdContactChipsCtrl', MdContactChipsCtrl);
+
+/**
+ * Controller for the MdContactChips component
+ * @constructor
+ */
+function MdContactChipsCtrl ($attrs, $element, $timeout) {
+ /** @type {$element} */
+ this.$element = $element;
+
+ /** @type {$attrs} */
+ this.$attrs = $attrs;
+
+ /** @type {Function} */
+ this.$timeout = $timeout;
+
+ /** @type {Object} */
+ this.selectedItem = null;
+
+ /** @type {string} */
+ this.searchText = '';
+
+ /**
+ * Collection of functions to call to un-register watchers
+ * @type {Array}
+ */
+ this.deRegister = [];
+
+ this.init();
+}
+
+MdContactChipsCtrl.prototype.init = function() {
+ var ctrl = this;
+ var deRegister = this.deRegister;
+ var element = this.$element;
+
+ // Setup a watcher which manages chips a11y messages and autocomplete aria.
+ // Timeout required to allow the child elements to be compiled.
+ this.$timeout(function() {
+ deRegister.push(
+ element.find('md-chips').controller('mdChips').$scope.$watchCollection('$mdChipsCtrl.items', function() {
+ // Make sure our input and wrapper have the correct ARIA attributes
+ ctrl.setupChipsAria();
+ ctrl.setupAutocompleteAria();
+ })
+ );
+ });
+};
+
+MdContactChipsCtrl.prototype.setupChipsAria = function() {
+ var chips = this.$element.find('md-chips');
+ var chipsCtrl = chips.controller('mdChips');
+
+ // Configure MdChipsCtrl
+ if (this.removedMessage) {
+ chipsCtrl.removedMessage = this.removedMessage;
+ }
+ if (this.containerHint) {
+ chipsCtrl.containerHint = this.containerHint;
+ }
+ if (this.containerEmptyHint) {
+ // Apply attribute to avoid the hint being overridden by MdChipsCtrl.configureAutocomplete()
+ chips.attr('container-empty-hint', this.containerEmptyHint);
+ chipsCtrl.containerEmptyHint = this.containerEmptyHint;
+ }
+ if (this.deleteHint) {
+ chipsCtrl.deleteHint = this.deleteHint;
+ }
+ if (this.inputAriaLabel) {
+ chipsCtrl.inputAriaLabel = this.inputAriaLabel;
+ }
+ if (this.inputClass) {
+ chipsCtrl.inputClass = this.inputClass;
+ }
+};
+
+MdContactChipsCtrl.prototype.setupAutocompleteAria = function() {
+ var autocompleteInput = this.$element.find('md-chips-wrap').find('md-autocomplete').find('input');
+
+ // Set attributes on the input of the md-autocomplete
+ if (this.inputAriaDescribedBy) {
+ autocompleteInput.attr('aria-describedby', this.inputAriaDescribedBy);
+ }
+ if (this.inputAriaLabelledBy) {
+ autocompleteInput.removeAttr('aria-label');
+ autocompleteInput.attr('aria-labelledby', this.inputAriaLabelledBy);
+ }
+};
+
+MdContactChipsCtrl.prototype.queryContact = function(searchText) {
+ return this.contactQuery({'$query': searchText});
+};
+
+MdContactChipsCtrl.prototype.inputKeydown = function(event) {
+ if (!this.separatorKeys || this.separatorKeys.indexOf(event.keyCode) < 0) {
+ return;
+ }
+
+ event.stopPropagation();
+ event.preventDefault();
+
+ var autocompleteCtrl = angular.element(event.target).controller('mdAutocomplete');
+ autocompleteCtrl.select(autocompleteCtrl.index);
+};
+
+MdContactChipsCtrl.prototype.itemName = function(item) {
+ return item[this.contactName];
+};
+
+/**
+ * Destructor for cleanup
+ */
+MdContactChipsCtrl.prototype.$onDestroy = function $onDestroy() {
+ var $destroyFn;
+ while (($destroyFn = this.deRegister.pop())) {
+ $destroyFn.call(this);
+ }
+};
+
+})();
+(function(){
+"use strict";
+
+
+MdContactChips.$inject = ["$mdTheming", "$mdUtil"];angular
+ .module('material.components.chips')
+ .directive('mdContactChips', MdContactChips);
+
+/**
+ * @ngdoc directive
+ * @name mdContactChips
+ * @module material.components.chips
+ *
+ * @description
+ * `<md-contact-chips>` is an input component based on `md-chips` and makes use of an
+ * `md-autocomplete` element. The component allows the caller to supply a query expression which
+ * returns a list of possible contacts. The user can select one of these and add it to the list of
+ * chips.
+ *
+ * You may also use the <a ng-href="api/directive/mdHighlightText">md-highlight-flags</a> attribute
+ * along with its parameters to control the appearance of the matched text inside of the contacts'
+ * autocomplete popup.
+ *
+ * @param {expression} ng-model Assignable AngularJS expression to be data-bound to the list of
+ * contact chips. The expression should evaluate to an `Object` Array.
+ * @param {expression=} ng-change AngularJS expression to be executed on chip addition, removal,
+ * or content change.
+ * @param {string=} placeholder Placeholder text that will be forwarded to the input.
+ * @param {string=} secondary-placeholder Placeholder text that will be forwarded to the input,
+ * displayed when there is at least on item in the list
+ * @param {expression} md-contacts An expression expected to return contacts matching the search
+ * test, `$query`. If this expression involves a promise, a loading bar is displayed while
+ * waiting for it to resolve.
+ * @param {string} md-contact-name The field name of the contact object representing the
+ * contact's name.
+ * @param {string} md-contact-email The field name of the contact object representing the
+ * contact's email address.
+ * @param {string} md-contact-image The field name of the contact object representing the
+ * contact's image.
+ * @param {number=} md-max-chips The maximum number of chips allowed to add through user input.
+ * <br/><br/>The validation property `md-max-chips` can be used when the max chips
+ * amount is reached.
+ * @param {number=} md-min-length Specifies the minimum length of text before autocomplete will
+ * make suggestions
+ * @param {string=} md-input-class This class will be applied to the child `md-autocomplete` for
+ * custom styling.
+ * @param {string=} input-aria-describedby A space-separated list of element IDs. This should
+ * contain the IDs of any elements that describe this autocomplete. Screen readers will read
+ * the content of these elements at the end of announcing that the chips input has been
+ * selected and describing its current state. The descriptive elements do not need to be
+ * visible on the page.
+ * @param {string=} input-aria-labelledby A space-separated list of element IDs. The ideal use
+ * case is that this would contain the ID of a `<label>` element that is associated with these
+ * chips.<br><br>
+ * For `<label id="state">US State</label>`, you would set this to
+ * `input-aria-labelledby="state"`.
+ * @param {string=} input-aria-label A string read by screen readers to identify the input.
+ * For static chips, this will be applied to the chips container.
+ * @param {string=} container-hint A string read by screen readers informing users of how to
+ * navigate the chips when there are chips.
+ * @param {string=} container-empty-hint A string read by screen readers informing users of how to
+ * add chips when there are no chips. You will want to use this to override the default when
+ * in a non-English locale.
+ * @param {string=} delete-hint A string read by screen readers instructing users that pressing
+ * the delete key will remove the chip. You will want to use this to override the default when
+ * in a non-English locale.
+ * @param {string=} md-removed-message Screen readers will announce this message following the
+ * chips contents. The default is `"removed"`. If a chip with the content of "Apple" was
+ * removed, the screen reader would read "Apple removed". You will want to use this to override
+ * the default when in a non-English locale.
+ *
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-contact-chips
+ * ng-model="ctrl.contacts"
+ * md-contacts="ctrl.querySearch($query)"
+ * md-contact-name="name"
+ * md-contact-image="image"
+ * md-contact-email="email"
+ * placeholder="To">
+ * </md-contact-chips>
+ * </hljs>
+ *
+ */
+
+
+var MD_CONTACT_CHIPS_TEMPLATE = '\
+ <md-chips class="md-contact-chips"\
+ ng-model="$mdContactChipsCtrl.contacts"\
+ ng-change="$mdContactChipsCtrl.ngChange($mdContactChipsCtrl.contacts)"\
+ md-require-match="$mdContactChipsCtrl.requireMatch"\
+ md-max-chips="{{$mdContactChipsCtrl.maxChips}}"\
+ md-chip-append-delay="{{$mdContactChipsCtrl.chipAppendDelay}}"\
+ md-separator-keys="$mdContactChipsCtrl.separatorKeys"\
+ md-autocomplete-snap>\
+ <md-autocomplete\
+ md-menu-class="md-contact-chips-suggestions"\
+ md-selected-item="$mdContactChipsCtrl.selectedItem"\
+ md-search-text="$mdContactChipsCtrl.searchText"\
+ md-items="item in $mdContactChipsCtrl.queryContact($mdContactChipsCtrl.searchText)"\
+ md-item-text="$mdContactChipsCtrl.itemName(item)"\
+ md-no-cache="true"\
+ md-min-length="$mdContactChipsCtrl.minLength"\
+ md-autoselect\
+ ng-attr-md-input-class="{{$mdContactChipsCtrl.inputClass}}"\
+ ng-keydown="$mdContactChipsCtrl.inputKeydown($event)"\
+ placeholder="{{$mdContactChipsCtrl.contacts.length === 0 ?\
+ $mdContactChipsCtrl.placeholder : $mdContactChipsCtrl.secondaryPlaceholder}}">\
+ <div class="md-contact-suggestion">\
+ <img \
+ ng-src="{{item[$mdContactChipsCtrl.contactImage]}}"\
+ alt="{{item[$mdContactChipsCtrl.contactName]}}"\
+ ng-if="item[$mdContactChipsCtrl.contactImage]" />\
+ <span class="md-contact-name" md-highlight-text="$mdContactChipsCtrl.searchText"\
+ md-highlight-flags="{{$mdContactChipsCtrl.highlightFlags}}">\
+ {{item[$mdContactChipsCtrl.contactName]}}\
+ </span>\
+ <span class="md-contact-email" >{{item[$mdContactChipsCtrl.contactEmail]}}</span>\
+ </div>\
+ </md-autocomplete>\
+ <md-chip-template>\
+ <div class="md-contact-avatar">\
+ <img \
+ ng-src="{{$chip[$mdContactChipsCtrl.contactImage]}}"\
+ alt="{{$chip[$mdContactChipsCtrl.contactName]}}"\
+ ng-if="$chip[$mdContactChipsCtrl.contactImage]" />\
+ </div>\
+ <div class="md-contact-name">\
+ {{$chip[$mdContactChipsCtrl.contactName]}}\
+ </div>\
+ </md-chip-template>\
+ </md-chips>';
+
+
+/**
+ * MDContactChips Directive Definition
+ *
+ * @param $mdTheming
+ * @param $mdUtil
+ * @returns {*}
+ * @ngInject
+ */
+function MdContactChips($mdTheming, $mdUtil) {
+ return {
+ template: function(element, attrs) {
+ return MD_CONTACT_CHIPS_TEMPLATE;
+ },
+ restrict: 'E',
+ controller: 'MdContactChipsCtrl',
+ controllerAs: '$mdContactChipsCtrl',
+ bindToController: true,
+ compile: compile,
+ scope: {
+ contactQuery: '&mdContacts',
+ placeholder: '@?',
+ secondaryPlaceholder: '@?',
+ contactName: '@mdContactName',
+ contactImage: '@mdContactImage',
+ contactEmail: '@mdContactEmail',
+ contacts: '=ngModel',
+ ngChange: '&?',
+ requireMatch: '=?mdRequireMatch',
+ minLength: '=?mdMinLength',
+ maxChips: '=?mdMaxChips',
+ highlightFlags: '@?mdHighlightFlags',
+ chipAppendDelay: '@?mdChipAppendDelay',
+ separatorKeys: '=?mdSeparatorKeys',
+ removedMessage: '@?mdRemovedMessage',
+ inputClass: '@?mdInputClass',
+ inputAriaDescribedBy: '@?inputAriaDescribedby',
+ inputAriaLabelledBy: '@?inputAriaLabelledby',
+ inputAriaLabel: '@?',
+ containerHint: '@?',
+ containerEmptyHint: '@?',
+ deleteHint: '@?'
+ }
+ };
+
+ function compile(element, attr) {
+ return function postLink(scope, element, attrs, controllers) {
+ var contactChipsController = controllers;
+
+ $mdUtil.initOptionalProperties(scope, attr);
+ $mdTheming(element);
+
+ element.attr('tabindex', '-1');
+
+ attrs.$observe('mdChipAppendDelay', function(newValue) {
+ contactChipsController.chipAppendDelay = newValue;
+ });
+ };
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+(function () {
+ "use strict";
+
+ /**
+ * Use a RegExp to check if the `md-colors="<expression>"` is static string
+ * or one that should be observed and dynamically interpolated.
+ */
+ MdColorsDirective.$inject = ["$mdColors", "$mdUtil", "$log", "$parse"];
+ MdColorsService.$inject = ["$mdTheming", "$mdUtil", "$log"];
+ var STATIC_COLOR_EXPRESSION = /^{((\s|,)*?["'a-zA-Z-]+?\s*?:\s*?(['"])[a-zA-Z0-9-.]*(['"]))+\s*}$/;
+ var colorPalettes = null;
+
+ /**
+ * @ngdoc module
+ * @name material.components.colors
+ *
+ * @description
+ * Define $mdColors service and a `md-colors=""` attribute directive
+ */
+ angular
+ .module('material.components.colors', ['material.core'])
+ .directive('mdColors', MdColorsDirective)
+ .service('$mdColors', MdColorsService);
+
+ /**
+ * @ngdoc service
+ * @name $mdColors
+ * @module material.components.colors
+ *
+ * @description
+ * By default, defining a theme does not make its colors available for applying to non AngularJS
+ * Material elements. The `$mdColors` service is used by the `md-color` directive to convert a
+ * set of color expressions to RGBA values and then apply those values to the element as CSS
+ * property values.
+ *
+ * @usage
+ * Getting a color based on a theme
+ *
+ * <hljs lang="js">
+ * angular.controller('myCtrl', function ($mdColors) {
+ * var color = $mdColors.getThemeColor('myTheme-primary-900-0.5');
+ * ...
+ * });
+ * </hljs>
+ *
+ * Applying a color from a palette to an element
+ * <hljs lang="js">
+ * app.directive('myDirective', function($mdColors) {
+ * return {
+ * ...
+ * link: function (scope, elem) {
+ * $mdColors.applyThemeColors(elem, {color: 'red-A200-0.2'});
+ * }
+ * }
+ * });
+ * </hljs>
+ */
+ function MdColorsService($mdTheming, $mdUtil, $log) {
+ colorPalettes = colorPalettes || Object.keys($mdTheming.PALETTES);
+
+ // Publish service instance
+ return {
+ applyThemeColors: applyThemeColors,
+ getThemeColor: getThemeColor,
+ hasTheme: hasTheme
+ };
+
+ // ********************************************
+ // Internal Methods
+ // ********************************************
+
+ /**
+ * @ngdoc method
+ * @name $mdColors#applyThemeColors
+ *
+ * @description
+ * Lookup a set of colors by hue, theme, and palette, then apply those colors
+ * with the provided opacity (via `rgba()`) to the specified CSS property.
+ *
+ * @param {angular.element} element the element to apply the styles to
+ * @param {Object} colorExpression Keys are CSS properties and values are strings representing
+ * the `theme-palette-hue-opacity` of the desired color. For example:
+ * `{'color': 'red-A200-0.3', 'background-color': 'myTheme-primary-700-0.8'}`. Theme, hue, and
+ * opacity are optional.
+ */
+ function applyThemeColors(element, colorExpression) {
+ try {
+ if (colorExpression) {
+ // Assign the calculate RGBA color values directly as inline CSS
+ element.css(interpolateColors(colorExpression));
+ }
+ } catch (e) {
+ $log.error(e.message);
+ }
+ }
+
+ /**
+ * @ngdoc method
+ * @name $mdColors#getThemeColor
+ *
+ * @description
+ * Get a parsed RGBA color using a string representing the `theme-palette-hue-opacity` of the
+ * desired color.
+ *
+ * @param {string} expression color expression like `'red-A200-0.3'` or
+ * `'myTheme-primary-700-0.8'`. Theme, hue, and opacity are optional.
+ * @returns {string} a CSS color value like `rgba(211, 47, 47, 0.8)`
+ */
+ function getThemeColor(expression) {
+ var color = extractColorOptions(expression);
+
+ return parseColor(color);
+ }
+
+ /**
+ * Return the parsed color
+ * @param {{hue: *, theme: any, palette: *, opacity: (*|string|number)}} color hash map of color
+ * definitions
+ * @param {boolean=} contrast whether use contrast color for foreground. Defaults to false.
+ * @returns {string} rgba color string
+ */
+ function parseColor(color, contrast) {
+ contrast = contrast || false;
+ var rgbValues = $mdTheming.PALETTES[color.palette][color.hue];
+
+ rgbValues = contrast ? rgbValues.contrast : rgbValues.value;
+
+ return $mdUtil.supplant('rgba({0}, {1}, {2}, {3})',
+ [rgbValues[0], rgbValues[1], rgbValues[2], rgbValues[3] || color.opacity]
+ );
+ }
+
+ /**
+ * Convert the color expression into an object with scope-interpolated values
+ * Then calculate the rgba() values based on the theme color parts
+ * @param {Object} themeColors json object, keys are css properties and values are string of
+ * the wanted color, for example: `{color: 'red-A200-0.3'}`.
+ * @return {Object} Hashmap of CSS properties with associated `rgba()` string values
+ */
+ function interpolateColors(themeColors) {
+ var rgbColors = {};
+
+ var hasColorProperty = themeColors.hasOwnProperty('color');
+
+ angular.forEach(themeColors, function (value, key) {
+ var color = extractColorOptions(value);
+ var hasBackground = key.indexOf('background') > -1;
+
+ rgbColors[key] = parseColor(color);
+ if (hasBackground && !hasColorProperty) {
+ rgbColors.color = parseColor(color, true);
+ }
+ });
+
+ return rgbColors;
+ }
+
+ /**
+ * Check if expression has defined theme
+ * For instance:
+ * 'myTheme-primary' => true
+ * 'red-800' => false
+ * @param {string} expression color expression like 'red-800', 'red-A200-0.3',
+ * 'myTheme-primary', or 'myTheme-primary-400'
+ * @return {boolean} true if the expression has a theme part, false otherwise.
+ */
+ function hasTheme(expression) {
+ return angular.isDefined($mdTheming.THEMES[expression.split('-')[0]]);
+ }
+
+ /**
+ * For the evaluated expression, extract the color parts into a hash map
+ * @param {string} expression color expression like 'red-800', 'red-A200-0.3',
+ * 'myTheme-primary', or 'myTheme-primary-400'
+ * @returns {{hue: *, theme: any, palette: *, opacity: (*|string|number)}}
+ */
+ function extractColorOptions(expression) {
+ var parts = expression.split('-');
+ var hasTheme = angular.isDefined($mdTheming.THEMES[parts[0]]);
+ var theme = hasTheme ? parts.splice(0, 1)[0] : $mdTheming.defaultTheme();
+
+ return {
+ theme: theme,
+ palette: extractPalette(parts, theme),
+ hue: extractHue(parts, theme),
+ opacity: parts[2] || 1
+ };
+ }
+
+ /**
+ * Calculate the theme palette name
+ * @param {Array} parts
+ * @param {string} theme name
+ * @return {string}
+ */
+ function extractPalette(parts, theme) {
+ // If the next section is one of the palettes we assume it's a two word palette
+ // Two word palette can be also written in camelCase, forming camelCase to dash-case
+
+ var isTwoWord = parts.length > 1 && colorPalettes.indexOf(parts[1]) !== -1;
+ var palette = parts[0].replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+
+ if (isTwoWord) palette = parts[0] + '-' + parts.splice(1, 1);
+
+ if (colorPalettes.indexOf(palette) === -1) {
+ // If the palette is not in the palette list it's one of primary/accent/warn/background
+ var scheme = $mdTheming.THEMES[theme].colors[palette];
+ if (!scheme) {
+ throw new Error($mdUtil.supplant(
+ 'mdColors: couldn\'t find \'{palette}\' in the palettes.',
+ {palette: palette}));
+ }
+ palette = scheme.name;
+ }
+
+ return palette;
+ }
+
+ /**
+ * @param {Array} parts
+ * @param {string} theme name
+ * @return {*}
+ */
+ function extractHue(parts, theme) {
+ var themeColors = $mdTheming.THEMES[theme].colors;
+
+ if (parts[1] === 'hue') {
+ var hueNumber = parseInt(parts.splice(2, 1)[0], 10);
+
+ if (hueNumber < 1 || hueNumber > 3) {
+ throw new Error($mdUtil.supplant(
+ 'mdColors: \'hue-{hueNumber}\' is not a valid hue, can be only \'hue-1\', \'hue-2\' and \'hue-3\'',
+ {hueNumber: hueNumber}));
+ }
+ parts[1] = 'hue-' + hueNumber;
+
+ if (!(parts[0] in themeColors)) {
+ throw new Error($mdUtil.supplant(
+ 'mdColors: \'hue-x\' can only be used with [{availableThemes}], but was used with \'{usedTheme}\'',
+ {
+ availableThemes: Object.keys(themeColors).join(', '),
+ usedTheme: parts[0]
+ }));
+ }
+
+ return themeColors[parts[0]].hues[parts[1]];
+ }
+
+ return parts[1] || themeColors[parts[0] in themeColors ? parts[0] : 'primary'].hues['default'];
+ }
+ }
+
+ /**
+ * @ngdoc directive
+ * @name mdColors
+ * @module material.components.colors
+ *
+ * @restrict A
+ *
+ * @description
+ * `mdColors` directive will apply the theme-based color expression as RGBA CSS style values.
+ *
+ * The format will be similar to the colors defined in the Sass files:
+ *
+ * ## `[?theme]-[palette]-[?hue]-[?opacity]`
+ * - [theme] - default value is the default theme
+ * - [palette] - can be either palette name or primary/accent/warn/background
+ * - [hue] - default is 500 (hue-x can be used with primary/accent/warn/background)
+ * - [opacity] - default is 1
+ *
+ *
+ * > `?` indicates optional parameter
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div md-colors="{background: 'myTheme-accent-900-0.43'}">
+ * <div md-colors="{color: 'red-A100', 'border-color': 'primary-600'}">
+ * <span>Color demo</span>
+ * </div>
+ * </div>
+ * </hljs>
+ *
+ * The `mdColors` directive will automatically watch for changes in the expression if it recognizes
+ * an interpolation expression or a function. For performance options, you can use `::` prefix to
+ * the `md-colors` expression to indicate a one-time data binding.
+ *
+ * <hljs lang="html">
+ * <md-card md-colors="::{background: '{{theme}}-primary-700'}">
+ * </md-card>
+ * </hljs>
+ */
+ function MdColorsDirective($mdColors, $mdUtil, $log, $parse) {
+ return {
+ restrict: 'A',
+ require: ['^?mdTheme'],
+ compile: function (tElem, tAttrs) {
+ var shouldWatch = shouldColorsWatch();
+
+ return function (scope, element, attrs, ctrl) {
+ var mdThemeController = ctrl[0];
+
+ var lastColors = {};
+
+ /**
+ * @param {string=} theme
+ * @return {Object} colors found in the specified theme
+ */
+ var parseColors = function (theme) {
+ if (typeof theme !== 'string') {
+ theme = '';
+ }
+
+ if (!attrs.mdColors) {
+ attrs.mdColors = '{}';
+ }
+
+ /**
+ * Json.parse() does not work because the keys are not quoted;
+ * use $parse to convert to a hash map
+ */
+ var colors = $parse(attrs.mdColors)(scope);
+
+ /**
+ * If mdTheme is defined higher up the DOM tree,
+ * we add mdTheme's theme to the colors which don't specify a theme.
+ *
+ * @example
+ * <hljs lang="html">
+ * <div md-theme="myTheme">
+ * <div md-colors="{background: 'primary-600'}">
+ * <span md-colors="{background: 'mySecondTheme-accent-200'}">Color demo</span>
+ * </div>
+ * </div>
+ * </hljs>
+ *
+ * 'primary-600' will be changed to 'myTheme-primary-600',
+ * but 'mySecondTheme-accent-200' will not be changed since it has a theme defined.
+ */
+ if (mdThemeController) {
+ Object.keys(colors).forEach(function (prop) {
+ var color = colors[prop];
+ if (!$mdColors.hasTheme(color)) {
+ colors[prop] = (theme || mdThemeController.$mdTheme) + '-' + color;
+ }
+ });
+ }
+
+ cleanElement(colors);
+
+ return colors;
+ };
+
+ /**
+ * @param {Object} colors
+ */
+ var cleanElement = function (colors) {
+ if (!angular.equals(colors, lastColors)) {
+ var keys = Object.keys(lastColors);
+
+ if (lastColors.background && !keys.color) {
+ keys.push('color');
+ }
+
+ keys.forEach(function (key) {
+ element.css(key, '');
+ });
+ }
+
+ lastColors = colors;
+ };
+
+ /**
+ * Registering for mgTheme changes and asking mdTheme controller run our callback whenever
+ * a theme changes.
+ */
+ var unregisterChanges = angular.noop;
+
+ if (mdThemeController) {
+ unregisterChanges = mdThemeController.registerChanges(function (theme) {
+ $mdColors.applyThemeColors(element, parseColors(theme));
+ });
+ }
+
+ scope.$on('$destroy', function () {
+ unregisterChanges();
+ });
+
+ try {
+ if (shouldWatch) {
+ scope.$watch(parseColors, angular.bind(this,
+ $mdColors.applyThemeColors, element
+ ), true);
+ }
+ else {
+ $mdColors.applyThemeColors(element, parseColors());
+ }
+
+ }
+ catch (e) {
+ $log.error(e.message);
+ }
+
+ };
+
+ /**
+ * @return {boolean}
+ */
+ function shouldColorsWatch() {
+ // Simulate 1x binding and mark mdColorsWatch == false
+ var rawColorExpression = tAttrs.mdColors;
+ var bindOnce = rawColorExpression.indexOf('::') > -1;
+ var isStatic = bindOnce ? true : STATIC_COLOR_EXPRESSION.test(tAttrs.mdColors);
+
+ // Remove it for the postLink...
+ tAttrs.mdColors = rawColorExpression.replace('::', '');
+
+ var hasWatchAttr = angular.isDefined(tAttrs.mdColorsWatch);
+
+ return (bindOnce || isStatic) ? false :
+ hasWatchAttr ? $mdUtil.parseAttributeBoolean(tAttrs.mdColorsWatch) : true;
+ }
+ }
+ };
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.content
+ *
+ * @description
+ * Scrollable content
+ */
+mdContentDirective.$inject = ["$mdTheming"];
+angular.module('material.components.content', [
+ 'material.core'
+])
+ .directive('mdContent', mdContentDirective);
+
+/**
+ * @ngdoc directive
+ * @name mdContent
+ * @module material.components.content
+ *
+ * @restrict E
+ *
+ * @description
+ *
+ * The `<md-content>` directive is a container element useful for scrollable content. It achieves
+ * this by setting the CSS `overflow` property to `auto` so that content can properly scroll.
+ *
+ * In general, `<md-content>` components are not designed to be nested inside one another. If
+ * possible, it is better to make them siblings. This often results in a better user experience as
+ * having nested scrollbars may confuse the user.
+ *
+ * ## Troubleshooting
+ *
+ * In some cases, you may wish to apply the `md-no-momentum` class to ensure that Safari's
+ * momentum scrolling is disabled. Momentum scrolling can cause flickering issues while scrolling
+ * SVG icons and some other components.
+ *
+ * Additionally, we now also offer the `md-no-flicker` class which can be applied to any element
+ * and uses a Webkit-specific filter of `blur(0px)` that forces GPU rendering of all elements
+ * inside (which eliminates the flicker on iOS devices).
+ *
+ * _<b>Note:</b> Forcing an element to render on the GPU can have unintended side-effects, especially
+ * related to the z-index of elements. Please use with caution and only on the elements needed._
+ *
+ * @usage
+ *
+ * Add the `[layout-padding]` attribute to make the content padded.
+ *
+ * <hljs lang="html">
+ * <md-content layout-padding>
+ * Lorem ipsum dolor sit amet, ne quod novum mei.
+ * </md-content>
+ * </hljs>
+ */
+
+function mdContentDirective($mdTheming) {
+ return {
+ restrict: 'E',
+ controller: ['$scope', '$element', ContentController],
+ link: function(scope, element) {
+ element.addClass('_md'); // private md component indicator for styling
+
+ $mdTheming(element);
+ scope.$broadcast('$mdContentLoaded', element);
+
+ iosScrollFix(element[0]);
+ }
+ };
+
+ function ContentController($scope, $element) {
+ this.$scope = $scope;
+ this.$element = $element;
+ }
+}
+
+function iosScrollFix(node) {
+ // IOS FIX:
+ // If we scroll where there is no more room for the webview to scroll,
+ // by default the webview itself will scroll up and down, this looks really
+ // bad. So if we are scrolling to the very top or bottom, add/subtract one
+ angular.element(node).on('$md.pressdown', function(ev) {
+ // Only touch events
+ if (ev.pointer.type !== 't') return;
+ // Don't let a child content's touchstart ruin it for us.
+ if (ev.$materialScrollFixed) return;
+ ev.$materialScrollFixed = true;
+
+ if (node.scrollTop === 0) {
+ node.scrollTop = 1;
+ } else if (node.scrollHeight === node.scrollTop + node.offsetHeight) {
+ node.scrollTop -= 1;
+ }
+ });
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.datepicker
+ * @description Module for the datepicker component.
+ */
+
+angular.module('material.components.datepicker', [
+ 'material.core',
+ 'material.components.icon',
+ 'material.components.virtualRepeat'
+]);
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * @ngdoc directive
+ * @name mdCalendar
+ * @module material.components.datepicker
+ *
+ * @param {Date} ng-model The component's model. Should be a Date object.
+ * @param {Object=} ng-model-options Allows tuning of the way in which `ng-model` is being
+ * updated. Also allows for a timezone to be specified.
+ * <a href="https://docs.angularjs.org/api/ng/directive/ngModelOptions#usage">Read more at the
+ * ngModelOptions docs.</a>
+ * @param {Date=} md-min-date Expression representing the minimum date.
+ * @param {Date=} md-max-date Expression representing the maximum date.
+ * @param {(function(Date): boolean)=} md-date-filter Function expecting a date and returning a
+ * boolean whether it can be selected in "day" mode or not.
+ * @param {(function(Date): boolean)=} md-month-filter Function expecting a date and returning a
+ * boolean whether it can be selected in "month" mode or not.
+ * @param {String=} md-current-view Current view of the calendar. Can be either "month" or "year".
+ * @param {String=} md-mode Restricts the user to only selecting a value from a particular view.
+ * This option can be used if the user is only supposed to choose from a certain date type
+ * (e.g. only selecting the month). Can be either "month" or "day". **Note** that this will
+ * overwrite the `md-current-view` value.
+ *
+ * @description
+ * `<md-calendar>` is a component that renders a calendar that can be used to select a date.
+ * It is a part of the `<md-datepicker>` pane, however it can also be used on it's own.
+ *
+ * @usage
+ *
+ * <hljs lang="html">
+ * <md-calendar ng-model="birthday"></md-calendar>
+ * </hljs>
+ */
+ CalendarCtrl.$inject = ["$element", "$scope", "$$mdDateUtil", "$mdUtil", "$mdConstant", "$mdTheming", "$$rAF", "$attrs", "$mdDateLocale", "$filter", "$document"];
+ calendarDirective.$inject = ["inputDirective"];
+ angular.module('material.components.datepicker')
+ .directive('mdCalendar', calendarDirective);
+
+ // TODO(jelbourn): Mac Cmd + left / right == Home / End
+ // TODO(jelbourn): Refactor month element creation to use cloneNode (performance).
+ // TODO(jelbourn): Define virtual scrolling constants (compactness) users can override.
+ // TODO(jelbourn): Animated month transition on ng-model change (virtual-repeat)
+ // TODO(jelbourn): Scroll snapping (virtual repeat)
+ // TODO(jelbourn): Remove superfluous row from short months (virtual-repeat)
+ // TODO(jelbourn): Month headers stick to top when scrolling.
+ // TODO(jelbourn): Previous month opacity is lowered when partially scrolled out of view.
+ // TODO(jelbourn): Support md-calendar standalone on a page (as a tabstop w/ aria-live
+ // announcement and key handling).
+ // TODO Read-only calendar (not just date-picker).
+
+ function calendarDirective(inputDirective) {
+ return {
+ template: function(tElement, tAttr) {
+ // This allows the calendar to work, without a datepicker. This ensures that the virtual
+ // repeater scrolls to the proper place on load by deferring the execution until the next
+ // digest. It's necessary only if the calendar is used without a datepicker, otherwise it's
+ // already wrapped in an ngIf.
+ var extraAttrs = tAttr.hasOwnProperty('ngIf') ? '' : 'ng-if="calendarCtrl.isInitialized"';
+ return '' +
+ '<div ng-switch="calendarCtrl.currentView" ' + extraAttrs + '>' +
+ '<md-calendar-year ng-switch-when="year"></md-calendar-year>' +
+ '<md-calendar-month ng-switch-default></md-calendar-month>' +
+ '</div>';
+ },
+ scope: {
+ minDate: '=mdMinDate',
+ maxDate: '=mdMaxDate',
+ dateFilter: '=mdDateFilter',
+ monthFilter: '=mdMonthFilter',
+
+ // These need to be prefixed, because Angular resets
+ // any changes to the value due to bindToController.
+ _mode: '@mdMode',
+ _currentView: '@mdCurrentView'
+ },
+ require: ['ngModel', 'mdCalendar'],
+ controller: CalendarCtrl,
+ controllerAs: 'calendarCtrl',
+ bindToController: true,
+ link: function(scope, element, attrs, controllers) {
+ var ngModelCtrl = controllers[0];
+ var mdCalendarCtrl = controllers[1];
+ mdCalendarCtrl.configureNgModel(ngModelCtrl, inputDirective);
+ }
+ };
+ }
+
+ /**
+ * Occasionally the hideVerticalScrollbar method might read an element's
+ * width as 0, because it hasn't been laid out yet. This value will be used
+ * as a fallback, in order to prevent scenarios where the element's width
+ * would otherwise have been set to 0. This value is the "usual" width of a
+ * calendar within a floating calendar pane.
+ */
+ var FALLBACK_WIDTH = 340;
+
+ /** Next identifier for calendar instance. */
+ var nextUniqueId = 0;
+
+ /** Maps the `md-mode` values to their corresponding calendar views. */
+ var MODE_MAP = {
+ day: 'month',
+ month: 'year'
+ };
+
+ /**
+ * Controller for the mdCalendar component.
+ * @ngInject @constructor
+ */
+ function CalendarCtrl($element, $scope, $$mdDateUtil, $mdUtil, $mdConstant, $mdTheming, $$rAF,
+ $attrs, $mdDateLocale, $filter, $document) {
+ $mdTheming($element);
+
+ /**
+ * @final
+ * @type {!JQLite}
+ */
+ this.$element = $element;
+
+ /**
+ * @final
+ * @type {!angular.Scope}
+ */
+ this.$scope = $scope;
+
+ /**
+ * @final
+ * @type {!angular.$attrs} Current attributes object for the element
+ */
+ this.$attrs = $attrs;
+
+ /** @final */
+ this.dateUtil = $$mdDateUtil;
+
+ /** @final */
+ this.$mdUtil = $mdUtil;
+
+ /** @final */
+ this.keyCode = $mdConstant.KEY_CODE;
+
+ /** @final */
+ this.$$rAF = $$rAF;
+
+ /** @final */
+ this.$mdDateLocale = $mdDateLocale;
+
+ /** @final The built-in Angular date filter. */
+ this.ngDateFilter = $filter('date');
+
+ /**
+ * @final
+ * @type {Date}
+ */
+ this.today = this.dateUtil.createDateAtMidnight();
+
+ /** @type {!ngModel.NgModelController} */
+ this.ngModelCtrl = undefined;
+
+ /** @type {string} Class applied to the selected date cell. */
+ this.SELECTED_DATE_CLASS = 'md-calendar-selected-date';
+
+ /** @type {string} Class applied to the cell for today. */
+ this.TODAY_CLASS = 'md-calendar-date-today';
+
+ /** @type {string} Class applied to the focused cell. */
+ this.FOCUSED_DATE_CLASS = 'md-focus';
+
+ /**
+ * @final
+ * @type {number} Unique ID for this calendar instance.
+ */
+ this.id = nextUniqueId++;
+
+ /**
+ * The date that is currently focused or showing in the calendar. This will initially be set
+ * to the ng-model value if set, otherwise to today. It will be updated as the user navigates
+ * to other months. The cell corresponding to the displayDate does not necessarily always have
+ * focus in the document (such as for cases when the user is scrolling the calendar).
+ * @type {Date}
+ */
+ this.displayDate = null;
+
+ /**
+ * Allows restricting the calendar to only allow selecting a month or a day.
+ * @type {'month'|'day'|null}
+ */
+ this.mode = null;
+
+ /**
+ * The selected date. Keep track of this separately from the ng-model value so that we
+ * can know, when the ng-model value changes, what the previous value was before it's updated
+ * in the component's UI.
+ *
+ * @type {Date}
+ */
+ this.selectedDate = null;
+
+ /**
+ * The first date that can be rendered by the calendar. The default is taken
+ * from the mdDateLocale provider and is limited by the mdMinDate.
+ * @type {Date}
+ */
+ this.firstRenderableDate = null;
+
+ /**
+ * The last date that can be rendered by the calendar. The default comes
+ * from the mdDateLocale provider and is limited by the maxDate.
+ * @type {Date}
+ */
+ this.lastRenderableDate = null;
+
+ /**
+ * Used to toggle initialize the root element in the next digest.
+ * @type {boolean}
+ */
+ this.isInitialized = false;
+
+ /**
+ * Cache for the width of the element without a scrollbar. Used to hide the scrollbar later on
+ * and to avoid extra reflows when switching between views.
+ * @type {number}
+ */
+ this.width = 0;
+
+ /**
+ * Caches the width of the scrollbar in order to be used when hiding it and to avoid extra reflows.
+ * @type {number}
+ */
+ this.scrollbarWidth = 0;
+
+ /**
+ * @type {boolean} set to true if the calendar is being used "standalone" (outside of a
+ * md-datepicker).
+ */
+ this.standaloneMode = false;
+
+ // Unless the user specifies so, the calendar should not be a tab stop.
+ // This is necessary because ngAria might add a tabindex to anything with an ng-model
+ // (based on whether or not the user has turned that particular feature on/off).
+ if (!$attrs.tabindex) {
+ $element.attr('tabindex', '-1');
+ }
+
+ var boundKeyHandler = angular.bind(this, this.handleKeyEvent);
+
+ // If use the md-calendar directly in the body without datepicker,
+ // handleKeyEvent will disable other inputs on the page.
+ // So only apply the handleKeyEvent on the body when the md-calendar inside datepicker,
+ // otherwise apply on the calendar element only.
+
+ var handleKeyElement;
+ if ($element.parent().hasClass('md-datepicker-calendar')) {
+ handleKeyElement = angular.element($document[0].body);
+ } else {
+ this.standaloneMode = true;
+ handleKeyElement = $element;
+ }
+
+ // Bind the keydown handler to the body, in order to handle cases where the focused
+ // element gets removed from the DOM and stops propagating click events.
+ handleKeyElement.on('keydown', boundKeyHandler);
+
+ $scope.$on('$destroy', function() {
+ handleKeyElement.off('keydown', boundKeyHandler);
+ });
+
+ // For AngularJS 1.4 and older, where there are no lifecycle hooks but bindings are pre-assigned,
+ // manually call the $onInit hook.
+ if (angular.version.major === 1 && angular.version.minor <= 4) {
+ this.$onInit();
+ }
+ }
+
+ /**
+ * AngularJS Lifecycle hook for newer AngularJS versions.
+ * Bindings are not guaranteed to have been assigned in the controller, but they are in the
+ * $onInit hook.
+ */
+ CalendarCtrl.prototype.$onInit = function() {
+ /**
+ * The currently visible calendar view. Note the prefix on the scope value,
+ * which is necessary, because the datepicker seems to reset the real one value if the
+ * calendar is open, but the `currentView` on the datepicker's scope is empty.
+ * @type {String}
+ */
+ if (this._mode && MODE_MAP.hasOwnProperty(this._mode)) {
+ this.currentView = MODE_MAP[this._mode];
+ this.mode = this._mode;
+ } else {
+ this.currentView = this._currentView || 'month';
+ this.mode = null;
+ }
+
+ if (this.minDate && this.minDate > this.$mdDateLocale.firstRenderableDate) {
+ this.firstRenderableDate = this.minDate;
+ } else {
+ this.firstRenderableDate = this.$mdDateLocale.firstRenderableDate;
+ }
+
+ if (this.maxDate && this.maxDate < this.$mdDateLocale.lastRenderableDate) {
+ this.lastRenderableDate = this.maxDate;
+ } else {
+ this.lastRenderableDate = this.$mdDateLocale.lastRenderableDate;
+ }
+ };
+
+ /**
+ * Sets up the controller's reference to ngModelController.
+ * @param {!ngModel.NgModelController} ngModelCtrl Instance of the ngModel controller.
+ * @param {Object} inputDirective Config for AngularJS's `input` directive.
+ */
+ CalendarCtrl.prototype.configureNgModel = function(ngModelCtrl, inputDirective) {
+ var self = this;
+ self.ngModelCtrl = ngModelCtrl;
+
+ // The component needs to be [type="date"] in order to be picked up by AngularJS.
+ this.$attrs.$set('type', 'date');
+
+ // Invoke the `input` directive link function, adding a stub for the element.
+ // This allows us to re-use AngularJS' logic for setting the timezone via ng-model-options.
+ // It works by calling the link function directly which then adds the proper `$parsers` and
+ // `$formatters` to the NgModelController.
+ inputDirective[0].link.pre(this.$scope, {
+ on: angular.noop,
+ val: angular.noop,
+ 0: {}
+ }, this.$attrs, [ngModelCtrl]);
+
+ ngModelCtrl.$render = function() {
+ var value = this.$viewValue, convertedDate;
+
+ // In the case where a conversion is needed, the $viewValue here will be a string like
+ // "2020-05-10" instead of a Date object.
+ if (!self.dateUtil.isValidDate(value)) {
+ convertedDate = self.dateUtil.removeLocalTzAndReparseDate(new Date(value));
+ if (self.dateUtil.isValidDate(convertedDate)) {
+ value = convertedDate;
+ }
+ }
+
+ // Notify the child scopes of any changes.
+ self.$scope.$broadcast('md-calendar-parent-changed', value);
+
+ // Set up the selectedDate if it hasn't been already.
+ if (!self.selectedDate) {
+ self.selectedDate = value;
+ }
+
+ // Also set up the displayDate.
+ if (!self.displayDate) {
+ self.displayDate = self.selectedDate || self.today;
+ }
+ };
+
+ self.$mdUtil.nextTick(function() {
+ self.isInitialized = true;
+ });
+ };
+
+ /**
+ * Sets the ng-model value for the calendar and emits a change event.
+ * @param {Date} date new value for the calendar
+ */
+ CalendarCtrl.prototype.setNgModelValue = function(date) {
+ var timezone = this.$mdUtil.getModelOption(this.ngModelCtrl, 'timezone');
+ var value = this.dateUtil.createDateAtMidnight(date);
+ this.focusDate(value);
+ this.$scope.$emit('md-calendar-change', value);
+ // Using the timezone when the offset is negative (GMT+X) causes the previous day to be
+ // selected here. This check avoids that.
+ if (timezone == null || value.getTimezoneOffset() < 0) {
+ this.ngModelCtrl.$setViewValue(this.ngDateFilter(value, 'yyyy-MM-dd'), 'default');
+ } else {
+ this.ngModelCtrl.$setViewValue(this.ngDateFilter(value, 'yyyy-MM-dd', timezone), 'default');
+ }
+ this.ngModelCtrl.$render();
+ return value;
+ };
+
+ /**
+ * Sets the current view that should be visible in the calendar
+ * @param {string} newView View name to be set.
+ * @param {number|Date} time Date object or a timestamp for the new display date.
+ */
+ CalendarCtrl.prototype.setCurrentView = function(newView, time) {
+ var self = this;
+
+ self.$mdUtil.nextTick(function() {
+ self.currentView = newView;
+
+ if (time) {
+ self.displayDate = angular.isDate(time) ? time : new Date(time);
+ }
+ });
+ };
+
+ /**
+ * Focus the cell corresponding to the given date.
+ * @param {Date=} date The date to be focused.
+ */
+ CalendarCtrl.prototype.focusDate = function(date) {
+ if (this.dateUtil.isValidDate(date)) {
+ var previousFocus = this.$element[0].querySelector('.' + this.FOCUSED_DATE_CLASS);
+ if (previousFocus) {
+ previousFocus.classList.remove(this.FOCUSED_DATE_CLASS);
+ }
+
+ var cellId = this.getDateId(date, this.currentView);
+ var cell = document.getElementById(cellId);
+ if (cell) {
+ cell.classList.add(this.FOCUSED_DATE_CLASS);
+ cell.focus();
+ this.displayDate = date;
+ }
+ } else {
+ var rootElement = this.$element[0].querySelector('[ng-switch]');
+
+ if (rootElement) {
+ rootElement.focus();
+ }
+ }
+ };
+
+ /**
+ * Highlights a date cell on the calendar and changes the selected date.
+ * @param {Date=} date Date to be marked as selected.
+ */
+ CalendarCtrl.prototype.changeSelectedDate = function(date) {
+ var selectedDateClass = this.SELECTED_DATE_CLASS;
+ var prevDateCell = this.$element[0].querySelector('.' + selectedDateClass);
+
+ // Remove the selected class from the previously selected date, if any.
+ if (prevDateCell) {
+ prevDateCell.classList.remove(selectedDateClass);
+ prevDateCell.setAttribute('aria-selected', 'false');
+ }
+
+ // Apply the select class to the new selected date if it is set.
+ if (date) {
+ var dateCell = document.getElementById(this.getDateId(date, this.currentView));
+ if (dateCell) {
+ dateCell.classList.add(selectedDateClass);
+ dateCell.setAttribute('aria-selected', 'true');
+ }
+ }
+
+ this.selectedDate = date;
+ };
+
+ /**
+ * Normalizes the key event into an action name. The action will be broadcast
+ * to the child controllers.
+ * @param {KeyboardEvent} event
+ * @returns {string} The action that should be taken, or null if the key
+ * does not match a calendar shortcut.
+ */
+ CalendarCtrl.prototype.getActionFromKeyEvent = function(event) {
+ var keyCode = this.keyCode;
+
+ switch (event.which) {
+ case keyCode.ENTER: return 'select';
+
+ case keyCode.RIGHT_ARROW: return 'move-right';
+ case keyCode.LEFT_ARROW: return 'move-left';
+
+ case keyCode.DOWN_ARROW: return event.metaKey ? 'move-page-down' : 'move-row-down';
+ case keyCode.UP_ARROW: return event.metaKey ? 'move-page-up' : 'move-row-up';
+
+ case keyCode.PAGE_DOWN: return 'move-page-down';
+ case keyCode.PAGE_UP: return 'move-page-up';
+
+ case keyCode.HOME: return 'start';
+ case keyCode.END: return 'end';
+
+ default: return null;
+ }
+ };
+
+ /**
+ * Handles a key event in the calendar with the appropriate action.
+ * The action will either
+ * - select the focused date
+ * - navigate to focus a new date
+ * - emit a md-calendar-close event if in a md-datepicker panel
+ * - emit a md-calendar-parent-action
+ * - delegate to normal tab order if the TAB key is pressed in standalone mode
+ * @param {KeyboardEvent} event
+ */
+ CalendarCtrl.prototype.handleKeyEvent = function(event) {
+ var self = this;
+
+ this.$scope.$apply(function() {
+ // Capture escape and emit back up so that a wrapping component
+ // (such as a date-picker) can decide to close.
+ if (event.which === self.keyCode.ESCAPE ||
+ (event.which === self.keyCode.TAB && !self.standaloneMode)) {
+ self.$scope.$emit('md-calendar-close');
+
+ if (event.which === self.keyCode.TAB) {
+ event.preventDefault();
+ }
+
+ return;
+ } else if (event.which === self.keyCode.TAB && self.standaloneMode) {
+ // delegate to the normal tab order if the TAB key is pressed in standalone mode
+ return;
+ }
+
+ // Broadcast the action that any child controllers should take.
+ var action = self.getActionFromKeyEvent(event);
+ if (action) {
+ event.preventDefault();
+ event.stopPropagation();
+ self.$scope.$broadcast('md-calendar-parent-action', action);
+ }
+ });
+ };
+
+ /**
+ * Hides the vertical scrollbar on the calendar scroller of a child controller by
+ * setting the width on the calendar scroller and the `overflow: hidden` wrapper
+ * around the scroller, and then setting a padding-right on the scroller equal
+ * to the width of the browser's scrollbar.
+ *
+ * This will cause a reflow.
+ *
+ * @param {object} childCtrl The child controller whose scrollbar should be hidden.
+ */
+ CalendarCtrl.prototype.hideVerticalScrollbar = function(childCtrl) {
+ var self = this;
+ var element = childCtrl.$element[0];
+ var scrollMask = element.querySelector('.md-calendar-scroll-mask');
+
+ if (self.width > 0) {
+ setWidth();
+ } else {
+ self.$$rAF(function() {
+ var scroller = childCtrl.calendarScroller;
+
+ self.scrollbarWidth = scroller.offsetWidth - scroller.clientWidth;
+ self.width = element.querySelector('table').offsetWidth;
+ setWidth();
+ });
+ }
+
+ function setWidth() {
+ var width = self.width || FALLBACK_WIDTH;
+ var scrollbarWidth = self.scrollbarWidth;
+ var scroller = childCtrl.calendarScroller;
+
+ scrollMask.style.width = width + 'px';
+ scroller.style.width = (width + scrollbarWidth) + 'px';
+ scroller.style.paddingRight = scrollbarWidth + 'px';
+ }
+ };
+
+ /**
+ * Gets an identifier for a date unique to the calendar instance for internal
+ * purposes. Not to be displayed.
+ * @param {Date} date The date for which the id is being generated
+ * @param {string} namespace Namespace for the id. (month, year etc.)
+ * @returns {string}
+ */
+ CalendarCtrl.prototype.getDateId = function(date, namespace) {
+ if (!namespace) {
+ throw new Error('A namespace for the date id has to be specified.');
+ }
+
+ return [
+ 'md',
+ this.id,
+ namespace,
+ date.getFullYear(),
+ date.getMonth(),
+ date.getDate()
+ ].join('-');
+ };
+
+ /**
+ * Util to trigger an extra digest on a parent scope, in order to to ensure that
+ * any child virtual repeaters have updated. This is necessary, because the virtual
+ * repeater doesn't update the $index the first time around since the content isn't
+ * in place yet. The case, in which this is an issue, is when the repeater has less
+ * than a page of content (e.g. a month or year view has a min or max date).
+ */
+ CalendarCtrl.prototype.updateVirtualRepeat = function() {
+ var scope = this.$scope;
+ var virtualRepeatResizeListener = scope.$on('$md-resize-enable', function() {
+ if (!scope.$$phase) {
+ scope.$apply();
+ }
+
+ virtualRepeatResizeListener();
+ });
+ };
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ CalendarMonthCtrl.$inject = ["$element", "$scope", "$animate", "$q", "$$mdDateUtil", "$mdDateLocale"];
+ angular.module('material.components.datepicker')
+ .directive('mdCalendarMonth', calendarDirective);
+
+ /**
+ * Height of one calendar month tbody. This must be made known to the virtual-repeat and is
+ * subsequently used for scrolling to specific months.
+ */
+ var TBODY_HEIGHT = 265;
+
+ /**
+ * Height of a calendar month with a single row. This is needed to calculate the offset for
+ * rendering an extra month in virtual-repeat that only contains one row.
+ */
+ var TBODY_SINGLE_ROW_HEIGHT = 45;
+
+ /** Private directive that represents a list of months inside the calendar. */
+ function calendarDirective() {
+ return {
+ template:
+ '<table aria-hidden="true" class="md-calendar-day-header"><thead></thead></table>' +
+ '<div class="md-calendar-scroll-mask">' +
+ '<md-virtual-repeat-container class="md-calendar-scroll-container" ' +
+ 'md-offset-size="' + (TBODY_SINGLE_ROW_HEIGHT - TBODY_HEIGHT) + '">' +
+ '<table role="grid" tabindex="0" class="md-calendar" aria-readonly="true">' +
+ '<tbody ' +
+ 'md-calendar-month-body ' +
+ 'role="rowgroup" ' +
+ 'md-virtual-repeat="i in monthCtrl.items" ' +
+ 'md-month-offset="$index" ' +
+ 'class="md-calendar-month" ' +
+ 'md-start-index="monthCtrl.getSelectedMonthIndex()" ' +
+ 'md-item-size="' + TBODY_HEIGHT + '">' +
+
+ // The <tr> ensures that the <tbody> will always have the
+ // proper height, even if it's empty. If it's content is
+ // compiled, the <tr> will be overwritten.
+ '<tr aria-hidden="true" md-force-height="\'' + TBODY_HEIGHT + 'px\'"></tr>' +
+ '</tbody>' +
+ '</table>' +
+ '</md-virtual-repeat-container>' +
+ '</div>',
+ require: ['^^mdCalendar', 'mdCalendarMonth'],
+ controller: CalendarMonthCtrl,
+ controllerAs: 'monthCtrl',
+ bindToController: true,
+ link: function(scope, element, attrs, controllers) {
+ var calendarCtrl = controllers[0];
+ var monthCtrl = controllers[1];
+ monthCtrl.initialize(calendarCtrl);
+ }
+ };
+ }
+
+ /**
+ * Controller for the calendar month component.
+ * @ngInject @constructor
+ */
+ function CalendarMonthCtrl($element, $scope, $animate, $q,
+ $$mdDateUtil, $mdDateLocale) {
+
+ /** @final {!angular.JQLite} */
+ this.$element = $element;
+
+ /** @final {!angular.Scope} */
+ this.$scope = $scope;
+
+ /** @final {!angular.$animate} */
+ this.$animate = $animate;
+
+ /** @final {!angular.$q} */
+ this.$q = $q;
+
+ /** @final */
+ this.dateUtil = $$mdDateUtil;
+
+ /** @final */
+ this.dateLocale = $mdDateLocale;
+
+ /** @final {HTMLElement} */
+ this.calendarScroller = $element[0].querySelector('.md-virtual-repeat-scroller');
+
+ /** @type {boolean} */
+ this.isInitialized = false;
+
+ /** @type {boolean} */
+ this.isMonthTransitionInProgress = false;
+
+ var self = this;
+
+ /**
+ * Handles a click event on a date cell.
+ * Created here so that every cell can use the same function instance.
+ * @this {HTMLTableCellElement} The cell that was clicked.
+ */
+ this.cellClickHandler = function() {
+ var timestamp = $$mdDateUtil.getTimestampFromNode(this);
+ self.$scope.$apply(function() {
+ // The timestamp has to be converted to a valid date.
+ self.calendarCtrl.setNgModelValue(new Date(timestamp));
+ });
+ };
+
+ /**
+ * Handles click events on the month headers. Switches
+ * the calendar to the year view.
+ * @this {HTMLTableCellElement} The cell that was clicked.
+ */
+ this.headerClickHandler = function() {
+ self.calendarCtrl.setCurrentView('year', $$mdDateUtil.getTimestampFromNode(this));
+ };
+ }
+
+ /** Initialization **/
+
+ /**
+ * Initialize the controller by saving a reference to the calendar and
+ * setting up the object that will be iterated by the virtual repeater.
+ */
+ CalendarMonthCtrl.prototype.initialize = function(calendarCtrl) {
+ /**
+ * Dummy array-like object for virtual-repeat to iterate over. The length is the total
+ * number of months that can be viewed. We add 2 months: one to include the current month
+ * and one for the last dummy month.
+ *
+ * This is shorter than ideal because of a (potential) Firefox bug
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=1181658.
+ */
+
+ this.items = {
+ length: this.dateUtil.getMonthDistance(
+ calendarCtrl.firstRenderableDate,
+ calendarCtrl.lastRenderableDate
+ ) + 2
+ };
+
+ this.calendarCtrl = calendarCtrl;
+ this.attachScopeListeners();
+ calendarCtrl.updateVirtualRepeat();
+
+ // Fire the initial render, since we might have missed it the first time it fired.
+ calendarCtrl.ngModelCtrl && calendarCtrl.ngModelCtrl.$render();
+ };
+
+ /**
+ * Gets the "index" of the currently selected date as it would be in the virtual-repeat.
+ * @returns {number} the "index" of the currently selected date
+ */
+ CalendarMonthCtrl.prototype.getSelectedMonthIndex = function() {
+ var calendarCtrl = this.calendarCtrl;
+
+ return this.dateUtil.getMonthDistance(
+ calendarCtrl.firstRenderableDate,
+ calendarCtrl.displayDate || calendarCtrl.selectedDate || calendarCtrl.today
+ );
+ };
+
+ /**
+ * Change the date that is being shown in the calendar. If the given date is in a different
+ * month, the displayed month will be transitioned.
+ * @param {Date} date
+ */
+ CalendarMonthCtrl.prototype.changeDisplayDate = function(date) {
+ // Initialization is deferred until this function is called because we want to reflect
+ // the starting value of ngModel.
+ if (!this.isInitialized) {
+ this.buildWeekHeader();
+ this.calendarCtrl.hideVerticalScrollbar(this);
+ this.isInitialized = true;
+ return this.$q.when();
+ }
+
+ // If trying to show an invalid date or a transition is in progress, do nothing.
+ if (!this.dateUtil.isValidDate(date) || this.isMonthTransitionInProgress) {
+ return this.$q.when();
+ }
+
+ this.isMonthTransitionInProgress = true;
+ var animationPromise = this.animateDateChange(date);
+
+ this.calendarCtrl.displayDate = date;
+
+ var self = this;
+ animationPromise.then(function() {
+ self.isMonthTransitionInProgress = false;
+ });
+
+ return animationPromise;
+ };
+
+ /**
+ * Animates the transition from the calendar's current month to the given month.
+ * @param {Date} date
+ * @returns {angular.$q.Promise} The animation promise.
+ */
+ CalendarMonthCtrl.prototype.animateDateChange = function(date) {
+ if (this.dateUtil.isValidDate(date)) {
+ var monthDistance = this.dateUtil.getMonthDistance(this.calendarCtrl.firstRenderableDate, date);
+ this.calendarScroller.scrollTop = monthDistance * TBODY_HEIGHT;
+ }
+
+ return this.$q.when();
+ };
+
+ /**
+ * Builds and appends a day-of-the-week header to the calendar.
+ * This should only need to be called once during initialization.
+ */
+ CalendarMonthCtrl.prototype.buildWeekHeader = function() {
+ var firstDayOfWeek = this.dateLocale.firstDayOfWeek;
+ var shortDays = this.dateLocale.shortDays;
+
+ var row = document.createElement('tr');
+ for (var i = 0; i < 7; i++) {
+ var th = document.createElement('th');
+ th.textContent = shortDays[(i + firstDayOfWeek) % 7];
+ row.appendChild(th);
+ }
+
+ this.$element.find('thead').append(row);
+ };
+
+ /**
+ * Attaches listeners for the scope events that are broadcast by the calendar.
+ */
+ CalendarMonthCtrl.prototype.attachScopeListeners = function() {
+ var self = this;
+
+ self.$scope.$on('md-calendar-parent-changed', function(event, value) {
+ self.calendarCtrl.changeSelectedDate(value);
+ self.changeDisplayDate(value);
+ });
+
+ self.$scope.$on('md-calendar-parent-action', angular.bind(this, this.handleKeyEvent));
+ };
+
+ /**
+ * Handles the month-specific keyboard interactions.
+ * @param {Object} event Scope event object passed by the calendar.
+ * @param {String} action Action, corresponding to the key that was pressed.
+ */
+ CalendarMonthCtrl.prototype.handleKeyEvent = function(event, action) {
+ var calendarCtrl = this.calendarCtrl;
+ var displayDate = calendarCtrl.displayDate;
+
+ if (action === 'select') {
+ calendarCtrl.setNgModelValue(displayDate);
+ } else {
+ var date = null;
+ var dateUtil = this.dateUtil;
+
+ switch (action) {
+ case 'move-right': date = dateUtil.incrementDays(displayDate, 1); break;
+ case 'move-left': date = dateUtil.incrementDays(displayDate, -1); break;
+
+ case 'move-page-down': date = dateUtil.incrementMonths(displayDate, 1); break;
+ case 'move-page-up': date = dateUtil.incrementMonths(displayDate, -1); break;
+
+ case 'move-row-down': date = dateUtil.incrementDays(displayDate, 7); break;
+ case 'move-row-up': date = dateUtil.incrementDays(displayDate, -7); break;
+
+ case 'start': date = dateUtil.getFirstDateOfMonth(displayDate); break;
+ case 'end': date = dateUtil.getLastDateOfMonth(displayDate); break;
+ }
+
+ if (date) {
+ date = this.dateUtil.clampDate(date, calendarCtrl.minDate, calendarCtrl.maxDate);
+
+ this.changeDisplayDate(date).then(function() {
+ calendarCtrl.focusDate(date);
+ });
+ }
+ }
+ };
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ mdCalendarMonthBodyDirective.$inject = ["$compile", "$$mdSvgRegistry"];
+ CalendarMonthBodyCtrl.$inject = ["$element", "$$mdDateUtil", "$mdDateLocale"];
+ angular.module('material.components.datepicker')
+ .directive('mdCalendarMonthBody', mdCalendarMonthBodyDirective);
+
+ /**
+ * Private directive consumed by md-calendar-month. Having this directive lets the calender use
+ * md-virtual-repeat and also cleanly separates the month DOM construction functions from
+ * the rest of the calendar controller logic.
+ * @ngInject
+ */
+ function mdCalendarMonthBodyDirective($compile, $$mdSvgRegistry) {
+ var ARROW_ICON = $compile('<md-icon md-svg-src="' +
+ $$mdSvgRegistry.mdTabsArrow + '"></md-icon>')({})[0];
+
+ return {
+ require: ['^^mdCalendar', '^^mdCalendarMonth', 'mdCalendarMonthBody'],
+ scope: { offset: '=mdMonthOffset' },
+ controller: CalendarMonthBodyCtrl,
+ controllerAs: 'mdMonthBodyCtrl',
+ bindToController: true,
+ link: function(scope, element, attrs, controllers) {
+ var calendarCtrl = controllers[0];
+ var monthCtrl = controllers[1];
+ var monthBodyCtrl = controllers[2];
+
+ monthBodyCtrl.calendarCtrl = calendarCtrl;
+ monthBodyCtrl.monthCtrl = monthCtrl;
+ monthBodyCtrl.arrowIcon = ARROW_ICON.cloneNode(true);
+
+ // The virtual-repeat re-uses the same DOM elements, so there are only a limited number
+ // of repeated items that are linked, and then those elements have their bindings updated.
+ // Since the months are not generated by bindings, we simply regenerate the entire thing
+ // when the binding (offset) changes.
+ scope.$watch(function() { return monthBodyCtrl.offset; }, function(offset) {
+ if (angular.isNumber(offset)) {
+ monthBodyCtrl.generateContent();
+ }
+ });
+ }
+ };
+ }
+
+ /**
+ * Controller for a single calendar month.
+ * @ngInject @constructor
+ */
+ function CalendarMonthBodyCtrl($element, $$mdDateUtil, $mdDateLocale) {
+ /**
+ * @final
+ * @type {!JQLite}
+ */
+ this.$element = $element;
+
+ /** @final */
+ this.dateUtil = $$mdDateUtil;
+
+ /** @final */
+ this.dateLocale = $mdDateLocale;
+
+ /** @type {Object} Reference to the month view. */
+ this.monthCtrl = null;
+
+ /** @type {Object} Reference to the calendar. */
+ this.calendarCtrl = null;
+
+ /**
+ * Number of months from the start of the month "items" that the currently rendered month
+ * occurs. Set via angular data binding.
+ * @type {number|null}
+ */
+ this.offset = null;
+
+ /**
+ * Date cell to focus after appending the month to the document.
+ * @type {HTMLElement}
+ */
+ this.focusAfterAppend = null;
+ }
+
+ /** Generate and append the content for this month to the directive element. */
+ CalendarMonthBodyCtrl.prototype.generateContent = function() {
+ var date = this.dateUtil.incrementMonths(this.calendarCtrl.firstRenderableDate, this.offset);
+
+ this.$element
+ .empty()
+ .append(this.buildCalendarForMonth(date));
+
+ if (this.focusAfterAppend) {
+ this.focusAfterAppend.classList.add(this.calendarCtrl.FOCUSED_DATE_CLASS);
+ this.focusAfterAppend = null;
+ }
+ };
+
+ /**
+ * Creates a single cell to contain a date in the calendar with all appropriate
+ * attributes and classes added. If a date is given, the cell content will be set
+ * based on the date.
+ * @param {Date=} opt_date
+ * @returns {HTMLElement}
+ */
+ CalendarMonthBodyCtrl.prototype.buildDateCell = function(opt_date) {
+ var monthCtrl = this.monthCtrl;
+ var calendarCtrl = this.calendarCtrl;
+
+ // TODO(jelbourn): cloneNode is likely a faster way of doing this.
+ var cell = document.createElement('td');
+ cell.tabIndex = -1;
+ cell.classList.add('md-calendar-date');
+ cell.setAttribute('role', 'gridcell');
+
+ if (opt_date) {
+ cell.setAttribute('tabindex', '-1');
+ cell.setAttribute('aria-label', this.dateLocale.longDateFormatter(opt_date));
+ cell.id = calendarCtrl.getDateId(opt_date, 'month');
+
+ // Use `data-timestamp` attribute because IE10 does not support the `dataset` property.
+ cell.setAttribute('data-timestamp', opt_date.getTime());
+
+ // TODO(jelourn): Doing these comparisons for class addition during generation might be slow.
+ // It may be better to finish the construction and then query the node and add the class.
+ if (this.dateUtil.isSameDay(opt_date, calendarCtrl.today)) {
+ cell.classList.add(calendarCtrl.TODAY_CLASS);
+ }
+
+ if (this.dateUtil.isValidDate(calendarCtrl.selectedDate) &&
+ this.dateUtil.isSameDay(opt_date, calendarCtrl.selectedDate)) {
+ cell.classList.add(calendarCtrl.SELECTED_DATE_CLASS);
+ cell.setAttribute('aria-selected', 'true');
+ }
+
+ var cellText = this.dateLocale.dates[opt_date.getDate()];
+
+ if (this.isDateEnabled(opt_date)) {
+ // Add a indicator for select, hover, and focus states.
+ var selectionIndicator = document.createElement('span');
+ selectionIndicator.classList.add('md-calendar-date-selection-indicator');
+ selectionIndicator.textContent = cellText;
+ cell.appendChild(selectionIndicator);
+ cell.addEventListener('click', monthCtrl.cellClickHandler);
+
+ if (calendarCtrl.displayDate && this.dateUtil.isSameDay(opt_date, calendarCtrl.displayDate)) {
+ this.focusAfterAppend = cell;
+ }
+ } else {
+ cell.classList.add('md-calendar-date-disabled');
+ cell.textContent = cellText;
+ }
+ }
+
+ return cell;
+ };
+
+ /**
+ * Check whether date is in range and enabled
+ * @param {Date=} opt_date
+ * @return {boolean} Whether the date is enabled.
+ */
+ CalendarMonthBodyCtrl.prototype.isDateEnabled = function(opt_date) {
+ return this.dateUtil.isDateWithinRange(opt_date,
+ this.calendarCtrl.minDate, this.calendarCtrl.maxDate) &&
+ (!angular.isFunction(this.calendarCtrl.dateFilter)
+ || this.calendarCtrl.dateFilter(opt_date));
+ };
+
+ /**
+ * Builds a `tr` element for the calendar grid.
+ * @param rowNumber The week number within the month.
+ * @returns {HTMLElement}
+ */
+ CalendarMonthBodyCtrl.prototype.buildDateRow = function(rowNumber) {
+ var row = document.createElement('tr');
+ row.setAttribute('role', 'row');
+
+ // Because of an NVDA bug (with Firefox), the row needs an aria-label in order
+ // to prevent the entire row being read aloud when the user moves between rows.
+ // See http://community.nvda-project.org/ticket/4643.
+ row.setAttribute('aria-label', this.dateLocale.weekNumberFormatter(rowNumber));
+
+ return row;
+ };
+
+ /**
+ * Builds the <tbody> content for the given date's month.
+ * @param {Date=} opt_dateInMonth
+ * @returns {DocumentFragment} A document fragment containing the <tr> elements.
+ */
+ CalendarMonthBodyCtrl.prototype.buildCalendarForMonth = function(opt_dateInMonth) {
+ var date = this.dateUtil.isValidDate(opt_dateInMonth) ? opt_dateInMonth : new Date();
+
+ var firstDayOfMonth = this.dateUtil.getFirstDateOfMonth(date);
+ var firstDayOfTheWeek = this.getLocaleDay_(firstDayOfMonth);
+ var numberOfDaysInMonth = this.dateUtil.getNumberOfDaysInMonth(date);
+
+ // Store rows for the month in a document fragment so that we can append them all at once.
+ var monthBody = document.createDocumentFragment();
+
+ var rowNumber = 1;
+ var row = this.buildDateRow(rowNumber);
+ monthBody.appendChild(row);
+
+ // If this is the final month in the list of items, only the first week should render,
+ // so we should return immediately after the first row is complete and has been
+ // attached to the body.
+ var isFinalMonth = this.offset === this.monthCtrl.items.length - 1;
+
+ // Add a label for the month. If the month starts on a Sun/Mon/Tues, the month label
+ // goes on a row above the first of the month. Otherwise, the month label takes up the first
+ // two cells of the first row.
+ var blankCellOffset = 0;
+ var monthLabelCell = document.createElement('td');
+ var monthLabelCellContent = document.createElement('span');
+ var calendarCtrl = this.calendarCtrl;
+
+ monthLabelCellContent.textContent = this.dateLocale.monthHeaderFormatter(date);
+ monthLabelCell.appendChild(monthLabelCellContent);
+ monthLabelCell.classList.add('md-calendar-month-label');
+ // If the entire month is after the max date, render the label as a disabled state.
+ if (calendarCtrl.maxDate && firstDayOfMonth > calendarCtrl.maxDate) {
+ monthLabelCell.classList.add('md-calendar-month-label-disabled');
+ // If the user isn't supposed to be able to change views, render the
+ // label as usual, but disable the clicking functionality.
+ } else if (!calendarCtrl.mode) {
+ monthLabelCell.addEventListener('click', this.monthCtrl.headerClickHandler);
+ monthLabelCell.setAttribute('data-timestamp', firstDayOfMonth.getTime());
+ monthLabelCell.setAttribute('aria-label', this.dateLocale.monthFormatter(date));
+ monthLabelCell.classList.add('md-calendar-label-clickable');
+ monthLabelCell.appendChild(this.arrowIcon.cloneNode(true));
+ }
+
+ if (firstDayOfTheWeek <= 2) {
+ monthLabelCell.setAttribute('colspan', '7');
+
+ var monthLabelRow = this.buildDateRow();
+ monthLabelRow.appendChild(monthLabelCell);
+ monthBody.insertBefore(monthLabelRow, row);
+
+ if (isFinalMonth) {
+ return monthBody;
+ }
+ } else {
+ blankCellOffset = 3;
+ monthLabelCell.setAttribute('colspan', '3');
+ row.appendChild(monthLabelCell);
+ }
+
+ // Add a blank cell for each day of the week that occurs before the first of the month.
+ // For example, if the first day of the month is a Tuesday, add blank cells for Sun and Mon.
+ // The blankCellOffset is needed in cases where the first N cells are used by the month label.
+ for (var i = blankCellOffset; i < firstDayOfTheWeek; i++) {
+ row.appendChild(this.buildDateCell());
+ }
+
+ // Add a cell for each day of the month, keeping track of the day of the week so that
+ // we know when to start a new row.
+ var dayOfWeek = firstDayOfTheWeek;
+ var iterationDate = firstDayOfMonth;
+ for (var d = 1; d <= numberOfDaysInMonth; d++) {
+ // If we've reached the end of the week, start a new row.
+ if (dayOfWeek === 7) {
+ // We've finished the first row, so we're done if this is the final month.
+ if (isFinalMonth) {
+ return monthBody;
+ }
+ dayOfWeek = 0;
+ rowNumber++;
+ row = this.buildDateRow(rowNumber);
+ monthBody.appendChild(row);
+ }
+
+ iterationDate.setDate(d);
+ var cell = this.buildDateCell(iterationDate);
+ row.appendChild(cell);
+
+ dayOfWeek++;
+ }
+
+ // Ensure that the last row of the month has 7 cells.
+ while (row.childNodes.length < 7) {
+ row.appendChild(this.buildDateCell());
+ }
+
+ // Ensure that all months have 6 rows. This is necessary for now because the virtual-repeat
+ // requires that all items have exactly the same height.
+ while (monthBody.childNodes.length < 6) {
+ var whitespaceRow = this.buildDateRow();
+ for (var j = 0; j < 7; j++) {
+ whitespaceRow.appendChild(this.buildDateCell());
+ }
+ monthBody.appendChild(whitespaceRow);
+ }
+
+ return monthBody;
+ };
+
+ /**
+ * Gets the day-of-the-week index for a date for the current locale.
+ * @private
+ * @param {Date} date
+ * @returns {number} The column index of the date in the calendar.
+ */
+ CalendarMonthBodyCtrl.prototype.getLocaleDay_ = function(date) {
+ return (date.getDay() + (7 - this.dateLocale.firstDayOfWeek)) % 7;
+ };
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ CalendarYearCtrl.$inject = ["$element", "$scope", "$animate", "$q", "$$mdDateUtil", "$mdUtil"];
+ angular.module('material.components.datepicker')
+ .directive('mdCalendarYear', calendarDirective);
+
+ /**
+ * Height of one calendar year tbody. This must be made known to the virtual-repeat and is
+ * subsequently used for scrolling to specific years.
+ */
+ var TBODY_HEIGHT = 88;
+
+ /** Private component, representing a list of years in the calendar. */
+ function calendarDirective() {
+ return {
+ template:
+ '<div class="md-calendar-scroll-mask">' +
+ '<md-virtual-repeat-container class="md-calendar-scroll-container">' +
+ '<table role="grid" tabindex="0" class="md-calendar" aria-readonly="true">' +
+ '<tbody ' +
+ 'md-calendar-year-body ' +
+ 'role="rowgroup" ' +
+ 'md-virtual-repeat="i in yearCtrl.items" ' +
+ 'md-year-offset="$index" class="md-calendar-year" ' +
+ 'md-start-index="yearCtrl.getFocusedYearIndex()" ' +
+ 'md-item-size="' + TBODY_HEIGHT + '">' +
+ // The <tr> ensures that the <tbody> will have the proper
+ // height, even though it may be empty.
+ '<tr aria-hidden="true" md-force-height="\'' + TBODY_HEIGHT + 'px\'"></tr>' +
+ '</tbody>' +
+ '</table>' +
+ '</md-virtual-repeat-container>' +
+ '</div>',
+ require: ['^^mdCalendar', 'mdCalendarYear'],
+ controller: CalendarYearCtrl,
+ controllerAs: 'yearCtrl',
+ bindToController: true,
+ link: function(scope, element, attrs, controllers) {
+ var calendarCtrl = controllers[0];
+ var yearCtrl = controllers[1];
+ yearCtrl.initialize(calendarCtrl);
+ }
+ };
+ }
+
+ /**
+ * Controller for the mdCalendar component.
+ * @ngInject @constructor
+ */
+ function CalendarYearCtrl($element, $scope, $animate, $q, $$mdDateUtil, $mdUtil) {
+
+ /** @final {!angular.JQLite} */
+ this.$element = $element;
+
+ /** @final {!angular.Scope} */
+ this.$scope = $scope;
+
+ /** @final {!angular.$animate} */
+ this.$animate = $animate;
+
+ /** @final {!angular.$q} */
+ this.$q = $q;
+
+ /** @final */
+ this.dateUtil = $$mdDateUtil;
+
+ /** @final {HTMLElement} */
+ this.calendarScroller = $element[0].querySelector('.md-virtual-repeat-scroller');
+
+ /** @type {boolean} */
+ this.isInitialized = false;
+
+ /** @type {boolean} */
+ this.isMonthTransitionInProgress = false;
+
+ /** @final */
+ this.$mdUtil = $mdUtil;
+
+ var self = this;
+
+ /**
+ * Handles a click event on a date cell.
+ * Created here so that every cell can use the same function instance.
+ * @this {HTMLTableCellElement} The cell that was clicked.
+ */
+ this.cellClickHandler = function() {
+ self.onTimestampSelected($$mdDateUtil.getTimestampFromNode(this));
+ };
+ }
+
+ /**
+ * Initialize the controller by saving a reference to the calendar and
+ * setting up the object that will be iterated by the virtual repeater.
+ */
+ CalendarYearCtrl.prototype.initialize = function(calendarCtrl) {
+ /**
+ * Dummy array-like object for virtual-repeat to iterate over. The length is the total
+ * number of years that can be viewed. We add 1 extra in order to include the current year.
+ */
+
+ this.items = {
+ length: this.dateUtil.getYearDistance(
+ calendarCtrl.firstRenderableDate,
+ calendarCtrl.lastRenderableDate
+ ) + 1
+ };
+
+ this.calendarCtrl = calendarCtrl;
+ this.attachScopeListeners();
+ calendarCtrl.updateVirtualRepeat();
+
+ // Fire the initial render, since we might have missed it the first time it fired.
+ calendarCtrl.ngModelCtrl && calendarCtrl.ngModelCtrl.$render();
+ };
+
+ /**
+ * Gets the "index" of the currently selected date as it would be in the virtual-repeat.
+ * @returns {number}
+ */
+ CalendarYearCtrl.prototype.getFocusedYearIndex = function() {
+ var calendarCtrl = this.calendarCtrl;
+
+ return this.dateUtil.getYearDistance(
+ calendarCtrl.firstRenderableDate,
+ calendarCtrl.displayDate || calendarCtrl.selectedDate || calendarCtrl.today
+ );
+ };
+
+ /**
+ * Change the date that is highlighted in the calendar.
+ * @param {Date} date
+ */
+ CalendarYearCtrl.prototype.changeDate = function(date) {
+ // Initialization is deferred until this function is called because we want to reflect
+ // the starting value of ngModel.
+ if (!this.isInitialized) {
+ this.calendarCtrl.hideVerticalScrollbar(this);
+ this.isInitialized = true;
+ return this.$q.when();
+ } else if (this.dateUtil.isValidDate(date) && !this.isMonthTransitionInProgress) {
+ var self = this;
+ var animationPromise = this.animateDateChange(date);
+
+ self.isMonthTransitionInProgress = true;
+ self.calendarCtrl.displayDate = date;
+
+ return animationPromise.then(function() {
+ self.isMonthTransitionInProgress = false;
+ });
+ }
+ };
+
+ /**
+ * Animates the transition from the calendar's current month to the given month.
+ * @param {Date} date
+ * @returns {angular.$q.Promise} The animation promise.
+ */
+ CalendarYearCtrl.prototype.animateDateChange = function(date) {
+ if (this.dateUtil.isValidDate(date)) {
+ var monthDistance = this.dateUtil.getYearDistance(this.calendarCtrl.firstRenderableDate, date);
+ this.calendarScroller.scrollTop = monthDistance * TBODY_HEIGHT;
+ }
+
+ return this.$q.when();
+ };
+
+ /**
+ * Handles the year-view-specific keyboard interactions.
+ * @param {Object} event Scope event object passed by the calendar.
+ * @param {String} action Action, corresponding to the key that was pressed.
+ */
+ CalendarYearCtrl.prototype.handleKeyEvent = function(event, action) {
+ var self = this;
+ var calendarCtrl = self.calendarCtrl;
+ var displayDate = calendarCtrl.displayDate;
+
+ if (action === 'select') {
+ self.changeDate(displayDate).then(function() {
+ self.onTimestampSelected(displayDate);
+ });
+ } else {
+ var date = null;
+ var dateUtil = self.dateUtil;
+
+ switch (action) {
+ case 'move-right': date = dateUtil.incrementMonths(displayDate, 1); break;
+ case 'move-left': date = dateUtil.incrementMonths(displayDate, -1); break;
+
+ case 'move-row-down': date = dateUtil.incrementMonths(displayDate, 6); break;
+ case 'move-row-up': date = dateUtil.incrementMonths(displayDate, -6); break;
+ }
+
+ if (date) {
+ var min = calendarCtrl.minDate ? dateUtil.getFirstDateOfMonth(calendarCtrl.minDate) : null;
+ var max = calendarCtrl.maxDate ? dateUtil.getFirstDateOfMonth(calendarCtrl.maxDate) : null;
+ date = dateUtil.getFirstDateOfMonth(self.dateUtil.clampDate(date, min, max));
+
+ self.changeDate(date).then(function() {
+ calendarCtrl.focusDate(date);
+ });
+ }
+ }
+ };
+
+ /**
+ * Attaches listeners for the scope events that are broadcast by the calendar.
+ */
+ CalendarYearCtrl.prototype.attachScopeListeners = function() {
+ var self = this;
+
+ self.$scope.$on('md-calendar-parent-changed', function(event, value) {
+ self.calendarCtrl.changeSelectedDate(value ? self.dateUtil.getFirstDateOfMonth(value) : value);
+ self.changeDate(value);
+ });
+
+ self.$scope.$on('md-calendar-parent-action', angular.bind(self, self.handleKeyEvent));
+ };
+
+ /**
+ * Handles the behavior when a date is selected. Depending on the `mode`
+ * of the calendar, this can either switch back to the calendar view or
+ * set the model value.
+ * @param {number} timestamp The selected timestamp.
+ */
+ CalendarYearCtrl.prototype.onTimestampSelected = function(timestamp) {
+ var calendarCtrl = this.calendarCtrl;
+
+ if (calendarCtrl.mode) {
+ this.$mdUtil.nextTick(function() {
+ // The timestamp has to be converted to a valid date.
+ calendarCtrl.setNgModelValue(new Date(timestamp));
+ });
+ } else {
+ calendarCtrl.setCurrentView('month', timestamp);
+ }
+ };
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ CalendarYearBodyCtrl.$inject = ["$element", "$$mdDateUtil", "$mdDateLocale"];
+ angular.module('material.components.datepicker')
+ .directive('mdCalendarYearBody', mdCalendarYearDirective);
+
+ /**
+ * Private component, consumed by the md-calendar-year, which separates the DOM construction logic
+ * and allows for the year view to use md-virtual-repeat.
+ */
+ function mdCalendarYearDirective() {
+ return {
+ require: ['^^mdCalendar', '^^mdCalendarYear', 'mdCalendarYearBody'],
+ scope: { offset: '=mdYearOffset' },
+ controller: CalendarYearBodyCtrl,
+ controllerAs: 'mdYearBodyCtrl',
+ bindToController: true,
+ link: function(scope, element, attrs, controllers) {
+ var calendarCtrl = controllers[0];
+ var yearCtrl = controllers[1];
+ var yearBodyCtrl = controllers[2];
+
+ yearBodyCtrl.calendarCtrl = calendarCtrl;
+ yearBodyCtrl.yearCtrl = yearCtrl;
+
+ scope.$watch(function() { return yearBodyCtrl.offset; }, function(offset) {
+ if (angular.isNumber(offset)) {
+ yearBodyCtrl.generateContent();
+ }
+ });
+ }
+ };
+ }
+
+ /**
+ * Controller for a single year.
+ * @ngInject @constructor
+ */
+ function CalendarYearBodyCtrl($element, $$mdDateUtil, $mdDateLocale) {
+ /**
+ * @final
+ * @type {!JQLite}
+ */
+ this.$element = $element;
+
+ /** @final */
+ this.dateUtil = $$mdDateUtil;
+
+ /** @final */
+ this.dateLocale = $mdDateLocale;
+
+ /** @type {Object} Reference to the calendar. */
+ this.calendarCtrl = null;
+
+ /** @type {Object} Reference to the year view. */
+ this.yearCtrl = null;
+
+ /**
+ * Number of months from the start of the month "items" that the currently rendered month
+ * occurs. Set via angular data binding.
+ * @type {number|null}
+ */
+ this.offset = null;
+
+ /**
+ * Date cell to focus after appending the month to the document.
+ * @type {HTMLElement}
+ */
+ this.focusAfterAppend = null;
+ }
+
+ /** Generate and append the content for this year to the directive element. */
+ CalendarYearBodyCtrl.prototype.generateContent = function() {
+ var date = this.dateUtil.incrementYears(this.calendarCtrl.firstRenderableDate, this.offset);
+
+ this.$element
+ .empty()
+ .append(this.buildCalendarForYear(date));
+
+ if (this.focusAfterAppend) {
+ this.focusAfterAppend.classList.add(this.calendarCtrl.FOCUSED_DATE_CLASS);
+ this.focusAfterAppend = null;
+ }
+ };
+
+ /**
+ * Creates a single cell to contain a year in the calendar.
+ * @param {number} year Four-digit year.
+ * @param {number} month Zero-indexed month.
+ * @returns {HTMLElement}
+ */
+ CalendarYearBodyCtrl.prototype.buildMonthCell = function(year, month) {
+ var calendarCtrl = this.calendarCtrl;
+ var yearCtrl = this.yearCtrl;
+ var cell = this.buildBlankCell();
+
+ // Represent this month/year as a date.
+ var firstOfMonth = new Date(year, month, 1);
+ cell.setAttribute('aria-label', this.dateLocale.monthFormatter(firstOfMonth));
+ cell.id = calendarCtrl.getDateId(firstOfMonth, 'year');
+
+ // Use `data-timestamp` attribute because IE10 does not support the `dataset` property.
+ cell.setAttribute('data-timestamp', String(firstOfMonth.getTime()));
+
+ if (this.dateUtil.isSameMonthAndYear(firstOfMonth, calendarCtrl.today)) {
+ cell.classList.add(calendarCtrl.TODAY_CLASS);
+ }
+
+ if (this.dateUtil.isValidDate(calendarCtrl.selectedDate) &&
+ this.dateUtil.isSameMonthAndYear(firstOfMonth, calendarCtrl.selectedDate)) {
+ cell.classList.add(calendarCtrl.SELECTED_DATE_CLASS);
+ cell.setAttribute('aria-selected', 'true');
+ }
+
+ var cellText = this.dateLocale.shortMonths[month];
+
+ if (this.dateUtil.isMonthWithinRange(
+ firstOfMonth, calendarCtrl.minDate, calendarCtrl.maxDate) &&
+ (!angular.isFunction(calendarCtrl.monthFilter) ||
+ calendarCtrl.monthFilter(firstOfMonth))) {
+ var selectionIndicator = document.createElement('span');
+ selectionIndicator.classList.add('md-calendar-date-selection-indicator');
+ selectionIndicator.textContent = cellText;
+ cell.appendChild(selectionIndicator);
+ cell.addEventListener('click', yearCtrl.cellClickHandler);
+
+ if (calendarCtrl.displayDate &&
+ this.dateUtil.isSameMonthAndYear(firstOfMonth, calendarCtrl.displayDate)) {
+ this.focusAfterAppend = cell;
+ }
+ } else {
+ cell.classList.add('md-calendar-date-disabled');
+ cell.textContent = cellText;
+ }
+
+ return cell;
+ };
+
+ /**
+ * Builds a blank cell.
+ * @return {HTMLElement}
+ */
+ CalendarYearBodyCtrl.prototype.buildBlankCell = function() {
+ var cell = document.createElement('td');
+ cell.tabIndex = -1;
+ cell.classList.add('md-calendar-date');
+ cell.setAttribute('role', 'gridcell');
+
+ cell.setAttribute('tabindex', '-1');
+ return cell;
+ };
+
+ /**
+ * Builds the <tbody> content for the given year.
+ * @param {Date} date Date for which the content should be built.
+ * @returns {DocumentFragment} A document fragment containing the months within the year.
+ */
+ CalendarYearBodyCtrl.prototype.buildCalendarForYear = function(date) {
+ // Store rows for the month in a document fragment so that we can append them all at once.
+ var year = date.getFullYear();
+ var yearBody = document.createDocumentFragment();
+
+ var monthCell, i;
+ // First row contains label and Jan-Jun.
+ var firstRow = document.createElement('tr');
+ var labelCell = document.createElement('td');
+ labelCell.className = 'md-calendar-month-label';
+ labelCell.textContent = String(year);
+ firstRow.appendChild(labelCell);
+
+ for (i = 0; i < 6; i++) {
+ firstRow.appendChild(this.buildMonthCell(year, i));
+ }
+ yearBody.appendChild(firstRow);
+
+ // Second row contains a blank cell and Jul-Dec.
+ var secondRow = document.createElement('tr');
+ secondRow.appendChild(this.buildBlankCell());
+ for (i = 6; i < 12; i++) {
+ secondRow.appendChild(this.buildMonthCell(year, i));
+ }
+ yearBody.appendChild(secondRow);
+
+ return yearBody;
+ };
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * @ngdoc service
+ * @name $mdDateLocaleProvider
+ * @module material.components.datepicker
+ *
+ * @description
+ * The `$mdDateLocaleProvider` is the provider that creates the `$mdDateLocale` service.
+ * This provider that allows the user to specify messages, formatters, and parsers for date
+ * internationalization. The `$mdDateLocale` service itself is consumed by AngularJS Material
+ * components that deal with dates
+ * (i.e. <a ng-href="api/directive/mdDatepicker">mdDatepicker</a>).
+ *
+ * @property {Array<string>} months Array of month names (in order).
+ * @property {Array<string>} shortMonths Array of abbreviated month names.
+ * @property {Array<string>} days Array of the days of the week (in order).
+ * @property {Array<string>} shortDays Array of abbreviated days of the week.
+ * @property {Array<string>} dates Array of dates of the month. Only necessary for locales
+ * using a numeral system other than [1, 2, 3...].
+ * @property {Array<string>} firstDayOfWeek The first day of the week. Sunday = 0, Monday = 1,
+ * etc.
+ * @property {function(string): Date} parseDate Function that converts a date string to a Date
+ * object (the date portion).
+ * @property {function(Date, string): string} formatDate Function to format a date object to a
+ * string. The datepicker directive also provides the time zone, if it was specified.
+ * @property {function(Date): string} monthHeaderFormatter Function that returns the label for
+ * a month given a date.
+ * @property {function(Date): string} monthFormatter Function that returns the full name of a month
+ * for a given date.
+ * @property {function(number): string} weekNumberFormatter Function that returns a label for
+ * a week given the week number.
+ * @property {function(Date): string} longDateFormatter Function that formats a date into a long
+ * `aria-label` that is read by the screen reader when the focused date changes.
+ * @property {string} msgCalendar Translation of the label "Calendar" for the current locale.
+ * @property {string} msgOpenCalendar Translation of the button label "Open calendar" for the
+ * current locale.
+ * @property {Date} firstRenderableDate The date from which the datepicker calendar will begin
+ * rendering. Note that this will be ignored if a minimum date is set.
+ * Defaults to January 1st 1880.
+ * @property {Date} lastRenderableDate The last date that will be rendered by the datepicker
+ * calendar. Note that this will be ignored if a maximum date is set.
+ * Defaults to January 1st 2130.
+ * @property {function(string): boolean} isDateComplete Function to determine whether a string
+ * makes sense to be parsed to a `Date` object. Returns `true` if the date appears to be complete
+ * and parsing should occur. By default, this checks for 3 groups of text or numbers separated
+ * by delimiters. This means that by default, date strings must include a month, day, and year
+ * to be parsed and for the model to be updated.
+ *
+ * @usage
+ * <hljs lang="js">
+ * myAppModule.config(function($mdDateLocaleProvider) {
+ *
+ * // Example of a French localization.
+ * $mdDateLocaleProvider.months = ['janvier', 'février', 'mars', ...];
+ * $mdDateLocaleProvider.shortMonths = ['janv', 'févr', 'mars', ...];
+ * $mdDateLocaleProvider.days = ['dimanche', 'lundi', 'mardi', ...];
+ * $mdDateLocaleProvider.shortDays = ['Di', 'Lu', 'Ma', ...];
+ *
+ * // Can change week display to start on Monday.
+ * $mdDateLocaleProvider.firstDayOfWeek = 1;
+ *
+ * // Optional.
+ * $mdDateLocaleProvider.dates = [1, 2, 3, 4, 5, 6, ...];
+ *
+ * // Example uses moment.js to parse and format dates.
+ * $mdDateLocaleProvider.parseDate = function(dateString) {
+ * var m = moment(dateString, 'L', true);
+ * return m.isValid() ? m.toDate() : new Date(NaN);
+ * };
+ *
+ * $mdDateLocaleProvider.formatDate = function(date) {
+ * var m = moment(date);
+ * return m.isValid() ? m.format('L') : '';
+ * };
+ *
+ * // Allow only a day and month to be specified.
+ * // This is required if using the 'M/D' format with moment.js.
+ * $mdDateLocaleProvider.isDateComplete = function(dateString) {
+ * dateString = dateString.trim();
+ *
+ * // Look for two chunks of content (either numbers or text) separated by delimiters.
+ * var re = /^(([a-zA-Z]{3,}|[0-9]{1,4})([ .,]+|[/-]))([a-zA-Z]{3,}|[0-9]{1,4})/;
+ * return re.test(dateString);
+ * };
+ *
+ * $mdDateLocaleProvider.monthHeaderFormatter = function(date) {
+ * return myShortMonths[date.getMonth()] + ' ' + date.getFullYear();
+ * };
+ *
+ * // In addition to date display, date components also need localized messages
+ * // for aria-labels for screen-reader users.
+ *
+ * $mdDateLocaleProvider.weekNumberFormatter = function(weekNumber) {
+ * return 'Semaine ' + weekNumber;
+ * };
+ *
+ * $mdDateLocaleProvider.msgCalendar = 'Calendrier';
+ * $mdDateLocaleProvider.msgOpenCalendar = 'Ouvrir le calendrier';
+ *
+ * // You can also set when your calendar begins and ends.
+ * $mdDateLocaleProvider.firstRenderableDate = new Date(1776, 6, 4);
+ * $mdDateLocaleProvider.lastRenderableDate = new Date(2012, 11, 21);
+ * });
+ * </hljs>
+ *
+ */
+ angular.module('material.components.datepicker').config(["$provide", function($provide) {
+ // TODO(jelbourn): Assert provided values are correctly formatted. Need assertions.
+
+ /** @constructor */
+ function DateLocaleProvider() {
+ /** Array of full month names. E.g., ['January', 'February', ...] */
+ this.months = null;
+
+ /** Array of abbreviated month names. E.g., ['Jan', 'Feb', ...] */
+ this.shortMonths = null;
+
+ /** Array of full day of the week names. E.g., ['Monday', 'Tuesday', ...] */
+ this.days = null;
+
+ /** Array of abbreviated dat of the week names. E.g., ['M', 'T', ...] */
+ this.shortDays = null;
+
+ /** Array of dates of a month (1 - 31). Characters might be different in some locales. */
+ this.dates = null;
+
+ /** Index of the first day of the week. 0 = Sunday, 1 = Monday, etc. */
+ this.firstDayOfWeek = 0;
+
+ /**
+ * Function that converts the date portion of a Date to a string.
+ * @type {(function(Date): string)}
+ */
+ this.formatDate = null;
+
+ /**
+ * Function that converts a date string to a Date object (the date portion)
+ * @type {function(string): Date}
+ */
+ this.parseDate = null;
+
+ /**
+ * Function that formats a Date into a month header string.
+ * @type {function(Date): string}
+ */
+ this.monthHeaderFormatter = null;
+
+ /**
+ * Function that formats a week number into a label for the week.
+ * @type {function(number): string}
+ */
+ this.weekNumberFormatter = null;
+
+ /**
+ * Function that formats a date into a long aria-label that is read
+ * when the focused date changes.
+ * @type {function(Date): string}
+ */
+ this.longDateFormatter = null;
+
+ /**
+ * Function to determine whether a string makes sense to be
+ * parsed to a Date object.
+ * @type {function(string): boolean}
+ */
+ this.isDateComplete = null;
+
+ /**
+ * ARIA label for the calendar "dialog" used in the datepicker.
+ * @type {string}
+ */
+ this.msgCalendar = '';
+
+ /**
+ * ARIA label for the datepicker's "Open calendar" buttons.
+ * @type {string}
+ */
+ this.msgOpenCalendar = '';
+ }
+
+ /**
+ * Factory function that returns an instance of the dateLocale service.
+ * @ngInject
+ * @param $locale
+ * @param $filter
+ * @returns {DateLocale}
+ */
+ DateLocaleProvider.prototype.$get = function($locale, $filter) {
+ /**
+ * Default date-to-string formatting function.
+ * @param {!Date} date
+ * @param {string=} timezone
+ * @returns {string}
+ */
+ function defaultFormatDate(date, timezone) {
+ if (!date) {
+ return '';
+ }
+
+ // All of the dates created through ng-material *should* be set to midnight.
+ // If we encounter a date where the localeTime shows at 11pm instead of midnight,
+ // we have run into an issue with DST where we need to increment the hour by one:
+ // var d = new Date(1992, 9, 8, 0, 0, 0);
+ // d.toLocaleString(); // == "10/7/1992, 11:00:00 PM"
+ var localeTime = date.toLocaleTimeString();
+ var formatDate = date;
+ if (date.getHours() === 0 &&
+ (localeTime.indexOf('11:') !== -1 || localeTime.indexOf('23:') !== -1)) {
+ formatDate = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 1, 0, 0);
+ }
+
+ return $filter('date')(formatDate, 'M/d/yyyy', timezone);
+ }
+
+ /**
+ * Default string-to-date parsing function.
+ * @param {string|number} dateString
+ * @returns {!Date}
+ */
+ function defaultParseDate(dateString) {
+ return new Date(dateString);
+ }
+
+ /**
+ * Default function to determine whether a string makes sense to be
+ * parsed to a Date object.
+ *
+ * This is very permissive and is just a basic check to ensure that
+ * things like single integers aren't able to be parsed into dates.
+ * @param {string} dateString
+ * @returns {boolean}
+ */
+ function defaultIsDateComplete(dateString) {
+ dateString = dateString.trim();
+
+ // Looks for three chunks of content (either numbers or text) separated
+ // by delimiters.
+ var re = /^(([a-zA-Z]{3,}|[0-9]{1,4})([ .,]+|[/-])){2}([a-zA-Z]{3,}|[0-9]{1,4})$/;
+ return re.test(dateString);
+ }
+
+ /**
+ * Default date-to-string formatter to get a month header.
+ * @param {!Date} date
+ * @returns {string}
+ */
+ function defaultMonthHeaderFormatter(date) {
+ return service.shortMonths[date.getMonth()] + ' ' + date.getFullYear();
+ }
+
+ /**
+ * Default formatter for a month.
+ * @param {!Date} date
+ * @returns {string}
+ */
+ function defaultMonthFormatter(date) {
+ return service.months[date.getMonth()] + ' ' + date.getFullYear();
+ }
+
+ /**
+ * Default week number formatter.
+ * @param number
+ * @returns {string}
+ */
+ function defaultWeekNumberFormatter(number) {
+ return 'Week ' + number;
+ }
+
+ /**
+ * Default formatter for date cell aria-labels.
+ * @param {!Date} date
+ * @returns {string}
+ */
+ function defaultLongDateFormatter(date) {
+ // Example: 'Thursday June 18 2015'
+ return [
+ service.days[date.getDay()],
+ service.months[date.getMonth()],
+ service.dates[date.getDate()],
+ date.getFullYear()
+ ].join(' ');
+ }
+
+ // The default "short" day strings are the first character of each day,
+ // e.g., "Monday" => "M".
+ var defaultShortDays = $locale.DATETIME_FORMATS.SHORTDAY.map(function(day) {
+ return day.substring(0, 1);
+ });
+
+ // The default dates are simply the numbers 1 through 31.
+ var defaultDates = Array(32);
+ for (var i = 1; i <= 31; i++) {
+ defaultDates[i] = i;
+ }
+
+ // Default ARIA messages are in English (US).
+ var defaultMsgCalendar = 'Calendar';
+ var defaultMsgOpenCalendar = 'Open calendar';
+
+ // Default start/end dates that are rendered in the calendar.
+ var defaultFirstRenderableDate = new Date(1880, 0, 1);
+ var defaultLastRendereableDate = new Date(defaultFirstRenderableDate.getFullYear() + 250, 0, 1);
+
+ var service = {
+ months: this.months || $locale.DATETIME_FORMATS.MONTH,
+ shortMonths: this.shortMonths || $locale.DATETIME_FORMATS.SHORTMONTH,
+ days: this.days || $locale.DATETIME_FORMATS.DAY,
+ shortDays: this.shortDays || defaultShortDays,
+ dates: this.dates || defaultDates,
+ firstDayOfWeek: this.firstDayOfWeek || 0,
+ formatDate: this.formatDate || defaultFormatDate,
+ parseDate: this.parseDate || defaultParseDate,
+ isDateComplete: this.isDateComplete || defaultIsDateComplete,
+ monthHeaderFormatter: this.monthHeaderFormatter || defaultMonthHeaderFormatter,
+ monthFormatter: this.monthFormatter || defaultMonthFormatter,
+ weekNumberFormatter: this.weekNumberFormatter || defaultWeekNumberFormatter,
+ longDateFormatter: this.longDateFormatter || defaultLongDateFormatter,
+ msgCalendar: this.msgCalendar || defaultMsgCalendar,
+ msgOpenCalendar: this.msgOpenCalendar || defaultMsgOpenCalendar,
+ firstRenderableDate: this.firstRenderableDate || defaultFirstRenderableDate,
+ lastRenderableDate: this.lastRenderableDate || defaultLastRendereableDate
+ };
+
+ return service;
+ };
+ DateLocaleProvider.prototype.$get.$inject = ["$locale", "$filter"];
+
+ $provide.provider('$mdDateLocale', new DateLocaleProvider());
+ }]);
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * Utility for performing date calculations to facilitate operation of the calendar and
+ * datepicker.
+ */
+ angular.module('material.components.datepicker').factory('$$mdDateUtil', ["$mdDateLocale", function($mdDateLocale) {
+ return {
+ getFirstDateOfMonth: getFirstDateOfMonth,
+ getNumberOfDaysInMonth: getNumberOfDaysInMonth,
+ getDateInNextMonth: getDateInNextMonth,
+ getDateInPreviousMonth: getDateInPreviousMonth,
+ isInNextMonth: isInNextMonth,
+ isInPreviousMonth: isInPreviousMonth,
+ getDateMidpoint: getDateMidpoint,
+ isSameMonthAndYear: isSameMonthAndYear,
+ getWeekOfMonth: getWeekOfMonth,
+ incrementDays: incrementDays,
+ incrementMonths: incrementMonths,
+ getLastDateOfMonth: getLastDateOfMonth,
+ isSameDay: isSameDay,
+ getMonthDistance: getMonthDistance,
+ isValidDate: isValidDate,
+ setDateTimeToMidnight: setDateTimeToMidnight,
+ createDateAtMidnight: createDateAtMidnight,
+ isDateWithinRange: isDateWithinRange,
+ incrementYears: incrementYears,
+ getYearDistance: getYearDistance,
+ clampDate: clampDate,
+ getTimestampFromNode: getTimestampFromNode,
+ isMonthWithinRange: isMonthWithinRange,
+ removeLocalTzAndReparseDate: removeLocalTzAndReparseDate
+ };
+
+ /**
+ * Gets the first day of the month for the given date's month.
+ * @param {Date} date
+ * @returns {Date}
+ */
+ function getFirstDateOfMonth(date) {
+ return new Date(date.getFullYear(), date.getMonth(), 1);
+ }
+
+ /**
+ * Gets the number of days in the month for the given date's month.
+ * @param date
+ * @returns {number}
+ */
+ function getNumberOfDaysInMonth(date) {
+ return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+ }
+
+ /**
+ * Get an arbitrary date in the month after the given date's month.
+ * @param date
+ * @returns {Date}
+ */
+ function getDateInNextMonth(date) {
+ return new Date(date.getFullYear(), date.getMonth() + 1, 1);
+ }
+
+ /**
+ * Get an arbitrary date in the month before the given date's month.
+ * @param date
+ * @returns {Date}
+ */
+ function getDateInPreviousMonth(date) {
+ return new Date(date.getFullYear(), date.getMonth() - 1, 1);
+ }
+
+ /**
+ * Gets whether two dates have the same month and year.
+ * @param {Date} d1
+ * @param {Date} d2
+ * @returns {boolean}
+ */
+ function isSameMonthAndYear(d1, d2) {
+ return d1.getFullYear() === d2.getFullYear() && d1.getMonth() === d2.getMonth();
+ }
+
+ /**
+ * Gets whether two dates are the same day (not not necessarily the same time).
+ * @param {Date} d1
+ * @param {Date} d2
+ * @returns {boolean}
+ */
+ function isSameDay(d1, d2) {
+ return d1.getDate() == d2.getDate() && isSameMonthAndYear(d1, d2);
+ }
+
+ /**
+ * Gets whether a date is in the month immediately after some date.
+ * @param {Date} startDate The date from which to compare.
+ * @param {Date} endDate The date to check.
+ * @returns {boolean}
+ */
+ function isInNextMonth(startDate, endDate) {
+ var nextMonth = getDateInNextMonth(startDate);
+ return isSameMonthAndYear(nextMonth, endDate);
+ }
+
+ /**
+ * Gets whether a date is in the month immediately before some date.
+ * @param {Date} startDate The date from which to compare.
+ * @param {Date} endDate The date to check.
+ * @returns {boolean}
+ */
+ function isInPreviousMonth(startDate, endDate) {
+ var previousMonth = getDateInPreviousMonth(startDate);
+ return isSameMonthAndYear(endDate, previousMonth);
+ }
+
+ /**
+ * Gets the midpoint between two dates.
+ * @param {Date} d1
+ * @param {Date} d2
+ * @returns {Date}
+ */
+ function getDateMidpoint(d1, d2) {
+ return createDateAtMidnight((d1.getTime() + d2.getTime()) / 2);
+ }
+
+ /**
+ * Gets the week of the month that a given date occurs in.
+ * @param {Date} date
+ * @returns {number} Index of the week of the month (zero-based).
+ */
+ function getWeekOfMonth(date) {
+ var firstDayOfMonth = getFirstDateOfMonth(date);
+ return Math.floor((firstDayOfMonth.getDay() + date.getDate() - 1) / 7);
+ }
+
+ /**
+ * Gets a new date incremented by the given number of days. Number of days can be negative.
+ * @param {Date} date
+ * @param {number} numberOfDays
+ * @returns {Date}
+ */
+ function incrementDays(date, numberOfDays) {
+ return new Date(date.getFullYear(), date.getMonth(), date.getDate() + numberOfDays);
+ }
+
+ /**
+ * Gets a new date incremented by the given number of months. Number of months can be negative.
+ * If the date of the given month does not match the target month, the date will be set to the
+ * last day of the month.
+ * @param {Date} date
+ * @param {number} numberOfMonths
+ * @returns {Date}
+ */
+ function incrementMonths(date, numberOfMonths) {
+ // If the same date in the target month does not actually exist, the Date object will
+ // automatically advance *another* month by the number of missing days.
+ // For example, if you try to go from Jan. 30 to Feb. 30, you'll end up on March 2.
+ // So, we check if the month overflowed and go to the last day of the target month instead.
+ var dateInTargetMonth = new Date(date.getFullYear(), date.getMonth() + numberOfMonths, 1);
+ var numberOfDaysInMonth = getNumberOfDaysInMonth(dateInTargetMonth);
+ if (numberOfDaysInMonth < date.getDate()) {
+ dateInTargetMonth.setDate(numberOfDaysInMonth);
+ } else {
+ dateInTargetMonth.setDate(date.getDate());
+ }
+
+ return dateInTargetMonth;
+ }
+
+ /**
+ * Get the integer distance between two months. This *only* considers the month and year
+ * portion of the Date instances.
+ *
+ * @param {Date} start
+ * @param {Date} end
+ * @returns {number} Number of months between `start` and `end`. If `end` is before `start`
+ * chronologically, this number will be negative.
+ */
+ function getMonthDistance(start, end) {
+ return (12 * (end.getFullYear() - start.getFullYear())) + (end.getMonth() - start.getMonth());
+ }
+
+ /**
+ * Gets the last day of the month for the given date.
+ * @param {Date} date
+ * @returns {Date}
+ */
+ function getLastDateOfMonth(date) {
+ return new Date(date.getFullYear(), date.getMonth(), getNumberOfDaysInMonth(date));
+ }
+
+ /**
+ * Checks whether a date is valid.
+ * @param {Date} date
+ * @return {boolean} Whether the date is a valid Date.
+ */
+ function isValidDate(date) {
+ return date && date.getTime && !isNaN(date.getTime());
+ }
+
+ /**
+ * Sets a date's time to midnight.
+ * @param {Date} date
+ */
+ function setDateTimeToMidnight(date) {
+ if (isValidDate(date)) {
+ date.setHours(0, 0, 0, 0);
+ }
+ }
+
+ /**
+ * Creates a date with the time set to midnight.
+ * Drop-in replacement for two forms of the Date constructor via opt_value.
+ * @param {number|Date=} opt_value Leave undefined for a Date representing now. Or use a
+ * single value representing the number of seconds since the Unix Epoch or a Date object.
+ * @return {Date} New date with time set to midnight.
+ */
+ function createDateAtMidnight(opt_value) {
+ var date;
+ if (angular.isDate(opt_value)) {
+ date = opt_value;
+ } else if (angular.isNumber(opt_value)) {
+ date = new Date(opt_value);
+ } else {
+ date = new Date();
+ }
+ setDateTimeToMidnight(date);
+ return date;
+ }
+
+ /**
+ * Checks if a date is within a min and max range, ignoring the time component.
+ * If minDate or maxDate are not dates, they are ignored.
+ * @param {Date} date
+ * @param {Date} minDate
+ * @param {Date} maxDate
+ */
+ function isDateWithinRange(date, minDate, maxDate) {
+ var dateAtMidnight = createDateAtMidnight(date);
+ var minDateAtMidnight = isValidDate(minDate) ? createDateAtMidnight(minDate) : null;
+ var maxDateAtMidnight = isValidDate(maxDate) ? createDateAtMidnight(maxDate) : null;
+ return (!minDateAtMidnight || minDateAtMidnight <= dateAtMidnight) &&
+ (!maxDateAtMidnight || maxDateAtMidnight >= dateAtMidnight);
+ }
+
+ /**
+ * Gets a new date incremented by the given number of years. Number of years can be negative.
+ * See `incrementMonths` for notes on overflow for specific dates.
+ * @param {Date} date
+ * @param {number} numberOfYears
+ * @returns {Date}
+ */
+ function incrementYears(date, numberOfYears) {
+ return incrementMonths(date, numberOfYears * 12);
+ }
+
+ /**
+ * Get the integer distance between two years. This *only* considers the year portion of the
+ * Date instances.
+ *
+ * @param {Date} start
+ * @param {Date} end
+ * @returns {number} Number of months between `start` and `end`. If `end` is before `start`
+ * chronologically, this number will be negative.
+ */
+ function getYearDistance(start, end) {
+ return end.getFullYear() - start.getFullYear();
+ }
+
+ /**
+ * Clamps a date between a minimum and a maximum date.
+ * @param {Date} date Date to be clamped
+ * @param {Date=} minDate Minimum date
+ * @param {Date=} maxDate Maximum date
+ * @return {Date}
+ */
+ function clampDate(date, minDate, maxDate) {
+ var boundDate = date;
+ if (minDate && date < minDate) {
+ boundDate = new Date(minDate.getTime());
+ }
+ if (maxDate && date > maxDate) {
+ boundDate = new Date(maxDate.getTime());
+ }
+ return boundDate;
+ }
+
+ /**
+ * Extracts and parses the timestamp from a DOM node.
+ * @param {HTMLElement} node Node from which the timestamp will be extracted.
+ * @return {number} Time since epoch.
+ */
+ function getTimestampFromNode(node) {
+ if (node && node.hasAttribute('data-timestamp')) {
+ return Number(node.getAttribute('data-timestamp'));
+ }
+ }
+
+ /**
+ * Checks if a month is within a min and max range, ignoring the date and time components.
+ * If minDate or maxDate are not dates, they are ignored.
+ * @param {Date} date
+ * @param {Date} minDate
+ * @param {Date} maxDate
+ */
+ function isMonthWithinRange(date, minDate, maxDate) {
+ var month = date.getMonth();
+ var year = date.getFullYear();
+
+ return (!minDate || minDate.getFullYear() < year || minDate.getMonth() <= month) &&
+ (!maxDate || maxDate.getFullYear() > year || maxDate.getMonth() >= month);
+ }
+
+ /**
+ * @param {Date} value date in local timezone
+ * @return {Date} date with local timezone offset removed
+ */
+ function removeLocalTzAndReparseDate(value) {
+ var dateValue, formattedDate;
+ // Remove the local timezone offset before calling formatDate.
+ dateValue = new Date(value.getTime() + 60000 * value.getTimezoneOffset());
+ formattedDate = $mdDateLocale.formatDate(dateValue);
+ // parseDate only works with a date formatted by formatDate when using Moment validation.
+ return $mdDateLocale.parseDate(formattedDate);
+ }
+ }]);
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ // TODO(jelbourn): forward more attributes to the internal input (required, autofocus, etc.)
+ // TODO(jelbourn): something better for mobile (calendar panel takes up entire screen?)
+ // TODO(jelbourn): input behavior (masking? auto-complete?)
+
+ DatePickerCtrl.$inject = ["$scope", "$element", "$attrs", "$window", "$mdConstant", "$mdTheming", "$mdUtil", "$mdDateLocale", "$$mdDateUtil", "$$rAF", "$filter", "$timeout"];
+ datePickerDirective.$inject = ["$$mdSvgRegistry", "$mdUtil", "$mdAria", "inputDirective"];
+ angular.module('material.components.datepicker')
+ .directive('mdDatepicker', datePickerDirective);
+
+ /**
+ * @ngdoc directive
+ * @name mdDatepicker
+ * @module material.components.datepicker
+ *
+ * @param {Date} ng-model The component's model. Expects either a JavaScript Date object or a
+ * value that can be parsed into one (e.g. a ISO 8601 string).
+ * @param {Object=} ng-model-options Allows tuning of the way in which `ng-model` is being
+ * updated. Also allows for a timezone to be specified.
+ * <a href="https://docs.angularjs.org/api/ng/directive/ngModelOptions#usage">
+ * Read more at the ngModelOptions docs.</a>
+ * @param {expression=} ng-change Expression evaluated when the model value changes.
+ * @param {expression=} ng-focus Expression evaluated when the input is focused or the calendar
+ * is opened.
+ * @param {expression=} ng-blur Expression evaluated when focus is removed from the input or the
+ * calendar is closed.
+ * @param {boolean=} ng-disabled Whether the datepicker is disabled.
+ * @param {boolean=} ng-required Whether a value is required for the datepicker.
+ * @param {Date=} md-min-date Expression representing a min date (inclusive).
+ * @param {Date=} md-max-date Expression representing a max date (inclusive).
+ * @param {(function(Date): boolean)=} md-date-filter Function expecting a date and returning a
+ * boolean whether it can be selected in "day" mode or not. Returning false will also trigger a
+ * `filtered` model validation error.
+ * @param {(function(Date): boolean)=} md-month-filter Function expecting a date and returning a
+ * boolean whether it can be selected in "month" mode or not. Returning false will also trigger a
+ * `filtered` model validation error.
+ * @param {string=} md-placeholder The date input placeholder value.
+ * @param {string=} md-open-on-focus When present, the calendar will be opened when the input
+ * is focused.
+ * @param {Boolean=} md-is-open Expression that can be used to open the datepicker's calendar
+ * on-demand.
+ * @param {string=} md-current-view Default open view of the calendar pane. Can be either
+ * "month" or "year".
+ * @param {string=} md-mode Restricts the user to only selecting a value from a particular view.
+ * This option can be used if the user is only supposed to choose from a certain date type
+ * (e.g. only selecting the month).
+ * Can be either "month" or "day". **Note** that this will overwrite the `md-current-view` value.
+ * @param {string=} md-hide-icons Determines which datepicker icons should be hidden. Note that
+ * this may cause the datepicker to not align properly with other components.
+ * **Use at your own risk.** Possible values are:
+ * * `"all"` - Hides all icons.
+ * * `"calendar"` - Only hides the calendar icon.
+ * * `"triangle"` - Only hides the triangle icon.
+ * @param {Object=} md-date-locale Allows for the values from the `$mdDateLocaleProvider` to be
+ * overwritten on a per-element basis (e.g. `msgOpenCalendar` can be overwritten with
+ * `md-date-locale="{ msgOpenCalendar: 'Open a special calendar' }"`).
+ * @param {string=} input-aria-describedby A space-separated list of element IDs. This should
+ * contain the IDs of any elements that describe this datepicker. Screen readers will read the
+ * content of these elements at the end of announcing that the datepicker has been selected
+ * and describing its current state. The descriptive elements do not need to be visible on the
+ * page.
+ * @param {string=} input-aria-labelledby A space-separated list of element IDs. The ideal use
+ * case is that this would contain the ID of a `<label>` element should be associated with this
+ * datepicker. This is necessary when using `md-datepicker` inside of an `md-input-container`
+ * with a `<label>`.<br><br>
+ * For `<label id="start-date">Start Date</label>`, you would set this to
+ * `input-aria-labelledby="start-date"`.
+ *
+ * @description
+ * `<md-datepicker>` is a component used to select a single date.
+ * For information on how to configure internationalization for the date picker,
+ * see <a ng-href="api/service/$mdDateLocaleProvider">$mdDateLocaleProvider</a>.
+ *
+ * This component supports
+ * [ngMessages](https://docs.angularjs.org/api/ngMessages/directive/ngMessages).
+ * Supported attributes are:
+ * * `required`: whether a required date is not set.
+ * * `mindate`: whether the selected date is before the minimum allowed date.
+ * * `maxdate`: whether the selected date is after the maximum allowed date.
+ * * `debounceInterval`: ms to delay input processing (since last debounce reset);
+ * default value 500ms
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-datepicker ng-model="birthday"></md-datepicker>
+ * </hljs>
+ *
+ */
+
+ function datePickerDirective($$mdSvgRegistry, $mdUtil, $mdAria, inputDirective) {
+ return {
+ template: function(tElement, tAttrs) {
+ // Buttons are not in the tab order because users can open the calendar via keyboard
+ // interaction on the text input, and multiple tab stops for one component (picker)
+ // may be confusing.
+ var hiddenIcons = tAttrs.mdHideIcons;
+ var inputAriaDescribedby = tAttrs.inputAriaDescribedby;
+ var inputAriaLabelledby = tAttrs.inputAriaLabelledby;
+ var ariaLabelValue = tAttrs.ariaLabel || tAttrs.mdPlaceholder;
+ var ngModelOptions = tAttrs.ngModelOptions;
+
+ var calendarButton = (hiddenIcons === 'all' || hiddenIcons === 'calendar') ? '' :
+ '<md-button class="md-datepicker-button md-icon-button" type="button" ' +
+ 'tabindex="-1" aria-hidden="true" ' +
+ 'ng-click="ctrl.openCalendarPane($event)">' +
+ '<md-icon class="md-datepicker-calendar-icon" aria-label="md-calendar" ' +
+ 'md-svg-src="' + $$mdSvgRegistry.mdCalendar + '"></md-icon>' +
+ '</md-button>';
+
+ var triangleButton = '';
+
+ if (hiddenIcons !== 'all' && hiddenIcons !== 'triangle') {
+ triangleButton = '' +
+ '<md-button type="button" md-no-ink ' +
+ 'class="md-datepicker-triangle-button md-icon-button" ' +
+ 'ng-click="ctrl.openCalendarPane($event)" ' +
+ 'aria-label="{{::ctrl.locale.msgOpenCalendar}}">' +
+ '<div class="md-datepicker-expand-triangle"></div>' +
+ '</md-button>';
+
+ tElement.addClass(HAS_TRIANGLE_ICON_CLASS);
+ }
+
+ return calendarButton +
+ '<div class="md-datepicker-input-container" ng-class="{\'md-datepicker-focused\': ctrl.isFocused}">' +
+ '<input ' +
+ (ariaLabelValue ? 'aria-label="' + ariaLabelValue + '" ' : '') +
+ (inputAriaDescribedby ? 'aria-describedby="' + inputAriaDescribedby + '" ' : '') +
+ (inputAriaLabelledby ? 'aria-labelledby="' + inputAriaLabelledby + '" ' : '') +
+ 'class="md-datepicker-input" ' +
+ 'aria-haspopup="dialog" ' +
+ 'ng-focus="ctrl.setFocused(true)" ' +
+ 'ng-blur="ctrl.setFocused(false)"> ' +
+ triangleButton +
+ '</div>' +
+
+ // This pane will be detached from here and re-attached to the document body.
+ '<div class="md-datepicker-calendar-pane md-whiteframe-z1" id="{{::ctrl.calendarPaneId}}">' +
+ '<div class="md-datepicker-input-mask">' +
+ '<div class="md-datepicker-input-mask-opaque"></div>' +
+ '</div>' +
+ '<div class="md-datepicker-calendar">' +
+ '<md-calendar role="dialog" aria-label="{{::ctrl.locale.msgCalendar}}" ' +
+ 'md-current-view="{{::ctrl.currentView}}" ' +
+ 'md-mode="{{::ctrl.mode}}" ' +
+ 'md-min-date="ctrl.minDate" ' +
+ 'md-max-date="ctrl.maxDate" ' +
+ 'md-date-filter="ctrl.dateFilter" ' +
+ 'md-month-filter="ctrl.monthFilter" ' +
+ (ngModelOptions ? 'ng-model-options="' + ngModelOptions + '" ' : '') +
+ 'ng-model="ctrl.date" ng-if="ctrl.isCalendarOpen">' +
+ '</md-calendar>' +
+ '</div>' +
+ '</div>';
+ },
+ require: ['ngModel', 'mdDatepicker', '?^mdInputContainer', '?^form'],
+ scope: {
+ minDate: '=mdMinDate',
+ maxDate: '=mdMaxDate',
+ placeholder: '@mdPlaceholder',
+ currentView: '@mdCurrentView',
+ mode: '@mdMode',
+ dateFilter: '=mdDateFilter',
+ monthFilter: '=mdMonthFilter',
+ isOpen: '=?mdIsOpen',
+ debounceInterval: '=mdDebounceInterval',
+ dateLocale: '=mdDateLocale'
+ },
+ controller: DatePickerCtrl,
+ controllerAs: 'ctrl',
+ bindToController: true,
+ link: function(scope, element, attr, controllers) {
+ var ngModelCtrl = controllers[0];
+ var mdDatePickerCtrl = controllers[1];
+ var mdInputContainer = controllers[2];
+ var parentForm = controllers[3];
+ var mdNoAsterisk = $mdUtil.parseAttributeBoolean(attr.mdNoAsterisk);
+
+ mdDatePickerCtrl.configureNgModel(ngModelCtrl, mdInputContainer, inputDirective);
+
+ if (mdInputContainer) {
+ // We need to move the spacer after the datepicker itself,
+ // because md-input-container adds it after the
+ // md-datepicker-input by default. The spacer gets wrapped in a
+ // div, because it floats and gets aligned next to the datepicker.
+ // There are easier ways of working around this with CSS (making the
+ // datepicker 100% wide, change the `display` etc.), however they
+ // break the alignment with any other form controls.
+ var spacer = element[0].querySelector('.md-errors-spacer');
+
+ if (spacer) {
+ element.after(angular.element('<div>').append(spacer));
+ }
+
+ mdInputContainer.setHasPlaceholder(attr.mdPlaceholder);
+ mdInputContainer.input = element;
+ mdInputContainer.element
+ .addClass(INPUT_CONTAINER_CLASS)
+ .toggleClass(HAS_CALENDAR_ICON_CLASS,
+ attr.mdHideIcons !== 'calendar' && attr.mdHideIcons !== 'all');
+
+ if (!mdInputContainer.label) {
+ $mdAria.expect(element, 'aria-label', attr.mdPlaceholder);
+ } else if (!mdNoAsterisk) {
+ attr.$observe('required', function(value) {
+ mdInputContainer.label.toggleClass('md-required', !!value);
+ });
+ }
+
+ scope.$watch(mdInputContainer.isErrorGetter || function() {
+ return ngModelCtrl.$invalid && (ngModelCtrl.$touched ||
+ (parentForm && parentForm.$submitted));
+ }, mdInputContainer.setInvalid);
+ } else if (parentForm) {
+ // If invalid, highlights the input when the parent form is submitted.
+ var parentSubmittedWatcher = scope.$watch(function() {
+ return parentForm.$submitted;
+ }, function(isSubmitted) {
+ if (isSubmitted) {
+ mdDatePickerCtrl.updateErrorState();
+ parentSubmittedWatcher();
+ }
+ });
+ }
+ }
+ };
+ }
+
+ /** Additional offset for the input's `size` attribute, which is updated based on its content. */
+ var EXTRA_INPUT_SIZE = 3;
+
+ /** Class applied to the container if the date is invalid. */
+ var INVALID_CLASS = 'md-datepicker-invalid';
+
+ /** Class applied to the datepicker when it's open. */
+ var OPEN_CLASS = 'md-datepicker-open';
+
+ /** Class applied to the md-input-container, if a datepicker is placed inside it */
+ var INPUT_CONTAINER_CLASS = '_md-datepicker-floating-label';
+
+ /** Class to be applied when the calendar icon is enabled. */
+ var HAS_CALENDAR_ICON_CLASS = '_md-datepicker-has-calendar-icon';
+
+ /** Class to be applied when the triangle icon is enabled. */
+ var HAS_TRIANGLE_ICON_CLASS = '_md-datepicker-has-triangle-icon';
+
+ /** Default time in ms to debounce input event by. */
+ var DEFAULT_DEBOUNCE_INTERVAL = 500;
+
+ /**
+ * Height of the calendar pane used to check if the pane is going outside the boundary of
+ * the viewport. See calendar.scss for how $md-calendar-height is computed; an extra 20px is
+ * also added to space the pane away from the exact edge of the screen.
+ *
+ * This is computed statically now, but can be changed to be measured if the circumstances
+ * of calendar sizing are changed.
+ */
+ var CALENDAR_PANE_HEIGHT = 368;
+
+ /**
+ * Width of the calendar pane used to check if the pane is going outside the boundary of
+ * the viewport. See calendar.scss for how $md-calendar-width is computed; an extra 20px is
+ * also added to space the pane away from the exact edge of the screen.
+ *
+ * This is computed statically now, but can be changed to be measured if the circumstances
+ * of calendar sizing are changed.
+ */
+ var CALENDAR_PANE_WIDTH = 360;
+
+ /** Used for checking whether the current user agent is on iOS or Android. */
+ var IS_MOBILE_REGEX = /ipad|iphone|ipod|android/i;
+
+ /**
+ * Controller for md-datepicker.
+ *
+ * @ngInject @constructor
+ */
+ function DatePickerCtrl($scope, $element, $attrs, $window, $mdConstant, $mdTheming, $mdUtil,
+ $mdDateLocale, $$mdDateUtil, $$rAF, $filter, $timeout) {
+
+ /** @final */
+ this.$window = $window;
+
+ /** @final */
+ this.dateUtil = $$mdDateUtil;
+
+ /** @final */
+ this.$mdConstant = $mdConstant;
+
+ /** @final */
+ this.$mdUtil = $mdUtil;
+
+ /** @final */
+ this.$$rAF = $$rAF;
+
+ /** @final */
+ this.$mdDateLocale = $mdDateLocale;
+
+ /** @final */
+ this.$timeout = $timeout;
+
+ /**
+ * The root document element. This is used for attaching a top-level click handler to
+ * close the calendar panel when a click outside said panel occurs. We use `documentElement`
+ * instead of body because, when scrolling is disabled, some browsers consider the body element
+ * to be completely off the screen and propagate events directly to the html element.
+ * @type {!JQLite}
+ */
+ this.documentElement = angular.element(document.documentElement);
+
+ /** @type {!ngModel.NgModelController} */
+ this.ngModelCtrl = null;
+
+ /** @type {HTMLInputElement} */
+ this.inputElement = $element[0].querySelector('input');
+
+ /**
+ * @final
+ * @type {!JQLite}
+ */
+ this.ngInputElement = angular.element(this.inputElement);
+
+ /** @type {HTMLElement} */
+ this.inputContainer = $element[0].querySelector('.md-datepicker-input-container');
+
+ /** @type {HTMLElement} Floating calendar pane. */
+ this.calendarPane = $element[0].querySelector('.md-datepicker-calendar-pane');
+
+ /** @type {HTMLElement} Calendar icon button. */
+ this.calendarButton = $element[0].querySelector('.md-datepicker-button');
+
+ /**
+ * Element covering everything but the input in the top of the floating calendar pane.
+ * @type {!JQLite}
+ */
+ this.inputMask = angular.element($element[0].querySelector('.md-datepicker-input-mask-opaque'));
+
+ /**
+ * @final
+ * @type {!JQLite}
+ */
+ this.$element = $element;
+
+ /**
+ * @final
+ * @type {!angular.Attributes}
+ */
+ this.$attrs = $attrs;
+
+ /**
+ * @final
+ * @type {!angular.Scope}
+ */
+ this.$scope = $scope;
+
+ /**
+ * This holds the model that will be used by the calendar.
+ * @type {Date|null|undefined}
+ */
+ this.date = null;
+
+ /** @type {boolean} */
+ this.isFocused = false;
+
+ /** @type {boolean} */
+ this.isDisabled = undefined;
+ this.setDisabled($element[0].disabled || angular.isString($attrs.disabled));
+
+ /** @type {boolean} Whether the date-picker's calendar pane is open. */
+ this.isCalendarOpen = false;
+
+ /** @type {boolean} Whether the calendar should open when the input is focused. */
+ this.openOnFocus = $attrs.hasOwnProperty('mdOpenOnFocus');
+
+ /** @type {Object} Instance of the mdInputContainer controller */
+ this.mdInputContainer = null;
+
+ /**
+ * Element from which the calendar pane was opened. Keep track of this so that we can return
+ * focus to it when the pane is closed.
+ * @type {HTMLElement}
+ */
+ this.calendarPaneOpenedFrom = null;
+
+ /** @type {String} Unique id for the calendar pane. */
+ this.calendarPaneId = 'md-date-pane-' + $mdUtil.nextUid();
+
+ /** Pre-bound click handler is saved so that the event listener can be removed. */
+ this.bodyClickHandler = angular.bind(this, this.handleBodyClick);
+
+ /**
+ * Name of the event that will trigger a close. Necessary to sniff the browser, because
+ * the resize event doesn't make sense on mobile and can have a negative impact since it
+ * triggers whenever the browser zooms in on a focused input.
+ */
+ this.windowEventName = IS_MOBILE_REGEX.test(
+ navigator.userAgent || navigator.vendor || window.opera
+ ) ? 'orientationchange' : 'resize';
+
+ /** Pre-bound close handler so that the event listener can be removed. */
+ this.windowEventHandler = $mdUtil.debounce(angular.bind(this, this.closeCalendarPane), 100);
+
+ /** Pre-bound handler for the window blur event. Allows for it to be removed later. */
+ this.windowBlurHandler = angular.bind(this, this.handleWindowBlur);
+
+ /** The built-in AngularJS date filter. */
+ this.ngDateFilter = $filter('date');
+
+ /** @type {Number} Extra margin for the left side of the floating calendar pane. */
+ this.leftMargin = 20;
+
+ /** @type {Number} Extra margin for the top of the floating calendar. Gets determined on the first open. */
+ this.topMargin = null;
+
+ // Unless the user specifies so, the datepicker should not be a tab stop.
+ // This is necessary because ngAria might add a tabindex to anything with an ng-model
+ // (based on whether or not the user has turned that particular feature on/off).
+ if ($attrs.tabindex) {
+ this.ngInputElement.attr('tabindex', $attrs.tabindex);
+ $attrs.$set('tabindex', null);
+ } else {
+ $attrs.$set('tabindex', '-1');
+ }
+
+ $attrs.$set('aria-owns', this.calendarPaneId);
+
+ $mdTheming($element);
+ $mdTheming(angular.element(this.calendarPane));
+
+ var self = this;
+
+ $scope.$on('$destroy', function() {
+ self.detachCalendarPane();
+ });
+
+ if ($attrs.mdIsOpen) {
+ $scope.$watch('ctrl.isOpen', function(shouldBeOpen) {
+ if (shouldBeOpen) {
+ self.openCalendarPane({
+ target: self.inputElement
+ });
+ } else {
+ self.closeCalendarPane();
+ }
+ });
+ }
+
+ // For AngularJS 1.4 and older, where there are no lifecycle hooks but bindings are
+ // pre-assigned, manually call the $onInit hook.
+ if (angular.version.major === 1 && angular.version.minor <= 4) {
+ this.$onInit();
+ }
+ }
+
+ /**
+ * AngularJS Lifecycle hook for newer AngularJS versions.
+ * Bindings are not guaranteed to have been assigned in the controller, but they are in the
+ * $onInit hook.
+ */
+ DatePickerCtrl.prototype.$onInit = function() {
+
+ /**
+ * Holds locale-specific formatters, parsers, labels etc. Allows
+ * the user to override specific ones from the $mdDateLocale provider.
+ * @type {!Object}
+ */
+ this.locale = this.dateLocale ? angular.extend({}, this.$mdDateLocale, this.dateLocale)
+ : this.$mdDateLocale;
+
+ this.installPropertyInterceptors();
+ this.attachChangeListeners();
+ this.attachInteractionListeners();
+ };
+
+ /**
+ * Sets up the controller's reference to ngModelController and
+ * applies AngularJS's `input[type="date"]` directive.
+ * @param {!angular.NgModelController} ngModelCtrl Instance of the ngModel controller.
+ * @param {Object} mdInputContainer Instance of the mdInputContainer controller.
+ * @param {Object} inputDirective Config for AngularJS's `input` directive.
+ */
+ DatePickerCtrl.prototype.configureNgModel = function(ngModelCtrl, mdInputContainer, inputDirective) {
+ this.ngModelCtrl = ngModelCtrl;
+ this.mdInputContainer = mdInputContainer;
+
+ // The input needs to be [type="date"] in order to be picked up by AngularJS.
+ this.$attrs.$set('type', 'date');
+
+ // Invoke the `input` directive link function, adding a stub for the element.
+ // This allows us to re-use AngularJS's logic for setting the timezone via ng-model-options.
+ // It works by calling the link function directly which then adds the proper `$parsers` and
+ // `$formatters` to the ngModel controller.
+ inputDirective[0].link.pre(this.$scope, {
+ on: angular.noop,
+ val: angular.noop,
+ 0: {}
+ }, this.$attrs, [ngModelCtrl]);
+
+ var self = this;
+
+ // Responds to external changes to the model value.
+ self.ngModelCtrl.$formatters.push(function(value) {
+ var parsedValue = angular.isDefined(value) ? value : null;
+
+ if (!(value instanceof Date)) {
+ parsedValue = Date.parse(value);
+
+ // `parsedValue` is the time since epoch if valid or `NaN` if invalid.
+ if (!isNaN(parsedValue) && angular.isNumber(parsedValue)) {
+ value = new Date(parsedValue);
+ }
+
+ if (value && !(value instanceof Date)) {
+ throw Error(
+ 'The ng-model for md-datepicker must be a Date instance or a value ' +
+ 'that can be parsed into a date. Currently the model is of type: ' + typeof value
+ );
+ }
+ }
+
+ self.onExternalChange(value);
+
+ return value;
+ });
+
+ // Responds to external error state changes (e.g. ng-required based on another input).
+ ngModelCtrl.$viewChangeListeners.unshift(angular.bind(this, this.updateErrorState));
+
+ // Forwards any events from the input to the root element. This is necessary to get `updateOn`
+ // working for events that don't bubble (e.g. 'blur') since AngularJS binds the handlers to
+ // the `<md-datepicker>`.
+ var updateOn = self.$mdUtil.getModelOption(ngModelCtrl, 'updateOn');
+
+ if (updateOn) {
+ this.ngInputElement.on(
+ updateOn,
+ angular.bind(this.$element, this.$element.triggerHandler, updateOn)
+ );
+ }
+ };
+
+ /**
+ * Attach event listeners for both the text input and the md-calendar.
+ * Events are used instead of ng-model so that updates don't infinitely update the other
+ * on a change. This should also be more performant than using a $watch.
+ */
+ DatePickerCtrl.prototype.attachChangeListeners = function() {
+ var self = this;
+
+ self.$scope.$on('md-calendar-change', function(event, date) {
+ self.setModelValue(date);
+ self.onExternalChange(date);
+ self.closeCalendarPane();
+ });
+
+ self.ngInputElement.on('input', angular.bind(self, self.resizeInputElement));
+
+ var debounceInterval = angular.isDefined(this.debounceInterval) ?
+ this.debounceInterval : DEFAULT_DEBOUNCE_INTERVAL;
+ self.ngInputElement.on('input', self.$mdUtil.debounce(self.handleInputEvent,
+ debounceInterval, self));
+ };
+
+ /** Attach event listeners for user interaction. */
+ DatePickerCtrl.prototype.attachInteractionListeners = function() {
+ var self = this;
+ var $scope = this.$scope;
+ var keyCodes = this.$mdConstant.KEY_CODE;
+
+ // Add event listener through angular so that we can triggerHandler in unit tests.
+ self.ngInputElement.on('keydown', function(event) {
+ if (event.altKey && event.keyCode === keyCodes.DOWN_ARROW) {
+ self.openCalendarPane(event);
+ $scope.$digest();
+ }
+ });
+
+ if (self.openOnFocus) {
+ self.ngInputElement.on('focus', angular.bind(self, self.openCalendarPane));
+ self.ngInputElement.on('click', function(event) {
+ event.stopPropagation();
+ });
+ self.ngInputElement.on('pointerdown',function(event) {
+ if (event.target && event.target.setPointerCapture) {
+ event.target.setPointerCapture(event.pointerId);
+ }
+ });
+
+ angular.element(self.$window).on('blur', self.windowBlurHandler);
+
+ $scope.$on('$destroy', function() {
+ angular.element(self.$window).off('blur', self.windowBlurHandler);
+ });
+ }
+
+ $scope.$on('md-calendar-close', function() {
+ self.closeCalendarPane();
+ });
+ };
+
+ /**
+ * Capture properties set to the date-picker and imperatively handle internal changes.
+ * This is done to avoid setting up additional $watches.
+ */
+ DatePickerCtrl.prototype.installPropertyInterceptors = function() {
+ var self = this;
+
+ if (this.$attrs.ngDisabled) {
+ // The expression is to be evaluated against the directive element's scope and not
+ // the directive's isolate scope.
+ var scope = this.$scope.$parent;
+
+ if (scope) {
+ scope.$watch(this.$attrs.ngDisabled, function(isDisabled) {
+ self.setDisabled(isDisabled);
+ });
+ }
+ }
+
+ Object.defineProperty(this, 'placeholder', {
+ get: function() { return self.inputElement.placeholder; },
+ set: function(value) { self.inputElement.placeholder = value || ''; }
+ });
+ };
+
+ /**
+ * Sets whether the date-picker is disabled.
+ * @param {boolean} isDisabled
+ */
+ DatePickerCtrl.prototype.setDisabled = function(isDisabled) {
+ this.isDisabled = isDisabled;
+ this.inputElement.disabled = isDisabled;
+
+ if (this.calendarButton) {
+ this.calendarButton.disabled = isDisabled;
+ }
+ };
+
+ /**
+ * Sets the custom ngModel.$error flags to be consumed by ngMessages. Flags are:
+ * - mindate: whether the selected date is before the minimum date.
+ * - maxdate: whether the selected flag is after the maximum date.
+ * - filtered: whether the selected date is allowed by the custom filtering function.
+ * - valid: whether the entered text input is a valid date
+ *
+ * The 'required' flag is handled automatically by ngModel.
+ *
+ * @param {Date=} opt_date Date to check. If not given, defaults to the datepicker's model value.
+ */
+ DatePickerCtrl.prototype.updateErrorState = function(opt_date) {
+ var date;
+ if (opt_date) {
+ date = new Date(opt_date.valueOf());
+ } else {
+ if (angular.isString(this.ngModelCtrl.$modelValue)) {
+ date = new Date(this.ngModelCtrl.$modelValue);
+ } else {
+ date = angular.copy(this.ngModelCtrl.$modelValue);
+ }
+ }
+
+ // Clear any existing errors to get rid of anything that's no longer relevant.
+ this.clearErrorState();
+
+ if (this.dateUtil.isValidDate(date)) {
+ // Force all dates to midnight in order to ignore the time portion.
+ date = this.dateUtil.createDateAtMidnight(date);
+
+ if (this.dateUtil.isValidDate(this.minDate)) {
+ var minDate = this.dateUtil.createDateAtMidnight(this.minDate);
+ this.ngModelCtrl.$setValidity('mindate', date >= minDate);
+ }
+
+ if (this.dateUtil.isValidDate(this.maxDate)) {
+ var maxDate = this.dateUtil.createDateAtMidnight(this.maxDate);
+ this.ngModelCtrl.$setValidity('maxdate', date <= maxDate);
+ }
+
+ if (angular.isFunction(this.dateFilter)) {
+ this.ngModelCtrl.$setValidity('filtered', this.dateFilter(date));
+ }
+
+ if (angular.isFunction(this.monthFilter)) {
+ this.ngModelCtrl.$setValidity('filtered', this.monthFilter(date));
+ }
+ } else {
+ // The date is seen as "not a valid date" if there is *something* set
+ // (i.e.., not null or undefined), but that something isn't a valid date.
+ this.ngModelCtrl.$setValidity('valid', date == null);
+ }
+
+ var input = this.inputElement.value;
+ var parsedDate = this.locale.parseDate(input);
+
+ if (!this.isInputValid(input, parsedDate) && this.ngModelCtrl.$valid) {
+ this.ngModelCtrl.$setValidity('valid', date == null);
+ }
+
+ angular.element(this.inputContainer).toggleClass(INVALID_CLASS,
+ this.ngModelCtrl.$invalid && (this.ngModelCtrl.$touched || this.ngModelCtrl.$submitted));
+ };
+
+ /**
+ * Check to see if the input is valid, as the validation should fail if the model is invalid.
+ *
+ * @param {string} inputString
+ * @param {Date} parsedDate
+ * @return {boolean} Whether the input is valid
+ */
+ DatePickerCtrl.prototype.isInputValid = function (inputString, parsedDate) {
+ return inputString === '' || (
+ this.dateUtil.isValidDate(parsedDate) &&
+ this.locale.isDateComplete(inputString) &&
+ this.isDateEnabled(parsedDate)
+ );
+ };
+
+ /** Clears any error flags set by `updateErrorState`. */
+ DatePickerCtrl.prototype.clearErrorState = function() {
+ this.inputContainer.classList.remove(INVALID_CLASS);
+ ['mindate', 'maxdate', 'filtered', 'valid'].forEach(function(field) {
+ this.ngModelCtrl.$setValidity(field, true);
+ }, this);
+ };
+
+ /** Resizes the input element based on the size of its content. */
+ DatePickerCtrl.prototype.resizeInputElement = function() {
+ this.inputElement.size = this.inputElement.value.length + EXTRA_INPUT_SIZE;
+ };
+
+ /**
+ * Sets the model value if the user input is a valid date.
+ * Adds an invalid class to the input element if not.
+ */
+ DatePickerCtrl.prototype.handleInputEvent = function() {
+ var inputString = this.inputElement.value;
+ var parsedDate = inputString ? this.locale.parseDate(inputString) : null;
+ this.dateUtil.setDateTimeToMidnight(parsedDate);
+
+ // An input string is valid if it is either empty (representing no date)
+ // or if it parses to a valid date that the user is allowed to select.
+ var isValidInput = this.isInputValid(inputString, parsedDate);
+
+ // The datepicker's model is only updated when there is a valid input.
+ if (isValidInput) {
+ this.setModelValue(parsedDate);
+ this.date = parsedDate;
+ }
+
+ this.updateErrorState(parsedDate);
+ };
+
+ /**
+ * Check whether date is in range and enabled
+ * @param {Date=} opt_date
+ * @return {boolean} Whether the date is enabled.
+ */
+ DatePickerCtrl.prototype.isDateEnabled = function(opt_date) {
+ return this.dateUtil.isDateWithinRange(opt_date, this.minDate, this.maxDate) &&
+ (!angular.isFunction(this.dateFilter) || this.dateFilter(opt_date)) &&
+ (!angular.isFunction(this.monthFilter) || this.monthFilter(opt_date));
+ };
+
+ /** Position and attach the floating calendar to the document. */
+ DatePickerCtrl.prototype.attachCalendarPane = function() {
+ var calendarPane = this.calendarPane;
+ var body = document.body;
+
+ calendarPane.style.transform = '';
+ this.$element.addClass(OPEN_CLASS);
+ this.mdInputContainer && this.mdInputContainer.element.addClass(OPEN_CLASS);
+ angular.element(body).addClass('md-datepicker-is-showing');
+
+ var elementRect = this.inputContainer.getBoundingClientRect();
+ var bodyRect = body.getBoundingClientRect();
+
+ if (!this.topMargin || this.topMargin < 0) {
+ this.topMargin =
+ (this.inputMask.parent().prop('clientHeight')
+ - this.ngInputElement.prop('clientHeight')) / 2;
+ }
+
+ // Check to see if the calendar pane would go off the screen. If so, adjust position
+ // accordingly to keep it within the viewport.
+ var paneTop = elementRect.top - bodyRect.top - this.topMargin;
+ var paneLeft = elementRect.left - bodyRect.left - this.leftMargin;
+
+ // If ng-material has disabled body scrolling (for example, if a dialog is open),
+ // then it's possible that the already-scrolled body has a negative top/left. In this case,
+ // we want to treat the "real" top as (0 - bodyRect.top). In a normal scrolling situation,
+ // though, the top of the viewport should just be the body's scroll position.
+ var viewportTop = (bodyRect.top < 0 && document.body.scrollTop === 0) ?
+ -bodyRect.top :
+ document.body.scrollTop;
+
+ var viewportLeft = (bodyRect.left < 0 && document.body.scrollLeft === 0) ?
+ -bodyRect.left :
+ document.body.scrollLeft;
+
+ var viewportBottom = viewportTop + this.$window.innerHeight;
+ var viewportRight = viewportLeft + this.$window.innerWidth;
+
+ // Creates an overlay with a hole the same size as element. We remove a pixel or two
+ // on each end to make it overlap slightly. The overlay's background is added in
+ // the theme in the form of a box-shadow with a huge spread.
+ this.inputMask.css({
+ position: 'absolute',
+ left: this.leftMargin + 'px',
+ top: this.topMargin + 'px',
+ width: (elementRect.width - 1) + 'px',
+ height: (elementRect.height - 2) + 'px'
+ });
+
+ // If the right edge of the pane would be off the screen and shifting it left by the
+ // difference would not go past the left edge of the screen. If the calendar pane is too
+ // big to fit on the screen at all, move it to the left of the screen and scale the entire
+ // element down to fit.
+ if (paneLeft + CALENDAR_PANE_WIDTH > viewportRight) {
+ if (viewportRight - CALENDAR_PANE_WIDTH > 0) {
+ paneLeft = viewportRight - CALENDAR_PANE_WIDTH;
+ } else {
+ paneLeft = viewportLeft;
+ var scale = this.$window.innerWidth / CALENDAR_PANE_WIDTH;
+ calendarPane.style.transform = 'scale(' + scale + ')';
+ }
+
+ calendarPane.classList.add('md-datepicker-pos-adjusted');
+ }
+
+ // If the bottom edge of the pane would be off the screen and shifting it up by the
+ // difference would not go past the top edge of the screen.
+ if (paneTop + CALENDAR_PANE_HEIGHT > viewportBottom &&
+ viewportBottom - CALENDAR_PANE_HEIGHT > viewportTop) {
+ paneTop = viewportBottom - CALENDAR_PANE_HEIGHT;
+ calendarPane.classList.add('md-datepicker-pos-adjusted');
+ }
+
+ calendarPane.style.left = paneLeft + 'px';
+ calendarPane.style.top = paneTop + 'px';
+ document.body.appendChild(calendarPane);
+
+ // Add CSS class after one frame to trigger open animation.
+ this.$$rAF(function() {
+ calendarPane.classList.add('md-pane-open');
+ });
+ };
+
+ /** Detach the floating calendar pane from the document. */
+ DatePickerCtrl.prototype.detachCalendarPane = function() {
+ this.$element.removeClass(OPEN_CLASS);
+ this.mdInputContainer && this.mdInputContainer.element.removeClass(OPEN_CLASS);
+ angular.element(document.body).removeClass('md-datepicker-is-showing');
+ this.calendarPane.classList.remove('md-pane-open');
+ this.calendarPane.classList.remove('md-datepicker-pos-adjusted');
+
+ if (this.isCalendarOpen) {
+ this.$mdUtil.enableScrolling();
+ }
+
+ if (this.calendarPane.parentNode) {
+ // Use native DOM removal because we do not want any of the
+ // angular state of this element to be disposed.
+ this.calendarPane.parentNode.removeChild(this.calendarPane);
+ }
+ };
+
+ /**
+ * Open the floating calendar pane.
+ * @param {MouseEvent|KeyboardEvent|{target: HTMLInputElement}} event
+ */
+ DatePickerCtrl.prototype.openCalendarPane = function(event) {
+ if (!this.isCalendarOpen && !this.isDisabled && !this.inputFocusedOnWindowBlur) {
+ this.isCalendarOpen = this.isOpen = true;
+ this.calendarPaneOpenedFrom = event.target;
+
+ // Because the calendar pane is attached directly to the body, it is possible that the
+ // rest of the component (input, etc) is in a different scrolling container, such as
+ // an md-content. This means that, if the container is scrolled, the pane would remain
+ // stationary. To remedy this, we disable scrolling while the calendar pane is open, which
+ // also matches the native behavior for things like `<select>` on Mac and Windows.
+ this.$mdUtil.disableScrollAround(this.calendarPane);
+
+ this.attachCalendarPane();
+ this.focusCalendar();
+ this.evalAttr('ngFocus');
+
+ // Attach click listener inside of a timeout because, if this open call was triggered by a
+ // click, we don't want it to be immediately propagated up to the body and handled.
+ var self = this;
+ this.$mdUtil.nextTick(function() {
+ // Use 'touchstart` in addition to click in order to work on iOS Safari, where click
+ // events aren't propagated under most circumstances.
+ // See http://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
+ self.documentElement.on('click touchstart', self.bodyClickHandler);
+ }, false);
+
+ window.addEventListener(this.windowEventName, this.windowEventHandler);
+ } else if (this.inputFocusedOnWindowBlur) {
+ this.resetInputFocused();
+ }
+ };
+
+ /** Close the floating calendar pane. */
+ DatePickerCtrl.prototype.closeCalendarPane = function() {
+ if (this.isCalendarOpen) {
+ var self = this;
+
+ self.detachCalendarPane();
+ self.ngModelCtrl.$setTouched();
+ self.evalAttr('ngBlur');
+
+ self.documentElement.off('click touchstart', self.bodyClickHandler);
+ window.removeEventListener(self.windowEventName, self.windowEventHandler);
+
+ self.calendarPaneOpenedFrom.focus();
+ self.calendarPaneOpenedFrom = null;
+
+ if (self.openOnFocus) {
+ // Ensures that all focus events have fired before resetting
+ // the calendar. Prevents the calendar from reopening immediately
+ // in IE when md-open-on-focus is set. Also it needs to trigger
+ // a digest, in order to prevent issues where the calendar wasn't
+ // showing up on the next open.
+ self.$timeout(reset);
+ } else {
+ reset();
+ }
+ }
+
+ function reset() {
+ self.isCalendarOpen = self.isOpen = false;
+ }
+ };
+
+ /** Gets the controller instance for the calendar in the floating pane. */
+ DatePickerCtrl.prototype.getCalendarCtrl = function() {
+ return angular.element(this.calendarPane.querySelector('md-calendar')).controller('mdCalendar');
+ };
+
+ /** Focus the calendar in the floating pane. */
+ DatePickerCtrl.prototype.focusCalendar = function() {
+ // Use a timeout in order to allow the calendar to be rendered, as it is gated behind an ng-if.
+ var self = this;
+ this.$mdUtil.nextTick(function() {
+ self.getCalendarCtrl().focusDate(self.date);
+ }, false);
+ };
+
+ /**
+ * Sets whether the input is currently focused.
+ * @param {boolean} isFocused
+ */
+ DatePickerCtrl.prototype.setFocused = function(isFocused) {
+ if (!isFocused) {
+ this.ngModelCtrl.$setTouched();
+ }
+
+ // The ng* expressions shouldn't be evaluated when mdOpenOnFocus is on,
+ // because they also get called when the calendar is opened/closed.
+ if (!this.openOnFocus) {
+ this.evalAttr(isFocused ? 'ngFocus' : 'ngBlur');
+ }
+
+ this.isFocused = isFocused;
+ };
+
+ /**
+ * Handles a click on the document body when the floating calendar pane is open.
+ * Closes the floating calendar pane if the click is not inside of it.
+ * @param {MouseEvent} event
+ */
+ DatePickerCtrl.prototype.handleBodyClick = function(event) {
+ if (this.isCalendarOpen) {
+ var isInCalendar = this.$mdUtil.getClosest(event.target, 'md-calendar');
+
+ if (!isInCalendar) {
+ this.closeCalendarPane();
+ }
+
+ this.$scope.$digest();
+ }
+ };
+
+ /**
+ * Handles the event when the user navigates away from the current tab. Keeps track of
+ * whether the input was focused when the event happened, in order to prevent the calendar
+ * from re-opening.
+ */
+ DatePickerCtrl.prototype.handleWindowBlur = function() {
+ this.inputFocusedOnWindowBlur = document.activeElement === this.inputElement;
+ };
+
+ /**
+ * Reset the flag inputFocusedOnWindowBlur to default state, to permit user to open calendar
+ * again when he back to tab with calendar focused.
+ */
+ DatePickerCtrl.prototype.resetInputFocused = function() {
+ this.inputFocusedOnWindowBlur = false;
+ };
+
+ /**
+ * Evaluates an attribute expression against the parent scope.
+ * @param {String} attr Name of the attribute to be evaluated.
+ */
+ DatePickerCtrl.prototype.evalAttr = function(attr) {
+ if (this.$attrs[attr]) {
+ this.$scope.$parent.$eval(this.$attrs[attr]);
+ }
+ };
+
+ /**
+ * Sets the ng-model value by first converting the date object into a string. Converting it
+ * is necessary, in order to pass AngularJS's `input[type="date"]` validations. AngularJS turns
+ * the value into a Date object afterwards, before setting it on the model.
+ * @param {Date=} value Date to be set as the model value.
+ */
+ DatePickerCtrl.prototype.setModelValue = function(value) {
+ var timezone = this.$mdUtil.getModelOption(this.ngModelCtrl, 'timezone');
+ // Using the timezone when the offset is negative (GMT+X) causes the previous day to be
+ // set as the model value here. This check avoids that.
+ if (timezone == null || value == null || value.getTimezoneOffset() < 0) {
+ this.ngModelCtrl.$setViewValue(this.ngDateFilter(value, 'yyyy-MM-dd'), 'default');
+ } else {
+ this.ngModelCtrl.$setViewValue(this.ngDateFilter(value, 'yyyy-MM-dd', timezone), 'default');
+ }
+ };
+
+ /**
+ * Updates the datepicker when a model change occurred externally.
+ * @param {Date=} value Value that was set to the model.
+ */
+ DatePickerCtrl.prototype.onExternalChange = function(value) {
+ var self = this;
+ var timezone = this.$mdUtil.getModelOption(this.ngModelCtrl, 'timezone');
+
+ // Update the model used by the calendar.
+ if (this.dateUtil.isValidDate(value) && timezone != null && value.getTimezoneOffset() >= 0) {
+ this.date = this.dateUtil.removeLocalTzAndReparseDate(value);
+ } else {
+ this.date = value;
+ }
+ // Using the timezone when the offset is negative (GMT+X) causes the previous day to be
+ // used here. This check avoids that.
+ if (timezone == null || value == null || value.getTimezoneOffset() < 0) {
+ this.inputElement.value = this.locale.formatDate(value);
+ } else {
+ this.inputElement.value = this.locale.formatDate(value, timezone);
+ }
+ this.mdInputContainer && this.mdInputContainer.setHasValue(!!value);
+ this.resizeInputElement();
+ // This is often called from the $formatters section of the $validators pipeline.
+ // In that case, we need to delay to let $render and $validate run, so that the checks for
+ // error state are accurate.
+ this.$mdUtil.nextTick(function() {self.updateErrorState();}, false, self.$scope);
+ };
+})();
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.dialog
+ */
+MdDialogDirective.$inject = ["$$rAF", "$mdTheming", "$mdDialog"];
+MdDialogProvider.$inject = ["$$interimElementProvider"];
+angular
+ .module('material.components.dialog', [
+ 'material.core',
+ 'material.components.backdrop'
+ ])
+ .directive('mdDialog', MdDialogDirective)
+ .provider('$mdDialog', MdDialogProvider);
+
+/**
+ * @ngdoc directive
+ * @name mdDialog
+ * @module material.components.dialog
+ *
+ * @restrict E
+ *
+ * @description
+ * `<md-dialog>` - The dialog's template must be inside this element.
+ *
+ * Inside, use an `<md-dialog-content>` element for the dialog's content, and use
+ * an `<md-dialog-actions>` element for the dialog's actions.
+ *
+ * ## CSS
+ * - `.md-dialog-content` - class that sets the padding on the content as the spec file
+ *
+ * ## Notes
+ * - If you specify an `id` for the `<md-dialog>`, the `<md-dialog-content>` will have the same `id`
+ * prefixed with `dialogContent_`.
+ *
+ * @usage
+ * ### Dialog template
+ * <hljs lang="html">
+ * <md-dialog aria-label="List dialog">
+ * <md-dialog-content>
+ * <md-list>
+ * <md-list-item ng-repeat="item in items">
+ * <p>Number {{item}}</p>
+ * </md-list-item>
+ * </md-list>
+ * </md-dialog-content>
+ * <md-dialog-actions>
+ * <md-button ng-click="closeDialog()" class="md-primary">Close Dialog</md-button>
+ * </md-dialog-actions>
+ * </md-dialog>
+ * </hljs>
+ */
+function MdDialogDirective($$rAF, $mdTheming, $mdDialog) {
+ return {
+ restrict: 'E',
+ link: function(scope, element) {
+ element.addClass('_md'); // private md component indicator for styling
+
+ $mdTheming(element);
+ $$rAF(function() {
+ var images;
+ var content = element[0].querySelector('md-dialog-content');
+
+ if (content) {
+ images = content.getElementsByTagName('img');
+ addOverflowClass();
+ // delayed image loading may impact scroll height, check after images are loaded
+ angular.element(images).on('load', addOverflowClass);
+ }
+
+ scope.$on('$destroy', function() {
+ $mdDialog.destroy(element);
+ });
+
+ /**
+ *
+ */
+ function addOverflowClass() {
+ element.toggleClass('md-content-overflow', content.scrollHeight > content.clientHeight);
+ }
+
+
+ });
+ }
+ };
+}
+
+/**
+ * @ngdoc service
+ * @name $mdDialog
+ * @module material.components.dialog
+ *
+ * @description
+ * `$mdDialog` opens a dialog over the app to inform users about critical information or require
+ * them to make decisions. There are two approaches for setup: a simple promise API
+ * and regular object syntax.
+ *
+ * ## Restrictions
+ *
+ * - The dialog is always given an isolate scope.
+ * - The dialog's template must have an outer `<md-dialog>` element.
+ * Inside, use an `<md-dialog-content>` element for the dialog's content, and use
+ * an `<md-dialog-actions>` element for the dialog's actions.
+ * - Dialogs must cover the entire application to keep interactions inside of them.
+ * Use the `parent` option to change where dialogs are appended.
+ *
+ * ## Sizing
+ * - Complex dialogs can be sized with `flex="percentage"`, i.e. `flex="66"`.
+ * - Default max-width is 80% of the `rootElement` or `parent`.
+ *
+ * ## CSS
+ * - `.md-dialog-content` - class that sets the padding on the content as the spec file
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div ng-app="demoApp" ng-controller="AppController as ctrl">
+ * <div>
+ * <md-button ng-click="ctrl.showAlert()" class="md-raised md-warn">
+ * Basic Alert!
+ * </md-button>
+ * </div>
+ * <div>
+ * <md-button ng-click="ctrl.showDialog($event)" class="md-raised">
+ * Custom Dialog
+ * </md-button>
+ * </div>
+ * </div>
+ * </hljs>
+ *
+ * ### JavaScript: object syntax
+ * <hljs lang="js">
+ * (function(angular, undefined) {
+ * "use strict";
+ *
+ * angular
+ * .module('demoApp', ['ngMaterial'])
+ * .controller('AppCtrl', AppController);
+ *
+ * function AppController($mdDialog) {
+ * var alert;
+ * var ctrl = this;
+ * ctrl.showAlert = showAlert;
+ * ctrl.showDialog = showDialog;
+ * ctrl.items = [1, 2, 3];
+ *
+ * // Internal method
+ * function showAlert() {
+ * alert = $mdDialog.alert({
+ * title: 'Attention',
+ * textContent: 'This is an example of how simple dialogs can be!',
+ * ok: 'Close'
+ * });
+ *
+ * $mdDialog
+ * .show( alert )
+ * .finally(function() {
+ * alert = undefined;
+ * });
+ * }
+ *
+ * function showDialog($event) {
+ * var parentEl = angular.element(document.body);
+ * $mdDialog.show({
+ * parent: parentEl,
+ * targetEvent: $event,
+ * template:
+ * '<md-dialog aria-label="List dialog">' +
+ * ' <md-dialog-content>'+
+ * ' <md-list>'+
+ * ' <md-list-item ng-repeat="item in ctrl.items">'+
+ * ' <p>Number {{item}}</p>' +
+ * ' </md-item>'+
+ * ' </md-list>'+
+ * ' </md-dialog-content>' +
+ * ' <md-dialog-actions>' +
+ * ' <md-button ng-click="ctrl.closeDialog()" class="md-primary">' +
+ * ' Close Dialog' +
+ * ' </md-button>' +
+ * ' </md-dialog-actions>' +
+ * '</md-dialog>',
+ * locals: {
+ * items: ctrl.items
+ * },
+ * controller: DialogController
+ * controllerAs: 'ctrl'
+ * });
+ * function DialogController($mdDialog) {
+ * this.closeDialog = function() {
+ * $mdDialog.hide();
+ * }
+ * }
+ * }
+ * }
+ * })(angular);
+ * </hljs>
+ *
+ * ### Multiple Dialogs
+ * Using the `multiple` option for the `$mdDialog` service allows developers to show multiple
+ * dialogs at the same time.
+ *
+ * <hljs lang="js">
+ * // From plain options
+ * $mdDialog.show({
+ * multiple: true
+ * });
+ *
+ * // From a dialog preset
+ * $mdDialog.show(
+ * $mdDialog
+ * .alert()
+ * .multiple(true)
+ * );
+ *
+ * </hljs>
+ *
+ * ### Pre-Rendered Dialogs
+ * By using the `contentElement` option, it is possible to use an already existing element in the
+ * DOM.
+ *
+ * > Pre-rendered dialogs will be not linked to any scope and will not instantiate any new
+ * > controller.<br/>
+ * > You can manually link the elements to a scope or instantiate a controller from the template
+ * > (using `ng-controller`).
+ *
+ * <hljs lang="js">
+ * function showPrerenderedDialog() {
+ * $mdDialog.show({
+ * contentElement: '#myStaticDialog',
+ * parent: angular.element(document.body)
+ * });
+ * }
+ * </hljs>
+ *
+ * When using a string as value, `$mdDialog` will automatically query the DOM for the specified CSS
+ * selector.
+ *
+ * <hljs lang="html">
+ * <div style="visibility: hidden">
+ * <div class="md-dialog-container" id="myStaticDialog">
+ * <md-dialog>
+ * This is a pre-rendered dialog.
+ * </md-dialog>
+ * </div>
+ * </div>
+ * </hljs>
+ *
+ * **Notice**: It is important, to use the `.md-dialog-container` as the content element, otherwise
+ * the dialog will not show up.
+ *
+ * It also possible to use a DOM element for the `contentElement` option.
+ * - `contentElement: document.querySelector('#myStaticDialog')`
+ * - `contentElement: angular.element(TEMPLATE)`
+ *
+ * When using a `template` as content element, it will be not compiled upon open.
+ * This allows you to compile the element yourself and use it each time the dialog opens.
+ *
+ * ### Custom Presets
+ * Developers are also able to create their own preset, which can be used without repeating
+ * their options each time.
+ *
+ * <hljs lang="js">
+ * $mdDialogProvider.addPreset('testPreset', {
+ * options: function() {
+ * return {
+ * template:
+ * '<md-dialog>' +
+ * 'This is a custom preset' +
+ * '</md-dialog>',
+ * controllerAs: 'dialog',
+ * bindToController: true,
+ * clickOutsideToClose: true,
+ * escapeToClose: true
+ * };
+ * }
+ * });
+ * </hljs>
+ *
+ * After creating your preset in the `config` phase, you can access it.
+ *
+ * <hljs lang="js">
+ * $mdDialog.show(
+ * $mdDialog.testPreset()
+ * );
+ * </hljs>
+ *
+ * ### JavaScript: promise API syntax, custom dialog template
+ *
+ * <hljs lang="js">
+ * (function(angular, undefined) {
+ * "use strict";
+ *
+ * angular
+ * .module('demoApp', ['ngMaterial'])
+ * .controller('EmployeeController', EmployeeController)
+ * .controller('GreetingController', GreetingController);
+ *
+ * // Fictitious Employee Editor to show how to use simple and complex dialogs.
+ *
+ * function EmployeeController($mdDialog) {
+ * var alert;
+ * var ctrl = this;
+ *
+ * ctrl.showAlert = showAlert;
+ * ctrl.showGreeting = showCustomGreeting;
+ *
+ * ctrl.hasAlert = function() { return !!alert };
+ * ctrl.userName = ctrl.userName || 'Bobby';
+ *
+ * // Dialog #1 - Show simple alert dialog and cache reference to dialog instance
+ *
+ * function showAlert() {
+ * alert = $mdDialog.alert()
+ * .title('Attention, ' + ctrl.userName)
+ * .textContent('This is an example of how simple dialogs can be!')
+ * .ok('Close');
+ *
+ * $mdDialog
+ * .show(alert)
+ * .finally(function() {
+ * alert = undefined;
+ * });
+ * }
+ *
+ * // Dialog #2 - Demonstrate more complex dialogs construction and popup.
+ *
+ * function showCustomGreeting($event) {
+ * $mdDialog.show({
+ * targetEvent: $event,
+ * template:
+ * '<md-dialog>' +
+ * ' <md-dialog-content>Hello {{ ctrl.employee }}!</md-dialog-content>' +
+ * ' <md-dialog-actions>' +
+ * ' <md-button ng-click="ctrl.closeDialog()" class="md-primary">' +
+ * ' Close Greeting' +
+ * ' </md-button>' +
+ * ' </md-dialog-actions>' +
+ * '</md-dialog>',
+ * controller: GreetingController,
+ * controllerAs: 'ctrl',
+ * onComplete: afterShowAnimation,
+ * locals: { employee: ctrl.userName }
+ * });
+ *
+ * // When the 'enter' animation finishes...
+ * function afterShowAnimation(scope, element, options) {
+ * // post-show code here: DOM element focus, etc.
+ * }
+ * }
+ * }
+ *
+ * // Greeting controller used with the 'showCustomGreeting()' custom dialog
+ * function GreetingController($mdDialog, $log) {
+ * var ctrl = this;
+ * this.$log = $log;
+ *
+ * ctrl.closeDialog = function() {
+ * // Hides the most recent dialog shown.
+ * // No specific dialog instance reference is needed.
+ * $mdDialog.hide();
+ * };
+ * }
+ *
+ * GreetingController.prototype.$onInit = function() {
+ * // Assigned from the locals options passed to $mdDialog.show.
+ * this.$log.log('Employee Name: ', ctrl.employee);
+ * };
+ *
+ * })(angular);
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdDialog#alert
+ *
+ * @description
+ * Builds a preconfigured dialog with the specified message.
+ *
+ * @returns {Object} a dialog preset with the chainable configuration methods:
+ *
+ * - `title(string)` - Sets the alert title.
+ * - `textContent(string)` - Sets the alert message.
+ * - `htmlContent(string)` - Sets the alert message as HTML. Requires the `ngSanitize`
+ * module to be loaded. HTML is not run through AngularJS' compiler.
+ * - `ok(string)` - Sets the alert "Okay" button text.
+ * - `theme(string)` - Sets the theme of the alert dialog.
+ * - `targetEvent(DOMClickEvent=)` - A click's event object. When passed in as an
+ * option, the location of the click will be used as the starting point for the opening
+ * animation of the the dialog.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdDialog#confirm
+ *
+ * @description
+ * Builds a preconfigured dialog with the specified message. You can call show and the promise
+ * returned will be resolved if the user clicks the confirm action on the dialog. The promise will
+ * be rejected if the user clicks the cancel action or dismisses the dialog.
+ *
+ * @returns {Object} a dialog preset with the chainable configuration methods:
+ *
+ * Additionally, it supports the following methods:
+ *
+ * - `title(string)` - Sets the confirm title.
+ * - `textContent(string)` - Sets the confirm message.
+ * - `htmlContent(string)` - Sets the confirm message as HTML. Requires the `ngSanitize`
+ * module to be loaded. HTML is not run through AngularJS' compiler.
+ * - `ok(string)` - Sets the confirm "Okay" button text.
+ * - `cancel(string)` - Sets the confirm "Cancel" button text.
+ * - `theme(string)` - Sets the theme of the confirm dialog.
+ * - `targetEvent(DOMClickEvent=)` - A click's event object. When passed in as an
+ * option, the location of the click will be used as the starting point for the opening
+ * animation of the the dialog.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdDialog#prompt
+ *
+ * @description
+ * Builds a preconfigured dialog with the specified message and input box. You can call show and the
+ * promise returned will be resolved, if the user clicks the prompt action on the dialog, passing
+ * the input value as the first argument. The promise will be rejected if the user clicks the cancel
+ * action or dismisses the dialog.
+ *
+ * @returns {Object} a dialog preset with the chainable configuration methods:
+ *
+ * Additionally, it supports the following methods:
+ *
+ * - `title(string)` - Sets the prompt title.
+ * - `textContent(string)` - Sets the prompt message.
+ * - `htmlContent(string)` - Sets the prompt message as HTML. Requires the `ngSanitize`
+ * module to be loaded. HTML is not run through AngularJS' compiler.
+ * - `placeholder(string)` - Sets the placeholder text for the input.
+ * - `required(boolean)` - Sets the input required value.
+ * - `initialValue(string)` - Sets the initial value for the prompt input.
+ * - `ok(string)` - Sets the prompt "Okay" button text.
+ * - `cancel(string)` - Sets the prompt "Cancel" button text.
+ * - `theme(string)` - Sets the theme of the prompt dialog.
+ * - `targetEvent(DOMClickEvent=)` - A click's event object. When passed in as an
+ * option, the location of the click will be used as the starting point for the opening
+ * animation of the the dialog.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdDialog#show
+ *
+ * @description
+ * Show a dialog with the specified options.
+ *
+ * @param {Object} optionsOrPreset Either provide a dialog preset returned from `alert()`,
+ * `prompt()`, or `confirm()`; or an options object with the following properties:
+ * - `templateUrl` - `{string=}`: The url of a template that will be used as the content
+ * of the dialog.
+ * - `template` - `{string=}`: HTML template to show in the dialog. This **must** be trusted HTML
+ * with respect to AngularJS' [$sce service](https://docs.angularjs.org/api/ng/service/$sce).
+ * This template should **never** be constructed with any kind of user input or user data.
+ * - `contentElement` - `{string|Element}`: Instead of using a template, which will be compiled
+ * each time a dialog opens, you can also use a DOM element.<br/>
+ * * When specifying an element, which is present on the DOM, `$mdDialog` will temporary fetch
+ * the element into the dialog and restores it at the old DOM position upon close.
+ * * When specifying a string, the string be used as a CSS selector, to lookup for the element
+ * in the DOM.
+ * - `autoWrap` - `{boolean=}`: Whether or not to automatically wrap the template with a
+ * `<md-dialog>` tag if one is not provided. Defaults to true. Can be disabled if you provide a
+ * custom dialog directive.
+ * - `targetEvent` - `{DOMClickEvent=}`: A click's event object. When passed in as an option,
+ * the location of the click will be used as the starting point for the opening animation
+ * of the the dialog.
+ * - `openFrom` - `{string|Element|Object}`: The query selector, DOM element or the Rect object
+ * that is used to determine the bounds (top, left, height, width) from which the Dialog will
+ * originate.
+ * - `closeTo` - `{string|Element|Object}`: The query selector, DOM element or the Rect object
+ * that is used to determine the bounds (top, left, height, width) to which the Dialog will
+ * target.
+ * - `scope` - `{Object=}`: the scope to link the template / controller to. If none is specified,
+ * it will create a new isolate scope.
+ * This scope will be destroyed when the dialog is removed unless `preserveScope` is set to
+ * true.
+ * - `preserveScope` - `{boolean=}`: whether to preserve the scope when the element is removed.
+ * Default is false
+ * - `disableParentScroll` - `{boolean=}`: Whether to disable scrolling while the dialog is open.
+ * Default true.
+ * - `hasBackdrop` - `{boolean=}`: Whether there should be an opaque backdrop behind the dialog.
+ * Default true.
+ * - `clickOutsideToClose` - `{boolean=}`: Whether the user can click outside the dialog to
+ * close it. Default false.
+ * - `escapeToClose` - `{boolean=}`: Whether the user can press escape to close the dialog.
+ * Default true.
+ * - `focusOnOpen` - `{boolean=}`: An option to override focus behavior on open. Only disable if
+ * focusing some other way, as focus management is required for dialogs to be accessible.
+ * Defaults to true.
+ * - `controller` - `{Function|string=}`: The controller to associate with the dialog. The
+ * controller will be injected with the local `$mdDialog`, which passes along a scope for the
+ * dialog.
+ * - `locals` - `{Object=}`: An object containing key/value pairs. The keys will be used as names
+ * of values to inject into the controller. For example, `locals: {three: 3}` would inject
+ * `three` into the controller, with the value 3. If `bindToController` is true, they will be
+ * copied to the controller instead.
+ * - `bindToController` - `bool`: bind the locals to the controller, instead of passing them in.
+ * - `resolve` - `{Function=}`: Similar to locals, except it takes as values functions that return
+ * promises, and the dialog will not open until all of the promises resolve.
+ * - `controllerAs` - `{string=}`: An alias to assign the controller to on the scope.
+ * - `parent` - `{element=}`: The element to append the dialog to. Defaults to appending
+ * to the root element of the application.
+ * - `onShowing` - `Function(scope, element, options: Object=, controller: Object)=`: Callback
+ * function used to notify the show() animation is starting.
+ * - `onComplete` - `Function(scope, element, options: Object=)=`: Callback function used to
+ * notify when the show() animation is finished.
+ * - `onRemoving` - `Function(element, removePromise)`: Callback function used to announce the
+ * close/hide() action is starting. This allows developers to run custom animations
+ * in parallel with the close animations.
+ * - `fullscreen` `{boolean=}`: An option to toggle whether the dialog should show in fullscreen
+ * or not. Defaults to `false`.
+ * - `multiple` `{boolean=}`: An option to allow this dialog to display over one that's currently
+ * open.
+ * @returns {Promise} A promise that can be resolved with `$mdDialog.hide()` or
+ * rejected with `$mdDialog.cancel()`.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdDialog#hide
+ *
+ * @description
+ * Hide an existing dialog and resolve the promise returned from `$mdDialog.show()`.
+ *
+ * @param {*=} response An argument for the resolved promise.
+ *
+ * @returns {promise} A promise that is resolved when the dialog has been closed.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdDialog#cancel
+ *
+ * @description
+ * Hide an existing dialog and reject the promise returned from `$mdDialog.show()`.
+ *
+ * @param {*=} response An argument for the rejected promise.
+ *
+ * @returns {promise} A promise that is resolved when the dialog has been closed.
+ */
+
+function MdDialogProvider($$interimElementProvider) {
+ // Elements to capture and redirect focus when the user presses tab at the dialog boundary.
+ MdDialogController.$inject = ["$mdDialog", "$mdConstant"];
+ dialogDefaultOptions.$inject = ["$mdDialog", "$mdAria", "$mdUtil", "$mdConstant", "$animate", "$document", "$window", "$rootElement", "$log", "$injector", "$mdTheming", "$interpolate", "$mdInteraction"];
+ var topFocusTrap, bottomFocusTrap;
+ var removeFocusTrap;
+
+ return $$interimElementProvider('$mdDialog')
+ .setDefaults({
+ methods: ['disableParentScroll', 'hasBackdrop', 'clickOutsideToClose', 'escapeToClose',
+ 'targetEvent', 'closeTo', 'openFrom', 'parent', 'fullscreen', 'multiple'],
+ options: dialogDefaultOptions
+ })
+ .addPreset('alert', {
+ methods: ['title', 'htmlContent', 'textContent', 'ariaLabel', 'ok', 'theme',
+ 'css'],
+ options: advancedDialogOptions
+ })
+ .addPreset('confirm', {
+ methods: ['title', 'htmlContent', 'textContent', 'ariaLabel', 'ok', 'cancel',
+ 'theme', 'css'],
+ options: advancedDialogOptions
+ })
+ .addPreset('prompt', {
+ methods: ['title', 'htmlContent', 'textContent', 'initialValue', 'placeholder', 'ariaLabel',
+ 'ok', 'cancel', 'theme', 'css', 'required'],
+ options: advancedDialogOptions
+ });
+
+ /* @ngInject */
+ function advancedDialogOptions() {
+ return {
+ template: [
+ '<md-dialog md-theme="{{ dialog.theme || dialog.defaultTheme }}" aria-label="{{ dialog.ariaLabel }}" ng-class="dialog.css">',
+ ' <md-dialog-content class="md-dialog-content" role="document" tabIndex="-1">',
+ ' <h2 class="md-title">{{ dialog.title }}</h2>',
+ ' <div ng-if="::dialog.mdHtmlContent" class="md-dialog-content-body" ',
+ ' ng-bind-html="::dialog.mdHtmlContent"></div>',
+ ' <div ng-if="::!dialog.mdHtmlContent" class="md-dialog-content-body">',
+ ' <p>{{::dialog.mdTextContent}}</p>',
+ ' </div>',
+ ' <md-input-container md-no-float ng-if="::dialog.$type == \'prompt\'" class="md-prompt-input-container">',
+ ' <input ng-keypress="dialog.keypress($event)" md-autofocus ng-model="dialog.result" ' +
+ ' placeholder="{{::dialog.placeholder}}" ng-required="dialog.required">',
+ ' </md-input-container>',
+ ' </md-dialog-content>',
+ ' <md-dialog-actions>',
+ ' <md-button ng-if="dialog.$type === \'confirm\' || dialog.$type === \'prompt\'"' +
+ ' ng-click="dialog.abort()" class="md-primary md-cancel-button">',
+ ' {{ dialog.cancel }}',
+ ' </md-button>',
+ ' <md-button ng-click="dialog.hide()" class="md-primary md-confirm-button" md-autofocus="dialog.$type===\'alert\'"' +
+ ' ng-disabled="dialog.required && !dialog.result">',
+ ' {{ dialog.ok }}',
+ ' </md-button>',
+ ' </md-dialog-actions>',
+ '</md-dialog>'
+ ].join('').replace(/\s\s+/g, ''),
+ controller: MdDialogController,
+ controllerAs: 'dialog',
+ bindToController: true,
+ };
+ }
+
+ /**
+ * Controller for the md-dialog interim elements
+ * @ngInject
+ */
+ function MdDialogController($mdDialog, $mdConstant) {
+ // For compatibility with AngularJS 1.6+, we should always use the $onInit hook in
+ // interimElements. The $mdCompiler simulates the $onInit hook for all versions.
+ this.$onInit = function() {
+ var isPrompt = this.$type === 'prompt';
+
+ if (isPrompt && this.initialValue) {
+ this.result = this.initialValue;
+ }
+
+ this.hide = function() {
+ $mdDialog.hide(isPrompt ? this.result : true);
+ };
+ this.abort = function() {
+ $mdDialog.cancel();
+ };
+ this.keypress = function($event) {
+ var invalidPrompt = isPrompt && this.required && !angular.isDefined(this.result);
+
+ if ($event.keyCode === $mdConstant.KEY_CODE.ENTER && !invalidPrompt) {
+ $mdDialog.hide(this.result);
+ }
+ };
+ };
+ }
+
+ /* @ngInject */
+ function dialogDefaultOptions($mdDialog, $mdAria, $mdUtil, $mdConstant, $animate, $document,
+ $window, $rootElement, $log, $injector, $mdTheming, $interpolate,
+ $mdInteraction) {
+ return {
+ hasBackdrop: true,
+ isolateScope: true,
+ onCompiling: beforeCompile,
+ onShow: onShow,
+ onShowing: beforeShow,
+ onRemove: onRemove,
+ clickOutsideToClose: false,
+ escapeToClose: true,
+ targetEvent: null,
+ closeTo: null,
+ openFrom: null,
+ focusOnOpen: true,
+ disableParentScroll: true,
+ autoWrap: true,
+ fullscreen: false,
+ transformTemplate: function(template, options) {
+ // Make the dialog container focusable, because otherwise the focus will be always
+ // redirected to an element outside of the container, and the focus trap won't work.
+ // Also the tabindex is needed for the `escapeToClose` functionality, because
+ // the keyDown event can't be triggered when the focus is outside of the container.
+ var startSymbol = $interpolate.startSymbol();
+ var endSymbol = $interpolate.endSymbol();
+ var theme = startSymbol + (options.themeWatch ? '' : '::') + 'theme' + endSymbol;
+ var themeAttr = (options.hasTheme) ? 'md-theme="'+theme+'"': '';
+ return '<div class="md-dialog-container" tabindex="-1" ' + themeAttr + '>' + validatedTemplate(template) + '</div>';
+
+ /**
+ * The specified template should contain a <md-dialog> wrapper element....
+ */
+ function validatedTemplate(template) {
+ if (options.autoWrap && !/<\/md-dialog>/g.test(template)) {
+ return '<md-dialog>' + (template || '') + '</md-dialog>';
+ } else {
+ return template || '';
+ }
+ }
+ }
+ };
+
+ function beforeCompile(options) {
+ // Automatically apply the theme, if the user didn't specify a theme explicitly.
+ // Those option changes need to be done, before the compilation has started, because otherwise
+ // the option changes will be not available in the $mdCompilers locales.
+ options.defaultTheme = $mdTheming.defaultTheme();
+
+ detectTheming(options);
+ }
+
+ function beforeShow(scope, element, options, controller) {
+
+ if (controller) {
+ var mdHtmlContent = controller.htmlContent || options.htmlContent || '';
+ var mdTextContent = controller.textContent || options.textContent || '';
+
+ if (mdHtmlContent && !$injector.has('$sanitize')) {
+ throw Error('The ngSanitize module must be loaded in order to use htmlContent.');
+ }
+
+ if (mdHtmlContent && mdTextContent) {
+ throw Error('md-dialog cannot have both `htmlContent` and `textContent`');
+ }
+
+ // Only assign the content if nothing throws, otherwise it'll still be compiled.
+ controller.mdHtmlContent = mdHtmlContent;
+ controller.mdTextContent = mdTextContent;
+ }
+ }
+
+ /** Show method for dialogs */
+ function onShow(scope, element, options) {
+ angular.element($document[0].body).addClass('md-dialog-is-showing');
+
+ var dialogElement = element.find('md-dialog');
+
+ // Once a dialog has `ng-cloak` applied on his template the dialog animation will not work
+ // properly. This is a very common problem, so we have to notify the developer about this.
+ if (dialogElement.hasClass('ng-cloak')) {
+ var message =
+ '$mdDialog: using `<md-dialog ng-cloak>` will affect the dialog opening animations.';
+ $log.warn(message, element[0]);
+ }
+
+ captureParentAndFromToElements(options);
+ configureAria(dialogElement, options);
+ showBackdrop(scope, element, options);
+ activateListeners(element, options);
+
+ return dialogPopIn(element, options)
+ .then(function() {
+ lockScreenReader(element, options);
+ focusOnOpen();
+ });
+
+ /**
+ * For alerts, focus on content... otherwise focus on the close button (or equivalent)
+ */
+ function focusOnOpen() {
+ if (options.focusOnOpen) {
+ var target = $mdUtil.findFocusTarget(element) || findCloseButton() || dialogElement;
+ target.focus();
+ }
+
+ /**
+ * If no element with class dialog-close, try to find the last
+ * button child in md-dialog-actions and assume it is a close button.
+ *
+ * If we find no actions at all, log a warning to the console.
+ */
+ function findCloseButton() {
+ return element[0].querySelector('.dialog-close, md-dialog-actions button:last-child');
+ }
+ }
+ }
+
+ /**
+ * Remove function for all dialogs
+ */
+ function onRemove(scope, element, options) {
+ options.deactivateListeners();
+ options.unlockScreenReader();
+ options.hideBackdrop(options.$destroy);
+
+ // Remove the focus traps that we added earlier for keeping focus within the dialog.
+ if (removeFocusTrap) {
+ removeFocusTrap();
+ removeFocusTrap = null;
+ }
+
+ // For navigation $destroy events, do a quick, non-animated removal,
+ // but for normal closes (from clicks, etc) animate the removal
+ return options.$destroy ? detachAndClean() : animateRemoval().then(detachAndClean);
+
+ /**
+ * For normal closes, animate the removal.
+ * For forced closes (like $destroy events), skip the animations
+ */
+ function animateRemoval() {
+ return dialogPopOut(element, options);
+ }
+
+ /**
+ * Detach the element
+ */
+ function detachAndClean() {
+ angular.element($document[0].body).removeClass('md-dialog-is-showing');
+
+ // Reverse the container stretch if using a content element.
+ if (options.contentElement) {
+ options.reverseContainerStretch();
+ }
+
+ // Exposed cleanup function from the $mdCompiler.
+ options.cleanupElement();
+
+ // Restores the focus to the origin element if the last interaction upon opening was a keyboard.
+ if (!options.$destroy && options.originInteraction === 'keyboard') {
+ options.origin.focus();
+ }
+ }
+ }
+
+ function detectTheming(options) {
+ // Once the user specifies a targetEvent, we will automatically try to find the correct
+ // nested theme.
+ var targetEl;
+ if (options.targetEvent && options.targetEvent.target) {
+ targetEl = angular.element(options.targetEvent.target);
+ }
+
+ var themeCtrl = targetEl && targetEl.controller('mdTheme');
+
+ options.hasTheme = (!!themeCtrl);
+
+ if (!options.hasTheme) {
+ return;
+ }
+
+ options.themeWatch = themeCtrl.$shouldWatch;
+
+ var theme = options.theme || themeCtrl.$mdTheme;
+
+ if (theme) {
+ options.scope.theme = theme;
+ }
+
+ var unwatch = themeCtrl.registerChanges(function (newTheme) {
+ options.scope.theme = newTheme;
+
+ if (!options.themeWatch) {
+ unwatch();
+ }
+ });
+ }
+
+ /**
+ * Capture originator/trigger/from/to element information (if available)
+ * and the parent container for the dialog; defaults to the $rootElement
+ * unless overridden in the options.parent
+ */
+ function captureParentAndFromToElements(options) {
+ options.origin = angular.extend({
+ element: null,
+ bounds: null,
+ focus: angular.noop
+ }, options.origin || {});
+
+ options.parent = getDomElement(options.parent, $rootElement);
+ options.closeTo = getBoundingClientRect(getDomElement(options.closeTo));
+ options.openFrom = getBoundingClientRect(getDomElement(options.openFrom));
+
+ if (options.targetEvent) {
+ options.origin = getBoundingClientRect(options.targetEvent.target, options.origin);
+ options.originInteraction = $mdInteraction.getLastInteractionType();
+ }
+
+
+ /**
+ * Identify the bounding RECT for the target element
+ *
+ */
+ function getBoundingClientRect (element, orig) {
+ var source = angular.element((element || {}));
+ if (source && source.length) {
+ // Compute and save the target element's bounding rect, so that if the
+ // element is hidden when the dialog closes, we can shrink the dialog
+ // back to the same position it expanded from.
+ //
+ // Checking if the source is a rect object or a DOM element
+ var bounds = {top:0,left:0,height:0,width:0};
+ var hasFn = angular.isFunction(source[0].getBoundingClientRect);
+
+ return angular.extend(orig || {}, {
+ element : hasFn ? source : undefined,
+ bounds : hasFn ? source[0].getBoundingClientRect() : angular.extend({}, bounds, source[0]),
+ focus : angular.bind(source, source.focus),
+ });
+ }
+ }
+
+ /**
+ * If the specifier is a simple string selector, then query for
+ * the DOM element.
+ */
+ function getDomElement(element, defaultElement) {
+ if (angular.isString(element)) {
+ element = $document[0].querySelector(element);
+ }
+
+ // If we have a reference to a raw dom element, always wrap it in jqLite
+ return angular.element(element || defaultElement);
+ }
+
+ }
+
+ /**
+ * Listen for escape keys and outside clicks to auto close
+ */
+ function activateListeners(element, options) {
+ var window = angular.element($window);
+ var onWindowResize = $mdUtil.debounce(function() {
+ stretchDialogContainerToViewport(element, options);
+ }, 60);
+
+ var removeListeners = [];
+ var smartClose = function() {
+ // Only 'confirm' dialogs have a cancel button... escape/clickOutside will
+ // cancel or fallback to hide.
+ var closeFn = (options.$type === 'alert') ? $mdDialog.hide : $mdDialog.cancel;
+ $mdUtil.nextTick(closeFn, true);
+ };
+
+ if (options.escapeToClose) {
+ var parentTarget = options.parent;
+ var keyHandlerFn = function(ev) {
+ if (ev.keyCode === $mdConstant.KEY_CODE.ESCAPE) {
+ ev.stopImmediatePropagation();
+ ev.preventDefault();
+
+ smartClose();
+ }
+ };
+
+ // Add keydown listeners
+ element.on('keydown', keyHandlerFn);
+ parentTarget.on('keydown', keyHandlerFn);
+
+ // Queue remove listeners function
+ removeListeners.push(function() {
+ element.off('keydown', keyHandlerFn);
+ parentTarget.off('keydown', keyHandlerFn);
+ });
+ }
+
+ // Register listener to update dialog on window resize
+ window.on('resize', onWindowResize);
+
+ removeListeners.push(function() {
+ window.off('resize', onWindowResize);
+ });
+
+ if (options.clickOutsideToClose) {
+ var target = element;
+ var sourceElem;
+
+ // Keep track of the element on which the mouse originally went down
+ // so that we can only close the backdrop when the 'click' started on it.
+ // A simple 'click' handler does not work,
+ // it sets the target object as the element the mouse went down on.
+ var mousedownHandler = function(ev) {
+ sourceElem = ev.target;
+ };
+
+ // We check if our original element and the target is the backdrop
+ // because if the original was the backdrop and the target was inside the dialog
+ // we don't want to dialog to close.
+ var mouseupHandler = function(ev) {
+ if (sourceElem === target[0] && ev.target === target[0]) {
+ ev.stopPropagation();
+ ev.preventDefault();
+
+ smartClose();
+ }
+ };
+
+ // Add listeners
+ target.on('mousedown', mousedownHandler);
+ target.on('mouseup', mouseupHandler);
+
+ // Queue remove listeners function
+ removeListeners.push(function() {
+ target.off('mousedown', mousedownHandler);
+ target.off('mouseup', mouseupHandler);
+ });
+ }
+
+ // Attach specific `remove` listener handler
+ options.deactivateListeners = function() {
+ removeListeners.forEach(function(removeFn) {
+ removeFn();
+ });
+ options.deactivateListeners = null;
+ };
+ }
+
+ /**
+ * Show modal backdrop element...
+ */
+ function showBackdrop(scope, element, options) {
+
+ if (options.disableParentScroll) {
+ // !! DO this before creating the backdrop; since disableScrollAround()
+ // configures the scroll offset; which is used by mdBackDrop postLink()
+ options.restoreScroll = $mdUtil.disableScrollAround(element, options.parent);
+ }
+
+ if (options.hasBackdrop) {
+ options.backdrop = $mdUtil.createBackdrop(scope, "md-dialog-backdrop md-opaque");
+ $animate.enter(options.backdrop, options.parent);
+ }
+
+ /**
+ * Hide modal backdrop element...
+ */
+ options.hideBackdrop = function hideBackdrop($destroy) {
+ if (options.backdrop) {
+ if ($destroy) {
+ options.backdrop.remove();
+ } else {
+ $animate.leave(options.backdrop);
+ }
+ }
+
+ if (options.disableParentScroll) {
+ options.restoreScroll && options.restoreScroll();
+ delete options.restoreScroll;
+ }
+
+ options.hideBackdrop = null;
+ };
+ }
+
+ /**
+ * Inject ARIA-specific attributes appropriate for Dialogs
+ */
+ function configureAria(element, options) {
+
+ var role = (options.$type === 'alert') ? 'alertdialog' : 'dialog';
+ var dialogContent = element.find('md-dialog-content');
+ var existingDialogId = element.attr('id');
+ var dialogContentId = 'dialogContent_' + (existingDialogId || $mdUtil.nextUid());
+
+ element.attr({
+ 'role': role,
+ 'tabIndex': '-1'
+ });
+
+ if (dialogContent.length === 0) {
+ dialogContent = element;
+ // If the dialog element already had an ID, don't clobber it.
+ if (existingDialogId) {
+ dialogContentId = existingDialogId;
+ }
+ }
+
+ dialogContent.attr('id', dialogContentId);
+ element.attr('aria-describedby', dialogContentId);
+
+ if (options.ariaLabel) {
+ $mdAria.expect(element, 'aria-label', options.ariaLabel);
+ }
+ else {
+ $mdAria.expectAsync(element, 'aria-label', function() {
+ // If dialog title is specified, set aria-label with it
+ // See https://github.com/angular/material/issues/10582
+ if (options.title) {
+ return options.title;
+ } else {
+ var words = dialogContent.text().split(/\s+/);
+ if (words.length > 3) words = words.slice(0, 3).concat('...');
+ return words.join(' ');
+ }
+ });
+ }
+
+ // Set up elements before and after the dialog content to capture focus and
+ // redirect back into the dialog.
+ topFocusTrap = document.createElement('div');
+ topFocusTrap.classList.add('md-dialog-focus-trap');
+ topFocusTrap.tabIndex = 0;
+
+ bottomFocusTrap = topFocusTrap.cloneNode(false);
+
+ /**
+ * When focus is about to move out of the end of the dialog, we intercept it and redirect it
+ * back to the md-dialog element.
+ * When focus is about to move out of the start of the dialog, we intercept it and redirect it
+ * back to the last focusable element in the md-dialog.
+ * @param {FocusEvent} event
+ */
+ var focusHandler = function(event) {
+ if (event.target && event.target.nextSibling &&
+ event.target.nextSibling.nodeName === 'MD-DIALOG') {
+ var lastFocusableElement = $mdUtil.getLastTabbableElement(element[0]);
+ if (angular.isElement(lastFocusableElement)) {
+ lastFocusableElement.focus();
+ }
+ } else {
+ element.focus();
+ }
+ };
+
+ topFocusTrap.addEventListener('focus', focusHandler);
+ bottomFocusTrap.addEventListener('focus', focusHandler);
+
+ removeFocusTrap = function () {
+ topFocusTrap.removeEventListener('focus', focusHandler);
+ bottomFocusTrap.removeEventListener('focus', focusHandler);
+
+ if (topFocusTrap && topFocusTrap.parentNode) {
+ topFocusTrap.parentNode.removeChild(topFocusTrap);
+ }
+
+ if (bottomFocusTrap && bottomFocusTrap.parentNode) {
+ bottomFocusTrap.parentNode.removeChild(bottomFocusTrap);
+ }
+ };
+
+ // The top focus trap inserted immediately before the md-dialog element (as a sibling).
+ // The bottom focus trap is inserted immediately after the md-dialog element (as a sibling).
+ element[0].parentNode.insertBefore(topFocusTrap, element[0]);
+ element.after(bottomFocusTrap);
+ }
+
+ /**
+ * Prevents screen reader interaction behind modal window on swipe interfaces.
+ */
+ function lockScreenReader(element, options) {
+ var isHidden = true;
+
+ // get raw DOM node
+ walkDOM(element[0]);
+
+ options.unlockScreenReader = function () {
+ isHidden = false;
+ walkDOM(element[0]);
+
+ options.unlockScreenReader = null;
+ };
+
+ /**
+ * Get all of an element's parent elements up the DOM tree.
+ * @param {Node & ParentNode} element the element to start from
+ * @return {Element[]} The parent elements
+ */
+ function getParents(element) {
+ var parents = [];
+ while (element.parentNode) {
+ if (element === document.body) {
+ return parents;
+ }
+ var children = element.parentNode.children;
+ for (var i = 0; i < children.length; i++) {
+ // skip over child if it is an ascendant of the dialog
+ // a script or style tag, or a live region.
+ if (element !== children[i] &&
+ !isNodeOneOf(children[i], ['SCRIPT', 'STYLE']) &&
+ !children[i].hasAttribute('aria-live')) {
+ parents.push(children[i]);
+ }
+ }
+ element = element.parentNode;
+ }
+ return parents;
+ }
+
+ /**
+ * Walk DOM to apply or remove aria-hidden on sibling nodes and parent sibling nodes.
+ * @param {Element} element the element to start from when walking up the DOM
+ * @returns {void}
+ */
+ function walkDOM(element) {
+ var elements = getParents(element);
+ for (var i = 0; i < elements.length; i++) {
+ elements[i].setAttribute('aria-hidden', isHidden);
+ }
+ }
+ }
+
+ /**
+ * Ensure the dialog container fill-stretches to the viewport.
+ * @param {JQLite} container dialog container
+ * @param {Object} options
+ * @returns {function(): void} function that reverts the modified styles
+ */
+ function stretchDialogContainerToViewport(container, options) {
+ var isFixed = $window.getComputedStyle($document[0].body).position === 'fixed';
+ var backdrop = options.backdrop ? $window.getComputedStyle(options.backdrop[0]) : null;
+ var height = backdrop ?
+ Math.min($document[0].body.clientHeight, Math.ceil(Math.abs(parseInt(backdrop.height, 10))))
+ : 0;
+
+ var previousStyles = {
+ top: container.css('top'),
+ height: container.css('height')
+ };
+
+ // If the body is fixed, determine the distance to the viewport in relative from the parent.
+ var parentTop = Math.abs(options.parent[0].getBoundingClientRect().top);
+
+ container.css({
+ top: (isFixed ? parentTop : 0) + 'px',
+ height: height ? height + 'px' : '100%'
+ });
+
+ return function() {
+ // Reverts the modified styles back to the previous values.
+ // This is needed for contentElements, which should have the same styles after close
+ // as before.
+ container.css(previousStyles);
+ };
+ }
+
+ /**
+ * Dialog open and pop-in animation.
+ * @param {JQLite} container dialog container
+ * @param {Object} options
+ * @returns {*}
+ */
+ function dialogPopIn(container, options) {
+ // Add the `md-dialog-container` to the DOM
+ options.parent.append(container);
+ options.reverseContainerStretch = stretchDialogContainerToViewport(container, options);
+
+ var dialogEl = container.find('md-dialog');
+ var animator = $mdUtil.dom.animator;
+ var buildTranslateToOrigin = animator.calculateZoomToOrigin;
+ var translateOptions = {transitionInClass: 'md-transition-in', transitionOutClass: 'md-transition-out'};
+ var from = animator.toTransformCss(buildTranslateToOrigin(dialogEl, options.openFrom || options.origin));
+ var to = animator.toTransformCss(""); // defaults to center display (or parent or $rootElement)
+
+ dialogEl.toggleClass('md-dialog-fullscreen', !!options.fullscreen);
+
+ return animator
+ .translate3d(dialogEl, from, to, translateOptions)
+ .then(function(animateReversal) {
+
+ // Build a reversal translate function synced to this translation...
+ options.reverseAnimate = function() {
+ delete options.reverseAnimate;
+
+ if (options.closeTo) {
+ // Using the opposite classes to create a close animation to the closeTo element
+ translateOptions = {transitionInClass: 'md-transition-out', transitionOutClass: 'md-transition-in'};
+ from = to;
+ to = animator.toTransformCss(buildTranslateToOrigin(dialogEl, options.closeTo));
+
+ return animator
+ .translate3d(dialogEl, from, to,translateOptions);
+ }
+
+ return animateReversal(
+ to = animator.toTransformCss(
+ // in case the origin element has moved or is hidden,
+ // let's recalculate the translateCSS
+ buildTranslateToOrigin(dialogEl, options.origin)
+ )
+ );
+ };
+
+ // Function to revert the generated animation styles on the dialog element.
+ // Useful when using a contentElement instead of a template.
+ options.clearAnimate = function() {
+ delete options.clearAnimate;
+
+ // Remove the transition classes, added from $animateCSS, since those can't be removed
+ // by reversely running the animator.
+ dialogEl.removeClass([
+ translateOptions.transitionOutClass,
+ translateOptions.transitionInClass
+ ].join(' '));
+
+ // Run the animation reversely to remove the previous added animation styles.
+ return animator.translate3d(dialogEl, to, animator.toTransformCss(''), {});
+ };
+
+ return true;
+ });
+ }
+
+ /**
+ * Dialog close and pop-out animation.
+ * @param {JQLite} container dialog container
+ * @param {Object} options
+ * @returns {*}
+ */
+ function dialogPopOut(container, options) {
+ return options.reverseAnimate().then(function() {
+ if (options.contentElement) {
+ // When we use a contentElement, we want the element to be the same as before.
+ // That means, that we have to clear all the animation properties, like transform.
+ options.clearAnimate();
+ }
+ });
+ }
+
+ /**
+ * Utility function to filter out raw DOM nodes.
+ * @param {Node} elem
+ * @param {string[]} nodeTypeArray
+ * @returns {boolean}
+ */
+ function isNodeOneOf(elem, nodeTypeArray) {
+ return nodeTypeArray.indexOf(elem.nodeName) !== -1;
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.divider
+ * @description Divider module!
+ */
+MdDividerDirective.$inject = ["$mdTheming"];
+angular.module('material.components.divider', [
+ 'material.core'
+])
+ .directive('mdDivider', MdDividerDirective);
+
+/**
+ * @ngdoc directive
+ * @name mdDivider
+ * @module material.components.divider
+ * @restrict E
+ *
+ * @description
+ * Dividers group and separate content within lists and page layouts using strong visual and spatial distinctions. This divider is a thin rule, lightweight enough to not distract the user from content.
+ *
+ * @param {boolean=} md-inset Add this attribute to activate the inset divider style.
+ * @usage
+ * <hljs lang="html">
+ * <md-divider></md-divider>
+ *
+ * <md-divider md-inset></md-divider>
+ * </hljs>
+ *
+ */
+function MdDividerDirective($mdTheming) {
+ return {
+ restrict: 'E',
+ link: $mdTheming
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * @ngdoc module
+ * @name material.components.fabActions
+ */
+ MdFabActionsDirective.$inject = ["$mdUtil"];
+ angular
+ .module('material.components.fabActions', ['material.core'])
+ .directive('mdFabActions', MdFabActionsDirective);
+
+ /**
+ * @ngdoc directive
+ * @name mdFabActions
+ * @module material.components.fabActions
+ *
+ * @restrict E
+ *
+ * @description
+ * The `<md-fab-actions>` directive is used inside of a `<md-fab-speed-dial>` or
+ * `<md-fab-toolbar>` directive to mark an element (or elements) as the actions and setup the
+ * proper event listeners.
+ *
+ * @usage
+ * See the `<md-fab-speed-dial>` or `<md-fab-toolbar>` directives for example usage.
+ */
+ function MdFabActionsDirective($mdUtil) {
+ return {
+ restrict: 'E',
+
+ require: ['^?mdFabSpeedDial', '^?mdFabToolbar'],
+
+ compile: function(element, attributes) {
+ var children = element.children();
+ var actionItemButtons;
+ var hasNgRepeat = $mdUtil.prefixer().hasAttribute(children, 'ng-repeat');
+
+ // Action item buttons should not be in the tab order when the speed dial is closed.
+ actionItemButtons = element.find('md-button');
+ angular.forEach(actionItemButtons, function(button) {
+ button.setAttribute('tabindex', -1);
+ });
+
+ // Support both ng-repeat and static content
+ if (hasNgRepeat) {
+ children.addClass('md-fab-action-item');
+ } else {
+ // Wrap every child in a new div and add a class that we can scale/fling independently
+ children.wrap('<div class="md-fab-action-item">');
+ }
+ }
+ };
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ MdFabController.$inject = ["$scope", "$element", "$animate", "$mdUtil", "$mdConstant", "$timeout"];
+ angular.module('material.components.fabShared', ['material.core'])
+ .controller('MdFabController', MdFabController);
+
+ function MdFabController($scope, $element, $animate, $mdUtil, $mdConstant, $timeout) {
+ var ctrl = this;
+ var initialAnimationAttempts = 0;
+
+ // NOTE: We use async eval(s) below to avoid conflicts with any existing digest loops
+
+ ctrl.open = function() {
+ $scope.$evalAsync("ctrl.isOpen = true");
+ };
+
+ ctrl.close = function() {
+ // Async eval to avoid conflicts with existing digest loops
+ $scope.$evalAsync("ctrl.isOpen = false");
+
+ // Focus the trigger when the element closes so users can still tab to the next item
+ $element.find('md-fab-trigger')[0].focus();
+ };
+
+ // Toggle the open/close state when the trigger is clicked
+ ctrl.toggle = function() {
+ $scope.$evalAsync("ctrl.isOpen = !ctrl.isOpen");
+ };
+
+ /*
+ * AngularJS Lifecycle hook for newer AngularJS versions.
+ * Bindings are not guaranteed to have been assigned in the controller, but they are in the
+ * $onInit hook.
+ */
+ ctrl.$onInit = function() {
+ setupDefaults();
+ setupListeners();
+ setupWatchers();
+
+ fireInitialAnimations();
+ };
+
+ // For AngularJS 1.4 and older, where there are no lifecycle hooks but bindings are pre-assigned,
+ // manually call the $onInit hook.
+ if (angular.version.major === 1 && angular.version.minor <= 4) {
+ this.$onInit();
+ }
+
+ function setupDefaults() {
+ // Set the default direction to 'down' if none is specified
+ ctrl.direction = ctrl.direction || 'down';
+
+ // Set the default to be closed
+ ctrl.isOpen = ctrl.isOpen || false;
+
+ // Start the keyboard interaction at the first action
+ resetActionIndex();
+
+ // Add an animations waiting class so we know not to run
+ $element.addClass('md-animations-waiting');
+ }
+
+ function setupListeners() {
+ var eventTypes = [
+ 'click', 'focusin', 'focusout'
+ ];
+
+ // Add our listeners
+ angular.forEach(eventTypes, function(eventType) {
+ $element.on(eventType, parseEvents);
+ });
+
+ // Remove our listeners when destroyed
+ $scope.$on('$destroy', function() {
+ angular.forEach(eventTypes, function(eventType) {
+ $element.off(eventType, parseEvents);
+ });
+
+ // remove any attached keyboard handlers in case element is removed while
+ // speed dial is open
+ disableKeyboard();
+ });
+ }
+
+ var closeTimeout;
+
+ /**
+ * @param {MouseEvent} event
+ */
+ function parseEvents(event) {
+ // If the event is a click, just handle it
+ if (event.type == 'click') {
+ handleItemClick(event);
+ }
+
+ // If we focusout, set a timeout to close the element
+ if (event.type == 'focusout' && !closeTimeout) {
+ closeTimeout = $timeout(function() {
+ ctrl.close();
+ }, 100, false);
+ }
+
+ // If we see a focusin and there is a timeout about to run, cancel it so we stay open
+ if (event.type == 'focusin' && closeTimeout) {
+ $timeout.cancel(closeTimeout);
+ closeTimeout = null;
+ }
+ }
+
+ function resetActionIndex() {
+ ctrl.currentActionIndex = -1;
+ }
+
+ function setupWatchers() {
+ // Watch for changes to the direction and update classes/attributes
+ $scope.$watch('ctrl.direction', function(newDir, oldDir) {
+ // Add the appropriate classes so we can target the direction in the CSS
+ $animate.removeClass($element, 'md-' + oldDir);
+ $animate.addClass($element, 'md-' + newDir);
+
+ // Reset the action index since it may have changed
+ resetActionIndex();
+ });
+
+ var trigger, actions;
+
+ // Watch for changes to md-open
+ $scope.$watch('ctrl.isOpen', function(isOpen) {
+ // Reset the action index since it may have changed
+ resetActionIndex();
+
+ // We can't get the trigger/actions outside of the watch because the component hasn't been
+ // linked yet, so we wait until the first watch fires to cache them.
+ if (!trigger || !actions) {
+ trigger = getTriggerElement();
+ actions = getActionsElement();
+ }
+
+ if (isOpen) {
+ enableKeyboard();
+ } else {
+ disableKeyboard();
+ }
+
+ var toAdd = isOpen ? 'md-is-open' : '';
+ var toRemove = isOpen ? '' : 'md-is-open';
+
+ // Set the proper ARIA attributes
+ trigger.attr('aria-haspopup', true);
+ trigger.attr('aria-expanded', isOpen);
+ actions.attr('aria-hidden', !isOpen);
+
+ // Animate the CSS classes
+ $animate.setClass($element, toAdd, toRemove);
+ });
+ }
+
+ function fireInitialAnimations() {
+ // If the element is actually visible on the screen
+ if ($element[0].scrollHeight > 0) {
+ // Fire our animation
+ $animate.addClass($element, '_md-animations-ready').then(function() {
+ // Remove the waiting class
+ $element.removeClass('md-animations-waiting');
+ });
+ }
+
+ // Otherwise, try for up to 1 second before giving up
+ else if (initialAnimationAttempts < 10) {
+ $timeout(fireInitialAnimations, 100);
+
+ // Increment our counter
+ initialAnimationAttempts = initialAnimationAttempts + 1;
+ }
+ }
+
+ function enableKeyboard() {
+ $element.on('keydown', keyPressed);
+
+ // On the next tick, setup a check for outside clicks; we do this on the next tick to avoid
+ // clicks/touches that result in the isOpen attribute changing (e.g. a bound radio button)
+ $mdUtil.nextTick(function() {
+ angular.element(document).on('click touchend', checkForOutsideClick);
+ });
+ }
+
+ function disableKeyboard() {
+ $element.off('keydown', keyPressed);
+ angular.element(document).off('click touchend', checkForOutsideClick);
+ }
+
+ function checkForOutsideClick(event) {
+ if (event.target) {
+ var closestTrigger = $mdUtil.getClosest(event.target, 'md-fab-trigger');
+ var closestActions = $mdUtil.getClosest(event.target, 'md-fab-actions');
+
+ if (!closestTrigger && !closestActions) {
+ ctrl.close();
+ }
+ }
+ }
+
+ /**
+ * @param {KeyboardEvent} event
+ * @returns {boolean}
+ */
+ function keyPressed(event) {
+ switch (event.which) {
+ case $mdConstant.KEY_CODE.ESCAPE: ctrl.close(); event.preventDefault(); return false;
+ case $mdConstant.KEY_CODE.LEFT_ARROW: doKeyLeft(event); return false;
+ case $mdConstant.KEY_CODE.UP_ARROW: doKeyUp(event); return false;
+ case $mdConstant.KEY_CODE.RIGHT_ARROW: doKeyRight(event); return false;
+ case $mdConstant.KEY_CODE.DOWN_ARROW: doKeyDown(event); return false;
+ case $mdConstant.KEY_CODE.TAB: doShift(event); return false;
+ }
+ }
+
+ function doActionPrev(event) {
+ focusAction(event, -1);
+ }
+
+ function doActionNext(event) {
+ focusAction(event, 1);
+ }
+
+ function focusAction(event, direction) {
+ var actions = getActionsElement()[0].querySelectorAll('.md-fab-action-item');
+ var previousActionIndex = ctrl.currentActionIndex;
+
+ // Increment/decrement the counter with restrictions
+ ctrl.currentActionIndex = ctrl.currentActionIndex + direction;
+ ctrl.currentActionIndex = Math.min(actions.length - 1, ctrl.currentActionIndex);
+ ctrl.currentActionIndex = Math.max(0, ctrl.currentActionIndex);
+
+ // Let Tab and Shift+Tab escape if we're trying to move past the start/end.
+ if (event.which !== $mdConstant.KEY_CODE.TAB ||
+ previousActionIndex !== ctrl.currentActionIndex) {
+ // Focus the element
+ var focusElement = angular.element(actions[ctrl.currentActionIndex]).children()[0];
+ focusElement.focus();
+
+ // Make sure the event doesn't bubble and cause something else
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ }
+ }
+
+ function doKeyLeft(event) {
+ if (ctrl.direction === 'left') {
+ doActionNext(event);
+ } else {
+ doActionPrev(event);
+ }
+ }
+
+ function doKeyUp(event) {
+ if (ctrl.direction === 'down') {
+ doActionPrev(event);
+ } else {
+ doActionNext(event);
+ }
+ }
+
+ function doKeyRight(event) {
+ if (ctrl.direction === 'left') {
+ doActionPrev(event);
+ } else {
+ doActionNext(event);
+ }
+ }
+
+ function doKeyDown(event) {
+ if (ctrl.direction === 'up') {
+ doActionPrev(event);
+ } else {
+ doActionNext(event);
+ }
+ }
+
+ function doShift(event) {
+ if (event.shiftKey) {
+ doActionPrev(event);
+ } else {
+ doActionNext(event);
+ }
+ }
+
+ /**
+ * @param {Node} element
+ * @returns {Node|null}
+ */
+ function getClosestButton(element) {
+ return $mdUtil.getClosest(element, 'button') || $mdUtil.getClosest(element, 'md-button');
+ }
+
+ /**
+ * @param {Node} element
+ * @returns {Node|null}
+ */
+ function getClosestTrigger(element) {
+ return $mdUtil.getClosest(element, 'md-fab-trigger');
+ }
+
+ /**
+ * @param {Node} element
+ * @returns {Node|null}
+ */
+ function getClosestAction(element) {
+ return $mdUtil.getClosest(element, 'md-fab-actions');
+ }
+
+ /**
+ * @param {MouseEvent|FocusEvent} event
+ */
+ function handleItemClick(event) {
+ var closestButton = event.target ? getClosestButton(event.target) : null;
+
+ // Check that the button in the trigger is not disabled
+ if (closestButton && !closestButton.disabled) {
+ if (getClosestTrigger(event.target)) {
+ ctrl.toggle();
+ }
+ }
+
+ if (getClosestAction(event.target)) {
+ ctrl.close();
+ }
+ }
+
+ function getTriggerElement() {
+ return $element.find('md-fab-trigger');
+ }
+
+ function getActionsElement() {
+ return $element.find('md-fab-actions');
+ }
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * The duration of the CSS animation in milliseconds.
+ *
+ * @type {number}
+ */
+ MdFabSpeedDialFlingAnimation.$inject = ["$timeout"];
+ MdFabSpeedDialScaleAnimation.$inject = ["$timeout"];
+ var cssAnimationDuration = 300;
+
+ /**
+ * @ngdoc module
+ * @name material.components.fabSpeedDial
+ */
+ angular
+ // Declare our module
+ .module('material.components.fabSpeedDial', [
+ 'material.core',
+ 'material.components.fabShared',
+ 'material.components.fabActions'
+ ])
+
+ // Register our directive
+ .directive('mdFabSpeedDial', MdFabSpeedDialDirective)
+
+ // Register our custom animations
+ .animation('.md-fling', MdFabSpeedDialFlingAnimation)
+ .animation('.md-scale', MdFabSpeedDialScaleAnimation)
+
+ // Register a service for each animation so that we can easily inject them into unit tests
+ .service('mdFabSpeedDialFlingAnimation', MdFabSpeedDialFlingAnimation)
+ .service('mdFabSpeedDialScaleAnimation', MdFabSpeedDialScaleAnimation);
+
+ /**
+ * @ngdoc directive
+ * @name mdFabSpeedDial
+ * @module material.components.fabSpeedDial
+ *
+ * @restrict E
+ *
+ * @description
+ * The `<md-fab-speed-dial>` directive is used to present a series of popup elements (usually
+ * `<md-button>`s) for quick access to common actions.
+ *
+ * There are currently two animations available by applying one of the following classes to
+ * the component:
+ *
+ * - `md-fling` - The speed dial items appear from underneath the trigger and move into their
+ * appropriate positions.
+ * - `md-scale` - The speed dial items appear in their proper places by scaling from 0% to 100%.
+ *
+ * You may also easily position the trigger by applying one one of the following classes to the
+ * `<md-fab-speed-dial>` element:
+ * - `md-fab-top-left`
+ * - `md-fab-top-right`
+ * - `md-fab-bottom-left`
+ * - `md-fab-bottom-right`
+ *
+ * These CSS classes use `position: absolute`, so you need to ensure that the container element
+ * also uses `position: absolute` or `position: relative` in order for them to work.
+ *
+ * Additionally, you may use the standard `ng-mouseenter` and `ng-mouseleave` directives to
+ * open or close the speed dial. However, if you wish to allow users to hover over the empty
+ * space where the actions will appear, you must also add the `md-hover-full` class to the speed
+ * dial element. Without this, the hover effect will only occur on top of the trigger.
+ *
+ * See the demos for more information.
+ *
+ * ## Troubleshooting
+ *
+ * If your speed dial shows the closing animation upon launch, you may need to use `ng-cloak` on
+ * the parent container to ensure that it is only visible once ready. We have plans to remove this
+ * necessity in the future.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-fab-speed-dial md-direction="up" class="md-fling">
+ * <md-fab-trigger>
+ * <md-button aria-label="Add..."><md-icon md-svg-src="/img/icons/plus.svg"></md-icon></md-button>
+ * </md-fab-trigger>
+ *
+ * <md-fab-actions>
+ * <md-button aria-label="Add User">
+ * <md-icon md-svg-src="/img/icons/user.svg"></md-icon>
+ * </md-button>
+ *
+ * <md-button aria-label="Add Group">
+ * <md-icon md-svg-src="/img/icons/group.svg"></md-icon>
+ * </md-button>
+ * </md-fab-actions>
+ * </md-fab-speed-dial>
+ * </hljs>
+ *
+ * @param {string} md-direction From which direction you would like the speed dial to appear
+ * relative to the trigger element.
+ * @param {expression=} md-open Programmatically control whether or not the speed-dial is visible.
+ */
+ function MdFabSpeedDialDirective() {
+ return {
+ restrict: 'E',
+
+ scope: {
+ direction: '@?mdDirection',
+ isOpen: '=?mdOpen'
+ },
+
+ bindToController: true,
+ controller: 'MdFabController',
+ controllerAs: 'ctrl',
+
+ link: FabSpeedDialLink
+ };
+
+ function FabSpeedDialLink(scope, element) {
+ // Prepend an element to hold our CSS variables so we can use them in the animations below
+ element.prepend('<div class="_md-css-variables"></div>');
+ }
+ }
+
+ function MdFabSpeedDialFlingAnimation($timeout) {
+ function delayDone(done) { $timeout(done, cssAnimationDuration, false); }
+
+ function runAnimation(element) {
+ // Don't run if we are still waiting and we are not ready
+ if (element.hasClass('md-animations-waiting') && !element.hasClass('_md-animations-ready')) {
+ return;
+ }
+
+ var el = element[0];
+ var ctrl = element.controller('mdFabSpeedDial');
+ var items = el.querySelectorAll('.md-fab-action-item');
+
+ // Grab our trigger element
+ var triggerElement = el.querySelector('md-fab-trigger');
+
+ // Grab our element which stores CSS variables
+ var variablesElement = el.querySelector('._md-css-variables');
+
+ // Setup JS variables based on our CSS variables
+ var startZIndex = parseInt(window.getComputedStyle(variablesElement).zIndex);
+
+ // Always reset the items to their natural position/state
+ angular.forEach(items, function(item, index) {
+ var styles = item.style;
+
+ styles.transform = styles.webkitTransform = '';
+ styles.transitionDelay = '';
+ styles.opacity = ctrl.isOpen ? 1 : 0;
+
+ // Make the items closest to the trigger have the highest z-index
+ styles.zIndex = (items.length - index) + startZIndex;
+ });
+
+ // Set the trigger to be above all of the actions so they disappear behind it.
+ triggerElement.style.zIndex = startZIndex + items.length + 1;
+
+ // If the control is closed, hide the items behind the trigger
+ if (!ctrl.isOpen) {
+ angular.forEach(items, function(item, index) {
+ var newPosition, axis;
+ var styles = item.style;
+
+ // Make sure to account for differences in the dimensions of the trigger verses the items
+ // so that we can properly center everything; this helps hide the item's shadows behind
+ // the trigger.
+ var triggerItemHeightOffset = (triggerElement.clientHeight - item.clientHeight) / 2;
+ var triggerItemWidthOffset = (triggerElement.clientWidth - item.clientWidth) / 2;
+
+ switch (ctrl.direction) {
+ case 'up':
+ newPosition = (item.scrollHeight * (index + 1) + triggerItemHeightOffset);
+ axis = 'Y';
+ break;
+ case 'down':
+ newPosition = -(item.scrollHeight * (index + 1) + triggerItemHeightOffset);
+ axis = 'Y';
+ break;
+ case 'left':
+ newPosition = (item.scrollWidth * (index + 1) + triggerItemWidthOffset);
+ axis = 'X';
+ break;
+ case 'right':
+ newPosition = -(item.scrollWidth * (index + 1) + triggerItemWidthOffset);
+ axis = 'X';
+ break;
+ }
+
+ var newTranslate = 'translate' + axis + '(' + newPosition + 'px)';
+
+ styles.transform = styles.webkitTransform = newTranslate;
+ });
+ }
+ }
+
+ return {
+ addClass: function(element, className, done) {
+ if (element.hasClass('md-fling')) {
+ runAnimation(element);
+ delayDone(done);
+ } else {
+ done();
+ }
+ },
+ removeClass: function(element, className, done) {
+ runAnimation(element);
+ delayDone(done);
+ }
+ };
+ }
+
+ function MdFabSpeedDialScaleAnimation($timeout) {
+ function delayDone(done) { $timeout(done, cssAnimationDuration, false); }
+
+ var delay = 65;
+
+ function runAnimation(element) {
+ var el = element[0];
+ var ctrl = element.controller('mdFabSpeedDial');
+ var items = el.querySelectorAll('.md-fab-action-item');
+
+ // Grab our element which stores CSS variables
+ var variablesElement = el.querySelector('._md-css-variables');
+
+ // Setup JS variables based on our CSS variables
+ var startZIndex = parseInt(window.getComputedStyle(variablesElement).zIndex);
+
+ // Always reset the items to their natural position/state
+ angular.forEach(items, function(item, index) {
+ var styles = item.style,
+ offsetDelay = index * delay;
+
+ styles.opacity = ctrl.isOpen ? 1 : 0;
+ styles.transform = styles.webkitTransform = ctrl.isOpen ? 'scale(1)' : 'scale(0)';
+ styles.transitionDelay = (ctrl.isOpen ? offsetDelay : (items.length - offsetDelay)) + 'ms';
+
+ // Make the items closest to the trigger have the highest z-index
+ styles.zIndex = (items.length - index) + startZIndex;
+ });
+ }
+
+ return {
+ addClass: function(element, className, done) {
+ runAnimation(element);
+ delayDone(done);
+ },
+
+ removeClass: function(element, className, done) {
+ runAnimation(element);
+ delayDone(done);
+ }
+ };
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+(function() {
+ 'use strict';
+
+ /**
+ * @ngdoc module
+ * @name material.components.fabToolbar
+ */
+ angular
+ // Declare our module
+ .module('material.components.fabToolbar', [
+ 'material.core',
+ 'material.components.fabShared',
+ 'material.components.fabActions'
+ ])
+
+ // Register our directive
+ .directive('mdFabToolbar', MdFabToolbarDirective)
+
+ // Register our custom animations
+ .animation('.md-fab-toolbar', MdFabToolbarAnimation)
+
+ // Register a service for the animation so that we can easily inject it into unit tests
+ .service('mdFabToolbarAnimation', MdFabToolbarAnimation);
+
+ /**
+ * @ngdoc directive
+ * @name mdFabToolbar
+ * @module material.components.fabToolbar
+ *
+ * @restrict E
+ *
+ * @description
+ *
+ * The `<md-fab-toolbar>` directive is used to present a toolbar of elements (usually `<md-button>`s)
+ * for quick access to common actions when a floating action button is activated (via click or
+ * keyboard navigation).
+ *
+ * You may also easily position the trigger by applying one one of the following classes to the
+ * `<md-fab-toolbar>` element:
+ * - `md-fab-top-left`
+ * - `md-fab-top-right`
+ * - `md-fab-bottom-left`
+ * - `md-fab-bottom-right`
+ *
+ * These CSS classes use `position: absolute`, so you need to ensure that the container element
+ * also uses `position: absolute` or `position: relative` in order for them to work.
+ *
+ * @usage
+ *
+ * <hljs lang="html">
+ * <md-fab-toolbar md-direction='left'>
+ * <md-fab-trigger>
+ * <md-button aria-label="Add..."><md-icon md-svg-src="/img/icons/plus.svg"></md-icon></md-button>
+ * </md-fab-trigger>
+ *
+ * <md-toolbar>
+ * <md-fab-actions>
+ * <md-button aria-label="Add User">
+ * <md-icon md-svg-src="/img/icons/user.svg"></md-icon>
+ * </md-button>
+ *
+ * <md-button aria-label="Add Group">
+ * <md-icon md-svg-src="/img/icons/group.svg"></md-icon>
+ * </md-button>
+ * </md-fab-actions>
+ * </md-toolbar>
+ * </md-fab-toolbar>
+ * </hljs>
+ *
+ * @param {string} md-direction From which direction you would like the toolbar items to appear
+ * relative to the trigger element. Supports `left` and `right` directions.
+ * @param {expression=} md-open Programmatically control whether or not the toolbar is visible.
+ */
+ function MdFabToolbarDirective() {
+ return {
+ restrict: 'E',
+ transclude: true,
+ template: '<div class="md-fab-toolbar-wrapper">' +
+ ' <div class="md-fab-toolbar-content" ng-transclude></div>' +
+ '</div>',
+
+ scope: {
+ direction: '@?mdDirection',
+ isOpen: '=?mdOpen'
+ },
+
+ bindToController: true,
+ controller: 'MdFabController',
+ controllerAs: 'ctrl',
+
+ link: link
+ };
+
+ function link(scope, element, attributes) {
+ // Add the base class for animations
+ element.addClass('md-fab-toolbar');
+
+ // Prepend the background element to the trigger's button
+ element.find('md-fab-trigger').find('button')
+ .prepend('<div class="md-fab-toolbar-background"></div>');
+ }
+ }
+
+ function MdFabToolbarAnimation() {
+
+ function runAnimation(element, className, done) {
+ // If no className was specified, don't do anything
+ if (!className) {
+ return;
+ }
+
+ var el = element[0];
+ var ctrl = element.controller('mdFabToolbar');
+
+ // Grab the relevant child elements
+ var backgroundElement = el.querySelector('.md-fab-toolbar-background');
+ var triggerElement = el.querySelector('md-fab-trigger button');
+ var toolbarElement = el.querySelector('md-toolbar');
+ var iconElement = el.querySelector('md-fab-trigger button md-icon');
+ var actions = element.find('md-fab-actions').children();
+
+ // If we have both elements, use them to position the new background
+ if (triggerElement && backgroundElement) {
+ // Get our variables
+ var color = window.getComputedStyle(triggerElement).getPropertyValue('background-color');
+ var width = el.offsetWidth;
+ var height = el.offsetHeight;
+
+ // Make it twice as big as it should be since we scale from the center
+ var scale = 2 * (width / triggerElement.offsetWidth);
+
+ // Set some basic styles no matter what animation we're doing
+ backgroundElement.style.backgroundColor = color;
+ backgroundElement.style.borderRadius = width + 'px';
+
+ // If we're open
+ if (ctrl.isOpen) {
+ // Turn on toolbar pointer events when closed
+ toolbarElement.style.pointerEvents = 'inherit';
+
+ backgroundElement.style.width = triggerElement.offsetWidth + 'px';
+ backgroundElement.style.height = triggerElement.offsetHeight + 'px';
+ backgroundElement.style.transform = 'scale(' + scale + ')';
+
+ // Set the next close animation to have the proper delays
+ backgroundElement.style.transitionDelay = '0ms';
+ iconElement && (iconElement.style.transitionDelay = '.3s');
+
+ // Apply a transition delay to actions
+ angular.forEach(actions, function(action, index) {
+ action.style.transitionDelay = (actions.length - index) * 25 + 'ms';
+ });
+ } else {
+ // Turn off toolbar pointer events when closed
+ toolbarElement.style.pointerEvents = 'none';
+
+ // Scale it back down to the trigger's size
+ backgroundElement.style.transform = 'scale(1)';
+
+ // Reset the position
+ backgroundElement.style.top = '0';
+
+ if (element.hasClass('md-right')) {
+ backgroundElement.style.left = '0';
+ backgroundElement.style.right = null;
+ }
+
+ if (element.hasClass('md-left')) {
+ backgroundElement.style.right = '0';
+ backgroundElement.style.left = null;
+ }
+
+ // Set the next open animation to have the proper delays
+ backgroundElement.style.transitionDelay = '200ms';
+ iconElement && (iconElement.style.transitionDelay = '0ms');
+
+ // Apply a transition delay to actions
+ angular.forEach(actions, function(action, index) {
+ action.style.transitionDelay = 200 + (index * 25) + 'ms';
+ });
+ }
+ }
+ }
+
+ return {
+ addClass: function(element, className, done) {
+ runAnimation(element, className, done);
+ done();
+ },
+
+ removeClass: function(element, className, done) {
+ runAnimation(element, className, done);
+ done();
+ }
+ };
+ }
+})();
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.gridList
+ */
+GridListController.$inject = ["$mdUtil"];
+GridLayoutFactory.$inject = ["$mdUtil"];
+GridListDirective.$inject = ["$interpolate", "$mdConstant", "$mdGridLayout", "$mdMedia", "$mdUtil"];
+GridTileDirective.$inject = ["$mdMedia"];
+angular.module('material.components.gridList', ['material.core'])
+ .directive('mdGridList', GridListDirective)
+ .directive('mdGridTile', GridTileDirective)
+ .directive('mdGridTileFooter', GridTileCaptionDirective)
+ .directive('mdGridTileHeader', GridTileCaptionDirective)
+ .factory('$mdGridLayout', GridLayoutFactory);
+
+/**
+ * @ngdoc directive
+ * @name mdGridList
+ * @module material.components.gridList
+ * @restrict E
+ * @description
+ * Grid lists are an alternative to standard list views. Grid lists are distinct
+ * from grids used for layouts and other visual presentations.
+ *
+ * A grid list is best suited to presenting a homogenous data type, typically
+ * images, and is optimized for visual comprehension and differentiating between
+ * like data types.
+ *
+ * A grid list is a continuous element consisting of tessellated, regular
+ * subdivisions called cells that contain tiles (`md-grid-tile`).
+ *
+ * <img src="//material-design.storage.googleapis.com/publish/v_2/material_ext_publish/0Bx4BSt6jniD7OVlEaXZ5YmU1Xzg/components_grids_usage2.png"
+ * style="width: 300px; height: auto; margin-right: 16px;" alt="Concept of grid explained visually">
+ * <img src="//material-design.storage.googleapis.com/publish/v_2/material_ext_publish/0Bx4BSt6jniD7VGhsOE5idWlJWXM/components_grids_usage3.png"
+ * style="width: 300px; height: auto;" alt="Grid concepts legend">
+ *
+ * Cells are arrayed vertically and horizontally within the grid.
+ *
+ * Tiles hold content and can span one or more cells vertically or horizontally.
+ *
+ * ### Responsive Attributes
+ *
+ * The `md-grid-list` directive supports "responsive" attributes, which allow
+ * different `md-cols`, `md-gutter` and `md-row-height` values depending on the
+ * currently matching media query.
+ *
+ * In order to set a responsive attribute, first define the fallback value with
+ * the standard attribute name, then add additional attributes with the
+ * following convention: `{base-attribute-name}-{media-query-name}="{value}"`
+ * (ie. `md-cols-lg="8"`)
+ *
+ * @param {number} md-cols Number of columns in the grid.
+ * @param {string} md-row-height One of
+ * <ul>
+ * <li>CSS length - Fixed height rows (eg. `8px` or `1rem`)</li>
+ * <li>`{width}:{height}` - Ratio of width to height (eg.
+ * `md-row-height="16:9"`)</li>
+ * <li>`"fit"` - Height will be determined by subdividing the available
+ * height by the number of rows</li>
+ * </ul>
+ * @param {string=} md-gutter The amount of space between tiles in CSS units
+ * (default 1px)
+ * @param {expression=} md-on-layout Expression to evaluate after layout. Event
+ * object is available as `$event`, and contains performance information.
+ *
+ * @usage
+ * Basic:
+ * <hljs lang="html">
+ * <md-grid-list md-cols="5" md-gutter="1em" md-row-height="4:3">
+ * <md-grid-tile></md-grid-tile>
+ * </md-grid-list>
+ * </hljs>
+ *
+ * Fixed-height rows:
+ * <hljs lang="html">
+ * <md-grid-list md-cols="4" md-row-height="200px" ...>
+ * <md-grid-tile></md-grid-tile>
+ * </md-grid-list>
+ * </hljs>
+ *
+ * Fit rows:
+ * <hljs lang="html">
+ * <md-grid-list md-cols="4" md-row-height="fit" style="height: 400px;" ...>
+ * <md-grid-tile></md-grid-tile>
+ * </md-grid-list>
+ * </hljs>
+ *
+ * Using responsive attributes:
+ * <hljs lang="html">
+ * <md-grid-list
+ * md-cols-sm="2"
+ * md-cols-md="4"
+ * md-cols-lg="8"
+ * md-cols-gt-lg="12"
+ * ...>
+ * <md-grid-tile></md-grid-tile>
+ * </md-grid-list>
+ * </hljs>
+ */
+function GridListDirective($interpolate, $mdConstant, $mdGridLayout, $mdMedia, $mdUtil) {
+ return {
+ restrict: 'E',
+ controller: GridListController,
+ scope: {
+ mdOnLayout: '&'
+ },
+ link: postLink
+ };
+
+ function postLink(scope, element, attrs, ctrl) {
+ element.addClass('_md'); // private md component indicator for styling
+
+ // Apply semantics
+ element.attr('role', 'list');
+
+ // Provide the controller with a way to trigger layouts.
+ ctrl.layoutDelegate = layoutDelegate;
+
+ var invalidateLayout = angular.bind(ctrl, ctrl.invalidateLayout),
+ unwatchAttrs = watchMedia();
+ scope.$on('$destroy', unwatchMedia);
+
+ /**
+ * Watches for changes in media, invalidating layout as necessary.
+ */
+ function watchMedia() {
+ for (var mediaName in $mdConstant.MEDIA) {
+ $mdMedia(mediaName); // initialize
+ $mdMedia.getQuery($mdConstant.MEDIA[mediaName])
+ .addListener(invalidateLayout);
+ }
+ return $mdMedia.watchResponsiveAttributes(
+ ['md-cols', 'md-row-height', 'md-gutter'], attrs, layoutIfMediaMatch);
+ }
+
+ function unwatchMedia() {
+ ctrl.layoutDelegate = angular.noop;
+
+ unwatchAttrs();
+ for (var mediaName in $mdConstant.MEDIA) {
+ $mdMedia.getQuery($mdConstant.MEDIA[mediaName])
+ .removeListener(invalidateLayout);
+ }
+ }
+
+ /**
+ * Performs grid layout if the provided mediaName matches the currently
+ * active media type.
+ */
+ function layoutIfMediaMatch(mediaName) {
+ if (mediaName == null) {
+ // TODO(shyndman): It would be nice to only layout if we have
+ // instances of attributes using this media type
+ ctrl.invalidateLayout();
+ } else if ($mdMedia(mediaName)) {
+ ctrl.invalidateLayout();
+ }
+ }
+
+ var lastLayoutProps;
+
+ /**
+ * Invokes the layout engine, and uses its results to lay out our
+ * tile elements.
+ *
+ * @param {boolean} tilesInvalidated Whether tiles have been
+ * added/removed/moved since the last layout. This is to avoid situations
+ * where tiles are replaced with properties identical to their removed
+ * counterparts.
+ */
+ function layoutDelegate(tilesInvalidated) {
+ var tiles = getTileElements();
+ var props = {
+ tileSpans: getTileSpans(tiles),
+ colCount: getColumnCount(),
+ rowMode: getRowMode(),
+ rowHeight: getRowHeight(),
+ gutter: getGutter()
+ };
+
+ if (!tilesInvalidated && angular.equals(props, lastLayoutProps)) {
+ return;
+ }
+
+ var performance =
+ $mdGridLayout(props.colCount, props.tileSpans, tiles)
+ .map(function(tilePositions, rowCount) {
+ return {
+ grid: {
+ element: element,
+ style: getGridStyle(props.colCount, rowCount,
+ props.gutter, props.rowMode, props.rowHeight)
+ },
+ tiles: tilePositions.map(function(ps, i) {
+ return {
+ element: angular.element(tiles[i]),
+ style: getTileStyle(ps.position, ps.spans,
+ props.colCount, rowCount,
+ props.gutter, props.rowMode, props.rowHeight)
+ };
+ })
+ };
+ })
+ .reflow()
+ .performance();
+
+ // Report layout
+ scope.mdOnLayout({
+ $event: {
+ performance: performance
+ }
+ });
+
+ lastLayoutProps = props;
+ }
+
+ // Use $interpolate to do some simple string interpolation as a convenience.
+
+ var startSymbol = $interpolate.startSymbol();
+ var endSymbol = $interpolate.endSymbol();
+
+ // Returns an expression wrapped in the interpolator's start and end symbols.
+ function expr(exprStr) {
+ return startSymbol + exprStr + endSymbol;
+ }
+
+ // The amount of space a single 1x1 tile would take up (either width or height), used as
+ // a basis for other calculations. This consists of taking the base size percent (as would be
+ // if evenly dividing the size between cells), and then subtracting the size of one gutter.
+ // However, since there are no gutters on the edges, each tile only uses a fration
+ // (gutterShare = numGutters / numCells) of the gutter size. (Imagine having one gutter per
+ // tile, and then breaking up the extra gutter on the edge evenly among the cells).
+ var UNIT = $interpolate(expr('share') + '% - (' + expr('gutter') + ' * ' + expr('gutterShare') + ')');
+
+ // The horizontal or vertical position of a tile, e.g., the 'top' or 'left' property value.
+ // The position comes the size of a 1x1 tile plus gutter for each previous tile in the
+ // row/column (offset).
+ var POSITION = $interpolate('calc((' + expr('unit') + ' + ' + expr('gutter') + ') * ' + expr('offset') + ')');
+
+ // The actual size of a tile, e.g., width or height, taking rowSpan or colSpan into account.
+ // This is computed by multiplying the base unit by the rowSpan/colSpan, and then adding back
+ // in the space that the gutter would normally have used (which was already accounted for in
+ // the base unit calculation).
+ var DIMENSION = $interpolate('calc((' + expr('unit') + ') * ' + expr('span') + ' + (' + expr('span') + ' - 1) * ' + expr('gutter') + ')');
+
+ /**
+ * Gets the styles applied to a tile element described by the given parameters.
+ * @param {{row: number, col: number}} position The row and column indices of the tile.
+ * @param {{row: number, col: number}} spans The rowSpan and colSpan of the tile.
+ * @param {number} colCount The number of columns.
+ * @param {number} rowCount The number of rows.
+ * @param {string} gutter The amount of space between tiles. This will be something like
+ * '5px' or '2em'.
+ * @param {string} rowMode The row height mode. Can be one of:
+ * 'fixed': all rows have a fixed size, given by rowHeight,
+ * 'ratio': row height defined as a ratio to width, or
+ * 'fit': fit to the grid-list element height, divinding evenly among rows.
+ * @param {string|number} rowHeight The height of a row. This is only used for 'fixed' mode and
+ * for 'ratio' mode. For 'ratio' mode, this is the *ratio* of width-to-height (e.g., 0.75).
+ * @returns {Object} Map of CSS properties to be applied to the style element. Will define
+ * values for top, left, width, height, marginTop, and paddingTop.
+ */
+ function getTileStyle(position, spans, colCount, rowCount, gutter, rowMode, rowHeight) {
+ // TODO(shyndman): There are style caching opportunities here.
+
+ // Percent of the available horizontal space that one column takes up.
+ var hShare = (1 / colCount) * 100;
+
+ // Fraction of the gutter size that each column takes up.
+ var hGutterShare = (colCount - 1) / colCount;
+
+ // Base horizontal size of a column.
+ var hUnit = UNIT({share: hShare, gutterShare: hGutterShare, gutter: gutter});
+
+ // The width and horizontal position of each tile is always calculated the same way, but the
+ // height and vertical position depends on the rowMode.
+ var style = (!$mdUtil.isRtl(attrs)) ? {
+ left: POSITION({ unit: hUnit, offset: position.col, gutter: gutter }),
+ width: DIMENSION({ unit: hUnit, span: spans.col, gutter: gutter }),
+ // resets
+ paddingTop: '',
+ marginTop: '',
+ top: '',
+ height: ''
+ } : {
+ right: POSITION({ unit: hUnit, offset: position.col, gutter: gutter }),
+ width: DIMENSION({ unit: hUnit, span: spans.col, gutter: gutter }),
+ // resets
+ paddingTop: '',
+ marginTop: '',
+ top: '',
+ height: ''
+ };
+
+ switch (rowMode) {
+ case 'fixed':
+ // In fixed mode, simply use the given rowHeight.
+ style.top = POSITION({ unit: rowHeight, offset: position.row, gutter: gutter });
+ style.height = DIMENSION({ unit: rowHeight, span: spans.row, gutter: gutter });
+ break;
+
+ case 'ratio':
+ // Percent of the available vertical space that one row takes up. Here, rowHeight holds
+ // the ratio value. For example, if the width:height ratio is 4:3, rowHeight = 1.333.
+ var vShare = hShare / rowHeight;
+
+ // Base veritcal size of a row.
+ var vUnit = UNIT({ share: vShare, gutterShare: hGutterShare, gutter: gutter });
+
+ // padidngTop and marginTop are used to maintain the given aspect ratio, as
+ // a percentage-based value for these properties is applied to the *width* of the
+ // containing block. See http://www.w3.org/TR/CSS2/box.html#margin-properties
+ style.paddingTop = DIMENSION({ unit: vUnit, span: spans.row, gutter: gutter});
+ style.marginTop = POSITION({ unit: vUnit, offset: position.row, gutter: gutter });
+ break;
+
+ case 'fit':
+ // Fraction of the gutter size that each column takes up.
+ var vGutterShare = (rowCount - 1) / rowCount;
+
+ // Percent of the available vertical space that one row takes up.
+ vShare = (1 / rowCount) * 100;
+
+ // Base vertical size of a row.
+ vUnit = UNIT({share: vShare, gutterShare: vGutterShare, gutter: gutter});
+
+ style.top = POSITION({unit: vUnit, offset: position.row, gutter: gutter});
+ style.height = DIMENSION({unit: vUnit, span: spans.row, gutter: gutter});
+ break;
+ }
+
+ return style;
+ }
+
+ function getGridStyle(colCount, rowCount, gutter, rowMode, rowHeight) {
+ var style = {};
+
+ switch (rowMode) {
+ case 'fixed':
+ style.height = DIMENSION({ unit: rowHeight, span: rowCount, gutter: gutter });
+ style.paddingBottom = '';
+ break;
+
+ case 'ratio':
+ // rowHeight is width / height
+ var hGutterShare = colCount === 1 ? 0 : (colCount - 1) / colCount,
+ hShare = (1 / colCount) * 100,
+ vShare = hShare * (1 / rowHeight),
+ vUnit = UNIT({ share: vShare, gutterShare: hGutterShare, gutter: gutter });
+
+ style.height = '';
+ style.paddingBottom = DIMENSION({ unit: vUnit, span: rowCount, gutter: gutter});
+ break;
+
+ case 'fit':
+ // noop, as the height is user set
+ break;
+ }
+
+ return style;
+ }
+
+ function getTileElements() {
+ return [].filter.call(element.children(), function(ele) {
+ return ele.tagName == 'MD-GRID-TILE' && !ele.$$mdDestroyed;
+ });
+ }
+
+ /**
+ * Gets an array of objects containing the rowspan and colspan for each tile.
+ * @returns {Array<{row: number, col: number}>}
+ */
+ function getTileSpans(tileElements) {
+ return [].map.call(tileElements, function(ele) {
+ var ctrl = angular.element(ele).controller('mdGridTile');
+ return {
+ row: parseInt(
+ $mdMedia.getResponsiveAttribute(ctrl.$attrs, 'md-rowspan'), 10) || 1,
+ col: parseInt(
+ $mdMedia.getResponsiveAttribute(ctrl.$attrs, 'md-colspan'), 10) || 1
+ };
+ });
+ }
+
+ function getColumnCount() {
+ var colCount = parseInt($mdMedia.getResponsiveAttribute(attrs, 'md-cols'), 10);
+ if (isNaN(colCount)) {
+ throw 'md-grid-list: md-cols attribute was not found, or contained a non-numeric value';
+ }
+ return colCount;
+ }
+
+ function getGutter() {
+ return applyDefaultUnit($mdMedia.getResponsiveAttribute(attrs, 'md-gutter') || 1);
+ }
+
+ function getRowHeight() {
+ var rowHeight = $mdMedia.getResponsiveAttribute(attrs, 'md-row-height');
+ if (!rowHeight) {
+ throw 'md-grid-list: md-row-height attribute was not found';
+ }
+
+ switch (getRowMode()) {
+ case 'fixed':
+ return applyDefaultUnit(rowHeight);
+ case 'ratio':
+ var whRatio = rowHeight.split(':');
+ return parseFloat(whRatio[0]) / parseFloat(whRatio[1]);
+ case 'fit':
+ return 0; // N/A
+ }
+ }
+
+ function getRowMode() {
+ var rowHeight = $mdMedia.getResponsiveAttribute(attrs, 'md-row-height');
+ if (!rowHeight) {
+ throw 'md-grid-list: md-row-height attribute was not found';
+ }
+
+ if (rowHeight == 'fit') {
+ return 'fit';
+ } else if (rowHeight.indexOf(':') !== -1) {
+ return 'ratio';
+ } else {
+ return 'fixed';
+ }
+ }
+
+ function applyDefaultUnit(val) {
+ return /\D$/.test(val) ? val : val + 'px';
+ }
+ }
+}
+
+/* @ngInject */
+function GridListController($mdUtil) {
+ this.layoutInvalidated = false;
+ this.tilesInvalidated = false;
+ this.$timeout_ = $mdUtil.nextTick;
+ this.layoutDelegate = angular.noop;
+}
+
+GridListController.prototype = {
+ invalidateTiles: function() {
+ this.tilesInvalidated = true;
+ this.invalidateLayout();
+ },
+
+ invalidateLayout: function() {
+ if (this.layoutInvalidated) {
+ return;
+ }
+ this.layoutInvalidated = true;
+ this.$timeout_(angular.bind(this, this.layout));
+ },
+
+ layout: function() {
+ try {
+ this.layoutDelegate(this.tilesInvalidated);
+ } finally {
+ this.layoutInvalidated = false;
+ this.tilesInvalidated = false;
+ }
+ }
+};
+
+
+/* @ngInject */
+function GridLayoutFactory($mdUtil) {
+ var defaultAnimator = GridTileAnimator;
+
+ /**
+ * Set the reflow animator callback
+ */
+ GridLayout.animateWith = function(customAnimator) {
+ defaultAnimator = !angular.isFunction(customAnimator) ? GridTileAnimator : customAnimator;
+ };
+
+ return GridLayout;
+
+ /**
+ * Publish layout function
+ */
+ function GridLayout(colCount, tileSpans) {
+ var self, layoutInfo, gridStyles, layoutTime, mapTime, reflowTime;
+
+ layoutTime = $mdUtil.time(function() {
+ layoutInfo = calculateGridFor(colCount, tileSpans);
+ });
+
+ return self = {
+
+ /**
+ * An array of objects describing each tile's position in the grid.
+ */
+ layoutInfo: function() {
+ return layoutInfo;
+ },
+
+ /**
+ * Maps grid positioning to an element and a set of styles using the
+ * provided updateFn.
+ */
+ map: function(updateFn) {
+ mapTime = $mdUtil.time(function() {
+ var info = self.layoutInfo();
+ gridStyles = updateFn(info.positioning, info.rowCount);
+ });
+ return self;
+ },
+
+ /**
+ * Default animator simply sets the element.css( <styles> ). An alternate
+ * animator can be provided as an argument. The function has the following
+ * signature:
+ *
+ * function({grid: {element: JQLite, style: Object}, tiles: Array<{element: JQLite, style: Object}>)
+ */
+ reflow: function(animatorFn) {
+ reflowTime = $mdUtil.time(function() {
+ var animator = animatorFn || defaultAnimator;
+ animator(gridStyles.grid, gridStyles.tiles);
+ });
+ return self;
+ },
+
+ /**
+ * Timing for the most recent layout run.
+ */
+ performance: function() {
+ return {
+ tileCount: tileSpans.length,
+ layoutTime: layoutTime,
+ mapTime: mapTime,
+ reflowTime: reflowTime,
+ totalTime: layoutTime + mapTime + reflowTime
+ };
+ }
+ };
+ }
+
+ /**
+ * Default Gridlist animator simple sets the css for each element;
+ * NOTE: any transitions effects must be manually set in the CSS.
+ * e.g.
+ *
+ * md-grid-tile {
+ * transition: all 700ms ease-out 50ms;
+ * }
+ *
+ */
+ function GridTileAnimator(grid, tiles) {
+ grid.element.css(grid.style);
+ tiles.forEach(function(t) {
+ t.element.css(t.style);
+ });
+ }
+
+ /**
+ * Calculates the positions of tiles.
+ *
+ * The algorithm works as follows:
+ * An Array<Number> with length colCount (spaceTracker) keeps track of
+ * available tiling positions, where elements of value 0 represents an
+ * empty position. Space for a tile is reserved by finding a sequence of
+ * 0s with length <= than the tile's colspan. When such a space has been
+ * found, the occupied tile positions are incremented by the tile's
+ * rowspan value, as these positions have become unavailable for that
+ * many rows.
+ *
+ * If the end of a row has been reached without finding space for the
+ * tile, spaceTracker's elements are each decremented by 1 to a minimum
+ * of 0. Rows are searched in this fashion until space is found.
+ */
+ function calculateGridFor(colCount, tileSpans) {
+ var curCol = 0,
+ curRow = 0,
+ spaceTracker = newSpaceTracker();
+
+ return {
+ positioning: tileSpans.map(function(spans, i) {
+ return {
+ spans: spans,
+ position: reserveSpace(spans, i)
+ };
+ }),
+ rowCount: curRow + Math.max.apply(Math, spaceTracker)
+ };
+
+ function reserveSpace(spans, i) {
+ if (spans.col > colCount) {
+ throw 'md-grid-list: Tile at position ' + i + ' has a colspan ' +
+ '(' + spans.col + ') that exceeds the column count ' +
+ '(' + colCount + ')';
+ }
+
+ var start = 0,
+ end = 0;
+
+ // TODO(shyndman): This loop isn't strictly necessary if you can
+ // determine the minimum number of rows before a space opens up. To do
+ // this, recognize that you've iterated across an entire row looking for
+ // space, and if so fast-forward by the minimum rowSpan count. Repeat
+ // until the required space opens up.
+ while (end - start < spans.col) {
+ if (curCol >= colCount) {
+ nextRow();
+ continue;
+ }
+
+ start = spaceTracker.indexOf(0, curCol);
+ if (start === -1 || (end = findEnd(start + 1)) === -1) {
+ start = end = 0;
+ nextRow();
+ continue;
+ }
+
+ curCol = end + 1;
+ }
+
+ adjustRow(start, spans.col, spans.row);
+ curCol = start + spans.col;
+
+ return {
+ col: start,
+ row: curRow
+ };
+ }
+
+ function nextRow() {
+ curCol = 0;
+ curRow++;
+ adjustRow(0, colCount, -1); // Decrement row spans by one
+ }
+
+ function adjustRow(from, cols, by) {
+ for (var i = from; i < from + cols; i++) {
+ spaceTracker[i] = Math.max(spaceTracker[i] + by, 0);
+ }
+ }
+
+ function findEnd(start) {
+ var i;
+ for (i = start; i < spaceTracker.length; i++) {
+ if (spaceTracker[i] !== 0) {
+ return i;
+ }
+ }
+
+ if (i === spaceTracker.length) {
+ return i;
+ }
+ }
+
+ function newSpaceTracker() {
+ var tracker = [];
+ for (var i = 0; i < colCount; i++) {
+ tracker.push(0);
+ }
+ return tracker;
+ }
+ }
+}
+
+/**
+ * @ngdoc directive
+ * @name mdGridTile
+ * @module material.components.gridList
+ * @restrict E
+ * @description
+ * Tiles contain the content of an `md-grid-list`. They span one or more grid
+ * cells vertically or horizontally, and use `md-grid-tile-{footer,header}` to
+ * display secondary content.
+ *
+ * ### Responsive Attributes
+ *
+ * The `md-grid-tile` directive supports "responsive" attributes, which allow
+ * different `md-rowspan` and `md-colspan` values depending on the currently
+ * matching media query.
+ *
+ * In order to set a responsive attribute, first define the fallback value with
+ * the standard attribute name, then add additional attributes with the
+ * following convention: `{base-attribute-name}-{media-query-name}="{value}"`
+ * (ie. `md-colspan-sm="4"`)
+ *
+ * @param {number=} md-colspan The number of columns to span (default 1). Cannot
+ * exceed the number of columns in the grid. Supports interpolation.
+ * @param {number=} md-rowspan The number of rows to span (default 1). Supports
+ * interpolation.
+ *
+ * @usage
+ * With header:
+ * <hljs lang="html">
+ * <md-grid-tile>
+ * <md-grid-tile-header>
+ * <h3>This is a header</h3>
+ * </md-grid-tile-header>
+ * </md-grid-tile>
+ * </hljs>
+ *
+ * With footer:
+ * <hljs lang="html">
+ * <md-grid-tile>
+ * <md-grid-tile-footer>
+ * <h3>This is a footer</h3>
+ * </md-grid-tile-footer>
+ * </md-grid-tile>
+ * </hljs>
+ *
+ * Spanning multiple rows/columns:
+ * <hljs lang="html">
+ * <md-grid-tile md-colspan="2" md-rowspan="3">
+ * </md-grid-tile>
+ * </hljs>
+ *
+ * Responsive attributes:
+ * <hljs lang="html">
+ * <md-grid-tile md-colspan="1" md-colspan-sm="3" md-colspan-md="5">
+ * </md-grid-tile>
+ * </hljs>
+ */
+function GridTileDirective($mdMedia) {
+ return {
+ restrict: 'E',
+ require: '^mdGridList',
+ template: '<figure ng-transclude></figure>',
+ transclude: true,
+ scope: {},
+ // Simple controller that exposes attributes to the grid directive
+ controller: ["$attrs", function($attrs) {
+ this.$attrs = $attrs;
+ }],
+ link: postLink
+ };
+
+ function postLink(scope, element, attrs, gridCtrl) {
+ // Apply semantics
+ element.attr('role', 'listitem');
+
+ // If our colspan or rowspan changes, trigger a layout
+ var unwatchAttrs = $mdMedia.watchResponsiveAttributes(['md-colspan', 'md-rowspan'],
+ attrs, angular.bind(gridCtrl, gridCtrl.invalidateLayout));
+
+ // Tile registration/deregistration
+ gridCtrl.invalidateTiles();
+ scope.$on('$destroy', function() {
+ // Mark the tile as destroyed so it is no longer considered in layout,
+ // even if the DOM element sticks around (like during a leave animation)
+ element[0].$$mdDestroyed = true;
+ unwatchAttrs();
+ gridCtrl.invalidateLayout();
+ });
+
+ if (angular.isDefined(scope.$parent.$index)) {
+ scope.$watch(function() { return scope.$parent.$index; },
+ function indexChanged(newIdx, oldIdx) {
+ if (newIdx === oldIdx) {
+ return;
+ }
+ gridCtrl.invalidateTiles();
+ });
+ }
+ }
+}
+
+
+function GridTileCaptionDirective() {
+ return {
+ template: '<figcaption ng-transclude></figcaption>',
+ transclude: true
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.icon
+ * @description
+ * Icon
+ */
+angular.module('material.components.icon', ['material.core']);
+
+})();
+(function(){
+"use strict";
+
+angular
+ .module('material.components.icon')
+ .directive('mdIcon', ['$mdIcon', '$mdTheming', '$mdAria', '$sce', mdIconDirective]);
+
+/**
+ * @ngdoc directive
+ * @name mdIcon
+ * @module material.components.icon
+ *
+ * @restrict E
+ *
+ * @description
+ * The `md-icon` directive makes it easier to use vector-based icons in your app (as opposed to
+ * raster-based icons types like PNG). The directive supports both icon fonts and SVG icons.
+ *
+ * Icons should be considered view-only elements that should not be used directly as buttons; instead nest a `<md-icon>`
+ * inside a `md-button` to add hover and click features.
+ *
+ * ### Icon fonts
+ * Icon fonts are a technique in which you use a font where the glyphs in the font are
+ * your icons instead of text. Benefits include a straightforward way to bundle everything into a
+ * single HTTP request, simple scaling, easy color changing, and more.
+ *
+ * `md-icon` lets you consume an icon font by letting you reference specific icons in that font
+ * by name rather than character code.
+ *
+ * When using font-icons, developers must follow three (3) simple steps:
+ *
+ * <ol>
+ * <li>Load the font library. e.g.<br/>
+ * `<link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">`
+ * </li>
+ * <li>
+ * Use either (a) font-icon class names or (b) a fontset and a font ligature to render the font glyph by
+ * using its textual name _or_ numerical character reference. Note that `material-icons` is the default fontset when
+ * none is specified.
+ * </li>
+ * <li> Use any of the following templates: <br/>
+ * <ul>
+ * <li>`<md-icon md-font-icon="classname"></md-icon>`</li>
+ * <li>`<md-icon md-font-set="font library classname or alias">textual_name</md-icon>`</li>
+ * <li>`<md-icon> numerical_character_reference </md-icon>`</li>
+ * <li>`<md-icon ng_bind="'textual_name'"></md-icon>`</li>
+ * <li>`<md-icon ng-bind="scopeVariable"></md-icon>`</li>
+ * </ul>
+ * </li>
+ * </ol>
+ *
+ * Full details for these steps can be found in the
+ * <a href="http://google.github.io/material-design-icons/#icon-font-for-the-web" target="_blank">
+ * Material Design Icon font for the web docs</a>.
+ *
+ * You can browse and search the Material Design icon style <code>.material-icons</code>
+ * in the <a href="https://material.io/tools/icons/" target="_blank">Material Design Icons tool</a>.
+ *
+ * ### SVG
+ * For SVGs, the problem with using `<img>` or a CSS `background-image` is that you can't take
+ * advantage of some SVG features, such as styling specific parts of the icon with CSS or SVG
+ * animation.
+ *
+ * `md-icon` makes it easier to use SVG icons by *inlining* the SVG into an `<svg>` element in the
+ * document. The most straightforward way of referencing an SVG icon is via URL, just like a
+ * traditional `<img>`. `$mdIconProvider`, as a convenience, lets you _name_ an icon so you can
+ * reference it by name instead of URL throughout your templates.
+ *
+ * Additionally, you may not want to make separate HTTP requests for every icon, so you can bundle
+ * your SVG icons together and pre-load them with `$mdIconProvider` as an icon set. An icon set can
+ * also be given a name, which acts as a namespace for individual icons, so you can reference them
+ * like `"social:cake"`.
+ *
+ * When using SVGs, both external SVGs (via URLs) or sets of SVGs (from icon sets) can be
+ * easily loaded and used.
+ *
+ * ### Localization
+ *
+ * Because an `md-icon` element's text content is not intended to be translated, it is recommended
+ * to declare the text content for an `md-icon` element in its start tag. Instead of using the HTML
+ * text content, consider using `ng-bind` with a scope variable or literal string.
+ *
+ * Examples:
+ *
+ * <ul>
+ * <li>`<md-icon ng-bind="myIconVariable"></md-icon>`</li>
+ * <li>`<md-icon ng-bind="'menu'"></md-icon>`
+ * </ul>
+ *
+ * <h2 id="material_design_icons">Material Design Icons tool</h2>
+ * Using the Material Design Icons tool, developers can easily and quickly search for a specific
+ * open source Material Design icon. The search is in the top left. Below search, you can select
+ * from the new icon themes or filter by icon category.
+ *
+ * <a href="https://material.io/tools/icons/" target="_blank" style="border-bottom:none;">
+ * <img src="https://user-images.githubusercontent.com/3506071/41942584-ef0695d0-796d-11e8-9436-44f25023a111.png"
+ * aria-label="Material Design Icons tool" style="max-width:95%">
+ * </a>
+ *
+ * <div class="md-caption" style="text-align: center; margin-bottom: 24px">
+ * Click on the image above to open the
+ * <a href="https://material.io/tools/icons/" target="_blank">Material Design Icons tool</a>.
+ * </div>
+ *
+ * Click on any icon, then click on the "Selected Icon" chevron to see the slide-up
+ * information panel with details regarding a SVG download and information on the font-icon's
+ * textual name. This panel also allows you to select a black on transparent or white on transparent
+ * icon and to change the icon size. These settings only affect the downloaded icons.
+ *
+ * @param {string} md-font-icon String name of CSS icon associated with the font-face will be used
+ * to render the icon. Requires the fonts and the named CSS styles to be preloaded.
+ * @param {string} md-font-set CSS style name associated with the font library; which will be assigned as
+ * the class for the font-icon ligature. This value may also be an alias that is used to lookup the classname;
+ * internally use `$mdIconProvider.fontSet(<alias>)` to determine the style name.
+ * @param {string} md-svg-src String URL (or expression) used to load, cache, and display an
+ * external SVG.
+ * @param {string} md-svg-icon md-svg-icon String name used for lookup of the icon from the internal cache;
+ * interpolated strings or expressions may also be used. Specific set names can be used with
+ * the syntax `<set name>:<icon name>`.<br/><br/>
+ * To use icon sets, developers are required to pre-register the sets using the `$mdIconProvider` service.
+ * @param {string=} aria-label Labels the icon for accessibility. If an empty string is provided,
+ * the icon will be hidden from the accessibility layer with `aria-hidden="true"`. If there is no
+ * `aria-label` attribute on the icon, we check the following, in order: the `alt` attribute, the
+ * `aria-label` from the parent element, the icon's `md-font-icon` or `md-svg-icon` string, and the
+ * text content inside `<md-icon></md-icon>`. If none of these have any text, the icon is hidden
+ * from the accessibility layer with `aria-hidden="true"`.
+ * @param {string=} alt Labels the icon for accessibility. If an empty string is provided and the
+ * icon has no `aria-label`, then the icon will be hidden from accessibility layer with
+ * `aria-hidden="true"`.
+ *
+ * @usage
+ * When using SVGs:
+ * <hljs lang="html">
+ *
+ *<!-- Icon ID; may contain optional icon set prefix.
+ * Icons must be registered using $mdIconProvider. -->
+ *<md-icon md-svg-icon="social:android" aria-label="android " ></md-icon>
+ *
+ *<!-- Icon urls; may be preloaded in templateCache -->
+ *<md-icon md-svg-src="/android.svg" aria-label="android " ></md-icon>
+ *<md-icon md-svg-src="{{ getAndroid() }}" aria-label="android " ></md-icon>
+ *
+ * </hljs>
+ *
+ * Use the <code>$mdIconProvider</code> to configure your application with
+ * SVG icon sets.
+ *
+ * <hljs lang="js">
+ * angular.module('appSvgIconSets', ['ngMaterial'])
+ * .controller('DemoCtrl', function($scope) {})
+ * .config(function($mdIconProvider) {
+ * $mdIconProvider
+ * .iconSet('social', 'img/icons/sets/social-icons.svg', 24)
+ * .defaultIconSet('img/icons/sets/core-icons.svg', 24);
+ * });
+ * </hljs>
+ *
+ *
+ * When using Font Icons with classnames:
+ * <hljs lang="html">
+ *
+ * <md-icon md-font-icon="android" aria-label="android" ></md-icon>
+ * <md-icon class="icon_home" aria-label="Home"></md-icon>
+ *
+ * </hljs>
+ *
+ * When using Material Font Icons with ligatures:
+ * <hljs lang="html">
+ * <!--
+ * For Material Design Icons
+ * The class '.material-icons' is auto-added if a style has NOT been specified
+ * since `material-icons` is the default fontset. So your markup:
+ * -->
+ * <md-icon> face </md-icon>
+ * <!-- becomes this at runtime: -->
+ * <md-icon md-font-set="material-icons"> face </md-icon>
+ * <!-- If the fontset does not support ligature names, then we need to use the ligature unicode.-->
+ * <md-icon>  </md-icon>
+ * <!-- The class '.material-icons' must be manually added if other styles are also specified-->
+ * <md-icon class="material-icons md-light md-48"> face </md-icon>
+ * </hljs>
+ *
+ * When using other Font-Icon libraries:
+ *
+ * <hljs lang="js">
+ * // Specify a font-icon style alias
+ * angular.config(function($mdIconProvider) {
+ * $mdIconProvider.fontSet('md', 'material-icons');
+ * });
+ * </hljs>
+ *
+ * <hljs lang="html">
+ * <md-icon md-font-set="md">favorite</md-icon>
+ * </hljs>
+ *
+ */
+function mdIconDirective($mdIcon, $mdTheming, $mdAria, $sce) {
+
+ return {
+ restrict: 'E',
+ link : postLink
+ };
+
+
+ /**
+ * Directive postLink
+ * Supports embedded SVGs, font-icons, & external SVGs.
+ * @param {IScope} scope
+ * @param {JQLite} element
+ * @param {IAttributes} attr
+ */
+ function postLink(scope, element, attr) {
+ $mdTheming(element);
+ var lastFontIcon = attr.mdFontIcon;
+ var lastFontSet = $mdIcon.fontSet(attr.mdFontSet);
+
+ prepareForFontIcon();
+
+ attr.$observe('mdFontIcon', fontIconChanged);
+ attr.$observe('mdFontSet', fontIconChanged);
+
+ /* Provide a default accessibility role of img */
+ if (!attr.role) {
+ $mdAria.expect(element, 'role', 'img');
+ /* manually update attr variable */
+ attr.role = 'img';
+ }
+
+ // If the aria-label is explicitly set to the empty string, then hide this element from the
+ // accessibility layer.
+ if (element[0].hasAttribute('aria-label') && attr.ariaLabel === '') {
+ element.attr('aria-hidden', true);
+ }
+
+ /* Don't process ARIA if already valid */
+ if (attr.role === "img" && !attr.ariaHidden && !$mdAria.hasAriaLabel(element)) {
+ // If the developer signals to hide this icon from the accessibility layer, do so.
+ if (element[0].hasAttribute('alt') && attr.alt === '') {
+ element.attr('aria-hidden', true);
+ } else if (attr.alt) {
+ /* Use the alt text for the aria-label by default, if available. */
+ $mdAria.expect(element, 'aria-label', attr.alt);
+ } else if ($mdAria.parentHasAriaLabel(element, 2)) {
+ /* Parent has ARIA so we will assume it will describe the icon. */
+ $mdAria.expect(element, 'aria-hidden', 'true');
+ } else if (attr.mdFontIcon || attr.mdSvgIcon || element.text()) {
+ /* Use icon name or node's text content as the aria-label */
+ $mdAria.expect(element, 'aria-label', attr.mdFontIcon || attr.mdSvgIcon || element.text());
+ } else {
+ /* No label found, hide this icon from the accessibility layer */
+ $mdAria.expect(element, 'aria-hidden', 'true');
+ }
+ }
+
+ var attrName = attr.$normalize(attr.$attr.mdSvgIcon || attr.$attr.mdSvgSrc || '');
+ if (attrName) {
+ // Use either pre-configured SVG or URL source, respectively.
+ attr.$observe(attrName, function(attrVal) {
+ element.empty();
+ if (attrVal) {
+ $mdIcon(attrVal)
+ .then(function(svg) {
+ element.empty();
+ element.append(svg);
+ });
+ }
+ });
+ }
+
+ function prepareForFontIcon() {
+ if (!attr.mdSvgIcon && !attr.mdSvgSrc) {
+ if (attr.mdFontIcon) {
+ element.addClass('md-font ' + attr.mdFontIcon);
+ }
+
+ element.addClass(lastFontSet);
+ }
+ }
+
+ function fontIconChanged() {
+ if (!attr.mdSvgIcon && !attr.mdSvgSrc) {
+ if (attr.mdFontIcon) {
+ element.removeClass(lastFontIcon);
+ element.addClass(attr.mdFontIcon);
+
+ lastFontIcon = attr.mdFontIcon;
+ }
+
+ var fontSet = $mdIcon.fontSet(attr.mdFontSet);
+
+ if (lastFontSet !== fontSet) {
+ element.removeClass(lastFontSet);
+ element.addClass(fontSet);
+
+ lastFontSet = fontSet;
+ }
+ }
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+
+MdIconService.$inject = ["config", "$templateRequest", "$q", "$log", "$mdUtil", "$sce"];angular
+ .module('material.components.icon')
+ .constant('$$mdSvgRegistry', {
+ 'mdTabsArrow': 'data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMjQgMjQiPjxnPjxwb2x5Z29uIHBvaW50cz0iMTUuNCw3LjQgMTQsNiA4LDEyIDE0LDE4IDE1LjQsMTYuNiAxMC44LDEyICIvPjwvZz48L3N2Zz4=',
+ 'mdClose': 'data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMjQgMjQiPjxnPjxwYXRoIGQ9Ik0xOSA2LjQxbC0xLjQxLTEuNDEtNS41OSA1LjU5LTUuNTktNS41OS0xLjQxIDEuNDEgNS41OSA1LjU5LTUuNTkgNS41OSAxLjQxIDEuNDEgNS41OS01LjU5IDUuNTkgNS41OSAxLjQxLTEuNDEtNS41OS01LjU5eiIvPjwvZz48L3N2Zz4=',
+ 'mdCancel': 'data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMjQgMjQiPjxnPjxwYXRoIGQ9Ik0xMiAyYy01LjUzIDAtMTAgNC40Ny0xMCAxMHM0LjQ3IDEwIDEwIDEwIDEwLTQuNDcgMTAtMTAtNC40Ny0xMC0xMC0xMHptNSAxMy41OWwtMS40MSAxLjQxLTMuNTktMy41OS0zLjU5IDMuNTktMS40MS0xLjQxIDMuNTktMy41OS0zLjU5LTMuNTkgMS40MS0xLjQxIDMuNTkgMy41OSAzLjU5LTMuNTkgMS40MSAxLjQxLTMuNTkgMy41OSAzLjU5IDMuNTl6Ii8+PC9nPjwvc3ZnPg==',
+ 'mdMenu': 'data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMjQgMjQiPjxwYXRoIGQ9Ik0zLDZIMjFWOEgzVjZNMywxMUgyMVYxM0gzVjExTTMsMTZIMjFWMThIM1YxNloiIC8+PC9zdmc+',
+ 'mdToggleArrow': 'data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgNDggNDgiPjxwYXRoIGQ9Ik0yNCAxNmwtMTIgMTIgMi44MyAyLjgzIDkuMTctOS4xNyA5LjE3IDkuMTcgMi44My0yLjgzeiIvPjxwYXRoIGQ9Ik0wIDBoNDh2NDhoLTQ4eiIgZmlsbD0ibm9uZSIvPjwvc3ZnPg==',
+ 'mdCalendar': 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0Ij48cGF0aCBkPSJNMTkgM2gtMVYxaC0ydjJIOFYxSDZ2Mkg1Yy0xLjExIDAtMS45OS45LTEuOTkgMkwzIDE5YzAgMS4xLjg5IDIgMiAyaDE0YzEuMSAwIDItLjkgMi0yVjVjMC0xLjEtLjktMi0yLTJ6bTAgMTZINVY4aDE0djExek03IDEwaDV2NUg3eiIvPjwvc3ZnPg==',
+ 'mdChecked': 'data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMjQgMjQiPjxnPjxwYXRoIGQ9Ik05IDE2LjE3TDQuODMgMTJsLTEuNDIgMS40MUw5IDE5IDIxIDdsLTEuNDEtMS40MXoiLz48L2c+PC9zdmc+'
+ })
+ .provider('$mdIcon', MdIconProvider);
+
+/**
+ * @ngdoc service
+ * @name $mdIconProvider
+ * @module material.components.icon
+ *
+ * @description
+ * `$mdIconProvider` is used only to register icon IDs with URLs. These configuration features allow
+ * icons and icon sets to be pre-registered and associated with source URLs **before** the
+ * `<md-icon />` directives are compiled.
+ *
+ * If using font-icons, the developer is responsible for loading the fonts.
+ *
+ * If using SVGs, loading of the actual svg files are deferred to on-demand requests and are loaded
+ * internally by the `$mdIcon` service using the `$templateRequest` service. When an SVG is
+ * requested by name/ID, the `$mdIcon` service searches its registry for the associated source URL;
+ * that URL is used to on-demand load and parse the SVG dynamically.
+ *
+ * The `$templateRequest` service expects the icons source to be loaded over trusted URLs.<br/>
+ * This means, when loading icons from an external URL, you have to trust the URL in the
+ * `$sceDelegateProvider`.
+ *
+ * <hljs lang="js">
+ * app.config(function($sceDelegateProvider) {
+ * $sceDelegateProvider.trustedResourceUrlList([
+ * // Adding 'self' to the allow-list, will allow requests from the current origin.
+ * 'self',
+ * // Using double asterisks here, will allow all URLs to load.
+ * // However, we recommend only specifying the given domain you want to allow.
+ * '**'
+ * ]);
+ * });
+ * </hljs>
+ *
+ * Read more about the [$sceDelegateProvider](https://docs.angularjs.org/api/ng/provider/$sceDelegateProvider).
+ *
+ * **Notice:** Most font-icon libraries do not support ligatures (for example `fontawesome`).<br/>
+ * In such cases you are not able to use the icon's ligature name - Like so:
+ *
+ * <hljs lang="html">
+ * <md-icon md-font-set="fa">fa-bell</md-icon>
+ * </hljs>
+ *
+ * You should instead use the given unicode, instead of the ligature name.
+ *
+ * <p ng-hide="true"> ##// Notice we can't use a hljs element here, because the characters will be escaped.</p>
+ * ```html
+ * <md-icon md-font-set="fa"></md-icon>
+ * ```
+ *
+ * All unicode ligatures are prefixed with the `&#x` string.
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.config(function($mdIconProvider) {
+ *
+ * // Configure URLs for icons specified by [set:]id.
+ * $mdIconProvider
+ * .defaultFontSet( 'fa' ) // This sets our default fontset className.
+ * .defaultIconSet('my/app/icons.svg') // Register a default set of SVG icons
+ * .iconSet('social', 'my/app/social.svg') // Register a named icon set of SVGs
+ * .icon('android', 'my/app/android.svg') // Register a specific icon (by name)
+ * .icon('work:chair', 'my/app/chair.svg'); // Register icon in a specific set
+ * });
+ * </hljs>
+ *
+ * SVG icons and icon sets can be easily pre-loaded and cached using either (a) a build process or
+ * (b) a runtime **startup** process (shown below):
+ *
+ * <hljs lang="js">
+ * app.config(function($mdIconProvider) {
+ *
+ * // Register a default set of SVG icon definitions
+ * $mdIconProvider.defaultIconSet('my/app/icons.svg')
+ * })
+ * .run(function($templateRequest) {
+ *
+ * // Pre-fetch icons sources by URL and cache in the $templateCache...
+ * // subsequent $templateRequest calls will look there first.
+ * var urls = [ 'imy/app/icons.svg', 'img/icons/android.svg'];
+ *
+ * angular.forEach(urls, function(url) {
+ * $templateRequest(url);
+ * });
+ * });
+ *
+ * </hljs>
+ *
+ * > <b>Note:</b> The loaded SVG data is subsequently cached internally for future requests.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdIconProvider#icon
+ *
+ * @description
+ * Register a source URL for a specific icon name; the name may include optional 'icon set' name
+ * prefix. These icons will later be retrieved from the cache using `$mdIcon(<icon name>)`.
+ *
+ * @param {string} id Icon name/id used to register the icon
+ * @param {string} url specifies the external location for the data file. Used internally by
+ * `$templateRequest` to load the data or as part of the lookup in `$templateCache` if pre-loading
+ * was configured.
+ * @param {number=} viewBoxSize Sets the width and height the icon's viewBox.
+ * It is ignored for icons with an existing viewBox. Default size is 24.
+ *
+ * @returns {obj} an `$mdIconProvider` reference; used to support method call chains for the API
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.config(function($mdIconProvider) {
+ *
+ * // Configure URLs for icons specified by [set:]id.
+ * $mdIconProvider
+ * .icon('android', 'my/app/android.svg') // Register a specific icon (by name)
+ * .icon('work:chair', 'my/app/chair.svg'); // Register icon in a specific set
+ * });
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdIconProvider#iconSet
+ *
+ * @description
+ * Register a source URL for a 'named' set of icons; group of SVG definitions where each definition
+ * has an icon id. Individual icons can be subsequently retrieved from this cached set using
+ * `$mdIcon(<icon set name>:<icon name>)`
+ *
+ * @param {string} id Icon name/id used to register the iconset
+ * @param {string} url specifies the external location for the data file. Used internally by
+ * `$templateRequest` to load the data or as part of the lookup in `$templateCache` if pre-loading
+ * was configured.
+ * @param {number=} viewBoxSize Sets the width and height of the viewBox of all icons in the set.
+ * It is ignored for icons with an existing viewBox. All icons in the icon set should be the same size.
+ * Default value is 24.
+ *
+ * @returns {obj} an `$mdIconProvider` reference; used to support method call chains for the API
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.config(function($mdIconProvider) {
+ *
+ * // Configure URLs for icons specified by [set:]id.
+ * $mdIconProvider
+ * .iconSet('social', 'my/app/social.svg'); // Register a named icon set
+ * });
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdIconProvider#defaultIconSet
+ *
+ * @description
+ * Register a source URL for the default 'named' set of icons. Unless explicitly registered,
+ * subsequent lookups of icons will fail over to search this 'default' icon set.
+ * Icon can be retrieved from this cached, default set using `$mdIcon(<name>)`
+ *
+ * @param {string} url specifies the external location for the data file. Used internally by
+ * `$templateRequest` to load the data or as part of the lookup in `$templateCache` if pre-loading
+ * was configured.
+ * @param {number=} viewBoxSize Sets the width and height of the viewBox of all icons in the set.
+ * It is ignored for icons with an existing viewBox. All icons in the icon set should be the same
+ * size. Default value is 24.
+ *
+ * @returns {Object} an `$mdIconProvider` reference; used to support method call chains for the API
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.config(function($mdIconProvider) {
+ *
+ * // Configure URLs for icons specified by [set:]id.
+ * $mdIconProvider
+ * .defaultIconSet('my/app/social.svg'); // Register a default icon set
+ * });
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdIconProvider#defaultFontSet
+ *
+ * @description
+ * When using Font-Icons, AngularJS Material assumes the the Material Design icons will be used and
+ * automatically configures the default `font-set == 'material-icons'`. Note that the font-set
+ * references the font-icon library class style that should be applied to the `<md-icon>`.
+ *
+ * Configuring the default means that the attributes
+ * `md-font-set="material-icons"` or `class="material-icons"` do not need to be explicitly declared
+ * on the `<md-icon>` markup.
+ *
+ * For example:<br/>
+ * `<md-icon>face</md-icon>` will render as `<span class="material-icons">face</span>`,<br/>
+ * and<br/>
+ * `<md-icon md-font-set="fa">face</md-icon>` will render as `<span class="fa">face</span>`
+ *
+ * @param {string} name Name of the font-library style that should be applied to the md-icon DOM
+ * element.
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.config(function($mdIconProvider) {
+ * $mdIconProvider.defaultFontSet('fa');
+ * });
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdIconProvider#fontSet
+ *
+ * @description
+ * When using a font-set for `<md-icon>` you must specify the correct font classname in the
+ * `md-font-set` attribute. If the font-set className is really long, your markup may become
+ * cluttered... an easy solution is to define an `alias` for your font-set:
+ *
+ * @param {string} alias Alias name of the specified font-set.
+ * @param {string} className Name of the class for the font-set.
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.config(function($mdIconProvider) {
+ * // In this case, we set an alias for the `material-icons` font-set.
+ * $mdIconProvider.fontSet('md', 'material-icons');
+ * });
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdIconProvider#defaultViewBoxSize
+ *
+ * @description
+ * While `<md-icon>` markup can also be styled with sizing CSS, this method configures
+ * the default width **and** height used for all icons; unless overridden by specific CSS.
+ * The default sizing is (`24px`, `24px`).
+ * @param {number=} viewBoxSize Sets the width and height of the viewBox for an icon or an icon set.
+ * All icons in a set should be the same size. The default value is 24.
+ *
+ * @returns {Object} an `$mdIconProvider` reference; used to support method call chains for the API
+ *
+ * @usage
+ * <hljs lang="js">
+ * app.config(function($mdIconProvider) {
+ *
+ * // Configure URLs for icons specified by [set:]id.
+ * $mdIconProvider
+ * .defaultViewBoxSize(36); // Register a default icon size (width == height)
+ * });
+ * </hljs>
+ */
+
+var config = {
+ defaultViewBoxSize: 24,
+ defaultFontSet: 'material-icons',
+ fontSets: []
+};
+
+function MdIconProvider() {
+}
+
+MdIconProvider.prototype = {
+ icon: function(id, url, viewBoxSize) {
+ if (id.indexOf(':') == -1) id = '$default:' + id;
+
+ config[id] = new ConfigurationItem(url, viewBoxSize);
+ return this;
+ },
+
+ iconSet: function(id, url, viewBoxSize) {
+ config[id] = new ConfigurationItem(url, viewBoxSize);
+ return this;
+ },
+
+ defaultIconSet: function(url, viewBoxSize) {
+ var setName = '$default';
+
+ if (!config[setName]) {
+ config[setName] = new ConfigurationItem(url, viewBoxSize);
+ }
+
+ config[setName].viewBoxSize = viewBoxSize || config.defaultViewBoxSize;
+
+ return this;
+ },
+
+ defaultViewBoxSize: function(viewBoxSize) {
+ config.defaultViewBoxSize = viewBoxSize;
+ return this;
+ },
+
+ /**
+ * Register an alias name associated with a font-icon library style ;
+ */
+ fontSet: function fontSet(alias, className) {
+ config.fontSets.push({
+ alias: alias,
+ fontSet: className || alias
+ });
+ return this;
+ },
+
+ /**
+ * Specify a default style name associated with a font-icon library
+ * fallback to Material Icons.
+ *
+ */
+ defaultFontSet: function defaultFontSet(className) {
+ config.defaultFontSet = !className ? '' : className;
+ return this;
+ },
+
+ defaultIconSize: function defaultIconSize(iconSize) {
+ config.defaultIconSize = iconSize;
+ return this;
+ },
+
+ $get: ['$templateRequest', '$q', '$log', '$mdUtil', '$sce', function($templateRequest, $q, $log, $mdUtil, $sce) {
+ return MdIconService(config, $templateRequest, $q, $log, $mdUtil, $sce);
+ }]
+};
+
+ /**
+ * Configuration item stored in the Icon registry; used for lookups
+ * to load if not already cached in the `loaded` cache
+ * @param {string} url
+ * @param {=number} viewBoxSize
+ * @constructor
+ */
+ function ConfigurationItem(url, viewBoxSize) {
+ this.url = url;
+ this.viewBoxSize = viewBoxSize || config.defaultViewBoxSize;
+ }
+
+/**
+ * @ngdoc service
+ * @name $mdIcon
+ * @module material.components.icon
+ *
+ * @description
+ * The `$mdIcon` service is a function used to lookup SVG icons.
+ *
+ * @param {string} id Query value for a unique Id or URL. If the argument is a URL, then the service will retrieve the icon element
+ * from its internal cache or load the icon and cache it first. If the value is not a URL-type string, then an ID lookup is
+ * performed. The Id may be a unique icon ID or may include an iconSet ID prefix.
+ *
+ * For the **id** query to work properly, this means that all id-to-URL mappings must have been previously configured
+ * using the `$mdIconProvider`.
+ *
+ * @returns {angular.$q.Promise} A promise that gets resolved to a clone of the initial SVG DOM element; which was
+ * created from the SVG markup in the SVG data file. If an error occurs (e.g. the icon cannot be found) the promise
+ * will get rejected.
+ *
+ * @usage
+ * <hljs lang="js">
+ * function SomeDirective($mdIcon) {
+ *
+ * // See if the icon has already been loaded, if not then lookup the icon from the
+ * // registry cache, load and cache it for future requests.
+ * // NOTE: Non-URL queries require configuration with $mdIconProvider.
+ * $mdIcon('android').then(function(iconEl) { element.append(iconEl); });
+ * $mdIcon('work:chair').then(function(iconEl) { element.append(iconEl); });
+ *
+ * // Load and cache the external SVG using a URL.
+ * $mdIcon('img/icons/android.svg').then(function(iconEl) {
+ * element.append(iconEl);
+ * });
+ * };
+ * </hljs>
+ *
+ * > <b>Note:</b> The `<md-icon>` directive internally uses the `$mdIcon` service to query, load,
+ * and instantiate SVG DOM elements.
+ */
+
+/* @ngInject */
+function MdIconService(config, $templateRequest, $q, $log, $mdUtil, $sce) {
+ var iconCache = {};
+ var svgCache = {};
+ var urlRegex = /[-\w@:%+.~#?&//=]{2,}\.[a-z]{2,4}\b(\/[-\w@:%+.~#?&//=]*)?/i;
+ var dataUrlRegex = /^data:image\/svg\+xml[\s*;\w\-=]*?(base64)?,(.*)$/i;
+
+ Icon.prototype = {clone: cloneSVG, prepare: prepareAndStyle};
+ getIcon.fontSet = findRegisteredFontSet;
+
+ // Publish service...
+ return getIcon;
+
+ /**
+ * Actual $mdIcon service is essentially a lookup function
+ * @param {*} id $sce trust wrapper over a URL string, URL, icon registry id, or icon set id
+ * @returns {angular.$q.Promise}
+ */
+ function getIcon(id) {
+ id = id || '';
+
+ // If the "id" provided is not a string, the only other valid value is a $sce trust wrapper
+ // over a URL string. If the value is not trusted, this will intentionally throw an error
+ // because the user is attempted to use an unsafe URL, potentially opening themselves up
+ // to an XSS attack.
+ if (!angular.isString(id)) {
+ id = $sce.getTrustedUrl(id);
+ }
+
+ // If already loaded and cached, use a clone of the cached icon.
+ // Otherwise either load by URL, or lookup in the registry and then load by URL, and cache.
+
+ if (iconCache[id]) {
+ return $q.when(transformClone(iconCache[id]));
+ }
+
+ if (urlRegex.test(id) || dataUrlRegex.test(id)) {
+ return loadByURL(id).then(cacheIcon(id));
+ }
+
+ if (id.indexOf(':') === -1) {
+ id = '$default:' + id;
+ }
+
+ var load = config[id] ? loadByID : loadFromIconSet;
+ return load(id)
+ .then(cacheIcon(id));
+ }
+
+ /**
+ * Lookup a registered fontSet style using its alias.
+ * @param {string} alias used to lookup the alias in the array of fontSets
+ * @returns {*} matching fontSet or the defaultFontSet if that alias does not match
+ */
+ function findRegisteredFontSet(alias) {
+ var useDefault = angular.isUndefined(alias) || !(alias && alias.length);
+ if (useDefault) {
+ return config.defaultFontSet;
+ }
+
+ var result = alias;
+ angular.forEach(config.fontSets, function(fontSet) {
+ if (fontSet.alias === alias) {
+ result = fontSet.fontSet || result;
+ }
+ });
+
+ return result;
+ }
+
+ /**
+ * @param {!Icon} cacheElement cached icon from the iconCache
+ * @returns {Icon} cloned Icon element with unique ids
+ */
+ function transformClone(cacheElement) {
+ var clone = cacheElement.clone();
+ var newUid = $mdUtil.nextUid();
+ var cacheSuffix, svgUrlQuerySelector, i, xlinkHrefValue;
+ // These are SVG attributes that can reference element ids.
+ var svgUrlAttributes = [
+ 'clip-path', 'color-profile', 'cursor', 'fill', 'filter', 'href', 'marker-start',
+ 'marker-mid', 'marker-end', 'mask', 'stroke', 'style', 'vector-effect'
+ ];
+ var isIeSvg = clone.innerHTML === undefined;
+
+ // Verify that the newUid only contains a number and not some XSS content.
+ if (!isFinite(Number(newUid))) {
+ throw new Error('Unsafe and unexpected non-number result from $mdUtil.nextUid().');
+ }
+ cacheSuffix = '_cache' + newUid;
+
+ // For each cached icon, we need to modify the id attributes and references.
+ // This is needed because SVG ids are treated as normal DOM ids and should not be duplicated on
+ // the page.
+ if (clone.id) {
+ clone.id += cacheSuffix;
+ }
+
+ // Do as much as possible with querySelectorAll as it provides much greater performance
+ // than RegEx against serialized DOM.
+ angular.forEach(clone.querySelectorAll('[id]'), function(descendantElem) {
+ svgUrlQuerySelector = '';
+ for (i = 0; i < svgUrlAttributes.length; i++) {
+ svgUrlQuerySelector += '[' + svgUrlAttributes[i] + '="url(#' + descendantElem.id + ')"]';
+ if (i + 1 < svgUrlAttributes.length) {
+ svgUrlQuerySelector += ', ';
+ }
+ }
+ // Append the cacheSuffix to references of the element's id within url(#id) calls.
+ angular.forEach(clone.querySelectorAll(svgUrlQuerySelector), function(refItem) {
+ updateSvgIdReferences(descendantElem, refItem, isIeSvg, newUid);
+ });
+ // Handle usages of url(#id) in the SVG's stylesheets
+ angular.forEach(clone.querySelectorAll('style'), function(refItem) {
+ updateSvgIdReferences(descendantElem, refItem, isIeSvg, newUid);
+ });
+
+ // Update ids referenced by the deprecated (in SVG v2) xlink:href XML attribute. The now
+ // preferred href attribute is handled above. However, this non-standard XML namespaced
+ // attribute cannot be handled in the same way. Explanation of this query selector here:
+ // https://stackoverflow.com/q/23034283/633107.
+ angular.forEach(clone.querySelectorAll('[*|href]:not([href])'), function(refItem) {
+ xlinkHrefValue = refItem.getAttribute('xlink:href');
+ if (xlinkHrefValue) {
+ xlinkHrefValue = xlinkHrefValue.replace("#" + descendantElem.id, "#" + descendantElem.id + cacheSuffix);
+ refItem.setAttribute('xlink:href', xlinkHrefValue);
+ }
+ });
+
+ descendantElem.id += cacheSuffix;
+ });
+
+ return clone;
+ }
+
+ /**
+ * @param {Element} referencedElement element w/ id that needs to be updated
+ * @param {Element} referencingElement element that references the original id
+ * @param {boolean} isIeSvg true if we're dealing with an SVG in IE11, false otherwise
+ * @param {string} newUid the cache id to add as part of the cache suffix
+ */
+ function updateSvgIdReferences(referencedElement, referencingElement, isIeSvg, newUid) {
+ var svgElement, cacheSuffix;
+
+ // Verify that the newUid only contains a number and not some XSS content.
+ if (!isFinite(Number(newUid))) {
+ throw new Error('Unsafe and unexpected non-number result for newUid.');
+ }
+ cacheSuffix = '_cache' + newUid;
+
+ // outerHTML of SVG elements is not supported by IE11
+ if (isIeSvg) {
+ svgElement = $mdUtil.getOuterHTML(referencingElement);
+ svgElement = svgElement.replace("url(#" + referencedElement.id + ")",
+ "url(#" + referencedElement.id + cacheSuffix + ")");
+ referencingElement.textContent = angular.element(svgElement)[0].innerHTML;
+ } else {
+ // This use of outerHTML should be safe from XSS attack since we are only injecting the
+ // cacheSuffix with content from $mdUtil.nextUid which we verify is a finite number above.
+ referencingElement.outerHTML = referencingElement.outerHTML.replace(
+ "url(#" + referencedElement.id + ")",
+ "url(#" + referencedElement.id + cacheSuffix + ")");
+ }
+ }
+
+ /**
+ * Prepare and cache the loaded icon for the specified `id`.
+ * @param {string} id icon cache id
+ * @returns {function(*=): *}
+ */
+ function cacheIcon(id) {
+
+ return function updateCache(icon) {
+ iconCache[id] = isIcon(icon) ? icon : new Icon(icon, config[id]);
+
+ return transformClone(iconCache[id]);
+ };
+ }
+
+ /**
+ * Lookup the configuration in the registry, if !registered throw an error
+ * otherwise load the icon [on-demand] using the registered URL.
+ * @param {string} id icon registry id
+ * @returns {angular.$q.Promise}
+ */
+ function loadByID(id) {
+ var iconConfig = config[id];
+ return loadByURL(iconConfig.url).then(function(icon) {
+ return new Icon(icon, iconConfig);
+ });
+ }
+
+ /**
+ * Loads the file as XML and uses querySelector( <id> ) to find the desired node...
+ * @param {string} id icon id in icon set
+ * @returns {angular.$q.Promise}
+ */
+ function loadFromIconSet(id) {
+ var setName = id.substring(0, id.lastIndexOf(':')) || '$default';
+ var iconSetConfig = config[setName];
+
+ return !iconSetConfig ? announceIdNotFound(id) : loadByURL(iconSetConfig.url).then(extractFromSet);
+
+ function extractFromSet(set) {
+ var iconName = id.slice(id.lastIndexOf(':') + 1);
+ var icon = set.querySelector('#' + iconName);
+ return icon ? new Icon(icon, iconSetConfig) : announceIdNotFound(id);
+ }
+
+ function announceIdNotFound(id) {
+ var msg = 'icon ' + id + ' not found';
+ $log.warn(msg);
+
+ return $q.reject(msg || id);
+ }
+ }
+
+ /**
+ * Load the icon by URL (may use the $templateCache).
+ * Extract the data for later conversion to Icon
+ * @param {string} url icon URL
+ * @returns {angular.$q.Promise}
+ */
+ function loadByURL(url) {
+ /* Load the icon from embedded data URL. */
+ function loadByDataUrl(url) {
+ var results = dataUrlRegex.exec(url);
+ var isBase64 = /base64/i.test(url);
+ var data = isBase64 ? window.atob(results[2]) : results[2];
+
+ return $q.when(angular.element(data)[0]);
+ }
+
+ /* Load the icon by URL using HTTP. */
+ function loadByHttpUrl(url) {
+ return $q(function(resolve, reject) {
+ // Catch HTTP or generic errors not related to incorrect icon IDs.
+ var announceAndReject = function(err) {
+ var msg = angular.isString(err) ? err : (err.message || err.data || err.statusText);
+ $log.warn(msg);
+ reject(err);
+ },
+ extractSvg = function(response) {
+ if (!svgCache[url]) {
+ svgCache[url] = angular.element('<div>').append(response)[0].querySelector('svg');
+ }
+ resolve(svgCache[url]);
+ };
+
+ $templateRequest(url, true).then(extractSvg, announceAndReject);
+ });
+ }
+
+ return dataUrlRegex.test(url)
+ ? loadByDataUrl(url)
+ : loadByHttpUrl(url);
+ }
+
+ /**
+ * Check target signature to see if it is an Icon instance.
+ * @param {Icon|Element} target
+ * @returns {boolean} true if the specified target is an Icon object, false otherwise.
+ */
+ function isIcon(target) {
+ return angular.isDefined(target.element) && angular.isDefined(target.config);
+ }
+
+ /**
+ * Define the Icon class
+ * @param {Element} el
+ * @param {=ConfigurationItem} config
+ * @constructor
+ */
+ function Icon(el, config) {
+ // If the node is a <symbol>, it won't be rendered so we have to convert it into <svg>.
+ if (el && el.tagName.toLowerCase() === 'symbol') {
+ var viewbox = el.getAttribute('viewBox');
+ // // Check if innerHTML is supported as IE11 does not support innerHTML on SVG elements.
+ if (el.innerHTML) {
+ el = angular.element('<svg xmlns="http://www.w3.org/2000/svg">')
+ .html(el.innerHTML)[0];
+ } else {
+ el = angular.element('<svg xmlns="http://www.w3.org/2000/svg">')
+ .append($mdUtil.getInnerHTML(el))[0];
+ }
+ if (viewbox) el.setAttribute('viewBox', viewbox);
+ }
+
+ if (el && el.tagName.toLowerCase() !== 'svg') {
+ el = angular.element(
+ '<svg xmlns="http://www.w3.org/2000/svg">').append(el.cloneNode(true))[0];
+ }
+
+ // Inject the namespace if not available...
+ if (!el.getAttribute('xmlns')) {
+ el.setAttribute('xmlns', "http://www.w3.org/2000/svg");
+ }
+
+ this.element = el;
+ this.config = config;
+ this.prepare();
+ }
+
+ /**
+ * Prepare the DOM element that will be cached in the
+ * loaded iconCache store.
+ */
+ function prepareAndStyle() {
+ var viewBoxSize = this.config ? this.config.viewBoxSize : config.defaultViewBoxSize;
+ angular.forEach({
+ 'fit': '',
+ 'height': '100%',
+ 'width': '100%',
+ 'preserveAspectRatio': 'xMidYMid meet',
+ 'viewBox': this.element.getAttribute('viewBox') || ('0 0 ' + viewBoxSize + ' ' + viewBoxSize),
+ 'focusable': false // Disable IE11s default behavior to make SVGs focusable
+ }, function(val, attr) {
+ this.element.setAttribute(attr, val);
+ }, this);
+ }
+
+ /**
+ * Clone the Icon DOM element.
+ */
+ function cloneSVG() {
+ // If the element or any of its children have a style attribute, then a CSP policy without
+ // 'unsafe-inline' in the style-src directive, will result in a violation.
+ return this.element.cloneNode(true);
+ }
+
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.input
+ */
+mdInputContainerDirective.$inject = ["$mdTheming", "$parse", "$$rAF"];
+inputTextareaDirective.$inject = ["$mdUtil", "$window", "$mdAria", "$timeout", "$mdGesture"];
+mdMaxlengthDirective.$inject = ["$animate", "$mdUtil"];
+placeholderDirective.$inject = ["$compile"];
+ngMessageDirective.$inject = ["$mdUtil"];
+mdSelectOnFocusDirective.$inject = ["$document", "$timeout"];
+mdInputInvalidMessagesAnimation.$inject = ["$$AnimateRunner", "$animateCss", "$mdUtil"];
+ngMessagesAnimation.$inject = ["$$AnimateRunner", "$animateCss", "$mdUtil"];
+ngMessageAnimation.$inject = ["$$AnimateRunner", "$animateCss", "$mdUtil", "$log"];
+var inputModule = angular.module('material.components.input', [
+ 'material.core'
+ ])
+ .directive('mdInputContainer', mdInputContainerDirective)
+ .directive('label', labelDirective)
+ .directive('input', inputTextareaDirective)
+ .directive('textarea', inputTextareaDirective)
+ .directive('mdMaxlength', mdMaxlengthDirective)
+ .directive('placeholder', placeholderDirective)
+ .directive('ngMessages', ngMessagesDirective)
+ .directive('ngMessage', ngMessageDirective)
+ .directive('ngMessageExp', ngMessageDirective)
+ .directive('mdSelectOnFocus', mdSelectOnFocusDirective)
+
+ .animation('.md-input-invalid', mdInputInvalidMessagesAnimation)
+ .animation('.md-input-messages-animation', ngMessagesAnimation)
+ .animation('.md-input-message-animation', ngMessageAnimation);
+
+// If we are running inside of tests; expose some extra services so that we can test them
+if (window._mdMocksIncluded) {
+ inputModule.service('$$mdInput', function() {
+ return {
+ // special accessor to internals... useful for testing
+ messages: {
+ getElement : getMessagesElement
+ }
+ };
+ })
+
+ // Register a service for each animation so that we can easily inject them into unit tests
+ .service('mdInputInvalidAnimation', mdInputInvalidMessagesAnimation)
+ .service('mdInputMessagesAnimation', ngMessagesAnimation)
+ .service('mdInputMessageAnimation', ngMessageAnimation);
+}
+
+/**
+ * @ngdoc directive
+ * @name mdInputContainer
+ * @module material.components.input
+ *
+ * @restrict E
+ *
+ * @description
+ * `<md-input-container>` is the parent of any input or textarea element. It can also optionally
+ * wrap `<md-select>` elements so that they will be formatted for use in a form.
+ *
+ * Input and textarea elements will not behave properly unless the md-input-container parent is
+ * provided.
+ *
+ * A single `<md-input-container>` should contain only one `<input>` or `<md-select>` element,
+ * otherwise it will throw an error.
+ *
+ * <b>Exception:</b> Hidden inputs (`<input type="hidden" />`) are ignored and will not throw an
+ * error, so you may combine these with other inputs.
+ *
+ * <b>Note:</b> When using `ngMessages` with your input element, make sure the message and container
+ * elements are *block* elements, otherwise animations applied to the messages will not look as
+ * intended. Either use a `div` and apply the `ng-message` and `ng-messages` classes respectively,
+ * or use the `md-block` class on your element.
+ *
+ * @param {expression=} md-is-error When the given expression evaluates to `true`, the input
+ * container will go into the error state. Defaults to erroring if the input has been touched and
+ * is invalid.
+ * @param {boolean=} md-no-float When present, `placeholder` attributes on the input will not be
+ * converted to floating labels.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-input-container>
+ * <label>Username</label>
+ * <input type="text" ng-model="user.name">
+ * </md-input-container>
+ *
+ * <md-input-container>
+ * <label>Description</label>
+ * <textarea ng-model="user.description"></textarea>
+ * </md-input-container>
+ *
+ * <md-input-container>
+ * <md-select ng-model="user.state" placeholder="State of Residence">
+ * <md-option ng-value="state" ng-repeat="state in states">{{ state }}</md-option>
+ * </md-select>
+ * </md-input-container>
+ * </hljs>
+ *
+ * <h3>When disabling floating labels</h3>
+ * <hljs lang="html">
+ * <md-input-container md-no-float>
+ * <input type="text" placeholder="Non-Floating Label">
+ * </md-input-container>
+ * </hljs>
+ *
+ * <h3>Aligning Form Elements</h3>
+ * Wrap your form elements with the `md-inline-form` class in order to align them horizontally
+ * within a form.
+ *
+ * <hljs lang="html">
+ * <form class="md-inline-form">
+ * <md-input-container>
+ * <label>Username</label>
+ * <input type="text" ng-model="user.name">
+ * </md-input-container>
+ *
+ * <md-input-container>
+ * <label>Description</label>
+ * <textarea ng-model="user.description"></textarea>
+ * </md-input-container>
+ *
+ * <md-input-container>
+ * <label>State of Residence</label>
+ * <md-select ng-model="user.state">
+ * <md-option ng-value="state" ng-repeat="state in states">{{ state }}</md-option>
+ * </md-select>
+ * </md-input-container>
+ *
+ * <md-input-container>
+ * <label>Enter date</label>
+ * <md-datepicker ng-model="user.submissionDate"></md-datepicker>
+ * </md-input-container>
+ *
+ * <md-input-container>
+ * <md-checkbox ng-model="user.licenseAccepted">
+ * I agree to the license terms.
+ * </md-checkbox>
+ * </md-input-container>
+ * </form>
+ * </hljs>
+ */
+function mdInputContainerDirective($mdTheming, $parse, $$rAF) {
+
+ ContainerCtrl.$inject = ["$scope", "$element", "$attrs", "$animate"];
+ var INPUT_TAGS = ['INPUT', 'TEXTAREA', 'SELECT', 'MD-SELECT'];
+
+ var LEFT_SELECTORS = INPUT_TAGS.reduce(function(selectors, isel) {
+ return selectors.concat(['md-icon ~ ' + isel, '.md-icon ~ ' + isel]);
+ }, []).join(",");
+
+ var RIGHT_SELECTORS = INPUT_TAGS.reduce(function(selectors, isel) {
+ return selectors.concat([isel + ' ~ md-icon', isel + ' ~ .md-icon']);
+ }, []).join(",");
+
+ return {
+ restrict: 'E',
+ compile: compile,
+ controller: ContainerCtrl
+ };
+
+ function compile(tElement) {
+ // Check for both a left & right icon
+ var hasLeftIcon = tElement[0].querySelector(LEFT_SELECTORS);
+ var hasRightIcon = tElement[0].querySelector(RIGHT_SELECTORS);
+
+ return function postLink(scope, element) {
+ $mdTheming(element);
+
+ if (hasLeftIcon || hasRightIcon) {
+ // When accessing the element's contents synchronously, they may not be defined yet because
+ // of the use of ng-if. If we wait one frame, then the element should be there if the ng-if
+ // resolves to true.
+ $$rAF(function() {
+ // Handle the case where the md-icon element is initially hidden via ng-if from #9529.
+ // We don't want to preserve the space for the icon in the case of ng-if, like we do for
+ // ng-show.
+ // Note that we can't use the same selectors from above because the elements are no longer
+ // siblings for textareas at this point due to the insertion of the md-resize-wrapper.
+ var iconNotRemoved = element[0].querySelector('md-icon') ||
+ element[0].querySelector('.md-icon');
+ if (hasLeftIcon && iconNotRemoved) {
+ element.addClass('md-icon-left');
+ }
+ if (hasRightIcon && iconNotRemoved) {
+ element.addClass('md-icon-right');
+ }
+ });
+ }
+ };
+ }
+
+ function ContainerCtrl($scope, $element, $attrs, $animate) {
+ var self = this;
+
+ $element.addClass('md-auto-horizontal-margin');
+
+ self.isErrorGetter = $attrs.mdIsError && $parse($attrs.mdIsError);
+
+ self.delegateClick = function() {
+ self.input.focus();
+ };
+ self.element = $element;
+ self.setFocused = function(isFocused) {
+ $element.toggleClass('md-input-focused', !!isFocused);
+ };
+ self.setHasValue = function(hasValue) {
+ $element.toggleClass('md-input-has-value', !!hasValue);
+ };
+ self.setHasPlaceholder = function(hasPlaceholder) {
+ $element.toggleClass('md-input-has-placeholder', !!hasPlaceholder);
+ };
+ self.setInvalid = function(isInvalid) {
+ if (isInvalid) {
+ $animate.addClass($element, 'md-input-invalid');
+ } else {
+ $animate.removeClass($element, 'md-input-invalid');
+ }
+ };
+ $scope.$watch(function() {
+ return self.label && self.input;
+ }, function(hasLabelAndInput) {
+ if (hasLabelAndInput && !self.label.attr('for')) {
+ self.label.attr('for', self.input.attr('id'));
+ }
+ });
+ }
+}
+
+function labelDirective() {
+ return {
+ restrict: 'E',
+ require: '^?mdInputContainer',
+ link: function(scope, element, attr, containerCtrl) {
+ if (!containerCtrl || attr.mdNoFloat || element.hasClass('md-container-ignore')) return;
+
+ containerCtrl.label = element;
+ scope.$on('$destroy', function() {
+ containerCtrl.label = null;
+ });
+ }
+ };
+}
+
+/**
+ * @ngdoc directive
+ * @name mdInput
+ * @restrict E
+ * @module material.components.input
+ *
+ * @description
+ * You can use any `<input>` or `<textarea>` element as a child of an `<md-input-container>`. This
+ * allows you to build complex forms for data entry.
+ *
+ * When the input is required and uses a floating label, then the label will automatically contain
+ * an asterisk (`*`).<br/>
+ * This behavior can be disabled by using the `md-no-asterisk` attribute.
+ *
+ * @param {number=} md-maxlength The maximum number of characters allowed in this input. If this is
+ * specified, a character counter will be shown underneath the input.<br/><br/>
+ * The purpose of **`md-maxlength`** is exactly to show the max length counter text. If you don't
+ * want the counter text and only need "plain" validation, you can use the "simple" `ng-maxlength`
+ * or maxlength attributes.<br/><br/>
+ * @param {boolean=} ng-trim If set to false, the input text will be not trimmed automatically.
+ * Defaults to true.
+ * @param {string=} aria-label Aria-label is required when no label is present. A warning message
+ * will be logged in the console if not present.
+ * @param {string=} placeholder An alternative approach to using aria-label when the label is not
+ * PRESENT. The placeholder text is copied to the aria-label attribute.
+ * @param {boolean=} md-no-autogrow When present, textareas will not grow automatically.
+ * @param {boolean=} md-no-asterisk When present, an asterisk will not be appended to the inputs
+ * floating label.
+ * @param {boolean=} md-no-resize Disables the textarea resize handle.
+ * @param {number=} max-rows The maximum amount of rows for a textarea.
+ * @param {boolean=} md-detect-hidden When present, textareas will be sized properly when they are
+ * revealed after being hidden. This is off by default for performance reasons because it
+ * guarantees a reflow every digest cycle.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-input-container>
+ * <label>Color</label>
+ * <input type="text" ng-model="color" required md-maxlength="10">
+ * </md-input-container>
+ * </hljs>
+ *
+ * <h3>With Errors</h3>
+ *
+ * `md-input-container` also supports errors using the standard `ng-messages` directives and
+ * animates the messages when they become visible using from the `ngEnter`/`ngLeave` events or
+ * the `ngShow`/`ngHide` events.
+ *
+ * By default, the messages will be hidden until the input is in an error state. This is based off
+ * of the `md-is-error` expression of the `md-input-container`. This gives the user a chance to
+ * fill out the form before the errors become visible.
+ *
+ * <hljs lang="html">
+ * <form name="colorForm">
+ * <md-input-container>
+ * <label>Favorite Color</label>
+ * <input name="favoriteColor" ng-model="favoriteColor" required>
+ * <div ng-messages="colorForm.favoriteColor.$error">
+ * <div ng-message="required">This is required!</div>
+ * </div>
+ * </md-input-container>
+ * </form>
+ * </hljs>
+ *
+ * We automatically disable this auto-hiding functionality if you provide any of the following
+ * visibility directives on the `ng-messages` container:
+ *
+ * - `ng-if`
+ * - `ng-show`/`ng-hide`
+ * - `ng-switch-when`/`ng-switch-default`
+ *
+ * You can also disable this functionality manually by adding the `md-auto-hide="false"` expression
+ * to the `ng-messages` container. This may be helpful if you always want to see the error messages
+ * or if you are building your own visibility directive.
+ *
+ * _<b>Note:</b> The `md-auto-hide` attribute is a static string that is only checked upon
+ * initialization of the `ng-messages` directive to see if it equals the string `false`._
+ *
+ * <hljs lang="html">
+ * <form name="userForm">
+ * <md-input-container>
+ * <label>Last Name</label>
+ * <input name="lastName" ng-model="lastName" required md-maxlength="10" minlength="4">
+ * <div ng-messages="userForm.lastName.$error" ng-show="userForm.lastName.$dirty">
+ * <div ng-message="required">This is required!</div>
+ * <div ng-message="md-maxlength">That's too long!</div>
+ * <div ng-message="minlength">That's too short!</div>
+ * </div>
+ * </md-input-container>
+ * <md-input-container>
+ * <label>Biography</label>
+ * <textarea name="bio" ng-model="biography" required md-maxlength="150"></textarea>
+ * <div ng-messages="userForm.bio.$error" ng-show="userForm.bio.$dirty">
+ * <div ng-message="required">This is required!</div>
+ * <div ng-message="md-maxlength">That's too long!</div>
+ * </div>
+ * </md-input-container>
+ * <md-input-container>
+ * <input aria-label='title' ng-model='title'>
+ * </md-input-container>
+ * <md-input-container>
+ * <input placeholder='title' ng-model='title'>
+ * </md-input-container>
+ * </form>
+ * </hljs>
+ *
+ * <h3>Notes</h3>
+ *
+ * - Requires [ngMessages](https://docs.angularjs.org/api/ngMessages).
+ * - Behaves like the [AngularJS input directive](https://docs.angularjs.org/api/ng/directive/input).
+ *
+ * The `md-input` and `md-input-container` directives use very specific positioning to achieve the
+ * error animation effects. Therefore, it is *not* advised to use the Layout system inside of the
+ * `<md-input-container>` tags. Instead, use relative or absolute positioning.
+ *
+ *
+ * <h3>Textarea directive</h3>
+ * The `textarea` element within a `md-input-container` has the following specific behavior:
+ * - By default the `textarea` grows as the user types. This can be disabled via the `md-no-autogrow`
+ * attribute.
+ * - If a `textarea` has the `rows` attribute, it will treat the `rows` as the minimum height and will
+ * continue growing as the user types. For example a textarea with `rows="3"` will be 3 lines of text
+ * high initially. If no rows are specified, the directive defaults to 1.
+ * - The textarea's height gets set on initialization, as well as while the user is typing. In certain situations
+ * (e.g. while animating) the directive might have been initialized, before the element got it's final height. In
+ * those cases, you can trigger a resize manually by broadcasting a `md-resize-textarea` event on the scope.
+ * - If you want a `textarea` to stop growing at a certain point, you can specify the `max-rows` attribute.
+ * - The textarea's bottom border acts as a handle which users can drag, in order to resize the element vertically.
+ * Once the user has resized a `textarea`, the autogrowing functionality becomes disabled. If you don't want a
+ * `textarea` to be resizeable by the user, you can add the `md-no-resize` attribute.
+ */
+
+function inputTextareaDirective($mdUtil, $window, $mdAria, $timeout, $mdGesture) {
+ return {
+ restrict: 'E',
+ require: ['^?mdInputContainer', '?ngModel', '?^form'],
+ link: postLink
+ };
+
+ function postLink(scope, element, attr, ctrls) {
+
+ var containerCtrl = ctrls[0];
+ var hasNgModel = !!ctrls[1];
+ var ngModelCtrl = ctrls[1] || $mdUtil.fakeNgModel();
+ var parentForm = ctrls[2];
+ var isReadonly = angular.isDefined(attr.readonly);
+ var mdNoAsterisk = $mdUtil.parseAttributeBoolean(attr.mdNoAsterisk);
+ var tagName = element[0].tagName.toLowerCase();
+
+
+ if (!containerCtrl) return;
+ if (attr.type === 'hidden') {
+ element.attr('aria-hidden', 'true');
+ return;
+ } else if (containerCtrl.input) {
+ if (containerCtrl.input[0].contains(element[0])) {
+ return;
+ } else {
+ throw new Error("<md-input-container> can only have *one* <input>, <textarea> or <md-select> child element!");
+ }
+ }
+ containerCtrl.input = element;
+
+ setupAttributeWatchers();
+
+ // Add an error spacer div after our input to provide space for the char counter and any ng-messages
+ var errorsSpacer = angular.element('<div class="md-errors-spacer">');
+ element.after(errorsSpacer);
+
+ var placeholderText = angular.isString(attr.placeholder) ? attr.placeholder.trim() : '';
+ if (!containerCtrl.label && !placeholderText.length) {
+ $mdAria.expect(element, 'aria-label');
+ }
+
+ element.addClass('md-input');
+ if (!element.attr('id')) {
+ element.attr('id', 'input_' + $mdUtil.nextUid());
+ }
+
+ // This works around a Webkit issue where number inputs, placed in a flexbox, that have
+ // a `min` and `max` will collapse to about 1/3 of their proper width. Please check #7349
+ // for more info. Also note that we don't override the `step` if the user has specified it,
+ // in order to prevent some unexpected behaviour.
+ if (tagName === 'input' && attr.type === 'number' && attr.min && attr.max && !attr.step) {
+ element.attr('step', 'any');
+ } else if (tagName === 'textarea') {
+ setupTextarea();
+ }
+
+ // If the input doesn't have an ngModel, it may have a static value. For that case,
+ // we have to do one initial check to determine if the container should be in the
+ // "has a value" state.
+ if (!hasNgModel) {
+ inputCheckValue();
+ }
+
+ var isErrorGetter = containerCtrl.isErrorGetter || function() {
+ return ngModelCtrl.$invalid && (ngModelCtrl.$touched || (parentForm && parentForm.$submitted));
+ };
+
+ scope.$watch(isErrorGetter, containerCtrl.setInvalid);
+
+ // When the developer uses the ngValue directive for the input, we have to observe the attribute, because
+ // AngularJS's ngValue directive is just setting the `value` attribute.
+ if (attr.ngValue) {
+ attr.$observe('value', inputCheckValue);
+ }
+
+ ngModelCtrl.$parsers.push(ngModelPipelineCheckValue);
+ ngModelCtrl.$formatters.push(ngModelPipelineCheckValue);
+
+ element.on('input', inputCheckValue);
+
+ if (!isReadonly) {
+ element
+ .on('focus', function(ev) {
+ $mdUtil.nextTick(function() {
+ containerCtrl.setFocused(true);
+ });
+ })
+ .on('blur', function(ev) {
+ $mdUtil.nextTick(function() {
+ containerCtrl.setFocused(false);
+ inputCheckValue();
+ });
+ });
+ }
+
+ scope.$on('$destroy', function() {
+ containerCtrl.setFocused(false);
+ containerCtrl.setHasValue(false);
+ containerCtrl.input = null;
+ });
+
+ /** Gets run through ngModel's pipeline and set the `has-value` class on the container. */
+ function ngModelPipelineCheckValue(arg) {
+ containerCtrl.setHasValue(!ngModelCtrl.$isEmpty(arg));
+ return arg;
+ }
+
+ function setupAttributeWatchers() {
+ if (containerCtrl.label) {
+ attr.$observe('required', function (value) {
+ // We don't need to parse the required value, it's always a boolean because of AngularJS'
+ // required directive.
+ if (containerCtrl.label) {
+ containerCtrl.label.toggleClass('md-required', value && !mdNoAsterisk);
+ }
+ });
+ }
+ }
+
+ function inputCheckValue() {
+ // An input's value counts if its length > 0,
+ // or if the input's validity state says it has bad input (eg string in a number input)
+ containerCtrl.setHasValue(element.val().length > 0 || (element[0].validity || {}).badInput);
+ }
+
+ function setupTextarea() {
+ var isAutogrowing = !attr.hasOwnProperty('mdNoAutogrow');
+
+ attachResizeHandle();
+
+ if (!isAutogrowing) return;
+
+ // Can't check if height was or not explicity set,
+ // so rows attribute will take precedence if present
+ var minRows = attr.hasOwnProperty('rows') ? parseInt(attr.rows) : NaN;
+ var maxRows = attr.hasOwnProperty('maxRows') ? parseInt(attr.maxRows) : NaN;
+ var scopeResizeListener = scope.$on('md-resize-textarea', growTextarea);
+ var lineHeight = null;
+ var node = element[0];
+
+ // This timeout is necessary, because the browser needs a little bit
+ // of time to calculate the `clientHeight` and `scrollHeight`.
+ $timeout(function() {
+ $mdUtil.nextTick(growTextarea);
+ }, 10, false);
+
+ // We could leverage ngModel's $parsers here, however it
+ // isn't reliable, because AngularJS trims the input by default,
+ // which means that growTextarea won't fire when newlines and
+ // spaces are added.
+ element.on('input', growTextarea);
+
+ // We should still use the $formatters, because they fire when
+ // the value was changed from outside the textarea.
+ if (hasNgModel) {
+ ngModelCtrl.$formatters.push(formattersListener);
+ }
+
+ if (!minRows) {
+ element.attr('rows', 1);
+ }
+
+ angular.element($window).on('resize', growTextarea);
+ scope.$on('$destroy', disableAutogrow);
+
+ function growTextarea() {
+ // temporarily disables element's flex so its height 'runs free'
+ element
+ .attr('rows', 1)
+ .css('height', 'auto')
+ .addClass('md-no-flex');
+
+ var height = getHeight();
+
+ if (!lineHeight) {
+ // offsetHeight includes padding which can throw off our value
+ var originalPadding = element[0].style.padding || '';
+ lineHeight = element.css('padding', 0).prop('offsetHeight');
+ element[0].style.padding = originalPadding;
+ }
+
+ if (minRows && lineHeight) {
+ height = Math.max(height, lineHeight * minRows);
+ }
+
+ if (maxRows && lineHeight) {
+ var maxHeight = lineHeight * maxRows;
+
+ if (maxHeight < height) {
+ element.attr('md-no-autogrow', '');
+ height = maxHeight;
+ } else {
+ element.removeAttr('md-no-autogrow');
+ }
+ }
+
+ if (lineHeight) {
+ element.attr('rows', Math.round(height / lineHeight));
+ }
+
+ element
+ .css('height', height + 'px')
+ .removeClass('md-no-flex');
+ }
+
+ function getHeight() {
+ var offsetHeight = node.offsetHeight;
+ var line = node.scrollHeight - offsetHeight;
+ return offsetHeight + Math.max(line, 0);
+ }
+
+ function formattersListener(value) {
+ $mdUtil.nextTick(growTextarea);
+ return value;
+ }
+
+ function disableAutogrow() {
+ if (!isAutogrowing) return;
+
+ isAutogrowing = false;
+ angular.element($window).off('resize', growTextarea);
+ scopeResizeListener && scopeResizeListener();
+ element
+ .attr('md-no-autogrow', '')
+ .off('input', growTextarea);
+
+ if (hasNgModel) {
+ var listenerIndex = ngModelCtrl.$formatters.indexOf(formattersListener);
+
+ if (listenerIndex > -1) {
+ ngModelCtrl.$formatters.splice(listenerIndex, 1);
+ }
+ }
+ }
+
+ function attachResizeHandle() {
+ if (attr.hasOwnProperty('mdNoResize')) return;
+
+ var handle = angular.element('<div class="md-resize-handle"></div>');
+ var isDragging = false;
+ var dragStart = null;
+ var startHeight = 0;
+ var container = containerCtrl.element;
+ var dragGestureHandler = $mdGesture.register(handle, 'drag', { horizontal: false });
+
+
+ element.wrap('<div class="md-resize-wrapper">').after(handle);
+ handle.on('mousedown', onMouseDown);
+
+ container
+ .on('$md.dragstart', onDragStart)
+ .on('$md.drag', onDrag)
+ .on('$md.dragend', onDragEnd);
+
+ scope.$on('$destroy', function() {
+ handle
+ .off('mousedown', onMouseDown)
+ .remove();
+
+ container
+ .off('$md.dragstart', onDragStart)
+ .off('$md.drag', onDrag)
+ .off('$md.dragend', onDragEnd);
+
+ dragGestureHandler();
+ handle = null;
+ container = null;
+ dragGestureHandler = null;
+ });
+
+ function onMouseDown(ev) {
+ ev.preventDefault();
+ isDragging = true;
+ dragStart = ev.clientY;
+ startHeight = parseFloat(element.css('height')) || element.prop('offsetHeight');
+ }
+
+ function onDragStart(ev) {
+ if (!isDragging) return;
+ ev.preventDefault();
+ disableAutogrow();
+ container.addClass('md-input-resized');
+ }
+
+ function onDrag(ev) {
+ if (!isDragging) return;
+
+ element.css('height', (startHeight + ev.pointer.distanceY) + 'px');
+ }
+
+ function onDragEnd(ev) {
+ if (!isDragging) return;
+ isDragging = false;
+ container.removeClass('md-input-resized');
+ }
+ }
+
+ // Attach a watcher to detect when the textarea gets shown.
+ if (attr.hasOwnProperty('mdDetectHidden')) {
+
+ var handleHiddenChange = function() {
+ var wasHidden = false;
+
+ return function() {
+ var isHidden = node.offsetHeight === 0;
+
+ if (isHidden === false && wasHidden === true) {
+ growTextarea();
+ }
+
+ wasHidden = isHidden;
+ };
+ }();
+
+ // Check every digest cycle whether the visibility of the textarea has changed.
+ // Queue up to run after the digest cycle is complete.
+ scope.$watch(function() {
+ $mdUtil.nextTick(handleHiddenChange, false);
+ return true;
+ });
+ }
+ }
+ }
+}
+
+function mdMaxlengthDirective($animate, $mdUtil) {
+ return {
+ restrict: 'A',
+ require: ['ngModel', '^mdInputContainer'],
+ link: postLink
+ };
+
+ function postLink(scope, element, attr, ctrls) {
+ var maxlength = parseInt(attr.mdMaxlength);
+ if (isNaN(maxlength)) maxlength = -1;
+ var ngModelCtrl = ctrls[0];
+ var containerCtrl = ctrls[1];
+ var charCountEl, errorsSpacer;
+ var ngTrim = angular.isDefined(attr.ngTrim) ? $mdUtil.parseAttributeBoolean(attr.ngTrim) : true;
+ var isPasswordInput = attr.type === 'password';
+
+ scope.$watch(attr.mdMaxlength, function(value) {
+ maxlength = value;
+ });
+
+ ngModelCtrl.$validators['md-maxlength'] = function(modelValue, viewValue) {
+ if (!angular.isNumber(maxlength) || maxlength < 0) {
+ return true;
+ }
+
+ // We always update the char count, when the modelValue has changed.
+ // Using the $validators for triggering the update works very well.
+ renderCharCount();
+
+ var elementVal = element.val() || viewValue;
+ if (elementVal === undefined || elementVal === null) {
+ elementVal = '';
+ }
+ elementVal = ngTrim && !isPasswordInput && angular.isString(elementVal) ? elementVal.trim() : elementVal;
+ // Force the value into a string since it may be a number,
+ // which does not have a length property.
+ return String(elementVal).length <= maxlength;
+ };
+
+ /**
+ * Override the default NgModelController $isEmpty check to take ng-trim, password inputs,
+ * etc. into account.
+ * @param value {*} the input's value
+ * @returns {boolean} true if the input's value should be considered empty, false otherwise
+ */
+ ngModelCtrl.$isEmpty = function(value) {
+ return calculateInputValueLength(value) === 0;
+ };
+
+ // Wait until the next tick to ensure that the input has setup the errors spacer where we will
+ // append our counter
+ $mdUtil.nextTick(function() {
+ errorsSpacer = angular.element(containerCtrl.element[0].querySelector('.md-errors-spacer'));
+ charCountEl = angular.element('<div class="md-char-counter">');
+
+ // Append our character counter inside the errors spacer
+ errorsSpacer.append(charCountEl);
+
+ attr.$observe('ngTrim', function (value) {
+ ngTrim = angular.isDefined(value) ? $mdUtil.parseAttributeBoolean(value) : true;
+ });
+
+ scope.$watch(attr.mdMaxlength, function(value) {
+ if (angular.isNumber(value) && value > 0) {
+ if (!charCountEl.parent().length) {
+ $animate.enter(charCountEl, errorsSpacer);
+ }
+ renderCharCount();
+ } else {
+ $animate.leave(charCountEl);
+ }
+ });
+ });
+
+ /**
+ * Calculate the input value's length after coercing it to a string
+ * and trimming it if appropriate.
+ * @param value {*} the input's value
+ * @returns {number} calculated length of the input's value
+ */
+ function calculateInputValueLength(value) {
+ value = ngTrim && !isPasswordInput && angular.isString(value) ? value.trim() : value;
+ if (value === undefined || value === null) {
+ value = '';
+ }
+ return String(value).length;
+ }
+
+ function renderCharCount() {
+ // If we have not been initialized or appended to the body yet; do not render.
+ if (!charCountEl || !charCountEl.parent()) {
+ return;
+ }
+ // Force the value into a string since it may be a number,
+ // which does not have a length property.
+ charCountEl.text(calculateInputValueLength(element.val()) + ' / ' + maxlength);
+ }
+ }
+}
+
+function placeholderDirective($compile) {
+ return {
+ restrict: 'A',
+ require: '^^?mdInputContainer',
+ priority: 200,
+ link: {
+ // Note that we need to do this in the pre-link, as opposed to the post link, if we want to
+ // support data bindings in the placeholder. This is necessary, because we have a case where
+ // we transfer the placeholder value to the `<label>` and we remove it from the original `<input>`.
+ // If we did this in the post-link, AngularJS would have set up the observers already and would be
+ // re-adding the attribute, even though we removed it from the element.
+ pre: preLink
+ }
+ };
+
+ function preLink(scope, element, attr, inputContainer) {
+ // If there is no input container, just return
+ if (!inputContainer) return;
+
+ var label = inputContainer.element.find('label');
+ var noFloat = inputContainer.element.attr('md-no-float');
+
+ // If we have a label, or they specify the md-no-float attribute, just return
+ if ((label && label.length) || noFloat === '' || scope.$eval(noFloat)) {
+ // Add a placeholder class so we can target it in the CSS
+ inputContainer.setHasPlaceholder(true);
+ return;
+ }
+
+ // md-select handles placeholders on it's own
+ if (element[0].nodeName !== 'MD-SELECT') {
+ // Move the placeholder expression to the label
+ var newLabel = angular.element(
+ '<label ng-click="delegateClick()" tabindex="-1" aria-hidden="true">' + attr.placeholder +
+ '</label>');
+
+ // Note that we unset it via `attr`, in order to get AngularJS
+ // to remove any observers that it might have set up. Otherwise
+ // the attribute will be added on the next digest.
+ attr.$set('placeholder', null);
+
+ // We need to compile the label manually in case it has any bindings.
+ // A gotcha here is that we first add the element to the DOM and we compile
+ // it later. This is necessary, because if we compile the element beforehand,
+ // it won't be able to find the `mdInputContainer` controller.
+ inputContainer.element
+ .addClass('md-icon-float')
+ .prepend(newLabel);
+
+ $compile(newLabel)(scope);
+ }
+ }
+}
+
+/**
+ * @ngdoc directive
+ * @name mdSelectOnFocus
+ * @module material.components.input
+ *
+ * @restrict A
+ *
+ * @description
+ * The `md-select-on-focus` directive allows you to automatically select the element's input text on focus.
+ *
+ * <h3>Notes</h3>
+ * - The use of `md-select-on-focus` is restricted to `<input>` and `<textarea>` elements.
+ *
+ * @usage
+ * <h3>Using with an Input</h3>
+ * <hljs lang="html">
+ *
+ * <md-input-container>
+ * <label>Auto Select</label>
+ * <input type="text" md-select-on-focus>
+ * </md-input-container>
+ * </hljs>
+ *
+ * <h3>Using with a Textarea</h3>
+ * <hljs lang="html">
+ *
+ * <md-input-container>
+ * <label>Auto Select</label>
+ * <textarea md-select-on-focus>This text will be selected on focus.</textarea>
+ * </md-input-container>
+ *
+ * </hljs>
+ */
+function mdSelectOnFocusDirective($document, $timeout) {
+
+ return {
+ restrict: 'A',
+ link: postLink
+ };
+
+ function postLink(scope, element, attr) {
+ if (element[0].nodeName !== 'INPUT' && element[0].nodeName !== "TEXTAREA") return;
+
+ var preventMouseUp = false;
+
+ element
+ .on('focus', onFocus)
+ .on('mouseup', onMouseUp);
+
+ scope.$on('$destroy', function() {
+ element
+ .off('focus', onFocus)
+ .off('mouseup', onMouseUp);
+ });
+
+ function onFocus() {
+ preventMouseUp = true;
+
+ $timeout(function() {
+
+ // Use HTMLInputElement#select to fix firefox select issues.
+ // The debounce is here for Edge's sake, otherwise the selection doesn't work.
+ // Since focus may already have been lost on the input (and because `select()`
+ // will re-focus), make sure the element is still active before applying.
+ if ($document[0].activeElement === element[0]) {
+ element[0].select();
+ }
+
+ // This should be reset from inside the `focus`, because the event might
+ // have originated from something different than a click, e.g. a keyboard event.
+ preventMouseUp = false;
+ }, 1, false);
+ }
+
+ // Prevents the default action of the first `mouseup` after a focus.
+ // This is necessary, because browsers fire a `mouseup` right after the element
+ // has been focused. In some browsers (Firefox in particular) this can clear the
+ // selection. There are examples of the problem in issue #7487.
+ function onMouseUp(event) {
+ if (preventMouseUp) {
+ event.preventDefault();
+ }
+ }
+ }
+}
+
+var visibilityDirectives = ['ngIf', 'ngShow', 'ngHide', 'ngSwitchWhen', 'ngSwitchDefault'];
+function ngMessagesDirective() {
+ return {
+ restrict: 'EA',
+ link: postLink,
+
+ // This is optional because we don't want target *all* ngMessage instances, just those inside of
+ // mdInputContainer.
+ require: '^^?mdInputContainer'
+ };
+
+ function postLink(scope, element, attrs, inputContainer) {
+ // If we are not a child of an input container, don't do anything
+ if (!inputContainer) return;
+
+ // Add our animation class
+ element.toggleClass('md-input-messages-animation', true);
+
+ // Add our md-auto-hide class to automatically hide/show messages when container is invalid
+ element.toggleClass('md-auto-hide', true);
+
+ // If we see some known visibility directives, remove the md-auto-hide class
+ if (attrs.mdAutoHide == 'false' || hasVisibiltyDirective(attrs)) {
+ element.toggleClass('md-auto-hide', false);
+ }
+ }
+
+ function hasVisibiltyDirective(attrs) {
+ return visibilityDirectives.some(function(attr) {
+ return attrs[attr];
+ });
+ }
+}
+
+function ngMessageDirective($mdUtil) {
+ return {
+ restrict: 'EA',
+ compile: compile,
+ priority: 100
+ };
+
+ function compile(tElement) {
+ if (!isInsideInputContainer(tElement)) {
+
+ // When the current element is inside of a document fragment, then we need to check for an input-container
+ // in the postLink, because the element will be later added to the DOM and is currently just in a temporary
+ // fragment, which causes the input-container check to fail.
+ if (isInsideFragment()) {
+ return function (scope, element) {
+ if (isInsideInputContainer(element)) {
+ // Inside of the postLink function, a ngMessage directive will be a comment element, because it's
+ // currently hidden. To access the shown element, we need to use the element from the compile function.
+ initMessageElement(tElement);
+ }
+ };
+ }
+ } else {
+ initMessageElement(tElement);
+ }
+
+ function isInsideFragment() {
+ var nextNode = tElement[0];
+ while (nextNode = nextNode.parentNode) {
+ if (nextNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ function isInsideInputContainer(element) {
+ return !!$mdUtil.getClosest(element, "md-input-container");
+ }
+
+ function initMessageElement(element) {
+ // Add our animation class
+ element.toggleClass('md-input-message-animation', true);
+ }
+ }
+}
+
+var $$AnimateRunner, $animateCss, $mdUtil;
+
+function mdInputInvalidMessagesAnimation($$AnimateRunner, $animateCss, $mdUtil) {
+ saveSharedServices($$AnimateRunner, $animateCss, $mdUtil);
+
+ return {
+ addClass: function(element, className, done) {
+ showInputMessages(element, done);
+ }
+
+ // NOTE: We do not need the removeClass method, because the message ng-leave animation will fire
+ };
+}
+
+function ngMessagesAnimation($$AnimateRunner, $animateCss, $mdUtil) {
+ saveSharedServices($$AnimateRunner, $animateCss, $mdUtil);
+
+ return {
+ enter: function(element, done) {
+ showInputMessages(element, done);
+ },
+
+ leave: function(element, done) {
+ hideInputMessages(element, done);
+ },
+
+ addClass: function(element, className, done) {
+ if (className == "ng-hide") {
+ hideInputMessages(element, done);
+ } else {
+ done();
+ }
+ },
+
+ removeClass: function(element, className, done) {
+ if (className == "ng-hide") {
+ showInputMessages(element, done);
+ } else {
+ done();
+ }
+ }
+ };
+}
+
+function ngMessageAnimation($$AnimateRunner, $animateCss, $mdUtil, $log) {
+ saveSharedServices($$AnimateRunner, $animateCss, $mdUtil, $log);
+
+ return {
+ enter: function(element, done) {
+ var animator = showMessage(element);
+
+ animator.start().done(done);
+ },
+
+ leave: function(element, done) {
+ var animator = hideMessage(element);
+
+ animator.start().done(done);
+ }
+ };
+}
+
+function showInputMessages(element, done) {
+ var animators = [], animator;
+ var messages = getMessagesElement(element);
+ var children = messages.children();
+
+ if (messages.length == 0 || children.length == 0) {
+ done();
+ return;
+ }
+
+ angular.forEach(children, function(child) {
+ animator = showMessage(angular.element(child));
+
+ animators.push(animator.start());
+ });
+
+ $$AnimateRunner.all(animators, done);
+}
+
+function hideInputMessages(element, done) {
+ var animators = [], animator;
+ var messages = getMessagesElement(element);
+ var children = messages.children();
+
+ if (messages.length == 0 || children.length == 0) {
+ done();
+ return;
+ }
+
+ angular.forEach(children, function(child) {
+ animator = hideMessage(angular.element(child));
+
+ animators.push(animator.start());
+ });
+
+ $$AnimateRunner.all(animators, done);
+}
+
+function showMessage(element) {
+ var height = parseInt(window.getComputedStyle(element[0]).height);
+ var topMargin = parseInt(window.getComputedStyle(element[0]).marginTop);
+
+ var messages = getMessagesElement(element);
+ var container = getInputElement(element);
+
+ // Check to see if the message is already visible so we can skip
+ var alreadyVisible = (topMargin > -height);
+
+ // If we have the md-auto-hide class, the md-input-invalid animation will fire, so we can skip
+ if (alreadyVisible || (messages.hasClass('md-auto-hide') && !container.hasClass('md-input-invalid'))) {
+ return $animateCss(element, {});
+ }
+
+ return $animateCss(element, {
+ event: 'enter',
+ structural: true,
+ from: {"opacity": 0, "margin-top": -height + "px"},
+ to: {"opacity": 1, "margin-top": "0"},
+ duration: 0.3
+ });
+}
+
+function hideMessage(element) {
+ var height = element[0].offsetHeight;
+ var styles = window.getComputedStyle(element[0]);
+
+ // If we are already hidden, just return an empty animation
+ if (parseInt(styles.opacity) === 0) {
+ return $animateCss(element, {});
+ }
+
+ // Otherwise, animate
+ return $animateCss(element, {
+ event: 'leave',
+ structural: true,
+ from: {"opacity": 1, "margin-top": 0},
+ to: {"opacity": 0, "margin-top": -height + "px"},
+ duration: 0.3
+ });
+}
+
+function getInputElement(element) {
+ var inputContainer = element.controller('mdInputContainer');
+
+ return inputContainer.element;
+}
+
+function getMessagesElement(element) {
+ // If we ARE the messages element, just return ourself
+ if (element.hasClass('md-input-messages-animation')) {
+ return element;
+ }
+
+ // If we are a ng-message element, we need to traverse up the DOM tree
+ if (element.hasClass('md-input-message-animation')) {
+ return angular.element($mdUtil.getClosest(element, function(node) {
+ return node.classList.contains('md-input-messages-animation');
+ }));
+ }
+
+ // Otherwise, we can traverse down
+ return angular.element(element[0].querySelector('.md-input-messages-animation'));
+}
+
+function saveSharedServices(_$$AnimateRunner_, _$animateCss_, _$mdUtil_) {
+ $$AnimateRunner = _$$AnimateRunner_;
+ $animateCss = _$animateCss_;
+ $mdUtil = _$mdUtil_;
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.list
+ * @description
+ * List module
+ */
+MdListController.$inject = ["$scope", "$element", "$mdListInkRipple"];
+mdListDirective.$inject = ["$mdTheming"];
+mdListItemDirective.$inject = ["$mdAria", "$mdConstant", "$mdUtil", "$timeout"];
+angular.module('material.components.list', [
+ 'material.core'
+])
+ .controller('MdListController', MdListController)
+ .directive('mdList', mdListDirective)
+ .directive('mdListItem', mdListItemDirective);
+
+/**
+ * @ngdoc directive
+ * @name mdList
+ * @module material.components.list
+ *
+ * @restrict E
+ *
+ * @description
+ * The `<md-list>` directive is a list container for 1..n `<md-list-item>` tags.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-list>
+ * <md-list-item class="md-2-line" ng-repeat="item in todos">
+ * <md-checkbox ng-model="item.done"></md-checkbox>
+ * <div class="md-list-item-text">
+ * <h3>{{item.title}}</h3>
+ * <p>{{item.description}}</p>
+ * </div>
+ * </md-list-item>
+ * </md-list>
+ * </hljs>
+ */
+
+function mdListDirective($mdTheming) {
+ return {
+ restrict: 'E',
+ compile: function(tEl) {
+ tEl[0].setAttribute('role', 'list');
+ return $mdTheming;
+ }
+ };
+}
+/**
+ * @ngdoc directive
+ * @name mdListItem
+ * @module material.components.list
+ *
+ * @restrict E
+ *
+ * @description
+ * A `md-list-item` element can be used to represent some information in a row.<br/>
+ *
+ * @usage
+ * ### Single Row Item
+ * <hljs lang="html">
+ * <md-list-item>
+ * <span>Single Row Item</span>
+ * </md-list-item>
+ * </hljs>
+ *
+ * ### Multiple Lines
+ * By using the following markup, you will be able to have two lines inside of one `md-list-item`.
+ *
+ * <hljs lang="html">
+ * <md-list-item class="md-2-line">
+ * <div class="md-list-item-text" layout="column">
+ * <p>First Line</p>
+ * <p>Second Line</p>
+ * </div>
+ * </md-list-item>
+ * </hljs>
+ *
+ * It is also possible to have three lines inside of one list item.
+ *
+ * <hljs lang="html">
+ * <md-list-item class="md-3-line">
+ * <div class="md-list-item-text" layout="column">
+ * <p>First Line</p>
+ * <p>Second Line</p>
+ * <p>Third Line</p>
+ * </div>
+ * </md-list-item>
+ * </hljs>
+ *
+ * ### Secondary Items
+ * Secondary items are elements which will be aligned at the end of the `md-list-item`.
+ *
+ * <hljs lang="html">
+ * <md-list-item>
+ * <span>Single Row Item</span>
+ * <md-button class="md-secondary">
+ * Secondary Button
+ * </md-button>
+ * </md-list-item>
+ * </hljs>
+ *
+ * It also possible to have multiple secondary items inside of one `md-list-item`.
+ *
+ * <hljs lang="html">
+ * <md-list-item>
+ * <span>Single Row Item</span>
+ * <md-button class="md-secondary">First Button</md-button>
+ * <md-button class="md-secondary">Second Button</md-button>
+ * </md-list-item>
+ * </hljs>
+ *
+ * ### Proxy Item
+ * Proxies are elements, which will execute their specific action on click<br/>
+ * Currently supported proxy items are
+ * - `md-checkbox` (Toggle)
+ * - `md-switch` (Toggle)
+ * - `md-menu` (Open)
+ *
+ * This means, when using a supported proxy item inside of `md-list-item`, the list item will
+ * automatically become clickable and executes the associated action of the proxy element on click.
+ *
+ * It is possible to disable this behavior by applying the `md-no-proxy` class to the list item.
+ *
+ * <hljs lang="html">
+ * <md-list-item class="md-no-proxy">
+ * <span>No Proxy List</span>
+ * <md-checkbox class="md-secondary"></md-checkbox>
+ * </md-list-item>
+ * </hljs>
+ *
+ * Here are a few examples of proxy elements inside of a list item.
+ *
+ * <hljs lang="html">
+ * <md-list-item>
+ * <span>First Line</span>
+ * <md-checkbox class="md-secondary"></md-checkbox>
+ * </md-list-item>
+ * </hljs>
+ *
+ * The `md-checkbox` element will be automatically detected as a proxy element and will toggle on
+ * click.
+ *
+ * If not provided, an `aria-label` will be applied using the text of the list item.
+ * In this case, the following will be applied to the `md-checkbox`:
+ * `aria-label="Toggle First Line"`.
+ * When localizing your application, you should supply a localized `aria-label`.
+ *
+ * <hljs lang="html">
+ * <md-list-item>
+ * <span>First Line</span>
+ * <md-switch class="md-secondary"></md-switch>
+ * </md-list-item>
+ * </hljs>
+ *
+ * The recognized `md-switch` will toggle its state, when the user clicks on the `md-list-item`.
+ *
+ * It is also possible to have a `md-menu` inside of a `md-list-item`.
+ *
+ * <hljs lang="html">
+ * <md-list-item>
+ * <p>Click anywhere to fire the secondary action</p>
+ * <md-menu class="md-secondary">
+ * <md-button class="md-icon-button">
+ * <md-icon md-svg-icon="communication:message"></md-icon>
+ * </md-button>
+ * <md-menu-content width="4">
+ * <md-menu-item>
+ * <md-button>
+ * Redial
+ * </md-button>
+ * </md-menu-item>
+ * <md-menu-item>
+ * <md-button>
+ * Check voicemail
+ * </md-button>
+ * </md-menu-item>
+ * <md-menu-divider></md-menu-divider>
+ * <md-menu-item>
+ * <md-button>
+ * Notifications
+ * </md-button>
+ * </md-menu-item>
+ * </md-menu-content>
+ * </md-menu>
+ * </md-list-item>
+ * </hljs>
+ *
+ * The menu will automatically open, when the users clicks on the `md-list-item`.<br/>
+ *
+ * If the developer didn't specify any position mode on the menu, the `md-list-item` will
+ * automatically detect the position mode and apply it to the `md-menu`.
+ *
+ * ### Avatars
+ * Sometimes you may want to have avatars inside of the `md-list-item `.<br/>
+ * You are able to create an optimized icon for the list item, by applying the `.md-avatar` class on
+ * the `<img>` element.
+ *
+ * <hljs lang="html">
+ * <md-list-item>
+ * <img src="my-avatar.png" class="md-avatar">
+ * <span>Alan Turing</span>
+ * </hljs>
+ *
+ * When using `<md-icon>` for an avatar, you have to use the `.md-avatar-icon` class.
+ *
+ * <hljs lang="html">
+ * <md-list-item>
+ * <md-icon class="md-avatar-icon" md-svg-icon="social:person"></md-icon>
+ * <span>Timothy Kopra</span>
+ * </md-list-item>
+ * </hljs>
+ *
+ * In cases where you have a `md-list-item`, which doesn't have an avatar,
+ * but you want to align it with the other avatar items, you need to use the `.md-offset` class.
+ *
+ * <hljs lang="html">
+ * <md-list-item class="md-offset">
+ * <span>Jon Doe</span>
+ * </md-list-item>
+ * </hljs>
+ *
+ * ### DOM modification
+ * The `md-list-item` component automatically detects if the list item should be clickable.
+ *
+ * ---
+ * If the `md-list-item` is clickable, we wrap all content inside of a `<div>` and create
+ * an overlaying button, which will will execute the given actions (like `ng-href`, `ng-click`).
+ *
+ * We create an overlaying button, instead of wrapping all content inside of the button,
+ * because otherwise some elements may not be clickable inside of the button.
+ *
+ * ---
+ * When using a secondary item inside of your list item, the `md-list-item` component will
+ * automatically create a secondary container at the end of the `md-list-item`, which contains all
+ * secondary items.
+ *
+ * The secondary item container is not static, because that would cause issues with the overflow
+ * of the list item.
+ */
+function mdListItemDirective($mdAria, $mdConstant, $mdUtil, $timeout) {
+ var proxiedTypes = ['md-checkbox', 'md-switch', 'md-menu'];
+ return {
+ restrict: 'E',
+ controller: 'MdListController',
+
+ compile: function(tElement, tAttrs) {
+
+ // Check for proxy controls (no ng-click on parent, and a control inside)
+ var secondaryItems = tElement[0].querySelectorAll('.md-secondary');
+ var hasProxiedElement;
+ var proxyElement;
+ var itemContainer = tElement;
+
+ tElement[0].setAttribute('role', 'listitem');
+
+ if (tAttrs.ngClick || tAttrs.ngDblclick || tAttrs.ngHref || tAttrs.href || tAttrs.uiSref || tAttrs.ngAttrUiSref) {
+ wrapIn('button');
+ } else if (!tElement.hasClass('md-no-proxy')) {
+
+ for (var i = 0, type; i < proxiedTypes.length; ++i) {
+ proxyElement = tElement[0].querySelector(proxiedTypes[i]);
+ if (proxyElement !== null) {
+ hasProxiedElement = true;
+ break;
+ }
+ }
+
+ if (hasProxiedElement) {
+ wrapIn('div');
+ } else {
+ tElement.addClass('md-no-proxy');
+ }
+ }
+
+ wrapSecondaryItems();
+ setupToggleAria();
+
+ if (hasProxiedElement && proxyElement.nodeName === "MD-MENU") {
+ setupProxiedMenu();
+ }
+
+ function setupToggleAria() {
+ var toggleTypes = ['md-switch', 'md-checkbox'];
+ var toggle;
+
+ for (var i = 0, toggleType; i < toggleTypes.length; ++i) {
+ toggle = tElement.find(toggleTypes[i])[0];
+ if (toggle) {
+ if (!toggle.hasAttribute('aria-label')) {
+ var labelElement = tElement.find('p')[0];
+ if (!labelElement) {
+ labelElement = tElement.find('span')[0];
+ }
+ if (!labelElement) return;
+ toggle.setAttribute('aria-label', 'Toggle ' + labelElement.textContent);
+ }
+ }
+ }
+ }
+
+ function setupProxiedMenu() {
+ var menuEl = angular.element(proxyElement);
+
+ var isEndAligned = menuEl.parent().hasClass('md-secondary-container') ||
+ proxyElement.parentNode.firstElementChild !== proxyElement;
+
+ var xAxisPosition = 'left';
+
+ if (isEndAligned) {
+ // When the proxy item is aligned at the end of the list, we have to set the origin to the end.
+ xAxisPosition = 'right';
+ }
+
+ // Set the position mode / origin of the proxied menu.
+ if (!menuEl.attr('md-position-mode')) {
+ menuEl.attr('md-position-mode', xAxisPosition + ' target');
+ }
+
+ // Apply menu open binding to menu button
+ var menuOpenButton = menuEl.children().eq(0);
+ if (!hasClickEvent(menuOpenButton[0])) {
+ menuOpenButton.attr('ng-click', '$mdMenu.open($event)');
+ }
+
+ if (!menuOpenButton.attr('aria-label')) {
+ menuOpenButton.attr('aria-label', 'Open List Menu');
+ }
+ }
+
+ /**
+ * @param {'div'|'button'} type
+ */
+ function wrapIn(type) {
+ if (type === 'div') {
+ itemContainer = angular.element('<div class="md-no-style md-list-item-inner">');
+ itemContainer.append(tElement.contents());
+ tElement.addClass('md-proxy-focus');
+ } else {
+ // Element which holds the default list-item content.
+ itemContainer = angular.element(
+ '<div class="md-button md-no-style">' +
+ ' <div class="md-list-item-inner"></div>' +
+ '</div>'
+ );
+
+ // Button which shows ripple and executes primary action.
+ var buttonWrap = angular.element('<md-button class="md-no-style"></md-button>');
+
+ moveAttributes(tElement[0], buttonWrap[0]);
+
+ // If there is no aria-label set on the button (previously copied over if present)
+ // we determine the label from the content and copy it to the button.
+ if (!buttonWrap.attr('aria-label')) {
+ buttonWrap.attr('aria-label', $mdAria.getText(tElement));
+
+ // If we set the button's aria-label to the text content, then make the content hidden
+ // from screen readers so that it isn't read/traversed twice.
+ var listItemInner = itemContainer[0].querySelector('.md-list-item-inner');
+ if (listItemInner) {
+ listItemInner.setAttribute('aria-hidden', 'true');
+ }
+ }
+
+ // We allow developers to specify the `md-no-focus` class, to disable the focus style
+ // on the button executor. Once more classes should be forwarded, we should probably make
+ // the class forward more generic.
+ if (tElement.hasClass('md-no-focus')) {
+ buttonWrap.addClass('md-no-focus');
+ }
+
+ // Append the button wrap before our list-item content, because it will overlay in
+ // relative.
+ itemContainer.prepend(buttonWrap);
+ itemContainer.children().eq(1).append(tElement.contents());
+
+ tElement.addClass('_md-button-wrap');
+ }
+
+ tElement[0].setAttribute('tabindex', '-1');
+ tElement.append(itemContainer);
+ }
+
+ function wrapSecondaryItems() {
+ var secondaryItemsWrapper = angular.element('<div class="md-secondary-container">');
+
+ angular.forEach(secondaryItems, function(secondaryItem) {
+ wrapSecondaryItem(secondaryItem, secondaryItemsWrapper);
+ });
+
+ itemContainer.append(secondaryItemsWrapper);
+ }
+
+ /**
+ * @param {HTMLElement} secondaryItem
+ * @param {HTMLDivElement} container
+ */
+ function wrapSecondaryItem(secondaryItem, container) {
+ // If the current secondary item is not a button, but contains a ng-click attribute,
+ // the secondary item will be automatically wrapped inside of a button.
+ if (secondaryItem && !isButton(secondaryItem) && secondaryItem.hasAttribute('ng-click')) {
+
+ $mdAria.expect(secondaryItem, 'aria-label');
+ var buttonWrapper = angular.element('<md-button class="md-secondary md-icon-button">');
+
+ // Move the attributes from the secondary item to the generated button.
+ // We also support some additional attributes from the secondary item,
+ // because some developers may use a ngIf, ngHide, ngShow on their item.
+ moveAttributes(secondaryItem, buttonWrapper[0], ['ng-if', 'ng-hide', 'ng-show']);
+
+ secondaryItem.setAttribute('tabindex', '-1');
+ buttonWrapper.append(secondaryItem);
+
+ secondaryItem = buttonWrapper[0];
+ }
+
+ if (secondaryItem &&
+ (!hasClickEvent(secondaryItem) ||
+ (!tAttrs.ngClick && isProxiedElement(secondaryItem)))) {
+ // In this case we remove the secondary class, so we can identify it later, when searching
+ // for the proxy items.
+ angular.element(secondaryItem).removeClass('md-secondary');
+ }
+
+ tElement.addClass('md-with-secondary');
+ container.append(secondaryItem);
+ }
+
+ /**
+ * Moves attributes from a source element to the destination element.
+ * By default, the function will copy the most necessary attributes, supported
+ * by the button executor for clickable list items.
+ * @param {Element} source Element with the specified attributes
+ * @param {Element} destination Element which will receive the attributes
+ * @param {string|string[]} extraAttrs Additional attributes, which will be moved over
+ */
+ function moveAttributes(source, destination, extraAttrs) {
+ var copiedAttrs = $mdUtil.prefixer([
+ 'ng-if', 'ng-click', 'ng-dblclick', 'aria-label', 'ng-disabled', 'ui-sref',
+ 'href', 'ng-href', 'rel', 'target', 'ng-attr-ui-sref', 'ui-sref-opts', 'download'
+ ]);
+
+ if (extraAttrs) {
+ copiedAttrs = copiedAttrs.concat($mdUtil.prefixer(extraAttrs));
+ }
+
+ angular.forEach(copiedAttrs, function(attr) {
+ if (source.hasAttribute(attr)) {
+ destination.setAttribute(attr, source.getAttribute(attr));
+ source.removeAttribute(attr);
+ }
+ });
+ }
+
+ /**
+ * @param {HTMLElement} element
+ * @return {boolean} true if the element has one of the proxied tags, false otherwise
+ */
+ function isProxiedElement(element) {
+ return proxiedTypes.indexOf(element.nodeName.toLowerCase()) !== -1;
+ }
+
+ /**
+ * @param {HTMLElement} element
+ * @return {boolean} true if the element is a button or md-button, false otherwise
+ */
+ function isButton(element) {
+ var nodeName = element.nodeName.toUpperCase();
+
+ return nodeName === "MD-BUTTON" || nodeName === "BUTTON";
+ }
+
+ /**
+ * @param {Element} element
+ * @return {boolean} true if the element has an ng-click attribute, false otherwise
+ */
+ function hasClickEvent(element) {
+ var attr = element.attributes;
+ for (var i = 0; i < attr.length; i++) {
+ if (tAttrs.$normalize(attr[i].name) === 'ngClick') {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ return postLink;
+
+ function postLink($scope, $element, $attr, ctrl) {
+ $element.addClass('_md'); // private md component indicator for styling
+
+ var proxies = [],
+ firstElement = $element[0].firstElementChild,
+ isButtonWrap = $element.hasClass('_md-button-wrap'),
+ clickChild = isButtonWrap ? firstElement.firstElementChild : firstElement,
+ hasClick = clickChild && hasClickEvent(clickChild),
+ noProxies = $element.hasClass('md-no-proxy');
+
+ computeProxies();
+ computeClickable();
+
+ if (proxies.length) {
+ angular.forEach(proxies, function(proxy) {
+ proxy = angular.element(proxy);
+
+ $scope.mouseActive = false;
+ proxy.on('mousedown', function() {
+ $scope.mouseActive = true;
+ $timeout(function() {
+ $scope.mouseActive = false;
+ }, 100);
+ })
+ .on('focus', function() {
+ if ($scope.mouseActive === false) { $element.addClass('md-focused'); }
+ proxy.on('blur', function proxyOnBlur() {
+ $element.removeClass('md-focused');
+ proxy.off('blur', proxyOnBlur);
+ });
+ });
+ });
+ }
+
+ function computeProxies() {
+ if (firstElement && firstElement.children && !hasClick && !noProxies) {
+
+ angular.forEach(proxiedTypes, function(type) {
+ // All elements which are not capable of being used as a proxy have the .md-secondary
+ // class applied. These items were identified in the secondary wrap function.
+ angular.forEach(firstElement.querySelectorAll(type + ':not(.md-secondary)'), function(child) {
+ proxies.push(child);
+ });
+ });
+ }
+ }
+
+ function computeClickable() {
+ if (proxies.length === 1 || hasClick) {
+ $element.addClass('md-clickable');
+
+ if (!hasClick) {
+ ctrl.attachRipple($scope, angular.element($element[0].querySelector('.md-no-style')));
+ }
+ }
+ }
+
+ /**
+ * @param {MouseEvent} event
+ * @return {boolean}
+ */
+ function isEventFromControl(event) {
+ var forbiddenControls = ['md-slider'];
+ var eventBubblePath = $mdUtil.getEventPath(event);
+
+ // If there is no bubble path, then the event was not bubbled.
+ if (!eventBubblePath || eventBubblePath.length === 0) {
+ return forbiddenControls.indexOf(event.target.tagName.toLowerCase()) !== -1;
+ }
+
+ // We iterate the event bubble path up and check for a possible component.
+ // Our maximum index to search, is the list item root.
+ var maxPath = eventBubblePath.indexOf($element.children()[0]);
+
+ for (var i = 0; i < maxPath; i++) {
+ if (forbiddenControls.indexOf(eventBubblePath[i].tagName.toLowerCase()) !== -1) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @param {KeyboardEvent} keypressEvent
+ */
+ var clickChildKeypressListener = function(keypressEvent) {
+ if (keypressEvent.target.nodeName !== 'INPUT' &&
+ keypressEvent.target.nodeName !== 'TEXTAREA' &&
+ !keypressEvent.target.isContentEditable) {
+ var keyCode = keypressEvent.which || keypressEvent.keyCode;
+ if (keyCode === $mdConstant.KEY_CODE.SPACE) {
+ if (clickChild) {
+ clickChild.click();
+ keypressEvent.preventDefault();
+ keypressEvent.stopPropagation();
+ }
+ }
+ }
+ };
+
+ if (!hasClick && !proxies.length) {
+ clickChild && clickChild.addEventListener('keypress', clickChildKeypressListener);
+ }
+
+ $element.off('click');
+ $element.off('keypress');
+ // Disable ng-aria's "helpful" keydown event that causes our ng-click handlers to be called
+ // twice.
+ $element.off('keydown');
+
+ if (proxies.length === 1 && clickChild) {
+ $element.children().eq(0).on('click', function(clickEvent) {
+ // When the event is coming from a control and it should not trigger the proxied element
+ // then we are skipping.
+ if (isEventFromControl(clickEvent)) return;
+
+ var parentButton = $mdUtil.getClosest(clickEvent.target, 'BUTTON');
+ if (!parentButton && clickChild.contains(clickEvent.target)) {
+ angular.forEach(proxies, function(proxy) {
+ if (clickEvent.target !== proxy && !proxy.contains(clickEvent.target)) {
+ if (proxy.nodeName === 'MD-MENU') {
+ proxy = proxy.children[0];
+ }
+ angular.element(proxy).triggerHandler('click');
+ }
+ });
+ }
+ });
+ }
+
+ $scope.$on('$destroy', function () {
+ clickChild && clickChild.removeEventListener('keypress', clickChildKeypressListener);
+ });
+ }
+ }
+ };
+}
+
+/*
+ * @private
+ * @ngdoc controller
+ * @name MdListController
+ * @module material.components.list
+ */
+function MdListController($scope, $element, $mdListInkRipple) {
+ var ctrl = this;
+ ctrl.attachRipple = attachRipple;
+
+ function attachRipple (scope, element) {
+ var options = {};
+ $mdListInkRipple.attach(scope, element, options);
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.menu
+ */
+
+angular.module('material.components.menu', [
+ 'material.core',
+ 'material.components.backdrop'
+]);
+
+})();
+(function(){
+"use strict";
+
+
+
+MenuController.$inject = ["$mdMenu", "$attrs", "$element", "$scope", "$mdUtil", "$timeout", "$rootScope", "$q", "$log"];
+angular
+ .module('material.components.menu')
+ .controller('mdMenuCtrl', MenuController);
+
+/**
+ * @ngInject
+ */
+function MenuController($mdMenu, $attrs, $element, $scope, $mdUtil, $timeout, $rootScope, $q, $log) {
+
+ var prefixer = $mdUtil.prefixer();
+ var menuContainer;
+ var self = this;
+ var triggerElement;
+
+ this.nestLevel = parseInt($attrs.mdNestLevel, 10) || 0;
+
+ /**
+ * Called by our linking fn to provide access to the menu-content
+ * element removed during link
+ */
+ this.init = function init(setMenuContainer, opts) {
+ opts = opts || {};
+ menuContainer = setMenuContainer;
+
+ // Default element for ARIA attributes has the ngClick or ngMouseenter expression
+ triggerElement = $element[0].querySelector(prefixer.buildSelector(['ng-click', 'ng-mouseenter']));
+ triggerElement.setAttribute('aria-expanded', 'false');
+
+ this.isInMenuBar = opts.isInMenuBar;
+ this.mdMenuBarCtrl = opts.mdMenuBarCtrl;
+ this.nestedMenus = $mdUtil.nodesToArray(menuContainer[0].querySelectorAll('.md-nested-menu'));
+
+ menuContainer.on('$mdInterimElementRemove', function() {
+ self.isOpen = false;
+ $mdUtil.nextTick(function(){ self.onIsOpenChanged(self.isOpen);});
+ });
+ $mdUtil.nextTick(function(){ self.onIsOpenChanged(self.isOpen);});
+
+ var menuContainerId = 'menu_container_' + $mdUtil.nextUid();
+ menuContainer.attr('id', menuContainerId);
+ angular.element(triggerElement).attr({
+ 'aria-owns': menuContainerId,
+ 'aria-haspopup': 'true'
+ });
+
+ $scope.$on('$destroy', angular.bind(this, function() {
+ this.disableHoverListener();
+ $mdMenu.destroy();
+ }));
+
+ menuContainer.on('$destroy', function() {
+ $mdMenu.destroy();
+ });
+ };
+
+ var openMenuTimeout, menuItems, deregisterScopeListeners = [];
+ this.enableHoverListener = function() {
+ deregisterScopeListeners.push($rootScope.$on('$mdMenuOpen', function(event, el) {
+ if (menuContainer[0].contains(el[0])) {
+ self.currentlyOpenMenu = el.controller('mdMenu');
+ self.isAlreadyOpening = false;
+ self.currentlyOpenMenu.registerContainerProxy(self.triggerContainerProxy.bind(self));
+ }
+ }));
+ deregisterScopeListeners.push($rootScope.$on('$mdMenuClose', function(event, el) {
+ if (menuContainer[0].contains(el[0])) {
+ self.currentlyOpenMenu = undefined;
+ }
+ }));
+ menuItems = angular.element($mdUtil.nodesToArray(menuContainer[0].children[0].children));
+ menuItems.on('mouseenter', self.handleMenuItemHover);
+ menuItems.on('mouseleave', self.handleMenuItemMouseLeave);
+ };
+
+ this.disableHoverListener = function() {
+ while (deregisterScopeListeners.length) {
+ deregisterScopeListeners.shift()();
+ }
+ menuItems && menuItems.off('mouseenter', self.handleMenuItemHover);
+ menuItems && menuItems.off('mouseleave', self.handleMenuItemMouseLeave);
+ };
+
+ this.handleMenuItemHover = function(event) {
+ if (self.isAlreadyOpening) return;
+ var nestedMenu = (
+ event.target.querySelector('md-menu')
+ || $mdUtil.getClosest(event.target, 'MD-MENU')
+ );
+ openMenuTimeout = $timeout(function() {
+ if (nestedMenu) {
+ nestedMenu = angular.element(nestedMenu).controller('mdMenu');
+ }
+
+ if (self.currentlyOpenMenu && self.currentlyOpenMenu != nestedMenu) {
+ var closeTo = self.nestLevel + 1;
+ self.currentlyOpenMenu.close(true, { closeTo: closeTo });
+ self.isAlreadyOpening = !!nestedMenu;
+ nestedMenu && nestedMenu.open();
+ } else if (nestedMenu && !nestedMenu.isOpen && nestedMenu.open) {
+ self.isAlreadyOpening = !!nestedMenu;
+ nestedMenu && nestedMenu.open();
+ }
+ }, nestedMenu ? 100 : 250);
+ var focusableTarget = event.currentTarget.querySelector('.md-button:not([disabled])');
+ focusableTarget && focusableTarget.focus();
+ };
+
+ this.handleMenuItemMouseLeave = function() {
+ if (openMenuTimeout) {
+ $timeout.cancel(openMenuTimeout);
+ openMenuTimeout = undefined;
+ }
+ };
+
+
+ /**
+ * Uses the $mdMenu interim element service to open the menu contents
+ */
+ this.open = function openMenu(ev) {
+ ev && ev.stopPropagation();
+ ev && ev.preventDefault();
+ if (self.isOpen) return;
+ self.enableHoverListener();
+ self.isOpen = true;
+ $mdUtil.nextTick(function(){ self.onIsOpenChanged(self.isOpen);});
+ triggerElement = triggerElement || (ev ? ev.target : $element[0]);
+ triggerElement.setAttribute('aria-expanded', 'true');
+ $scope.$emit('$mdMenuOpen', $element);
+ $mdMenu.show({
+ scope: $scope,
+ mdMenuCtrl: self,
+ nestLevel: self.nestLevel,
+ element: menuContainer,
+ target: triggerElement,
+ preserveElement: true,
+ parent: 'body'
+ }).finally(function() {
+ triggerElement.setAttribute('aria-expanded', 'false');
+ self.disableHoverListener();
+ });
+ };
+
+ this.onIsOpenChanged = function(isOpen) {
+ if (isOpen) {
+ menuContainer.attr('aria-hidden', 'false');
+ $element[0].classList.add('md-open');
+ angular.forEach(self.nestedMenus, function(el) {
+ el.classList.remove('md-open');
+ });
+ } else {
+ menuContainer.attr('aria-hidden', 'true');
+ $element[0].classList.remove('md-open');
+ }
+ $scope.$mdMenuIsOpen = self.isOpen;
+ };
+
+ this.focusMenuContainer = function focusMenuContainer() {
+ var focusTarget = menuContainer[0]
+ .querySelector(prefixer.buildSelector(['md-menu-focus-target', 'md-autofocus']));
+
+ if (!focusTarget) focusTarget = menuContainer[0].querySelector('.md-button:not([disabled])');
+ focusTarget.focus();
+ };
+
+ this.registerContainerProxy = function registerContainerProxy(handler) {
+ this.containerProxy = handler;
+ };
+
+ this.triggerContainerProxy = function triggerContainerProxy(ev) {
+ this.containerProxy && this.containerProxy(ev);
+ };
+
+ this.destroy = function() {
+ return self.isOpen ? $mdMenu.destroy() : $q.when(false);
+ };
+
+ // Use the $mdMenu interim element service to close the menu contents
+ this.close = function closeMenu(skipFocus, closeOpts) {
+ if (!self.isOpen) return;
+ self.isOpen = false;
+ $mdUtil.nextTick(function(){ self.onIsOpenChanged(self.isOpen);});
+
+ var eventDetails = angular.extend({}, closeOpts, { skipFocus: skipFocus });
+ $scope.$emit('$mdMenuClose', $element, eventDetails);
+ $mdMenu.hide(null, closeOpts);
+
+ if (!skipFocus) {
+ var el = self.restoreFocusTo || $element.find('button')[0];
+ if (el instanceof angular.element) el = el[0];
+ if (el) el.focus();
+ }
+ };
+
+ /**
+ * Build a nice object out of our string attribute which specifies the
+ * target mode for left and top positioning
+ */
+ this.positionMode = function positionMode() {
+ var attachment = ($attrs.mdPositionMode || 'target').split(' ');
+
+ // If attachment is a single item, duplicate it for our second value.
+ // ie. 'target' -> 'target target'
+ if (attachment.length === 1) {
+ attachment.push(attachment[0]);
+ }
+
+ return {
+ left: attachment[0],
+ top: attachment[1]
+ };
+ };
+
+ /**
+ * Build a nice object out of our string attribute which specifies
+ * the offset of top and left in pixels.
+ */
+ this.offsets = function offsets() {
+ var position = ($attrs.mdOffset || '0 0').split(' ').map(parseFloat);
+ if (position.length === 2) {
+ return {
+ left: position[0],
+ top: position[1]
+ };
+ } else if (position.length === 1) {
+ return {
+ top: position[0],
+ left: position[0]
+ };
+ } else {
+ throw Error('Invalid offsets specified. Please follow format <x, y> or <n>');
+ }
+ };
+
+ // Functionality that is exposed in the view.
+ $scope.$mdMenu = {
+ open: this.open,
+ close: this.close
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc directive
+ * @name mdMenu
+ * @module material.components.menu
+ * @restrict E
+ * @description
+ *
+ * Menus are elements that open when clicked. They are useful for displaying
+ * additional options within the context of an action.
+ *
+ * Every `md-menu` must specify exactly two child elements. The first element is what is
+ * left in the DOM and is used to open the menu. This element is called the trigger element.
+ * The trigger element's scope has access to `$mdMenu.open($event)`
+ * which it may call to open the menu. By passing $event as argument, the
+ * corresponding event is stopped from propagating up the DOM-tree. Similarly, `$mdMenu.close()`
+ * can be used to close the menu.
+ *
+ * The second element is the `md-menu-content` element which represents the
+ * contents of the menu when it is open. Typically this will contain `md-menu-item`s,
+ * but you can do custom content as well.
+ *
+ * <hljs lang="html">
+ * <md-menu>
+ * <!-- Trigger element is a md-button with an icon -->
+ * <md-button ng-click="$mdMenu.open($event)" class="md-icon-button" aria-label="Open sample menu">
+ * <md-icon md-svg-icon="call:phone"></md-icon>
+ * </md-button>
+ * <md-menu-content>
+ * <md-menu-item><md-button ng-click="doSomething()">Do Something</md-button></md-menu-item>
+ * </md-menu-content>
+ * </md-menu>
+ * </hljs>
+
+ * ## Sizing Menus
+ *
+ * The width of the menu when it is open may be specified by specifying a `width`
+ * attribute on the `md-menu-content` element.
+ * See the [Material Design Spec](https://material.io/archive/guidelines/components/menus.html#menus-simple-menus)
+ * for more information.
+ *
+ * ## Menu Density
+ *
+ * You can use dense menus by adding the `md-dense` class to the `md-menu-content` element.
+ * This reduces the height of menu items, their top and bottom padding, and default font size.
+ * Without the `md-dense` class, we use the "mobile" height of `48px`. With the `md-dense` class,
+ * we use the "desktop" height of `32px`. We do not support the "dense desktop" option in the spec,
+ * which uses a height of `24px`, at this time.
+ * See the [Menu Specs](https://material.io/archive/guidelines/components/menus.html#menus-specs)
+ * section of the Material Design Spec for more information.
+ *
+ * ## Aligning Menus
+ *
+ * When a menu opens, it is important that the content aligns with the trigger element.
+ * Failure to align menus can result in jarring experiences for users as content
+ * suddenly shifts. To help with this, `md-menu` provides several APIs to help
+ * with alignment.
+ *
+ * ### Target Mode
+ *
+ * By default, `md-menu` will attempt to align the `md-menu-content` by aligning
+ * designated child elements in both the trigger and the menu content.
+ *
+ * To specify the alignment element in the `trigger` you can use the `md-menu-origin`
+ * attribute on a child element. If no `md-menu-origin` is specified, the `md-menu`
+ * will be used as the origin element.
+ *
+ * Similarly, the `md-menu-content` may specify a `md-menu-align-target` for a
+ * `md-menu-item` to specify the node that it should try and align with.
+ *
+ * In this example code, we specify an icon to be our origin element, and an
+ * icon in our menu content to be our alignment target. This ensures that both
+ * icons are aligned when the menu opens.
+ *
+ * <hljs lang="html">
+ * <md-menu>
+ * <md-button ng-click="$mdMenu.open($event)" class="md-icon-button" aria-label="Open some menu">
+ * <md-icon md-menu-origin md-svg-icon="call:phone"></md-icon>
+ * </md-button>
+ * <md-menu-content>
+ * <md-menu-item>
+ * <md-button ng-click="doSomething()" aria-label="Do something">
+ * <md-icon md-menu-align-target md-svg-icon="call:phone"></md-icon>
+ * Do Something
+ * </md-button>
+ * </md-menu-item>
+ * </md-menu-content>
+ * </md-menu>
+ * </hljs>
+ *
+ * ### Position Mode
+ *
+ * We can specify the origin of the menu by using the `md-position-mode` attribute.
+ * This attribute allows specifying the positioning by the `x` and `y` axes.
+ *
+ * The default mode is `target target`. This mode uses the left and top edges of the origin element
+ * to position the menu in LTR layouts. The `x` axis modes will adjust when in RTL layouts.
+ *
+ * Sometimes you want to specify alignment from the right side of a origin element. For example,
+ * if we have a menu on the right side a toolbar, we may want to right align our menu content.
+ * We can use `target-right target` to specify a right-oriented alignment target.
+ * There is a working example of this in the Menu Position Modes demo.
+ *
+ * #### Horizontal Positioning Options
+ * - `target`
+ * - `target-left`
+ * - `target-right`
+ * - `cascade`
+ * - `right`
+ * - `left`
+ *
+ * #### Vertical Positioning Options
+ * - `target`
+ * - `cascade`
+ * - `bottom`
+ *
+ * ### Menu Offsets
+ *
+ * It is sometimes unavoidable to need to have a deeper level of control for
+ * the positioning of a menu to ensure perfect alignment. `md-menu` provides
+ * the `md-offset` attribute to allow pixel-level specificity when adjusting
+ * menu positioning.
+ *
+ * This offset is provided in the format of `x y` or `n` where `n` will be used
+ * in both the `x` and `y` axis.
+ * For example, to move a menu by `2px` down from the top, we can use:
+ *
+ * <hljs lang="html">
+ * <md-menu md-offset="0 2">
+ * <!-- menu-content -->
+ * </md-menu>
+ * </hljs>
+ *
+ * Specifying `md-offset="2 2"` would shift the menu two pixels down and two pixels to the right.
+ *
+ * ### Auto Focus
+ * By default, when a menu opens, `md-menu` focuses the first button in the menu content.
+ *
+ * Sometimes you would like to focus another menu item instead of the first.<br/>
+ * This can be done by applying the `md-autofocus` directive on the given element.
+ *
+ * <hljs lang="html">
+ * <md-menu-item>
+ * <md-button md-autofocus ng-click="doSomething()">
+ * Auto Focus
+ * </md-button>
+ * </md-menu-item>
+ * </hljs>
+ *
+ *
+ * ### Preventing close
+ *
+ * Sometimes you would like to be able to click on a menu item without having the menu
+ * close. To do this, AngularJS Material exposes the `md-prevent-menu-close` attribute which
+ * can be added to a button inside a menu to stop the menu from automatically closing.
+ * You can then close the menu either by using `$mdMenu.close()` in the template,
+ * or programmatically by injecting `$mdMenu` and calling `$mdMenu.hide()`.
+ *
+ * <hljs lang="html">
+ * <md-menu-content ng-mouseleave="$mdMenu.close()">
+ * <md-menu-item>
+ * <md-button ng-click="doSomething()" aria-label="Do something" md-prevent-menu-close="md-prevent-menu-close">
+ * <md-icon md-menu-align-target md-svg-icon="call:phone"></md-icon>
+ * Do Something
+ * </md-button>
+ * </md-menu-item>
+ * </md-menu-content>
+ * </hljs>
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-menu>
+ * <md-button ng-click="$mdMenu.open($event)" class="md-icon-button">
+ * <md-icon md-svg-icon="call:phone"></md-icon>
+ * </md-button>
+ * <md-menu-content>
+ * <md-menu-item><md-button ng-click="doSomething()">Do Something</md-button></md-menu-item>
+ * </md-menu-content>
+ * </md-menu>
+ * </hljs>
+ *
+ * @param {string=} md-position-mode Specify pre-defined position modes for the `x` and `y` axes.
+ * The default modes are `target target`. This positions the origin of the menu using the left and top edges
+ * of the origin element in LTR layouts.<br>
+ * #### Valid modes for horizontal positioning
+ * - `target`
+ * - `target-left`
+ * - `target-right`
+ * - `cascade`
+ * - `right`
+ * - `left`<br>
+ * #### Valid modes for vertical positioning
+ * - `target`
+ * - `cascade`
+ * - `bottom`
+ * @param {string=} md-offset An offset to apply to the dropdown on opening, after positioning.
+ * Defined as `x` and `y` pixel offset values in the form of `x y`.<br>
+ * The default value is `0 0`.
+ */
+MenuDirective.$inject = ["$mdUtil"];
+angular
+ .module('material.components.menu')
+ .directive('mdMenu', MenuDirective);
+
+/**
+ * @ngInject
+ */
+function MenuDirective($mdUtil) {
+ var INVALID_PREFIX = 'Invalid HTML for md-menu: ';
+ return {
+ restrict: 'E',
+ require: ['mdMenu', '?^mdMenuBar'],
+ controller: 'mdMenuCtrl', // empty function to be built by link
+ scope: true,
+ compile: compile
+ };
+
+ function compile(templateElement) {
+ templateElement.addClass('md-menu');
+
+ var triggerEl = templateElement.children()[0];
+ var prefixer = $mdUtil.prefixer();
+
+ if (!prefixer.hasAttribute(triggerEl, 'ng-click')) {
+ triggerEl = triggerEl
+ .querySelector(prefixer.buildSelector(['ng-click', 'ng-mouseenter'])) || triggerEl;
+ }
+
+ var isButtonTrigger = triggerEl.nodeName === 'MD-BUTTON' || triggerEl.nodeName === 'BUTTON';
+
+ if (triggerEl && isButtonTrigger && !triggerEl.hasAttribute('type')) {
+ triggerEl.setAttribute('type', 'button');
+ }
+
+ if (!triggerEl) {
+ throw Error(INVALID_PREFIX + 'Expected the menu to have a trigger element.');
+ }
+
+ if (templateElement.children().length !== 2) {
+ throw Error(INVALID_PREFIX + 'Expected two children elements. The second element must have a `md-menu-content` element.');
+ }
+
+ // Default element for ARIA attributes has the ngClick or ngMouseenter expression
+ triggerEl && triggerEl.setAttribute('aria-haspopup', 'true');
+
+ var nestedMenus = templateElement[0].querySelectorAll('md-menu');
+ var nestingDepth = parseInt(templateElement[0].getAttribute('md-nest-level'), 10) || 0;
+ if (nestedMenus) {
+ angular.forEach($mdUtil.nodesToArray(nestedMenus), function(menuEl) {
+ if (!menuEl.hasAttribute('md-position-mode')) {
+ menuEl.setAttribute('md-position-mode', 'cascade');
+ }
+ menuEl.classList.add('_md-nested-menu');
+ menuEl.setAttribute('md-nest-level', nestingDepth + 1);
+ });
+ }
+ return link;
+ }
+
+ function link(scope, element, attr, ctrls) {
+ var mdMenuCtrl = ctrls[0];
+ var isInMenuBar = !!ctrls[1];
+ var mdMenuBarCtrl = ctrls[1];
+ // Move everything into a md-menu-container and pass it to the controller
+ var menuContainer = angular.element('<div class="_md md-open-menu-container md-whiteframe-z2"></div>');
+ var menuContents = element.children()[1];
+
+ element.addClass('_md'); // private md component indicator for styling
+
+ if (!menuContents.hasAttribute('role')) {
+ menuContents.setAttribute('role', 'menu');
+ }
+ menuContainer.append(menuContents);
+
+ element.on('$destroy', function() {
+ menuContainer.remove();
+ });
+
+ element.append(menuContainer);
+ menuContainer[0].style.display = 'none';
+ mdMenuCtrl.init(menuContainer, { isInMenuBar: isInMenuBar, mdMenuBarCtrl: mdMenuBarCtrl });
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+
+MenuProvider.$inject = ["$$interimElementProvider"];angular
+ .module('material.components.menu')
+ .provider('$mdMenu', MenuProvider);
+
+/**
+ * Interim element provider for the menu.
+ * Handles behavior for a menu while it is open, including:
+ * - handling animating the menu opening/closing
+ * - handling key/mouse events on the menu element
+ * - handling enabling/disabling scroll while the menu is open
+ * - handling redrawing during resizes and orientation changes
+ *
+ */
+
+function MenuProvider($$interimElementProvider) {
+ menuDefaultOptions.$inject = ["$mdUtil", "$mdTheming", "$mdConstant", "$document", "$window", "$q", "$$rAF", "$animateCss", "$animate", "$log"];
+ var MENU_EDGE_MARGIN = 8;
+
+ return $$interimElementProvider('$mdMenu')
+ .setDefaults({
+ methods: ['target'],
+ options: menuDefaultOptions
+ });
+
+ /* @ngInject */
+ function menuDefaultOptions($mdUtil, $mdTheming, $mdConstant, $document, $window, $q, $$rAF,
+ $animateCss, $animate, $log) {
+
+ var prefixer = $mdUtil.prefixer();
+ var animator = $mdUtil.dom.animator;
+
+ return {
+ parent: 'body',
+ onShow: onShow,
+ onRemove: onRemove,
+ hasBackdrop: true,
+ disableParentScroll: true,
+ skipCompile: true,
+ preserveScope: true,
+ multiple: true,
+ themable: true
+ };
+
+ /**
+ * Show modal backdrop element...
+ * @returns {function(): void} A function that removes this backdrop
+ */
+ function showBackdrop(scope, element, options) {
+ if (options.nestLevel) return angular.noop;
+
+ // If we are not within a dialog...
+ if (options.disableParentScroll && !$mdUtil.getClosest(options.target, 'MD-DIALOG')) {
+ // !! DO this before creating the backdrop; since disableScrollAround()
+ // configures the scroll offset; which is used by mdBackDrop postLink()
+ options.restoreScroll = $mdUtil.disableScrollAround(options.element, options.parent);
+ } else {
+ options.disableParentScroll = false;
+ }
+
+ if (options.hasBackdrop) {
+ options.backdrop = $mdUtil.createBackdrop(scope, "md-menu-backdrop md-click-catcher");
+
+ $animate.enter(options.backdrop, options.backdropParent || $document[0].body);
+ }
+
+ /**
+ * Hide and destroys the backdrop created by showBackdrop()
+ */
+ return function hideBackdrop() {
+ if (options.backdrop) options.backdrop.remove();
+ if (options.disableParentScroll) options.restoreScroll();
+ };
+ }
+
+ /**
+ * Removing the menu element from the DOM and remove all associated event listeners
+ * and backdrop
+ */
+ function onRemove(scope, element, opts) {
+ opts.cleanupInteraction();
+ opts.cleanupBackdrop();
+ opts.cleanupResizing();
+ opts.hideBackdrop();
+
+ // Before the menu is closing remove the clickable class.
+ element.removeClass('md-clickable');
+
+ // For navigation $destroy events, do a quick, non-animated removal,
+ // but for normal closes (from clicks, etc) animate the removal
+
+ return (opts.$destroy === true) ? detachAndClean() : animateRemoval().then(detachAndClean);
+
+ /**
+ * For normal closes, animate the removal.
+ * For forced closes (like $destroy events), skip the animations
+ */
+ function animateRemoval() {
+ return $animateCss(element, {addClass: 'md-leave'}).start();
+ }
+
+ /**
+ * Detach the element
+ */
+ function detachAndClean() {
+ element.removeClass('md-active');
+ detachElement(element, opts);
+ opts.alreadyOpen = false;
+ }
+
+ }
+
+ /**
+ * Inserts and configures the staged Menu element into the DOM, positioning it,
+ * and wiring up various interaction events
+ */
+ function onShow(scope, element, opts) {
+ sanitizeAndConfigure(opts);
+
+ if (opts.menuContentEl[0]) {
+ // Inherit the theme from the target element.
+ $mdTheming.inherit(opts.menuContentEl, opts.target);
+ } else {
+ $log.warn(
+ '$mdMenu: Menu elements should always contain a `md-menu-content` element,' +
+ 'otherwise interactivity features will not work properly.',
+ element
+ );
+ }
+
+ // Register various listeners to move menu on resize/orientation change
+ opts.cleanupResizing = startRepositioningOnResize();
+ opts.hideBackdrop = showBackdrop(scope, element, opts);
+
+ // Return the promise for when our menu is done animating in
+ return showMenu()
+ .then(function(response) {
+ opts.alreadyOpen = true;
+ opts.cleanupInteraction = activateInteraction();
+ opts.cleanupBackdrop = setupBackdrop();
+
+ // Since the menu finished its animation, mark the menu as clickable.
+ element.addClass('md-clickable');
+
+ return response;
+ });
+
+ /**
+ * Place the menu into the DOM and call positioning related functions
+ */
+ function showMenu() {
+ opts.parent.append(element);
+ element[0].style.display = '';
+
+ return $q(function(resolve) {
+ var position = calculateMenuPosition(element, opts);
+
+ element.removeClass('md-leave');
+
+ // Animate the menu scaling, and opacity [from its position origin (default == top-left)]
+ // to normal scale.
+ $animateCss(element, {
+ addClass: 'md-active',
+ from: animator.toCss(position),
+ to: animator.toCss({transform: ''})
+ })
+ .start()
+ .then(resolve);
+
+ });
+ }
+
+ /**
+ * Check for valid opts and set some useful defaults
+ */
+ function sanitizeAndConfigure() {
+ if (!opts.target) {
+ throw Error(
+ '$mdMenu.show() expected a target to animate from in options.target'
+ );
+ }
+ angular.extend(opts, {
+ alreadyOpen: false,
+ isRemoved: false,
+ target: angular.element(opts.target), // make sure it's not a naked DOM node
+ parent: angular.element(opts.parent),
+ menuContentEl: angular.element(element[0].querySelector('md-menu-content'))
+ });
+ }
+
+ /**
+ * Configure various resize listeners for screen changes
+ */
+ function startRepositioningOnResize() {
+
+ var repositionMenu = (function(target, options) {
+ return $$rAF.throttle(function() {
+ if (opts.isRemoved) return;
+ var position = calculateMenuPosition(target, options);
+
+ target.css(animator.toCss(position));
+ });
+ })(element, opts);
+
+ $window.addEventListener('resize', repositionMenu);
+ $window.addEventListener('orientationchange', repositionMenu);
+
+ return function stopRepositioningOnResize() {
+
+ // Disable resizing handlers
+ $window.removeEventListener('resize', repositionMenu);
+ $window.removeEventListener('orientationchange', repositionMenu);
+
+ };
+ }
+
+ /**
+ * Sets up the backdrop and listens for click elements.
+ * Once the backdrop will be clicked, the menu will automatically close.
+ * @returns {!Function} Function to remove the backdrop.
+ */
+ function setupBackdrop() {
+ if (!opts.backdrop) return angular.noop;
+
+ opts.backdrop.on('click', onBackdropClick);
+
+ return function() {
+ opts.backdrop.off('click', onBackdropClick);
+ };
+ }
+
+ /**
+ * Function to be called whenever the backdrop is clicked.
+ * @param {!MouseEvent} event
+ */
+ function onBackdropClick(event) {
+ event.preventDefault();
+ event.stopPropagation();
+
+ scope.$apply(function() {
+ opts.mdMenuCtrl.close(true, { closeAll: true });
+ });
+ }
+
+ /**
+ * Activate interaction on the menu. Resolves the focus target and closes the menu on
+ * escape or option click.
+ * @returns {!Function} Function to deactivate the interaction listeners.
+ */
+ function activateInteraction() {
+ if (!opts.menuContentEl[0]) return angular.noop;
+
+ // Wire up keyboard listeners.
+ // - Close on escape,
+ // - focus next item on down arrow,
+ // - focus prev item on up
+ opts.menuContentEl.on('keydown', onMenuKeyDown);
+ opts.menuContentEl[0].addEventListener('click', captureClickListener, true);
+
+ // kick off initial focus in the menu on the first enabled element
+ var focusTarget = opts.menuContentEl[0]
+ .querySelector(prefixer.buildSelector(['md-menu-focus-target', 'md-autofocus']));
+
+ if (!focusTarget) {
+ var childrenLen = opts.menuContentEl[0].children.length;
+ for (var childIndex = 0; childIndex < childrenLen; childIndex++) {
+ var child = opts.menuContentEl[0].children[childIndex];
+ focusTarget = child.querySelector('.md-button:not([disabled])');
+ if (focusTarget) {
+ break;
+ }
+ // Need to check the attribute as well since this might be a custom element whose
+ // disabled property is undefined.
+ if (child.firstElementChild && !child.firstElementChild.disabled &&
+ !child.firstElementChild.getAttribute('disabled')) {
+ focusTarget = child.firstElementChild;
+ break;
+ }
+ }
+ }
+
+ focusTarget && focusTarget.focus();
+
+ return function cleanupInteraction() {
+ opts.menuContentEl.off('keydown', onMenuKeyDown);
+ opts.menuContentEl[0].removeEventListener('click', captureClickListener, true);
+ };
+
+ // ************************************
+ // internal functions
+ // ************************************
+
+ function onMenuKeyDown(ev) {
+ var handled;
+ switch (ev.keyCode) {
+ case $mdConstant.KEY_CODE.ESCAPE:
+ if (opts.nestLevel) {
+ opts.mdMenuCtrl.close();
+ } else {
+ opts.mdMenuCtrl.close(false, { closeAll: true });
+ }
+ handled = true;
+ break;
+ case $mdConstant.KEY_CODE.TAB:
+ opts.mdMenuCtrl.close(false, { closeAll: true });
+ // Don't prevent default or stop propagation on this event as we want tab
+ // to move the focus to the next focusable element on the page.
+ handled = false;
+ break;
+ case $mdConstant.KEY_CODE.UP_ARROW:
+ if (!focusMenuItem(ev, opts.menuContentEl, opts, -1) && !opts.nestLevel) {
+ opts.mdMenuCtrl.triggerContainerProxy(ev);
+ }
+ handled = true;
+ break;
+ case $mdConstant.KEY_CODE.DOWN_ARROW:
+ if (!focusMenuItem(ev, opts.menuContentEl, opts, 1) && !opts.nestLevel) {
+ opts.mdMenuCtrl.triggerContainerProxy(ev);
+ }
+ handled = true;
+ break;
+ case $mdConstant.KEY_CODE.LEFT_ARROW:
+ if (opts.nestLevel) {
+ opts.mdMenuCtrl.close();
+ } else {
+ opts.mdMenuCtrl.triggerContainerProxy(ev);
+ }
+ handled = true;
+ break;
+ case $mdConstant.KEY_CODE.RIGHT_ARROW:
+ var parentMenu = $mdUtil.getClosest(ev.target, 'MD-MENU');
+ if (parentMenu && parentMenu != opts.parent[0]) {
+ ev.target.click();
+ } else {
+ opts.mdMenuCtrl.triggerContainerProxy(ev);
+ }
+ handled = true;
+ break;
+ }
+ if (handled) {
+ ev.preventDefault();
+ ev.stopImmediatePropagation();
+ }
+ }
+
+ function onBackdropClick(e) {
+ e.preventDefault();
+ e.stopPropagation();
+ scope.$apply(function() {
+ opts.mdMenuCtrl.close(true, { closeAll: true });
+ });
+ }
+
+ // Close menu on menu item click, if said menu-item is not disabled
+ function captureClickListener(e) {
+ var target = e.target;
+ // Traverse up the event until we get to the menuContentEl to see if
+ // there is an ng-click and that the ng-click is not disabled
+ do {
+ if (target == opts.menuContentEl[0]) return;
+ if ((hasAnyAttribute(target, ['ng-click', 'ng-href', 'ui-sref']) ||
+ target.nodeName == 'BUTTON' || target.nodeName == 'MD-BUTTON') && !hasAnyAttribute(target, ['md-prevent-menu-close'])) {
+ var closestMenu = $mdUtil.getClosest(target, 'MD-MENU');
+ if (!target.hasAttribute('disabled') && (!closestMenu || closestMenu == opts.parent[0])) {
+ close();
+ }
+ break;
+ }
+ } while (target = target.parentNode);
+
+ function close() {
+ scope.$apply(function() {
+ opts.mdMenuCtrl.close(true, { closeAll: true });
+ });
+ }
+
+ function hasAnyAttribute(target, attrs) {
+ if (!target) return false;
+
+ for (var i = 0, attr; attr = attrs[i]; ++i) {
+ if (prefixer.hasAttribute(target, attr)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+ }
+
+ }
+ }
+
+ /**
+ * Takes a keypress event and focuses the next/previous menu
+ * item from the emitting element
+ * @param {event} e - The origin keypress event
+ * @param {angular.element} menuEl - The menu element
+ * @param {object} opts - The interim element options for the mdMenu
+ * @param {number} direction - The direction to move in (+1 = next, -1 = prev)
+ */
+ function focusMenuItem(e, menuEl, opts, direction) {
+ var currentItem = $mdUtil.getClosest(e.target, 'MD-MENU-ITEM');
+
+ var items = $mdUtil.nodesToArray(menuEl[0].children);
+ var currentIndex = items.indexOf(currentItem);
+
+ // Traverse through our elements in the specified direction (+/-1) and try to
+ // focus them until we find one that accepts focus
+ var didFocus;
+ for (var i = currentIndex + direction; i >= 0 && i < items.length; i = i + direction) {
+ var focusTarget = items[i].querySelector('.md-button');
+ didFocus = attemptFocus(focusTarget);
+ if (didFocus) {
+ break;
+ }
+ }
+ return didFocus;
+ }
+
+ /**
+ * Attempts to focus an element. Checks whether that element is the currently
+ * focused element after attempting.
+ * @param {HTMLElement} el - the element to attempt focus on
+ * @returns {boolean} - whether the element was successfully focused
+ */
+ function attemptFocus(el) {
+ if (el && el.getAttribute('tabindex') != -1) {
+ el.focus();
+ return ($document[0].activeElement == el);
+ }
+ }
+
+ /**
+ * Use browser to remove this element without triggering a $destroy event
+ */
+ function detachElement(element, opts) {
+ if (!opts.preserveElement) {
+ if (toNode(element).parentNode === toNode(opts.parent)) {
+ toNode(opts.parent).removeChild(toNode(element));
+ }
+ } else {
+ toNode(element).style.display = 'none';
+ }
+ }
+
+ /**
+ * Computes menu position and sets the style on the menu container
+ * @param {HTMLElement} el - the menu container element
+ * @param {object} opts - the interim element options object
+ */
+ function calculateMenuPosition(el, opts) {
+
+ var containerNode = el[0],
+ openMenuNode = el[0].firstElementChild,
+ openMenuNodeRect = openMenuNode.getBoundingClientRect(),
+ boundryNode = $document[0].body,
+ boundryNodeRect = boundryNode.getBoundingClientRect();
+
+ var menuStyle = $window.getComputedStyle(openMenuNode);
+
+ var originNode = opts.target[0].querySelector(prefixer.buildSelector('md-menu-origin')) || opts.target[0],
+ originNodeRect = originNode.getBoundingClientRect();
+
+ var bounds = {
+ left: boundryNodeRect.left + MENU_EDGE_MARGIN,
+ top: Math.max(boundryNodeRect.top, 0) + MENU_EDGE_MARGIN,
+ bottom: Math.max(boundryNodeRect.bottom, Math.max(boundryNodeRect.top, 0) + boundryNodeRect.height) - MENU_EDGE_MARGIN,
+ right: boundryNodeRect.right - MENU_EDGE_MARGIN
+ };
+
+ var alignTarget, alignTargetRect = { top:0, left : 0, right:0, bottom:0 }, existingOffsets = { top:0, left : 0, right:0, bottom:0 };
+ var positionMode = opts.mdMenuCtrl.positionMode();
+
+ if (positionMode.top === 'target' || positionMode.left === 'target' || positionMode.left === 'target-right') {
+ alignTarget = firstVisibleChild();
+ if (alignTarget) {
+ // TODO: Allow centering on an arbitrary node, for now center on first menu-item's child
+ alignTarget = alignTarget.firstElementChild || alignTarget;
+ alignTarget = alignTarget.querySelector(prefixer.buildSelector('md-menu-align-target')) || alignTarget;
+ alignTargetRect = alignTarget.getBoundingClientRect();
+
+ existingOffsets = {
+ top: parseFloat(containerNode.style.top || 0),
+ left: parseFloat(containerNode.style.left || 0)
+ };
+ }
+ }
+
+ var position = {};
+ var transformOrigin = 'top ';
+
+ switch (positionMode.top) {
+ case 'target':
+ position.top = existingOffsets.top + originNodeRect.top - alignTargetRect.top;
+ break;
+ case 'cascade':
+ position.top = originNodeRect.top - parseFloat(menuStyle.paddingTop) - originNode.style.top;
+ break;
+ case 'bottom':
+ position.top = originNodeRect.top + originNodeRect.height;
+ break;
+ default:
+ throw new Error('Invalid target mode "' + positionMode.top + '" specified for md-menu on Y axis.');
+ }
+
+ var rtl = $mdUtil.isRtl(el);
+
+ switch (positionMode.left) {
+ case 'target':
+ position.left = existingOffsets.left + originNodeRect.left - alignTargetRect.left;
+ transformOrigin += rtl ? 'right' : 'left';
+ break;
+ case 'target-left':
+ position.left = originNodeRect.left;
+ transformOrigin += 'left';
+ break;
+ case 'target-right':
+ position.left = originNodeRect.right - openMenuNodeRect.width + (openMenuNodeRect.right - alignTargetRect.right);
+ transformOrigin += 'right';
+ break;
+ case 'cascade':
+ var willFitRight = rtl ? (originNodeRect.left - openMenuNodeRect.width) < bounds.left : (originNodeRect.right + openMenuNodeRect.width) < bounds.right;
+ position.left = willFitRight ? originNodeRect.right - originNode.style.left : originNodeRect.left - originNode.style.left - openMenuNodeRect.width;
+ transformOrigin += willFitRight ? 'left' : 'right';
+ break;
+ case 'right':
+ if (rtl) {
+ position.left = originNodeRect.right - originNodeRect.width;
+ transformOrigin += 'left';
+ } else {
+ position.left = originNodeRect.right - openMenuNodeRect.width;
+ transformOrigin += 'right';
+ }
+ break;
+ case 'left':
+ if (rtl) {
+ position.left = originNodeRect.right - openMenuNodeRect.width;
+ transformOrigin += 'right';
+ } else {
+ position.left = originNodeRect.left;
+ transformOrigin += 'left';
+ }
+ break;
+ default:
+ throw new Error('Invalid target mode "' + positionMode.left + '" specified for md-menu on X axis.');
+ }
+
+ var offsets = opts.mdMenuCtrl.offsets();
+ position.top += offsets.top;
+ position.left += offsets.left;
+
+ clamp(position);
+
+ var scaleX = Math.round(100 * Math.min(originNodeRect.width / containerNode.offsetWidth, 1.0)) / 100;
+ var scaleY = Math.round(100 * Math.min(originNodeRect.height / containerNode.offsetHeight, 1.0)) / 100;
+
+ return {
+ top: Math.round(position.top),
+ left: Math.round(position.left),
+ // Animate a scale out if we aren't just repositioning
+ transform: !opts.alreadyOpen ? $mdUtil.supplant('scale({0},{1})', [scaleX, scaleY]) : undefined,
+ transformOrigin: transformOrigin
+ };
+
+ /**
+ * Clamps the repositioning of the menu within the confines of
+ * bounding element (often the screen/body)
+ */
+ function clamp(pos) {
+ pos.top = Math.max(Math.min(pos.top, bounds.bottom - containerNode.offsetHeight), bounds.top);
+ pos.left = Math.max(Math.min(pos.left, bounds.right - containerNode.offsetWidth), bounds.left);
+ }
+
+ /**
+ * Gets the first visible child in the openMenuNode
+ * Necessary incase menu nodes are being dynamically hidden
+ */
+ function firstVisibleChild() {
+ for (var i = 0; i < openMenuNode.children.length; ++i) {
+ if ($window.getComputedStyle(openMenuNode.children[i]).display != 'none') {
+ return openMenuNode.children[i];
+ }
+ }
+ }
+ }
+ }
+ function toNode(el) {
+ if (el instanceof angular.element) {
+ el = el[0];
+ }
+ return el;
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.menuBar
+ */
+
+angular.module('material.components.menuBar', [
+ 'material.core',
+ 'material.components.icon',
+ 'material.components.menu'
+]);
+
+})();
+(function(){
+"use strict";
+
+
+MenuBarController.$inject = ["$scope", "$rootScope", "$element", "$attrs", "$mdConstant", "$document", "$mdUtil", "$timeout"];
+angular
+ .module('material.components.menuBar')
+ .controller('MenuBarController', MenuBarController);
+
+var BOUND_MENU_METHODS = ['handleKeyDown', 'handleMenuHover', 'scheduleOpenHoveredMenu', 'cancelScheduledOpen'];
+
+/**
+ * @ngInject
+ */
+function MenuBarController($scope, $rootScope, $element, $attrs, $mdConstant, $document, $mdUtil, $timeout) {
+ this.$element = $element;
+ this.$attrs = $attrs;
+ this.$mdConstant = $mdConstant;
+ this.$mdUtil = $mdUtil;
+ this.$document = $document;
+ this.$scope = $scope;
+ this.$rootScope = $rootScope;
+ this.$timeout = $timeout;
+
+ var self = this;
+ angular.forEach(BOUND_MENU_METHODS, function(methodName) {
+ self[methodName] = angular.bind(self, self[methodName]);
+ });
+}
+
+MenuBarController.prototype.init = function() {
+ var $element = this.$element;
+ var $mdUtil = this.$mdUtil;
+ var $scope = this.$scope;
+
+ var self = this;
+ var deregisterFns = [];
+ $element.on('keydown', this.handleKeyDown);
+ this.parentToolbar = $mdUtil.getClosest($element, 'MD-TOOLBAR');
+
+ deregisterFns.push(this.$rootScope.$on('$mdMenuOpen', function(event, el) {
+ if (self.getMenus().indexOf(el[0]) != -1) {
+ $element[0].classList.add('md-open');
+ el[0].classList.add('md-open');
+ self.currentlyOpenMenu = el.controller('mdMenu');
+ self.currentlyOpenMenu.registerContainerProxy(self.handleKeyDown);
+ self.enableOpenOnHover();
+ }
+ }));
+
+ deregisterFns.push(this.$rootScope.$on('$mdMenuClose', function(event, el, opts) {
+ var rootMenus = self.getMenus();
+ if (rootMenus.indexOf(el[0]) != -1) {
+ $element[0].classList.remove('md-open');
+ el[0].classList.remove('md-open');
+ }
+
+ var ctrl = angular.element(el[0]).controller('mdMenu');
+ if (ctrl.isInMenuBar && ctrl.mdMenuBarCtrl === self) {
+ var parentMenu = el[0];
+ while (parentMenu && rootMenus.indexOf(parentMenu) == -1) {
+ parentMenu = $mdUtil.getClosest(parentMenu, 'MD-MENU', true);
+ }
+ if (parentMenu) {
+ if (!opts.skipFocus) parentMenu.querySelector('button:not([disabled])').focus();
+ self.currentlyOpenMenu = undefined;
+ }
+ self.disableOpenOnHover();
+ self.setKeyboardMode(true);
+ }
+ }));
+
+ $scope.$on('$destroy', function() {
+ self.disableOpenOnHover();
+ while (deregisterFns.length) {
+ deregisterFns.shift()();
+ }
+ });
+
+
+ this.setKeyboardMode(true);
+};
+
+MenuBarController.prototype.setKeyboardMode = function(enabled) {
+ if (enabled) this.$element[0].classList.add('md-keyboard-mode');
+ else this.$element[0].classList.remove('md-keyboard-mode');
+};
+
+MenuBarController.prototype.enableOpenOnHover = function() {
+ if (this.openOnHoverEnabled) return;
+
+ var self = this;
+
+ self.openOnHoverEnabled = true;
+
+ if (self.parentToolbar) {
+ self.parentToolbar.classList.add('md-has-open-menu');
+
+ // Needs to be on the next tick so it doesn't close immediately.
+ self.$mdUtil.nextTick(function() {
+ angular.element(self.parentToolbar).on('click', self.handleParentClick);
+ }, false);
+ }
+
+ angular
+ .element(self.getMenus())
+ .on('mouseenter', self.handleMenuHover);
+};
+
+MenuBarController.prototype.handleMenuHover = function(e) {
+ this.setKeyboardMode(false);
+ if (this.openOnHoverEnabled) {
+ this.scheduleOpenHoveredMenu(e);
+ }
+};
+
+MenuBarController.prototype.disableOpenOnHover = function() {
+ if (!this.openOnHoverEnabled) return;
+
+ this.openOnHoverEnabled = false;
+
+ if (this.parentToolbar) {
+ this.parentToolbar.classList.remove('md-has-open-menu');
+ angular.element(this.parentToolbar).off('click', this.handleParentClick);
+ }
+
+ angular
+ .element(this.getMenus())
+ .off('mouseenter', this.handleMenuHover);
+};
+
+MenuBarController.prototype.scheduleOpenHoveredMenu = function(e) {
+ var menuEl = angular.element(e.currentTarget);
+ var menuCtrl = menuEl.controller('mdMenu');
+ this.setKeyboardMode(false);
+ this.scheduleOpenMenu(menuCtrl);
+};
+
+MenuBarController.prototype.scheduleOpenMenu = function(menuCtrl) {
+ var self = this;
+ var $timeout = this.$timeout;
+ if (menuCtrl != self.currentlyOpenMenu) {
+ $timeout.cancel(self.pendingMenuOpen);
+ self.pendingMenuOpen = $timeout(function() {
+ self.pendingMenuOpen = undefined;
+ if (self.currentlyOpenMenu) {
+ self.currentlyOpenMenu.close(true, { closeAll: true });
+ }
+ menuCtrl.open();
+ }, 200, false);
+ }
+};
+
+MenuBarController.prototype.handleKeyDown = function(e) {
+ var keyCodes = this.$mdConstant.KEY_CODE;
+ var currentMenu = this.currentlyOpenMenu;
+ var wasOpen = currentMenu && currentMenu.isOpen;
+ this.setKeyboardMode(true);
+ var handled, newMenu, newMenuCtrl;
+ switch (e.keyCode) {
+ case keyCodes.DOWN_ARROW:
+ if (currentMenu) {
+ currentMenu.focusMenuContainer();
+ } else {
+ this.openFocusedMenu();
+ }
+ handled = true;
+ break;
+ case keyCodes.UP_ARROW:
+ currentMenu && currentMenu.close();
+ handled = true;
+ break;
+ case keyCodes.LEFT_ARROW:
+ newMenu = this.focusMenu(-1);
+ if (wasOpen) {
+ newMenuCtrl = angular.element(newMenu).controller('mdMenu');
+ this.scheduleOpenMenu(newMenuCtrl);
+ }
+ handled = true;
+ break;
+ case keyCodes.RIGHT_ARROW:
+ newMenu = this.focusMenu(+1);
+ if (wasOpen) {
+ newMenuCtrl = angular.element(newMenu).controller('mdMenu');
+ this.scheduleOpenMenu(newMenuCtrl);
+ }
+ handled = true;
+ break;
+ }
+ if (handled) {
+ e && e.preventDefault && e.preventDefault();
+ e && e.stopImmediatePropagation && e.stopImmediatePropagation();
+ }
+};
+
+MenuBarController.prototype.focusMenu = function(direction) {
+ var menus = this.getMenus();
+ var focusedIndex = this.getFocusedMenuIndex();
+
+ if (focusedIndex == -1) { focusedIndex = this.getOpenMenuIndex(); }
+
+ var changed = false;
+
+ if (focusedIndex == -1) { focusedIndex = 0; changed = true; }
+ else if (
+ direction < 0 && focusedIndex > 0 ||
+ direction > 0 && focusedIndex < menus.length - direction
+ ) {
+ focusedIndex += direction;
+ changed = true;
+ }
+ if (changed) {
+ menus[focusedIndex].querySelector('button').focus();
+ return menus[focusedIndex];
+ }
+};
+
+MenuBarController.prototype.openFocusedMenu = function() {
+ var menu = this.getFocusedMenu();
+ menu && angular.element(menu).controller('mdMenu').open();
+};
+
+MenuBarController.prototype.getMenus = function() {
+ var $element = this.$element;
+ return this.$mdUtil.nodesToArray($element[0].children)
+ .filter(function(el) { return el.nodeName == 'MD-MENU'; });
+};
+
+MenuBarController.prototype.getFocusedMenu = function() {
+ return this.getMenus()[this.getFocusedMenuIndex()];
+};
+
+MenuBarController.prototype.getFocusedMenuIndex = function() {
+ var $mdUtil = this.$mdUtil;
+ var focusedEl = $mdUtil.getClosest(
+ this.$document[0].activeElement,
+ 'MD-MENU'
+ );
+ if (!focusedEl) return -1;
+
+ var focusedIndex = this.getMenus().indexOf(focusedEl);
+ return focusedIndex;
+};
+
+MenuBarController.prototype.getOpenMenuIndex = function() {
+ var menus = this.getMenus();
+ for (var i = 0; i < menus.length; ++i) {
+ if (menus[i].classList.contains('md-open')) return i;
+ }
+ return -1;
+};
+
+MenuBarController.prototype.handleParentClick = function(event) {
+ var openMenu = this.querySelector('md-menu.md-open');
+
+ if (openMenu && !openMenu.contains(event.target)) {
+ angular.element(openMenu).controller('mdMenu').close(true, {
+ closeAll: true
+ });
+ }
+};
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc directive
+ * @name mdMenuBar
+ * @module material.components.menuBar
+ * @restrict E
+ * @description
+ *
+ * Menu bars are containers that hold multiple menus. They change the behavior and appearance
+ * of the `md-menu` directive to behave similar to an operating system provided menu.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-menu-bar>
+ * <md-menu>
+ * <button ng-click="$mdMenu.open()">
+ * File
+ * </button>
+ * <md-menu-content>
+ * <md-menu-item>
+ * <md-button ng-click="ctrl.sampleAction('share', $event)">
+ * Share...
+ * </md-button>
+ * </md-menu-item>
+ * <md-menu-divider></md-menu-divider>
+ * <md-menu-item>
+ * <md-menu-item>
+ * <md-menu>
+ * <md-button ng-click="$mdMenu.open()">New</md-button>
+ * <md-menu-content>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Document', $event)">Document</md-button></md-menu-item>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Spreadsheet', $event)">Spreadsheet</md-button></md-menu-item>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Presentation', $event)">Presentation</md-button></md-menu-item>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Form', $event)">Form</md-button></md-menu-item>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Drawing', $event)">Drawing</md-button></md-menu-item>
+ * </md-menu-content>
+ * </md-menu>
+ * </md-menu-item>
+ * </md-menu-content>
+ * </md-menu>
+ * </md-menu-bar>
+ * </hljs>
+ *
+ * ## Menu Bar Controls
+ *
+ * You may place `md-menu-item`s that function as controls within menu bars.
+ * There are two modes that are exposed via the `type` attribute of the `md-menu-item`.
+ * `type="checkbox"` will function as a boolean control for the `ng-model` attribute of the
+ * `md-menu-item`. `type="radio"` will function like a radio button, setting the `ngModel`
+ * to the `string` value of the `value` attribute. If you need non-string values, you can use
+ * `ng-value` to provide an expression (this is similar to how angular's native `input[type=radio]`
+ * works.
+ *
+ * If you want either to disable closing the opened menu when clicked, you can add the
+ * `md-prevent-menu-close` attribute to the `md-menu-item`. The attribute will be forwarded to the
+ * `button` element that is generated.
+ *
+ * <hljs lang="html">
+ * <md-menu-bar>
+ * <md-menu>
+ * <button ng-click="$mdMenu.open()">
+ * Sample Menu
+ * </button>
+ * <md-menu-content>
+ * <md-menu-item type="checkbox" ng-model="settings.allowChanges" md-prevent-menu-close>
+ * Allow changes
+ * </md-menu-item>
+ * <md-menu-divider></md-menu-divider>
+ * <md-menu-item type="radio" ng-model="settings.mode" ng-value="1">Mode 1</md-menu-item>
+ * <md-menu-item type="radio" ng-model="settings.mode" ng-value="2">Mode 2</md-menu-item>
+ * <md-menu-item type="radio" ng-model="settings.mode" ng-value="3">Mode 3</md-menu-item>
+ * </md-menu-content>
+ * </md-menu>
+ * </md-menu-bar>
+ * </hljs>
+ *
+ *
+ * ### Nesting Menus
+ *
+ * Menus may be nested within menu bars. This is commonly called cascading menus.
+ * To nest a menu place the nested menu inside the content of the `md-menu-item`.
+ * <hljs lang="html">
+ * <md-menu-item>
+ * <md-menu>
+ * <button ng-click="$mdMenu.open()">New</md-button>
+ * <md-menu-content>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Document', $event)">Document</md-button></md-menu-item>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Spreadsheet', $event)">Spreadsheet</md-button></md-menu-item>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Presentation', $event)">Presentation</md-button></md-menu-item>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Form', $event)">Form</md-button></md-menu-item>
+ * <md-menu-item><md-button ng-click="ctrl.sampleAction('New Drawing', $event)">Drawing</md-button></md-menu-item>
+ * </md-menu-content>
+ * </md-menu>
+ * </md-menu-item>
+ * </hljs>
+ *
+ */
+
+MenuBarDirective.$inject = ["$mdUtil", "$mdTheming"];
+angular
+ .module('material.components.menuBar')
+ .directive('mdMenuBar', MenuBarDirective);
+
+/* @ngInject */
+function MenuBarDirective($mdUtil, $mdTheming) {
+ return {
+ restrict: 'E',
+ require: 'mdMenuBar',
+ controller: 'MenuBarController',
+
+ compile: function compile(templateEl, templateAttrs) {
+ if (!templateAttrs.ariaRole) {
+ templateEl[0].setAttribute('role', 'menubar');
+ }
+ angular.forEach(templateEl[0].children, function(menuEl) {
+ if (menuEl.nodeName == 'MD-MENU') {
+ if (!menuEl.hasAttribute('md-position-mode')) {
+ menuEl.setAttribute('md-position-mode', 'left bottom');
+
+ // Since we're in the compile function and actual `md-buttons` are not compiled yet,
+ // we need to query for possible `md-buttons` as well.
+ menuEl.querySelector('button, a, md-button').setAttribute('role', 'menuitem');
+ }
+ var contentEls = $mdUtil.nodesToArray(menuEl.querySelectorAll('md-menu-content'));
+ angular.forEach(contentEls, function(contentEl) {
+ contentEl.classList.add('md-menu-bar-menu');
+ contentEl.classList.add('md-dense');
+ if (!contentEl.hasAttribute('width')) {
+ contentEl.setAttribute('width', 5);
+ }
+ });
+ }
+ });
+
+ // Mark the child menu items that they're inside a menu bar. This is necessary,
+ // because mnMenuItem has special behaviour during compilation, depending on
+ // whether it is inside a mdMenuBar. We can usually figure this out via the DOM,
+ // however if a directive that uses documentFragment is applied to the child (e.g. ngRepeat),
+ // the element won't have a parent and won't compile properly.
+ templateEl.find('md-menu-item').addClass('md-in-menu-bar');
+
+ return function postLink(scope, el, attr, ctrl) {
+ el.addClass('_md'); // private md component indicator for styling
+ $mdTheming(scope, el);
+ ctrl.init();
+ };
+ }
+ };
+
+}
+
+})();
+(function(){
+"use strict";
+
+
+angular
+ .module('material.components.menuBar')
+ .directive('mdMenuDivider', MenuDividerDirective);
+
+
+function MenuDividerDirective() {
+ return {
+ restrict: 'E',
+ compile: function(templateEl, templateAttrs) {
+ if (!templateAttrs.role) {
+ templateEl[0].setAttribute('role', 'separator');
+ }
+ }
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+
+MenuItemController.$inject = ["$scope", "$element", "$attrs"];
+angular
+ .module('material.components.menuBar')
+ .controller('MenuItemController', MenuItemController);
+
+
+/**
+ * @ngInject
+ */
+function MenuItemController($scope, $element, $attrs) {
+ this.$element = $element;
+ this.$attrs = $attrs;
+ this.$scope = $scope;
+}
+
+MenuItemController.prototype.init = function(ngModel) {
+ var $element = this.$element;
+ var $attrs = this.$attrs;
+
+ this.ngModel = ngModel;
+ if ($attrs.type == 'checkbox' || $attrs.type == 'radio') {
+ this.mode = $attrs.type;
+ this.iconEl = $element[0].children[0];
+ this.buttonEl = $element[0].children[1];
+ if (ngModel) {
+ // Clear ngAria set attributes
+ this.initClickListeners();
+ }
+ }
+};
+
+// ngAria auto sets attributes on a menu-item with a ngModel.
+// We don't want this because our content (buttons) get the focus
+// and set their own aria attributes appropritately. Having both
+// breaks NVDA / JAWS. This undeoes ngAria's attrs.
+MenuItemController.prototype.clearNgAria = function() {
+ var el = this.$element[0];
+ var clearAttrs = ['role', 'tabindex', 'aria-invalid', 'aria-checked'];
+ angular.forEach(clearAttrs, function(attr) {
+ el.removeAttribute(attr);
+ });
+};
+
+MenuItemController.prototype.initClickListeners = function() {
+ var self = this;
+ var ngModel = this.ngModel;
+ var $scope = this.$scope;
+ var $attrs = this.$attrs;
+ var $element = this.$element;
+ var mode = this.mode;
+
+ this.handleClick = angular.bind(this, this.handleClick);
+
+ var icon = this.iconEl;
+ var button = angular.element(this.buttonEl);
+ var handleClick = this.handleClick;
+
+ $attrs.$observe('disabled', setDisabled);
+ setDisabled($attrs.disabled);
+
+ ngModel.$render = function render() {
+ self.clearNgAria();
+ if (isSelected()) {
+ icon.style.display = '';
+ button.attr('aria-checked', 'true');
+ } else {
+ icon.style.display = 'none';
+ button.attr('aria-checked', 'false');
+ }
+ };
+
+ $scope.$$postDigest(ngModel.$render);
+
+ function isSelected() {
+ if (mode == 'radio') {
+ var val = $attrs.ngValue ? $scope.$eval($attrs.ngValue) : $attrs.value;
+ return ngModel.$modelValue == val;
+ } else {
+ return ngModel.$modelValue;
+ }
+ }
+
+ function setDisabled(disabled) {
+ if (disabled) {
+ button.off('click', handleClick);
+ } else {
+ button.on('click', handleClick);
+ }
+ }
+};
+
+MenuItemController.prototype.handleClick = function(e) {
+ var mode = this.mode;
+ var ngModel = this.ngModel;
+ var $attrs = this.$attrs;
+ var newVal;
+ if (mode == 'checkbox') {
+ newVal = !ngModel.$modelValue;
+ } else if (mode == 'radio') {
+ newVal = $attrs.ngValue ? this.$scope.$eval($attrs.ngValue) : $attrs.value;
+ }
+ ngModel.$setViewValue(newVal);
+ ngModel.$render();
+};
+
+})();
+(function(){
+"use strict";
+
+
+MenuItemDirective.$inject = ["$mdUtil", "$mdConstant", "$$mdSvgRegistry"];
+angular
+ .module('material.components.menuBar')
+ .directive('mdMenuItem', MenuItemDirective);
+
+ /* @ngInject */
+function MenuItemDirective($mdUtil, $mdConstant, $$mdSvgRegistry) {
+ return {
+ controller: 'MenuItemController',
+ require: ['mdMenuItem', '?ngModel'],
+ priority: $mdConstant.BEFORE_NG_ARIA,
+ compile: function(templateEl, templateAttrs) {
+ var type = templateAttrs.type;
+ var inMenuBarClass = 'md-in-menu-bar';
+
+ // Note: This allows us to show the `check` icon for the md-menu-bar items.
+ // The `md-in-menu-bar` class is set by the mdMenuBar directive.
+ if ((type === 'checkbox' || type === 'radio') && templateEl.hasClass(inMenuBarClass)) {
+ var text = templateEl[0].textContent;
+ var buttonEl = angular.element('<md-button type="button"></md-button>');
+ var iconTemplate = '<md-icon md-svg-src="' + $$mdSvgRegistry.mdChecked + '"></md-icon>';
+
+ buttonEl.html(text);
+ buttonEl.attr('tabindex', '0');
+
+ if (angular.isDefined(templateAttrs.mdPreventMenuClose)) {
+ buttonEl.attr('md-prevent-menu-close', templateAttrs.mdPreventMenuClose);
+ }
+
+ templateEl.html('');
+ templateEl.append(angular.element(iconTemplate));
+ templateEl.append(buttonEl);
+ templateEl.addClass('md-indent').removeClass(inMenuBarClass);
+
+ setDefault('role', type === 'checkbox' ? 'menuitemcheckbox' : 'menuitemradio', buttonEl);
+ moveAttrToButton('ng-disabled');
+
+ } else {
+ setDefault('role', 'menuitem', templateEl[0].querySelector('md-button, button, a'));
+ }
+
+
+ return function(scope, el, attrs, ctrls) {
+ var ctrl = ctrls[0];
+ var ngModel = ctrls[1];
+ ctrl.init(ngModel);
+ };
+
+ function setDefault(attr, val, el) {
+ el = el || templateEl;
+ if (el instanceof angular.element) {
+ el = el[0];
+ }
+ if (!el.hasAttribute(attr)) {
+ el.setAttribute(attr, val);
+ }
+ }
+
+ function moveAttrToButton(attribute) {
+ var attributes = $mdUtil.prefixer(attribute);
+
+ angular.forEach(attributes, function(attr) {
+ if (templateEl[0].hasAttribute(attr)) {
+ var val = templateEl[0].getAttribute(attr);
+ buttonEl[0].setAttribute(attr, val);
+ templateEl[0].removeAttribute(attr);
+ }
+ });
+ }
+ }
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.navBar
+ */
+MdNavBar.$inject = ["$mdAria", "$mdTheming", "$window", "$mdUtil"];
+MdNavBarController.$inject = ["$element", "$scope", "$timeout", "$mdConstant"];
+MdNavItem.$inject = ["$mdAria", "$$rAF", "$mdUtil", "$window"];
+MdNavItemController.$inject = ["$element"];
+angular.module('material.components.navBar', ['material.core'])
+ .controller('MdNavBarController', MdNavBarController)
+ .directive('mdNavBar', MdNavBar)
+ .controller('MdNavItemController', MdNavItemController)
+ .directive('mdNavItem', MdNavItem);
+
+/**
+ * @ngdoc directive
+ * @name mdNavBar
+ * @module material.components.navBar
+ *
+ * @restrict E
+ *
+ * @description
+ * The `<md-nav-bar>` directive renders a list of material tabs that can be used
+ * for top-level page navigation. Unlike `<md-tabs>`, it has no concept of a tab
+ * body and no bar pagination.
+ *
+ * Because it deals with page navigation, certain routing concepts are built-in.
+ * Route changes via `ng-href`, `ui-sref`, or `ng-click` events are supported.
+ * Alternatively, the user could simply watch the value of `md-selected-nav-item`
+ * (`currentNavItem` in the below example) for changes.
+ *
+ * Accessibility functionality is implemented as a
+ * <a href="https://www.w3.org/TR/wai-aria-1.0/complete#tablist">
+ * tablist</a> with
+ * <a href="https://www.w3.org/TR/wai-aria-1.0/complete#tab">tabs</a>.
+ * We've kept the `role="navigation"` on the `<nav>`, for backwards compatibility, even though
+ * it is not required in the
+ * <a href="https://www.w3.org/TR/wai-aria-practices/#aria_lh_navigation">
+ * latest Working Group Note from December 2017</a>.
+ *
+ * <h3>Keyboard Navigation</h3>
+ * - `Tab`/`Shift+Tab` moves the focus to the next/previous interactive element on the page
+ * - `Enter`/`Space` selects the focused nav item and navigates to display the item's contents
+ * - `Right`/`Down` moves focus to the next nav item, wrapping at the end
+ * - `Left`/`Up` moves focus to the previous nav item, wrapping at the end
+ * - `Home`/`End` moves the focus to the first/last nav item
+ *
+ * @param {string=} md-selected-nav-item The name of the current tab; this must
+ * match the `name` attribute of `<md-nav-item>`.
+ * @param {boolean=} md-no-ink-bar If set to true, the ink bar will be hidden.
+ * @param {string=} nav-bar-aria-label An `aria-label` applied to the `md-nav-bar`'s tablist
+ * for accessibility.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-nav-bar md-selected-nav-item="currentNavItem">
+ * <md-nav-item md-nav-click="goto('page1')" name="page1">
+ * Page One
+ * </md-nav-item>
+ * <md-nav-item md-nav-href="#page2" name="page3">Page Two</md-nav-item>
+ * <md-nav-item md-nav-sref="page3" name="page2">Page Three</md-nav-item>
+ * <md-nav-item
+ * md-nav-sref="app.page4"
+ * sref-opts="{reload: true, notify: true}"
+ * name="page4">
+ * Page Four
+ * </md-nav-item>
+ * </md-nav-bar>
+ *</hljs>
+ * <hljs lang="js">
+ * (function() {
+ * 'use strict';
+ *
+ * $rootScope.$on('$routeChangeSuccess', function(event, current) {
+ * $scope.currentLink = getCurrentLinkFromRoute(current);
+ * });
+ * });
+ * </hljs>
+ */
+/**
+ * @param $mdAria
+ * @param $mdTheming
+ * @param $window
+ * @param $mdUtil
+ * @constructor
+ * @ngInject
+ */
+function MdNavBar($mdAria, $mdTheming, $window, $mdUtil) {
+ return {
+ restrict: 'E',
+ transclude: true,
+ controller: MdNavBarController,
+ controllerAs: 'ctrl',
+ bindToController: true,
+ scope: {
+ 'mdSelectedNavItem': '=?',
+ 'mdNoInkBar': '=?',
+ 'navBarAriaLabel': '@?',
+ },
+ template:
+ '<div class="md-nav-bar">' +
+ '<nav role="navigation">' +
+ '<ul class="_md-nav-bar-list" ng-transclude role="tablist" ' +
+ 'ng-focus="ctrl.onFocus()" ' + // Deprecated but kept for now in order to not break tests
+ 'aria-label="{{ctrl.navBarAriaLabel}}">' +
+ '</ul>' +
+ '</nav>' +
+ '<md-nav-ink-bar ng-hide="ctrl.mdNoInkBar"></md-nav-ink-bar>' +
+ '</div>',
+ link: function(scope, element, attrs, ctrl) {
+
+ ctrl.width = $window.innerWidth;
+
+ function onResize() {
+ if (ctrl.width !== $window.innerWidth) {
+ ctrl.updateSelectedTabInkBar();
+ ctrl.width = $window.innerWidth;
+ scope.$digest();
+ }
+ }
+
+ function cleanUp() {
+ angular.element($window).off('resize', onResize);
+ }
+
+ angular.element($window).on('resize', $mdUtil.debounce(onResize, 300));
+ scope.$on('$destroy', cleanUp);
+
+ $mdTheming(element);
+ if (!ctrl.navBarAriaLabel) {
+ $mdAria.expectAsync(element, 'aria-label', angular.noop);
+ }
+ },
+ };
+}
+
+/**
+ * Controller for the nav-bar component.
+ * Accessibility functionality is implemented as a tablist
+ * (https://www.w3.org/TR/wai-aria-1.0/complete#tablist) and
+ * tabs (https://www.w3.org/TR/wai-aria-1.0/complete#tab).
+ *
+ * @param {!JQLite} $element
+ * @param {!IScope} $scope
+ * @param {!ITimeoutService} $timeout
+ * @param {!Object} $mdConstant
+ * @constructor
+ * @final
+ * @ngInject
+ */
+function MdNavBarController($element, $scope, $timeout, $mdConstant) {
+ // Injected variables
+ /**
+ * @private @const
+ * @type {!ITimeoutService}
+ */
+ this._$timeout = $timeout;
+
+ /**
+ * @private @const
+ * @type {!IScope}
+ */
+ this._$scope = $scope;
+
+ /**
+ * @private @const
+ * @type {!Object}
+ */
+ this._$mdConstant = $mdConstant;
+
+ // Data-bound variables.
+ /** @type {?string} */
+ this.mdSelectedNavItem;
+
+ /** @type {?string} */
+ this.navBarAriaLabel;
+
+ // State variables.
+ /** @type {?HTMLElement} */
+ this._navBarEl = $element[0];
+
+ /** @type {?JQLite} */
+ this._inkbar;
+
+ var self = this;
+ // need to wait for transcluded content to be available
+ var deregisterTabWatch = this._$scope.$watch(function() {
+ return self._navBarEl.querySelectorAll('._md-nav-button').length;
+ },
+ function(newLength) {
+ if (newLength > 0) {
+ self._initTabs();
+ deregisterTabWatch();
+ }
+ });
+}
+
+/**
+ * Initializes the tab components once they exist.
+ * @private
+ */
+MdNavBarController.prototype._initTabs = function() {
+ this._inkbar = angular.element(this._navBarEl.querySelector('md-nav-ink-bar'));
+
+ var self = this;
+ this._$timeout(function() {
+ self._updateTabs(self.mdSelectedNavItem, null);
+ });
+
+ this._$scope.$watch('ctrl.mdSelectedNavItem', function(newValue, oldValue) {
+ // Wait a digest before update tabs for products doing
+ // anything dynamic in the template.
+ self._$timeout(function() {
+ self._updateTabs(newValue, oldValue);
+ });
+ });
+};
+
+/**
+ * Set the current tab to be selected.
+ * @param {string|undefined} newValue New current tab name.
+ * @param {string|undefined|null} oldValue Previous tab name.
+ * @private
+ */
+MdNavBarController.prototype._updateTabs = function(newValue, oldValue) {
+ var self = this;
+ var tabs = this._getTabs();
+ var sameTab = newValue === oldValue;
+
+ // this._getTabs can return null if nav-bar has not yet been initialized
+ if (!tabs) return;
+
+ var newIndex = -1;
+ var newTab = this._getTabByName(newValue);
+ var oldTab = this._getTabByName(oldValue);
+
+ if (oldTab) {
+ oldTab.setSelected(false);
+ }
+
+ if (newTab) {
+ newTab.setSelected(true);
+ newIndex = tabs.indexOf(newTab);
+ }
+
+ this._$timeout(function() {
+ self._updateInkBarStyles(newTab, newIndex);
+ // Don't change focus when there is no newTab, the new and old tabs are the same, or when
+ // called from MdNavBarController._initTabs() which would have no oldTab defined.
+ if (newTab && oldTab && !sameTab) {
+ self._moveFocus(oldTab, newTab);
+ }
+ });
+};
+
+/**
+ * Repositions the ink bar to the selected tab.
+ * @param {MdNavItemController} tab the nav item that should have ink bar styles applied
+ * @param {number=} newIndex the index of the newly selected nav item
+ * @private
+ */
+MdNavBarController.prototype._updateInkBarStyles = function(tab, newIndex) {
+ this._inkbar.css({display: newIndex < 0 ? 'none' : ''});
+
+ if (tab) {
+ var tabEl = tab.getButtonEl();
+ var left = tabEl.offsetLeft;
+ var tabWidth = tabEl.offsetWidth;
+ var navBarWidth = this._navBarEl.getBoundingClientRect().width;
+ var scale = tabWidth / navBarWidth;
+ var translate = left / navBarWidth * 100;
+
+ this._inkbar.css({ transform: 'translateX(' + translate + '%) scaleX(' + scale + ')' });
+ }
+};
+
+/**
+ * Updates ink bar to match current tab.
+ */
+MdNavBarController.prototype.updateSelectedTabInkBar = function() {
+ this._updateInkBarStyles(this._getSelectedTab());
+};
+
+/**
+ * Returns an array of the current tabs.
+ * @return {Array<!MdNavItemController>}
+ * @private
+ */
+MdNavBarController.prototype._getTabs = function() {
+ var controllers = Array.prototype.slice.call(
+ this._navBarEl.querySelectorAll('.md-nav-item'))
+ .map(function(el) {
+ return angular.element(el).controller('mdNavItem');
+ });
+ return controllers.indexOf(undefined) ? controllers : [];
+};
+
+/**
+ * Returns the tab with the specified name.
+ * @param {string} name The name of the tab, found in its name attribute.
+ * @return {MdNavItemController}
+ * @private
+ */
+MdNavBarController.prototype._getTabByName = function(name) {
+ return this._findTab(function(tab) {
+ return tab.getName() === name;
+ });
+};
+
+/**
+ * Returns the selected tab.
+ * @return {MdNavItemController}
+ * @private
+ */
+MdNavBarController.prototype._getSelectedTab = function() {
+ return this._findTab(function(tab) {
+ return tab.isSelected();
+ });
+};
+
+/**
+ * Returns the focused tab.
+ * @return {MdNavItemController}
+ */
+MdNavBarController.prototype.getFocusedTab = function() {
+ return this._findTab(function(tab) {
+ return tab.hasFocus();
+ });
+};
+
+/**
+ * Find a tab that matches the specified function, starting from the first tab.
+ * @param {Function} fn
+ * @param {number=} startIndex index to start at. Defaults to 0.
+ * @returns {MdNavItemController|null}
+ * @private
+ */
+MdNavBarController.prototype._findTab = function(fn, startIndex) {
+ var tabs = this._getTabs(), i;
+ if (startIndex == null) {
+ startIndex = 0;
+ }
+ for (i = startIndex; i < tabs.length; i++) {
+ if (fn(tabs[i])) {
+ return tabs[i];
+ }
+ }
+ return null;
+};
+
+/**
+ * Find a tab that matches the specified function, going backwards from the end of the list.
+ * @param {Function} fn
+ * @param {number=} startIndex index to start at. Defaults to tabs.length - 1.
+ * @returns {MdNavItemController}
+ * @private
+ */
+MdNavBarController.prototype._findTabReverse = function(fn, startIndex) {
+ var tabs = this._getTabs();
+ if (startIndex === undefined || startIndex === null) {
+ startIndex = tabs.length - 1;
+ }
+ for (var i = startIndex; i >= 0 ; i--) {
+ if (fn(tabs[i])) {
+ return tabs[i];
+ }
+ }
+ return null;
+};
+
+/**
+ * Direct focus to the selected tab when focus enters the nav bar.
+ */
+MdNavBarController.prototype.onFocus = function() {
+ var tab = this._getSelectedTab();
+ if (tab && !tab.isFocused) {
+ tab.setFocused(true);
+ }
+};
+
+/**
+ * Move focus from oldTab to newTab.
+ * @param {!MdNavItemController} oldTab
+ * @param {!MdNavItemController} newTab
+ * @private
+ */
+MdNavBarController.prototype._moveFocus = function(oldTab, newTab) {
+ oldTab.setFocused(false);
+ newTab.setFocused(true);
+};
+
+/**
+ * Focus the first tab.
+ * @private
+ */
+MdNavBarController.prototype._focusFirstTab = function() {
+ var tabs = this._getTabs();
+ if (!tabs) return;
+ var tabToFocus = this._findTab(function(tab) {
+ return tab._isEnabled();
+ });
+ if (tabToFocus) {
+ this._moveFocus(this.getFocusedTab(), tabToFocus);
+ }
+};
+
+/**
+ * Focus the last tab.
+ * @private
+ */
+MdNavBarController.prototype._focusLastTab = function() {
+ var tabs = this._getTabs();
+ if (!tabs) return;
+ var tabToFocus = this._findTabReverse(function(tab) {
+ return tab._isEnabled();
+ });
+ if (tabToFocus) {
+ this._moveFocus(this.getFocusedTab(), tabToFocus);
+ }
+};
+
+/**
+ * Focus the next non-disabled tab.
+ * @param {number} focusedTabIndex the index of the currently focused tab
+ * @private
+ */
+MdNavBarController.prototype._focusNextTab = function(focusedTabIndex) {
+ var tabs = this._getTabs();
+ if (!tabs) return;
+ var tabToFocus = this._findTab(function(tab) {
+ return tab._isEnabled();
+ }, focusedTabIndex + 1);
+ if (tabToFocus) {
+ this._moveFocus(this.getFocusedTab(), tabToFocus);
+ } else {
+ this._focusFirstTab();
+ }
+};
+
+/**
+ * Focus the previous non-disabled tab.
+ * @param {number} focusedTabIndex the index of the currently focused tab
+ * @private
+ */
+MdNavBarController.prototype._focusPreviousTab = function(focusedTabIndex) {
+ var tabs = this._getTabs();
+ if (!tabs) return;
+ var tabToFocus = this._findTabReverse(function(tab) {
+ return tab._isEnabled();
+ }, focusedTabIndex - 1);
+ if (tabToFocus) {
+ this._moveFocus(this.getFocusedTab(), tabToFocus);
+ } else {
+ this._focusLastTab();
+ }
+};
+
+/**
+ * Responds to keydown events.
+ * Calls to preventDefault() stop the page from scrolling when changing focus in the nav-bar.
+ * @param {!KeyboardEvent} e
+ */
+MdNavBarController.prototype.onKeydown = function(e) {
+ var keyCodes = this._$mdConstant.KEY_CODE;
+ var tabs = this._getTabs();
+ var focusedTab = this.getFocusedTab();
+ if (!focusedTab || !tabs) return;
+
+ var focusedTabIndex = tabs.indexOf(focusedTab);
+
+ // use arrow keys to navigate between tabs
+ switch (e.keyCode) {
+ case keyCodes.UP_ARROW:
+ case keyCodes.LEFT_ARROW:
+ e.preventDefault();
+ this._focusPreviousTab(focusedTabIndex);
+ break;
+ case keyCodes.DOWN_ARROW:
+ case keyCodes.RIGHT_ARROW:
+ e.preventDefault();
+ this._focusNextTab(focusedTabIndex);
+ break;
+ case keyCodes.SPACE:
+ case keyCodes.ENTER:
+ // timeout to avoid a "digest already in progress" console error
+ this._$timeout(function() {
+ focusedTab.getButtonEl().click();
+ });
+ break;
+ case keyCodes.HOME:
+ e.preventDefault();
+ this._focusFirstTab();
+ break;
+ case keyCodes.END:
+ e.preventDefault();
+ this._focusLastTab();
+ break;
+ }
+};
+
+/**
+ * @ngdoc directive
+ * @name mdNavItem
+ * @module material.components.navBar
+ *
+ * @restrict E
+ *
+ * @description
+ * `<md-nav-item>` describes a page navigation link within the `<md-nav-bar>` component.
+ * It renders an `<md-button>` as the actual link.
+ *
+ * Exactly one of the `md-nav-click`, `md-nav-href`, or `md-nav-sref` attributes are required
+ * to be specified.
+ *
+ * @param {string=} nav-item-aria-label Allows setting or overriding the label that is announced by
+ * a screen reader for the nav item's button. If this is not set, the nav item's transcluded
+ * content will be announced. Make sure to set this if the nav item's transcluded content does
+ * not include descriptive text, for example only an icon.
+ * @param {expression=} md-nav-click Expression which will be evaluated when the
+ * link is clicked to change the page. Renders as an `ng-click`.
+ * @param {string=} md-nav-href url to transition to when this link is clicked.
+ * Renders as an `ng-href`.
+ * @param {string=} md-nav-sref UI-Router state to transition to when this link is
+ * clicked. Renders as a `ui-sref`.
+ * @param {string} name The name of this link. Used by the nav bar to know
+ * which link is currently selected.
+ * @param {!object=} sref-opts UI-Router options that are passed to the `$state.go()` function. See
+ * the <a ng-href="https://ui-router.github.io/docs/latest/interfaces/transition.transitionoptions.html"
+ * target="_blank">UI-Router documentation for details</a>.
+ *
+ * @usage
+ * See <a ng-href="api/directive/mdNavBar">md-nav-bar</a> for usage.
+ */
+/**
+ * @param $mdAria
+ * @param $$rAF
+ * @param $mdUtil
+ * @param $window
+ * @constructor
+ * @ngInject
+ */
+function MdNavItem($mdAria, $$rAF, $mdUtil, $window) {
+ return {
+ restrict: 'E',
+ require: ['mdNavItem', '^mdNavBar'],
+ controller: MdNavItemController,
+ bindToController: true,
+ controllerAs: 'ctrl',
+ replace: true,
+ transclude: true,
+ template: function(tElement, tAttrs) {
+ var hasNavClick = tAttrs.mdNavClick;
+ var hasNavHref = tAttrs.mdNavHref;
+ var hasNavSref = tAttrs.mdNavSref;
+ var hasSrefOpts = tAttrs.srefOpts;
+ var navigationAttribute;
+ var navigationOptions;
+ var buttonTemplate;
+
+ // Cannot specify more than one nav attribute
+ if ((hasNavClick ? 1 : 0) + (hasNavHref ? 1 : 0) + (hasNavSref ? 1 : 0) > 1) {
+ throw Error(
+ 'Please do not specify more than one of the md-nav-click, md-nav-href, ' +
+ 'or md-nav-sref attributes per nav-item directive.'
+ );
+ }
+
+ if (hasNavClick !== undefined && hasNavClick !== null) {
+ navigationAttribute = 'ng-click="ctrl.mdNavClick()"';
+ } else if (hasNavHref !== undefined && hasNavHref !== null) {
+ navigationAttribute = 'ng-href="{{ctrl.mdNavHref}}"';
+ } else if (hasNavSref !== undefined && hasNavSref !== null) {
+ navigationAttribute = 'ui-sref="{{ctrl.mdNavSref}}"';
+ } else {
+ throw Error(
+ 'Please specify at least one of the md-nav-click, md-nav-href, or md-nav-sref ' +
+ 'attributes per nav-item directive.');
+ }
+
+ navigationOptions = hasSrefOpts ? 'ui-sref-opts="{{ctrl.srefOpts}}" ' : '';
+
+ if (navigationAttribute) {
+ buttonTemplate = '' +
+ '<md-button class="_md-nav-button md-accent" ' +
+ 'ng-class="ctrl.getNgClassMap()" ' +
+ 'ng-blur="ctrl.setFocused(false)" ' +
+ 'ng-disabled="ctrl.disabled" ' +
+ 'tabindex="-1" ' +
+ 'role="tab" ' +
+ 'ng-attr-aria-label="{{ctrl.navItemAriaLabel ? ctrl.navItemAriaLabel : undefined}}" ' +
+ 'aria-selected="{{ctrl.isSelected()}}" ' +
+ navigationOptions +
+ navigationAttribute + '>' +
+ '<span ng-transclude class="_md-nav-button-text"></span>' +
+ '</md-button>';
+ }
+
+ return '' +
+ '<li class="md-nav-item" ' +
+ 'role="presentation">' +
+ (buttonTemplate || '') +
+ '</li>';
+ },
+ scope: {
+ 'mdNavClick': '&?',
+ 'mdNavHref': '@?',
+ 'mdNavSref': '@?',
+ 'srefOpts': '=?',
+ 'name': '@',
+ 'navItemAriaLabel': '@?',
+ },
+ link: function(scope, element, attrs, controllers) {
+ var disconnect;
+ var mdNavItem;
+ var mdNavBar;
+ var navButton;
+
+ // When accessing the element's contents synchronously, they
+ // may not be defined yet because of transclusion. There is a higher
+ // chance that it will be accessible if we wait one frame.
+ $$rAF(function() {
+ mdNavItem = controllers[0];
+ mdNavBar = controllers[1];
+ navButton = angular.element(element[0].querySelector('._md-nav-button'));
+
+ if (!mdNavItem.name) {
+ mdNavItem.name = angular.element(element[0]
+ .querySelector('._md-nav-button-text')).text().trim();
+ }
+
+ navButton.on('keydown', function($event) {
+ mdNavBar.onKeydown($event);
+ });
+
+ navButton.on('focus', function() {
+ mdNavItem._focused = true;
+ });
+
+ navButton.on('click', function() {
+ // This triggers a watcher on mdNavBar.mdSelectedNavItem which calls
+ // MdNavBarController._updateTabs() after a $timeout. That function calls
+ // MdNavItemController.setSelected() for the old tab with false and the new tab with true.
+ mdNavBar.mdSelectedNavItem = mdNavItem.name;
+ scope.$apply();
+ });
+
+ // Get the disabled attribute value first, then setup observing of value changes
+ mdNavItem.disabled = $mdUtil.parseAttributeBoolean(attrs['disabled'], false);
+ if ('MutationObserver' in $window) {
+ var config = {attributes: true, attributeFilter: ['disabled']};
+ var targetNode = element[0];
+ var mutationCallback = function(mutationList) {
+ $mdUtil.nextTick(function() {
+ mdNavItem.disabled = $mdUtil.parseAttributeBoolean(attrs[mutationList[0].attributeName], false);
+ });
+ };
+ var observer = new MutationObserver(mutationCallback);
+ observer.observe(targetNode, config);
+ disconnect = observer.disconnect.bind(observer);
+ } else {
+ attrs.$observe('disabled', function (value) {
+ mdNavItem.disabled = $mdUtil.parseAttributeBoolean(value, false);
+ });
+ }
+
+ if (!mdNavItem.navItemAriaLabel) {
+ $mdAria.expectWithText(navButton, 'aria-label');
+ }
+ });
+
+ scope.$on('destroy', function() {
+ navButton.off('keydown');
+ navButton.off('focus');
+ navButton.off('click');
+ disconnect();
+ });
+ }
+ };
+}
+
+/**
+ * Controller for the nav-item component.
+ * @param {!JQLite} $element
+ * @constructor
+ * @final
+ * @ngInject
+ */
+function MdNavItemController($element) {
+
+ /**
+ * @private @const
+ * @type {!JQLite}
+ */
+ this._$element = $element;
+
+ // Data-bound variables
+
+ /**
+ * @const
+ * @type {?Function}
+ */
+ this.mdNavClick;
+
+ /**
+ * @const
+ * @type {?string}
+ */
+ this.mdNavHref;
+
+ /**
+ * @const
+ * @type {?string}
+ */
+ this.mdNavSref;
+ /**
+ * @const
+ * @type {?Object}
+ */
+ this.srefOpts;
+ /**
+ * @const
+ * @type {?string}
+ */
+ this.name;
+
+ /**
+ * @const
+ * @type {string}
+ */
+ this.navItemAriaLabel;
+
+ // State variables
+ /**
+ * @private
+ * @type {boolean}
+ */
+ this._selected = false;
+
+ /**
+ * @type {boolean}
+ */
+ this.isFocused = false;
+}
+
+/**
+ * Returns a map of class names and values for use by ng-class.
+ * @return {!Object<string,boolean>}
+ */
+MdNavItemController.prototype.getNgClassMap = function() {
+ return {
+ 'md-active': this._selected,
+ 'md-primary': this._selected,
+ 'md-unselected': !this._selected,
+ 'md-focused': this.isFocused,
+ };
+};
+
+/**
+ * Get the name attribute of the tab.
+ * @return {string}
+ */
+MdNavItemController.prototype.getName = function() {
+ return this.name;
+};
+
+/**
+ * Get the button element associated with the tab.
+ * @return {!Element}
+ */
+MdNavItemController.prototype.getButtonEl = function() {
+ return this._$element[0].querySelector('._md-nav-button');
+};
+
+/**
+ * Set the selected state of the tab and updates the tabindex.
+ * This function is called for the oldTab and newTab when selection changes.
+ * @param {boolean} isSelected true to select the tab, false to deselect the tab
+ */
+MdNavItemController.prototype.setSelected = function(isSelected) {
+ this._selected = isSelected;
+ if (isSelected) {
+ // https://www.w3.org/TR/wai-aria-practices/examples/tabs/tabs-2/tabs.html suggests that we call
+ // removeAttribute('tabindex') here, but that causes our unit tests to fail due to
+ // document.activeElement staying set to the body instead of the focused nav button.
+ this.getButtonEl().setAttribute('tabindex', '0');
+ } else {
+ this.getButtonEl().setAttribute('tabindex', '-1');
+ }
+};
+
+/**
+ * @return {boolean}
+ */
+MdNavItemController.prototype.isSelected = function() {
+ return this._selected;
+};
+
+/**
+ * Set the focused state of the tab.
+ * @param {boolean} isFocused
+ */
+MdNavItemController.prototype.setFocused = function(isFocused) {
+ this.isFocused = isFocused;
+
+ if (isFocused) {
+ this.getButtonEl().focus();
+ }
+};
+
+/**
+ * @return {boolean} true if the tab has focus, false if not.
+ */
+MdNavItemController.prototype.hasFocus = function() {
+ return this.isFocused;
+};
+
+/**
+ * @return {boolean} true if the tab is enabled, false if disabled.
+ * @private
+ */
+MdNavItemController.prototype._isEnabled = function() {
+ return !this._$element.attr('disabled');
+};
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.panel
+ */
+MdPanelService.$inject = ["presets", "$rootElement", "$rootScope", "$injector", "$window"];
+angular
+ .module('material.components.panel', [
+ 'material.core',
+ 'material.components.backdrop'
+ ])
+ .provider('$mdPanel', MdPanelProvider);
+
+
+/*****************************************************************************
+ * PUBLIC DOCUMENTATION *
+ *****************************************************************************/
+
+
+/**
+ * @ngdoc service
+ * @name $mdPanelProvider
+ * @module material.components.panel
+ *
+ * @description
+ * `$mdPanelProvider` allows users to create configuration presets that will be
+ * stored within a cached presets object. When the configuration is needed, the
+ * user can request the preset by passing it as the first parameter in the
+ * `$mdPanel.create` or `$mdPanel.open` methods.
+ *
+ * @usage
+ * <hljs lang="js">
+ * (function(angular, undefined) {
+ * 'use strict';
+ *
+ * angular
+ * .module('demoApp', ['ngMaterial'])
+ * .config(DemoConfig)
+ * .controller('DemoCtrl', DemoCtrl)
+ * .controller('DemoMenuCtrl', DemoMenuCtrl);
+ *
+ * function DemoConfig($mdPanelProvider) {
+ * $mdPanelProvider.definePreset('demoPreset', {
+ * attachTo: angular.element(document.body),
+ * controller: DemoMenuCtrl,
+ * controllerAs: 'ctrl',
+ * template: '' +
+ * '<div class="menu-panel" md-whiteframe="4">' +
+ * ' <div class="menu-content">' +
+ * ' <div class="menu-item" ng-repeat="item in ctrl.items">' +
+ * ' <button class="md-button">' +
+ * ' <span>{{item}}</span>' +
+ * ' </button>' +
+ * ' </div>' +
+ * ' <md-divider></md-divider>' +
+ * ' <div class="menu-item">' +
+ * ' <button class="md-button" ng-click="ctrl.closeMenu()">' +
+ * ' <span>Close Menu</span>' +
+ * ' </button>' +
+ * ' </div>' +
+ * ' </div>' +
+ * '</div>',
+ * panelClass: 'menu-panel-container',
+ * focusOnOpen: false,
+ * zIndex: 100,
+ * propagateContainerEvents: true,
+ * groupName: 'menus'
+ * });
+ * }
+ *
+ * function PanelProviderCtrl($mdPanel) {
+ * this.navigation = {
+ * name: 'navigation',
+ * items: [
+ * 'Home',
+ * 'About',
+ * 'Contact'
+ * ]
+ * };
+ * this.favorites = {
+ * name: 'favorites',
+ * items: [
+ * 'Add to Favorites'
+ * ]
+ * };
+ * this.more = {
+ * name: 'more',
+ * items: [
+ * 'Account',
+ * 'Sign Out'
+ * ]
+ * };
+ *
+ * $mdPanel.newPanelGroup('menus', {
+ * maxOpen: 2
+ * });
+ *
+ * this.showMenu = function($event, menu) {
+ * $mdPanel.open('demoPreset', {
+ * id: 'menu_' + menu.name,
+ * position: $mdPanel.newPanelPosition()
+ * .relativeTo($event.target)
+ * .addPanelPosition(
+ * $mdPanel.xPosition.ALIGN_START,
+ * $mdPanel.yPosition.BELOW
+ * ),
+ * locals: {
+ * items: menu.items
+ * },
+ * openFrom: $event
+ * });
+ * };
+ * }
+ *
+ * function PanelMenuCtrl(mdPanelRef) {
+ * // 'mdPanelRef' is injected in the controller.
+ * this.closeMenu = function() {
+ * if (mdPanelRef) {
+ * mdPanelRef.close();
+ * }
+ * };
+ * }
+ * })(angular);
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdPanelProvider#definePreset
+ * @description
+ * Takes the passed in preset name and preset configuration object and adds it
+ * to the `_presets` object of the provider. This `_presets` object is then
+ * passed along to the `$mdPanel` service.
+ *
+ * @param {string} name Preset name.
+ * @param {!Object} preset Specific configuration object that can contain any
+ * and all of the parameters available within the `$mdPanel.create` method.
+ * However, parameters that pertain to id, position, animation, and user
+ * interaction are not allowed and will be removed from the preset
+ * configuration.
+ */
+
+
+/*****************************************************************************
+ * MdPanel Service *
+ *****************************************************************************/
+
+
+/**
+ * @ngdoc service
+ * @name $mdPanel
+ * @module material.components.panel
+ *
+ * @description
+ * `$mdPanel` is a robust, low-level service for creating floating panels on
+ * the screen. It can be used to implement tooltips, dialogs, pop-ups, etc.
+ *
+ * The following types, referenced below, have separate documentation:
+ * - <a ng-href="api/type/MdPanelAnimation">MdPanelAnimation</a> from `$mdPanel.newPanelAnimation()`
+ * - <a ng-href="api/type/MdPanelPosition">MdPanelPosition</a> from `$mdPanel.newPanelPosition()`
+ * - <a ng-href="api/type/MdPanelRef">MdPanelRef</a> from the `$mdPanel.open()` Promise or
+ * injected in the panel's controller
+ *
+ * @usage
+ * <hljs lang="js">
+ * (function(angular, undefined) {
+ * 'use strict';
+ *
+ * angular
+ * .module('demoApp', ['ngMaterial'])
+ * .controller('DemoDialogController', DialogController)
+ * .controller('DemoCtrl', function($mdPanel) {
+ *
+ * var panelRef;
+ *
+ * function showPanel($event) {
+ * var panelPosition = $mdPanel.newPanelPosition()
+ * .absolute()
+ * .top('50%')
+ * .left('50%');
+ *
+ * var panelAnimation = $mdPanel.newPanelAnimation()
+ * .openFrom($event)
+ * .duration(200)
+ * .closeTo('.show-button')
+ * .withAnimation($mdPanel.animation.SCALE);
+ *
+ * var config = {
+ * attachTo: angular.element(document.body),
+ * controller: DialogController,
+ * controllerAs: 'ctrl',
+ * position: panelPosition,
+ * animation: panelAnimation,
+ * targetEvent: $event,
+ * templateUrl: 'dialog-template.html',
+ * clickOutsideToClose: true,
+ * escapeToClose: true,
+ * focusOnOpen: true
+ * };
+ *
+ * $mdPanel.open(config)
+ * .then(function(result) {
+ * panelRef = result;
+ * });
+ * }
+ * }
+ *
+ * function DialogController(MdPanelRef) {
+ * function closeDialog() {
+ * if (MdPanelRef) MdPanelRef.close();
+ * }
+ * }
+ * })(angular);
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdPanel#create
+ * @description
+ * Creates a panel with the specified options.
+ *
+ * @param {!Object=} config Specific configuration object that may contain the
+ * following properties:
+ *
+ * - `id` - `{string=}`: An ID to track the panel by. When an ID is provided,
+ * the created panel is added to a tracked panels object. Any subsequent
+ * requests made to create a panel with that ID are ignored. This is useful
+ * in having the panel service not open multiple panels from the same user
+ * interaction when there is no backdrop and events are propagated. Defaults
+ * to an arbitrary string that is not tracked.
+ * - `template` - `{string=}`: HTML template to show in the panel. This
+ * **must** be trusted HTML with respect to AngularJS’s
+ * [$sce service](https://docs.angularjs.org/api/ng/service/$sce).
+ * - `templateUrl` - `{string=}`: The URL that will be used as the content of
+ * the panel.
+ * - `contentElement` - `{(string|!JQLite|!Element)=}`: Pre-compiled
+ * element to be used as the panel's content.
+ * - `controller` - `{(function|string)=}`: The controller to associate with
+ * the panel. The controller can inject a reference to the returned
+ * panelRef, which allows the panel to be closed, hidden, and shown. Any
+ * fields passed in through locals or resolve will be bound to the
+ * controller.
+ * - `controllerAs` - `{string=}`: An alias to assign the controller to on
+ * the scope.
+ * - `bindToController` - `{boolean=}`: Binds locals to the controller
+ * instead of passing them in. Defaults to true, as this is a best
+ * practice.
+ * - `locals` - `{Object=}`: An object containing key/value pairs. The keys
+ * will be used as names of values to inject into the controller. For
+ * example, `locals: {three: 3}` would inject `three` into the controller,
+ * with the value 3. 'mdPanelRef' is a reserved key, and will always
+ * be set to the created `MdPanelRef` instance.
+ * - `resolve` - `{Object=}`: Similar to locals, except it takes promises as
+ * values. The panel will not open until all of the promises resolve.
+ * - `attachTo` - `{(string|!JQLite|!Element)=}`: The element to
+ * attach the panel to. Defaults to appending to the root element of the
+ * application.
+ * - `propagateContainerEvents` - `{boolean=}`: Whether pointer or touch
+ * events should be allowed to propagate 'go through' the container, aka the
+ * wrapper, of the panel. Defaults to false.
+ * - `panelClass` - `{string=}`: A css class to apply to the panel element.
+ * This class should define any borders, box-shadow, etc. for the panel.
+ * - `zIndex` - `{number=}`: The z-index to place the panel at.
+ * Defaults to 80.
+ * - `position` - `{MdPanelPosition=}`: An MdPanelPosition object that
+ * specifies the alignment of the panel. For more information, see
+ * `MdPanelPosition`.
+ * - `clickOutsideToClose` - `{boolean=}`: Whether the user can click
+ * outside the panel to close it. Defaults to false.
+ * - `escapeToClose` - `{boolean=}`: Whether the user can press escape to
+ * close the panel. Defaults to false.
+ * - `onCloseSuccess` - `{function(!panelRef, string)=}`: Function that is
+ * called after the close successfully finishes. The first parameter passed
+ * into this function is the current panelRef and the 2nd is an optional
+ * string explaining the close reason. The currently supported closeReasons
+ * can be found in the `MdPanelRef.closeReasons` enum. These are by default
+ * passed along by the panel.
+ * - `trapFocus` - `{boolean=}`: Whether focus should be trapped within the
+ * panel. If `trapFocus` is true, the user will not be able to interact
+ * with the rest of the page until the panel is dismissed. Defaults to
+ * false.
+ * - `focusOnOpen` - `{boolean=}`: An option to override focus behavior on
+ * open. Only disable if focusing some other way, as focus management is
+ * required for panels to be accessible. Defaults to true.
+ * - `fullscreen` - `{boolean=}`: Whether the panel should be full screen.
+ * Applies the class `._md-panel-fullscreen` to the panel on open. Defaults
+ * to false.
+ * - `animation` - `{MdPanelAnimation=}`: An MdPanelAnimation object that
+ * specifies the animation of the panel. For more information, see
+ * `MdPanelAnimation`.
+ * - `hasBackdrop` - `{boolean=}`: Whether there should be an opaque backdrop
+ * behind the panel. Defaults to false.
+ * - `disableParentScroll` - `{boolean=}`: Whether the user can scroll the
+ * page behind the panel. Defaults to false.
+ * - `onDomAdded` - `{function=}`: Callback function used to announce when
+ * the panel is added to the DOM.
+ * - `onOpenComplete` - `{function=}`: Callback function used to announce
+ * when the open() action is finished.
+ * - `onRemoving` - `{function=}`: Callback function used to announce the
+ * close/hide() action is starting.
+ * - `onDomRemoved` - `{function=}`: Callback function used to announce when
+ * the panel is removed from the DOM.
+ * - `origin` - `{(string|!JQLite|!Element)=}`: The element to focus
+ * on when the panel closes. This is commonly the element which triggered
+ * the opening of the panel. If you do not use `origin`, you need to control
+ * the focus manually.
+ * - `groupName` - `{(string|!Array<string>)=}`: A group name or an array of
+ * group names. The group name is used for creating a group of panels. The
+ * group is used for configuring the number of open panels and identifying
+ * specific behaviors for groups. For instance, all tooltips could be
+ * identified using the same groupName.
+ *
+ * @returns {!MdPanelRef} panelRef
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdPanel#open
+ * @description
+ * Calls the create method above, then opens the panel. This is a shortcut for
+ * creating and then calling open manually. If custom methods need to be
+ * called when the panel is added to the DOM or opened, do not use this method.
+ * Instead create the panel, chain promises on the domAdded and openComplete
+ * methods, and call open from the returned panelRef.
+ *
+ * @param {!Object=} config Specific configuration object that may contain
+ * the properties defined in `$mdPanel.create`.
+ * @returns {!Q.IPromise<!MdPanelRef>} panelRef A promise that resolves
+ * to an instance of the panel.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdPanel#newPanelPosition
+ * @description
+ * Returns a new instance of the MdPanelPosition object. Use this to create
+ * the position config object.
+ *
+ * @returns {!MdPanelPosition} panelPosition
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdPanel#newPanelAnimation
+ * @description
+ * Returns a new instance of the MdPanelAnimation object. Use this to create
+ * the animation config object.
+ *
+ * @returns {!MdPanelAnimation} panelAnimation
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdPanel#setGroupMaxOpen
+ * @description
+ * Sets the maximum number of panels in a group that can be opened at a given
+ * time.
+ *
+ * @param {string} groupName The name of the group to configure.
+ * @param {number} maxOpen The maximum number of panels that can be
+ * opened. Infinity can be passed in to remove the maxOpen limit.
+ */
+
+
+/*****************************************************************************
+ * MdPanelRef *
+ *****************************************************************************/
+
+
+/**
+ * @ngdoc type
+ * @name MdPanelRef
+ * @module material.components.panel
+ * @description
+ * A reference to a created panel. This reference contains a unique id for the
+ * panel, along with the following properties:
+ *
+ * - `id` - `{string}`: The unique id for the panel. This id is used to track
+ * when a panel was interacted with.
+ * - `config` - `{!Object=}`: The entire config object that was used in
+ * create.
+ * - `isAttached` - `{boolean}`: Whether the panel is attached to the DOM.
+ * Visibility to the user does not factor into isAttached.
+ * - `panelContainer` - `{JQLite}`: The wrapper element containing the
+ * panel. This property is added in order to have access to the `addClass`,
+ * `removeClass`, `toggleClass`, etc methods.
+ * - `panelEl` - `{JQLite}`: The panel element. This property is added
+ * in order to have access to the `addClass`, `removeClass`, `toggleClass`,
+ * etc methods.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#open
+ * @description
+ * Attaches and shows the panel.
+ *
+ * @returns {!Q.IPromise} A promise that is resolved when the panel is
+ * opened.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#close
+ * @description
+ * Hides and detaches the panel. Note that this will **not** destroy the panel.
+ * If you don't intend on using the panel again, call the {@link #destroy
+ * destroy} method afterwards.
+ *
+ * @returns {!Q.IPromise} A promise that is resolved when the panel is
+ * closed.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#attach
+ * @description
+ * Create the panel elements and attach them to the DOM. The panel will be
+ * hidden by default.
+ *
+ * @returns {!Q.IPromise} A promise that is resolved when the panel is
+ * attached.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#detach
+ * @description
+ * Removes the panel from the DOM. This will NOT hide the panel before removing
+ * it.
+ *
+ * @returns {!Q.IPromise} A promise that is resolved when the panel is
+ * detached.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#show
+ * @description
+ * Shows the panel.
+ *
+ * @returns {!Q.IPromise} A promise that is resolved when the panel has
+ * shown and animations are completed.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#hide
+ * @description
+ * Hides the panel.
+ *
+ * @returns {!Q.IPromise} A promise that is resolved when the panel has
+ * hidden and animations are completed.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#destroy
+ * @description
+ * Destroys the panel. The panel cannot be opened again after this is called.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#updatePosition
+ * @description
+ * Updates the position configuration of a panel. Use this to update the
+ * position of a panel that is open, without having to close and re-open the
+ * panel.
+ *
+ * @param {!MdPanelPosition} position
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#addToGroup
+ * @description
+ * Adds a panel to a group if the panel does not exist within the group already.
+ * A panel can only exist within a single group.
+ *
+ * @param {string} groupName The name of the group to add the panel to.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#removeFromGroup
+ * @description
+ * Removes a panel from a group if the panel exists within that group. The group
+ * must be created ahead of time.
+ *
+ * @param {string} groupName The name of the group.
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#registerInterceptor
+ * @description
+ * Registers an interceptor with the panel. The callback should return a promise,
+ * which will allow the action to continue when it gets resolved, or will
+ * prevent an action if it is rejected. The interceptors are called sequentially
+ * and it reverse order. `type` must be one of the following
+ * values available on `$mdPanel.interceptorTypes`:
+ * * `CLOSE` - Gets called before the panel begins closing.
+ *
+ * @param {string} type Type of interceptor.
+ * @param {!Q.IPromise<any>} callback Callback to be registered.
+ * @returns {!MdPanelRef}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#removeInterceptor
+ * @description
+ * Removes a registered interceptor.
+ *
+ * @param {string} type Type of interceptor to be removed.
+ * @param {function(): !Q.IPromise<any>} callback Interceptor to be removed.
+ * @returns {!MdPanelRef}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#removeAllInterceptors
+ * @description
+ * Removes all interceptors. If a type is supplied, only the
+ * interceptors of that type will be cleared.
+ *
+ * @param {string=} type Type of interceptors to be removed.
+ * @returns {!MdPanelRef}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelRef#updateAnimation
+ * @description
+ * Updates the animation configuration for a panel. You can use this to change
+ * the panel's animation without having to re-create it.
+ *
+ * @param {!MdPanelAnimation} animation
+ */
+
+
+/*****************************************************************************
+ * MdPanelPosition *
+ *****************************************************************************/
+
+
+/**
+ * @ngdoc type
+ * @name MdPanelPosition
+ * @module material.components.panel
+ * @description
+ *
+ * Object for configuring the position of the panel.
+ *
+ * @usage
+ *
+ * #### Centering the panel
+ *
+ * <hljs lang="js">
+ * new MdPanelPosition().absolute().center();
+ * </hljs>
+ *
+ * #### Overlapping the panel with an element
+ *
+ * <hljs lang="js">
+ * new MdPanelPosition()
+ * .relativeTo(someElement)
+ * .addPanelPosition(
+ * $mdPanel.xPosition.ALIGN_START,
+ * $mdPanel.yPosition.ALIGN_TOPS
+ * );
+ * </hljs>
+ *
+ * #### Aligning the panel with the bottom of an element
+ *
+ * <hljs lang="js">
+ * new MdPanelPosition()
+ * .relativeTo(someElement)
+ * .addPanelPosition($mdPanel.xPosition.CENTER, $mdPanel.yPosition.BELOW);
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#absolute
+ * @description
+ * Positions the panel absolutely relative to the parent element. If the parent
+ * is document.body, this is equivalent to positioning the panel absolutely
+ * within the viewport.
+ *
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#relativeTo
+ * @description
+ * Positions the panel relative to a specific element.
+ *
+ * @param {string|!Element|!JQLite} element Query selector, DOM element,
+ * or angular element to position the panel with respect to.
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#top
+ * @description
+ * Sets the value of `top` for the panel. Clears any previously set vertical
+ * position.
+ *
+ * @param {string=} top Value of `top`. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#bottom
+ * @description
+ * Sets the value of `bottom` for the panel. Clears any previously set vertical
+ * position.
+ *
+ * @param {string=} bottom Value of `bottom`. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#start
+ * @description
+ * Sets the panel to the start of the page - `left` if `ltr` or `right` for
+ * `rtl`. Clears any previously set horizontal position.
+ *
+ * @param {string=} start Value of position. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#end
+ * @description
+ * Sets the panel to the end of the page - `right` if `ltr` or `left` for `rtl`.
+ * Clears any previously set horizontal position.
+ *
+ * @param {string=} end Value of position. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#left
+ * @description
+ * Sets the value of `left` for the panel. Clears any previously set
+ * horizontal position.
+ *
+ * @param {string=} left Value of `left`. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#right
+ * @description
+ * Sets the value of `right` for the panel. Clears any previously set
+ * horizontal position.
+ *
+ * @param {string=} right Value of `right`. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#centerHorizontally
+ * @description
+ * Centers the panel horizontally in the viewport. Clears any previously set
+ * horizontal position.
+ *
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#centerVertically
+ * @description
+ * Centers the panel vertically in the viewport. Clears any previously set
+ * vertical position.
+ *
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#center
+ * @description
+ * Centers the panel horizontally and vertically in the viewport. This is
+ * equivalent to calling both `centerHorizontally` and `centerVertically`.
+ * Clears any previously set horizontal and vertical positions.
+ *
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#addPanelPosition
+ * @description
+ * Sets the x and y position for the panel relative to another element. Can be
+ * called multiple times to specify an ordered list of panel positions. The
+ * first position which allows the panel to be completely on-screen will be
+ * chosen; the last position will be chose whether it is on-screen or not.
+ *
+ * xPosition must be one of the following values available on
+ * $mdPanel.xPosition:
+ *
+ *
+ * CENTER | ALIGN_START | ALIGN_END | OFFSET_START | OFFSET_END
+ *
+ * <pre>
+ * *************
+ * * *
+ * * PANEL *
+ * * *
+ * *************
+ * A B C D E
+ *
+ * A: OFFSET_START (for LTR displays)
+ * B: ALIGN_START (for LTR displays)
+ * C: CENTER
+ * D: ALIGN_END (for LTR displays)
+ * E: OFFSET_END (for LTR displays)
+ * </pre>
+ *
+ * yPosition must be one of the following values available on
+ * $mdPanel.yPosition:
+ *
+ * CENTER | ALIGN_TOPS | ALIGN_BOTTOMS | ABOVE | BELOW
+ *
+ * <pre>
+ * F
+ * G *************
+ * * *
+ * H * PANEL *
+ * * *
+ * I *************
+ * J
+ *
+ * F: BELOW
+ * G: ALIGN_TOPS
+ * H: CENTER
+ * I: ALIGN_BOTTOMS
+ * J: ABOVE
+ * </pre>
+ *
+ * @param {string} xPosition
+ * @param {string} yPosition
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#withOffsetX
+ * @description
+ * Sets the value of the offset in the x-direction.
+ *
+ * @param {string|number} offsetX
+ * @returns {!MdPanelPosition}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelPosition#withOffsetY
+ * @description
+ * Sets the value of the offset in the y-direction.
+ *
+ * @param {string|number} offsetY
+ * @returns {!MdPanelPosition}
+ */
+
+
+/*****************************************************************************
+ * MdPanelAnimation *
+ *****************************************************************************/
+
+
+/**
+ * @ngdoc type
+ * @name MdPanelAnimation
+ * @module material.components.panel
+ * @description
+ * Animation configuration object. To use, create an MdPanelAnimation with the
+ * desired properties, then pass the object as part of $mdPanel creation.
+ *
+ * @usage
+ *
+ * <hljs lang="js">
+ * var panelAnimation = new MdPanelAnimation()
+ * .openFrom(myButtonEl)
+ * .duration(1337)
+ * .closeTo('.my-button')
+ * .withAnimation($mdPanel.animation.SCALE);
+ *
+ * $mdPanel.create({
+ * animation: panelAnimation
+ * });
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelAnimation#openFrom
+ * @description
+ * Specifies where to start the open animation. `openFrom` accepts a
+ * click event object, query selector, DOM element, or a Rect object that
+ * is used to determine the bounds. When passed a click event, the location
+ * of the click will be used as the position to start the animation.
+ *
+ * @param {string|!Element|!Event|{top: number, left: number}}
+ * @returns {!MdPanelAnimation}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelAnimation#closeTo
+ * @description
+ * Specifies where to animate the panel close. `closeTo` accepts a
+ * query selector, DOM element, or a Rect object that is used to determine
+ * the bounds.
+ *
+ * @param {string|!Element|{top: number, left: number}}
+ * @returns {!MdPanelAnimation}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelAnimation#withAnimation
+ * @description
+ * Specifies the animation class.
+ *
+ * There are several default animations that can be used: `$mdPanel.animation.`
+ * - `SLIDE`: The panel slides in and out from the specified
+ * elements. It will not fade in or out.
+ * - `SCALE`: The panel scales in and out. Slide and fade are
+ * included in this animation.
+ * - `FADE`: The panel fades in and out.
+ *
+ * Custom classes will by default fade in and out unless
+ * `transition: opacity 1ms` is added to the to custom class.
+ *
+ * @param {string|{open: string, close: string}} cssClass
+ * @returns {!MdPanelAnimation}
+ */
+
+/**
+ * @ngdoc method
+ * @name MdPanelAnimation#duration
+ * @description
+ * Specifies the duration of the animation in milliseconds. The `duration`
+ * method accepts either a number or an object with separate open and close
+ * durations.
+ *
+ * @param {number|{open: number, close: number}} duration
+ * @returns {!MdPanelAnimation}
+ */
+
+
+/*****************************************************************************
+ * PUBLIC DOCUMENTATION *
+ *****************************************************************************/
+
+
+var MD_PANEL_Z_INDEX = 80;
+var MD_PANEL_HIDDEN = '_md-panel-hidden';
+var FOCUS_TRAP_TEMPLATE = angular.element(
+ '<div class="_md-panel-focus-trap" tabindex="0"></div>');
+
+var _presets = {};
+
+
+/**
+ * A provider that is used for creating presets for the panel API.
+ * @final @constructor @ngInject
+ */
+function MdPanelProvider() {
+ return {
+ 'definePreset': definePreset,
+ 'getAllPresets': getAllPresets,
+ 'clearPresets': clearPresets,
+ '$get': $getProvider()
+ };
+}
+
+
+/**
+ * Takes the passed in panel configuration object and adds it to the `_presets`
+ * object at the specified name.
+ * @param {string} name Name of the preset to set.
+ * @param {!Object} preset Specific configuration object that can contain any
+ * and all of the parameters available within the `$mdPanel.create` method.
+ * However, parameters that pertain to id, position, animation, and user
+ * interaction are not allowed and will be removed from the preset
+ * configuration.
+ */
+function definePreset(name, preset) {
+ if (!name || !preset) {
+ throw new Error('mdPanelProvider: The panel preset definition is ' +
+ 'malformed. The name and preset object are required.');
+ } else if (_presets.hasOwnProperty(name)) {
+ throw new Error('mdPanelProvider: The panel preset you have requested ' +
+ 'has already been defined.');
+ }
+
+ // Delete any property on the preset that is not allowed.
+ delete preset.id;
+ delete preset.position;
+ delete preset.animation;
+
+ _presets[name] = preset;
+}
+
+
+/**
+ * Gets a clone of the `_presets`.
+ * @return {!Object}
+ */
+function getAllPresets() {
+ return angular.copy(_presets);
+}
+
+
+/**
+ * Clears all of the stored presets.
+ */
+function clearPresets() {
+ _presets = {};
+}
+
+
+/**
+ * Represents the `$get` method of the AngularJS provider. From here, a new
+ * reference to the MdPanelService is returned where the needed arguments are
+ * passed in including the MdPanelProvider `_presets`.
+ * @param {!Object} _presets
+ * @param {!JQLite} $rootElement
+ * @param {!angular.Scope} $rootScope
+ * @param {!IInjectorService} $injector
+ * @param {!IWindowService} $window
+ */
+function $getProvider() {
+ return [
+ '$rootElement', '$rootScope', '$injector', '$window',
+ function($rootElement, $rootScope, $injector, $window) {
+ return new MdPanelService(_presets, $rootElement, $rootScope,
+ $injector, $window);
+ }
+ ];
+}
+
+/**
+ * @param {string|[]} value
+ * @returns {[]} the input string wrapped in an Array or the original Array
+ */
+function coerceToArray(value) {
+ if (angular.isString(value)) {
+ value = [value];
+ }
+ return value;
+}
+
+/*****************************************************************************
+ * MdPanel Service *
+ *****************************************************************************/
+
+
+/**
+ * A service that is used for controlling/displaying panels on the screen.
+ * @param {!Object} presets
+ * @param {!JQLite} $rootElement
+ * @param {!angular.Scope} $rootScope
+ * @param {!IInjectorService} $injector
+ * @param {!IWindowService} $window
+ * @final @constructor @ngInject
+ */
+function MdPanelService(presets, $rootElement, $rootScope, $injector, $window) {
+ /**
+ * Default config options for the panel.
+ * Anything angular related needs to be done later. Therefore
+ * scope: $rootScope.$new(true),
+ * attachTo: $rootElement,
+ * are added later.
+ * @private {!Object}
+ */
+ this._defaultConfigOptions = {
+ bindToController: true,
+ clickOutsideToClose: false,
+ disableParentScroll: false,
+ escapeToClose: false,
+ focusOnOpen: true,
+ fullscreen: false,
+ hasBackdrop: false,
+ propagateContainerEvents: false,
+ transformTemplate: angular.bind(this, this._wrapTemplate),
+ trapFocus: false,
+ zIndex: MD_PANEL_Z_INDEX
+ };
+
+ /** @private {!Object} */
+ this._config = {};
+
+ /** @private {!Object} */
+ this._presets = presets;
+
+ /** @private @const */
+ this._$rootElement = $rootElement;
+
+ /** @private @const */
+ this._$rootScope = $rootScope;
+
+ /** @private @const */
+ this._$injector = $injector;
+
+ /** @private @const */
+ this._$window = $window;
+
+ /** @private @const */
+ this._$mdUtil = this._$injector.get('$mdUtil');
+
+ /** @private {!Object<string, !MdPanelRef>} */
+ this._trackedPanels = {};
+
+ /**
+ * @private {!Object<string,
+ * {panels: !Array<!MdPanelRef>,
+ * openPanels: !Array<!MdPanelRef>,
+ * maxOpen: number}>}
+ */
+ this._groups = Object.create(null);
+
+ /**
+ * Default animations that can be used within the panel.
+ * @type {enum}
+ */
+ this.animation = MdPanelAnimation.animation;
+
+ /**
+ * Possible values of xPosition for positioning the panel relative to
+ * another element.
+ * @type {enum}
+ */
+ this.xPosition = MdPanelPosition.xPosition;
+
+ /**
+ * Possible values of yPosition for positioning the panel relative to
+ * another element.
+ * @type {enum}
+ */
+ this.yPosition = MdPanelPosition.yPosition;
+
+ /**
+ * Possible values for the interceptors that can be registered on a panel.
+ * @type {enum}
+ */
+ this.interceptorTypes = MdPanelRef.interceptorTypes;
+
+ /**
+ * Possible values for closing of a panel.
+ * @type {enum}
+ */
+ this.closeReasons = MdPanelRef.closeReasons;
+
+ /**
+ * Possible values of absolute position.
+ * @type {enum}
+ */
+ this.absPosition = MdPanelPosition.absPosition;
+}
+
+
+/**
+ * Creates a panel with the specified options.
+ * @param {string|Object=} preset Name of a preset configuration that can be used to
+ * extend the panel configuration.
+ * @param {!Object=} config Configuration object for the panel.
+ * @returns {!MdPanelRef}
+ */
+MdPanelService.prototype.create = function(preset, config) {
+ if (typeof preset === 'string') {
+ preset = this._getPresetByName(preset);
+ } else if (typeof preset === 'object' &&
+ (angular.isUndefined(config) || !config)) {
+ config = preset;
+ preset = {};
+ }
+
+ preset = preset || {};
+ config = config || {};
+
+ // If the passed-in config contains an ID and the ID is within _trackedPanels,
+ // return the tracked panel after updating its config with the passed-in
+ // config.
+ if (angular.isDefined(config.id) && this._trackedPanels[config.id]) {
+ var trackedPanel = this._trackedPanels[config.id];
+ angular.extend(trackedPanel.config, config);
+ return trackedPanel;
+ }
+
+ // Combine the passed-in config, the _defaultConfigOptions, and the preset
+ // configuration into the `_config`.
+ this._config = angular.extend({
+ // If no ID is set within the passed-in config, then create an arbitrary ID.
+ id: config.id || 'panel_' + this._$mdUtil.nextUid(),
+ scope: this._$rootScope.$new(true),
+ attachTo: this._$rootElement
+ }, this._defaultConfigOptions, config, preset);
+
+ // Create the panelRef and add it to the `_trackedPanels` object.
+ var panelRef = new MdPanelRef(this._config, this._$injector);
+ this._trackedPanels[this._config.id] = panelRef;
+
+ // Add the panel to each of its requested groups.
+ if (this._config.groupName) {
+ this._config.groupName = coerceToArray(this._config.groupName);
+ angular.forEach(this._config.groupName, function(group) {
+ panelRef.addToGroup(group);
+ });
+ }
+
+ this._config.scope.$on('$destroy', angular.bind(panelRef, panelRef.detach));
+
+ return panelRef;
+};
+
+
+/**
+ * Creates and opens a panel with the specified options.
+ * @param {string=} preset Name of a preset configuration that can be used to
+ * extend the panel configuration.
+ * @param {!Object=} config Configuration object for the panel.
+ * @returns {!Q.IPromise<!MdPanelRef>} The panel created from create.
+ */
+MdPanelService.prototype.open = function(preset, config) {
+ var panelRef = this.create(preset, config);
+ return panelRef.open().then(function() {
+ return panelRef;
+ });
+};
+
+
+/**
+ * Gets a specific preset configuration object saved within `_presets`.
+ * @param {string} preset Name of the preset to search for.
+ * @returns {!Object} The preset configuration object.
+ */
+MdPanelService.prototype._getPresetByName = function(preset) {
+ if (!this._presets[preset]) {
+ throw new Error('mdPanel: The panel preset configuration that you ' +
+ 'requested does not exist. Use the $mdPanelProvider to create a ' +
+ 'preset before requesting one.');
+ }
+ return this._presets[preset];
+};
+
+
+/**
+ * Returns a new instance of the MdPanelPosition. Use this to create the
+ * positioning object.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelService.prototype.newPanelPosition = function() {
+ return new MdPanelPosition(this._$injector);
+};
+
+
+/**
+ * Returns a new instance of the MdPanelAnimation. Use this to create the
+ * animation object.
+ * @returns {!MdPanelAnimation}
+ */
+MdPanelService.prototype.newPanelAnimation = function() {
+ return new MdPanelAnimation(this._$injector);
+};
+
+
+/**
+ * @ngdoc method
+ * @name $mdPanel#newPanelGroup
+ * @description
+ * Creates a panel group and adds it to a tracked list of panel groups.
+ * @param {string} groupName Name of the group to create.
+ * @param {{maxOpen: number}=} config Configuration object that may contain the following
+ * properties:
+ *
+ * - `maxOpen`: The maximum number of panels that are allowed open within a defined panel group.
+ *
+ * @returns {!{panels: !Array<!MdPanelRef>, openPanels: !Array<!MdPanelRef>, maxOpen: number}}
+ * the new panel group
+ */
+MdPanelService.prototype.newPanelGroup = function(groupName, config) {
+ if (!this._groups[groupName]) {
+ config = config || {};
+ this._groups[groupName] = {
+ panels: [],
+ openPanels: [],
+ maxOpen: config.maxOpen > 0 ? config.maxOpen : Infinity
+ };
+ }
+ return this._groups[groupName];
+};
+
+
+/**
+ * Sets the maximum number of panels in a group that can be opened at a given
+ * time.
+ * @param {string} groupName The name of the group to configure.
+ * @param {number} maxOpen The maximum number of panels that can be
+ * opened. Infinity can be passed in to remove the maxOpen limit.
+ */
+MdPanelService.prototype.setGroupMaxOpen = function(groupName, maxOpen) {
+ if (this._groups[groupName]) {
+ this._groups[groupName].maxOpen = maxOpen;
+ } else {
+ throw new Error('mdPanel: Group does not exist yet. Call newPanelGroup().');
+ }
+};
+
+
+/**
+ * Determines if the current number of open panels within a group exceeds the
+ * limit of allowed open panels.
+ * @param {string} groupName The name of the group to check.
+ * @returns {boolean} true if open count does exceed maxOpen and false if not.
+ * @private
+ */
+MdPanelService.prototype._openCountExceedsMaxOpen = function(groupName) {
+ if (this._groups[groupName]) {
+ var group = this._groups[groupName];
+ return group.maxOpen > 0 && group.openPanels.length > group.maxOpen;
+ }
+ return false;
+};
+
+
+/**
+ * Closes the first open panel within a specific group.
+ * @param {string} groupName The name of the group.
+ * @private
+ */
+MdPanelService.prototype._closeFirstOpenedPanel = function(groupName) {
+ var group = this._groups[groupName];
+ if (group && group.openPanels.length) {
+ group.openPanels[0].close();
+ }
+};
+
+
+/**
+ * Wraps the user's template in three elements:
+ * - md-panel-outer-wrapper - covers the entire `attachTo` element.
+ * - md-panel-inner-wrapper - handles the positioning.
+ * - md-panel - contains the user's content and deals with the animations.
+ * @param {string} origTemplate The original template.
+ * @returns {string} The wrapped template.
+ * @private
+ */
+MdPanelService.prototype._wrapTemplate = function(origTemplate) {
+ var template = origTemplate || '';
+
+ // The panel should be initially rendered offscreen so we can calculate
+ // height and width for positioning.
+ return '' +
+ '<div class="md-panel-outer-wrapper">' +
+ '<div class="md-panel-inner-wrapper _md-panel-offscreen">' +
+ '<div class="md-panel _md-panel-offscreen">' + template + '</div>' +
+ '</div>' +
+ '</div>';
+};
+
+
+/**
+ * Wraps a content element in a `md-panel-outer-wrapper`, as well as
+ * a `md-panel-inner-wrapper`, and positions it off-screen. Allows for
+ * proper control over positioning and animations.
+ * @param {!JQLite} contentElement Element to be wrapped.
+ * @return {!JQLite} Wrapper element.
+ * @private
+ */
+MdPanelService.prototype._wrapContentElement = function(contentElement) {
+ var outerWrapper = angular.element(
+ '<div class="md-panel-outer-wrapper">' +
+ '<div class="md-panel-inner-wrapper _md-panel-offscreen"></div>' +
+ '</div>'
+ );
+
+ contentElement.addClass('md-panel _md-panel-offscreen');
+ outerWrapper.children().eq(0).append(contentElement);
+
+ return outerWrapper;
+};
+
+
+/*****************************************************************************
+ * MdPanelRef *
+ *****************************************************************************/
+
+
+/**
+ * A reference to a created panel. This reference contains a unique id for the
+ * panel, along with properties/functions used to control the panel.
+ * @param {!Object} config
+ * @param {!IInjectorService} $injector
+ * @final @constructor
+ */
+function MdPanelRef(config, $injector) {
+ // Injected variables.
+ /** @private @const {!IQService} */
+ this._$q = $injector.get('$q');
+
+ /** @private @const {!angular.$mdCompiler} */
+ this._$mdCompiler = $injector.get('$mdCompiler');
+
+ /** @private @const {!angular.$mdConstant} */
+ this._$mdConstant = $injector.get('$mdConstant');
+
+ /** @private @const {!angular.$mdUtil} */
+ this._$mdUtil = $injector.get('$mdUtil');
+
+ /** @private @const {!angular.$mdTheming} */
+ this._$mdTheming = $injector.get('$mdTheming');
+
+ /** @private @const {!IRootScopeService} */
+ this._$rootScope = $injector.get('$rootScope');
+
+ /** @private @const {!angular.$animate} */
+ this._$animate = $injector.get('$animate');
+
+ /** @private @const {!MdPanelRef} */
+ this._$mdPanel = $injector.get('$mdPanel');
+
+ /** @private @const {!ILogService} */
+ this._$log = $injector.get('$log');
+
+ /** @private @const {!IWindowService} */
+ this._$window = $injector.get('$window');
+
+ /** @private @const {!Function} */
+ this._$$rAF = $injector.get('$$rAF');
+
+ // Public variables.
+ /**
+ * Unique id for the panelRef.
+ * @type {string}
+ */
+ this.id = config.id;
+
+ /** @type {!Object} */
+ this.config = config;
+
+ /** @type {!JQLite|undefined} */
+ this.panelContainer = undefined;
+
+ /** @type {!JQLite|undefined} */
+ this.panelEl = undefined;
+
+ /** @type {!JQLite|undefined} */
+ this.innerWrapper = undefined;
+
+ /**
+ * Whether the panel is attached. This is synchronous. When attach is called,
+ * isAttached is set to true. When detach is called, isAttached is set to
+ * false.
+ * @type {boolean}
+ */
+ this.isAttached = false;
+
+ // Private variables.
+ /** @private {Array<function()>} */
+ this._removeListeners = [];
+
+ /** @private {!JQLite|undefined} */
+ this._topFocusTrap = undefined;
+
+ /** @private {!JQLite|undefined} */
+ this._bottomFocusTrap = undefined;
+
+ /** @private {!$mdPanel|undefined} */
+ this._backdropRef = undefined;
+
+ /** @private {Function?} */
+ this._restoreScroll = null;
+
+ /**
+ * Keeps track of all the panel interceptors.
+ * @private {!Object}
+ */
+ this._interceptors = Object.create(null);
+
+ /**
+ * Cleanup function, provided by `$mdCompiler` and assigned after the element
+ * has been compiled. When `contentElement` is used, the function is used to
+ * restore the element to it's proper place in the DOM.
+ * @private {Function|null}
+ */
+ this._compilerCleanup = null;
+
+ /**
+ * Cache for saving and restoring element inline styles, CSS classes etc.
+ * @type {{styles: string, classes: string}}
+ */
+ this._restoreCache = {
+ styles: '',
+ classes: ''
+ };
+}
+
+
+MdPanelRef.interceptorTypes = {
+ CLOSE: 'onClose'
+};
+
+
+/**
+ * Opens an already created and configured panel. If the panel is already
+ * visible, does nothing.
+ * @returns {!Q.IPromise<!MdPanelRef>} A promise that is resolved when
+ * the panel is opened and animations finish.
+ */
+MdPanelRef.prototype.open = function() {
+ var self = this;
+ return this._$q(function(resolve, reject) {
+ var done = self._done(resolve, self);
+ var show = self._simpleBind(self.show, self);
+ var checkGroupMaxOpen = function() {
+ if (self.config.groupName) {
+ self.config.groupName = coerceToArray(self.config.groupName);
+ angular.forEach(self.config.groupName, function(group) {
+ if (self._$mdPanel._openCountExceedsMaxOpen(group)) {
+ self._$mdPanel._closeFirstOpenedPanel(group);
+ }
+ });
+ }
+ };
+
+ self.attach()
+ .then(show)
+ .then(checkGroupMaxOpen)
+ .then(done)
+ .catch(reject);
+ });
+};
+
+
+/**
+ * Closes the panel.
+ * @param {string} closeReason The event type that triggered the close.
+ * @returns {!Q.IPromise<!MdPanelRef>} A promise that is resolved when
+ * the panel is closed and animations finish.
+ */
+MdPanelRef.prototype.close = function(closeReason) {
+ var self = this;
+
+ return this._$q(function(resolve, reject) {
+ self._callInterceptors(MdPanelRef.interceptorTypes.CLOSE).then(function() {
+ var done = self._done(resolve, self);
+ var detach = self._simpleBind(self.detach, self);
+ var onCloseSuccess = self.config['onCloseSuccess'] || angular.noop;
+ onCloseSuccess = angular.bind(self, onCloseSuccess, self, closeReason);
+
+ self.hide()
+ .then(detach)
+ .then(done)
+ .then(onCloseSuccess)
+ .catch(reject);
+ }, reject);
+ });
+};
+
+
+/**
+ * Attaches the panel. The panel will be hidden afterwards.
+ * @returns {!Q.IPromise<!MdPanelRef>} A promise that is resolved when
+ * the panel is attached.
+ */
+MdPanelRef.prototype.attach = function() {
+ if (this.isAttached && this.panelEl) {
+ return this._$q.when(this);
+ }
+
+ var self = this;
+ return this._$q(function(resolve, reject) {
+ var done = self._done(resolve, self);
+ var onDomAdded = self.config['onDomAdded'] || angular.noop;
+ var addListeners = function(response) {
+ self.isAttached = true;
+ self._addEventListeners();
+ return response;
+ };
+
+ self._$q.all([
+ self._createBackdrop(),
+ self._createPanel()
+ .then(addListeners)
+ .catch(reject)
+ ]).then(onDomAdded)
+ .then(done)
+ .catch(reject);
+ });
+};
+
+
+/**
+ * Only detaches the panel. Will NOT hide the panel first.
+ * @returns {!Q.IPromise<!MdPanelRef>} A promise that is resolved when
+ * the panel is detached.
+ */
+MdPanelRef.prototype.detach = function() {
+ if (!this.isAttached) {
+ return this._$q.when(this);
+ }
+
+ var self = this;
+ var onDomRemoved = self.config['onDomRemoved'] || angular.noop;
+
+ var detachFn = function() {
+ self._removeEventListeners();
+
+ // Remove the focus traps that we added earlier for keeping focus within
+ // the panel.
+ if (self._topFocusTrap && self._topFocusTrap.parentNode) {
+ self._topFocusTrap.parentNode.removeChild(self._topFocusTrap);
+ }
+
+ if (self._bottomFocusTrap && self._bottomFocusTrap.parentNode) {
+ self._bottomFocusTrap.parentNode.removeChild(self._bottomFocusTrap);
+ }
+
+ if (self._restoreCache.classes) {
+ self.panelEl[0].className = self._restoreCache.classes;
+ }
+
+ // Either restore the saved styles or clear the ones set by mdPanel.
+ self.panelEl[0].style.cssText = self._restoreCache.styles || '';
+
+ self._compilerCleanup();
+ self.panelContainer.remove();
+ self.isAttached = false;
+ return self._$q.when(self);
+ };
+
+ if (this._restoreScroll) {
+ this._restoreScroll();
+ this._restoreScroll = null;
+ }
+
+ return this._$q(function(resolve, reject) {
+ var done = self._done(resolve, self);
+
+ self._$q.all([
+ detachFn(),
+ self._backdropRef ? self._backdropRef.detach() : true
+ ]).then(onDomRemoved)
+ .then(done)
+ .catch(reject);
+ });
+};
+
+
+/**
+ * Destroys the panel. The Panel cannot be opened again after this.
+ */
+MdPanelRef.prototype.destroy = function() {
+ var self = this;
+ if (this.config.groupName) {
+ this.config.groupName = coerceToArray(this.config.groupName);
+ angular.forEach(this.config.groupName, function(group) {
+ self.removeFromGroup(group);
+ });
+ }
+ this.config.scope.$destroy();
+ this.config.locals = null;
+ this.config.onDomAdded = null;
+ this.config.onDomRemoved = null;
+ this.config.onRemoving = null;
+ this.config.onOpenComplete = null;
+ this._interceptors = undefined;
+};
+
+
+/**
+ * Shows the panel.
+ * @returns {!Q.IPromise<!MdPanelRef>} A promise that is resolved when
+ * the panel has shown and animations finish.
+ */
+MdPanelRef.prototype.show = function() {
+ if (!this.panelContainer) {
+ return this._$q(function(resolve, reject) {
+ reject('mdPanel: Panel does not exist yet. Call open() or attach().');
+ });
+ }
+
+ if (!this.panelContainer.hasClass(MD_PANEL_HIDDEN)) {
+ return this._$q.when(this);
+ }
+
+ var self = this;
+ var animatePromise = function() {
+ self.panelContainer.removeClass(MD_PANEL_HIDDEN);
+ return self._animateOpen();
+ };
+
+ return this._$q(function(resolve, reject) {
+ var done = self._done(resolve, self);
+ var onOpenComplete = self.config['onOpenComplete'] || angular.noop;
+ var addToGroupOpen = function() {
+ if (self.config.groupName) {
+ self.config.groupName = coerceToArray(self.config.groupName);
+ angular.forEach(self.config.groupName, function(group) {
+ group = self._$mdPanel._groups[group];
+ if (group) {
+ group.openPanels.push(self);
+ }
+ });
+ }
+ };
+
+ self._$q.all([
+ self._backdropRef ? self._backdropRef.show() : self,
+ animatePromise().then(function() { self._focusOnOpen(); }, reject)
+ ]).then(onOpenComplete)
+ .then(addToGroupOpen)
+ .then(done)
+ .catch(reject);
+ });
+};
+
+
+/**
+ * Hides the panel.
+ * @returns {!Q.IPromise<!MdPanelRef>} A promise that is resolved when
+ * the panel has hidden and animations finish.
+ */
+MdPanelRef.prototype.hide = function() {
+ if (!this.panelContainer) {
+ return this._$q(function(resolve, reject) {
+ reject('mdPanel: Panel does not exist yet. Call open() or attach().');
+ });
+ }
+
+ if (this.panelContainer.hasClass(MD_PANEL_HIDDEN)) {
+ return this._$q.when(this);
+ }
+
+ var self = this;
+
+ return this._$q(function(resolve, reject) {
+ var done = self._done(resolve, self);
+ var onRemoving = self.config['onRemoving'] || angular.noop;
+ var hidePanel = function() {
+ self.panelContainer.addClass(MD_PANEL_HIDDEN);
+ };
+ var removeFromGroupOpen = function() {
+ if (self.config.groupName) {
+ var index;
+ self.config.groupName = coerceToArray(self.config.groupName);
+ angular.forEach(self.config.groupName, function(group) {
+ group = self._$mdPanel._groups[group];
+ index = group.openPanels.indexOf(self);
+ if (index > -1) {
+ group.openPanels.splice(index, 1);
+ }
+ });
+ }
+ };
+ var focusOnOrigin = function() {
+ var origin = self.config['origin'];
+ if (origin) {
+ getElement(origin).focus();
+ }
+ };
+
+ self._$q.all([
+ self._backdropRef ? self._backdropRef.hide() : self,
+ self._animateClose()
+ .then(onRemoving)
+ .then(hidePanel)
+ .then(removeFromGroupOpen)
+ .then(focusOnOrigin)
+ .catch(reject)
+ ]).then(done, reject);
+ });
+};
+
+/**
+ * Compiles the panel, according to the passed in config and appends it to
+ * the DOM. Helps normalize differences in the compilation process between
+ * using a string template and a content element.
+ * @returns {!Q.IPromise<!MdPanelRef>} Promise that is resolved when
+ * the element has been compiled and added to the DOM.
+ * @private
+ */
+MdPanelRef.prototype._compile = function() {
+ var self = this;
+
+ // Compile the element via $mdCompiler. Note that when using a
+ // contentElement, the element isn't actually being compiled, rather the
+ // compiler saves it's place in the DOM and provides a way of restoring it.
+ return self._$mdCompiler.compile(self.config).then(function(compileData) {
+ var config = self.config;
+
+ if (config.contentElement) {
+ var panelEl = compileData.element;
+
+ // Since mdPanel modifies the inline styles and CSS classes, we need
+ // to save them in order to be able to restore on close.
+ self._restoreCache.styles = panelEl[0].style.cssText;
+ self._restoreCache.classes = panelEl[0].className;
+
+ self.panelContainer = self._$mdPanel._wrapContentElement(panelEl);
+ self.panelEl = panelEl;
+ } else {
+ self.panelContainer = compileData.link(config['scope']);
+ self.panelEl = angular.element(
+ self.panelContainer[0].querySelector('.md-panel')
+ );
+ }
+
+ // Save a reference to the inner wrapper.
+ self.innerWrapper = angular.element(
+ self.panelContainer[0].querySelector('.md-panel-inner-wrapper')
+ );
+
+ // Save a reference to the cleanup function from the compiler.
+ self._compilerCleanup = compileData.cleanup;
+
+ // Attach the panel to the proper place in the DOM.
+ getElement(self.config['attachTo']).append(self.panelContainer);
+
+ return self;
+ });
+};
+
+
+/**
+ * Creates a panel and adds it to the dom.
+ * @returns {!Q.IPromise} A promise that is resolved when the panel is
+ * created.
+ * @private
+ */
+MdPanelRef.prototype._createPanel = function() {
+ var self = this;
+
+ return this._$q(function(resolve, reject) {
+ if (!self.config.locals) {
+ self.config.locals = {};
+ }
+
+ self.config.locals.mdPanelRef = self;
+
+ self._compile().then(function() {
+ if (self.config['disableParentScroll']) {
+ self._restoreScroll = self._$mdUtil.disableScrollAround(
+ null,
+ self.panelContainer,
+ { disableScrollMask: true }
+ );
+ }
+
+ // Add a custom CSS class to the panel element.
+ if (self.config['panelClass']) {
+ self.panelEl.addClass(self.config['panelClass']);
+ }
+
+ // Handle click and touch events for the panel container.
+ if (self.config['propagateContainerEvents']) {
+ self.panelContainer.css('pointer-events', 'none');
+ self.panelEl.css('pointer-events', 'all');
+ }
+
+ // Panel may be outside the $rootElement, tell ngAnimate to animate
+ // regardless.
+ if (self._$animate.pin) {
+ self._$animate.pin(
+ self.panelContainer,
+ getElement(self.config['attachTo'])
+ );
+ }
+
+ self._configureTrapFocus();
+ self._addStyles().then(function() {
+ resolve(self);
+ }, reject);
+ }, reject);
+
+ });
+};
+
+
+/**
+ * Adds the styles for the panel, such as positioning and z-index. Also,
+ * themes the panel element and panel container using `$mdTheming`.
+ * @returns {!Q.IPromise<!MdPanelRef>}
+ * @private
+ */
+MdPanelRef.prototype._addStyles = function() {
+ var self = this;
+ return this._$q(function(resolve) {
+ self.panelContainer.css('z-index', self.config['zIndex']);
+ self.innerWrapper.css('z-index', self.config['zIndex'] + 1);
+
+ var hideAndResolve = function() {
+ // Theme the element and container.
+ self._setTheming();
+
+ // Remove offscreen classes and add hidden class.
+ self.panelEl.removeClass('_md-panel-offscreen');
+ self.innerWrapper.removeClass('_md-panel-offscreen');
+ self.panelContainer.addClass(MD_PANEL_HIDDEN);
+
+ resolve(self);
+ };
+
+ if (self.config['fullscreen']) {
+ self.panelEl.addClass('_md-panel-fullscreen');
+ hideAndResolve();
+ return; // Don't setup positioning.
+ }
+
+ var positionConfig = self.config['position'];
+ if (!positionConfig) {
+ hideAndResolve();
+ return; // Don't setup positioning.
+ }
+
+ // Wait for angular to finish processing the template
+ self._$rootScope['$$postDigest'](function() {
+ // Position it correctly. This is necessary so that the panel will have a
+ // defined height and width.
+ self._updatePosition(true);
+
+ // Theme the element and container.
+ self._setTheming();
+
+ resolve(self);
+ });
+ });
+};
+
+
+/**
+ * Sets the `$mdTheming` classes on the `panelContainer` and `panelEl`.
+ * @private
+ */
+MdPanelRef.prototype._setTheming = function() {
+ this._$mdTheming(this.panelEl);
+ this._$mdTheming(this.panelContainer);
+};
+
+
+/**
+ * Updates the position configuration of a panel
+ * @param {!MdPanelPosition} position
+ */
+MdPanelRef.prototype.updatePosition = function(position) {
+ if (!this.panelContainer) {
+ throw new Error(
+ 'mdPanel: Panel does not exist yet. Call open() or attach().');
+ }
+
+ this.config['position'] = position;
+ this._updatePosition();
+};
+
+
+/**
+ * Calculates and updates the position of the panel.
+ * @param {boolean=} init
+ * @private
+ */
+MdPanelRef.prototype._updatePosition = function(init) {
+ var positionConfig = this.config['position'];
+
+ if (positionConfig) {
+ positionConfig._setPanelPosition(this.innerWrapper);
+
+ // Hide the panel now that position is known.
+ if (init) {
+ this.panelEl.removeClass('_md-panel-offscreen');
+ this.innerWrapper.removeClass('_md-panel-offscreen');
+ this.panelContainer.addClass(MD_PANEL_HIDDEN);
+ }
+
+ this.innerWrapper.css(
+ MdPanelPosition.absPosition.TOP,
+ positionConfig.getTop()
+ );
+ this.innerWrapper.css(
+ MdPanelPosition.absPosition.BOTTOM,
+ positionConfig.getBottom()
+ );
+ this.innerWrapper.css(
+ MdPanelPosition.absPosition.LEFT,
+ positionConfig.getLeft()
+ );
+ this.innerWrapper.css(
+ MdPanelPosition.absPosition.RIGHT,
+ positionConfig.getRight()
+ );
+ }
+};
+
+
+/**
+ * Focuses on the panel or the first focus target.
+ * @private
+ */
+MdPanelRef.prototype._focusOnOpen = function() {
+ if (this.config['focusOnOpen']) {
+ // Wait for the template to finish rendering to guarantee md-autofocus has
+ // finished adding the class md-autofocus, otherwise the focusable element
+ // isn't available to focus.
+ var self = this;
+ this._$rootScope['$$postDigest'](function() {
+ var target = self._$mdUtil.findFocusTarget(self.panelEl) ||
+ self.panelEl;
+ target.focus();
+ });
+ }
+};
+
+
+/**
+ * Shows the backdrop.
+ * @returns {!Q.IPromise} A promise that is resolved when the backdrop
+ * is created and attached.
+ * @private
+ */
+MdPanelRef.prototype._createBackdrop = function() {
+ if (this.config.hasBackdrop) {
+ if (!this._backdropRef) {
+ var backdropAnimation = this._$mdPanel.newPanelAnimation()
+ .openFrom(this.config.attachTo)
+ .withAnimation({
+ open: '_md-opaque-enter',
+ close: '_md-opaque-leave'
+ });
+
+ if (this.config.animation) {
+ backdropAnimation.duration(this.config.animation._rawDuration);
+ }
+
+ var backdropConfig = {
+ animation: backdropAnimation,
+ attachTo: this.config.attachTo,
+ focusOnOpen: false,
+ panelClass: '_md-panel-backdrop',
+ zIndex: this.config.zIndex - 1
+ };
+
+ this._backdropRef = this._$mdPanel.create(backdropConfig);
+ }
+ if (!this._backdropRef.isAttached) {
+ return this._backdropRef.attach();
+ }
+ }
+};
+
+
+/**
+ * Listen for escape keys and outside clicks to auto close.
+ * @private
+ */
+MdPanelRef.prototype._addEventListeners = function() {
+ this._configureEscapeToClose();
+ this._configureClickOutsideToClose();
+ this._configureScrollListener();
+};
+
+
+/**
+ * Remove event listeners added in _addEventListeners.
+ * @private
+ */
+MdPanelRef.prototype._removeEventListeners = function() {
+ this._removeListeners && this._removeListeners.forEach(function(removeFn) {
+ removeFn();
+ });
+ this._removeListeners = [];
+};
+
+
+/**
+ * Setup the escapeToClose event listeners.
+ * @private
+ */
+MdPanelRef.prototype._configureEscapeToClose = function() {
+ if (this.config['escapeToClose']) {
+ var parentTarget = getElement(this.config['attachTo']);
+ var self = this;
+
+ var keyHandlerFn = function(ev) {
+ if (ev.keyCode === self._$mdConstant.KEY_CODE.ESCAPE) {
+ ev.stopPropagation();
+ ev.preventDefault();
+
+ self.close(MdPanelRef.closeReasons.ESCAPE);
+ }
+ };
+
+ // Add keydown listeners
+ this.panelContainer.on('keydown', keyHandlerFn);
+ parentTarget.on('keydown', keyHandlerFn);
+
+ // Queue remove listeners function
+ this._removeListeners.push(function() {
+ self.panelContainer.off('keydown', keyHandlerFn);
+ parentTarget.off('keydown', keyHandlerFn);
+ });
+ }
+};
+
+
+/**
+ * Setup the clickOutsideToClose event listeners.
+ * @private
+ */
+MdPanelRef.prototype._configureClickOutsideToClose = function() {
+ if (this.config['clickOutsideToClose']) {
+ var target = this.config['propagateContainerEvents'] ?
+ angular.element(document.body) :
+ this.panelContainer;
+ var sourceEl;
+
+ // Keep track of the element on which the mouse originally went down
+ // so that we can only close the backdrop when the 'click' started on it.
+ // A simple 'click' handler does not work, it sets the target object as the
+ // element the mouse went down on.
+ var mousedownHandler = function(ev) {
+ sourceEl = ev.target;
+ };
+
+ // We check if our original element and the target is the backdrop
+ // because if the original was the backdrop and the target was inside the
+ // panel we don't want to panel to close.
+ var self = this;
+ var mouseupHandler = function(ev) {
+ if (self.config['propagateContainerEvents']) {
+
+ // We check if the sourceEl of the event is the panel element or one
+ // of it's children. If it is not, then close the panel.
+ if (sourceEl !== self.panelEl[0] && !self.panelEl[0].contains(sourceEl)) {
+ self.close();
+ }
+
+ } else if (sourceEl === target[0] && ev.target === target[0]) {
+ ev.stopPropagation();
+ ev.preventDefault();
+
+ self.close(MdPanelRef.closeReasons.CLICK_OUTSIDE);
+ }
+ };
+
+ // Add listeners
+ target.on('mousedown', mousedownHandler);
+ target.on('mouseup', mouseupHandler);
+
+ // Queue remove listeners function
+ this._removeListeners.push(function() {
+ target.off('mousedown', mousedownHandler);
+ target.off('mouseup', mouseupHandler);
+ });
+ }
+};
+
+
+/**
+ * Configures the listeners for updating the panel position on scroll.
+ * @private
+*/
+MdPanelRef.prototype._configureScrollListener = function() {
+ // No need to bind the event if scrolling is disabled.
+ if (!this.config['disableParentScroll']) {
+ var updatePosition = angular.bind(this, this._updatePosition);
+ var debouncedUpdatePosition = this._$$rAF.throttle(updatePosition);
+ var self = this;
+
+ var onScroll = function() {
+ debouncedUpdatePosition();
+ };
+
+ // Add listeners.
+ this._$window.addEventListener('scroll', onScroll, true);
+
+ // Queue remove listeners function.
+ this._removeListeners.push(function() {
+ self._$window.removeEventListener('scroll', onScroll, true);
+ });
+ }
+};
+
+
+/**
+ * Setup the focus traps. These traps will wrap focus when tabbing past the
+ * panel. When shift-tabbing, the focus will stick in place.
+ * @private
+ */
+MdPanelRef.prototype._configureTrapFocus = function() {
+ // Focus doesn't remain inside of the panel without this.
+ this.panelEl.attr('tabIndex', '-1');
+ if (this.config['trapFocus']) {
+ var element = this.panelEl;
+ // Set up elements before and after the panel to capture focus and
+ // redirect back into the panel.
+ this._topFocusTrap = FOCUS_TRAP_TEMPLATE.clone()[0];
+ this._bottomFocusTrap = FOCUS_TRAP_TEMPLATE.clone()[0];
+
+ // When focus is about to move out of the panel, we want to intercept it
+ // and redirect it back to the panel element.
+ var focusHandler = function() {
+ element.focus();
+ };
+ this._topFocusTrap.addEventListener('focus', focusHandler);
+ this._bottomFocusTrap.addEventListener('focus', focusHandler);
+
+ // Queue remove listeners function
+ this._removeListeners.push(this._simpleBind(function() {
+ this._topFocusTrap.removeEventListener('focus', focusHandler);
+ this._bottomFocusTrap.removeEventListener('focus', focusHandler);
+ }, this));
+
+ // The top focus trap inserted immediately before the md-panel element (as
+ // a sibling). The bottom focus trap inserted immediately after the
+ // md-panel element (as a sibling).
+ element[0].parentNode.insertBefore(this._topFocusTrap, element[0]);
+ element.after(this._bottomFocusTrap);
+ }
+};
+
+
+/**
+ * Updates the animation of a panel.
+ * @param {!MdPanelAnimation} animation
+ */
+MdPanelRef.prototype.updateAnimation = function(animation) {
+ this.config['animation'] = animation;
+
+ if (this._backdropRef) {
+ this._backdropRef.config.animation.duration(animation._rawDuration);
+ }
+};
+
+
+/**
+ * Animate the panel opening.
+ * @returns {!Q.IPromise} A promise that is resolved when the panel has
+ * animated open.
+ * @private
+ */
+MdPanelRef.prototype._animateOpen = function() {
+ this.panelContainer.addClass('md-panel-is-showing');
+ var animationConfig = this.config['animation'];
+ if (!animationConfig) {
+ // Promise is in progress, return it.
+ this.panelContainer.addClass('_md-panel-shown');
+ return this._$q.when(this);
+ }
+
+ var self = this;
+ return this._$q(function(resolve) {
+ var done = self._done(resolve, self);
+ var warnAndOpen = function() {
+ self._$log.warn(
+ 'mdPanel: MdPanel Animations failed. ' +
+ 'Showing panel without animating.');
+ done();
+ };
+
+ animationConfig.animateOpen(self.panelEl)
+ .then(done, warnAndOpen);
+ });
+};
+
+
+/**
+ * Animate the panel closing.
+ * @returns {!Q.IPromise} A promise that is resolved when the panel has animated closed.
+ * @private
+ */
+MdPanelRef.prototype._animateClose = function() {
+ var self = this;
+ var animationConfig = this.config['animation'];
+
+ if (!animationConfig) {
+ this.panelContainer.removeClass('md-panel-is-showing');
+ this.panelContainer.removeClass('_md-panel-shown');
+ return this._$q.when(this);
+ } else {
+ return this._$q(function (resolve) {
+ var done = function () {
+ self.panelContainer.removeClass('md-panel-is-showing');
+ // Remove the transform so that re-used panels don't accumulate transforms.
+ self.panelEl.css('transform', '');
+ resolve(self);
+ };
+ var warnAndClose = function () {
+ self._$log.warn(
+ 'mdPanel: MdPanel Animations failed. Hiding panel without animating.');
+ done();
+ };
+
+ animationConfig.animateClose(self.panelEl).then(done, warnAndClose);
+ });
+ }
+};
+
+
+/**
+ * Registers a interceptor with the panel. The callback should return a promise,
+ * which will allow the action to continue when it gets resolved, or will
+ * prevent an action if it is rejected.
+ * @param {string} type Type of interceptor.
+ * @param {!Q.IPromise<!any>} callback Callback to be registered.
+ * @returns {!MdPanelRef}
+ */
+MdPanelRef.prototype.registerInterceptor = function(type, callback) {
+ var error = null;
+
+ if (!angular.isString(type)) {
+ error = 'Interceptor type must be a string, instead got ' + typeof type;
+ } else if (!angular.isFunction(callback)) {
+ error = 'Interceptor callback must be a function, instead got ' + typeof callback;
+ }
+
+ if (error) {
+ throw new Error('MdPanel: ' + error);
+ }
+
+ var interceptors = this._interceptors[type] = this._interceptors[type] || [];
+
+ if (interceptors.indexOf(callback) === -1) {
+ interceptors.push(callback);
+ }
+
+ return this;
+};
+
+
+/**
+ * Removes a registered interceptor.
+ * @param {string} type Type of interceptor to be removed.
+ * @param {Function} callback Interceptor to be removed.
+ * @returns {!MdPanelRef}
+ */
+MdPanelRef.prototype.removeInterceptor = function(type, callback) {
+ var index = this._interceptors[type] ?
+ this._interceptors[type].indexOf(callback) : -1;
+
+ if (index > -1) {
+ this._interceptors[type].splice(index, 1);
+ }
+
+ return this;
+};
+
+
+/**
+ * Removes all interceptors.
+ * @param {string=} type Type of interceptors to be removed.
+ * If ommited, all interceptors types will be removed.
+ * @returns {!MdPanelRef}
+ */
+MdPanelRef.prototype.removeAllInterceptors = function(type) {
+ if (type) {
+ this._interceptors[type] = [];
+ } else {
+ this._interceptors = Object.create(null);
+ }
+
+ return this;
+};
+
+
+/**
+ * Invokes all the interceptors of a certain type sequantially in
+ * reverse order. Works in a similar way to `$q.all`, except it
+ * respects the order of the functions.
+ * @param {string} type Type of interceptors to be invoked.
+ * @returns {!Q.IPromise<!MdPanelRef>}
+ * @private
+ */
+MdPanelRef.prototype._callInterceptors = function(type) {
+ var self = this;
+ var $q = self._$q;
+ var interceptors = self._interceptors && self._interceptors[type] || [];
+
+ return interceptors.reduceRight(function(promise, interceptor) {
+ var isPromiseLike = interceptor && angular.isFunction(interceptor.then);
+ var response = isPromiseLike ? interceptor : null;
+
+ /**
+ * For interceptors to reject/cancel subsequent portions of the chain, simply
+ * return a `$q.reject(<value>)`
+ */
+ return promise.then(function() {
+ if (!response) {
+ try {
+ response = interceptor(self);
+ } catch (e) {
+ response = $q.reject(e);
+ }
+ }
+
+ return response;
+ });
+ }, $q.resolve(self));
+};
+
+
+/**
+ * Faster, more basic than angular.bind
+ * http://jsperf.com/angular-bind-vs-custom-vs-native
+ * @param {function} callback
+ * @param {!Object} self
+ * @return {function} Callback function with a bound self.
+ */
+MdPanelRef.prototype._simpleBind = function(callback, self) {
+ return function(value) {
+ return callback.apply(self, value);
+ };
+};
+
+
+/**
+ * @param {function|IQResolveReject} callback
+ * @param {!Object} self
+ * @return {function} Callback function with a self param.
+ */
+MdPanelRef.prototype._done = function(callback, self) {
+ return function() {
+ callback(self);
+ };
+};
+
+
+/**
+ * Adds a panel to a group if the panel does not exist within the group already.
+ * A panel can only exist within a single group.
+ * @param {string} groupName The name of the group.
+ */
+MdPanelRef.prototype.addToGroup = function(groupName) {
+ if (!this._$mdPanel._groups[groupName]) {
+ this._$mdPanel.newPanelGroup(groupName);
+ }
+
+ var group = this._$mdPanel._groups[groupName];
+ var index = group.panels.indexOf(this);
+
+ if (index < 0) {
+ group.panels.push(this);
+ }
+};
+
+
+/**
+ * Removes a panel from a group if the panel exists within that group. The group
+ * must be created ahead of time.
+ * @param {string} groupName The name of the group.
+ */
+MdPanelRef.prototype.removeFromGroup = function(groupName) {
+ if (!this._$mdPanel._groups[groupName]) {
+ throw new Error('mdPanel: The group ' + groupName + ' does not exist.');
+ }
+
+ var group = this._$mdPanel._groups[groupName];
+ var index = group.panels.indexOf(this);
+
+ if (index > -1) {
+ group.panels.splice(index, 1);
+ }
+};
+
+
+/**
+ * Possible default closeReasons for the close function.
+ * @enum {string}
+ */
+MdPanelRef.closeReasons = {
+ CLICK_OUTSIDE: 'clickOutsideToClose',
+ ESCAPE: 'escapeToClose',
+};
+
+
+/*****************************************************************************
+ * MdPanelPosition *
+ *****************************************************************************/
+
+
+/**
+ * Position configuration object. To use, create an MdPanelPosition with the
+ * desired properties, then pass the object as part of $mdPanel creation.
+ *
+ * Example:
+ *
+ * var panelPosition = new MdPanelPosition()
+ * .relativeTo(myButtonEl)
+ * .addPanelPosition(
+ * $mdPanel.xPosition.CENTER,
+ * $mdPanel.yPosition.ALIGN_TOPS
+ * );
+ *
+ * $mdPanel.create({
+ * position: panelPosition
+ * });
+ *
+ * @param {!IInjectorService} $injector
+ * @final @constructor
+ */
+function MdPanelPosition($injector) {
+ /** @private @const {!IWindowService} */
+ this._$window = $injector.get('$window');
+
+ /** @private {boolean} */
+ this._isRTL = $injector.get('$mdUtil').isRtl();
+
+ /** @private @const {!angular.$mdConstant} */
+ this._$mdConstant = $injector.get('$mdConstant');
+
+ /** @private {boolean} */
+ this._absolute = false;
+
+ /** @private {!JQLite} */
+ this._relativeToEl = undefined;
+
+ /** @private {string} */
+ this._top = '';
+
+ /** @private {string} */
+ this._bottom = '';
+
+ /** @private {string} */
+ this._left = '';
+
+ /** @private {string} */
+ this._right = '';
+
+ /** @private {!Array<string>} */
+ this._translateX = [];
+
+ /** @private {!Array<string>} */
+ this._translateY = [];
+
+ /** @private {!Array<{x:string, y:string}>} */
+ this._positions = [];
+
+ /** @private {?{x:string, y:string}} */
+ this._actualPosition = undefined;
+}
+
+
+/**
+ * Possible values of xPosition.
+ * @enum {string}
+ */
+MdPanelPosition.xPosition = {
+ CENTER: 'center',
+ ALIGN_START: 'align-start',
+ ALIGN_END: 'align-end',
+ OFFSET_START: 'offset-start',
+ OFFSET_END: 'offset-end'
+};
+
+
+/**
+ * Possible values of yPosition.
+ * @enum {string}
+ */
+MdPanelPosition.yPosition = {
+ CENTER: 'center',
+ ALIGN_TOPS: 'align-tops',
+ ALIGN_BOTTOMS: 'align-bottoms',
+ ABOVE: 'above',
+ BELOW: 'below'
+};
+
+
+/**
+ * Possible values of absolute position.
+ * @enum {string}
+ */
+MdPanelPosition.absPosition = {
+ TOP: 'top',
+ RIGHT: 'right',
+ BOTTOM: 'bottom',
+ LEFT: 'left'
+};
+
+/**
+ * Margin between the edges of a panel and the viewport.
+ * @const {number}
+ */
+MdPanelPosition.viewportMargin = 8;
+
+
+/**
+ * Sets absolute positioning for the panel.
+ * @return {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.absolute = function() {
+ this._absolute = true;
+ return this;
+};
+
+
+/**
+ * Sets the value of a position for the panel. Clears any previously set
+ * position.
+ * @param {string} position Position to set
+ * @param {string=} value Value of the position. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ * @private
+ */
+MdPanelPosition.prototype._setPosition = function(position, value) {
+ if (position === MdPanelPosition.absPosition.RIGHT ||
+ position === MdPanelPosition.absPosition.LEFT) {
+ this._left = this._right = '';
+ } else if (
+ position === MdPanelPosition.absPosition.BOTTOM ||
+ position === MdPanelPosition.absPosition.TOP) {
+ this._top = this._bottom = '';
+ } else {
+ var positions = Object.keys(MdPanelPosition.absPosition).join()
+ .toLowerCase();
+
+ throw new Error('mdPanel: Position must be one of ' + positions + '.');
+ }
+
+ this['_' + position] = angular.isString(value) ? value : '0';
+
+ return this;
+};
+
+
+/**
+ * Sets the value of `top` for the panel. Clears any previously set vertical
+ * position.
+ * @param {string=} top Value of `top`. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.top = function(top) {
+ return this._setPosition(MdPanelPosition.absPosition.TOP, top);
+};
+
+
+/**
+ * Sets the value of `bottom` for the panel. Clears any previously set vertical
+ * position.
+ * @param {string=} bottom Value of `bottom`. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.bottom = function(bottom) {
+ return this._setPosition(MdPanelPosition.absPosition.BOTTOM, bottom);
+};
+
+
+/**
+ * Sets the panel to the start of the page - `left` if `ltr` or `right` for
+ * `rtl`. Clears any previously set horizontal position.
+ * @param {string=} start Value of position. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.start = function(start) {
+ var position = this._isRTL ? MdPanelPosition.absPosition.RIGHT : MdPanelPosition.absPosition.LEFT;
+ return this._setPosition(position, start);
+};
+
+
+/**
+ * Sets the panel to the end of the page - `right` if `ltr` or `left` for `rtl`.
+ * Clears any previously set horizontal position.
+ * @param {string=} end Value of position. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.end = function(end) {
+ var position = this._isRTL ? MdPanelPosition.absPosition.LEFT : MdPanelPosition.absPosition.RIGHT;
+ return this._setPosition(position, end);
+};
+
+
+/**
+ * Sets the value of `left` for the panel. Clears any previously set
+ * horizontal position.
+ * @param {string=} left Value of `left`. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.left = function(left) {
+ return this._setPosition(MdPanelPosition.absPosition.LEFT, left);
+};
+
+
+/**
+ * Sets the value of `right` for the panel. Clears any previously set
+ * horizontal position.
+ * @param {string=} right Value of `right`. Defaults to '0'.
+ * @returns {!MdPanelPosition}
+*/
+MdPanelPosition.prototype.right = function(right) {
+ return this._setPosition(MdPanelPosition.absPosition.RIGHT, right);
+};
+
+
+/**
+ * Centers the panel horizontally in the viewport. Clears any previously set
+ * horizontal position.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.centerHorizontally = function() {
+ this._left = '50%';
+ this._right = '';
+ this._translateX = ['-50%'];
+ return this;
+};
+
+
+/**
+ * Centers the panel vertically in the viewport. Clears any previously set
+ * vertical position.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.centerVertically = function() {
+ this._top = '50%';
+ this._bottom = '';
+ this._translateY = ['-50%'];
+ return this;
+};
+
+
+/**
+ * Centers the panel horizontally and vertically in the viewport. This is
+ * equivalent to calling both `centerHorizontally` and `centerVertically`.
+ * Clears any previously set horizontal and vertical positions.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.center = function() {
+ return this.centerHorizontally().centerVertically();
+};
+
+
+/**
+ * Sets element for relative positioning.
+ * @param {string|!Element|!JQLite} element Query selector, DOM element,
+ * or angular element to set the panel relative to.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.relativeTo = function(element) {
+ this._absolute = false;
+ this._relativeToEl = getElement(element);
+ return this;
+};
+
+
+/**
+ * Sets the x and y positions for the panel relative to another element.
+ * @param {string} xPosition must be one of the MdPanelPosition.xPosition
+ * values.
+ * @param {string} yPosition must be one of the MdPanelPosition.yPosition
+ * values.
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.addPanelPosition = function(xPosition, yPosition) {
+ if (!this._relativeToEl) {
+ throw new Error('mdPanel: addPanelPosition can only be used with ' +
+ 'relative positioning. Set relativeTo first.');
+ }
+
+ validatePosition(MdPanelPosition.xPosition, xPosition);
+ validatePosition(MdPanelPosition.yPosition, yPosition);
+
+ this._positions.push({
+ x: xPosition,
+ y: yPosition
+ });
+
+ return this;
+};
+
+
+/**
+ * Sets the value of the offset in the x-direction. This will add to any
+ * previously set offsets.
+ * @param {string|number|function(MdPanelPosition): string} offsetX
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.withOffsetX = function(offsetX) {
+ this._translateX.push(addUnits(offsetX));
+ return this;
+};
+
+
+/**
+ * Sets the value of the offset in the y-direction. This will add to any
+ * previously set offsets.
+ * @param {string|number|function(MdPanelPosition): string} offsetY
+ * @returns {!MdPanelPosition}
+ */
+MdPanelPosition.prototype.withOffsetY = function(offsetY) {
+ this._translateY.push(addUnits(offsetY));
+ return this;
+};
+
+
+/**
+ * Gets the value of `top` for the panel.
+ * @returns {string}
+ */
+MdPanelPosition.prototype.getTop = function() {
+ return this._top;
+};
+
+
+/**
+ * Gets the value of `bottom` for the panel.
+ * @returns {string}
+ */
+MdPanelPosition.prototype.getBottom = function() {
+ return this._bottom;
+};
+
+
+/**
+ * Gets the value of `left` for the panel.
+ * @returns {string}
+ */
+MdPanelPosition.prototype.getLeft = function() {
+ return this._left;
+};
+
+
+/**
+ * Gets the value of `right` for the panel.
+ * @returns {string}
+ */
+MdPanelPosition.prototype.getRight = function() {
+ return this._right;
+};
+
+
+/**
+ * Gets the value of `transform` for the panel.
+ * @returns {string} representation of the translateX and translateY rules and values
+ */
+MdPanelPosition.prototype.getTransform = function() {
+ var translateX = this._reduceTranslateValues('translateX', this._translateX);
+ var translateY = this._reduceTranslateValues('translateY', this._translateY);
+
+ // It's important to trim the result, because the browser will ignore the set
+ // operation if the string contains only whitespace.
+ return (translateX + ' ' + translateY).trim();
+};
+
+
+/**
+ * Sets the `transform` value for an element.
+ * @param {!JQLite} el
+ * @returns {!JQLite}
+ * @private
+ */
+MdPanelPosition.prototype._setTransform = function(el) {
+ return el.css(this._$mdConstant.CSS.TRANSFORM, this.getTransform());
+};
+
+
+/**
+ * True if the panel is completely on-screen with this positioning; false
+ * otherwise.
+ * @param {!JQLite} el
+ * @return {boolean}
+ * @private
+ */
+MdPanelPosition.prototype._isOnscreen = function(el) {
+ // this works because we always use fixed positioning for the panel,
+ // which is relative to the viewport.
+ var left = parseInt(this.getLeft());
+ var top = parseInt(this.getTop());
+
+ if (this._translateX.length || this._translateY.length) {
+ var prefixedTransform = this._$mdConstant.CSS.TRANSFORM;
+ var offsets = getComputedTranslations(el, prefixedTransform);
+ left += offsets.x;
+ top += offsets.y;
+ }
+
+ var right = left + el[0].offsetWidth;
+ var bottom = top + el[0].offsetHeight;
+
+ return (left >= 0) &&
+ (top >= 0) &&
+ (bottom <= this._$window.innerHeight) &&
+ (right <= this._$window.innerWidth);
+};
+
+
+/**
+ * Gets the first x/y position that can fit on-screen.
+ * @returns {{x: string, y: string}}
+ */
+MdPanelPosition.prototype.getActualPosition = function() {
+ return this._actualPosition;
+};
+
+
+/**
+ * Reduces a list of translate values to a string that can be used within
+ * transform.
+ * @param {string} translateFn
+ * @param {!Array<string>} values
+ * @returns {string}
+ * @private
+ */
+MdPanelPosition.prototype._reduceTranslateValues =
+ function(translateFn, values) {
+ return values.map(function(translation) {
+ var translationValue = angular.isFunction(translation) ?
+ addUnits(translation(this)) : translation;
+ return translateFn + '(' + translationValue + ')';
+ }, this).join(' ');
+ };
+
+
+/**
+ * Sets the panel position based on the created panel element and best x/y
+ * positioning.
+ * @param {!JQLite} el
+ * @private
+ */
+MdPanelPosition.prototype._setPanelPosition = function(el) {
+ // Remove the class in case it has been added before.
+ el.removeClass('_md-panel-position-adjusted');
+
+ // Only calculate the position if necessary.
+ if (this._absolute) {
+ this._setTransform(el);
+ return;
+ }
+
+ if (this._actualPosition) {
+ this._calculatePanelPosition(el, this._actualPosition);
+ this._setTransform(el);
+ this._constrainToViewport(el);
+ return;
+ }
+
+ for (var i = 0; i < this._positions.length; i++) {
+ this._actualPosition = this._positions[i];
+ this._calculatePanelPosition(el, this._actualPosition);
+ this._setTransform(el);
+
+ if (this._isOnscreen(el)) {
+ return;
+ }
+ }
+
+ this._constrainToViewport(el);
+};
+
+
+/**
+ * Constrains a panel's position to the viewport.
+ * @param {!JQLite} el
+ * @private
+ */
+MdPanelPosition.prototype._constrainToViewport = function(el) {
+ var margin = MdPanelPosition.viewportMargin;
+ var initialTop = this._top;
+ var initialLeft = this._left;
+
+ if (this.getTop()) {
+ var top = parseInt(this.getTop());
+ var bottom = el[0].offsetHeight + top;
+ var viewportHeight = this._$window.innerHeight;
+
+ if (top < margin) {
+ this._top = margin + 'px';
+ } else if (bottom > viewportHeight) {
+ this._top = top - (bottom - viewportHeight + margin) + 'px';
+ }
+ }
+
+ if (this.getLeft()) {
+ var left = parseInt(this.getLeft());
+ var right = el[0].offsetWidth + left;
+ var viewportWidth = this._$window.innerWidth;
+
+ if (left < margin) {
+ this._left = margin + 'px';
+ } else if (right > viewportWidth) {
+ this._left = left - (right - viewportWidth + margin) + 'px';
+ }
+ }
+
+ // Class that can be used to re-style the panel if it was repositioned.
+ el.toggleClass(
+ '_md-panel-position-adjusted',
+ this._top !== initialTop || this._left !== initialLeft
+ );
+};
+
+
+/**
+ * Switches between 'start' and 'end'.
+ * @param {string} position Horizontal position of the panel
+ * @returns {string} Reversed position
+ * @private
+ */
+MdPanelPosition.prototype._reverseXPosition = function(position) {
+ if (position === MdPanelPosition.xPosition.CENTER) {
+ return position;
+ }
+
+ var start = 'start';
+ var end = 'end';
+
+ return position.indexOf(start) > -1 ? position.replace(start, end) : position.replace(end, start);
+};
+
+
+/**
+ * Handles horizontal positioning in rtl or ltr environments.
+ * @param {string} position Horizontal position of the panel
+ * @returns {string} The correct position according the page direction
+ * @private
+ */
+MdPanelPosition.prototype._bidi = function(position) {
+ return this._isRTL ? this._reverseXPosition(position) : position;
+};
+
+
+/**
+ * Calculates the panel position based on the created panel element and the
+ * provided positioning.
+ * @param {!JQLite} el
+ * @param {!{x:string, y:string}} position
+ * @private
+ */
+MdPanelPosition.prototype._calculatePanelPosition = function(el, position) {
+
+ var panelBounds = el[0].getBoundingClientRect();
+ var panelWidth = Math.max(panelBounds.width, el[0].clientWidth);
+ var panelHeight = Math.max(panelBounds.height, el[0].clientHeight);
+
+ var targetBounds = this._relativeToEl[0].getBoundingClientRect();
+
+ var targetLeft = targetBounds.left;
+ var targetRight = targetBounds.right;
+ var targetWidth = targetBounds.width;
+
+ switch (this._bidi(position.x)) {
+ case MdPanelPosition.xPosition.OFFSET_START:
+ this._left = targetLeft - panelWidth + 'px';
+ break;
+ case MdPanelPosition.xPosition.ALIGN_END:
+ this._left = targetRight - panelWidth + 'px';
+ break;
+ case MdPanelPosition.xPosition.CENTER:
+ var left = targetLeft + (0.5 * targetWidth) - (0.5 * panelWidth);
+ this._left = left + 'px';
+ break;
+ case MdPanelPosition.xPosition.ALIGN_START:
+ this._left = targetLeft + 'px';
+ break;
+ case MdPanelPosition.xPosition.OFFSET_END:
+ this._left = targetRight + 'px';
+ break;
+ }
+
+ var targetTop = targetBounds.top;
+ var targetBottom = targetBounds.bottom;
+ var targetHeight = targetBounds.height;
+
+ switch (position.y) {
+ case MdPanelPosition.yPosition.ABOVE:
+ this._top = targetTop - panelHeight + 'px';
+ break;
+ case MdPanelPosition.yPosition.ALIGN_BOTTOMS:
+ this._top = targetBottom - panelHeight + 'px';
+ break;
+ case MdPanelPosition.yPosition.CENTER:
+ var top = targetTop + (0.5 * targetHeight) - (0.5 * panelHeight);
+ this._top = top + 'px';
+ break;
+ case MdPanelPosition.yPosition.ALIGN_TOPS:
+ this._top = targetTop + 'px';
+ break;
+ case MdPanelPosition.yPosition.BELOW:
+ this._top = targetBottom + 'px';
+ break;
+ }
+};
+
+
+/*****************************************************************************
+ * MdPanelAnimation *
+ *****************************************************************************/
+
+
+/**
+ * Animation configuration object. To use, create an MdPanelAnimation with the
+ * desired properties, then pass the object as part of $mdPanel creation.
+ *
+ * Example:
+ *
+ * var panelAnimation = new MdPanelAnimation()
+ * .openFrom(myButtonEl)
+ * .closeTo('.my-button')
+ * .withAnimation($mdPanel.animation.SCALE);
+ *
+ * $mdPanel.create({
+ * animation: panelAnimation
+ * });
+ *
+ * @param {!IInjectorService} $injector
+ * @final @constructor
+ */
+function MdPanelAnimation($injector) {
+ /** @private @const {!angular.$mdUtil} */
+ this._$mdUtil = $injector.get('$mdUtil');
+
+ /**
+ * @private {{element: !JQLite|undefined, bounds: !DOMRect}|
+ * undefined}
+ */
+ this._openFrom;
+
+ /**
+ * @private {{element: !JQLite|undefined, bounds: !DOMRect}|
+ * undefined}
+ */
+ this._closeTo;
+
+ /** @private {string|{open: string, close: string}} */
+ this._animationClass = '';
+
+ /** @private {number} */
+ this._openDuration;
+
+ /** @private {number} */
+ this._closeDuration;
+
+ /** @private {number|{open: number, close: number}} */
+ this._rawDuration;
+}
+
+
+/**
+ * Possible default animations.
+ * @enum {string}
+ */
+MdPanelAnimation.animation = {
+ SLIDE: 'md-panel-animate-slide',
+ SCALE: 'md-panel-animate-scale',
+ FADE: 'md-panel-animate-fade'
+};
+
+
+/**
+ * Specifies where to start the open animation. `openFrom` accepts a
+ * click event object, query selector, DOM element, or a Rect object that
+ * is used to determine the bounds. When passed a click event, the location
+ * of the click will be used as the position to start the animation.
+ * @param {string|!Element|!Event|{top: number, left: number}} openFrom
+ * @returns {!MdPanelAnimation}
+ */
+MdPanelAnimation.prototype.openFrom = function(openFrom) {
+ // Check if 'openFrom' is an Event.
+ openFrom = openFrom.target ? openFrom.target : openFrom;
+
+ this._openFrom = this._getPanelAnimationTarget(openFrom);
+
+ if (!this._closeTo) {
+ this._closeTo = this._openFrom;
+ }
+ return this;
+};
+
+
+/**
+ * Specifies where to animate the panel close. `closeTo` accepts a
+ * query selector, DOM element, or a Rect object that is used to determine
+ * the bounds.
+ * @param {string|!Element|{top: number, left: number}} closeTo
+ * @returns {!MdPanelAnimation}
+ */
+MdPanelAnimation.prototype.closeTo = function(closeTo) {
+ this._closeTo = this._getPanelAnimationTarget(closeTo);
+ return this;
+};
+
+
+/**
+ * Specifies the duration of the animation in milliseconds.
+ * @param {number|{open: number, close: number}} duration
+ * @returns {!MdPanelAnimation}
+ */
+MdPanelAnimation.prototype.duration = function(duration) {
+ if (duration) {
+ if (angular.isNumber(duration)) {
+ this._openDuration = this._closeDuration = toSeconds(duration);
+ } else if (angular.isObject(duration)) {
+ this._openDuration = toSeconds(duration.open);
+ this._closeDuration = toSeconds(duration.close);
+ }
+ }
+
+ // Save the original value so it can be passed to the backdrop.
+ this._rawDuration = duration;
+
+ return this;
+
+ function toSeconds(value) {
+ if (angular.isNumber(value)) return value / 1000;
+ }
+};
+
+
+/**
+ * Returns the element and bounds for the animation target.
+ * @param {string|!Element|{top: number, left: number}} location
+ * @returns {{element: !JQLite|undefined, bounds: !DOMRect}}
+ * @private
+ */
+MdPanelAnimation.prototype._getPanelAnimationTarget = function(location) {
+ if (angular.isDefined(location.top) || angular.isDefined(location.left)) {
+ return {
+ element: undefined,
+ bounds: {
+ top: location.top || 0,
+ left: location.left || 0
+ }
+ };
+ } else {
+ return this._getBoundingClientRect(getElement(location));
+ }
+};
+
+
+/**
+ * Specifies the animation class.
+ *
+ * There are several default animations that can be used:
+ * (MdPanelAnimation.animation)
+ * SLIDE: The panel slides in and out from the specified
+ * elements.
+ * SCALE: The panel scales in and out.
+ * FADE: The panel fades in and out.
+ *
+ * @param {string|{open: string, close: string}} cssClass
+ * @returns {!MdPanelAnimation}
+ */
+MdPanelAnimation.prototype.withAnimation = function(cssClass) {
+ this._animationClass = cssClass;
+ return this;
+};
+
+
+/**
+ * Animate the panel open.
+ * @param {!JQLite} panelEl
+ * @returns {!Q.IPromise} A promise that is resolved when the open
+ * animation is complete.
+ */
+MdPanelAnimation.prototype.animateOpen = function(panelEl) {
+ var animator = this._$mdUtil.dom.animator;
+
+ this._fixBounds(panelEl);
+ var animationOptions = {};
+
+ // Include the panel transformations when calculating the animations.
+ var panelTransform = panelEl[0].style.transform || '';
+
+ var openFrom = animator.toTransformCss(panelTransform);
+ var openTo = animator.toTransformCss(panelTransform);
+
+ switch (this._animationClass) {
+ case MdPanelAnimation.animation.SLIDE:
+ // Slide should start with opacity: 1.
+ panelEl.css('opacity', '1');
+
+ animationOptions = {
+ transitionInClass: '_md-panel-animate-enter',
+ transitionOutClass: '_md-panel-animate-leave',
+ };
+
+ var openSlide = animator.calculateSlideToOrigin(
+ panelEl, this._openFrom) || '';
+ openFrom = animator.toTransformCss(openSlide + ' ' + panelTransform);
+ break;
+
+ case MdPanelAnimation.animation.SCALE:
+ animationOptions = {
+ transitionInClass: '_md-panel-animate-enter'
+ };
+
+ var openScale = animator.calculateZoomToOrigin(
+ panelEl, this._openFrom) || '';
+ openFrom = animator.toTransformCss(panelTransform + ' ' + openScale);
+ break;
+
+ case MdPanelAnimation.animation.FADE:
+ animationOptions = {
+ transitionInClass: '_md-panel-animate-enter'
+ };
+ break;
+
+ default:
+ if (angular.isString(this._animationClass)) {
+ animationOptions = {
+ transitionInClass: this._animationClass
+ };
+ } else {
+ animationOptions = {
+ transitionInClass: this._animationClass['open'],
+ transitionOutClass: this._animationClass['close'],
+ };
+ }
+ }
+
+ animationOptions.duration = this._openDuration;
+
+ return animator
+ .translate3d(panelEl, openFrom, openTo, animationOptions);
+};
+
+
+/**
+ * Animate the panel close.
+ * @param {!JQLite} panelEl
+ * @returns {!Q.IPromise} A promise that resolves when the close animation is complete.
+ */
+MdPanelAnimation.prototype.animateClose = function(panelEl) {
+ var animator = this._$mdUtil.dom.animator;
+ var reverseAnimationOptions = {};
+
+ // Include the panel transformations when calculating the animations.
+ var panelTransform = panelEl[0].style.transform || '';
+
+ var closeFrom = animator.toTransformCss(panelTransform);
+ var closeTo = animator.toTransformCss(panelTransform);
+
+ switch (this._animationClass) {
+ case MdPanelAnimation.animation.SLIDE:
+ // Slide should start with opacity: 1.
+ panelEl.css('opacity', '1');
+ reverseAnimationOptions = {
+ transitionInClass: '_md-panel-animate-leave',
+ transitionOutClass: '_md-panel-animate-enter _md-panel-animate-leave'
+ };
+
+ var closeSlide = animator.calculateSlideToOrigin(panelEl, this._closeTo) || '';
+ closeTo = animator.toTransformCss(closeSlide + ' ' + panelTransform);
+ break;
+
+ case MdPanelAnimation.animation.SCALE:
+ reverseAnimationOptions = {
+ transitionInClass: '_md-panel-animate-scale-out _md-panel-animate-leave',
+ transitionOutClass: '_md-panel-animate-scale-out _md-panel-animate-enter _md-panel-animate-leave'
+ };
+
+ var closeScale = animator.calculateZoomToOrigin(panelEl, this._closeTo) || '';
+ closeTo = animator.toTransformCss(panelTransform + ' ' + closeScale);
+ break;
+
+ case MdPanelAnimation.animation.FADE:
+ reverseAnimationOptions = {
+ transitionInClass: '_md-panel-animate-fade-out _md-panel-animate-leave',
+ transitionOutClass: '_md-panel-animate-fade-out _md-panel-animate-enter _md-panel-animate-leave'
+ };
+ break;
+
+ default:
+ if (angular.isString(this._animationClass)) {
+ reverseAnimationOptions = {
+ transitionOutClass: this._animationClass
+ };
+ } else {
+ reverseAnimationOptions = {
+ transitionInClass: this._animationClass['close'],
+ transitionOutClass: this._animationClass['open']
+ };
+ }
+ }
+
+ reverseAnimationOptions.duration = this._closeDuration;
+
+ return animator
+ .translate3d(panelEl, closeFrom, closeTo, reverseAnimationOptions);
+};
+
+
+/**
+ * Set the height and width to match the panel if not provided.
+ * @param {!JQLite} panelEl
+ * @private
+ */
+MdPanelAnimation.prototype._fixBounds = function(panelEl) {
+ var panelWidth = panelEl[0].offsetWidth;
+ var panelHeight = panelEl[0].offsetHeight;
+
+ if (this._openFrom && this._openFrom.bounds.height == null) {
+ this._openFrom.bounds.height = panelHeight;
+ }
+ if (this._openFrom && this._openFrom.bounds.width == null) {
+ this._openFrom.bounds.width = panelWidth;
+ }
+ if (this._closeTo && this._closeTo.bounds.height == null) {
+ this._closeTo.bounds.height = panelHeight;
+ }
+ if (this._closeTo && this._closeTo.bounds.width == null) {
+ this._closeTo.bounds.width = panelWidth;
+ }
+};
+
+
+/**
+ * Identify the bounding RECT for the target element.
+ * @param {!JQLite} element
+ * @returns {{element: !JQLite|undefined, bounds: !DOMRect}}
+ * @private
+ */
+MdPanelAnimation.prototype._getBoundingClientRect = function(element) {
+ if (element instanceof angular.element) {
+ return {
+ element: element,
+ bounds: element[0].getBoundingClientRect()
+ };
+ }
+};
+
+
+/*****************************************************************************
+ * Util Methods *
+ *****************************************************************************/
+
+
+/**
+ * Returns the angular element associated with a css selector or element.
+ * @param el {string|!JQLite|!Element}
+ * @returns {!JQLite}
+ */
+function getElement(el) {
+ var queryResult = angular.isString(el) ?
+ document.querySelector(el) : el;
+ return angular.element(queryResult);
+}
+
+/**
+ * Gets the computed values for an element's translateX and translateY in px.
+ * @param {!JQLite|!Element} el the element to evaluate
+ * @param {string} property
+ * @return {{x: number, y: number}} an element's translateX and translateY in px
+ */
+function getComputedTranslations(el, property) {
+ // The transform being returned by `getComputedStyle` is in the format:
+ // `matrix(a, b, c, d, translateX, translateY)` if defined and `none`
+ // if the element doesn't have a transform.
+ var transform = getComputedStyle(el[0] || el)[property];
+ var openIndex = transform.indexOf('(');
+ var closeIndex = transform.lastIndexOf(')');
+ var output = { x: 0, y: 0 };
+
+ if (openIndex > -1 && closeIndex > -1) {
+ var parsedValues = transform
+ .substring(openIndex + 1, closeIndex)
+ .split(', ')
+ .slice(-2);
+
+ output.x = parseInt(parsedValues[0]);
+ output.y = parseInt(parsedValues[1]);
+ }
+
+ return output;
+}
+
+/*
+ * Ensures that a value is a valid position name. Throw an exception if not.
+ * @param {Object} positionMap Object against which the value will be checked.
+ * @param {string} value
+ */
+function validatePosition(positionMap, value) {
+ // empty is ok
+ if (value === null || angular.isUndefined(value)) {
+ return;
+ }
+
+ var positionKeys = Object.keys(positionMap);
+ var positionValues = [];
+
+ for (var key, i = 0; key = positionKeys[i]; i++) {
+ var position = positionMap[key];
+ positionValues.push(position);
+
+ if (position === value) {
+ return;
+ }
+ }
+
+ throw new Error('Panel position only accepts the following values:\n' +
+ positionValues.join(' | '));
+}
+
+/**
+ * Adds units to a number value.
+ * @param {string|number} value
+ * @return {string}
+ */
+function addUnits(value) {
+ return angular.isNumber(value) ? value + 'px' : value;
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.progressCircular
+ * @description Module for a circular progressbar
+ */
+
+angular.module('material.components.progressCircular', ['material.core']);
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc directive
+ * @name mdProgressCircular
+ * @module material.components.progressCircular
+ * @restrict E
+ *
+ * @description
+ * The circular progress directive is used to make loading content in your app as delightful and
+ * painless as possible by minimizing the amount of visual change a user sees before they can view
+ * and interact with content.
+ *
+ * For operations where the percentage of the operation completed can be determined, use a
+ * determinate indicator. They give users a quick sense of how long an operation will take.
+ *
+ * For operations where the user is asked to wait a moment while something finishes up, and it’s
+ * not necessary to expose what's happening behind the scenes and how long it will take, use an
+ * indeterminate indicator.
+ *
+ * @param {string} md-mode Select from one of two modes: **'determinate'** and **'indeterminate'**.
+ *
+ * Note: if the `md-mode` value is set as undefined or specified as not 1 of the two (2) valid modes, then **'indeterminate'**
+ * will be auto-applied as the mode.
+ *
+ * Note: if not configured, the `md-mode="indeterminate"` will be auto injected as an attribute.
+ * If `value=""` is also specified, however, then `md-mode="determinate"` would be auto-injected instead.
+ * @param {number=} value In determinate mode, this number represents the percentage of the
+ * circular progress. Default: 0
+ * @param {number=} md-diameter This specifies the diameter of the circular progress. The value
+ * should be a pixel-size value (eg '100'). If this attribute is
+ * not present then a default value of '50px' is assumed.
+ *
+ * @param {boolean=} ng-disabled Determines whether to disable the progress element.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-progress-circular md-mode="determinate" value="..."></md-progress-circular>
+ *
+ * <md-progress-circular md-mode="determinate" ng-value="..."></md-progress-circular>
+ *
+ * <md-progress-circular md-mode="determinate" value="..." md-diameter="100"></md-progress-circular>
+ *
+ * <md-progress-circular md-mode="indeterminate"></md-progress-circular>
+ * </hljs>
+ */
+
+MdProgressCircularDirective.$inject = ["$window", "$mdProgressCircular", "$mdTheming", "$mdUtil", "$interval", "$log"];
+angular
+ .module('material.components.progressCircular')
+ .directive('mdProgressCircular', MdProgressCircularDirective);
+
+/* @ngInject */
+function MdProgressCircularDirective($window, $mdProgressCircular, $mdTheming,
+ $mdUtil, $interval, $log) {
+
+ // Note that this shouldn't use use $$rAF, because it can cause an infinite loop
+ // in any tests that call $animate.flush.
+ var rAF = $window.requestAnimationFrame ||
+ $window.webkitRequestAnimationFrame ||
+ angular.noop;
+
+ var cAF = $window.cancelAnimationFrame ||
+ $window.webkitCancelAnimationFrame ||
+ $window.webkitCancelRequestAnimationFrame ||
+ angular.noop;
+
+ var MODE_DETERMINATE = 'determinate';
+ var MODE_INDETERMINATE = 'indeterminate';
+ var DISABLED_CLASS = '_md-progress-circular-disabled';
+ var INDETERMINATE_CLASS = 'md-mode-indeterminate';
+
+ return {
+ restrict: 'E',
+ scope: {
+ value: '@',
+ mdDiameter: '@',
+ mdMode: '@'
+ },
+ template:
+ '<svg xmlns="http://www.w3.org/2000/svg">' +
+ '<path fill="none"/>' +
+ '</svg>',
+ compile: function(element, attrs) {
+ element.attr({
+ 'aria-valuemin': 0,
+ 'aria-valuemax': 100,
+ 'role': 'progressbar'
+ });
+
+ if (angular.isUndefined(attrs.mdMode)) {
+ var mode = attrs.hasOwnProperty('value') ? MODE_DETERMINATE : MODE_INDETERMINATE;
+ attrs.$set('mdMode', mode);
+ } else {
+ attrs.$set('mdMode', attrs.mdMode.trim());
+ }
+
+ return MdProgressCircularLink;
+ }
+ };
+
+ function MdProgressCircularLink(scope, element, attrs) {
+ var node = element[0];
+ var svg = angular.element(node.querySelector('svg'));
+ var path = angular.element(node.querySelector('path'));
+ var startIndeterminate = $mdProgressCircular.startIndeterminate;
+ var endIndeterminate = $mdProgressCircular.endIndeterminate;
+ var iterationCount = 0;
+ var lastAnimationId = 0;
+ var lastDrawFrame;
+ var interval;
+
+ $mdTheming(element);
+ element.toggleClass(DISABLED_CLASS, attrs.hasOwnProperty('disabled'));
+
+ // If the mode is indeterminate, it doesn't need to
+ // wait for the next digest. It can start right away.
+ if (scope.mdMode === MODE_INDETERMINATE){
+ startIndeterminateAnimation();
+ }
+
+ scope.$on('$destroy', function(){
+ cleanupIndeterminateAnimation();
+
+ if (lastDrawFrame) {
+ cAF(lastDrawFrame);
+ }
+ });
+
+ scope.$watchGroup(['value', 'mdMode', function() {
+ var isDisabled = node.disabled;
+
+ // Sometimes the browser doesn't return a boolean, in
+ // which case we should check whether the attribute is
+ // present.
+ if (isDisabled === true || isDisabled === false){
+ return isDisabled;
+ }
+
+ return angular.isDefined(element.attr('disabled'));
+ }], function(newValues, oldValues) {
+ var mode = newValues[1];
+ var isDisabled = newValues[2];
+ var wasDisabled = oldValues[2];
+ var diameter = 0;
+ var strokeWidth = 0;
+
+ if (isDisabled !== wasDisabled) {
+ element.toggleClass(DISABLED_CLASS, !!isDisabled);
+ }
+
+ if (isDisabled) {
+ cleanupIndeterminateAnimation();
+ } else {
+ if (mode !== MODE_DETERMINATE && mode !== MODE_INDETERMINATE) {
+ mode = MODE_INDETERMINATE;
+ attrs.$set('mdMode', mode);
+ }
+
+ if (mode === MODE_INDETERMINATE) {
+ if (oldValues[1] === MODE_DETERMINATE) {
+ diameter = getSize(scope.mdDiameter);
+ strokeWidth = getStroke(diameter);
+ path.attr('d', getSvgArc(diameter, strokeWidth, true));
+ path.attr('stroke-dasharray', getDashLength(diameter, strokeWidth, 75));
+ }
+ startIndeterminateAnimation();
+ } else {
+ var newValue = clamp(newValues[0]);
+ var oldValue = clamp(oldValues[0]);
+
+ cleanupIndeterminateAnimation();
+
+ if (oldValues[1] === MODE_INDETERMINATE) {
+ diameter = getSize(scope.mdDiameter);
+ strokeWidth = getStroke(diameter);
+ path.attr('d', getSvgArc(diameter, strokeWidth, false));
+ path.attr('stroke-dasharray', getDashLength(diameter, strokeWidth, 100));
+ }
+
+ element.attr('aria-valuenow', newValue);
+ renderCircle(oldValue, newValue);
+ }
+ }
+
+ });
+
+ // This is in a separate watch in order to avoid layout, unless
+ // the value has actually changed.
+ scope.$watch('mdDiameter', function(newValue) {
+ var diameter = getSize(newValue);
+ var strokeWidth = getStroke(diameter);
+ var value = clamp(scope.value);
+ var transformOrigin = (diameter / 2) + 'px';
+ var dimensions = {
+ width: diameter + 'px',
+ height: diameter + 'px'
+ };
+
+ // The viewBox has to be applied via setAttribute, because it is
+ // case-sensitive. If jQuery is included in the page, `.attr` lowercases
+ // all attribute names.
+ svg[0].setAttribute('viewBox', '0 0 ' + diameter + ' ' + diameter);
+
+ // Usually viewBox sets the dimensions for the SVG, however that doesn't
+ // seem to be the case on IE10.
+ // Important! The transform origin has to be set from here and it has to
+ // be in the format of "Ypx Ypx Ypx", otherwise the rotation wobbles in
+ // IE and Edge, because they don't account for the stroke width when
+ // rotating. Also "center" doesn't help in this case, it has to be a
+ // precise value.
+ svg
+ .css(dimensions)
+ .css('transform-origin', transformOrigin + ' ' + transformOrigin + ' ' + transformOrigin);
+
+ element.css(dimensions);
+
+ path.attr('stroke-width', strokeWidth);
+ path.attr('stroke-linecap', 'square');
+ if (scope.mdMode == MODE_INDETERMINATE) {
+ path.attr('d', getSvgArc(diameter, strokeWidth, true));
+ path.attr('stroke-dasharray', getDashLength(diameter, strokeWidth, 75));
+ path.attr('stroke-dashoffset', getDashOffset(diameter, strokeWidth, 1, 75));
+ } else {
+ path.attr('d', getSvgArc(diameter, strokeWidth, false));
+ path.attr('stroke-dasharray', getDashLength(diameter, strokeWidth, 100));
+ path.attr('stroke-dashoffset', getDashOffset(diameter, strokeWidth, 0, 100));
+ renderCircle(value, value);
+ }
+
+ });
+
+ function renderCircle(animateFrom, animateTo, easing, duration, iterationCount, maxValue) {
+ var id = ++lastAnimationId;
+ var startTime = $mdUtil.now();
+ var changeInValue = animateTo - animateFrom;
+ var diameter = getSize(scope.mdDiameter);
+ var strokeWidth = getStroke(diameter);
+ var ease = easing || $mdProgressCircular.easeFn;
+ var animationDuration = duration || $mdProgressCircular.duration;
+ var rotation = -90 * (iterationCount || 0);
+ var dashLimit = maxValue || 100;
+
+ // No need to animate it if the values are the same
+ if (animateTo === animateFrom) {
+ renderFrame(animateTo);
+ } else {
+ lastDrawFrame = rAF(function animation() {
+ var currentTime = $window.Math.max(0, $window.Math.min($mdUtil.now() - startTime, animationDuration));
+
+ renderFrame(ease(currentTime, animateFrom, changeInValue, animationDuration));
+
+ // Do not allow overlapping animations
+ if (id === lastAnimationId && currentTime < animationDuration) {
+ lastDrawFrame = rAF(animation);
+ }
+ });
+ }
+
+ function renderFrame(value) {
+ path.attr('stroke-dashoffset', getDashOffset(diameter, strokeWidth, value, dashLimit));
+ path.attr('transform','rotate(' + (rotation) + ' ' + diameter/2 + ' ' + diameter/2 + ')');
+ }
+ }
+
+ function animateIndeterminate() {
+ renderCircle(
+ startIndeterminate,
+ endIndeterminate,
+ $mdProgressCircular.easeFnIndeterminate,
+ $mdProgressCircular.durationIndeterminate,
+ iterationCount,
+ 75
+ );
+
+ // The %4 technically isn't necessary, but it keeps the rotation
+ // under 360, instead of becoming a crazy large number.
+ iterationCount = ++iterationCount % 4;
+
+ }
+
+ function startIndeterminateAnimation() {
+ if (!interval) {
+ // Note that this interval isn't supposed to trigger a digest.
+ interval = $interval(
+ animateIndeterminate,
+ $mdProgressCircular.durationIndeterminate,
+ 0,
+ false
+ );
+
+ animateIndeterminate();
+
+ element
+ .addClass(INDETERMINATE_CLASS)
+ .removeAttr('aria-valuenow');
+ }
+ }
+
+ function cleanupIndeterminateAnimation() {
+ if (interval) {
+ $interval.cancel(interval);
+ interval = null;
+ element.removeClass(INDETERMINATE_CLASS);
+ }
+ }
+ }
+
+ /**
+ * Returns SVG path data for progress circle
+ * Syntax spec: https://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands
+ *
+ * @param {number} diameter Diameter of the container.
+ * @param {number} strokeWidth Stroke width to be used when drawing circle
+ * @param {boolean} indeterminate Use if progress circle will be used for indeterminate
+ *
+ * @returns {string} String representation of an SVG arc.
+ */
+ function getSvgArc(diameter, strokeWidth, indeterminate) {
+ var radius = diameter / 2;
+ var offset = strokeWidth / 2;
+ var start = radius + ',' + offset; // ie: (25, 2.5) or 12 o'clock
+ var end = offset + ',' + radius; // ie: (2.5, 25) or 9 o'clock
+ var arcRadius = radius - offset;
+ return 'M' + start
+ + 'A' + arcRadius + ',' + arcRadius + ' 0 1 1 ' + end // 75% circle
+ + (indeterminate ? '' : 'A' + arcRadius + ',' + arcRadius + ' 0 0 1 ' + start); // loop to start
+ }
+
+ /**
+ * Return stroke length for progress circle
+ *
+ * @param {number} diameter Diameter of the container.
+ * @param {number} strokeWidth Stroke width to be used when drawing circle
+ * @param {number} value Percentage of circle (between 0 and 100)
+ * @param {number} maxArcLength Maximum length of arc as a percentage of circle (between 0 and 100)
+ *
+ * @returns {number} Stroke length for progress circle
+ */
+ function getDashOffset(diameter, strokeWidth, value, maxArcLength) {
+ return getSpinnerCircumference(diameter, strokeWidth) * ((maxArcLength - value) / 100);
+ }
+
+ /**
+ * Limits a value between 0 and 100.
+ */
+ function clamp(value) {
+ return $window.Math.max(0, $window.Math.min(value || 0, 100));
+ }
+
+ /**
+ * Determines the size of a progress circle, based on the provided
+ * value in the following formats: `X`, `Ypx`, `Z%`.
+ */
+ function getSize(value) {
+ var defaultValue = $mdProgressCircular.progressSize;
+
+ if (value) {
+ var parsed = parseFloat(value);
+
+ if (value.lastIndexOf('%') === value.length - 1) {
+ parsed = (parsed / 100) * defaultValue;
+ }
+
+ return parsed;
+ }
+
+ return defaultValue;
+ }
+
+ /**
+ * Determines the circle's stroke width, based on
+ * the provided diameter.
+ */
+ function getStroke(diameter) {
+ return $mdProgressCircular.strokeWidth / 100 * diameter;
+ }
+
+ /**
+ * Return length of the dash
+ *
+ * @param {number} diameter Diameter of the container.
+ * @param {number} strokeWidth Stroke width to be used when drawing circle
+ * @param {number} value Percentage of circle (between 0 and 100)
+ *
+ * @returns {number} Length of the dash
+ */
+ function getDashLength(diameter, strokeWidth, value) {
+ return getSpinnerCircumference(diameter, strokeWidth) * (value / 100);
+ }
+
+ /**
+ * Return circumference of the spinner
+ *
+ * @param {number} diameter Diameter of the container.
+ * @param {number} strokeWidth Stroke width to be used when drawing circle
+ *
+ * @returns {number} Circumference of the spinner
+ */
+ function getSpinnerCircumference(diameter, strokeWidth) {
+ return ((diameter - strokeWidth) * $window.Math.PI);
+ }
+
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc service
+ * @name $mdProgressCircular
+ * @module material.components.progressCircular
+ *
+ * @description
+ * Allows the user to specify the default options for the `progressCircular` directive.
+ *
+ * @property {number} progressSize Diameter of the progress circle in pixels.
+ * @property {number} strokeWidth Width of the circle's stroke as a percentage of the circle's size.
+ * @property {number} duration Length of the circle animation in milliseconds.
+ * @property {function} easeFn Default easing animation function.
+ * @property {object} easingPresets Collection of pre-defined easing functions.
+ *
+ * @property {number} durationIndeterminate Duration of the indeterminate animation.
+ * @property {number} startIndeterminate Indeterminate animation start point.
+ * @property {number} endIndeterminate Indeterminate animation end point.
+ * @property {function} easeFnIndeterminate Easing function to be used when animating
+ * between the indeterminate values.
+ *
+ * @property {(function(object): object)} configure Used to modify the default options.
+ *
+ * @usage
+ * <hljs lang="js">
+ * myAppModule.config(function($mdProgressCircularProvider) {
+ *
+ * // Example of changing the default progress options.
+ * $mdProgressCircularProvider.configure({
+ * progressSize: 100,
+ * strokeWidth: 20,
+ * duration: 800
+ * });
+ * });
+ * </hljs>
+ *
+ */
+
+angular
+ .module('material.components.progressCircular')
+ .provider("$mdProgressCircular", MdProgressCircularProvider);
+
+function MdProgressCircularProvider() {
+ var progressConfig = {
+ progressSize: 50,
+ strokeWidth: 10,
+ duration: 100,
+ easeFn: linearEase,
+
+ durationIndeterminate: 1333,
+ startIndeterminate: 1,
+ endIndeterminate: 149,
+ easeFnIndeterminate: materialEase,
+
+ easingPresets: {
+ linearEase: linearEase,
+ materialEase: materialEase
+ }
+ };
+
+ return {
+ configure: function(options) {
+ progressConfig = angular.extend(progressConfig, options || {});
+ return progressConfig;
+ },
+ $get: function() { return progressConfig; }
+ };
+
+ function linearEase(t, b, c, d) {
+ return c * t / d + b;
+ }
+
+ function materialEase(t, b, c, d) {
+ // via http://www.timotheegroleau.com/Flash/experiments/easing_function_generator.htm
+ // with settings of [0, 0, 1, 1]
+ var ts = (t /= d) * t;
+ var tc = ts * t;
+ return b + c * (6 * tc * ts + -15 * ts * ts + 10 * tc);
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.progressLinear
+ * @description Linear Progress module!
+ */
+MdProgressLinearDirective.$inject = ["$mdTheming", "$mdUtil", "$log"];
+angular.module('material.components.progressLinear', [
+ 'material.core'
+])
+ .directive('mdProgressLinear', MdProgressLinearDirective);
+
+/**
+ * @ngdoc directive
+ * @name mdProgressLinear
+ * @module material.components.progressLinear
+ * @restrict E
+ *
+ * @description
+ * The linear progress directive is used to make loading content
+ * in your app as delightful and painless as possible by minimizing
+ * the amount of visual change a user sees before they can view
+ * and interact with content.
+ *
+ * Each operation should only be represented by one activity indicator
+ * For example: one refresh operation should not display both a
+ * refresh bar and an activity circle.
+ *
+ * For operations where the percentage of the operation completed
+ * can be determined, use a determinate indicator. They give users
+ * a quick sense of how long an operation will take.
+ *
+ * For operations where the user is asked to wait a moment while
+ * something finishes up, and it’s not necessary to expose what's
+ * happening behind the scenes and how long it will take, use an
+ * indeterminate indicator.
+ *
+ * @param {string} md-mode Select from one of four modes: determinate, indeterminate, buffer or query.
+ *
+ * Note: if the `md-mode` value is set as undefined or specified as 1 of the four (4) valid modes, then `indeterminate`
+ * will be auto-applied as the mode.
+ *
+ * Note: if not configured, the `md-mode="indeterminate"` will be auto injected as an attribute. If `value=""` is also specified, however,
+ * then `md-mode="determinate"` would be auto-injected instead.
+ * @param {number=} value In determinate and buffer modes, this number represents the percentage of the primary progress bar. Default: 0
+ * @param {number=} md-buffer-value In the buffer mode, this number represents the percentage of the secondary progress bar. Default: 0
+ * @param {boolean=} ng-disabled Determines whether to disable the progress element.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-progress-linear md-mode="determinate" value="..."></md-progress-linear>
+ *
+ * <md-progress-linear md-mode="determinate" ng-value="..."></md-progress-linear>
+ *
+ * <md-progress-linear md-mode="indeterminate"></md-progress-linear>
+ *
+ * <md-progress-linear md-mode="buffer" value="..." md-buffer-value="..."></md-progress-linear>
+ *
+ * <md-progress-linear md-mode="query"></md-progress-linear>
+ * </hljs>
+ */
+function MdProgressLinearDirective($mdTheming, $mdUtil, $log) {
+ var MODE_DETERMINATE = "determinate";
+ var MODE_INDETERMINATE = "indeterminate";
+ var MODE_BUFFER = "buffer";
+ var MODE_QUERY = "query";
+ var DISABLED_CLASS = "_md-progress-linear-disabled";
+
+ return {
+ restrict: 'E',
+ template: '<div class="md-container">' +
+ '<div class="md-dashed"></div>' +
+ '<div class="md-bar md-bar1"></div>' +
+ '<div class="md-bar md-bar2"></div>' +
+ '</div>',
+ compile: compile
+ };
+
+ function compile(tElement, tAttrs, transclude) {
+ tElement.attr('aria-valuemin', 0);
+ tElement.attr('aria-valuemax', 100);
+ tElement.attr('role', 'progressbar');
+
+ return postLink;
+ }
+ function postLink(scope, element, attr) {
+ $mdTheming(element);
+
+ var lastMode;
+ var isDisabled = attr.hasOwnProperty('disabled');
+ var toVendorCSS = $mdUtil.dom.animator.toCss;
+ var bar1 = angular.element(element[0].querySelector('.md-bar1'));
+ var bar2 = angular.element(element[0].querySelector('.md-bar2'));
+ var container = angular.element(element[0].querySelector('.md-container'));
+
+ element
+ .attr('md-mode', mode())
+ .toggleClass(DISABLED_CLASS, isDisabled);
+
+ validateMode();
+ watchAttributes();
+
+ /**
+ * Watch the value, md-buffer-value, and md-mode attributes
+ */
+ function watchAttributes() {
+ attr.$observe('value', function(value) {
+ var percentValue = clamp(value);
+ element.attr('aria-valuenow', percentValue);
+
+ if (mode() != MODE_QUERY) animateIndicator(bar2, percentValue);
+ });
+
+ attr.$observe('mdBufferValue', function(value) {
+ animateIndicator(bar1, clamp(value));
+ });
+
+ attr.$observe('disabled', function(value) {
+ if (value === true || value === false) {
+ isDisabled = !!value;
+ } else {
+ isDisabled = angular.isDefined(value);
+ }
+
+ element.toggleClass(DISABLED_CLASS, isDisabled);
+ container.toggleClass(lastMode, !isDisabled);
+ });
+
+ attr.$observe('mdMode', function(mode) {
+ if (lastMode) container.removeClass(lastMode);
+
+ switch (mode) {
+ case MODE_QUERY:
+ case MODE_BUFFER:
+ case MODE_DETERMINATE:
+ case MODE_INDETERMINATE:
+ container.addClass(lastMode = "md-mode-" + mode);
+ break;
+ default:
+ container.addClass(lastMode = "md-mode-" + MODE_INDETERMINATE);
+ break;
+ }
+ });
+ }
+
+ /**
+ * Auto-defaults the mode to either `determinate` or `indeterminate` mode; if not specified
+ */
+ function validateMode() {
+ if (angular.isUndefined(attr.mdMode)) {
+ var hasValue = angular.isDefined(attr.value);
+ var mode = hasValue ? MODE_DETERMINATE : MODE_INDETERMINATE;
+ var info = "Auto-adding the missing md-mode='{0}' to the ProgressLinear element";
+ element.attr("md-mode", mode);
+ attr.mdMode = mode;
+ }
+ }
+
+ /**
+ * Is the md-mode a valid option?
+ */
+ function mode() {
+ var value = (attr.mdMode || "").trim();
+ if (value) {
+ switch (value) {
+ case MODE_DETERMINATE:
+ case MODE_INDETERMINATE:
+ case MODE_BUFFER:
+ case MODE_QUERY:
+ break;
+ default:
+ value = MODE_INDETERMINATE;
+ break;
+ }
+ }
+ return value;
+ }
+
+ /**
+ * Manually set CSS to animate the Determinate indicator based on the specified
+ * percentage value (0-100).
+ */
+ function animateIndicator(target, value) {
+ if (isDisabled || !mode()) return;
+
+ var to = $mdUtil.supplant("translateX({0}%) scale({1},1)", [(value-100)/2, value/100]);
+ var styles = toVendorCSS({ transform : to });
+ angular.element(target).css(styles);
+ }
+ }
+
+ /**
+ * Clamps the value to be between 0 and 100.
+ * @param {number} value The value to clamp.
+ * @returns {number}
+ */
+ function clamp(value) {
+ return Math.max(0, Math.min(value || 0, 100));
+ }
+}
+
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.radioButton
+ * @description radioButton module!
+ */
+mdRadioGroupDirective.$inject = ["$mdUtil", "$mdConstant", "$mdTheming", "$timeout"];
+mdRadioButtonDirective.$inject = ["$mdAria", "$mdUtil", "$mdTheming"];
+angular.module('material.components.radioButton', [
+ 'material.core'
+])
+ .directive('mdRadioGroup', mdRadioGroupDirective)
+ .directive('mdRadioButton', mdRadioButtonDirective);
+
+/**
+ * @type {Readonly<{NEXT: number, CURRENT: number, PREVIOUS: number}>}
+ */
+var incrementSelection = Object.freeze({PREVIOUS: -1, CURRENT: 0, NEXT: 1});
+
+/**
+ * @ngdoc directive
+ * @module material.components.radioButton
+ * @name mdRadioGroup
+ *
+ * @restrict E
+ *
+ * @description
+ * The `<md-radio-group>` directive identifies a grouping
+ * container for the 1..n grouped radio buttons; specified using nested
+ * `<md-radio-button>` elements.
+ *
+ * The radio button uses the accent color by default. The primary color palette may be used with
+ * the `md-primary` class.
+ *
+ * Note: `<md-radio-group>` and `<md-radio-button>` handle `tabindex` differently
+ * than the native `<input type="radio">` controls. Whereas the native controls
+ * force the user to tab through all the radio buttons, `<md-radio-group>`
+ * is focusable and by default the `<md-radio-button>`s are not.
+ *
+ * @param {string} ng-model Assignable angular expression to data-bind to.
+ * @param {string=} ng-change AngularJS expression to be executed when input changes due to user
+ * interaction.
+ * @param {boolean=} md-no-ink If present, disables ink ripple effects.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-radio-group ng-model="selected">
+ * <md-radio-button ng-repeat="item in items"
+ * ng-value="item.value" aria-label="{{item.label}}">
+ * {{ item.label }}
+ * </md-radio-button>
+ * </md-radio-group>
+ * </hljs>
+ */
+function mdRadioGroupDirective($mdUtil, $mdConstant, $mdTheming, $timeout) {
+ RadioGroupController.prototype = createRadioGroupControllerProto();
+
+ return {
+ restrict: 'E',
+ controller: ['$element', RadioGroupController],
+ require: ['mdRadioGroup', '?ngModel'],
+ link: { pre: linkRadioGroup }
+ };
+
+ function linkRadioGroup(scope, element, attr, controllers) {
+ // private md component indicator for styling
+ element.addClass('_md');
+ $mdTheming(element);
+
+ var radioGroupController = controllers[0];
+ var ngModelCtrl = controllers[1] || $mdUtil.fakeNgModel();
+
+ radioGroupController.init(ngModelCtrl);
+
+ scope.mouseActive = false;
+
+ element
+ .attr({
+ 'role': 'radiogroup',
+ 'tabIndex': element.attr('tabindex') || '0'
+ })
+ .on('keydown', keydownListener)
+ .on('mousedown', function() {
+ scope.mouseActive = true;
+ $timeout(function() {
+ scope.mouseActive = false;
+ }, 100);
+ })
+ .on('focus', function() {
+ if (scope.mouseActive === false) {
+ radioGroupController.$element.addClass('md-focused');
+ }
+ })
+ .on('blur', function() {
+ radioGroupController.$element.removeClass('md-focused');
+ });
+
+ // Initially set the first radio button as the aria-activedescendant. This will be overridden
+ // if a 'checked' radio button gets rendered. We need to wait for the nextTick here so that the
+ // radio buttons have their id values assigned.
+ $mdUtil.nextTick(function () {
+ var radioButtons = getRadioButtons(radioGroupController.$element);
+ if (radioButtons.count() &&
+ !radioGroupController.$element[0].hasAttribute('aria-activedescendant')) {
+ radioGroupController.setActiveDescendant(radioButtons.first().id);
+ }
+ });
+
+ /**
+ * Apply the md-focused class if it isn't already applied.
+ */
+ function setFocus() {
+ if (!element.hasClass('md-focused')) { element.addClass('md-focused'); }
+ }
+
+ /**
+ * @param {KeyboardEvent} keyboardEvent
+ */
+ function keydownListener(keyboardEvent) {
+ var keyCode = keyboardEvent.which || keyboardEvent.keyCode;
+
+ // Only listen to events that we originated ourselves
+ // so that we don't trigger on things like arrow keys in inputs.
+ if (keyCode !== $mdConstant.KEY_CODE.ENTER &&
+ keyboardEvent.currentTarget !== keyboardEvent.target) {
+ return;
+ }
+
+ switch (keyCode) {
+ case $mdConstant.KEY_CODE.LEFT_ARROW:
+ case $mdConstant.KEY_CODE.UP_ARROW:
+ keyboardEvent.preventDefault();
+ radioGroupController.selectPrevious();
+ setFocus();
+ break;
+
+ case $mdConstant.KEY_CODE.RIGHT_ARROW:
+ case $mdConstant.KEY_CODE.DOWN_ARROW:
+ keyboardEvent.preventDefault();
+ radioGroupController.selectNext();
+ setFocus();
+ break;
+
+ case $mdConstant.KEY_CODE.SPACE:
+ keyboardEvent.preventDefault();
+ radioGroupController.selectCurrent();
+ break;
+
+ case $mdConstant.KEY_CODE.ENTER:
+ var form = angular.element($mdUtil.getClosest(element[0], 'form'));
+ if (form.length > 0) {
+ form.triggerHandler('submit');
+ }
+ break;
+ }
+ }
+ }
+
+ /**
+ * @param {JQLite} $element
+ * @constructor
+ */
+ function RadioGroupController($element) {
+ this._radioButtonRenderFns = [];
+ this.$element = $element;
+ }
+
+ function createRadioGroupControllerProto() {
+ return {
+ init: function(ngModelCtrl) {
+ this._ngModelCtrl = ngModelCtrl;
+ this._ngModelCtrl.$render = angular.bind(this, this.render);
+ },
+ add: function(rbRender) {
+ this._radioButtonRenderFns.push(rbRender);
+ },
+ remove: function(rbRender) {
+ var index = this._radioButtonRenderFns.indexOf(rbRender);
+ if (index !== -1) {
+ this._radioButtonRenderFns.splice(index, 1);
+ }
+ },
+ render: function() {
+ this._radioButtonRenderFns.forEach(function(rbRender) {
+ rbRender();
+ });
+ },
+ setViewValue: function(value, eventType) {
+ this._ngModelCtrl.$setViewValue(value, eventType);
+ // update the other radio buttons as well
+ this.render();
+ },
+ getViewValue: function() {
+ return this._ngModelCtrl.$viewValue;
+ },
+ selectCurrent: function() {
+ return changeSelectedButton(this.$element, incrementSelection.CURRENT);
+ },
+ selectNext: function() {
+ return changeSelectedButton(this.$element, incrementSelection.NEXT);
+ },
+ selectPrevious: function() {
+ return changeSelectedButton(this.$element, incrementSelection.PREVIOUS);
+ },
+ setActiveDescendant: function (radioId) {
+ this.$element.attr('aria-activedescendant', radioId);
+ },
+ isDisabled: function() {
+ return this.$element[0].hasAttribute('disabled');
+ }
+ };
+ }
+
+ /**
+ * Coerce all child radio buttons into an array, then wrap them in an iterator.
+ * @param parent {!JQLite}
+ * @return {{add: add, next: (function()), last: (function(): any|null), previous: (function()), count: (function(): number), hasNext: (function(*=): Array.length|*|number|boolean), inRange: (function(*): boolean), remove: remove, contains: (function(*=): *|boolean), itemAt: (function(*=): any|null), findBy: (function(*, *): *[]), hasPrevious: (function(*=): Array.length|*|number|boolean), items: (function(): *[]), indexOf: (function(*=): number), first: (function(): any|null)}}
+ */
+ function getRadioButtons(parent) {
+ return $mdUtil.iterator(parent[0].querySelectorAll('md-radio-button'), true);
+ }
+
+ /**
+ * Change the radio group's selected button by a given increment.
+ * If no button is selected, select the first button.
+ * @param {JQLite} parent the md-radio-group
+ * @param {incrementSelection} increment enum that determines whether the next or
+ * previous button is clicked. For current, only the first button is selected, otherwise the
+ * current selection is maintained (by doing nothing).
+ */
+ function changeSelectedButton(parent, increment) {
+ var buttons = getRadioButtons(parent);
+ var target;
+
+ if (buttons.count()) {
+ var validate = function (button) {
+ // If disabled, then NOT valid
+ return !angular.element(button).attr("disabled");
+ };
+
+ var selected = parent[0].querySelector('md-radio-button.md-checked');
+ if (!selected) {
+ target = buttons.first();
+ } else if (increment === incrementSelection.PREVIOUS ||
+ increment === incrementSelection.NEXT) {
+ target = buttons[
+ increment === incrementSelection.PREVIOUS ? 'previous' : 'next'
+ ](selected, validate);
+ }
+
+ if (target) {
+ // Activate radioButton's click listener (triggerHandler won't create a real click event)
+ angular.element(target).triggerHandler('click');
+ }
+ }
+ }
+}
+
+/**
+ * @ngdoc directive
+ * @module material.components.radioButton
+ * @name mdRadioButton
+ *
+ * @restrict E
+ *
+ * @description
+ * The `<md-radio-button>`directive is the child directive required to be used within `<md-radio-group>` elements.
+ *
+ * While similar to the `<input type="radio" ng-model="" value="">` directive,
+ * the `<md-radio-button>` directive provides ink effects, ARIA support, and
+ * supports use within named radio groups.
+ *
+ * One of `value` or `ng-value` must be set so that the `md-radio-group`'s model is set properly when the
+ * `md-radio-button` is selected.
+ *
+ * @param {string} value The value to which the model should be set when selected.
+ * @param {string} ng-value AngularJS expression which sets the value to which the model should
+ * be set when selected.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} aria-label Adds label to radio button for accessibility.
+ * Defaults to radio button's text. If no text content is available, a warning will be logged.
+ *
+ * @usage
+ * <hljs lang="html">
+ *
+ * <md-radio-button value="1" aria-label="Label 1">
+ * Label 1
+ * </md-radio-button>
+ *
+ * <md-radio-button ng-value="specialValue" aria-label="Green">
+ * Green
+ * </md-radio-button>
+ *
+ * </hljs>
+ *
+ */
+function mdRadioButtonDirective($mdAria, $mdUtil, $mdTheming) {
+
+ var CHECKED_CSS = 'md-checked';
+
+ return {
+ restrict: 'E',
+ require: '^mdRadioGroup',
+ transclude: true,
+ template: '<div class="md-container" md-ink-ripple md-ink-ripple-checkbox>' +
+ '<div class="md-off"></div>' +
+ '<div class="md-on"></div>' +
+ '</div>' +
+ '<div ng-transclude class="md-label"></div>',
+ link: link
+ };
+
+ function link(scope, element, attr, radioGroupController) {
+ var lastChecked;
+
+ $mdTheming(element);
+ configureAria(element);
+ element.addClass('md-auto-horizontal-margin');
+
+ // ngAria overwrites the aria-checked inside a $watch for ngValue.
+ // We should defer the initialization until all the watches have fired.
+ // This can also be fixed by removing the `lastChecked` check, but that'll
+ // cause more DOM manipulation on each digest.
+ if (attr.ngValue) {
+ $mdUtil.nextTick(initialize, false);
+ } else {
+ initialize();
+ }
+
+ /**
+ * Initializes the component.
+ */
+ function initialize() {
+ if (!radioGroupController) {
+ throw 'RadioButton: No RadioGroupController could be found.';
+ }
+
+ radioGroupController.add(render);
+ attr.$observe('value', render);
+
+ element
+ .on('click', listener)
+ .on('$destroy', function() {
+ radioGroupController.remove(render);
+ });
+ }
+
+ /**
+ * On click functionality.
+ */
+ function listener(ev) {
+ if (element[0].hasAttribute('disabled') || radioGroupController.isDisabled()) return;
+
+ scope.$apply(function() {
+ radioGroupController.setViewValue(attr.value, ev && ev.type);
+ });
+ }
+
+ /**
+ * Add or remove the `.md-checked` class from the RadioButton (and conditionally its parent).
+ * Update the `aria-activedescendant` attribute.
+ */
+ function render() {
+ var checked = radioGroupController.getViewValue() == attr.value;
+
+ if (checked === lastChecked) return;
+
+ if (element[0] && element[0].parentNode &&
+ element[0].parentNode.nodeName.toLowerCase() !== 'md-radio-group') {
+ // If the radioButton is inside a div, then add class so highlighting will work.
+ element.parent().toggleClass(CHECKED_CSS, checked);
+ }
+
+ if (checked) {
+ radioGroupController.setActiveDescendant(element.attr('id'));
+ }
+
+ lastChecked = checked;
+
+ element
+ .attr('aria-checked', checked)
+ .toggleClass(CHECKED_CSS, checked);
+ }
+
+ /**
+ * Inject ARIA-specific attributes appropriate for each radio button
+ */
+ function configureAria(element) {
+ element.attr({
+ id: attr.id || 'radio_' + $mdUtil.nextUid(),
+ role: 'radio',
+ 'aria-checked': 'false'
+ });
+
+ $mdAria.expectWithText(element, 'aria-label');
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.select
+ */
+
+/***************************************************
+
+ ### TODO ###
+ - [ ] Abstract placement logic in $mdSelect service to $mdMenu service
+
+ ***************************************************/
+
+SelectDirective.$inject = ["$mdSelect", "$mdUtil", "$mdConstant", "$mdTheming", "$mdAria", "$parse", "$sce"];
+SelectMenuDirective.$inject = ["$parse", "$mdUtil", "$mdConstant", "$mdTheming"];
+OptionDirective.$inject = ["$mdButtonInkRipple", "$mdUtil", "$mdTheming"];
+SelectProvider.$inject = ["$$interimElementProvider"];
+OptionController.$inject = ["$element"];
+var SELECT_EDGE_MARGIN = 8;
+var selectNextId = 0;
+var CHECKBOX_SELECTION_INDICATOR =
+ angular.element('<div class="md-container"><div class="md-icon"></div></div>');
+
+angular.module('material.components.select', [
+ 'material.core',
+ 'material.components.backdrop'
+ ])
+ .directive('mdSelect', SelectDirective)
+ .directive('mdSelectMenu', SelectMenuDirective)
+ .directive('mdOption', OptionDirective)
+ .directive('mdOptgroup', OptgroupDirective)
+ .directive('mdSelectHeader', SelectHeaderDirective)
+ .provider('$mdSelect', SelectProvider);
+
+/**
+ * @ngdoc directive
+ * @name mdSelect
+ * @restrict E
+ * @module material.components.select
+ *
+ * @description Displays a select box, bound to an `ng-model`. Selectable options are defined using
+ * the <a ng-href="api/directive/mdOption">md-option</a> element directive. Options can be grouped
+ * using the <a ng-href="api/directive/mdOptgroup">md-optgroup</a> element directive.
+ *
+ * When the select is required and uses a floating label, then the label will automatically contain
+ * an asterisk (`*`). This behavior can be disabled by using the `md-no-asterisk` attribute.
+ *
+ * By default, the select will display with an underline to match other form elements. This can be
+ * disabled by applying the `md-no-underline` CSS class.
+ *
+ * @param {expression} ng-model Assignable angular expression to data-bind to.
+ * @param {expression=} ng-change Expression to be executed when the model value changes.
+ * @param {boolean=} multiple When present, allows for more than one option to be selected.
+ * The model is an array with the selected choices. **Note:** This attribute is only evaluated
+ * once; it is not watched.
+ * @param {expression=} md-on-close Expression to be evaluated when the select is closed.
+ * @param {expression=} md-on-open Expression to be evaluated when opening the select.
+ * Will hide the select options and show a spinner until the evaluated promise resolves.
+ * @param {expression=} md-selected-text Expression to be evaluated that will return a string
+ * to be displayed as a placeholder in the select input box when it is closed. The value
+ * will be treated as *text* (not html).
+ * @param {expression=} md-selected-html Expression to be evaluated that will return a string
+ * to be displayed as a placeholder in the select input box when it is closed. The value
+ * will be treated as *html*. The value must either be explicitly marked as trustedHtml or
+ * the ngSanitize module must be loaded.
+ * @param {string=} placeholder Placeholder hint text.
+ * @param {boolean=} md-no-asterisk When set to true, an asterisk will not be appended to the
+ * floating label. **Note:** This attribute is only evaluated once; it is not watched.
+ * @param {string=} aria-label Optional label for accessibility. Only necessary if no explicit label
+ * is present.
+ * @param {string=} md-container-class Class list to get applied to the `.md-select-menu-container`
+ * element (for custom styling).
+ * @param {string=} md-select-only-option If specified, a `<md-select>` will automatically select
+ * it's first option, if it only has one.
+ *
+ * @usage
+ * With a placeholder (label and aria-label are added dynamically)
+ * <hljs lang="html">
+ * <md-input-container>
+ * <md-select
+ * ng-model="someModel"
+ * placeholder="Select a state">
+ * <md-option ng-value="opt" ng-repeat="opt in neighborhoods2">{{ opt }}</md-option>
+ * </md-select>
+ * </md-input-container>
+ * </hljs>
+ *
+ * With an explicit label
+ * <hljs lang="html">
+ * <md-input-container>
+ * <label>State</label>
+ * <md-select
+ * ng-model="someModel">
+ * <md-option ng-value="opt" ng-repeat="opt in neighborhoods2">{{ opt }}</md-option>
+ * </md-select>
+ * </md-input-container>
+ * </hljs>
+ *
+ * Using the `md-select-header` element directive
+ *
+ * When a developer needs to put more than just a text label in the `md-select-menu`, they should
+ * use one or more `md-select-header`s. These elements can contain custom HTML which can be styled
+ * as desired. Use cases for this element include a sticky search bar and custom option group
+ * labels.
+ *
+ * <hljs lang="html">
+ * <md-input-container>
+ * <md-select ng-model="someModel">
+ * <md-select-header>
+ * <span> Neighborhoods - </span>
+ * </md-select-header>
+ * <md-option ng-value="opt" ng-repeat="opt in neighborhoods2">{{ opt }}</md-option>
+ * </md-select>
+ * </md-input-container>
+ * </hljs>
+ *
+ * ## Selects and object equality
+ * When using a `md-select` to pick from a list of objects, it is important to realize how javascript handles
+ * equality. Consider the following example:
+ * <hljs lang="js">
+ * angular.controller('MyCtrl', function($scope) {
+ * $scope.users = [
+ * { id: 1, name: 'Bob' },
+ * { id: 2, name: 'Alice' },
+ * { id: 3, name: 'Steve' }
+ * ];
+ * $scope.selectedUser = { id: 1, name: 'Bob' };
+ * });
+ * </hljs>
+ * <hljs lang="html">
+ * <div ng-controller="MyCtrl">
+ * <md-select ng-model="selectedUser">
+ * <md-option ng-value="user" ng-repeat="user in users">{{ user.name }}</md-option>
+ * </md-select>
+ * </div>
+ * </hljs>
+ *
+ * At first one might expect that the select should be populated with "Bob" as the selected user.
+ * However, this is not true. To determine whether something is selected,
+ * `ngModelController` is looking at whether `$scope.selectedUser == (any user in $scope.users);`;
+ *
+ * Javascript's `==` operator does not check for deep equality (ie. that all properties
+ * on the object are the same), but instead whether the objects are *the same object in memory*.
+ * In this case, we have two instances of identical objects, but they exist in memory as unique
+ * entities. Because of this, the select will have no value populated for a selected user.
+ *
+ * To get around this, `ngModelController` provides a `track by` option that allows us to specify a
+ * different expression which will be used for the equality operator. As such, we can update our
+ * `html` to make use of this by specifying the `ng-model-options="{trackBy: '$value.id'}"` on the
+ * `md-select` element. This converts our equality expression to be
+ * `$scope.selectedUser.id == (any id in $scope.users.map(function(u) { return u.id; }));`
+ * which results in Bob being selected as desired.
+ *
+ * **Note:** We do not support AngularJS's `track by` syntax. For instance
+ * `ng-options="user in users track by user.id"` will not work with `md-select`.
+ *
+ * Working HTML:
+ * <hljs lang="html">
+ * <div ng-controller="MyCtrl">
+ * <md-select ng-model="selectedUser" ng-model-options="{trackBy: '$value.id'}">
+ * <md-option ng-value="user" ng-repeat="user in users">{{ user.name }}</md-option>
+ * </md-select>
+ * </div>
+ * </hljs>
+ */
+function SelectDirective($mdSelect, $mdUtil, $mdConstant, $mdTheming, $mdAria, $parse, $sce) {
+ return {
+ restrict: 'E',
+ require: ['^?mdInputContainer', 'mdSelect', 'ngModel', '?^form'],
+ compile: compile,
+ controller: function() {
+ } // empty placeholder controller to be initialized in link
+ };
+
+ /**
+ * @param {JQLite} tElement
+ * @param {IAttributes} tAttrs
+ * @return {postLink}
+ */
+ function compile(tElement, tAttrs) {
+ var isMultiple = $mdUtil.parseAttributeBoolean(tAttrs.multiple);
+ tElement.addClass('md-auto-horizontal-margin');
+
+ // add the select value that will hold our placeholder or selected option value
+ var valueEl = angular.element('<md-select-value><span></span></md-select-value>');
+ valueEl.append('<span class="md-select-icon" aria-hidden="true"></span>');
+ valueEl.addClass('md-select-value');
+ if (!valueEl[0].hasAttribute('id')) {
+ valueEl.attr('id', 'select_value_label_' + $mdUtil.nextUid());
+ }
+
+ // There's got to be an md-content inside. If there's not one, let's add it.
+ var mdContentEl = tElement.find('md-content');
+ if (!mdContentEl.length) {
+ tElement.append(angular.element('<md-content>').append(tElement.contents()));
+ mdContentEl = tElement.find('md-content');
+ }
+ mdContentEl.attr('role', 'listbox');
+ mdContentEl.attr('tabindex', '-1');
+
+ if (isMultiple) {
+ mdContentEl.attr('aria-multiselectable', 'true');
+ } else {
+ mdContentEl.attr('aria-multiselectable', 'false');
+ }
+
+ // Add progress spinner for md-options-loading
+ if (tAttrs.mdOnOpen) {
+
+ // Show progress indicator while loading async
+ // Use ng-hide for `display:none` so the indicator does not interfere with the options list
+ tElement
+ .find('md-content')
+ .prepend(angular.element(
+ '<div>' +
+ ' <md-progress-circular md-mode="indeterminate" ng-if="$$loadingAsyncDone === false"' +
+ ' md-diameter="25px"></md-progress-circular>' +
+ '</div>'
+ ));
+
+ // Hide list [of item options] while loading async
+ tElement
+ .find('md-option')
+ .attr('ng-show', '$$loadingAsyncDone');
+ }
+
+ if (tAttrs.name) {
+ var autofillClone = angular.element('<select class="md-visually-hidden"></select>');
+ autofillClone.attr({
+ 'name': tAttrs.name,
+ 'aria-hidden': 'true',
+ 'tabindex': '-1'
+ });
+ var opts = tElement.find('md-option');
+ angular.forEach(opts, function(el) {
+ var newEl = angular.element('<option>' + el.innerHTML + '</option>');
+ if (el.hasAttribute('ng-value')) {
+ newEl.attr('ng-value', el.getAttribute('ng-value'));
+ }
+ else if (el.hasAttribute('value')) {
+ newEl.attr('value', el.getAttribute('value'));
+ }
+ autofillClone.append(newEl);
+ });
+
+ // Adds an extra option that will hold the selected value for the
+ // cases where the select is a part of a non-AngularJS form. This can be done with a ng-model,
+ // however if the `md-option` is being `ng-repeat`-ed, AngularJS seems to insert a similar
+ // `option` node, but with a value of `? string: <value> ?` which would then get submitted.
+ // This also goes around having to prepend a dot to the name attribute.
+ autofillClone.append(
+ '<option ng-value="' + tAttrs.ngModel + '" selected></option>'
+ );
+
+ tElement.parent().append(autofillClone);
+ }
+
+ // Use everything that's left inside element.contents() as the contents of the menu
+ var multipleContent = isMultiple ? 'multiple' : '';
+ var ngModelOptions = tAttrs.ngModelOptions ? $mdUtil.supplant('ng-model-options="{0}"', [tAttrs.ngModelOptions]) : '';
+ var selectTemplate = '' +
+ '<div class="md-select-menu-container" aria-hidden="true" role="presentation">' +
+ ' <md-select-menu role="presentation" {0} {1}>{2}</md-select-menu>' +
+ '</div>';
+
+ selectTemplate = $mdUtil.supplant(selectTemplate, [multipleContent, ngModelOptions, tElement.html()]);
+ tElement.empty().append(valueEl);
+ tElement.append(selectTemplate);
+
+ if (!tAttrs.tabindex) {
+ tAttrs.$set('tabindex', 0);
+ }
+
+ return function postLink(scope, element, attrs, ctrls) {
+ var untouched = true;
+ var isDisabled;
+
+ var containerCtrl = ctrls[0];
+ var mdSelectCtrl = ctrls[1];
+ var ngModelCtrl = ctrls[2];
+ var formCtrl = ctrls[3];
+ // grab a reference to the select menu value label
+ var selectValueElement = element.find('md-select-value');
+ var isReadonly = angular.isDefined(attrs.readonly);
+ var disableAsterisk = $mdUtil.parseAttributeBoolean(attrs.mdNoAsterisk);
+ var stopMdMultipleWatch;
+ var userDefinedLabelledby = angular.isDefined(attrs.ariaLabelledby);
+ var listboxContentElement = element.find('md-content');
+ var initialPlaceholder = element.attr('placeholder');
+
+ if (disableAsterisk) {
+ element.addClass('md-no-asterisk');
+ }
+
+ if (containerCtrl) {
+ var isErrorGetter = containerCtrl.isErrorGetter || function() {
+ return ngModelCtrl.$invalid && (ngModelCtrl.$touched || (formCtrl && formCtrl.$submitted));
+ };
+
+ if (containerCtrl.input) {
+ // We ignore inputs that are in the md-select-header.
+ // One case where this might be useful would be adding as searchbox.
+ if (element.find('md-select-header').find('input')[0] !== containerCtrl.input[0]) {
+ throw new Error("<md-input-container> can only have *one* child <input>, <textarea>, or <select> element!");
+ }
+ }
+
+ containerCtrl.input = element;
+ if (!containerCtrl.label) {
+ $mdAria.expect(element, 'aria-label', initialPlaceholder);
+ var selectLabel = element.attr('aria-label');
+ if (!selectLabel) {
+ selectLabel = initialPlaceholder;
+ }
+ listboxContentElement.attr('aria-label', selectLabel);
+ } else {
+ containerCtrl.label.attr('aria-hidden', 'true');
+ listboxContentElement.attr('aria-label', containerCtrl.label.text());
+ containerCtrl.setHasPlaceholder(!!initialPlaceholder);
+ }
+
+ var stopInvalidWatch = scope.$watch(isErrorGetter, containerCtrl.setInvalid);
+ }
+
+ var selectContainer, selectScope, selectMenuCtrl;
+
+ selectContainer = findSelectContainer();
+ $mdTheming(element);
+
+ var originalRender = ngModelCtrl.$render;
+ ngModelCtrl.$render = function() {
+ originalRender();
+ syncSelectValueText();
+ inputCheckValue();
+ };
+
+ var stopPlaceholderObserver = attrs.$observe('placeholder', ngModelCtrl.$render);
+
+ var stopRequiredObserver = attrs.$observe('required', function (value) {
+ if (containerCtrl && containerCtrl.label) {
+ // Toggle the md-required class on the input containers label, because the input container
+ // is automatically applying the asterisk indicator on the label.
+ containerCtrl.label.toggleClass('md-required', value && !disableAsterisk);
+ }
+ element.removeAttr('aria-required');
+ if (value) {
+ listboxContentElement.attr('aria-required', 'true');
+ } else {
+ listboxContentElement.removeAttr('aria-required');
+ }
+ });
+
+ /**
+ * Set the contents of the md-select-value element. This element's contents are announced by
+ * screen readers and used for displaying the value of the select in both single and multiple
+ * selection modes.
+ * @param {string=} text A sanitized and trusted HTML string or a pure text string from user
+ * input.
+ */
+ mdSelectCtrl.setSelectValueText = function(text) {
+ var useDefaultText = text === undefined || text === '';
+ // Whether the select label has been given via user content rather than the internal
+ // template of <md-option>
+ var isSelectLabelFromUser = false;
+
+ mdSelectCtrl.setIsPlaceholder(!text);
+
+ if (attrs.mdSelectedText && attrs.mdSelectedHtml) {
+ throw Error('md-select cannot have both `md-selected-text` and `md-selected-html`');
+ }
+
+ if (attrs.mdSelectedText || attrs.mdSelectedHtml) {
+ text = $parse(attrs.mdSelectedText || attrs.mdSelectedHtml)(scope);
+ isSelectLabelFromUser = true;
+ } else if (useDefaultText) {
+ // Use placeholder attribute, otherwise fallback to the md-input-container label
+ var tmpPlaceholder = attrs.placeholder ||
+ (containerCtrl && containerCtrl.label ? containerCtrl.label.text() : '');
+
+ text = tmpPlaceholder || '';
+ isSelectLabelFromUser = true;
+ }
+
+ var target = selectValueElement.children().eq(0);
+
+ if (attrs.mdSelectedHtml) {
+ // Using getTrustedHtml will run the content through $sanitize if it is not already
+ // explicitly trusted. If the ngSanitize module is not loaded, this will
+ // *correctly* throw an sce error.
+ target.html($sce.getTrustedHtml(text));
+ } else if (isSelectLabelFromUser) {
+ target.text(text);
+ } else {
+ // If we've reached this point, the text is not user-provided.
+ target.html(text);
+ }
+
+ if (useDefaultText) {
+ // Avoid screen readers double announcing the label name when no value has been selected
+ selectValueElement.attr('aria-hidden', 'true');
+ if (!userDefinedLabelledby) {
+ element.removeAttr('aria-labelledby');
+ }
+ } else {
+ selectValueElement.removeAttr('aria-hidden');
+ if (!userDefinedLabelledby) {
+ element.attr('aria-labelledby', element[0].id + ' ' + selectValueElement[0].id);
+ }
+ }
+ };
+
+ /**
+ * @param {boolean} isPlaceholder true to mark the md-select-value element and
+ * input container, if one exists, with classes for styling when a placeholder is present.
+ * false to remove those classes.
+ */
+ mdSelectCtrl.setIsPlaceholder = function(isPlaceholder) {
+ if (isPlaceholder) {
+ selectValueElement.addClass('md-select-placeholder');
+ // Don't hide the floating label if the md-select has a placeholder.
+ if (containerCtrl && containerCtrl.label && !element.attr('placeholder')) {
+ containerCtrl.label.addClass('md-placeholder');
+ }
+ } else {
+ selectValueElement.removeClass('md-select-placeholder');
+ if (containerCtrl && containerCtrl.label && !element.attr('placeholder')) {
+ containerCtrl.label.removeClass('md-placeholder');
+ }
+ }
+ };
+
+ if (!isReadonly) {
+ var handleBlur = function(event) {
+ // Attach before ngModel's blur listener to stop propagation of blur event
+ // and prevent setting $touched.
+ if (untouched) {
+ untouched = false;
+ if (selectScope._mdSelectIsOpen) {
+ event.stopImmediatePropagation();
+ }
+ }
+
+ containerCtrl && containerCtrl.setFocused(false);
+ inputCheckValue();
+ };
+ var handleFocus = function() {
+ // Always focus the container (if we have one) so floating labels and other styles are
+ // applied properly
+ containerCtrl && containerCtrl.setFocused(true);
+ };
+
+ element.on('focus', handleFocus);
+ element.on('blur', handleBlur);
+ }
+
+ mdSelectCtrl.triggerClose = function() {
+ $parse(attrs.mdOnClose)(scope);
+ };
+
+ scope.$$postDigest(function() {
+ initAriaLabel();
+ syncSelectValueText();
+ });
+
+ function initAriaLabel() {
+ var labelText = element.attr('aria-label') || element.attr('placeholder');
+ if (!labelText && containerCtrl && containerCtrl.label) {
+ labelText = containerCtrl.label.text();
+ }
+ $mdAria.expect(element, 'aria-label', labelText);
+ }
+
+ var stopSelectedLabelsWatcher = scope.$watch(function() {
+ return selectMenuCtrl.getSelectedLabels();
+ }, syncSelectValueText);
+
+ function syncSelectValueText() {
+ selectMenuCtrl = selectMenuCtrl ||
+ selectContainer.find('md-select-menu').controller('mdSelectMenu');
+ mdSelectCtrl.setSelectValueText(selectMenuCtrl.getSelectedLabels());
+ }
+
+ // TODO add tests for mdMultiple
+ // TODO add docs for mdMultiple
+ var stopMdMultipleObserver = attrs.$observe('mdMultiple', function(val) {
+ if (stopMdMultipleWatch) {
+ stopMdMultipleWatch();
+ }
+ var parser = $parse(val);
+ stopMdMultipleWatch = scope.$watch(function() {
+ return parser(scope);
+ }, function(multiple, prevVal) {
+ var selectMenu = selectContainer.find('md-select-menu');
+ // assume compiler did a good job
+ if (multiple === undefined && prevVal === undefined) {
+ return;
+ }
+ if (multiple) {
+ var setMultipleAttrs = {'multiple': 'multiple'};
+ element.attr(setMultipleAttrs);
+ selectMenu.attr(setMultipleAttrs);
+ } else {
+ element.removeAttr('multiple');
+ selectMenu.removeAttr('multiple');
+ }
+ element.find('md-content').attr('aria-multiselectable', multiple ? 'true' : 'false');
+
+ if (selectContainer) {
+ selectMenuCtrl.setMultiple(Boolean(multiple));
+ originalRender = ngModelCtrl.$render;
+ ngModelCtrl.$render = function() {
+ originalRender();
+ syncSelectValueText();
+ inputCheckValue();
+ };
+ ngModelCtrl.$render();
+ }
+ });
+ });
+
+ var stopDisabledObserver = attrs.$observe('disabled', function(disabled) {
+ if (angular.isString(disabled)) {
+ disabled = true;
+ }
+ // Prevent click event being registered twice
+ if (isDisabled !== undefined && isDisabled === disabled) {
+ return;
+ }
+ isDisabled = disabled;
+ if (disabled) {
+ element
+ .attr({'aria-disabled': 'true'})
+ .removeAttr('tabindex')
+ .removeAttr('aria-expanded')
+ .removeAttr('aria-haspopup')
+ .off('click', openSelect)
+ .off('keydown', handleKeypress);
+ } else {
+ element
+ .attr({
+ 'tabindex': attrs.tabindex,
+ 'aria-haspopup': 'listbox'
+ })
+ .removeAttr('aria-disabled')
+ .on('click', openSelect)
+ .on('keydown', handleKeypress);
+ }
+ });
+
+ if (!attrs.hasOwnProperty('disabled') && !attrs.hasOwnProperty('ngDisabled')) {
+ element.attr({'aria-disabled': 'false'});
+ element.on('click', openSelect);
+ element.on('keydown', handleKeypress);
+ }
+
+ var ariaAttrs = {
+ role: 'button',
+ 'aria-haspopup': 'listbox'
+ };
+
+ if (!element[0].hasAttribute('id')) {
+ ariaAttrs.id = 'select_' + $mdUtil.nextUid();
+ }
+
+ var containerId = 'select_container_' + $mdUtil.nextUid();
+ selectContainer.attr('id', containerId);
+ var listboxContentId = 'select_listbox_' + $mdUtil.nextUid();
+ selectContainer.find('md-content').attr('id', listboxContentId);
+ // Only add aria-owns if element ownership is NOT represented in the DOM.
+ if (!element.find('md-select-menu').length) {
+ ariaAttrs['aria-owns'] = listboxContentId;
+ }
+ element.attr(ariaAttrs);
+
+ scope.$on('$destroy', function() {
+ stopRequiredObserver && stopRequiredObserver();
+ stopDisabledObserver && stopDisabledObserver();
+ stopMdMultipleWatch && stopMdMultipleWatch();
+ stopMdMultipleObserver && stopMdMultipleObserver();
+ stopSelectedLabelsWatcher && stopSelectedLabelsWatcher();
+ stopPlaceholderObserver && stopPlaceholderObserver();
+ stopInvalidWatch && stopInvalidWatch();
+
+ element.off('focus');
+ element.off('blur');
+
+ $mdSelect
+ .destroy()
+ .finally(function() {
+ if (containerCtrl) {
+ containerCtrl.setFocused(false);
+ containerCtrl.setHasValue(false);
+ containerCtrl.input = null;
+ }
+ ngModelCtrl.$setTouched();
+ });
+ });
+
+ function inputCheckValue() {
+ // The select counts as having a value if one or more options are selected,
+ // or if the input's validity state says it has bad input (eg: string in a number input).
+ // We must do this on nextTick as the $render is sometimes invoked on nextTick.
+ $mdUtil.nextTick(function () {
+ containerCtrl && containerCtrl.setHasValue(
+ selectMenuCtrl.getSelectedLabels().length > 0 || (element[0].validity || {}).badInput);
+ });
+ }
+
+ function findSelectContainer() {
+ var selectContainer = angular.element(
+ element[0].querySelector('.md-select-menu-container')
+ );
+ selectScope = scope;
+ attrs.mdContainerClass && selectContainer.addClass(attrs.mdContainerClass);
+ selectMenuCtrl = selectContainer.find('md-select-menu').controller('mdSelectMenu');
+ selectMenuCtrl.init(ngModelCtrl, attrs);
+ element.on('$destroy', function() {
+ selectContainer.remove();
+ });
+ return selectContainer;
+ }
+
+ /**
+ * Determine if the select menu should be opened or an option in the select menu should be
+ * selected.
+ * @param {KeyboardEvent} e keyboard event to handle
+ */
+ function handleKeypress(e) {
+ if ($mdConstant.isNavigationKey(e)) {
+ // prevent page scrolling on interaction
+ e.preventDefault();
+ openSelect(e);
+ } else {
+ if (shouldHandleKey(e, $mdConstant)) {
+ e.preventDefault();
+
+ var node = selectMenuCtrl.optNodeForKeyboardSearch(e);
+ if (!node || node.hasAttribute('disabled')) {
+ return;
+ }
+ var optionCtrl = angular.element(node).controller('mdOption');
+ if (!selectMenuCtrl.isMultiple) {
+ angular.forEach(Object.keys(selectMenuCtrl.selected), function (key) {
+ selectMenuCtrl.deselect(key);
+ });
+ }
+ selectMenuCtrl.select(optionCtrl.hashKey, optionCtrl.value);
+ selectMenuCtrl.refreshViewValue();
+ }
+ }
+ }
+
+ function openSelect() {
+ selectScope._mdSelectIsOpen = true;
+ element.attr('aria-expanded', 'true');
+
+ $mdSelect.show({
+ scope: selectScope,
+ preserveScope: true,
+ skipCompile: true,
+ element: selectContainer,
+ target: element[0],
+ selectCtrl: mdSelectCtrl,
+ preserveElement: true,
+ hasBackdrop: true,
+ loadingAsync: attrs.mdOnOpen ? scope.$eval(attrs.mdOnOpen) || true : false
+ }).finally(function() {
+ selectScope._mdSelectIsOpen = false;
+ element.removeAttr('aria-expanded');
+ element.removeAttr('aria-activedescendant');
+ ngModelCtrl.$setTouched();
+ });
+ }
+
+ };
+ }
+}
+
+function SelectMenuDirective($parse, $mdUtil, $mdConstant, $mdTheming) {
+ // We want the scope to be set to 'false' so an isolated scope is not created
+ // which would interfere with the md-select-header's access to the
+ // parent scope.
+ SelectMenuController.$inject = ["$scope", "$attrs", "$element"];
+ return {
+ restrict: 'E',
+ require: ['mdSelectMenu'],
+ scope: false,
+ controller: SelectMenuController,
+ link: {pre: preLink}
+ };
+
+ // We use preLink instead of postLink to ensure that the select is initialized before
+ // its child options run postLink.
+ function preLink(scope, element, attrs, ctrls) {
+ var selectMenuCtrl = ctrls[0];
+
+ element.addClass('_md'); // private md component indicator for styling
+
+ $mdTheming(element);
+ element.on('click', clickListener);
+ element.on('keypress', keyListener);
+
+ /**
+ * @param {KeyboardEvent} keyboardEvent
+ */
+ function keyListener(keyboardEvent) {
+ if (keyboardEvent.keyCode === 13 || keyboardEvent.keyCode === 32) {
+ clickListener(keyboardEvent);
+ }
+ }
+
+ /**
+ * @param {Event} mouseEvent
+ * @return {void}
+ */
+ function clickListener(mouseEvent) {
+ var option = $mdUtil.getClosest(mouseEvent.target, 'md-option');
+ var optionCtrl = option && angular.element(option).data('$mdOptionController');
+
+ if (!option || !optionCtrl) {
+ // Avoid closing the menu when the select header's input is clicked
+ if (mouseEvent.target && mouseEvent.target.parentNode &&
+ mouseEvent.target.parentNode.tagName === 'MD-SELECT-HEADER') {
+ mouseEvent.stopImmediatePropagation();
+ }
+ return;
+ } else if (option.hasAttribute('disabled')) {
+ mouseEvent.stopImmediatePropagation();
+ return;
+ }
+
+ var optionHashKey = selectMenuCtrl.hashGetter(optionCtrl.value);
+ var isSelected = angular.isDefined(selectMenuCtrl.selected[optionHashKey]);
+
+ scope.$apply(function() {
+ if (selectMenuCtrl.isMultiple) {
+ if (isSelected) {
+ selectMenuCtrl.deselect(optionHashKey);
+ } else {
+ selectMenuCtrl.select(optionHashKey, optionCtrl.value);
+ }
+ } else {
+ if (!isSelected) {
+ angular.forEach(Object.keys(selectMenuCtrl.selected), function (key) {
+ selectMenuCtrl.deselect(key);
+ });
+ selectMenuCtrl.select(optionHashKey, optionCtrl.value);
+ }
+ }
+ selectMenuCtrl.refreshViewValue();
+ });
+ }
+ }
+
+ function SelectMenuController($scope, $attrs, $element) {
+ var self = this;
+ var defaultIsEmpty;
+ var searchStr = '';
+ var clearSearchTimeout, optNodes, optText;
+ var CLEAR_SEARCH_AFTER = 300;
+
+ self.isMultiple = angular.isDefined($attrs.multiple);
+ // selected is an object with keys matching all of the selected options' hashed values
+ self.selected = {};
+ // options is an object with keys matching every option's hash value,
+ // and values containing an instance of every option's controller.
+ self.options = {};
+
+ $scope.$watchCollection(function() {
+ return self.options;
+ }, function() {
+ self.ngModel.$render();
+ updateOptionSetSizeAndPosition();
+ });
+
+ /**
+ * @param {boolean} isMultiple
+ */
+ self.setMultiple = function(isMultiple) {
+ var ngModel = self.ngModel;
+ defaultIsEmpty = defaultIsEmpty || ngModel.$isEmpty;
+ self.isMultiple = isMultiple;
+
+ if (self.isMultiple) {
+ // We want to delay the render method so that the directive has a chance to load before
+ // rendering, this prevents the control being marked as dirty onload.
+ var loaded = false;
+ var delayedRender = function(val) {
+ if (!loaded) {
+ $mdUtil.nextTick(function () {
+ renderMultiple(val);
+ loaded = true;
+ });
+ } else {
+ renderMultiple(val);
+ }
+ };
+ ngModel.$validators['md-multiple'] = validateArray;
+ ngModel.$render = delayedRender;
+
+ // watchCollection on the model because by default ngModel only watches the model's
+ // reference. This allows the developer to also push and pop from their array.
+ $scope.$watchCollection(self.modelBinding, function(value) {
+ if (validateArray(value)) {
+ delayedRender(value);
+ }
+ });
+
+ ngModel.$isEmpty = function(value) {
+ return !value || value.length === 0;
+ };
+ } else {
+ delete ngModel.$validators['md-multiple'];
+ ngModel.$render = renderSingular;
+ }
+
+ function validateArray(modelValue, viewValue) {
+ // If a value is truthy but not an array, reject it.
+ // If value is undefined/falsy, accept that it's an empty array.
+ return angular.isArray(modelValue || viewValue || []);
+ }
+ };
+
+ /**
+ * @param {KeyboardEvent} keyboardEvent keyboard event to handle
+ * @return {Element|HTMLElement|undefined}
+ */
+ self.optNodeForKeyboardSearch = function(keyboardEvent) {
+ var search, i;
+ clearSearchTimeout && clearTimeout(clearSearchTimeout);
+ clearSearchTimeout = setTimeout(function() {
+ clearSearchTimeout = undefined;
+ searchStr = '';
+ optText = undefined;
+ optNodes = undefined;
+ }, CLEAR_SEARCH_AFTER);
+
+ searchStr += keyboardEvent.key;
+ search = new RegExp('^' + $mdUtil.sanitize(searchStr), 'i');
+ if (!optNodes) {
+ optNodes = $element.find('md-option');
+ optText = new Array(optNodes.length);
+ angular.forEach(optNodes, function(el, i) {
+ optText[i] = el.textContent.trim();
+ });
+ }
+
+ for (i = 0; i < optText.length; ++i) {
+ if (search.test(optText[i])) {
+ return optNodes[i];
+ }
+ }
+ };
+
+ self.init = function(ngModel, parentAttrs) {
+ self.ngModel = ngModel;
+ self.modelBinding = parentAttrs.ngModel;
+
+ // Setup a more robust version of isEmpty to ensure value is a valid option
+ self.ngModel.$isEmpty = function($viewValue) {
+ // We have to transform the viewValue into the hashKey, because otherwise the
+ // OptionCtrl may not exist. Developers may have specified a trackBy function.
+ var hashedValue = self.options[self.hashGetter($viewValue)] ? self.options[self.hashGetter($viewValue)].value : null;
+ // Base this check on the default AngularJS $isEmpty() function.
+ // eslint-disable-next-line no-self-compare
+ return !angular.isDefined(hashedValue) || hashedValue === null || hashedValue === '' || hashedValue !== hashedValue;
+ };
+
+ // Allow users to provide `ng-model="foo" ng-model-options="{trackBy: '$value.id'}"` so
+ // that we can properly compare objects set on the model to the available options
+ //
+ // If the user doesn't provide a trackBy, we automatically generate an id for every
+ // value passed in with the getId function
+ if ($attrs.ngModelOptions) {
+ self.hashGetter = function(value) {
+ var ngModelOptions = $parse($attrs.ngModelOptions)($scope);
+ var trackByOption = ngModelOptions && ngModelOptions.trackBy;
+
+ if (trackByOption) {
+ return $parse(trackByOption)($scope, { $value: value });
+ } else if (angular.isObject(value)) {
+ return getId(value);
+ }
+ return value;
+ };
+ } else {
+ self.hashGetter = getId;
+ }
+ self.setMultiple(self.isMultiple);
+
+ /**
+ * If the value is an object, get the unique, incremental id of the value.
+ * If it's not an object, the value will be converted to a string and then returned.
+ * @param value
+ * @returns {string}
+ */
+ function getId(value) {
+ if (angular.isObject(value) && !angular.isArray(value)) {
+ return 'object_' + (value.$$mdSelectId || (value.$$mdSelectId = ++selectNextId));
+ }
+ return value + '';
+ }
+
+ if (parentAttrs.hasOwnProperty('mdSelectOnlyOption')) {
+ $mdUtil.nextTick(function() {
+ var optionKeys = Object.keys(self.options);
+
+ if (optionKeys.length === 1) {
+ var option = self.options[optionKeys[0]];
+
+ self.deselect(Object.keys(self.selected)[0]);
+ self.select(self.hashGetter(option.value), option.value);
+ self.refreshViewValue();
+ self.ngModel.$setPristine();
+ }
+ }, false);
+ }
+ };
+
+ /**
+ * @param {string=} id
+ */
+ self.setActiveDescendant = function(id) {
+ if (angular.isDefined(id)) {
+ $element.find('md-content').attr('aria-activedescendant', id);
+ } else {
+ $element.find('md-content').removeAttr('aria-activedescendant');
+ }
+ };
+
+ /**
+ * @param {{mode: string}=} opts options object to allow specifying html (default) or aria mode.
+ * @return {string} comma separated set of selected values
+ */
+ self.getSelectedLabels = function(opts) {
+ opts = opts || {};
+ var mode = opts.mode || 'html';
+ var selectedOptionEls =
+ $mdUtil.nodesToArray($element[0].querySelectorAll('md-option[selected]'));
+
+ if (selectedOptionEls.length) {
+ var mapFn;
+
+ if (mode === 'html') {
+ // Map the given element to its innerHTML string. If the element has a child ripple
+ // container remove it from the HTML string, before returning the string.
+ mapFn = function(el) {
+ // If we do not have a `value` or `ng-value`, assume it is an empty option which clears
+ // the select.
+ if (el.hasAttribute('md-option-empty')) {
+ return '';
+ }
+
+ var html = el.innerHTML;
+
+ // Remove the ripple container from the selected option, copying it would cause a CSP
+ // violation.
+ var rippleContainer = el.querySelector('.md-ripple-container');
+ if (rippleContainer) {
+ html = html.replace(rippleContainer.outerHTML, '');
+ }
+
+ // Remove the checkbox container, because it will cause the label to wrap inside of the
+ // placeholder. It should be not displayed inside of the label element.
+ var checkboxContainer = el.querySelector('.md-container');
+ if (checkboxContainer) {
+ html = html.replace(checkboxContainer.outerHTML, '');
+ }
+
+ return html;
+ };
+ } else if (mode === 'aria') {
+ mapFn = function(el) {
+ return el.hasAttribute('aria-label') ? el.getAttribute('aria-label') : el.textContent;
+ };
+ }
+
+ // Ensure there are no duplicates; see https://github.com/angular/material/issues/9442
+ return $mdUtil.uniq(selectedOptionEls.map(mapFn)).join(', ');
+ } else {
+ return '';
+ }
+ };
+
+ /**
+ * Mark an option as selected
+ * @param {string} hashKey key within the SelectMenuController.options object, which is an
+ * instance of OptionController.
+ * @param {OptionController} hashedValue value to associate with the key
+ */
+ self.select = function(hashKey, hashedValue) {
+ var option = self.options[hashKey];
+ option && option.setSelected(true, self.isMultiple);
+ self.selected[hashKey] = hashedValue;
+ };
+
+ /**
+ * Mark an option as not selected
+ * @param {string} hashKey key within the SelectMenuController.options object, which is an
+ * instance of OptionController.
+ */
+ self.deselect = function(hashKey) {
+ var option = self.options[hashKey];
+ option && option.setSelected(false, self.isMultiple);
+ delete self.selected[hashKey];
+ };
+
+ /**
+ * Add an option to the select
+ * @param {string} hashKey key within the SelectMenuController.options object, which is an
+ * instance of OptionController.
+ * @param {OptionController} optionCtrl instance to associate with the key
+ */
+ self.addOption = function(hashKey, optionCtrl) {
+ if (angular.isDefined(self.options[hashKey])) {
+ throw new Error('Duplicate md-option values are not allowed in a select. ' +
+ 'Duplicate value "' + optionCtrl.value + '" found.');
+ }
+
+ self.options[hashKey] = optionCtrl;
+
+ // If this option's value was already in our ngModel, go ahead and select it.
+ if (angular.isDefined(self.selected[hashKey])) {
+ self.select(hashKey, optionCtrl.value);
+
+ // When the current $modelValue of the ngModel Controller is using the same hash as
+ // the current option, which will be added, then we can be sure, that the validation
+ // of the option has occurred before the option was added properly.
+ // This means, that we have to manually trigger a new validation of the current option.
+ if (angular.isDefined(self.ngModel.$$rawModelValue) &&
+ self.hashGetter(self.ngModel.$$rawModelValue) === hashKey) {
+ self.ngModel.$validate();
+ }
+
+ self.refreshViewValue();
+ }
+ };
+
+ /**
+ * Remove an option from the select
+ * @param {string} hashKey key within the SelectMenuController.options object, which is an
+ * instance of OptionController.
+ */
+ self.removeOption = function(hashKey) {
+ delete self.options[hashKey];
+ // Don't deselect an option when it's removed - the user's ngModel should be allowed
+ // to have values that do not match a currently available option.
+ };
+
+ self.refreshViewValue = function() {
+ var values = [];
+ var option;
+ for (var hashKey in self.selected) {
+ // If this hashKey has an associated option, push that option's value to the model.
+ if ((option = self.options[hashKey])) {
+ values.push(option.value);
+ } else {
+ // Otherwise, the given hashKey has no associated option, and we got it
+ // from an ngModel value at an earlier time. Push the unhashed value of
+ // this hashKey to the model.
+ // This allows the developer to put a value in the model that doesn't yet have
+ // an associated option.
+ values.push(self.selected[hashKey]);
+ }
+ }
+
+ var newVal = self.isMultiple ? values : values[0];
+ var prevVal = self.ngModel.$modelValue;
+
+ if (!equals(prevVal, newVal)) {
+ self.ngModel.$setViewValue(newVal);
+ self.ngModel.$render();
+ }
+
+ function equals(prevVal, newVal) {
+ if (self.isMultiple) {
+ if (!angular.isArray(prevVal)) {
+ // newVal is always an array when self.isMultiple is true
+ // thus, if prevVal is not an array they are different
+ return false;
+ } else if (prevVal.length !== newVal.length) {
+ // they are different if they have different length
+ return false;
+ } else {
+ // if they have the same length, then they are different
+ // if an item in the newVal array can't be found in the prevVal
+ var prevValHashes = prevVal.map(function(prevValItem) {
+ return self.hashGetter(prevValItem);
+ });
+ return newVal.every(function(newValItem) {
+ var newValItemHash = self.hashGetter(newValItem);
+ return prevValHashes.some(function(prevValHash) {
+ return prevValHash === newValItemHash;
+ });
+ });
+ }
+ } else {
+ return self.hashGetter(prevVal) === self.hashGetter(newVal);
+ }
+ }
+ };
+
+ /**
+ * If the options include md-optgroups, then we need to apply aria-setsize and aria-posinset
+ * to help screen readers understand the indexes. When md-optgroups are not used, we save on
+ * perf and extra attributes by not applying these attributes as they are not needed by screen
+ * readers.
+ */
+ function updateOptionSetSizeAndPosition() {
+ var i, options;
+ var hasOptGroup = $element.find('md-optgroup');
+ if (!hasOptGroup.length) {
+ return;
+ }
+
+ options = $element.find('md-option');
+
+ for (i = 0; i < options.length; i++) {
+ options[i].setAttribute('aria-setsize', options.length);
+ options[i].setAttribute('aria-posinset', i + 1);
+ }
+ }
+
+ function renderMultiple() {
+ var newSelectedValues = self.ngModel.$modelValue || self.ngModel.$viewValue || [];
+ if (!angular.isArray(newSelectedValues)) {
+ return;
+ }
+
+ var oldSelected = Object.keys(self.selected);
+
+ var newSelectedHashes = newSelectedValues.map(self.hashGetter);
+ var deselected = oldSelected.filter(function(hash) {
+ return newSelectedHashes.indexOf(hash) === -1;
+ });
+
+ deselected.forEach(self.deselect);
+ newSelectedHashes.forEach(function(hashKey, i) {
+ self.select(hashKey, newSelectedValues[i]);
+ });
+ }
+
+ function renderSingular() {
+ var value = self.ngModel.$viewValue || self.ngModel.$modelValue;
+ Object.keys(self.selected).forEach(self.deselect);
+ self.select(self.hashGetter(value), value);
+ }
+ }
+}
+
+/**
+ * @ngdoc directive
+ * @name mdOption
+ * @restrict E
+ * @module material.components.select
+ *
+ * @description Displays an option in a <a ng-href="api/directive/mdSelect">md-select</a> box's
+ * dropdown menu. Options can be grouped using
+ * <a ng-href="api/directive/mdOptgroup">md-optgroup</a> element directives.
+ *
+ * ### Option Params
+ *
+ * When applied, `md-option-empty` will mark the option as "empty" allowing the option to clear the
+ * select and put it back in it's default state. You may supply this attribute on any option you
+ * wish, however, it is automatically applied to an option whose `value` or `ng-value` are not
+ * defined.
+ *
+ * **Automatically Applied**
+ *
+ * - `<md-option>`
+ * - `<md-option value>`
+ * - `<md-option value="">`
+ * - `<md-option ng-value>`
+ * - `<md-option ng-value="">`
+ *
+ * **NOT Automatically Applied**
+ *
+ * - `<md-option ng-value="1">`
+ * - `<md-option ng-value="''">`
+ * - `<md-option ng-value="undefined">`
+ * - `<md-option value="undefined">` (this evaluates to the string `"undefined"`)
+ * - <code ng-non-bindable><md-option ng-value="{{someValueThatMightBeUndefined}}"></code>
+ *
+ * **Note:** A value of `undefined` ***is considered a valid value*** (and does not auto-apply this
+ * attribute) since you may wish this to be your "Not Available" or "None" option.
+ *
+ * **Note:** Using the
+ * <a ng-href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/option#Attributes">value</a>
+ * attribute from the `<option>` element (as opposed to the `<md-option>` element's
+ * <a ng-href="https://docs.angularjs.org/api/ng/directive/ngValue">ng-value</a>) always evaluates
+ * to a `string`. This means that `value="null"` will cause a check against `myValue != "null"`
+ * rather than `!myValue` or `myValue != null`.
+ * Importantly, this also applies to `number` values. `value="1"` will not match up with an
+ * `ng-model` like `$scope.selectedValue = 1`. Use `ng-value="1"` in this case and other cases where
+ * you have values that are not strings.
+ *
+ * **Note:** Please see our <a ng-href="api/directive/mdSelect#selects-and-object-equality">docs on
+ * using objects with `md-select`</a> for additional guidance on using the `trackBy` option with
+ * `ng-model-options`.
+ *
+ * @param {expression=} ng-value Binds the given expression to the value of the option.
+ * @param {string=} value Attribute to set the value of the option.
+ * @param {expression=} ng-repeat <a ng-href="https://docs.angularjs.org/api/ng/directive/ngRepeat">
+ * AngularJS directive</a> that instantiates a template once per item from a collection.
+ * @param {expression=} ng-selected <a ng-href="https://docs.angularjs.org/api/ng/directive/ngSelected">
+ * AngularJS directive</a> that adds the `selected` attribute to the option when the expression
+ * evaluates as truthy.
+ *
+ * **Note:** Unlike native `option` elements used with AngularJS, `md-option` elements
+ * watch their `selected` attributes for changes and trigger model value changes on `md-select`.
+ * @param {boolean=} md-option-empty If the attribute exists, mark the option as "empty" allowing
+ * the option to clear the select and put it back in it's default state. You may supply this
+ * attribute on any option you wish, however, it is automatically applied to an option whose `value`
+ * or `ng-value` are not defined.
+ * @param {number=} tabindex The `tabindex` of the option. Defaults to `0`.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-select ng-model="currentState" placeholder="Select a state">
+ * <md-option ng-value="AL">Alabama</md-option>
+ * <md-option ng-value="AK">Alaska</md-option>
+ * <md-option ng-value="FL">Florida</md-option>
+ * </md-select>
+ * </hljs>
+ *
+ * With `ng-repeat`:
+ * <hljs lang="html">
+ * <md-select ng-model="currentState" placeholder="Select a state">
+ * <md-option ng-value="state" ng-repeat="state in states">{{ state }}</md-option>
+ * </md-select>
+ * </hljs>
+ */
+function OptionDirective($mdButtonInkRipple, $mdUtil, $mdTheming) {
+
+ return {
+ restrict: 'E',
+ require: ['mdOption', '^^mdSelectMenu'],
+ controller: OptionController,
+ compile: compile
+ };
+
+ /**
+ * @param {JQLite} element
+ * @param {IAttributes} attrs
+ * @return {postLink}
+ */
+ function compile(element, attrs) {
+ // Manual transclusion to avoid the extra inner <span> that ng-transclude generates
+ element.append(angular.element('<div class="md-text">').append(element.contents()));
+
+ element.attr('tabindex', attrs.tabindex || '0');
+
+ if (!hasDefinedValue(attrs)) {
+ element.attr('md-option-empty', '');
+ }
+
+ return postLink;
+ }
+
+ /**
+ * @param {Object} attrs list of attributes from the compile function
+ * @return {string|undefined|null} if defined and non-empty, return the value of the option's
+ * value attribute, otherwise return the value of the option's ng-value attribute.
+ */
+ function hasDefinedValue(attrs) {
+ var value = attrs.value;
+ var ngValue = attrs.ngValue;
+
+ return value || ngValue;
+ }
+
+ function postLink(scope, element, attrs, ctrls) {
+ var optionCtrl = ctrls[0];
+ var selectMenuCtrl = ctrls[1];
+
+ $mdTheming(element);
+
+ if (selectMenuCtrl.isMultiple) {
+ element.addClass('md-checkbox-enabled');
+ element.prepend(CHECKBOX_SELECTION_INDICATOR.clone());
+ }
+
+ if (angular.isDefined(attrs.ngValue)) {
+ scope.$watch(attrs.ngValue, function (newValue, oldValue) {
+ setOptionValue(newValue, oldValue);
+ element.removeAttr('aria-checked');
+ });
+ } else if (angular.isDefined(attrs.value)) {
+ setOptionValue(attrs.value);
+ } else {
+ scope.$watch(function() {
+ return element.text().trim();
+ }, setOptionValue);
+ }
+
+ attrs.$observe('disabled', function(disabled) {
+ if (disabled) {
+ element.attr('tabindex', '-1');
+ } else {
+ element.attr('tabindex', '0');
+ }
+ });
+
+ scope.$$postDigest(function() {
+ attrs.$observe('selected', function(selected) {
+ if (!angular.isDefined(selected)) return;
+ if (typeof selected == 'string') selected = true;
+ if (selected) {
+ if (!selectMenuCtrl.isMultiple) {
+ selectMenuCtrl.deselect(Object.keys(selectMenuCtrl.selected)[0]);
+ }
+ selectMenuCtrl.select(optionCtrl.hashKey, optionCtrl.value);
+ } else {
+ selectMenuCtrl.deselect(optionCtrl.hashKey);
+ }
+ selectMenuCtrl.refreshViewValue();
+ });
+ });
+
+ $mdButtonInkRipple.attach(scope, element);
+ configureAria();
+
+ /**
+ * @param {*} newValue the option's new value
+ * @param {*=} oldValue the option's previous value
+ * @param {boolean=} prevAttempt true if this had to be attempted again due to an undefined
+ * hashGetter on the selectMenuCtrl, undefined otherwise.
+ */
+ function setOptionValue(newValue, oldValue, prevAttempt) {
+ if (!selectMenuCtrl.hashGetter) {
+ if (!prevAttempt) {
+ scope.$$postDigest(function() {
+ setOptionValue(newValue, oldValue, true);
+ });
+ }
+ return;
+ }
+ var oldHashKey = selectMenuCtrl.hashGetter(oldValue, scope);
+ var newHashKey = selectMenuCtrl.hashGetter(newValue, scope);
+
+ optionCtrl.hashKey = newHashKey;
+ optionCtrl.value = newValue;
+
+ selectMenuCtrl.removeOption(oldHashKey, optionCtrl);
+ selectMenuCtrl.addOption(newHashKey, optionCtrl);
+ }
+
+ scope.$on('$destroy', function() {
+ selectMenuCtrl.removeOption(optionCtrl.hashKey, optionCtrl);
+ });
+
+ function configureAria() {
+ var ariaAttrs = {
+ 'role': 'option'
+ };
+
+ // We explicitly omit the `aria-selected` attribute from single-selection, unselected
+ // options. Including the `aria-selected="false"` attributes adds a significant amount of
+ // noise to screen-reader users without providing useful information.
+ if (selectMenuCtrl.isMultiple) {
+ ariaAttrs['aria-selected'] = 'false';
+ }
+
+ if (!element[0].hasAttribute('id')) {
+ ariaAttrs.id = 'select_option_' + $mdUtil.nextUid();
+ }
+ element.attr(ariaAttrs);
+ }
+ }
+}
+
+/**
+ * @param {JQLite} $element
+ * @constructor
+ */
+function OptionController($element) {
+ /**
+ * @param {boolean} isSelected
+ * @param {boolean=} isMultiple
+ */
+ this.setSelected = function(isSelected, isMultiple) {
+ if (isSelected) {
+ $element.attr({
+ 'selected': 'true',
+ 'aria-selected': 'true'
+ });
+ } else if (!isSelected) {
+ $element.removeAttr('selected');
+
+ if (isMultiple) {
+ $element.attr('aria-selected', 'false');
+ } else {
+ // We explicitly omit the `aria-selected` attribute from single-selection, unselected
+ // options. Including the `aria-selected="false"` attributes adds a significant amount of
+ // noise to screen-reader users without providing useful information.
+ $element.removeAttr('aria-selected');
+ }
+ }
+ };
+}
+
+/**
+ * @ngdoc directive
+ * @name mdOptgroup
+ * @restrict E
+ * @module material.components.select
+ *
+ * @description Displays a label separating groups of
+ * <a ng-href="api/directive/mdOption">md-option</a> element directives in a
+ * <a ng-href="api/directive/mdSelect">md-select</a> box's dropdown menu.
+ *
+ * **Note:** When using `md-select-header` element directives within a `md-select`, the labels that
+ * would normally be added to the <a ng-href="api/directive/mdOptgroup">md-optgroup</a> directives
+ * are omitted, allowing the `md-select-header` to represent the option group label
+ * (and possibly more).
+ *
+ * @usage
+ * With label attributes
+ * <hljs lang="html">
+ * <md-select ng-model="currentState" placeholder="Select a state">
+ * <md-optgroup label="Southern">
+ * <md-option ng-value="AL">Alabama</md-option>
+ * <md-option ng-value="FL">Florida</md-option>
+ * </md-optgroup>
+ * <md-optgroup label="Northern">
+ * <md-option ng-value="AK">Alaska</md-option>
+ * <md-option ng-value="MA">Massachusetts</md-option>
+ * </md-optgroup>
+ * </md-select>
+ * </hljs>
+ *
+ * With label elements
+ * <hljs lang="html">
+ * <md-select ng-model="currentState" placeholder="Select a state">
+ * <md-optgroup>
+ * <label>Southern</label>
+ * <md-option ng-value="AL">Alabama</md-option>
+ * <md-option ng-value="FL">Florida</md-option>
+ * </md-optgroup>
+ * <md-optgroup>
+ * <label>Northern</label>
+ * <md-option ng-value="AK">Alaska</md-option>
+ * <md-option ng-value="MA">Massachusetts</md-option>
+ * </md-optgroup>
+ * </md-select>
+ * </hljs>
+ *
+ * @param {string=} label The option group's label.
+ */
+function OptgroupDirective() {
+ return {
+ restrict: 'E',
+ compile: compile
+ };
+ function compile(element, attrs) {
+ // If we have a select header element, we don't want to add the normal label
+ // header.
+ if (!hasSelectHeader()) {
+ setupLabelElement();
+ }
+ element.attr('role', 'group');
+
+ function hasSelectHeader() {
+ return element.parent().find('md-select-header').length;
+ }
+
+ function setupLabelElement() {
+ var labelElement = element.find('label');
+ if (!labelElement.length) {
+ labelElement = angular.element('<label>');
+ element.prepend(labelElement);
+ }
+ labelElement.addClass('md-container-ignore');
+ labelElement.attr('aria-hidden', 'true');
+ if (attrs.label) {
+ labelElement.text(attrs.label);
+ }
+ element.attr('aria-label', labelElement.text());
+ }
+ }
+}
+
+function SelectHeaderDirective() {
+ return {
+ restrict: 'E',
+ };
+}
+
+function SelectProvider($$interimElementProvider) {
+ selectDefaultOptions.$inject = ["$mdSelect", "$mdConstant", "$mdUtil", "$window", "$q", "$$rAF", "$animateCss", "$animate", "$document"];
+ return $$interimElementProvider('$mdSelect')
+ .setDefaults({
+ methods: ['target'],
+ options: selectDefaultOptions
+ });
+
+ /* @ngInject */
+ function selectDefaultOptions($mdSelect, $mdConstant, $mdUtil, $window, $q, $$rAF, $animateCss, $animate, $document) {
+ var ERROR_TARGET_EXPECTED = "$mdSelect.show() expected a target element in options.target but got '{0}'!";
+ var animator = $mdUtil.dom.animator;
+ var keyCodes = $mdConstant.KEY_CODE;
+
+ return {
+ parent: 'body',
+ themable: true,
+ onShow: onShow,
+ onRemove: onRemove,
+ hasBackdrop: true,
+ disableParentScroll: true
+ };
+
+ /**
+ * Interim-element onRemove logic....
+ */
+ function onRemove(scope, element, opts) {
+ var animationRunner = null;
+ var destroyListener = scope.$on('$destroy', function() {
+ // Listen for the case where the element was destroyed while there was an
+ // ongoing close animation. If this happens, we need to end the animation
+ // manually.
+ animationRunner.end();
+ });
+
+ opts = opts || { };
+ opts.cleanupInteraction();
+ opts.cleanupResizing();
+ opts.hideBackdrop();
+
+ // For navigation $destroy events, do a quick, non-animated removal,
+ // but for normal closes (from clicks, etc) animate the removal
+ return (opts.$destroy === true) ? cleanElement() : animateRemoval().then(cleanElement);
+
+ /**
+ * For normal closes (eg clicks), animate the removal.
+ * For forced closes (like $destroy events from navigation),
+ * skip the animations.
+ */
+ function animateRemoval() {
+ animationRunner = $animateCss(element, {addClass: 'md-leave'});
+ return animationRunner.start();
+ }
+
+ /**
+ * Restore the element to a closed state
+ */
+ function cleanElement() {
+ destroyListener();
+
+ element
+ .removeClass('md-active')
+ .attr('aria-hidden', 'true')
+ .css({
+ 'display': 'none',
+ 'top': '',
+ 'right': '',
+ 'bottom': '',
+ 'left': '',
+ 'font-size': '',
+ 'min-width': ''
+ });
+
+ announceClosed(opts);
+
+ if (!opts.$destroy) {
+ if (opts.restoreFocus) {
+ opts.target.focus();
+ } else {
+ // Make sure that the container's md-input-focused is removed on backdrop click.
+ $mdUtil.nextTick(function() {
+ opts.target.triggerHandler('blur');
+ }, true);
+ }
+ }
+ }
+ }
+
+ /**
+ * Interim-element onShow logic.
+ */
+ function onShow(scope, element, opts) {
+
+ watchAsyncLoad();
+ sanitizeAndConfigure(scope, opts);
+
+ opts.hideBackdrop = showBackdrop(scope, element, opts);
+
+ return showDropDown(scope, element, opts)
+ .then(function(response) {
+ element.attr('aria-hidden', 'false');
+ opts.alreadyOpen = true;
+ opts.cleanupInteraction = activateInteraction();
+ opts.cleanupResizing = activateResizing();
+ opts.contentEl[0].focus();
+
+ return response;
+ }, opts.hideBackdrop);
+
+ // ************************************
+ // Closure Functions
+ // ************************************
+
+ /**
+ * Attach the select DOM element(s) and animate to the correct positions and scale.
+ */
+ function showDropDown(scope, element, opts) {
+ if (opts.parent !== element.parent()) {
+ element.parent().attr('aria-owns', element.find('md-content').attr('id'));
+ }
+
+ opts.parent.append(element);
+
+ return $q(function(resolve, reject) {
+ try {
+ $animateCss(element, {removeClass: 'md-leave', duration: 0})
+ .start()
+ .then(positionAndFocusMenu)
+ .then(resolve);
+
+ } catch (e) {
+ reject(e);
+ }
+ });
+ }
+
+ /**
+ * Initialize container and dropDown menu positions/scale, then animate to show.
+ * @return {*} a Promise that resolves after the menu is animated in and an item is focused
+ */
+ function positionAndFocusMenu() {
+ return $q(function(resolve) {
+ if (opts.isRemoved) return $q.reject(false);
+
+ var info = calculateMenuPositions(scope, element, opts);
+
+ info.container.element.css(animator.toCss(info.container.styles));
+ info.dropDown.element.css(animator.toCss(info.dropDown.styles));
+
+ $$rAF(function() {
+ element.addClass('md-active');
+ info.dropDown.element.css(animator.toCss({transform: ''}));
+ autoFocus(opts.focusedNode);
+
+ resolve();
+ });
+
+ });
+ }
+
+ /**
+ * Show modal backdrop element.
+ */
+ function showBackdrop(scope, element, options) {
+
+ // If we are not within a dialog...
+ if (options.disableParentScroll && !$mdUtil.getClosest(options.target, 'MD-DIALOG')) {
+ // !! DO this before creating the backdrop; since disableScrollAround()
+ // configures the scroll offset; which is used by mdBackDrop postLink()
+ options.restoreScroll = $mdUtil.disableScrollAround(options.element, options.parent);
+ } else {
+ options.disableParentScroll = false;
+ }
+
+ if (options.hasBackdrop) {
+ // Override duration to immediately show invisible backdrop
+ options.backdrop = $mdUtil.createBackdrop(scope, "md-select-backdrop md-click-catcher");
+ $animate.enter(options.backdrop, $document[0].body, null, {duration: 0});
+ }
+
+ /**
+ * Hide modal backdrop element...
+ */
+ return function hideBackdrop() {
+ if (options.backdrop) options.backdrop.remove();
+ if (options.disableParentScroll) options.restoreScroll();
+
+ delete options.restoreScroll;
+ };
+ }
+
+ /**
+ * @param {Element|HTMLElement|null=} previousNode
+ * @param {Element|HTMLElement} node
+ * @param {SelectMenuController|Function|object=} menuController SelectMenuController instance
+ */
+ function focusOptionNode(previousNode, node, menuController) {
+ var listboxContentNode = opts.contentEl[0];
+
+ if (node) {
+ if (previousNode) {
+ previousNode.classList.remove('md-focused');
+ }
+
+ node.classList.add('md-focused');
+ if (menuController && menuController.setActiveDescendant) {
+ menuController.setActiveDescendant(node.id);
+ }
+
+ // Scroll the node into view if needed.
+ if (listboxContentNode.scrollHeight > listboxContentNode.clientHeight) {
+ var scrollBottom = listboxContentNode.clientHeight + listboxContentNode.scrollTop;
+ var nodeBottom = node.offsetTop + node.offsetHeight;
+ if (nodeBottom > scrollBottom) {
+ listboxContentNode.scrollTop = nodeBottom - listboxContentNode.clientHeight;
+ } else if (node.offsetTop < listboxContentNode.scrollTop) {
+ listboxContentNode.scrollTop = node.offsetTop;
+ }
+ }
+ opts.focusedNode = node;
+ if (menuController && menuController.refreshViewValue) {
+ menuController.refreshViewValue();
+ }
+ }
+ }
+
+ /**
+ * @param {Element|HTMLElement} nodeToFocus
+ */
+ function autoFocus(nodeToFocus) {
+ var selectMenuController;
+ if (nodeToFocus && !nodeToFocus.hasAttribute('disabled')) {
+ selectMenuController = opts.selectEl.controller('mdSelectMenu');
+ focusOptionNode(null, nodeToFocus, selectMenuController);
+ }
+ }
+
+ /**
+ * Check for valid opts and set some useful defaults
+ */
+ function sanitizeAndConfigure(scope, options) {
+ var selectMenuElement = element.find('md-select-menu');
+
+ if (!options.target) {
+ throw new Error($mdUtil.supplant(ERROR_TARGET_EXPECTED, [options.target]));
+ }
+
+ angular.extend(options, {
+ isRemoved: false,
+ target: angular.element(options.target), // make sure it's not a naked DOM node
+ parent: angular.element(options.parent),
+ selectEl: selectMenuElement,
+ contentEl: element.find('md-content'),
+ optionNodes: selectMenuElement[0].getElementsByTagName('md-option')
+ });
+ }
+
+ /**
+ * Configure various resize listeners for screen changes
+ */
+ function activateResizing() {
+ var debouncedOnResize = (function(scope, target, options) {
+
+ return function() {
+ if (options.isRemoved) return;
+
+ var updates = calculateMenuPositions(scope, target, options);
+ var container = updates.container;
+ var dropDown = updates.dropDown;
+
+ container.element.css(animator.toCss(container.styles));
+ dropDown.element.css(animator.toCss(dropDown.styles));
+ };
+
+ })(scope, element, opts);
+
+ var window = angular.element($window);
+ window.on('resize', debouncedOnResize);
+ window.on('orientationchange', debouncedOnResize);
+
+ // Publish deactivation closure...
+ return function deactivateResizing() {
+
+ // Disable resizing handlers
+ window.off('resize', debouncedOnResize);
+ window.off('orientationchange', debouncedOnResize);
+ };
+ }
+
+ /**
+ * If asynchronously loading, watch and update internal '$$loadingAsyncDone' flag.
+ */
+ function watchAsyncLoad() {
+ if (opts.loadingAsync && !opts.isRemoved) {
+ scope.$$loadingAsyncDone = false;
+
+ $q.when(opts.loadingAsync)
+ .then(function() {
+ scope.$$loadingAsyncDone = true;
+ delete opts.loadingAsync;
+ }).then(function() {
+ $$rAF(positionAndFocusMenu);
+ });
+ }
+ }
+
+ function activateInteraction() {
+ if (opts.isRemoved) {
+ return;
+ }
+
+ var dropDown = opts.selectEl;
+ var selectMenuController = dropDown.controller('mdSelectMenu') || {};
+
+ element.addClass('md-clickable');
+
+ // Close on backdrop click
+ opts.backdrop && opts.backdrop.on('click', onBackdropClick);
+
+ // Escape to close
+ // Cycling of options, and closing on enter
+ dropDown.on('keydown', onMenuKeyDown);
+ dropDown.on('click', checkCloseMenu);
+
+ return function cleanupInteraction() {
+ opts.backdrop && opts.backdrop.off('click', onBackdropClick);
+ dropDown.off('keydown', onMenuKeyDown);
+ dropDown.off('click', checkCloseMenu);
+
+ element.removeClass('md-clickable');
+ opts.isRemoved = true;
+ };
+
+ // ************************************
+ // Closure Functions
+ // ************************************
+
+ function onBackdropClick(e) {
+ e.preventDefault();
+ e.stopPropagation();
+ opts.restoreFocus = false;
+ $mdUtil.nextTick($mdSelect.hide, true);
+ }
+
+ function onMenuKeyDown(ev) {
+ ev.preventDefault();
+ ev.stopPropagation();
+
+ switch (ev.keyCode) {
+ case keyCodes.UP_ARROW:
+ return focusPrevOption();
+ case keyCodes.DOWN_ARROW:
+ return focusNextOption();
+ case keyCodes.SPACE:
+ case keyCodes.ENTER:
+ if (opts.focusedNode) {
+ dropDown.triggerHandler({
+ type: 'click',
+ target: opts.focusedNode
+ });
+ ev.preventDefault();
+ }
+ checkCloseMenu(ev);
+ break;
+ case keyCodes.TAB:
+ case keyCodes.ESCAPE:
+ ev.stopPropagation();
+ ev.preventDefault();
+ opts.restoreFocus = true;
+ $mdUtil.nextTick($mdSelect.hide, true);
+ break;
+ default:
+ if (shouldHandleKey(ev, $mdConstant)) {
+ var optNode = selectMenuController.optNodeForKeyboardSearch(ev);
+ if (optNode && !optNode.hasAttribute('disabled')) {
+ focusOptionNode(opts.focusedNode, optNode, selectMenuController);
+ }
+ }
+ }
+ }
+
+ /**
+ * Change the focus to another option. If there is no focused option, focus the first
+ * option. If there is a focused option, then use the direction to determine if we should
+ * focus the previous or next option in the list.
+ * @param {'next'|'prev'} direction
+ */
+ function focusOption(direction) {
+ var optionsArray = $mdUtil.nodesToArray(opts.optionNodes);
+ var index = optionsArray.indexOf(opts.focusedNode);
+ var prevOption = optionsArray[index];
+ var newOption;
+
+ do {
+ if (index === -1) {
+ // We lost the previously focused element, reset to first option
+ index = 0;
+ } else if (direction === 'next' && index < optionsArray.length - 1) {
+ index++;
+ } else if (direction === 'prev' && index > 0) {
+ index--;
+ }
+ newOption = optionsArray[index];
+ if (newOption.hasAttribute('disabled')) {
+ newOption = null;
+ }
+ } while (!newOption && index < optionsArray.length - 1 && index > 0);
+
+ focusOptionNode(prevOption, newOption, selectMenuController);
+ }
+
+ function focusNextOption() {
+ focusOption('next');
+ }
+
+ function focusPrevOption() {
+ focusOption('prev');
+ }
+
+ /**
+ * @param {KeyboardEvent|MouseEvent} event
+ */
+ function checkCloseMenu(event) {
+ if (event && (event.type === 'click') && (event.currentTarget !== dropDown[0])) {
+ return;
+ }
+ if (mouseOnScrollbar()) {
+ return;
+ }
+
+ if (opts.focusedNode && opts.focusedNode.hasAttribute &&
+ !opts.focusedNode.hasAttribute('disabled')) {
+ event.preventDefault();
+ event.stopPropagation();
+ if (!selectMenuController.isMultiple) {
+ opts.restoreFocus = true;
+
+ $mdUtil.nextTick(function () {
+ $mdSelect.hide(selectMenuController.ngModel.$viewValue);
+ opts.focusedNode.classList.remove('md-focused');
+ }, true);
+ }
+ }
+
+ /**
+ * check if the mouseup event was on a scrollbar
+ */
+ function mouseOnScrollbar() {
+ var clickOnScrollbar = false;
+ if (event && (event.currentTarget.children.length > 0)) {
+ var child = event.currentTarget.children[0];
+ var hasScrollbar = child.scrollHeight > child.clientHeight;
+ if (hasScrollbar && child.children.length > 0) {
+ var relPosX = event.pageX - event.currentTarget.getBoundingClientRect().left;
+ if (relPosX > child.querySelector('md-option').offsetWidth)
+ clickOnScrollbar = true;
+ }
+ }
+ return clickOnScrollbar;
+ }
+ }
+ }
+ }
+
+ /**
+ * To notify listeners that the Select menu has closed,
+ * trigger the [optional] user-defined expression
+ */
+ function announceClosed(opts) {
+ var mdSelect = opts.selectCtrl;
+ if (mdSelect) {
+ var menuController = opts.selectEl.controller('mdSelectMenu');
+ mdSelect.setSelectValueText(menuController ? menuController.getSelectedLabels() : '');
+ mdSelect.triggerClose();
+ }
+ }
+
+
+ /**
+ * Calculate the menu positions after an event like options changing, screen resizing, or
+ * animations finishing.
+ * @param {Object} scope
+ * @param element
+ * @param opts
+ * @return {{container: {styles: {top: number, left: number, 'font-size': *, 'min-width': number}, element: Object}, dropDown: {styles: {transform: string, transformOrigin: string}, element: Object}}}
+ */
+ function calculateMenuPositions(scope, element, opts) {
+ var
+ containerNode = element[0],
+ targetNode = opts.target[0].children[0], // target the label
+ parentNode = $document[0].body,
+ selectNode = opts.selectEl[0],
+ contentNode = opts.contentEl[0],
+ parentRect = parentNode.getBoundingClientRect(),
+ targetRect = targetNode.getBoundingClientRect(),
+ shouldOpenAroundTarget = false,
+ bounds = {
+ left: parentRect.left + SELECT_EDGE_MARGIN,
+ top: SELECT_EDGE_MARGIN,
+ bottom: parentRect.height - SELECT_EDGE_MARGIN,
+ right: parentRect.width - SELECT_EDGE_MARGIN - ($mdUtil.floatingScrollbars() ? 16 : 0)
+ },
+ spaceAvailable = {
+ top: targetRect.top - bounds.top,
+ left: targetRect.left - bounds.left,
+ right: bounds.right - (targetRect.left + targetRect.width),
+ bottom: bounds.bottom - (targetRect.top + targetRect.height)
+ },
+ maxWidth = parentRect.width - SELECT_EDGE_MARGIN * 2,
+ selectedNode = selectNode.querySelector('md-option[selected]'),
+ optionNodes = selectNode.getElementsByTagName('md-option'),
+ optgroupNodes = selectNode.getElementsByTagName('md-optgroup'),
+ isScrollable = calculateScrollable(element, contentNode),
+ centeredNode;
+
+ var loading = isPromiseLike(opts.loadingAsync);
+ if (!loading) {
+ // If a selected node, center around that
+ if (selectedNode) {
+ centeredNode = selectedNode;
+ // If there are option groups, center around the first option group
+ } else if (optgroupNodes.length) {
+ centeredNode = optgroupNodes[0];
+ // Otherwise - if we are not loading async - center around the first optionNode
+ } else if (optionNodes.length) {
+ centeredNode = optionNodes[0];
+ // In case there are no options, center on whatever's in there... (eg progress indicator)
+ } else {
+ centeredNode = contentNode.firstElementChild || contentNode;
+ }
+ } else {
+ // If loading, center on progress indicator
+ centeredNode = contentNode.firstElementChild || contentNode;
+ }
+
+ if (contentNode.offsetWidth > maxWidth) {
+ contentNode.style['max-width'] = maxWidth + 'px';
+ } else {
+ contentNode.style.maxWidth = null;
+ }
+ if (shouldOpenAroundTarget) {
+ contentNode.style['min-width'] = targetRect.width + 'px';
+ }
+
+ // Remove padding before we compute the position of the menu
+ if (isScrollable) {
+ selectNode.classList.add('md-overflow');
+ }
+
+ var focusedNode = centeredNode;
+ if ((focusedNode.tagName || '').toUpperCase() === 'MD-OPTGROUP') {
+ focusedNode = optionNodes[0] || contentNode.firstElementChild || contentNode;
+ centeredNode = focusedNode;
+ }
+ // Cache for autoFocus()
+ opts.focusedNode = focusedNode;
+
+ // Get the selectMenuRect *after* max-width is possibly set above
+ containerNode.style.display = 'block';
+ var selectMenuRect = selectNode.getBoundingClientRect();
+ var centeredRect = getOffsetRect(centeredNode);
+
+ if (centeredNode) {
+ var centeredStyle = $window.getComputedStyle(centeredNode);
+ centeredRect.paddingLeft = parseInt(centeredStyle.paddingLeft, 10) || 0;
+ centeredRect.paddingRight = parseInt(centeredStyle.paddingRight, 10) || 0;
+ }
+
+ if (isScrollable) {
+ var scrollBuffer = contentNode.offsetHeight / 2;
+ contentNode.scrollTop = centeredRect.top + centeredRect.height / 2 - scrollBuffer;
+
+ if (spaceAvailable.top < scrollBuffer) {
+ contentNode.scrollTop = Math.min(
+ centeredRect.top,
+ contentNode.scrollTop + scrollBuffer - spaceAvailable.top
+ );
+ } else if (spaceAvailable.bottom < scrollBuffer) {
+ contentNode.scrollTop = Math.max(
+ centeredRect.top + centeredRect.height - selectMenuRect.height,
+ contentNode.scrollTop - scrollBuffer + spaceAvailable.bottom
+ );
+ }
+ }
+
+ var left, top, transformOrigin, minWidth, fontSize;
+ if (shouldOpenAroundTarget) {
+ left = targetRect.left;
+ top = targetRect.top + targetRect.height;
+ transformOrigin = '50% 0';
+ if (top + selectMenuRect.height > bounds.bottom) {
+ top = targetRect.top - selectMenuRect.height;
+ transformOrigin = '50% 100%';
+ }
+ } else {
+ left = (targetRect.left + centeredRect.left - centeredRect.paddingLeft);
+ top = Math.floor(targetRect.top + targetRect.height / 2 - centeredRect.height / 2 -
+ centeredRect.top + contentNode.scrollTop) + 2;
+
+ transformOrigin = (centeredRect.left + targetRect.width / 2) + 'px ' +
+ (centeredRect.top + centeredRect.height / 2 - contentNode.scrollTop) + 'px 0px';
+
+ minWidth = Math.min(targetRect.width + centeredRect.paddingLeft + centeredRect.paddingRight, maxWidth);
+
+ fontSize = window.getComputedStyle(targetNode)['font-size'];
+ }
+
+ // Keep left and top within the window
+ var containerRect = containerNode.getBoundingClientRect();
+ var scaleX = Math.round(100 * Math.min(targetRect.width / selectMenuRect.width, 1.0)) / 100;
+ var scaleY = Math.round(100 * Math.min(targetRect.height / selectMenuRect.height, 1.0)) / 100;
+
+ return {
+ container: {
+ element: angular.element(containerNode),
+ styles: {
+ left: Math.floor(clamp(bounds.left, left, bounds.right - minWidth)),
+ top: Math.floor(clamp(bounds.top, top, bounds.bottom - containerRect.height)),
+ 'min-width': minWidth,
+ 'font-size': fontSize
+ }
+ },
+ dropDown: {
+ element: angular.element(selectNode),
+ styles: {
+ transformOrigin: transformOrigin,
+ transform: !opts.alreadyOpen ? $mdUtil.supplant('scale({0},{1})', [scaleX, scaleY]) : ""
+ }
+ }
+ };
+ }
+ }
+
+ function isPromiseLike(obj) {
+ return obj && angular.isFunction(obj.then);
+ }
+
+ function clamp(min, n, max) {
+ return Math.max(min, Math.min(n, max));
+ }
+
+ function getOffsetRect(node) {
+ return node ? {
+ left: node.offsetLeft,
+ top: node.offsetTop,
+ width: node.offsetWidth,
+ height: node.offsetHeight
+ } : {left: 0, top: 0, width: 0, height: 0};
+ }
+
+ function calculateScrollable(element, contentNode) {
+ var isScrollable = false;
+
+ try {
+ var oldDisplay = element[0].style.display;
+
+ // Set the element's display to block so that this calculation is correct
+ element[0].style.display = 'block';
+
+ isScrollable = contentNode.scrollHeight > contentNode.offsetHeight;
+
+ // Reset it back afterwards
+ element[0].style.display = oldDisplay;
+ } finally {
+ // Nothing to do
+ }
+ return isScrollable;
+ }
+}
+
+function shouldHandleKey(ev, $mdConstant) {
+ var char = String.fromCharCode(ev.keyCode);
+ var isNonUsefulKey = (ev.keyCode <= 31);
+
+ return (char && char.length && !isNonUsefulKey &&
+ !$mdConstant.isMetaKey(ev) && !$mdConstant.isFnLockKey(ev) && !$mdConstant.hasModifierKey(ev));
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.showHide
+ */
+
+// Add additional handlers to ng-show and ng-hide that notify directives
+// contained within that they should recompute their size.
+// These run in addition to AngularJS's built-in ng-hide and ng-show directives.
+angular.module('material.components.showHide', [
+ 'material.core'
+])
+ .directive('ngShow', createDirective('ngShow', true))
+ .directive('ngHide', createDirective('ngHide', false));
+
+
+function createDirective(name, targetValue) {
+ return ['$mdUtil', '$window', function($mdUtil, $window) {
+ return {
+ restrict: 'A',
+ multiElement: true,
+ link: function($scope, $element, $attr) {
+ var unregister = $scope.$on('$md-resize-enable', function() {
+ unregister();
+
+ var node = $element[0];
+ var cachedTransitionStyles = node.nodeType === $window.Node.ELEMENT_NODE ?
+ $window.getComputedStyle(node) : {};
+
+ $scope.$watch($attr[name], function(value) {
+ if (!!value === targetValue) {
+ $mdUtil.nextTick(function() {
+ $scope.$broadcast('$md-resize');
+ });
+
+ var opts = {
+ cachedTransitionStyles: cachedTransitionStyles
+ };
+
+ $mdUtil.dom.animator.waitTransitionEnd($element, opts).then(function() {
+ $scope.$broadcast('$md-resize');
+ });
+ }
+ });
+ });
+ }
+ };
+ }];
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.sidenav
+ *
+ * @description
+ * A Sidenav component.
+ */
+SidenavService.$inject = ["$mdComponentRegistry", "$mdUtil", "$q", "$log"];
+SidenavDirective.$inject = ["$mdMedia", "$mdUtil", "$mdConstant", "$mdTheming", "$mdInteraction", "$animate", "$compile", "$parse", "$log", "$q", "$document", "$window", "$$rAF"];
+SidenavController.$inject = ["$scope", "$attrs", "$mdComponentRegistry", "$q", "$interpolate"];
+angular
+ .module('material.components.sidenav', [
+ 'material.core',
+ 'material.components.backdrop'
+ ])
+ .factory('$mdSidenav', SidenavService)
+ .directive('mdSidenav', SidenavDirective)
+ .controller('$mdSidenavController', SidenavController);
+
+
+/**
+ * @ngdoc service
+ * @name $mdSidenav
+ * @module material.components.sidenav
+ *
+ * @description
+ * `$mdSidenav` makes it easy to interact with multiple sidenavs in an app. When looking up a
+ * sidenav instance, you can either look it up synchronously or wait for it to be initialized
+ * asynchronously. This is done by passing the second argument to `$mdSidenav`.
+ *
+ * @usage
+ * <hljs lang="js">
+ * // Async lookup for sidenav instance; will resolve when the instance is available
+ * $mdSidenav(componentId, true).then(function(instance) {
+ * $log.debug( componentId + "is now ready" );
+ * });
+ * // Sync lookup for sidenav instance; this will resolve immediately.
+ * $mdSidenav(componentId).then(function(instance) {
+ * $log.debug( componentId + "is now ready" );
+ * });
+ * // Async toggle the given sidenav;
+ * // when instance is known ready and lazy lookup is not needed.
+ * $mdSidenav(componentId)
+ * .toggle()
+ * .then(function(){
+ * $log.debug('toggled');
+ * });
+ * // Async open the given sidenav
+ * $mdSidenav(componentId)
+ * .open()
+ * .then(function(){
+ * $log.debug('opened');
+ * });
+ * // Async close the given sidenav
+ * $mdSidenav(componentId)
+ * .close()
+ * .then(function(){
+ * $log.debug('closed');
+ * });
+ * // Async lookup for sidenav instance
+ * $mdSidenav(componentId, true).then(function(instance) {
+ * // On close callback to handle close, backdrop click, or escape key pressed.
+ * // Callback happens BEFORE the close action occurs.
+ * instance.onClose(function() {
+ * $log.debug('closing');
+ * });
+ * });
+ * // Sync check to see if the specified sidenav is set to be open
+ * $mdSidenav(componentId).isOpen();
+ * // Sync check to whether given sidenav is locked open
+ * // If this is true, the sidenav will be open regardless of close()
+ * $mdSidenav(componentId).isLockedOpen();
+ * </hljs>
+ */
+function SidenavService($mdComponentRegistry, $mdUtil, $q, $log) {
+ var errorMsg = "SideNav '{0}' is not available! Did you use md-component-id='{0}'?";
+ var service = {
+ find: findInstance, // sync - returns proxy API
+ waitFor: waitForInstance // async - returns promise
+ };
+
+ /**
+ * Service API that supports three (3) usages:
+ * $mdSidenav().find("left") // sync (must already exist) or returns undefined
+ * $mdSidenav("left").toggle(); // sync (must already exist) or returns reject promise;
+ * $mdSidenav("left",true).then(function(left) { // async returns instance when available
+ * left.toggle();
+ * });
+ */
+ return function(handle, enableWait) {
+ if (angular.isUndefined(handle)) {
+ return service;
+ }
+
+ var shouldWait = enableWait === true;
+ var instance = service.find(handle, shouldWait);
+ return !instance && shouldWait ? service.waitFor(handle) :
+ !instance && angular.isUndefined(enableWait) ? addLegacyAPI(service, handle) : instance;
+ };
+
+ /**
+ * For failed instance/handle lookups, older-clients expect an response object with noops
+ * that include `rejected promise APIs`
+ * @param service
+ * @param handle
+ * @returns {Object}
+ */
+ function addLegacyAPI(service, handle) {
+ var falseFn = function() {
+ return false;
+ };
+ var rejectFn = function() {
+ return $q.when($mdUtil.supplant(errorMsg, [handle || ""]));
+ };
+
+ return angular.extend({
+ isLockedOpen: falseFn,
+ isOpen: falseFn,
+ toggle: rejectFn,
+ open: rejectFn,
+ close: rejectFn,
+ onClose: angular.noop,
+ then: function(callback) {
+ return waitForInstance(handle).then(callback || angular.noop);
+ }
+ }, service);
+ }
+
+ /**
+ * Synchronously lookup the controller instance for the specified sidNav instance which has been
+ * registered with the markup `md-component-id`
+ */
+ function findInstance(handle, shouldWait) {
+ var instance = $mdComponentRegistry.get(handle);
+
+ if (!instance && !shouldWait) {
+ // Report missing instance
+ $log.error($mdUtil.supplant(errorMsg, [handle || ""]));
+
+ // The component has not registered itself... most like NOT yet created
+ // return null to indicate that the Sidenav is not in the DOM
+ return undefined;
+ }
+ return instance;
+ }
+
+ /**
+ * Asynchronously wait for the component instantiation,
+ * Deferred lookup of component instance using $component registry
+ */
+ function waitForInstance(handle) {
+ return $mdComponentRegistry.when(handle).catch($log.error);
+ }
+}
+
+/**
+ * @ngdoc directive
+ * @name mdSidenav
+ * @module material.components.sidenav
+ * @restrict E
+ *
+ * @description
+ * A Sidenav component that can be opened and closed programmatically.
+ *
+ * By default, upon opening it will slide out on top of the main content area.
+ *
+ * For keyboard and screen reader accessibility, focus is sent to the sidenav wrapper by default.
+ * It can be overridden with the `md-autofocus` directive on the child element you want focused.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div layout="row" ng-controller="MyController">
+ * <md-sidenav md-component-id="left" class="md-sidenav-left">
+ * Left Nav!
+ * </md-sidenav>
+ *
+ * <md-content>
+ * Center Content
+ * <md-button ng-click="openLeftMenu()">
+ * Open Left Menu
+ * </md-button>
+ * </md-content>
+ *
+ * <md-sidenav md-component-id="right"
+ * md-is-locked-open="$mdMedia('min-width: 333px')"
+ * class="md-sidenav-right">
+ * <form>
+ * <md-input-container>
+ * <label for="testInput">Test input</label>
+ * <input id="testInput" type="text"
+ * ng-model="data" md-autofocus>
+ * </md-input-container>
+ * </form>
+ * </md-sidenav>
+ * </div>
+ * </hljs>
+ *
+ * <hljs lang="js">
+ * var app = angular.module('myApp', ['ngMaterial']);
+ * app.controller('MyController', function($scope, $mdSidenav) {
+ * $scope.openLeftMenu = function() {
+ * $mdSidenav('left').toggle();
+ * };
+ * });
+ * </hljs>
+ *
+ * @param {expression=} md-is-open A model bound to whether the sidenav is opened.
+ * @param {boolean=} md-disable-backdrop When present in the markup, the sidenav will not show a
+ * backdrop.
+ * @param {boolean=} md-disable-close-events When present in the markup, clicking the backdrop or
+ * pressing the 'Escape' key will not close the sidenav.
+ * @param {string=} md-component-id componentId to use with $mdSidenav service.
+ * @param {expression=} md-is-locked-open When this expression evaluates to true,
+ * the sidenav "locks open": it falls into the content's flow instead of appearing over it. This
+ * overrides the `md-is-open` attribute.
+ *
+ * The `$mdMedia()` service is exposed to the `md-is-locked-open` attribute, which
+ * can be given a media query or one of the `sm`, `gt-sm`, `md`, `gt-md`, `lg` or `gt-lg` presets.
+ * <br><br>Examples:
+ *
+ * Lock open when `true`:<br>
+ * `<md-sidenav md-is-locked-open="shouldLockOpen"></md-sidenav>`
+ *
+ * Lock open when the width is `1000px` or greater:<br>
+ * `<md-sidenav md-is-locked-open="$mdMedia('min-width: 1000px')"></md-sidenav>`
+ *
+ * Lock open on small screens:<br>
+ * `<md-sidenav md-is-locked-open="$mdMedia('sm')"></md-sidenav>`
+ *
+ * @param {string=} md-disable-scroll-target Selector, pointing to an element, whose scrolling will
+ * be disabled when the sidenav is opened. By default this is the sidenav's direct parent.
+ */
+function SidenavDirective($mdMedia, $mdUtil, $mdConstant, $mdTheming, $mdInteraction, $animate,
+ $compile, $parse, $log, $q, $document, $window, $$rAF) {
+ return {
+ restrict: 'E',
+ scope: {
+ isOpen: '=?mdIsOpen'
+ },
+ controller: '$mdSidenavController',
+ compile: function(element) {
+ element.addClass('md-closed').attr('tabIndex', '-1');
+ return postLink;
+ }
+ };
+
+ /**
+ * Directive Post Link function...
+ */
+ function postLink(scope, element, attr, sidenavCtrl) {
+ var lastParentOverFlow;
+ var backdrop;
+ var disableScrollTarget = null;
+ var disableCloseEvents;
+ var triggeringInteractionType;
+ var triggeringElement = null;
+ var previousContainerStyles;
+ var promise = $q.when(true);
+ var isLockedOpenParsed = $parse(attr.mdIsLockedOpen);
+ var ngWindow = angular.element($window);
+ var isLocked = function() {
+ return isLockedOpenParsed(scope.$parent, {
+ $mdMedia: $mdMedia
+ });
+ };
+
+ if (attr.mdDisableScrollTarget) {
+ disableScrollTarget = $document[0].querySelector(attr.mdDisableScrollTarget);
+
+ if (disableScrollTarget) {
+ disableScrollTarget = angular.element(disableScrollTarget);
+ } else {
+ $log.warn($mdUtil.supplant('mdSidenav: couldn\'t find element matching ' +
+ 'selector "{selector}". Falling back to parent.',
+ { selector: attr.mdDisableScrollTarget }));
+ }
+ }
+
+ if (!disableScrollTarget) {
+ disableScrollTarget = element.parent();
+ }
+
+ // Only create the backdrop if the backdrop isn't disabled.
+ if (!attr.hasOwnProperty('mdDisableBackdrop')) {
+ backdrop = $mdUtil.createBackdrop(scope, "md-sidenav-backdrop md-opaque ng-enter");
+ }
+
+ // If md-disable-close-events is set on the sidenav we will disable
+ // backdrop click and Escape key events
+ if (attr.hasOwnProperty('mdDisableCloseEvents')) {
+ disableCloseEvents = true;
+ }
+
+ element.addClass('_md'); // private md component indicator for styling
+ $mdTheming(element);
+
+ // The backdrop should inherit the sidenavs theme,
+ // because the backdrop will take its parent theme by default.
+ if (backdrop) $mdTheming.inherit(backdrop, element);
+
+ element.on('$destroy', function() {
+ backdrop && backdrop.remove();
+ sidenavCtrl.destroy();
+ });
+
+ scope.$on('$destroy', function(){
+ backdrop && backdrop.remove();
+ });
+
+ scope.$watch(isLocked, updateIsLocked);
+ scope.$watch('isOpen', updateIsOpen);
+
+
+ // Publish special accessor for the Controller instance
+ sidenavCtrl.$toggleOpen = toggleOpen;
+
+ /**
+ * Toggle the DOM classes to indicate `locked`
+ * @param isLocked
+ * @param oldValue
+ */
+ function updateIsLocked(isLocked, oldValue) {
+ scope.isLockedOpen = isLocked;
+ if (isLocked === oldValue) {
+ element.toggleClass('md-locked-open', !!isLocked);
+ } else {
+ $animate[isLocked ? 'addClass' : 'removeClass'](element, 'md-locked-open');
+ }
+ if (backdrop) {
+ backdrop.toggleClass('md-locked-open', !!isLocked);
+ }
+ }
+
+ /**
+ * Toggle the SideNav view and attach/detach listeners
+ * @param {boolean} isOpen
+ */
+ function updateIsOpen(isOpen) {
+ var focusEl = $mdUtil.findFocusTarget(element) || element;
+ var parent = element.parent();
+ var restorePositioning;
+
+ // If the user hasn't set the disable close events property we are adding
+ // click and escape events to close the sidenav
+ if (!disableCloseEvents) {
+ parent[isOpen ? 'on' : 'off']('keydown', onKeyDown);
+ if (backdrop) backdrop[isOpen ? 'on' : 'off']('click', close);
+ }
+
+ restorePositioning = updateContainerPositions(parent, isOpen);
+
+ if (isOpen) {
+ // Capture upon opening..
+ triggeringElement = $document[0].activeElement;
+ triggeringInteractionType = $mdInteraction.getLastInteractionType();
+ }
+
+ disableParentScroll(isOpen);
+
+ return promise = $q.all([
+ isOpen && backdrop ? $animate.enter(backdrop, parent) : backdrop ?
+ $animate.leave(backdrop) : $q.when(true),
+ $animate[isOpen ? 'removeClass' : 'addClass'](element, 'md-closed')
+ ]).then(function() {
+ // Perform focus when animations are ALL done...
+ if (scope.isOpen) {
+ $$rAF(function() {
+ // Notifies child components that the sidenav was opened. Should wait
+ // a frame in order to allow for the element height to be computed.
+ ngWindow.triggerHandler('resize');
+ });
+
+ focusEl && focusEl.focus();
+ }
+
+ // Restores the positioning on the sidenav and backdrop.
+ restorePositioning && restorePositioning();
+ });
+ }
+
+ function updateContainerPositions(parent, willOpen) {
+ var drawerEl = element[0];
+ var scrollTop = parent[0].scrollTop;
+
+ if (willOpen && scrollTop) {
+ previousContainerStyles = {
+ top: drawerEl.style.top,
+ bottom: drawerEl.style.bottom,
+ height: drawerEl.style.height
+ };
+
+ // When the parent is scrolled down, then we want to be able to show the sidenav at the
+ // current scroll position. We're moving the sidenav down to the correct scroll position
+ // and apply the height of the parent, to increase the performance. Using 100% as height,
+ // will impact the performance heavily.
+ var positionStyle = {
+ top: scrollTop + 'px',
+ bottom: 'auto',
+ height: parent[0].clientHeight + 'px'
+ };
+
+ // Apply the new position styles to the sidenav and backdrop.
+ element.css(positionStyle);
+ backdrop.css(positionStyle);
+ }
+
+ // When the sidenav is closing and we have previous defined container styles,
+ // then we return a restore function, which resets the sidenav and backdrop.
+ if (!willOpen && previousContainerStyles) {
+ return function() {
+ drawerEl.style.top = previousContainerStyles.top;
+ drawerEl.style.bottom = previousContainerStyles.bottom;
+ drawerEl.style.height = previousContainerStyles.height;
+
+ backdrop[0].style.top = null;
+ backdrop[0].style.bottom = null;
+ backdrop[0].style.height = null;
+
+ previousContainerStyles = null;
+ };
+ }
+ }
+
+ /**
+ * Prevent parent scrolling (when the SideNav is open)
+ */
+ function disableParentScroll(disabled) {
+ if (disabled && !lastParentOverFlow) {
+ lastParentOverFlow = disableScrollTarget.css('overflow');
+ disableScrollTarget.css('overflow', 'hidden');
+ } else if (angular.isDefined(lastParentOverFlow)) {
+ disableScrollTarget.css('overflow', lastParentOverFlow);
+ lastParentOverFlow = undefined;
+ }
+ }
+
+ /**
+ * Toggle the sideNav view and publish a promise to be resolved when
+ * the view animation finishes.
+ * @param {boolean} isOpen true to open the sidenav, false to close it
+ * @returns {*} promise to be resolved when the view animation finishes
+ */
+ function toggleOpen(isOpen) {
+ if (scope.isOpen === isOpen) {
+ return $q.when(true);
+ } else {
+ if (scope.isOpen && sidenavCtrl.onCloseCb) sidenavCtrl.onCloseCb();
+
+ return $q(function(resolve) {
+ // Toggle value to force an async `updateIsOpen()` to run
+ scope.isOpen = isOpen;
+
+ $mdUtil.nextTick(function() {
+ // When the current `updateIsOpen()` animation finishes
+ promise.then(function(result) {
+
+ if (!scope.isOpen && triggeringElement && triggeringInteractionType === 'keyboard') {
+ // reset focus to originating element (if available) upon close
+ triggeringElement.focus();
+ triggeringElement = null;
+ }
+
+ resolve(result);
+ });
+ });
+ });
+ }
+ }
+
+ /**
+ * Auto-close sideNav when the `escape` key is pressed.
+ * @param {KeyboardEvent} ev keydown event
+ */
+ function onKeyDown(ev) {
+ var isEscape = (ev.keyCode === $mdConstant.KEY_CODE.ESCAPE);
+ return isEscape ? close(ev) : $q.when(true);
+ }
+
+ /**
+ * With backdrop `clicks` or `escape` key-press, immediately apply the CSS close transition...
+ * Then notify the controller to close() and perform its own actions.
+ * @param {Event} ev
+ * @returns {*}
+ */
+ function close(ev) {
+ ev.preventDefault();
+
+ return sidenavCtrl.close();
+ }
+ }
+}
+
+/*
+ * @private
+ * @ngdoc controller
+ * @name SidenavController
+ * @module material.components.sidenav
+ */
+function SidenavController($scope, $attrs, $mdComponentRegistry, $q, $interpolate) {
+ var self = this;
+
+ // Use Default internal method until overridden by directive postLink
+
+ // Synchronous getters
+ self.isOpen = function() { return !!$scope.isOpen; };
+ self.isLockedOpen = function() { return !!$scope.isLockedOpen; };
+
+ // Synchronous setters
+ self.onClose = function (callback) {
+ self.onCloseCb = callback;
+ return self;
+ };
+
+ // Async actions
+ self.open = function() { return self.$toggleOpen(true); };
+ self.close = function() { return self.$toggleOpen(false); };
+ self.toggle = function() { return self.$toggleOpen(!$scope.isOpen); };
+ self.$toggleOpen = function(value) { return $q.when($scope.isOpen = value); };
+
+ // Evaluate the component id.
+ var rawId = $attrs.mdComponentId;
+ var hasDataBinding = rawId && rawId.indexOf($interpolate.startSymbol()) > -1;
+ var componentId = hasDataBinding ? $interpolate(rawId)($scope.$parent) : rawId;
+
+ // Register the component.
+ self.destroy = $mdComponentRegistry.register(self, componentId);
+
+ // Watch and update the component, if the id has changed.
+ if (hasDataBinding) {
+ $attrs.$observe('mdComponentId', function(id) {
+ if (id && id !== self.$$mdHandle) {
+ // `destroy` only deregisters the old component id so we can add the new one.
+ self.destroy();
+ self.destroy = $mdComponentRegistry.register(self, id);
+ }
+ });
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.slider
+ */
+SliderDirective.$inject = ["$$rAF", "$window", "$mdAria", "$mdUtil", "$mdConstant", "$mdTheming", "$mdGesture", "$parse", "$log", "$timeout"];
+angular.module('material.components.slider', [
+ 'material.core'
+])
+.directive('mdSlider', SliderDirective)
+.directive('mdSliderContainer', SliderContainerDirective);
+
+/**
+ * @type {number} the page size used for stepping when page up/down keys are pressed.
+ */
+var stepPageSize = 10;
+/**
+ * @type {number} the multiplier applied to a step when the arrow key is pressed along with
+ * alt, meta, or ctrl.
+ */
+var modifierMultiplier = 4;
+
+/**
+ * @ngdoc directive
+ * @name mdSliderContainer
+ * @module material.components.slider
+ * @restrict E
+ * @description
+ * The `<md-slider-container>` can hold the slider with two other elements.
+ * In this case, the other elements are a `span` for the label and an `input` for displaying
+ * the model value.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-slider-container>
+ * <span>Red</span>
+ * <md-slider min="0" max="255" ng-model="color.red" aria-label="red" id="red-slider">
+ * </md-slider>
+ * <md-input-container>
+ * <input type="number" ng-model="color.red" aria-label="Red" aria-controls="red-slider">
+ * </md-input-container>
+ * </md-slider-container>
+ * </hljs>
+ */
+function SliderContainerDirective() {
+ return {
+ controller: function () {},
+ compile: function (elem) {
+ var slider = elem.find('md-slider');
+
+ if (!slider) {
+ return;
+ }
+
+ var vertical = slider.attr('md-vertical');
+
+ if (vertical !== undefined) {
+ elem.attr('md-vertical', '');
+ }
+
+ if (!slider.attr('flex')) {
+ slider.attr('flex', '');
+ }
+
+ return function postLink(scope, element, attr, ctrl) {
+ element.addClass('_md'); // private md component indicator for styling
+
+ // We have to manually stop the $watch on ngDisabled because it exists
+ // on the parent scope, and won't be automatically destroyed when
+ // the component is destroyed.
+ function setDisable(value) {
+ element.children().attr('disabled', value);
+ element.find('input').attr('disabled', value);
+ }
+
+ var stopDisabledWatch = angular.noop;
+
+ if (attr.disabled) {
+ setDisable(true);
+ }
+ else if (attr.ngDisabled) {
+ stopDisabledWatch = scope.$watch(attr.ngDisabled, function (value) {
+ setDisable(value);
+ });
+ }
+
+ scope.$on('$destroy', function () {
+ stopDisabledWatch();
+ });
+
+ var initialMaxWidth;
+
+ /**
+ * @param {number} length of the input's string value
+ */
+ ctrl.fitInputWidthToTextLength = function (length) {
+ var input = element[0].querySelector('md-input-container');
+
+ if (input) {
+ var computedStyle = getComputedStyle(input);
+ var minWidth = parseInt(computedStyle.minWidth);
+ var padding = parseInt(computedStyle.paddingLeft) + parseInt(computedStyle.paddingRight);
+
+ initialMaxWidth = initialMaxWidth || parseInt(computedStyle.maxWidth);
+ var newMaxWidth = Math.max(initialMaxWidth, minWidth + padding + (minWidth / 2 * length));
+
+ input.style.maxWidth = newMaxWidth + 'px';
+ }
+ };
+ };
+ }
+ };
+}
+
+/**
+ * @ngdoc directive
+ * @name mdSlider
+ * @module material.components.slider
+ * @restrict E
+ * @description
+ * The `<md-slider>` component allows the user to choose from a range of values.
+ *
+ * As per the [Material Design spec](https://material.io/archive/guidelines/style/color.html#color-color-system)
+ * the slider is in the accent color by default. The primary color palette may be used with
+ * the `md-primary` class.
+ *
+ * The slider has two modes:
+ * - "normal" mode where the user slides between a wide range of values
+ * - "discrete" mode where the user slides between only a few select values
+ *
+ * To enable discrete mode, add the `md-discrete` attribute to a slider
+ * and use the `step` attribute to change the distance between
+ * values the user is allowed to pick.
+ *
+ * When using the keyboard:
+ * - pressing the arrow keys will increase or decrease the slider's value by one step
+ * - holding the Meta, Control, or Alt key while pressing the arrow keys will
+ * move the slider four steps at a time
+ * - pressing the Home key will move the slider to the first allowed value
+ * - pressing the End key will move the slider to the last allowed value
+ * - pressing the Page Up key will increase the slider value by ten
+ * - pressing the Page Down key will decrease the slider value by ten
+ *
+ * @usage
+ * <h4>Normal Mode</h4>
+ * <hljs lang="html">
+ * <md-slider ng-model="myValue" min="5" max="500">
+ * </md-slider>
+ * </hljs>
+ * <h4>Discrete Mode</h4>
+ * <hljs lang="html">
+ * <md-slider md-discrete ng-model="myDiscreteValue" step="10" min="10" max="130">
+ * </md-slider>
+ * </hljs>
+ * <h4>Invert Mode</h4>
+ * <hljs lang="html">
+ * <md-slider md-invert ng-model="myValue" step="10" min="10" max="130">
+ * </md-slider>
+ * </hljs>
+ *
+ * @param {expression} ng-model Assignable angular expression to be data-bound.
+ * The expression should evaluate to a `number`.
+ * @param {expression=} ng-disabled If this expression evaluates as truthy, the slider will be
+ * disabled.
+ * @param {expression=} ng-readonly If this expression evaluates as truthy, the slider will be in
+ * read only mode.
+ * @param {boolean=} md-discrete If this attribute exists during initialization, enable discrete
+ * mode. Defaults to `false`.
+ * @param {boolean=} md-vertical If this attribute exists during initialization, enable vertical
+ * orientation mode. Defaults to `false`.
+ * @param {boolean=} md-invert If this attribute exists during initialization, enable inverted mode.
+ * Defaults to `false`.
+ * @param {number=} step The distance between values the user is allowed to pick. Defaults to `1`.
+ * @param {number=} min The minimum value the user is allowed to pick. Defaults to `0`.
+ * @param {number=} max The maximum value the user is allowed to pick. Defaults to `100`.
+ * @param {number=} round The amount of numbers after the decimal point. The maximum is 6 to
+ * prevent scientific notation. Defaults to `3`.
+ */
+function SliderDirective($$rAF, $window, $mdAria, $mdUtil, $mdConstant, $mdTheming, $mdGesture,
+ $parse, $log, $timeout) {
+ return {
+ scope: {},
+ require: ['?ngModel', '?^mdSliderContainer'],
+ template:
+ '<div class="md-slider-wrapper">' +
+ '<div class="md-slider-content">' +
+ '<div class="md-track-container">' +
+ '<div class="md-track"></div>' +
+ '<div class="md-track md-track-fill"></div>' +
+ '<div class="md-track-ticks"></div>' +
+ '</div>' +
+ '<div class="md-thumb-container">' +
+ '<div class="md-thumb"></div>' +
+ '<div class="md-focus-thumb"></div>' +
+ '<div class="md-focus-ring"></div>' +
+ '<div class="md-sign">' +
+ '<span class="md-thumb-text"></span>' +
+ '</div>' +
+ '<div class="md-disabled-thumb"></div>' +
+ '</div>' +
+ '</div>' +
+ '</div>',
+ compile: compile
+ };
+
+ // **********************************************************
+ // Private Methods
+ // **********************************************************
+
+ function compile (tElement, tAttrs) {
+ var wrapper = angular.element(tElement[0].getElementsByClassName('md-slider-wrapper'));
+
+ var tabIndex = tAttrs.tabindex || 0;
+ wrapper.attr('tabindex', tabIndex);
+
+ if (tAttrs.disabled || tAttrs.ngDisabled) wrapper.attr('tabindex', -1);
+
+ wrapper.attr('role', 'slider');
+
+ $mdAria.expect(tElement, 'aria-label');
+
+ return postLink;
+ }
+
+ function postLink(scope, element, attr, ctrls) {
+ $mdTheming(element);
+ var ngModelCtrl = ctrls[0] || {
+ // Mock ngModelController if it doesn't exist to give us
+ // the minimum functionality needed
+ $setViewValue: function(val) {
+ this.$viewValue = val;
+ this.$viewChangeListeners.forEach(function(cb) { cb(); });
+ },
+ $parsers: [],
+ $formatters: [],
+ $viewChangeListeners: []
+ };
+
+ var containerCtrl = ctrls[1];
+ var container = angular.element($mdUtil.getClosest(element, '_md-slider-container', true));
+ var isDisabled = attr.ngDisabled ? angular.bind(null, $parse(attr.ngDisabled), scope.$parent) : function () {
+ return element[0].hasAttribute('disabled');
+ };
+
+ var thumb = angular.element(element[0].querySelector('.md-thumb'));
+ var thumbText = angular.element(element[0].querySelector('.md-thumb-text'));
+ var thumbContainer = thumb.parent();
+ var trackContainer = angular.element(element[0].querySelector('.md-track-container'));
+ var activeTrack = angular.element(element[0].querySelector('.md-track-fill'));
+ var tickContainer = angular.element(element[0].querySelector('.md-track-ticks'));
+ var wrapper = angular.element(element[0].getElementsByClassName('md-slider-wrapper'));
+ var content = angular.element(element[0].getElementsByClassName('md-slider-content'));
+ var throttledRefreshDimensions = $mdUtil.throttle(refreshSliderDimensions, 5000);
+
+ // Default values, overridable by attrs
+ var DEFAULT_ROUND = 3;
+ var vertical = angular.isDefined(attr.mdVertical);
+ var discrete = angular.isDefined(attr.mdDiscrete);
+ var invert = angular.isDefined(attr.mdInvert);
+ angular.isDefined(attr.min) ? attr.$observe('min', updateMin) : updateMin(0);
+ angular.isDefined(attr.max) ? attr.$observe('max', updateMax) : updateMax(100);
+ angular.isDefined(attr.step)? attr.$observe('step', updateStep) : updateStep(1);
+ angular.isDefined(attr.round)? attr.$observe('round', updateRound) : updateRound(DEFAULT_ROUND);
+
+ // We have to manually stop the $watch on ngDisabled because it exists
+ // on the parent scope, and won't be automatically destroyed when
+ // the component is destroyed.
+ var stopDisabledWatch = angular.noop;
+ if (attr.ngDisabled) {
+ stopDisabledWatch = scope.$parent.$watch(attr.ngDisabled, updateAriaDisabled);
+ }
+
+ $mdGesture.register(wrapper, 'drag', { horizontal: !vertical });
+
+ scope.mouseActive = false;
+
+ wrapper
+ .on('keydown', keydownListener)
+ .on('mousedown', mouseDownListener)
+ .on('focus', focusListener)
+ .on('blur', blurListener)
+ .on('$md.pressdown', onPressDown)
+ .on('$md.pressup', onPressUp)
+ .on('$md.dragstart', onDragStart)
+ .on('$md.drag', onDrag)
+ .on('$md.dragend', onDragEnd);
+
+ // On resize, recalculate the slider's dimensions and re-render
+ function updateAll() {
+ refreshSliderDimensions();
+ ngModelRender();
+ }
+ setTimeout(updateAll, 0);
+
+ var debouncedUpdateAll = $$rAF.throttle(updateAll);
+ angular.element($window).on('resize', debouncedUpdateAll);
+
+ scope.$on('$destroy', function() {
+ angular.element($window).off('resize', debouncedUpdateAll);
+ });
+
+ ngModelCtrl.$render = ngModelRender;
+ ngModelCtrl.$viewChangeListeners.push(ngModelRender);
+ ngModelCtrl.$formatters.push(minMaxValidator);
+ ngModelCtrl.$formatters.push(stepValidator);
+
+ /**
+ * Attributes
+ */
+ var min;
+ var max;
+ var step;
+ var round;
+ function updateMin(value) {
+ min = parseFloat(value);
+ ngModelCtrl.$viewValue = minMaxValidator(ngModelCtrl.$modelValue, min, max);
+ wrapper.attr('aria-valuemin', value);
+ updateAll();
+ }
+ function updateMax(value) {
+ max = parseFloat(value);
+ ngModelCtrl.$viewValue = minMaxValidator(ngModelCtrl.$modelValue, min, max);
+ wrapper.attr('aria-valuemax', value);
+ updateAll();
+ }
+ function updateStep(value) {
+ step = parseFloat(value);
+ }
+ function updateRound(value) {
+ // Set max round digits to 6, after 6 the input uses scientific notation
+ round = minMaxValidator(parseInt(value), 0, 6);
+ }
+ function updateAriaDisabled() {
+ element.attr('aria-disabled', !!isDisabled());
+ }
+
+ // Draw the ticks with canvas.
+ // The alternative to drawing ticks with canvas is to draw one element for each tick,
+ // which could quickly become a performance bottleneck.
+ var tickCanvas, tickCtx;
+ function redrawTicks() {
+ if (!discrete || isDisabled()) return;
+ if (angular.isUndefined(step)) return;
+
+ if (step <= 0) {
+ var msg = 'Slider step value must be greater than zero when in discrete mode';
+ $log.error(msg);
+ throw new Error(msg);
+ }
+
+ var numSteps = Math.floor((max - min) / step);
+ if (!tickCanvas) {
+ tickCanvas = angular.element('<canvas>').css('position', 'absolute');
+ tickContainer.append(tickCanvas);
+
+ tickCtx = tickCanvas[0].getContext('2d');
+ }
+
+ var dimensions = getSliderDimensions();
+
+ // If `dimensions` doesn't have height and width it might be the first attempt so we will refresh dimensions
+ if (dimensions && !dimensions.height && !dimensions.width) {
+ refreshSliderDimensions();
+ dimensions = sliderDimensions;
+ }
+
+ tickCanvas[0].width = dimensions.width;
+ tickCanvas[0].height = dimensions.height;
+
+ var distance;
+ for (var i = 0; i <= numSteps; i++) {
+ var trackTicksStyle = $window.getComputedStyle(tickContainer[0]);
+ tickCtx.fillStyle = trackTicksStyle.color || 'black';
+
+ distance = Math.floor((vertical ? dimensions.height : dimensions.width) * (i / numSteps));
+
+ tickCtx.fillRect(vertical ? 0 : distance - 1,
+ vertical ? distance - 1 : 0,
+ vertical ? dimensions.width : 2,
+ vertical ? 2 : dimensions.height);
+ }
+ }
+
+ function clearTicks() {
+ if (tickCanvas && tickCtx) {
+ var dimensions = getSliderDimensions();
+ tickCtx.clearRect(0, 0, dimensions.width, dimensions.height);
+ }
+ }
+
+ /**
+ * Refreshing Dimensions
+ */
+ var sliderDimensions = {};
+ refreshSliderDimensions();
+ function refreshSliderDimensions() {
+ sliderDimensions = trackContainer[0].getBoundingClientRect();
+ }
+ function getSliderDimensions() {
+ throttledRefreshDimensions();
+ return sliderDimensions;
+ }
+
+ /**
+ * left/right/up/down arrow listener
+ * @param {!KeyboardEvent} ev
+ */
+ function keydownListener(ev) {
+ if (isDisabled()) return;
+ var keyCodes = $mdConstant.KEY_CODE;
+
+ var changeAmount;
+ switch (ev.keyCode) {
+ case keyCodes.DOWN_ARROW:
+ case keyCodes.LEFT_ARROW:
+ ev.preventDefault();
+ changeAmount = -step;
+ break;
+ case keyCodes.UP_ARROW:
+ case keyCodes.RIGHT_ARROW:
+ ev.preventDefault();
+ changeAmount = step;
+ break;
+ case keyCodes.PAGE_DOWN:
+ ev.preventDefault();
+ changeAmount = -step * stepPageSize;
+ break;
+ case keyCodes.PAGE_UP:
+ ev.preventDefault();
+ changeAmount = step * stepPageSize;
+ break;
+ case keyCodes.HOME:
+ ev.preventDefault();
+ ev.stopPropagation();
+ updateValue(min);
+ break;
+ case keyCodes.END:
+ ev.preventDefault();
+ ev.stopPropagation();
+ updateValue(max);
+ break;
+ }
+ if (changeAmount) {
+ changeAmount = invert ? -changeAmount : changeAmount;
+ if (ev.metaKey || ev.ctrlKey || ev.altKey) {
+ changeAmount *= modifierMultiplier;
+ }
+ ev.preventDefault();
+ ev.stopPropagation();
+ updateValue(ngModelCtrl.$viewValue + changeAmount);
+ }
+ }
+
+ /**
+ * @param value new slider value used for setting the model value
+ */
+ function updateValue(value) {
+ scope.$evalAsync(function() {
+ setModelValue(value);
+ });
+ }
+
+ function mouseDownListener() {
+ redrawTicks();
+
+ scope.mouseActive = true;
+ wrapper.removeClass('md-focused');
+
+ $timeout(function() {
+ scope.mouseActive = false;
+ }, 100);
+ }
+
+ function focusListener() {
+ if (scope.mouseActive === false) {
+ wrapper.addClass('md-focused');
+ }
+ }
+
+ function blurListener() {
+ wrapper.removeClass('md-focused');
+ element.removeClass('md-active');
+ clearTicks();
+ }
+
+ /**
+ * ngModel setters and validators
+ */
+ function setModelValue(value) {
+ ngModelCtrl.$setViewValue(minMaxValidator(stepValidator(value)));
+ }
+ function ngModelRender() {
+ if (isNaN(ngModelCtrl.$viewValue)) {
+ ngModelCtrl.$viewValue = ngModelCtrl.$modelValue;
+ }
+
+ ngModelCtrl.$viewValue = minMaxValidator(ngModelCtrl.$viewValue);
+
+ var percent = valueToPercent(ngModelCtrl.$viewValue);
+ scope.modelValue = ngModelCtrl.$viewValue;
+ wrapper.attr('aria-valuenow', ngModelCtrl.$viewValue);
+ setSliderPercent(percent);
+ thumbText.text(ngModelCtrl.$viewValue);
+ }
+
+ function minMaxValidator(value, minValue, maxValue) {
+ if (angular.isNumber(value)) {
+ minValue = angular.isNumber(minValue) ? minValue : min;
+ maxValue = angular.isNumber(maxValue) ? maxValue : max;
+
+ return Math.max(minValue, Math.min(maxValue, value));
+ }
+ }
+
+ function stepValidator(value) {
+ if (angular.isNumber(value)) {
+ var formattedValue = (Math.round((value - min) / step) * step + min);
+ formattedValue = (Math.round(formattedValue * Math.pow(10, round)) / Math.pow(10, round));
+
+ if (containerCtrl && containerCtrl.fitInputWidthToTextLength) {
+ $mdUtil.debounce(function () {
+ containerCtrl.fitInputWidthToTextLength(formattedValue.toString().length);
+ }, 100)();
+ }
+
+ return formattedValue;
+ }
+ }
+
+ /**
+ * @param {number} percent 0-1
+ */
+ function setSliderPercent(percent) {
+
+ percent = clamp(percent);
+
+ var thumbPosition = (percent * 100) + '%';
+ var activeTrackPercent = invert ? (1 - percent) * 100 + '%' : thumbPosition;
+
+ if (vertical) {
+ thumbContainer.css('bottom', thumbPosition);
+ }
+ else {
+ $mdUtil.bidiProperty(thumbContainer, 'left', 'right', thumbPosition);
+ }
+
+
+ activeTrack.css(vertical ? 'height' : 'width', activeTrackPercent);
+
+ element.toggleClass((invert ? 'md-max' : 'md-min'), percent === 0);
+ element.toggleClass((invert ? 'md-min' : 'md-max'), percent === 1);
+ }
+
+ /**
+ * Slide listeners
+ */
+ var isDragging = false;
+
+ function onPressDown(ev) {
+ if (isDisabled()) return;
+
+ element.addClass('md-active');
+ element[0].focus();
+ refreshSliderDimensions();
+
+ var exactVal = percentToValue(positionToPercent(vertical ? ev.srcEvent.clientY : ev.srcEvent.clientX));
+ var closestVal = minMaxValidator(stepValidator(exactVal));
+ scope.$apply(function() {
+ setModelValue(closestVal);
+ setSliderPercent(valueToPercent(closestVal));
+ });
+ }
+ function onPressUp(ev) {
+ if (isDisabled()) return;
+
+ element.removeClass('md-dragging');
+
+ var exactVal = percentToValue(positionToPercent(vertical ? ev.srcEvent.clientY : ev.srcEvent.clientX));
+ var closestVal = minMaxValidator(stepValidator(exactVal));
+ scope.$apply(function() {
+ setModelValue(closestVal);
+ ngModelRender();
+ });
+ }
+ function onDragStart(ev) {
+ if (isDisabled()) return;
+ isDragging = true;
+
+ ev.stopPropagation();
+
+ element.addClass('md-dragging');
+ setSliderFromEvent(ev);
+ }
+ function onDrag(ev) {
+ if (!isDragging) return;
+ ev.stopPropagation();
+ setSliderFromEvent(ev);
+ }
+ function onDragEnd(ev) {
+ if (!isDragging) return;
+ ev.stopPropagation();
+ isDragging = false;
+ }
+
+ function setSliderFromEvent(ev) {
+ // While panning discrete, update only the
+ // visual positioning but not the model value.
+ if (discrete) adjustThumbPosition(vertical ? ev.srcEvent.clientY : ev.srcEvent.clientX);
+ else doSlide(vertical ? ev.srcEvent.clientY : ev.srcEvent.clientX);
+ }
+
+ /**
+ * Slide the UI by changing the model value
+ * @param x
+ */
+ function doSlide(x) {
+ scope.$evalAsync(function() {
+ setModelValue(percentToValue(positionToPercent(x)));
+ });
+ }
+
+ /**
+ * Slide the UI without changing the model (while dragging/panning)
+ * @param x
+ */
+ function adjustThumbPosition(x) {
+ var exactVal = percentToValue(positionToPercent(x));
+ var closestVal = minMaxValidator(stepValidator(exactVal));
+ setSliderPercent(positionToPercent(x));
+ thumbText.text(closestVal);
+ }
+
+ /**
+ * Clamps the value to be between 0 and 1.
+ * @param {number} value The value to clamp.
+ * @returns {number}
+ */
+ function clamp(value) {
+ return Math.max(0, Math.min(value || 0, 1));
+ }
+
+ /**
+ * Convert position on slider to percentage value of offset from beginning...
+ * @param position
+ * @returns {number}
+ */
+ function positionToPercent(position) {
+ var offset = vertical ? sliderDimensions.top : sliderDimensions.left;
+ var size = vertical ? sliderDimensions.height : sliderDimensions.width;
+ var calc = (position - offset) / size;
+
+ if (!vertical && $mdUtil.isRtl(attr)) {
+ calc = 1 - calc;
+ }
+
+ return Math.max(0, Math.min(1, vertical ? 1 - calc : calc));
+ }
+
+ /**
+ * Convert percentage offset on slide to equivalent model value
+ * @param percent
+ * @returns {*}
+ */
+ function percentToValue(percent) {
+ var adjustedPercent = invert ? (1 - percent) : percent;
+ return (min + adjustedPercent * (max - min));
+ }
+
+ function valueToPercent(val) {
+ var percent = (val - min) / (max - min);
+ return invert ? (1 - percent) : percent;
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.sticky
+ * @description
+ * Sticky effects for md.
+ */
+MdSticky.$inject = ["$mdConstant", "$$rAF", "$mdUtil", "$compile"];
+angular
+ .module('material.components.sticky', [
+ 'material.core',
+ 'material.components.content'
+ ])
+ .factory('$mdSticky', MdSticky);
+
+/**
+ * @ngdoc service
+ * @name $mdSticky
+ * @module material.components.sticky
+ *
+ * @description
+ * The `$mdSticky` service provides the capability to make elements sticky, even when the browser
+ * does not support `position: sticky`.
+ *
+ * Whenever the current browser supports stickiness natively, the `$mdSticky` service will leverage
+ * the native browser's sticky functionality.
+ *
+ * By default the `$mdSticky` service compiles the cloned element, when not specified through the
+ * `stickyClone` parameter, in the same scope as the actual element lives.
+ *
+ * @usage
+ * <hljs lang="js">
+ * angular.module('myModule')
+ * .directive('stickyText', function($mdSticky) {
+ * return {
+ * restrict: 'E',
+ * template: '<span>Sticky Text</span>',
+ * link: function(scope, element) {
+ * $mdSticky(scope, element);
+ * }
+ * };
+ * });
+ * </hljs>
+ *
+ * <h3>Notes</h3>
+ * When using an element which contains a compiled directive that changes the DOM structure
+ * during compilation, you should compile the clone yourself.
+ *
+ * An example of this usage can be found below:
+ * <hljs lang="js">
+ * angular.module('myModule')
+ * .directive('stickySelect', function($mdSticky, $compile) {
+ * var SELECT_TEMPLATE =
+ * '<md-select ng-model="selected">' +
+ * ' <md-option>Option 1</md-option>' +
+ * '</md-select>';
+ *
+ * return {
+ * restrict: 'E',
+ * replace: true,
+ * template: SELECT_TEMPLATE,
+ * link: function(scope, element) {
+ * $mdSticky(scope, element, $compile(SELECT_TEMPLATE)(scope));
+ * }
+ * };
+ * });
+ * </hljs>
+ *
+ * @returns {function(IScope, JQLite, ITemplateLinkingFunction=): void} `$mdSticky` returns a
+ * function that takes three arguments:
+ * - `scope`: the scope to use when compiling the clone and listening for the `$destroy` event,
+ * which triggers removal of the clone
+ * - `element`: the element that will be 'sticky'
+ * - `stickyClone`: An optional clone of the element (returned from AngularJS'
+ * [$compile service](https://docs.angularjs.org/api/ng/service/$compile#usage)),
+ * that will be shown when the user starts scrolling past the original element. If not
+ * provided, the result of `element.clone()` will be used and compiled in the given scope.
+ */
+function MdSticky($mdConstant, $$rAF, $mdUtil, $compile) {
+
+ var browserStickySupport = $mdUtil.checkStickySupport();
+
+ /**
+ * Registers an element as sticky, used internally by directives to register themselves.
+ */
+ return function registerStickyElement(scope, element, stickyClone) {
+ var contentCtrl = element.controller('mdContent');
+ if (!contentCtrl) return;
+
+ if (browserStickySupport) {
+ element.css({
+ position: browserStickySupport,
+ top: 0,
+ 'z-index': 2
+ });
+ } else {
+ var $$sticky = contentCtrl.$element.data('$$sticky');
+ if (!$$sticky) {
+ $$sticky = setupSticky(contentCtrl);
+ contentCtrl.$element.data('$$sticky', $$sticky);
+ }
+
+ // Compile our cloned element, when cloned in this service, into the given scope.
+ var cloneElement = stickyClone || $compile(element.clone())(scope);
+
+ var deregister = $$sticky.add(element, cloneElement);
+ scope.$on('$destroy', deregister);
+ }
+ };
+
+ function setupSticky(contentCtrl) {
+ var contentEl = contentCtrl.$element;
+
+ // Refresh elements is very expensive, so we use the debounced
+ // version when possible.
+ var debouncedRefreshElements = $$rAF.throttle(refreshElements);
+
+ // setupAugmentedScrollEvents gives us `$scrollstart` and `$scroll`,
+ // more reliable than `scroll` on android.
+ setupAugmentedScrollEvents(contentEl);
+ contentEl.on('$scrollstart', debouncedRefreshElements);
+ contentEl.on('$scroll', onScroll);
+
+ var self;
+ return self = {
+ prev: null,
+ current: null, // the currently stickied item
+ next: null,
+ items: [],
+ add: add,
+ refreshElements: refreshElements
+ };
+
+ /***************
+ * Public
+ ***************/
+ // Add an element and its sticky clone to this content's sticky collection
+ function add(element, stickyClone) {
+ stickyClone.addClass('md-sticky-clone');
+
+ var item = {
+ element: element,
+ clone: stickyClone
+ };
+ self.items.push(item);
+
+ $mdUtil.nextTick(function() {
+ contentEl.prepend(item.clone);
+ });
+
+ debouncedRefreshElements();
+
+ return function remove() {
+ self.items.forEach(function(item, index) {
+ if (item.element[0] === element[0]) {
+ self.items.splice(index, 1);
+ item.clone.remove();
+ }
+ });
+ debouncedRefreshElements();
+ };
+ }
+
+ function refreshElements() {
+ // Sort our collection of elements by their current position in the DOM.
+ // We need to do this because our elements' order of being added may not
+ // be the same as their order of display.
+ self.items.forEach(refreshPosition);
+ self.items = self.items.sort(function(a, b) {
+ return a.top < b.top ? -1 : 1;
+ });
+
+ // Find which item in the list should be active,
+ // based upon the content's current scroll position
+ var item;
+ var currentScrollTop = contentEl.prop('scrollTop');
+ for (var i = self.items.length - 1; i >= 0; i--) {
+ if (currentScrollTop > self.items[i].top) {
+ item = self.items[i];
+ break;
+ }
+ }
+ setCurrentItem(item);
+ }
+
+ /***************
+ * Private
+ ***************/
+
+ // Find the `top` of an item relative to the content element,
+ // and also the height.
+ function refreshPosition(item) {
+ // Find the top of an item by adding to the offsetHeight until we reach the
+ // content element.
+ var current = item.element[0];
+ item.top = 0;
+ item.left = 0;
+ item.right = 0;
+ while (current && current !== contentEl[0]) {
+ item.top += current.offsetTop;
+ item.left += current.offsetLeft;
+ if (current.offsetParent) {
+ // Compute offsetRight
+ item.right += current.offsetParent.offsetWidth - current.offsetWidth - current.offsetLeft;
+ }
+ current = current.offsetParent;
+ }
+ item.height = item.element.prop('offsetHeight');
+
+ var defaultVal = $mdUtil.floatingScrollbars() ? '0' : undefined;
+ $mdUtil.bidi(item.clone, 'margin-left', item.left, defaultVal);
+ $mdUtil.bidi(item.clone, 'margin-right', defaultVal, item.right);
+ }
+
+ // As we scroll, push in and select the correct sticky element.
+ function onScroll() {
+ var scrollTop = contentEl.prop('scrollTop');
+ var isScrollingDown = scrollTop > (onScroll.prevScrollTop || 0);
+
+ // Store the previous scroll so we know which direction we are scrolling
+ onScroll.prevScrollTop = scrollTop;
+
+ //
+ // AT TOP (not scrolling)
+ //
+ if (scrollTop === 0) {
+ // If we're at the top, just clear the current item and return
+ setCurrentItem(null);
+ return;
+ }
+
+ //
+ // SCROLLING DOWN (going towards the next item)
+ //
+ if (isScrollingDown) {
+
+ // If we've scrolled down past the next item's position, sticky it and return
+ if (self.next && self.next.top <= scrollTop) {
+ setCurrentItem(self.next);
+ return;
+ }
+
+ // If the next item is close to the current one, push the current one up out of the way
+ if (self.current && self.next && self.next.top - scrollTop <= self.next.height) {
+ translate(self.current, scrollTop + (self.next.top - self.next.height - scrollTop));
+ return;
+ }
+ }
+
+ //
+ // SCROLLING UP (not at the top & not scrolling down; must be scrolling up)
+ //
+ if (!isScrollingDown) {
+
+ // If we've scrolled up past the previous item's position, sticky it and return
+ if (self.current && self.prev && scrollTop < self.current.top) {
+ setCurrentItem(self.prev);
+ return;
+ }
+
+ // If the next item is close to the current one, pull the current one down into view
+ if (self.next && self.current && (scrollTop >= (self.next.top - self.current.height))) {
+ translate(self.current, scrollTop + (self.next.top - scrollTop - self.current.height));
+ return;
+ }
+ }
+
+ //
+ // Otherwise, just move the current item to the proper place (scrolling up or down)
+ //
+ if (self.current) {
+ translate(self.current, scrollTop);
+ }
+ }
+
+ function setCurrentItem(item) {
+ if (self.current === item) return;
+ // Deactivate currently active item
+ if (self.current) {
+ translate(self.current, null);
+ setStickyState(self.current, null);
+ }
+
+ // Activate new item if given
+ if (item) {
+ setStickyState(item, 'active');
+ }
+
+ self.current = item;
+ var index = self.items.indexOf(item);
+ // If index === -1, index + 1 = 0. It works out.
+ self.next = self.items[index + 1];
+ self.prev = self.items[index - 1];
+ setStickyState(self.next, 'next');
+ setStickyState(self.prev, 'prev');
+ }
+
+ function setStickyState(item, state) {
+ if (!item || item.state === state) return;
+ if (item.state) {
+ item.clone.attr('sticky-prev-state', item.state);
+ item.element.attr('sticky-prev-state', item.state);
+ }
+ item.clone.attr('sticky-state', state);
+ item.element.attr('sticky-state', state);
+ item.state = state;
+ }
+
+ function translate(item, amount) {
+ if (!item) return;
+ if (amount === null || amount === undefined) {
+ if (item.translateY) {
+ item.translateY = null;
+ item.clone.css($mdConstant.CSS.TRANSFORM, '');
+ }
+ } else {
+ item.translateY = amount;
+
+ $mdUtil.bidi(item.clone, $mdConstant.CSS.TRANSFORM,
+ 'translate3d(' + item.left + 'px,' + amount + 'px,0)',
+ 'translateY(' + amount + 'px)'
+ );
+ }
+ }
+ }
+
+
+ // Android 4.4 don't accurately give scroll events.
+ // To fix this problem, we setup a fake scroll event. We say:
+ // > If a scroll or touchmove event has happened in the last DELAY milliseconds,
+ // then send a `$scroll` event every animationFrame.
+ // Additionally, we add $scrollstart and $scrollend events.
+ function setupAugmentedScrollEvents(element) {
+ var SCROLL_END_DELAY = 200;
+ var isScrolling;
+ var lastScrollTime;
+ element.on('scroll touchmove', function() {
+ if (!isScrolling) {
+ isScrolling = true;
+ $$rAF.throttle(loopScrollEvent);
+ element.triggerHandler('$scrollstart');
+ }
+ element.triggerHandler('$scroll');
+ lastScrollTime = +$mdUtil.now();
+ });
+
+ function loopScrollEvent() {
+ if (+$mdUtil.now() - lastScrollTime > SCROLL_END_DELAY) {
+ isScrolling = false;
+ element.triggerHandler('$scrollend');
+ } else {
+ element.triggerHandler('$scroll');
+ $$rAF.throttle(loopScrollEvent);
+ }
+ }
+ }
+
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.subheader
+ * @description
+ * SubHeader module
+ *
+ * Subheaders are special list tiles that delineate distinct sections of a
+ * list or grid list and are typically related to the current filtering or
+ * sorting criteria. Subheader tiles are either displayed inline with tiles or
+ * can be associated with content, for example, in an adjacent column.
+ *
+ * Upon scrolling, subheaders remain pinned to the top of the screen and remain
+ * pinned until pushed on or off screen by the next subheader. @see [Material
+ * Design Specifications](https://material.io/archive/guidelines/components/subheaders.html)
+ *
+ * > To improve the visual grouping of content, use the system color for your subheaders.
+ *
+ */
+MdSubheaderDirective.$inject = ["$mdSticky", "$compile", "$mdTheming", "$mdUtil", "$mdAria"];
+angular
+ .module('material.components.subheader', [
+ 'material.core',
+ 'material.components.sticky'
+ ])
+ .directive('mdSubheader', MdSubheaderDirective);
+
+/**
+ * @ngdoc directive
+ * @name mdSubheader
+ * @module material.components.subheader
+ *
+ * @restrict E
+ *
+ * @description
+ * The `md-subheader` directive creates a sticky subheader for a section.
+ *
+ * Developers are able to disable the stickiness of the subheader by using the following markup
+ *
+ * <hljs lang="html">
+ * <md-subheader class="md-no-sticky">Not Sticky</md-subheader>
+ * </hljs>
+ *
+ * ### Notes
+ * - The `md-subheader` directive uses the <a ng-href="api/service/$mdSticky">$mdSticky</a> service
+ * to make the subheader sticky.
+ *
+ * > Whenever the current browser doesn't support stickiness natively, the subheader
+ * will be compiled twice to create a sticky clone of the subheader.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-subheader>Online Friends</md-subheader>
+ * </hljs>
+ */
+
+function MdSubheaderDirective($mdSticky, $compile, $mdTheming, $mdUtil, $mdAria) {
+ return {
+ restrict: 'E',
+ replace: true,
+ transclude: true,
+ template: (
+ '<div class="md-subheader _md">' +
+ ' <div class="md-subheader-inner">' +
+ ' <div class="md-subheader-content"></div>' +
+ ' </div>' +
+ '</div>'
+ ),
+ link: function postLink(scope, element, attr, controllers, transclude) {
+ $mdTheming(element);
+ element.addClass('_md');
+
+ // Remove the ngRepeat attribute from the root element, because we don't want to compile
+ // the ngRepeat for the sticky clone again.
+ $mdUtil.prefixer().removeAttribute(element, 'ng-repeat');
+
+ var outerHTML = element[0].outerHTML;
+
+ function getContent(el) {
+ return angular.element(el[0].querySelector('.md-subheader-content'));
+ }
+
+ // Set the ARIA attributes on the original element since it keeps it's original place in
+ // the DOM, whereas the clones are in reverse order. Should be done after the outerHTML,
+ // in order to avoid having multiple element be marked as headers.
+ attr.$set('role', 'heading');
+ $mdAria.expect(element, 'aria-level', '2');
+
+ // Transclude the user-given contents of the subheader
+ // the conventional way.
+ transclude(scope, function(clone) {
+ getContent(element).append(clone);
+ });
+
+ // Create another clone, that uses the outer and inner contents
+ // of the element, that will be 'stickied' as the user scrolls.
+ if (!element.hasClass('md-no-sticky')) {
+ transclude(scope, function(clone) {
+ // If the user adds an ng-if or ng-repeat directly to the md-subheader element, the
+ // compiled clone below will only be a comment tag (since they replace their elements with
+ // a comment) which cannot be properly passed to the $mdSticky; so we wrap it in our own
+ // DIV to ensure we have something $mdSticky can use
+ var wrapper = $compile('<div class="md-subheader-wrapper" aria-hidden="true">' + outerHTML + '</div>')(scope);
+
+ // Delay initialization until after any `ng-if`/`ng-repeat`/etc has finished before
+ // attempting to create the clone
+ $mdUtil.nextTick(function() {
+ // Append our transcluded clone into the wrapper.
+ // We don't have to recompile the element again, because the clone is already
+ // compiled in it's transclusion scope. If we recompile the outerHTML of the new clone, we would lose
+ // our ngIf's and other previous registered bindings / properties.
+ getContent(wrapper).append(clone);
+ });
+
+ // Make the element sticky and provide the stickyClone our self, to avoid recompilation of the subheader
+ // element.
+ $mdSticky(scope, element, wrapper);
+ });
+ }
+ }
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.swipe
+ * @description Swipe module!
+ */
+/**
+ * @ngdoc directive
+ * @module material.components.swipe
+ * @name mdSwipeLeft
+ *
+ * @restrict A
+ *
+ * @description
+ * The md-swipe-left directive allows you to specify custom behavior when an element is swiped
+ * left.
+ *
+ * ### Notes
+ * - The `$event.currentTarget` of the swiped element will be `null`, but you can get a
+ * reference to the element that actually holds the `md-swipe-left` directive by using
+ * `$target.current`
+ *
+ * > You can see this in action on the <a ng-href="demo/swipe">demo page</a> (Look at the Developer
+ * Tools console while swiping).
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div md-swipe-left="onSwipeLeft($event, $target)">Swipe me left!</div>
+ * </hljs>
+ */
+/**
+ * @ngdoc directive
+ * @module material.components.swipe
+ * @name mdSwipeRight
+ *
+ * @restrict A
+ *
+ * @description
+ * The md-swipe-right directive allows you to specify custom behavior when an element is swiped
+ * right.
+ *
+ * ### Notes
+ * - The `$event.currentTarget` of the swiped element will be `null`, but you can get a
+ * reference to the element that actually holds the `md-swipe-right` directive by using
+ * `$target.current`
+ *
+ * > You can see this in action on the <a ng-href="demo/swipe">demo page</a> (Look at the Developer
+ * Tools console while swiping).
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div md-swipe-right="onSwipeRight($event, $target)">Swipe me right!</div>
+ * </hljs>
+ */
+/**
+ * @ngdoc directive
+ * @module material.components.swipe
+ * @name mdSwipeUp
+ *
+ * @restrict A
+ *
+ * @description
+ * The md-swipe-up directive allows you to specify custom behavior when an element is swiped
+ * up.
+ *
+ * ### Notes
+ * - The `$event.currentTarget` of the swiped element will be `null`, but you can get a
+ * reference to the element that actually holds the `md-swipe-up` directive by using
+ * `$target.current`
+ *
+ * > You can see this in action on the <a ng-href="demo/swipe">demo page</a> (Look at the Developer
+ * Tools console while swiping).
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div md-swipe-up="onSwipeUp($event, $target)">Swipe me up!</div>
+ * </hljs>
+ */
+/**
+ * @ngdoc directive
+ * @module material.components.swipe
+ * @name mdSwipeDown
+ *
+ * @restrict A
+ *
+ * @description
+ * The md-swipe-down directive allows you to specify custom behavior when an element is swiped
+ * down.
+ *
+ * ### Notes
+ * - The `$event.currentTarget` of the swiped element will be `null`, but you can get a
+ * reference to the element that actually holds the `md-swipe-down` directive by using
+ * `$target.current`
+ *
+ * > You can see this in action on the <a ng-href="demo/swipe">demo page</a> (Look at the Developer
+ * Tools console while swiping).
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div md-swipe-down="onSwipeDown($event, $target)">Swipe me down!</div>
+ * </hljs>
+ */
+
+angular.module('material.components.swipe', ['material.core'])
+ .directive('mdSwipeLeft', getDirective('SwipeLeft'))
+ .directive('mdSwipeRight', getDirective('SwipeRight'))
+ .directive('mdSwipeUp', getDirective('SwipeUp'))
+ .directive('mdSwipeDown', getDirective('SwipeDown'));
+
+function getDirective(name) {
+ DirectiveFactory.$inject = ["$parse"];
+ var directiveName = 'md' + name;
+ var eventName = '$md.' + name.toLowerCase();
+
+ return DirectiveFactory;
+
+ /* @ngInject */
+ function DirectiveFactory($parse) {
+ return { restrict: 'A', link: postLink };
+ function postLink(scope, element, attr) {
+ var fn = $parse(attr[directiveName]);
+ element.on(eventName, function(ev) {
+ var currentTarget = ev.currentTarget;
+ scope.$applyAsync(function() { fn(scope, { $event: ev, $target: { current: currentTarget } }); });
+ });
+ }
+ }
+}
+
+
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.switch
+ */
+
+MdSwitch.$inject = ["mdCheckboxDirective", "$mdUtil", "$mdConstant", "$parse", "$$rAF", "$mdGesture", "$timeout"];
+angular.module('material.components.switch', [
+ 'material.core',
+ 'material.components.checkbox'
+])
+ .directive('mdSwitch', MdSwitch);
+
+/**
+ * @ngdoc directive
+ * @module material.components.switch
+ * @name mdSwitch
+ * @restrict E
+ *
+ * The switch directive is used very much like the normal [angular checkbox](https://docs.angularjs.org/api/ng/input/input%5Bcheckbox%5D).
+ *
+ * As per the [Material Design spec](https://material.io/archive/guidelines/style/color.html#color-color-system)
+ * the switch is in the accent color by default. The primary color palette may be used with
+ * the `md-primary` class.
+ *
+ * @param {expression} ng-model Assignable angular expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {expression=} ng-true-value The value to which the expression should be set when selected.
+ * @param {expression=} ng-false-value The value to which the expression should be set when not selected.
+ * @param {expression=} ng-change Expression to be executed when the model value changes.
+ * @param {expression=} ng-disabled En/Disable based on the expression.
+ * @param {boolean=} md-no-ink Use of attribute indicates use of ripple ink effects.
+ * @param {string=} aria-label Publish the button label used by screen-readers for accessibility. Defaults to the switch's text.
+ * @param {boolean=} md-invert When set to true, the switch will be inverted.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-switch ng-model="isActive" aria-label="Finished?">
+ * Finished ?
+ * </md-switch>
+ *
+ * <md-switch md-no-ink ng-model="hasInk" aria-label="No Ink Effects">
+ * No Ink Effects
+ * </md-switch>
+ *
+ * <md-switch ng-disabled="true" ng-model="isDisabled" aria-label="Disabled">
+ * Disabled
+ * </md-switch>
+ *
+ * </hljs>
+ */
+function MdSwitch(mdCheckboxDirective, $mdUtil, $mdConstant, $parse, $$rAF, $mdGesture, $timeout) {
+ var checkboxDirective = mdCheckboxDirective[0];
+
+ return {
+ restrict: 'E',
+ priority: $mdConstant.BEFORE_NG_ARIA,
+ transclude: true,
+ template:
+ '<div class="md-container">' +
+ '<div class="md-bar"></div>' +
+ '<div class="md-thumb-container">' +
+ '<div class="md-thumb" md-ink-ripple md-ink-ripple-checkbox></div>' +
+ '</div>'+
+ '</div>' +
+ '<div ng-transclude class="md-label"></div>',
+ require: ['^?mdInputContainer', '?ngModel', '?^form'],
+ compile: mdSwitchCompile
+ };
+
+ function mdSwitchCompile(element, attr) {
+ var checkboxLink = checkboxDirective.compile(element, attr).post;
+ // No transition on initial load.
+ element.addClass('md-dragging');
+
+ return function (scope, element, attr, ctrls) {
+ var containerCtrl = ctrls[0];
+ var ngModel = ctrls[1] || $mdUtil.fakeNgModel();
+ var formCtrl = ctrls[2];
+
+ var disabledGetter = null;
+ if (attr.disabled != null) {
+ disabledGetter = function() { return true; };
+ } else if (attr.ngDisabled) {
+ disabledGetter = $parse(attr.ngDisabled);
+ }
+
+ var thumbContainer = angular.element(element[0].querySelector('.md-thumb-container'));
+ var switchContainer = angular.element(element[0].querySelector('.md-container'));
+ var labelContainer = angular.element(element[0].querySelector('.md-label'));
+
+ // no transition on initial load
+ $$rAF(function() {
+ element.removeClass('md-dragging');
+ });
+
+ checkboxLink(scope, element, attr, ctrls);
+
+ if (disabledGetter) {
+ scope.$watch(disabledGetter, function(isDisabled) {
+ element.attr('tabindex', isDisabled ? -1 : 0);
+ });
+ }
+
+ attr.$observe('mdInvert', function(newValue) {
+ var isInverted = $mdUtil.parseAttributeBoolean(newValue);
+
+ isInverted ? element.prepend(labelContainer) : element.prepend(switchContainer);
+
+ // Toggle a CSS class to update the margin.
+ element.toggleClass('md-inverted', isInverted);
+ });
+
+ // These events are triggered by setup drag
+ $mdGesture.register(switchContainer, 'drag');
+ switchContainer
+ .on('$md.dragstart', onDragStart)
+ .on('$md.drag', onDrag)
+ .on('$md.dragend', onDragEnd);
+
+ var drag;
+ function onDragStart(ev) {
+ // Don't go if the switch is disabled.
+ if (disabledGetter && disabledGetter(scope)) return;
+ ev.stopPropagation();
+
+ element.addClass('md-dragging');
+ drag = {width: thumbContainer.prop('offsetWidth')};
+ }
+
+ function onDrag(ev) {
+ if (!drag) return;
+ ev.stopPropagation();
+ ev.srcEvent && ev.srcEvent.preventDefault();
+
+ var percent = ev.pointer.distanceX / drag.width;
+
+ // if checked, start from right. else, start from left
+ var translate = ngModel.$viewValue ? 1 + percent : percent;
+ // Make sure the switch stays inside its bounds, 0-1%
+ translate = Math.max(0, Math.min(1, translate));
+
+ thumbContainer.css($mdConstant.CSS.TRANSFORM, 'translate3d(' + (100*translate) + '%,0,0)');
+ drag.translate = translate;
+ }
+
+ function onDragEnd(ev) {
+ if (!drag) return;
+ ev.stopPropagation();
+
+ element.removeClass('md-dragging');
+ thumbContainer.css($mdConstant.CSS.TRANSFORM, '');
+
+ // We changed if there is no distance (this is a click a click),
+ // or if the drag distance is >50% of the total.
+ var isChanged = ngModel.$viewValue ? drag.translate < 0.5 : drag.translate > 0.5;
+ if (isChanged) {
+ applyModelValue(!ngModel.$viewValue);
+ }
+ drag = null;
+
+ // Wait for incoming mouse click
+ scope.skipToggle = true;
+ $timeout(function() {
+ scope.skipToggle = false;
+ }, 1);
+ }
+
+ function applyModelValue(newValue) {
+ scope.$apply(function() {
+ ngModel.$setViewValue(newValue);
+ ngModel.$render();
+ });
+ }
+
+ };
+ }
+
+
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.tabs
+ * @description
+ *
+ * Tabs, created with the `<md-tabs>` directive provide *tabbed* navigation with different styles.
+ * The Tabs component consists of clickable tabs that are aligned horizontally side-by-side.
+ *
+ * Features include support for:
+ *
+ * - static or dynamic tabs,
+ * - responsive designs,
+ * - accessibility support (ARIA),
+ * - tab pagination,
+ * - external or internal tab content,
+ * - focus indicators and arrow-key navigations,
+ * - programmatic lookup and access to tab controllers, and
+ * - dynamic transitions through different tab contents.
+ *
+ */
+/*
+ * @see js folder for tabs implementation
+ */
+angular.module('material.components.tabs', [
+ 'material.core',
+ 'material.components.icon'
+]);
+
+})();
+(function(){
+"use strict";
+
+angular
+.module('material.components.tabs')
+.service('MdTabsPaginationService', MdTabsPaginationService);
+
+/**
+ * @private
+ * @module material.components.tabs
+ * @name MdTabsPaginationService
+ * @description Provides many standalone functions to ease in pagination calculations.
+ *
+ * Most functions accept the elements and the current offset.
+ *
+ * The `elements` parameter is typically the value returned from the `getElements()` function of the
+ * tabsController.
+ *
+ * The `offset` parameter is always positive regardless of LTR or RTL (we simply make the LTR one
+ * negative when we apply our transform). This is typically the `ctrl.leftOffset` variable in the
+ * tabsController.
+ *
+ * @returns MdTabsPaginationService
+ * @constructor
+ */
+function MdTabsPaginationService() {
+ return {
+ decreasePageOffset: decreasePageOffset,
+ increasePageOffset: increasePageOffset,
+ getTabOffsets: getTabOffsets,
+ getTotalTabsWidth: getTotalTabsWidth
+ };
+
+ /**
+ * Returns the offset for the next decreasing page.
+ *
+ * @param elements
+ * @param currentOffset
+ * @returns {number}
+ */
+ function decreasePageOffset(elements, currentOffset) {
+ var canvas = elements.canvas,
+ tabOffsets = getTabOffsets(elements),
+ i, firstVisibleTabOffset;
+
+ // Find the first fully visible tab in offset range
+ for (i = 0; i < tabOffsets.length; i++) {
+ if (tabOffsets[i] >= currentOffset) {
+ firstVisibleTabOffset = tabOffsets[i];
+ break;
+ }
+ }
+
+ // Return (the first visible tab offset - the tabs container width) without going negative
+ return Math.max(0, firstVisibleTabOffset - canvas.clientWidth);
+ }
+
+ /**
+ * Returns the offset for the next increasing page.
+ *
+ * @param elements
+ * @param currentOffset
+ * @returns {number}
+ */
+ function increasePageOffset(elements, currentOffset) {
+ var canvas = elements.canvas,
+ maxOffset = getTotalTabsWidth(elements) - canvas.clientWidth,
+ tabOffsets = getTabOffsets(elements),
+ i, firstHiddenTabOffset;
+
+ // Find the first partially (or fully) invisible tab
+ for (i = 0; i < tabOffsets.length, tabOffsets[i] <= currentOffset + canvas.clientWidth; i++) {
+ firstHiddenTabOffset = tabOffsets[i];
+ }
+
+ // Return the offset of the first hidden tab, or the maximum offset (whichever is smaller)
+ return Math.min(maxOffset, firstHiddenTabOffset);
+ }
+
+ /**
+ * Returns the offsets of all of the tabs based on their widths.
+ *
+ * @param elements
+ * @returns {number[]}
+ */
+ function getTabOffsets(elements) {
+ var i, tab, currentOffset = 0, offsets = [];
+
+ for (i = 0; i < elements.tabs.length; i++) {
+ tab = elements.tabs[i];
+ offsets.push(currentOffset);
+ currentOffset += tab.offsetWidth;
+ }
+
+ return offsets;
+ }
+
+ /**
+ * Sum the width of all tabs.
+ *
+ * @param elements
+ * @returns {number}
+ */
+ function getTotalTabsWidth(elements) {
+ var sum = 0, i, tab;
+
+ for (i = 0; i < elements.tabs.length; i++) {
+ tab = elements.tabs[i];
+ sum += tab.offsetWidth;
+ }
+
+ return sum;
+ }
+
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc directive
+ * @name mdTab
+ * @module material.components.tabs
+ *
+ * @restrict E
+ *
+ * @description
+ * The `<md-tab>` is a nested directive used within `<md-tabs>` to specify a tab with a **label**
+ * and optional *view content*.
+ *
+ * If the `label` attribute is not specified, then an optional `<md-tab-label>` tag can be used to
+ * specify more complex tab header markup. If neither the **label** nor the **md-tab-label** are
+ * specified, then the nested markup of the `<md-tab>` is used as the tab header markup.
+ *
+ * Please note that if you use `<md-tab-label>`, your content **MUST** be wrapped in the
+ * `<md-tab-body>` tag. This is to define a clear separation between the tab content and the tab
+ * label.
+ *
+ * This container is used by the TabsController to show/hide the active tab's content view. This
+ * synchronization is automatically managed by the internal TabsController whenever the tab
+ * selection changes. Selection changes can be initiated via data binding changes, programmatic
+ * invocation, or user gestures.
+ *
+ * @param {string=} label Optional attribute to specify a simple string as the tab label
+ * @param {boolean=} ng-disabled If present and expression evaluates to truthy, disabled tab
+ * selection.
+ * @param {string=} md-tab-class Optional attribute to specify a class that will be applied to the
+ * tab's button
+ * @param {expression=} md-on-deselect Expression to be evaluated after the tab has been
+ * de-selected.
+ * @param {expression=} md-on-select Expression to be evaluated after the tab has been selected.
+ * @param {boolean=} md-active When true, sets the active tab. Note: There can only be one active
+ * tab at a time.
+ *
+ *
+ * @usage
+ *
+ * <hljs lang="html">
+ * <md-tab label="My Tab" md-tab-class="my-content-tab" ng-disabled md-on-select="onSelect()"
+ * md-on-deselect="onDeselect()">
+ * <h3>My Tab content</h3>
+ * </md-tab>
+ *
+ * <md-tab>
+ * <md-tab-label>
+ * <h3>My Tab</h3>
+ * </md-tab-label>
+ * <md-tab-body>
+ * <p>
+ * Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque
+ * laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi
+ * architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit
+ * aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione
+ * voluptatem sequi nesciunt.
+ * </p>
+ * </md-tab-body>
+ * </md-tab>
+ * </hljs>
+ *
+ */
+angular
+ .module('material.components.tabs')
+ .directive('mdTab', MdTab);
+
+function MdTab () {
+ return {
+ require: '^?mdTabs',
+ terminal: true,
+ compile: function (element, attr) {
+ var label = firstChild(element, 'md-tab-label'),
+ body = firstChild(element, 'md-tab-body');
+
+ if (label.length === 0) {
+ label = angular.element('<md-tab-label></md-tab-label>');
+ if (attr.label) label.text(attr.label);
+ else label.append(element.contents());
+
+ if (body.length === 0) {
+ var contents = element.contents().detach();
+ body = angular.element('<md-tab-body></md-tab-body>');
+ body.append(contents);
+ }
+ }
+
+ element.append(label);
+ if (body.html()) element.append(body);
+
+ return postLink;
+ },
+ scope: {
+ active: '=?mdActive',
+ disabled: '=?ngDisabled',
+ select: '&?mdOnSelect',
+ deselect: '&?mdOnDeselect',
+ tabClass: '@mdTabClass'
+ }
+ };
+
+ function postLink (scope, element, attr, ctrl) {
+ if (!ctrl) return;
+ var index = ctrl.getTabElementIndex(element),
+ body = firstChild(element, 'md-tab-body').remove(),
+ label = firstChild(element, 'md-tab-label').remove(),
+ data = ctrl.insertTab({
+ scope: scope,
+ parent: scope.$parent,
+ index: index,
+ element: element,
+ template: body.html(),
+ label: label.html()
+ }, index);
+
+ scope.select = scope.select || angular.noop;
+ scope.deselect = scope.deselect || angular.noop;
+
+ scope.$watch('active', function (active) { if (active) ctrl.select(data.getIndex(), true); });
+ scope.$watch('disabled', function () { ctrl.refreshIndex(); });
+ scope.$watch(
+ function () {
+ return ctrl.getTabElementIndex(element);
+ },
+ function (newIndex) {
+ data.index = newIndex;
+ ctrl.updateTabOrder();
+ }
+ );
+ scope.$on('$destroy', function () { ctrl.removeTab(data); });
+ }
+
+ function firstChild (element, tagName) {
+ var children = element[0].children;
+ for (var i = 0, len = children.length; i < len; i++) {
+ var child = children[i];
+ if (child.tagName === tagName.toUpperCase()) return angular.element(child);
+ }
+ return angular.element();
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+angular
+ .module('material.components.tabs')
+ .directive('mdTabItem', MdTabItem);
+
+function MdTabItem () {
+ return {
+ require: '^?mdTabs',
+ link: function link (scope, element, attr, ctrl) {
+ if (!ctrl) return;
+ ctrl.attachRipple(scope, element);
+ }
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+angular
+ .module('material.components.tabs')
+ .directive('mdTabLabel', MdTabLabel);
+
+function MdTabLabel () {
+ return { terminal: true };
+}
+
+
+})();
+(function(){
+"use strict";
+
+
+MdTabScroll.$inject = ["$parse"];angular.module('material.components.tabs')
+ .directive('mdTabScroll', MdTabScroll);
+
+function MdTabScroll ($parse) {
+ return {
+ restrict: 'A',
+ compile: function ($element, attr) {
+ var fn = $parse(attr.mdTabScroll, null, true);
+ return function ngEventHandler (scope, element) {
+ element.on('wheel', function (event) {
+ scope.$apply(function () { fn(scope, { $event: event }); });
+ });
+ };
+ }
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+
+MdTabsController.$inject = ["$scope", "$element", "$window", "$mdConstant", "$mdTabInkRipple", "$mdUtil", "$animateCss", "$attrs", "$compile", "$mdTheming", "$mdInteraction", "$timeout", "MdTabsPaginationService"];angular
+ .module('material.components.tabs')
+ .controller('MdTabsController', MdTabsController);
+
+/**
+ * @ngInject
+ */
+function MdTabsController ($scope, $element, $window, $mdConstant, $mdTabInkRipple, $mdUtil,
+ $animateCss, $attrs, $compile, $mdTheming, $mdInteraction, $timeout,
+ MdTabsPaginationService) {
+ // define private properties
+ var ctrl = this,
+ locked = false,
+ queue = [],
+ destroyed = false,
+ loaded = false;
+
+ // Define public methods
+ ctrl.$onInit = $onInit;
+ ctrl.updatePagination = $mdUtil.debounce(updatePagination, 100);
+ ctrl.redirectFocus = redirectFocus;
+ ctrl.attachRipple = attachRipple;
+ ctrl.insertTab = insertTab;
+ ctrl.removeTab = removeTab;
+ ctrl.select = select;
+ ctrl.scroll = scroll;
+ ctrl.nextPage = nextPage;
+ ctrl.previousPage = previousPage;
+ ctrl.keydown = keydown;
+ ctrl.canPageForward = canPageForward;
+ ctrl.canPageBack = canPageBack;
+ ctrl.refreshIndex = refreshIndex;
+ ctrl.incrementIndex = incrementIndex;
+ ctrl.getTabElementIndex = getTabElementIndex;
+ ctrl.updateInkBarStyles = $mdUtil.debounce(updateInkBarStyles, 100);
+ ctrl.updateTabOrder = $mdUtil.debounce(updateTabOrder, 100);
+ ctrl.getFocusedTabId = getFocusedTabId;
+
+ // For AngularJS 1.4 and older, where there are no lifecycle hooks but bindings are pre-assigned,
+ // manually call the $onInit hook.
+ if (angular.version.major === 1 && angular.version.minor <= 4) {
+ this.$onInit();
+ }
+
+ /**
+ * AngularJS Lifecycle hook for newer AngularJS versions.
+ * Bindings are not guaranteed to have been assigned in the controller, but they are in the
+ * $onInit hook.
+ */
+ function $onInit() {
+ // Define one-way bindings
+ defineOneWayBinding('stretchTabs', handleStretchTabs);
+
+ // Define public properties with change handlers
+ defineProperty('focusIndex', handleFocusIndexChange, ctrl.selectedIndex || 0);
+ defineProperty('offsetLeft', handleOffsetChange, 0);
+ defineProperty('hasContent', handleHasContent, false);
+ defineProperty('maxTabWidth', handleMaxTabWidth, getMaxTabWidth());
+ defineProperty('shouldPaginate', handleShouldPaginate, false);
+
+ // Define boolean attributes
+ defineBooleanAttribute('noInkBar', handleInkBar);
+ defineBooleanAttribute('dynamicHeight', handleDynamicHeight);
+ defineBooleanAttribute('noPagination');
+ defineBooleanAttribute('swipeContent');
+ defineBooleanAttribute('autoselect');
+ defineBooleanAttribute('noSelectClick');
+ defineBooleanAttribute('centerTabs', handleCenterTabs);
+ defineBooleanAttribute('enableDisconnect');
+
+ // Define public properties
+ ctrl.scope = $scope;
+ ctrl.parent = $scope.$parent;
+ ctrl.tabs = [];
+ ctrl.lastSelectedIndex = null;
+ ctrl.hasFocus = false;
+ ctrl.styleTabItemFocus = false;
+ ctrl.shouldCenterTabs = shouldCenterTabs();
+ ctrl.tabContentPrefix = 'tab-content-';
+ ctrl.navigationHint = 'Use the left and right arrow keys to navigate between tabs';
+
+ // Setup the tabs controller after all bindings are available.
+ setupTabsController();
+ }
+
+ /**
+ * Perform setup for the controller, setup events and watcher(s)
+ */
+ function setupTabsController () {
+ ctrl.selectedIndex = ctrl.selectedIndex || 0;
+ compileTemplate();
+ configureWatchers();
+ bindEvents();
+ $mdTheming($element);
+ $mdUtil.nextTick(function () {
+ updateHeightFromContent();
+ adjustOffset();
+ updateInkBarStyles();
+ ctrl.tabs[ ctrl.selectedIndex ] && ctrl.tabs[ ctrl.selectedIndex ].scope.select();
+ loaded = true;
+ updatePagination();
+ });
+ }
+
+ /**
+ * Compiles the template provided by the user. This is passed as an attribute from the tabs
+ * directive's template function.
+ */
+ function compileTemplate () {
+ var template = $attrs.$mdTabsTemplate,
+ element = angular.element($element[0].querySelector('md-tab-data'));
+
+ element.html(template);
+ $compile(element.contents())(ctrl.parent);
+ delete $attrs.$mdTabsTemplate;
+ }
+
+ /**
+ * Binds events used by the tabs component.
+ */
+ function bindEvents () {
+ angular.element($window).on('resize', handleWindowResize);
+ $scope.$on('$destroy', cleanup);
+ }
+
+ /**
+ * Configure watcher(s) used by Tabs
+ */
+ function configureWatchers () {
+ $scope.$watch('$mdTabsCtrl.selectedIndex', handleSelectedIndexChange);
+ }
+
+ /**
+ * Creates a one-way binding manually rather than relying on AngularJS's isolated scope
+ * @param key
+ * @param handler
+ */
+ function defineOneWayBinding (key, handler) {
+ var attr = $attrs.$normalize('md-' + key);
+ if (handler) defineProperty(key, handler);
+ $attrs.$observe(attr, function (newValue) { ctrl[ key ] = newValue; });
+ }
+
+ /**
+ * Defines boolean attributes with default value set to true. I.e. md-stretch-tabs with no value
+ * will be treated as being truthy.
+ * @param {string} key
+ * @param {Function=} handler
+ */
+ function defineBooleanAttribute (key, handler) {
+ var attr = $attrs.$normalize('md-' + key);
+ if (handler) defineProperty(key, handler, undefined);
+ if ($attrs.hasOwnProperty(attr)) updateValue($attrs[attr]);
+ $attrs.$observe(attr, updateValue);
+ function updateValue (newValue) {
+ ctrl[ key ] = newValue !== 'false';
+ }
+ }
+
+ /**
+ * Remove any events defined by this controller
+ */
+ function cleanup () {
+ destroyed = true;
+ angular.element($window).off('resize', handleWindowResize);
+ }
+
+ // Change handlers
+
+ /**
+ * Toggles stretch tabs class and updates inkbar when tab stretching changes.
+ */
+ function handleStretchTabs () {
+ var elements = getElements();
+ angular.element(elements.wrapper).toggleClass('md-stretch-tabs', shouldStretchTabs());
+ updateInkBarStyles();
+ }
+
+ /**
+ * Update the value of ctrl.shouldCenterTabs.
+ */
+ function handleCenterTabs () {
+ ctrl.shouldCenterTabs = shouldCenterTabs();
+ }
+
+ /**
+ * @param {number} newWidth new max tab width in pixels
+ * @param {number} oldWidth previous max tab width in pixels
+ */
+ function handleMaxTabWidth (newWidth, oldWidth) {
+ if (newWidth !== oldWidth) {
+ var elements = getElements();
+
+ // Set the max width for the real tabs
+ angular.forEach(elements.tabs, function(tab) {
+ tab.style.maxWidth = newWidth + 'px';
+ });
+
+ // Set the max width for the dummy tabs too
+ angular.forEach(elements.dummies, function(tab) {
+ tab.style.maxWidth = newWidth + 'px';
+ });
+
+ $mdUtil.nextTick(ctrl.updateInkBarStyles);
+ }
+ }
+
+ function handleShouldPaginate (newValue, oldValue) {
+ if (newValue !== oldValue) {
+ ctrl.maxTabWidth = getMaxTabWidth();
+ ctrl.shouldCenterTabs = shouldCenterTabs();
+ $mdUtil.nextTick(function () {
+ ctrl.maxTabWidth = getMaxTabWidth();
+ adjustOffset(ctrl.selectedIndex);
+ });
+ }
+ }
+
+ /**
+ * Add/remove the `md-no-tab-content` class depending on `ctrl.hasContent`
+ * @param {boolean} hasContent
+ */
+ function handleHasContent (hasContent) {
+ $element[ hasContent ? 'removeClass' : 'addClass' ]('md-no-tab-content');
+ }
+
+ /**
+ * Apply ctrl.offsetLeft to the paging element when it changes
+ * @param {string|number} left
+ */
+ function handleOffsetChange (left) {
+ var newValue = ((ctrl.shouldCenterTabs || isRtl() ? '' : '-') + left + 'px');
+
+ // Fix double-negative which can happen with RTL support
+ newValue = newValue.replace('--', '');
+
+ angular.element(getElements().paging).css($mdConstant.CSS.TRANSFORM,
+ 'translate(' + newValue + ', 0)');
+ $scope.$broadcast('$mdTabsPaginationChanged');
+ }
+
+ /**
+ * Update the UI whenever `ctrl.focusIndex` is updated
+ * @param {number} newIndex
+ * @param {number} oldIndex
+ */
+ function handleFocusIndexChange (newIndex, oldIndex) {
+ if (newIndex === oldIndex) return;
+ if (!getElements().tabs[ newIndex ]) return;
+ adjustOffset();
+ redirectFocus();
+ }
+
+ /**
+ * Update the UI whenever the selected index changes. Calls user-defined select/deselect methods.
+ * @param {number} newValue selected index's new value
+ * @param {number} oldValue selected index's previous value
+ */
+ function handleSelectedIndexChange (newValue, oldValue) {
+ if (newValue === oldValue) return;
+
+ ctrl.selectedIndex = getNearestSafeIndex(newValue);
+ ctrl.lastSelectedIndex = oldValue;
+ ctrl.updateInkBarStyles();
+ updateHeightFromContent();
+ adjustOffset(newValue);
+ $scope.$broadcast('$mdTabsChanged');
+ ctrl.tabs[ oldValue ] && ctrl.tabs[ oldValue ].scope.deselect();
+ ctrl.tabs[ newValue ] && ctrl.tabs[ newValue ].scope.select();
+ }
+
+ function getTabElementIndex(tabEl){
+ var tabs = $element[0].getElementsByTagName('md-tab');
+ return Array.prototype.indexOf.call(tabs, tabEl[0]);
+ }
+
+ /**
+ * Queues up a call to `handleWindowResize` when a resize occurs while the tabs component is
+ * hidden.
+ */
+ function handleResizeWhenVisible () {
+ // if there is already a watcher waiting for resize, do nothing
+ if (handleResizeWhenVisible.watcher) return;
+ // otherwise, we will abuse the $watch function to check for visible
+ handleResizeWhenVisible.watcher = $scope.$watch(function () {
+ // since we are checking for DOM size, we use $mdUtil.nextTick() to wait for after the DOM updates
+ $mdUtil.nextTick(function () {
+ // if the watcher has already run (ie. multiple digests in one cycle), do nothing
+ if (!handleResizeWhenVisible.watcher) return;
+
+ if ($element.prop('offsetParent')) {
+ handleResizeWhenVisible.watcher();
+ handleResizeWhenVisible.watcher = null;
+
+ handleWindowResize();
+ }
+ }, false);
+ });
+ }
+
+ // Event handlers / actions
+
+ /**
+ * Handle user keyboard interactions
+ * @param {KeyboardEvent} event keydown event
+ */
+ function keydown (event) {
+ switch (event.keyCode) {
+ case $mdConstant.KEY_CODE.LEFT_ARROW:
+ event.preventDefault();
+ incrementIndex(-1, true);
+ break;
+ case $mdConstant.KEY_CODE.RIGHT_ARROW:
+ event.preventDefault();
+ incrementIndex(1, true);
+ break;
+ case $mdConstant.KEY_CODE.SPACE:
+ case $mdConstant.KEY_CODE.ENTER:
+ event.preventDefault();
+ if (!locked) select(ctrl.focusIndex);
+ break;
+ case $mdConstant.KEY_CODE.TAB:
+ // On tabbing out of the tablist, reset hasFocus to reset ng-focused and
+ // its md-focused class if the focused tab is not the active tab.
+ if (ctrl.focusIndex !== ctrl.selectedIndex) {
+ ctrl.focusIndex = ctrl.selectedIndex;
+ }
+ break;
+ }
+ }
+
+ /**
+ * Update the selected index. Triggers a click event on the original `md-tab` element in order
+ * to fire user-added click events if canSkipClick or `md-no-select-click` are false.
+ * @param index
+ * @param canSkipClick Optionally allow not firing the click event if `md-no-select-click` is also true.
+ */
+ function select (index, canSkipClick) {
+ if (!locked) ctrl.focusIndex = ctrl.selectedIndex = index;
+ // skip the click event if noSelectClick is enabled
+ if (canSkipClick && ctrl.noSelectClick) return;
+ // nextTick is required to prevent errors in user-defined click events
+ $mdUtil.nextTick(function () {
+ ctrl.tabs[ index ].element.triggerHandler('click');
+ }, false);
+ }
+
+ /**
+ * When pagination is on, this makes sure the selected index is in view.
+ * @param {WheelEvent} event
+ */
+ function scroll (event) {
+ if (!ctrl.shouldPaginate) return;
+ event.preventDefault();
+ if (event.deltaY) {
+ ctrl.offsetLeft = fixOffset(ctrl.offsetLeft + event.deltaY);
+ } else if (event.deltaX) {
+ ctrl.offsetLeft = fixOffset(ctrl.offsetLeft + event.deltaX);
+ }
+ }
+
+ /**
+ * Slides the tabs over approximately one page forward.
+ */
+ function nextPage () {
+ if (!ctrl.canPageForward()) { return; }
+
+ var newOffset = MdTabsPaginationService.increasePageOffset(getElements(), ctrl.offsetLeft);
+
+ ctrl.offsetLeft = fixOffset(newOffset);
+ }
+
+ /**
+ * Slides the tabs over approximately one page backward.
+ */
+ function previousPage () {
+ if (!ctrl.canPageBack()) { return; }
+
+ var newOffset = MdTabsPaginationService.decreasePageOffset(getElements(), ctrl.offsetLeft);
+
+ // Set the new offset
+ ctrl.offsetLeft = fixOffset(newOffset);
+ }
+
+ /**
+ * Update size calculations when the window is resized.
+ */
+ function handleWindowResize () {
+ ctrl.lastSelectedIndex = ctrl.selectedIndex;
+ ctrl.offsetLeft = fixOffset(ctrl.offsetLeft);
+
+ $mdUtil.nextTick(function () {
+ ctrl.updateInkBarStyles();
+ updatePagination();
+ });
+ }
+
+ /**
+ * Hides or shows the tabs ink bar.
+ * @param {boolean} hide A Boolean (not just truthy/falsy) value to determine whether the class
+ * should be added or removed.
+ */
+ function handleInkBar (hide) {
+ angular.element(getElements().inkBar).toggleClass('ng-hide', hide);
+ }
+
+ /**
+ * Enables or disables tabs dynamic height.
+ * @param {boolean} value A Boolean (not just truthy/falsy) value to determine whether the class
+ * should be added or removed.
+ */
+ function handleDynamicHeight (value) {
+ $element.toggleClass('md-dynamic-height', value);
+ }
+
+ /**
+ * Remove a tab from the data and select the nearest valid tab.
+ * @param {Object} tabData tab to remove
+ */
+ function removeTab (tabData) {
+ if (destroyed) return;
+ var selectedIndex = ctrl.selectedIndex,
+ tab = ctrl.tabs.splice(tabData.getIndex(), 1)[ 0 ];
+ refreshIndex();
+ // when removing a tab, if the selected index did not change, we have to manually trigger the
+ // tab select/deselect events
+ if (ctrl.selectedIndex === selectedIndex) {
+ tab.scope.deselect();
+ ctrl.tabs[ ctrl.selectedIndex ] && ctrl.tabs[ ctrl.selectedIndex ].scope.select();
+ }
+ $mdUtil.nextTick(function () {
+ updatePagination();
+ ctrl.offsetLeft = fixOffset(ctrl.offsetLeft);
+ });
+ }
+
+ /**
+ * Create an entry in the tabs array for a new tab at the specified index.
+ * @param {Object} tabData tab to insert
+ * @param {number} index location to insert the new tab
+ * @returns {Object} the inserted tab
+ */
+ function insertTab (tabData, index) {
+ var hasLoaded = loaded;
+ var proto = {
+ getIndex: function () { return ctrl.tabs.indexOf(tab); },
+ isActive: function () { return this.getIndex() === ctrl.selectedIndex; },
+ isLeft: function () { return this.getIndex() < ctrl.selectedIndex; },
+ isRight: function () { return this.getIndex() > ctrl.selectedIndex; },
+ shouldRender: function () { return ctrl.dynamicHeight || this.isActive(); },
+ hasFocus: function () {
+ return ctrl.styleTabItemFocus
+ && ctrl.hasFocus && this.getIndex() === ctrl.focusIndex;
+ },
+ id: $mdUtil.nextUid(),
+ hasContent: !!(tabData.template && tabData.template.trim())
+ };
+ var tab = angular.extend(proto, tabData);
+
+ if (angular.isDefined(index)) {
+ ctrl.tabs.splice(index, 0, tab);
+ } else {
+ ctrl.tabs.push(tab);
+ }
+ processQueue();
+ updateHasContent();
+
+ $mdUtil.nextTick(function () {
+ updatePagination();
+ setAriaControls(tab);
+
+ // if autoselect is enabled, select the newly added tab
+ if (hasLoaded && ctrl.autoselect) {
+ $mdUtil.nextTick(function () {
+ $mdUtil.nextTick(function () { select(ctrl.tabs.indexOf(tab)); });
+ });
+ }
+ });
+ return tab;
+ }
+
+ // Getter methods
+
+ /**
+ * Gathers references to all of the DOM elements used by this controller.
+ * @returns {Object}
+ */
+ function getElements () {
+ var elements = {};
+ var node = $element[0];
+
+ // gather tab bar elements
+ elements.wrapper = node.querySelector('md-tabs-wrapper');
+ elements.canvas = elements.wrapper.querySelector('md-tabs-canvas');
+ elements.paging = elements.canvas.querySelector('md-pagination-wrapper');
+ elements.inkBar = elements.paging.querySelector('md-ink-bar');
+ elements.nextButton = node.querySelector('md-next-button');
+ elements.prevButton = node.querySelector('md-prev-button');
+
+ elements.contents = node.querySelectorAll('md-tabs-content-wrapper > md-tab-content');
+ elements.tabs = elements.paging.querySelectorAll('md-tab-item');
+ elements.dummies = elements.canvas.querySelectorAll('md-dummy-tab');
+
+ return elements;
+ }
+
+ /**
+ * Determines whether or not the left pagination arrow should be enabled.
+ * @returns {boolean}
+ */
+ function canPageBack () {
+ // This works for both LTR and RTL
+ return ctrl.offsetLeft > 0;
+ }
+
+ /**
+ * Determines whether or not the right pagination arrow should be enabled.
+ * @returns {*|boolean}
+ */
+ function canPageForward () {
+ var elements = getElements();
+ var lastTab = elements.tabs[ elements.tabs.length - 1 ];
+
+ if (isRtl()) {
+ return ctrl.offsetLeft < elements.paging.offsetWidth - elements.canvas.offsetWidth;
+ }
+
+ return lastTab && lastTab.offsetLeft + lastTab.offsetWidth > elements.canvas.clientWidth +
+ ctrl.offsetLeft;
+ }
+
+ /**
+ * Returns currently focused tab item's element ID
+ */
+ function getFocusedTabId() {
+ var focusedTab = ctrl.tabs[ctrl.focusIndex];
+ if (!focusedTab || !focusedTab.id) {
+ return null;
+ }
+ return 'tab-item-' + focusedTab.id;
+ }
+
+ /**
+ * Determines if the UI should stretch the tabs to fill the available space.
+ * @returns {*}
+ */
+ function shouldStretchTabs () {
+ switch (ctrl.stretchTabs) {
+ case 'always':
+ return true;
+ case 'never':
+ return false;
+ default:
+ return !ctrl.shouldPaginate
+ && $window.matchMedia('(max-width: 600px)').matches;
+ }
+ }
+
+ /**
+ * Determines if the tabs should appear centered.
+ * @returns {boolean}
+ */
+ function shouldCenterTabs () {
+ return ctrl.centerTabs && !ctrl.shouldPaginate;
+ }
+
+ /**
+ * Determines if pagination is necessary to display the tabs within the available space.
+ * @returns {boolean} true if pagination is necessary, false otherwise
+ */
+ function shouldPaginate () {
+ var shouldPaginate;
+ if (ctrl.noPagination || !loaded) return false;
+ var canvasWidth = $element.prop('clientWidth');
+
+ angular.forEach(getElements().tabs, function (tab) {
+ canvasWidth -= tab.offsetWidth;
+ });
+
+ shouldPaginate = canvasWidth < 0;
+ // Work around width calculation issues on IE11 when pagination is enabled.
+ // Don't do this on other browsers because it breaks scroll to new tab animation.
+ if ($mdUtil.msie) {
+ if (shouldPaginate) {
+ getElements().paging.style.width = '999999px';
+ } else {
+ getElements().paging.style.width = undefined;
+ }
+ }
+ return shouldPaginate;
+ }
+
+ /**
+ * Finds the nearest tab index that is available. This is primarily used for when the active
+ * tab is removed.
+ * @param newIndex
+ * @returns {*}
+ */
+ function getNearestSafeIndex (newIndex) {
+ if (newIndex === -1) return -1;
+ var maxOffset = Math.max(ctrl.tabs.length - newIndex, newIndex),
+ i, tab;
+ for (i = 0; i <= maxOffset; i++) {
+ tab = ctrl.tabs[ newIndex + i ];
+ if (tab && (tab.scope.disabled !== true)) return tab.getIndex();
+ tab = ctrl.tabs[ newIndex - i ];
+ if (tab && (tab.scope.disabled !== true)) return tab.getIndex();
+ }
+ return newIndex;
+ }
+
+ // Utility methods
+
+ /**
+ * Defines a property using a getter and setter in order to trigger a change handler without
+ * using `$watch` to observe changes.
+ * @param {PropertyKey} key
+ * @param {Function} handler
+ * @param {any} value
+ */
+ function defineProperty (key, handler, value) {
+ Object.defineProperty(ctrl, key, {
+ get: function () { return value; },
+ set: function (newValue) {
+ var oldValue = value;
+ value = newValue;
+ handler && handler(newValue, oldValue);
+ }
+ });
+ }
+
+ /**
+ * Updates whether or not pagination should be displayed.
+ */
+ function updatePagination () {
+ ctrl.maxTabWidth = getMaxTabWidth();
+ ctrl.shouldPaginate = shouldPaginate();
+ }
+
+ /**
+ * @param {Array<HTMLElement>} tabs tab item elements for use in computing total width
+ * @returns {number} the width of the tabs in the specified array in pixels
+ */
+ function calcTabsWidth(tabs) {
+ var width = 0;
+
+ angular.forEach(tabs, function (tab) {
+ // Uses the larger value between `getBoundingClientRect().width` and `offsetWidth`. This
+ // prevents `offsetWidth` value from being rounded down and causing wrapping issues, but
+ // also handles scenarios where `getBoundingClientRect()` is inaccurate (ie. tabs inside
+ // of a dialog).
+ width += Math.max(tab.offsetWidth, tab.getBoundingClientRect().width);
+ });
+
+ return Math.ceil(width);
+ }
+
+ /**
+ * @returns {number} either the max width as constrained by the container or the max width from
+ * the 2017 version of the Material Design spec.
+ */
+ function getMaxTabWidth() {
+ var elements = getElements(),
+ containerWidth = elements.canvas.clientWidth,
+
+ // See https://material.io/archive/guidelines/components/tabs.html#tabs-specs
+ specMax = 264;
+
+ // Do the spec maximum, or the canvas width; whichever is *smaller* (tabs larger than the canvas
+ // width can break the pagination) but not less than 0
+ return Math.max(0, Math.min(containerWidth - 1, specMax));
+ }
+
+ /**
+ * Re-orders the tabs and updates the selected and focus indexes to their new positions.
+ * This is triggered by `tabDirective.js` when the user's tabs have been re-ordered.
+ */
+ function updateTabOrder () {
+ var selectedItem = ctrl.tabs[ ctrl.selectedIndex ],
+ focusItem = ctrl.tabs[ ctrl.focusIndex ];
+ ctrl.tabs = ctrl.tabs.sort(function (a, b) {
+ return a.index - b.index;
+ });
+ ctrl.selectedIndex = ctrl.tabs.indexOf(selectedItem);
+ ctrl.focusIndex = ctrl.tabs.indexOf(focusItem);
+ }
+
+ /**
+ * This moves the selected or focus index left or right. This is used by the keydown handler.
+ * @param {number} inc amount to increment
+ * @param {boolean} focus true to increment the focus index, false to increment the selected index
+ */
+ function incrementIndex (inc, focus) {
+ var newIndex,
+ key = focus ? 'focusIndex' : 'selectedIndex',
+ index = ctrl[ key ];
+ for (newIndex = index + inc;
+ ctrl.tabs[ newIndex ] && ctrl.tabs[ newIndex ].scope.disabled;
+ newIndex += inc) { /* do nothing */ }
+
+ newIndex = (index + inc + ctrl.tabs.length) % ctrl.tabs.length;
+
+ if (ctrl.tabs[ newIndex ]) {
+ ctrl[ key ] = newIndex;
+ }
+ }
+
+ /**
+ * This is used to forward focus to tab container elements. This method is necessary to avoid
+ * animation issues when attempting to focus an item that is out of view.
+ */
+ function redirectFocus () {
+ ctrl.styleTabItemFocus = ($mdInteraction.getLastInteractionType() === 'keyboard');
+ var tabToFocus = getElements().tabs[ctrl.focusIndex];
+ if (tabToFocus) {
+ tabToFocus.focus();
+ }
+ }
+
+ /**
+ * Forces the pagination to move the focused tab into view.
+ * @param {number=} index of tab to have its offset adjusted
+ */
+ function adjustOffset (index) {
+ var elements = getElements();
+
+ if (!angular.isNumber(index)) index = ctrl.focusIndex;
+ if (!elements.tabs[ index ]) return;
+ if (ctrl.shouldCenterTabs) return;
+ var tab = elements.tabs[ index ],
+ left = tab.offsetLeft,
+ right = tab.offsetWidth + left,
+ extraOffset = 32;
+
+ // If we are selecting the first tab (in LTR and RTL), always set the offset to 0
+ if (index === 0) {
+ ctrl.offsetLeft = 0;
+ return;
+ }
+
+ if (isRtl()) {
+ var tabWidthsBefore = calcTabsWidth(Array.prototype.slice.call(elements.tabs, 0, index));
+ var tabWidthsIncluding = calcTabsWidth(Array.prototype.slice.call(elements.tabs, 0, index + 1));
+
+ ctrl.offsetLeft = Math.min(ctrl.offsetLeft, fixOffset(tabWidthsBefore));
+ ctrl.offsetLeft = Math.max(ctrl.offsetLeft, fixOffset(tabWidthsIncluding - elements.canvas.clientWidth));
+ } else {
+ ctrl.offsetLeft = Math.max(ctrl.offsetLeft, fixOffset(right - elements.canvas.clientWidth + extraOffset));
+ ctrl.offsetLeft = Math.min(ctrl.offsetLeft, fixOffset(left));
+ }
+ }
+
+ /**
+ * Iterates through all queued functions and clears the queue. This is used for functions that
+ * are called before the UI is ready, such as size calculations.
+ */
+ function processQueue () {
+ queue.forEach(function (func) { $mdUtil.nextTick(func); });
+ queue = [];
+ }
+
+ /**
+ * Determines if the tab content area is needed.
+ */
+ function updateHasContent () {
+ var hasContent = false;
+ var i;
+
+ for (i = 0; i < ctrl.tabs.length; i++) {
+ if (ctrl.tabs[i].hasContent) {
+ hasContent = true;
+ break;
+ }
+ }
+
+ ctrl.hasContent = hasContent;
+ }
+
+ /**
+ * Moves the indexes to their nearest valid values.
+ */
+ function refreshIndex () {
+ ctrl.selectedIndex = getNearestSafeIndex(ctrl.selectedIndex);
+ ctrl.focusIndex = getNearestSafeIndex(ctrl.focusIndex);
+ }
+
+ /**
+ * Calculates the content height of the current tab.
+ * @returns {*}
+ */
+ function updateHeightFromContent () {
+ if (!ctrl.dynamicHeight) return $element.css('height', '');
+ if (!ctrl.tabs.length) return queue.push(updateHeightFromContent);
+
+ var elements = getElements();
+
+ var tabContent = elements.contents[ ctrl.selectedIndex ],
+ contentHeight = tabContent ? tabContent.offsetHeight : 0,
+ tabsHeight = elements.wrapper.offsetHeight,
+ newHeight = contentHeight + tabsHeight,
+ currentHeight = $element.prop('clientHeight');
+
+ if (currentHeight === newHeight) return;
+
+ // Adjusts calculations for when the buttons are bottom-aligned since this relies on absolute
+ // positioning. This should probably be cleaned up if a cleaner solution is possible.
+ if ($element.attr('md-align-tabs') === 'bottom') {
+ currentHeight -= tabsHeight;
+ newHeight -= tabsHeight;
+ // Need to include bottom border in these calculations
+ if ($element.attr('md-border-bottom') !== undefined) {
+ ++currentHeight;
+ }
+ }
+
+ // Lock during animation so the user can't change tabs
+ locked = true;
+
+ var fromHeight = { height: currentHeight + 'px' },
+ toHeight = { height: newHeight + 'px' };
+
+ // Set the height to the current, specific pixel height to fix a bug on iOS where the height
+ // first animates to 0, then back to the proper height causing a visual glitch
+ $element.css(fromHeight);
+
+ // Animate the height from the old to the new
+ $animateCss($element, {
+ from: fromHeight,
+ to: toHeight,
+ easing: 'cubic-bezier(0.35, 0, 0.25, 1)',
+ duration: 0.5
+ }).start().done(function () {
+ // Then (to fix the same iOS issue as above), disable transitions and remove the specific
+ // pixel height so the height can size with browser width/content changes, etc.
+ $element.css({
+ transition: 'none',
+ height: ''
+ });
+
+ // In the next tick, re-allow transitions (if we do it all at once, $element.css is "smart"
+ // enough to batch it for us instead of doing it immediately, which undoes the original
+ // transition: none)
+ $mdUtil.nextTick(function() {
+ $element.css('transition', '');
+ });
+
+ // And unlock so tab changes can occur
+ locked = false;
+ });
+ }
+
+ /**
+ * Repositions the ink bar to the selected tab.
+ * Parameters are used when calling itself recursively when md-center-tabs is used as we need to
+ * run two passes to properly center the tabs. These parameters ensure that we only run two passes
+ * and that we don't run indefinitely.
+ * @param {number=} previousTotalWidth previous width of pagination wrapper
+ * @param {number=} previousWidthOfTabItems previous width of all tab items
+ */
+ function updateInkBarStyles (previousTotalWidth, previousWidthOfTabItems) {
+ if (ctrl.noInkBar) {
+ return;
+ }
+ var elements = getElements();
+
+ if (!elements.tabs[ ctrl.selectedIndex ]) {
+ angular.element(elements.inkBar).css({ left: 'auto', right: 'auto' });
+ return;
+ }
+
+ if (!ctrl.tabs.length) {
+ queue.push(ctrl.updateInkBarStyles);
+ return;
+ }
+ // If the element is not visible, we will not be able to calculate sizes until it becomes
+ // visible. We should treat that as a resize event rather than just updating the ink bar.
+ if (!$element.prop('offsetParent')) {
+ handleResizeWhenVisible();
+ return;
+ }
+
+ var index = ctrl.selectedIndex,
+ totalWidth = elements.paging.offsetWidth,
+ tab = elements.tabs[ index ],
+ left = tab.offsetLeft,
+ right = totalWidth - left - tab.offsetWidth;
+
+ if (ctrl.shouldCenterTabs) {
+ // We need to use the same calculate process as in the pagination wrapper, to avoid rounding
+ // deviations.
+ var totalWidthOfTabItems = calcTabsWidth(elements.tabs);
+
+ if (totalWidth > totalWidthOfTabItems &&
+ previousTotalWidth !== totalWidth &&
+ previousWidthOfTabItems !== totalWidthOfTabItems) {
+ $timeout(updateInkBarStyles, 0, true, totalWidth, totalWidthOfTabItems);
+ }
+ }
+ updateInkBarClassName();
+ angular.element(elements.inkBar).css({ left: left + 'px', right: right + 'px' });
+ }
+
+ /**
+ * Adds left/right classes so that the ink bar will animate properly.
+ */
+ function updateInkBarClassName () {
+ var elements = getElements();
+ var newIndex = ctrl.selectedIndex,
+ oldIndex = ctrl.lastSelectedIndex,
+ ink = angular.element(elements.inkBar);
+ if (!angular.isNumber(oldIndex)) return;
+ ink
+ .toggleClass('md-left', newIndex < oldIndex)
+ .toggleClass('md-right', newIndex > oldIndex);
+ }
+
+ /**
+ * Takes an offset value and makes sure that it is within the min/max allowed values.
+ * @param {number} value
+ * @returns {number}
+ */
+ function fixOffset (value) {
+ var elements = getElements();
+
+ if (!elements.tabs.length || !ctrl.shouldPaginate) return 0;
+
+ var lastTab = elements.tabs[ elements.tabs.length - 1 ],
+ totalWidth = lastTab.offsetLeft + lastTab.offsetWidth;
+
+ if (isRtl()) {
+ value = Math.min(elements.paging.offsetWidth - elements.canvas.clientWidth, value);
+ value = Math.max(0, value);
+ } else {
+ value = Math.max(0, value);
+ value = Math.min(totalWidth - elements.canvas.clientWidth, value);
+ }
+
+ return value;
+ }
+
+ /**
+ * Attaches a ripple to the tab item element.
+ * @param scope
+ * @param element
+ */
+ function attachRipple (scope, element) {
+ var elements = getElements();
+ var options = { colorElement: angular.element(elements.inkBar) };
+ $mdTabInkRipple.attach(scope, element, options);
+ }
+
+ /**
+ * Sets the `aria-controls` attribute to the elements that correspond to the passed-in tab.
+ * @param tab
+ */
+ function setAriaControls (tab) {
+ if (tab.hasContent) {
+ var nodes = $element[0].querySelectorAll('[md-tab-id="' + tab.id + '"]');
+ angular.element(nodes).attr('aria-controls', ctrl.tabContentPrefix + tab.id);
+ }
+ }
+
+ function isRtl() {
+ return $mdUtil.isRtl($attrs);
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc directive
+ * @name mdTabs
+ * @module material.components.tabs
+ *
+ * @restrict E
+ *
+ * @description
+ * The `<md-tabs>` directive serves as the container for 1..n
+ * <a ng-href="api/directive/mdTab">`<md-tab>`</a> child directives.
+ * In turn, the nested `<md-tab>` directive is used to specify a tab label for the
+ * **header button** and <i>optional</i> tab view content that will be associated with each tab
+ * button.
+ *
+ * Below is the markup for its simplest usage:
+ *
+ * <hljs lang="html">
+ * <md-tabs>
+ * <md-tab label="Tab #1"></md-tab>
+ * <md-tab label="Tab #2"></md-tab>
+ * <md-tab label="Tab #3"></md-tab>
+ * </md-tabs>
+ * </hljs>
+ *
+ * Tabs support three (3) usage scenarios:
+ *
+ * 1. Tabs (buttons only)
+ * 2. Tabs with internal view content
+ * 3. Tabs with external view content
+ *
+ * **Tabs-only** support is useful when tab buttons are used for custom navigation regardless of any
+ * other components, content, or views.
+ *
+ * <blockquote><b>Note:</b> If you are using the Tabs component for page-level navigation, please
+ * use the <a ng-href="./api/directive/mdNavBar">NavBar component</a> instead. It handles this
+ * case a more natively and more performantly.</blockquote>
+ *
+ * **Tabs with internal views** are the traditional usage where each tab has associated view
+ * content and the view switching is managed internally by the Tabs component.
+ *
+ * **Tabs with external view content** is often useful when content associated with each tab is
+ * independently managed and data-binding notifications announce tab selection changes.
+ *
+ * Additional features include:
+ *
+ * * Content can include any markup.
+ * * If a tab is disabled while active/selected, then the next tab will be auto-selected.
+ *
+ * ### Theming
+ *
+ * By default, tabs use your app's accent color for the selected tab's text and ink bar.
+ *
+ * You can use the theming classes to change the color of the `md-tabs` background:
+ * * Applying `class="md-primary"` will use your app's primary color for the background, your
+ * accent color for the ink bar, and your primary palette's contrast color for the text of the
+ * selected tab.
+ * * When using the `md-primary` class, you can add the `md-no-ink-bar-color` class to make the
+ * ink bar use your theme's primary contrast color instead of the accent color.
+ * * Applying `class="md-accent"` will use your app's accent color for the background and your
+ * accent palette's contrast color for the text and ink bar of the selected tab.
+ * * Applying `class="md-warn"` will use your app's warn color for the background and your
+ * warn palette's contrast color for the text and ink bar of the selected tab.
+ *
+ * ### Explanation of tab stretching
+ *
+ * Initially, tabs will have an inherent size. This size will either be defined by how much space
+ * is needed to accommodate their text or set by the user through CSS.
+ * Calculations will be based on this size.
+ *
+ * On mobile devices, tabs will be expanded to fill the available horizontal space.
+ * When this happens, all tabs will become the same size.
+ *
+ * On desktops, by default, stretching will never occur.
+ *
+ * This default behavior can be overridden through the `md-stretch-tabs` attribute.
+ * Here is a table showing when stretching will occur:
+ *
+ * `md-stretch-tabs` | mobile | desktop
+ * ------------------|-----------|--------
+ * `auto` | stretched | ---
+ * `always` | stretched | stretched
+ * `never` | --- | ---
+ *
+ * @param {number=} md-selected Index of the active/selected tab.
+ * @param {expression=} md-no-ink-bar If `true` or no value, disables the selection ink bar.
+ * @param {string=} md-align-tabs Attribute to indicate position of tab buttons: `bottom` or `top`;
+ * Default is `top`.
+ * @param {string=} md-stretch-tabs Attribute to indicate whether or not to stretch tabs: `auto`,
+ * `always`, or `never`; Default is `auto`.
+ * @param {expression=} md-dynamic-height If `true` or no value, the tab wrapper will resize based
+ * on the contents of the selected tab.
+ * @param {boolean=} md-border-bottom If the attribute is present, shows a solid `1px` border
+ * between the tabs and their content.
+ * @param {boolean=} md-center-tabs If the attribute is present, tabs will be centered provided
+ * there is no need for pagination.
+ * @param {boolean=} md-no-pagination If the attribute is present, pagination will remain off.
+ * @param {expression=} md-swipe-content When enabled, swipe gestures will be enabled for the content
+ * area to allow swiping between tabs.
+ * @param {boolean=} md-enable-disconnect When enabled, scopes will be disconnected for tabs that
+ * are not being displayed. This provides a performance boost, but may also cause unexpected
+ * issues. It is not recommended for most users.
+ * @param {boolean=} md-autoselect If the attribute is present, any tabs added after the initial
+ * load will be automatically selected.
+ * @param {boolean=} md-no-select-click When true, click events will not be fired when the value of
+ * `md-active` on an `md-tab` changes. This is useful when using tabs with UI-Router's child
+ * states, as triggering a click event in that case can cause an extra tab change to occur.
+ * @param {string=} md-navigation-hint Attribute to override the default `tablist` navigation hint
+ * that screen readers will announce to provide instructions for navigating between tabs. This is
+ * desirable when you want the hint to be in a different language. Default is "Use the left and
+ * right arrow keys to navigate between tabs".
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-tabs md-selected="selectedIndex">
+ * <img ng-src="img/angular.png" class="centered" alt="Angular icon">
+ * <md-tab
+ * ng-repeat="tab in tabs | orderBy:predicate:reversed"
+ * md-on-select="onTabSelected(tab)"
+ * md-on-deselect="announceDeselected(tab)"
+ * ng-disabled="tab.disabled">
+ * <md-tab-label>
+ * {{tab.title}}
+ * <img src="img/removeTab.png" ng-click="removeTab(tab)" class="delete" alt="Remove tab">
+ * </md-tab-label>
+ * <md-tab-body>
+ * {{tab.content}}
+ * </md-tab-body>
+ * </md-tab>
+ * </md-tabs>
+ * </hljs>
+ *
+ */
+MdTabs.$inject = ["$$mdSvgRegistry"];
+angular
+ .module('material.components.tabs')
+ .directive('mdTabs', MdTabs);
+
+function MdTabs ($$mdSvgRegistry) {
+ return {
+ scope: {
+ navigationHint: '@?mdNavigationHint',
+ selectedIndex: '=?mdSelected'
+ },
+ template: function (element, attr) {
+ attr.$mdTabsTemplate = element.html();
+ return '' +
+ '<md-tabs-wrapper> ' +
+ '<md-tab-data></md-tab-data> ' +
+ '<md-prev-button ' +
+ 'tabindex="-1" ' +
+ 'role="button" ' +
+ 'aria-label="Previous Page" ' +
+ 'aria-disabled="{{!$mdTabsCtrl.canPageBack()}}" ' +
+ 'ng-class="{ \'md-disabled\': !$mdTabsCtrl.canPageBack() }" ' +
+ 'ng-if="$mdTabsCtrl.shouldPaginate" ' +
+ 'ng-click="$mdTabsCtrl.previousPage()"> ' +
+ '<md-icon md-svg-src="'+ $$mdSvgRegistry.mdTabsArrow +'"></md-icon> ' +
+ '</md-prev-button> ' +
+ '<md-next-button ' +
+ 'tabindex="-1" ' +
+ 'role="button" ' +
+ 'aria-label="Next Page" ' +
+ 'aria-disabled="{{!$mdTabsCtrl.canPageForward()}}" ' +
+ 'ng-class="{ \'md-disabled\': !$mdTabsCtrl.canPageForward() }" ' +
+ 'ng-if="$mdTabsCtrl.shouldPaginate" ' +
+ 'ng-click="$mdTabsCtrl.nextPage()"> ' +
+ '<md-icon md-svg-src="'+ $$mdSvgRegistry.mdTabsArrow +'"></md-icon> ' +
+ '</md-next-button> ' +
+ '<md-tabs-canvas ' +
+ 'tabindex="{{ $mdTabsCtrl.hasFocus ? -1 : 0 }}" ' +
+ 'ng-focus="$mdTabsCtrl.redirectFocus()" ' +
+ 'ng-class="{ ' +
+ '\'md-paginated\': $mdTabsCtrl.shouldPaginate, ' +
+ '\'md-center-tabs\': $mdTabsCtrl.shouldCenterTabs ' +
+ '}" ' +
+ 'ng-keydown="$mdTabsCtrl.keydown($event)"> ' +
+ '<md-pagination-wrapper ' +
+ 'ng-class="{ \'md-center-tabs\': $mdTabsCtrl.shouldCenterTabs }" ' +
+ 'md-tab-scroll="$mdTabsCtrl.scroll($event)" ' +
+ 'role="tablist" ' +
+ 'aria-label="{{::$mdTabsCtrl.navigationHint}}">' +
+ '<md-tab-item ' +
+ 'tabindex="{{ tab.isActive() ? 0 : -1 }}" ' +
+ 'class="md-tab {{::tab.scope.tabClass}}" ' +
+ 'ng-repeat="tab in $mdTabsCtrl.tabs" ' +
+ 'role="tab" ' +
+ 'id="tab-item-{{::tab.id}}" ' +
+ 'md-tab-id="{{::tab.id}}" ' +
+ 'aria-selected="{{tab.isActive()}}" ' +
+ 'aria-disabled="{{tab.scope.disabled || \'false\'}}" ' +
+ 'ng-click="$mdTabsCtrl.select(tab.getIndex())" ' +
+ 'ng-focus="$mdTabsCtrl.hasFocus = true" ' +
+ 'ng-blur="$mdTabsCtrl.hasFocus = false" ' +
+ 'ng-class="{ ' +
+ '\'md-active\': tab.isActive(), ' +
+ '\'md-focused\': tab.hasFocus(), ' +
+ '\'md-disabled\': tab.scope.disabled ' +
+ '}" ' +
+ 'ng-disabled="tab.scope.disabled" ' +
+ 'md-swipe-left="$mdTabsCtrl.nextPage()" ' +
+ 'md-swipe-right="$mdTabsCtrl.previousPage()" ' +
+ 'md-tabs-template="::tab.label" ' +
+ 'md-scope="::tab.parent"></md-tab-item> ' +
+ '<md-ink-bar></md-ink-bar> ' +
+ '</md-pagination-wrapper> ' +
+ '<md-tabs-dummy-wrapper aria-hidden="true" class="md-visually-hidden md-dummy-wrapper"> ' +
+ '<md-dummy-tab ' +
+ 'class="md-tab" ' +
+ 'tabindex="-1" ' +
+ 'ng-focus="$mdTabsCtrl.hasFocus = true" ' +
+ 'ng-blur="$mdTabsCtrl.hasFocus = false" ' +
+ 'ng-repeat="tab in $mdTabsCtrl.tabs" ' +
+ 'md-tabs-template="::tab.label" ' +
+ 'md-scope="::tab.parent"></md-dummy-tab> ' +
+ '</md-tabs-dummy-wrapper> ' +
+ '</md-tabs-canvas> ' +
+ '</md-tabs-wrapper> ' +
+ '<md-tabs-content-wrapper ng-show="$mdTabsCtrl.hasContent && $mdTabsCtrl.selectedIndex >= 0" class="_md"> ' +
+ '<md-tab-content ' +
+ 'id="{{:: $mdTabsCtrl.tabContentPrefix + tab.id}}" ' +
+ 'class="_md" ' +
+ 'role="tabpanel" ' +
+ 'aria-labelledby="tab-item-{{::tab.id}}" ' +
+ 'md-swipe-left="$mdTabsCtrl.swipeContent && $mdTabsCtrl.incrementIndex(1)" ' +
+ 'md-swipe-right="$mdTabsCtrl.swipeContent && $mdTabsCtrl.incrementIndex(-1)" ' +
+ 'ng-if="tab.hasContent" ' +
+ 'ng-repeat="(index, tab) in $mdTabsCtrl.tabs" ' +
+ 'ng-class="{ ' +
+ '\'md-no-transition\': $mdTabsCtrl.lastSelectedIndex == null, ' +
+ '\'md-active\': tab.isActive(), ' +
+ '\'md-left\': tab.isLeft(), ' +
+ '\'md-right\': tab.isRight(), ' +
+ '\'md-no-scroll\': $mdTabsCtrl.dynamicHeight ' +
+ '}"> ' +
+ '<div ' +
+ 'md-tabs-template="::tab.template" ' +
+ 'md-connected-if="tab.isActive()" ' +
+ 'md-scope="::tab.parent" ' +
+ 'ng-if="$mdTabsCtrl.enableDisconnect || tab.shouldRender()"></div> ' +
+ '</md-tab-content> ' +
+ '</md-tabs-content-wrapper>';
+ },
+ controller: 'MdTabsController',
+ controllerAs: '$mdTabsCtrl',
+ bindToController: true
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+
+MdTabsDummyWrapper.$inject = ["$mdUtil", "$window"];angular
+ .module('material.components.tabs')
+ .directive('mdTabsDummyWrapper', MdTabsDummyWrapper);
+
+/**
+ * @private
+ *
+ * @param $mdUtil
+ * @param $window
+ * @returns {{require: string, link: link}}
+ * @constructor
+ *
+ * @ngInject
+ */
+function MdTabsDummyWrapper ($mdUtil, $window) {
+ return {
+ require: '^?mdTabs',
+ link: function link (scope, element, attr, ctrl) {
+ if (!ctrl) return;
+
+ var observer;
+ var disconnect;
+
+ var mutationCallback = function() {
+ ctrl.updatePagination();
+ ctrl.updateInkBarStyles();
+ };
+
+ if ('MutationObserver' in $window) {
+ var config = {
+ childList: true,
+ subtree: true,
+ // Per https://bugzilla.mozilla.org/show_bug.cgi?id=1138368, browsers will not fire
+ // the childList mutation, once a <span> element's innerText changes.
+ // The characterData of the <span> element will change.
+ characterData: true
+ };
+
+ observer = new MutationObserver(mutationCallback);
+ observer.observe(element[0], config);
+ disconnect = observer.disconnect.bind(observer);
+ } else {
+ var debounced = $mdUtil.debounce(mutationCallback, 15, null, false);
+
+ element.on('DOMSubtreeModified', debounced);
+ disconnect = element.off.bind(element, 'DOMSubtreeModified', debounced);
+ }
+
+ // Disconnect the observer
+ scope.$on('$destroy', function() {
+ disconnect();
+ });
+ }
+ };
+}
+
+})();
+(function(){
+"use strict";
+
+
+MdTabsTemplate.$inject = ["$compile", "$mdUtil"];angular
+ .module('material.components.tabs')
+ .directive('mdTabsTemplate', MdTabsTemplate);
+
+function MdTabsTemplate ($compile, $mdUtil) {
+ return {
+ restrict: 'A',
+ link: link,
+ scope: {
+ template: '=mdTabsTemplate',
+ connected: '=?mdConnectedIf',
+ compileScope: '=mdScope'
+ },
+ require: '^?mdTabs'
+ };
+ function link (scope, element, attr, ctrl) {
+ if (!ctrl) return;
+
+ var compileScope = ctrl.enableDisconnect ? scope.compileScope.$new() : scope.compileScope;
+
+ element.html(scope.template);
+ $compile(element.contents())(compileScope);
+
+ return $mdUtil.nextTick(handleScope);
+
+ function handleScope () {
+ scope.$watch('connected', function (value) { value === false ? disconnect() : reconnect(); });
+ scope.$on('$destroy', reconnect);
+ }
+
+ function disconnect () {
+ if (ctrl.enableDisconnect) $mdUtil.disconnectScope(compileScope);
+ }
+
+ function reconnect () {
+ if (ctrl.enableDisconnect) $mdUtil.reconnectScope(compileScope);
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.toast
+ * @description
+ * Toast and Snackbar component.
+ */
+MdToastDirective.$inject = ["$mdToast"];
+MdToastProvider.$inject = ["$$interimElementProvider"];
+angular.module('material.components.toast', [
+ 'material.core',
+ 'material.components.button'
+])
+ .directive('mdToast', MdToastDirective)
+ .provider('$mdToast', MdToastProvider);
+
+/* @ngInject */
+function MdToastDirective($mdToast) {
+ return {
+ restrict: 'E',
+ link: function postLink(scope, element) {
+ element.addClass('_md'); // private md component indicator for styling
+
+ // When navigation force destroys an interimElement, then
+ // listen and $destroy() that interim instance...
+ scope.$on('$destroy', function() {
+ $mdToast.destroy();
+ });
+ }
+ };
+}
+
+/**
+ * @ngdoc service
+ * @name $mdToast
+ * @module material.components.toast
+ *
+ * @description
+ * `$mdToast` is a service to build a toast notification on any position
+ * on the screen with an optional duration, and provides a simple promise API.
+ *
+ * The toast will be always positioned at the `bottom`, when the screen size is
+ * between `600px` and `959px` (`sm` breakpoint)
+ *
+ * ## Restrictions on custom toasts
+ * - The toast's template must have an outer `<md-toast>` element.
+ * - For a toast action, use element with class `md-action`.
+ * - Add the class `md-capsule` for curved corners.
+ *
+ * ### Custom Presets
+ * Developers are also able to create their own preset, which can be easily used without repeating
+ * their options each time.
+ *
+ * <hljs lang="js">
+ * $mdToastProvider.addPreset('testPreset', {
+ * options: function() {
+ * return {
+ * template:
+ * '<md-toast>' +
+ * '<div class="md-toast-content">' +
+ * 'This is a custom preset' +
+ * '</div>' +
+ * '</md-toast>',
+ * controllerAs: 'toast',
+ * bindToController: true
+ * };
+ * }
+ * });
+ * </hljs>
+ *
+ * After you created your preset at config phase, you can easily access it.
+ *
+ * <hljs lang="js">
+ * $mdToast.show(
+ * $mdToast.testPreset()
+ * );
+ * </hljs>
+ *
+ * ## Parent container notes
+ *
+ * The toast is positioned using absolute positioning relative to its first non-static parent
+ * container. Thus, if the requested parent container uses static positioning, we will temporarily
+ * set its positioning to `relative` while the toast is visible and reset it when the toast is
+ * hidden.
+ *
+ * Because of this, it is usually best to ensure that the parent container has a fixed height and
+ * prevents scrolling by setting the `overflow: hidden;` style. Since the position is based off of
+ * the parent's height, the toast may be mispositioned if you allow the parent to scroll.
+ *
+ * You can, however, have a scrollable element inside of the container; just make sure the
+ * container itself does not scroll.
+ *
+ * <hljs lang="html">
+ * <div layout-fill id="toast-container">
+ * <md-content>
+ * I can have lots of content and scroll!
+ * </md-content>
+ * </div>
+ * </hljs>
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div ng-controller="MyController">
+ * <md-button ng-click="openToast()">
+ * Open a Toast!
+ * </md-button>
+ * </div>
+ * </hljs>
+ *
+ * <hljs lang="js">
+ * var app = angular.module('app', ['ngMaterial']);
+ * app.controller('MyController', function($scope, $mdToast) {
+ * $scope.openToast = function($event) {
+ * $mdToast.show($mdToast.simple().textContent('Hello!'));
+ * // Could also do $mdToast.showSimple('Hello');
+ * };
+ * });
+ * </hljs>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdToast#showSimple
+ *
+ * @param {string} message The message to display inside the toast
+ * @description
+ * Convenience method which builds and shows a simple toast.
+ *
+ * @returns {promise} A promise that can be resolved with `$mdToast.hide()`.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdToast#simple
+ *
+ * @description
+ * Builds a preconfigured toast.
+ *
+ * @returns {obj} a `$mdToastPreset` with the following chainable configuration methods.
+ *
+ * _**Note:** These configuration methods are provided in addition to the methods provided by
+ * the `build()` and `show()` methods below._
+ *
+ * <table class="md-api-table methods">
+ * <thead>
+ * <tr>
+ * <th>Method</th>
+ * <th>Description</th>
+ * </tr>
+ * </thead>
+ * <tbody>
+ * <tr>
+ * <td>`.textContent(string)`</td>
+ * <td>Sets the toast content to the specified string</td>
+ * </tr>
+ * <tr>
+ * <td>`.action(string)`</td>
+ * <td>
+ * Adds an action button. <br/>
+ * If clicked, the promise (returned from `show()`) will resolve with the value `'ok'`;
+ * otherwise, it is resolved with `true` after a `hideDelay` timeout.
+ * </td>
+ * </tr>
+ * <tr>
+ * <td>`.actionKey(string)`</td>
+ * <td>
+ * Adds a hotkey for the action button to the page. <br/>
+ * If the `actionKey` and `Control` key are pressed, the toast's action will be triggered.
+ * </td>
+ * </tr>
+ * <tr>
+ * <td>`.actionHint(string)`</td>
+ * <td>
+ * Text that a screen reader will announce to let the user know how to activate the
+ * action. <br>
+ * If an `actionKey` is defined, this defaults to:
+ * 'Press Control-"`actionKey`" to ' followed by the `action`.
+ * </td>
+ * </tr>
+ * <tr>
+ * <td>`.dismissHint(string)`</td>
+ * <td>
+ * Text that a screen reader will announce to let the user know how to dismiss the toast.
+ * <br>Defaults to: "Press Escape to dismiss."
+ * </td>
+ * </tr>
+ * <tr>
+ * <td>`.highlightAction(boolean)`</td>
+ * <td>
+ * Whether or not the action button will have an additional highlight class.<br/>
+ * By default the `accent` color will be applied to the action button.
+ * </td>
+ * </tr>
+ * <tr>
+ * <td>`.highlightClass(string)`</td>
+ * <td>
+ * If set, the given class will be applied to the highlighted action button.<br/>
+ * This allows you to specify the highlight color easily. Highlight classes are
+ * `md-primary`, `md-warn`, and `md-accent`
+ * </td>
+ * </tr>
+ * <tr>
+ * <td>`.capsule(boolean)`</td>
+ * <td>
+ * Whether or not to add the `md-capsule` class to the toast to provide rounded corners
+ * </td>
+ * </tr>
+ * <tr>
+ * <td>`.theme(string)`</td>
+ * <td>
+ * Sets the theme on the toast to the requested theme. Default is `$mdThemingProvider`'s
+ * default.
+ * </td>
+ * </tr>
+ * <tr>
+ * <td>`.toastClass(string)`</td>
+ * <td>Sets a class on the toast element</td>
+ * </tr>
+ * </tbody>
+ * </table>
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdToast#updateTextContent
+ *
+ * @description
+ * Updates the content of an existing toast. Useful for updating things like counts, etc.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdToast#build
+ *
+ * @description
+ * Creates a custom `$mdToastPreset` that you can configure.
+ *
+ * @returns {obj} a `$mdToastPreset` with the chainable configuration methods for shows' options
+ * (see below).
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdToast#show
+ *
+ * @description Shows the toast.
+ *
+ * @param {Object} optionsOrPreset Either provide an `$mdToastPreset` returned from `simple()`
+ * and `build()`, or an options object with the following properties:
+ *
+ * - `templateUrl` - `{string=}`: The url of an html template file that will
+ * be used as the content of the toast. Restrictions: the template must
+ * have an outer `md-toast` element.
+ * - `template` - `{string=}`: Same as templateUrl, except this is an actual
+ * template string.
+ * - `autoWrap` - `{boolean=}`: Whether or not to automatically wrap the template content with a
+ * `<div class="md-toast-content">` if one is not provided. Defaults to true. Can be disabled
+ * if you provide a custom toast directive.
+ * - `scope` - `{Object=}`: the scope to link the template / controller to. If none is specified,
+ * it will create a new child scope. This scope will be destroyed when the toast is removed
+ * unless `preserveScope` is set to true.
+ * - `preserveScope` - `{boolean=}`: whether to preserve the scope when the element is removed.
+ * Default is false
+ * - `hideDelay` - `{number=}`: The number of milliseconds the toast should stay active before
+ * automatically closing. Set to `0` or `false` to have the toast stay open until closed
+ * manually via an action in the toast, a hotkey, or a swipe gesture. For accessibility, toasts
+ * should not automatically close when they contain an action.<br>
+ * Defaults to: `3000`.
+ * - `position` - `{string=}`: Sets the position of the toast. <br/>
+ * Available: any combination of `'bottom'`, `'left'`, `'top'`, `'right'`, `'end'`, and
+ * `'start'`. The properties `'end'` and `'start'` are dynamic and can be used for RTL support.
+ * <br/>
+ * Default combination: `'bottom left'`.
+ * - `toastClass` - `{string=}`: A class to set on the toast element.
+ * - `controller` - `{string=}`: The controller to associate with this toast.
+ * The controller will be injected the local `$mdToast.hide()`, which is a function
+ * used to hide the toast.
+ * - `locals` - `{Object=}`: An object containing key/value pairs. The keys will be used as names
+ * of values to inject into the controller. For example, `locals: {three: 3}` would inject
+ * `three` into the controller with the value of 3.
+ * - `bindToController` - `{boolean=}`: bind the locals to the controller, instead of passing
+ * them in.
+ * - `resolve` - `{Object=}`: Similar to locals, except it takes promises as values
+ * and the toast will not open until the promises resolve.
+ * - `controllerAs` - `{string=}`: An alias to assign the controller to on the scope.
+ * - `parent` - `{element=}`: The element to append the toast to. Defaults to appending
+ * to the root element of the application.
+ *
+ * @returns {promise} A promise that can be resolved with `$mdToast.hide()`. `$mdToast.hide()` will
+ * resolve either with the boolean value `true` or the value passed as an argument to
+ * `$mdToast.hide()`.
+ */
+
+/**
+ * @ngdoc method
+ * @name $mdToast#hide
+ *
+ * @description
+ * Hide an existing toast and resolve the promise returned from `$mdToast.show()`.
+ *
+ * @param {*=} response An argument for the resolved promise.
+ *
+ * @returns {promise} A promise that is called when the existing element is removed from the DOM.
+ * The promise is resolved with either the Boolean value `true` or the value passed as the
+ * argument to `$mdToast.hide()`.
+ */
+
+function MdToastProvider($$interimElementProvider) {
+ // Differentiate promise resolves: hide timeout (value == true) and hide action clicks
+ // (value == ok).
+ MdToastController.$inject = ["$mdToast", "$scope", "$log"];
+ toastDefaultOptions.$inject = ["$animate", "$mdToast", "$mdUtil", "$mdMedia", "$document", "$q"];
+ var ACTION_RESOLVE = 'ok';
+
+ var activeToastContent;
+ var $mdToast = $$interimElementProvider('$mdToast')
+ .setDefaults({
+ methods: ['position', 'hideDelay', 'capsule', 'parent', 'position', 'toastClass'],
+ options: toastDefaultOptions
+ })
+ .addPreset('simple', {
+ argOption: 'textContent',
+ methods: ['textContent', 'action', 'actionKey', 'actionHint', 'highlightAction',
+ 'highlightClass', 'theme', 'parent', 'dismissHint'],
+ options: /* @ngInject */ ["$mdToast", "$mdTheming", function($mdToast, $mdTheming) {
+ return {
+ template:
+ '<md-toast md-theme="{{ toast.theme }}" ng-class="{\'md-capsule\': toast.capsule}">' +
+ ' <div class="md-toast-content" aria-live="polite" aria-relevant="all">' +
+ ' <span class="md-toast-text">' +
+ ' {{ toast.content }}' +
+ ' </span>' +
+ ' <span class="md-visually-hidden">{{ toast.dismissHint }}</span>' +
+ ' <span class="md-visually-hidden" ng-if="toast.action && toast.actionKey">' +
+ ' {{ toast.actionHint }}' +
+ ' </span>' +
+ ' <md-button class="md-action" ng-if="toast.action" ng-click="toast.resolve()" ' +
+ ' ng-class="highlightClasses">' +
+ ' {{ toast.action }}' +
+ ' </md-button>' +
+ ' </div>' +
+ '</md-toast>',
+ controller: MdToastController,
+ theme: $mdTheming.defaultTheme(),
+ controllerAs: 'toast',
+ bindToController: true
+ };
+ }]
+ })
+ .addMethod('updateTextContent', updateTextContent);
+
+ function updateTextContent(newContent) {
+ activeToastContent = newContent;
+ }
+
+ return $mdToast;
+
+ /**
+ * Controller for the Toast interim elements.
+ * @ngInject
+ */
+ function MdToastController($mdToast, $scope, $log) {
+ // For compatibility with AngularJS 1.6+, we should always use the $onInit hook in
+ // interimElements. The $mdCompiler simulates the $onInit hook for all versions.
+ this.$onInit = function() {
+ var self = this;
+
+ if (self.highlightAction) {
+ $scope.highlightClasses = [
+ 'md-highlight',
+ self.highlightClass
+ ];
+ }
+
+ // If an action is defined and no actionKey is specified, then log a warning.
+ if (self.action && !self.actionKey) {
+ $log.warn('Toasts with actions should define an actionKey for accessibility.',
+ 'Details: https://material.angularjs.org/latest/api/service/$mdToast#mdtoast-simple');
+ }
+
+ if (self.actionKey && !self.actionHint) {
+ self.actionHint = 'Press Control-"' + self.actionKey + '" to ';
+ }
+
+ if (!self.dismissHint) {
+ self.dismissHint = 'Press Escape to dismiss.';
+ }
+
+ $scope.$watch(function() { return activeToastContent; }, function() {
+ self.content = activeToastContent;
+ });
+
+ this.resolve = function() {
+ $mdToast.hide(ACTION_RESOLVE);
+ };
+ };
+ }
+
+ /* @ngInject */
+ function toastDefaultOptions($animate, $mdToast, $mdUtil, $mdMedia, $document, $q) {
+ var SWIPE_EVENTS = '$md.swipeleft $md.swiperight $md.swipeup $md.swipedown';
+ return {
+ onShow: onShow,
+ onRemove: onRemove,
+ toastClass: '',
+ position: 'bottom left',
+ themable: true,
+ hideDelay: 3000,
+ autoWrap: true,
+ transformTemplate: function(template, options) {
+ var shouldAddWrapper = options.autoWrap && template && !/md-toast-content/g.test(template);
+
+ if (shouldAddWrapper) {
+ // Root element of template will be <md-toast>. We need to wrap all of its content inside
+ // of <div class="md-toast-content">. All templates provided here should be static,
+ // developer-controlled content (meaning we're not attempting to guard against XSS).
+ var templateRoot = document.createElement('md-template');
+ templateRoot.innerHTML = template;
+
+ // Iterate through all root children, to detect possible md-toast directives.
+ for (var i = 0; i < templateRoot.children.length; i++) {
+ if (templateRoot.children[i].nodeName === 'MD-TOAST') {
+ var wrapper = angular.element('<div class="md-toast-content">');
+
+ // Wrap the children of the `md-toast` directive in jqLite, to be able to append
+ // multiple nodes with the same execution.
+ wrapper.append(angular.element(templateRoot.children[i].childNodes));
+
+ // Append the new wrapped element to the `md-toast` directive.
+ templateRoot.children[i].appendChild(wrapper[0]);
+ }
+ }
+
+ // We have to return the innerHTML, because we do not want to have the `md-template`
+ // element to be the root element of our interimElement.
+ return templateRoot.innerHTML;
+ }
+
+ return template || '';
+ }
+ };
+
+ /**
+ * @param {{toast: {actionKey: string=}}=} scope
+ * @param {JQLite} element
+ * @param {Object.<string, string>} options
+ * @return {*}
+ */
+ function onShow(scope, element, options) {
+ activeToastContent = options.textContent;
+
+ var isSmScreen = !$mdMedia('gt-sm');
+
+ element = $mdUtil.extractElementByName(element, 'md-toast', true);
+ options.element = element;
+
+ options.onSwipe = function(ev) {
+ // Add the relevant swipe class to the element so it can animate correctly
+ var swipe = ev.type.replace('$md.','');
+ var direction = swipe.replace('swipe', '');
+
+ // If the swipe direction is down/up but the toast came from top/bottom don't fade away
+ // Unless the screen is small, then the toast always on bottom
+ if ((direction === 'down' && options.position.indexOf('top') !== -1 && !isSmScreen) ||
+ (direction === 'up' && (options.position.indexOf('bottom') !== -1 || isSmScreen))) {
+ return;
+ }
+
+ if ((direction === 'left' || direction === 'right') && isSmScreen) {
+ return;
+ }
+
+ element.addClass('md-' + swipe);
+ $mdUtil.nextTick($mdToast.cancel);
+ };
+ options.openClass = toastOpenClass(options.position);
+
+ element.addClass(options.toastClass);
+
+ // 'top left' -> 'md-top md-left'
+ options.parent.addClass(options.openClass);
+
+ // static is the default position
+ if ($mdUtil.hasComputedStyle(options.parent, 'position', 'static')) {
+ options.parent.css('position', 'relative');
+ }
+
+ setupActionKeyListener(scope.toast && scope.toast.actionKey ?
+ scope.toast.actionKey : undefined);
+
+ element.on(SWIPE_EVENTS, options.onSwipe);
+
+ var verticalPositionDefined = false;
+ var positionClasses = options.position.split(' ').map(function (position) {
+ if (position) {
+ var className = 'md-' + position;
+ if (className === 'md-top' || className === 'md-bottom') {
+ verticalPositionDefined = true;
+ }
+ return className;
+ }
+ return 'md-bottom';
+ });
+ // If only "right" or "left" are defined, default to a vertical position of "bottom"
+ // as documented.
+ if (!verticalPositionDefined) {
+ positionClasses.push('md-bottom');
+ }
+ element.addClass(isSmScreen ? 'md-bottom' : positionClasses.join(' '));
+
+ if (options.parent) {
+ options.parent.addClass('md-toast-animating');
+ }
+ return $animate.enter(element, options.parent).then(function() {
+ if (options.parent) {
+ options.parent.removeClass('md-toast-animating');
+ }
+ });
+ }
+
+ /**
+ * @param {Object} scope the toast's scope
+ * @param {JQLite} element the toast to be removed
+ * @param {Object} options
+ * @return {Promise<*>} a Promise to remove the element immediately or to animate it out.
+ */
+ function onRemove(scope, element, options) {
+ if (scope.toast && scope.toast.actionKey) {
+ removeActionKeyListener();
+ }
+ element.off(SWIPE_EVENTS, options.onSwipe);
+ if (options.parent) options.parent.addClass('md-toast-animating');
+ if (options.openClass) options.parent.removeClass(options.openClass);
+
+ // Don't run the leave animation if the element has already been destroyed.
+ return ((options.$destroy === true) ? $q.when(element.remove()) : $animate.leave(element))
+ .then(function () {
+ if (options.parent) options.parent.removeClass('md-toast-animating');
+ if ($mdUtil.hasComputedStyle(options.parent, 'position', 'static')) {
+ options.parent.css('position', '');
+ }
+ });
+ }
+
+ function toastOpenClass(position) {
+ // For mobile, always open full-width on bottom
+ if (!$mdMedia('gt-xs')) {
+ return 'md-toast-open-bottom';
+ }
+
+ return 'md-toast-open-' + (position.indexOf('top') > -1 ? 'top' : 'bottom');
+ }
+
+ /**
+ * @param {string} actionKey
+ */
+ function setupActionKeyListener(actionKey) {
+ /**
+ * @param {KeyboardEvent} event
+ */
+ var handleKeyDown = function(event) {
+ if (event.key === 'Escape') {
+ $mdToast.hide(false);
+ }
+ if (actionKey && event.key === actionKey && event.ctrlKey) {
+ $mdToast.hide(ACTION_RESOLVE);
+ }
+ };
+ $document.on('keydown', handleKeyDown);
+ }
+
+ function removeActionKeyListener() {
+ $document.off('keydown');
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.toolbar
+ */
+mdToolbarDirective.$inject = ["$$rAF", "$mdConstant", "$mdUtil", "$mdTheming", "$animate", "$timeout"];
+angular.module('material.components.toolbar', [
+ 'material.core',
+ 'material.components.content'
+])
+ .directive('mdToolbar', mdToolbarDirective);
+
+/**
+ * @ngdoc directive
+ * @name mdToolbar
+ * @module material.components.toolbar
+ * @restrict E
+ * @description
+ * `md-toolbar` is used to place a toolbar in your app.
+ *
+ * Toolbars are usually used above a content area to display the title of the
+ * current page, and show relevant action buttons for that page.
+ *
+ * You can change the height of the toolbar by adding either the
+ * `md-medium-tall` or `md-tall` class to the toolbar.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div layout="column" layout-fill>
+ * <md-toolbar>
+ *
+ * <div class="md-toolbar-tools">
+ * <h2 md-truncate flex>My App's Title</h2>
+ *
+ * <md-button>
+ * Right Bar Button
+ * </md-button>
+ * </div>
+ *
+ * </md-toolbar>
+ * <md-content>
+ * Hello!
+ * </md-content>
+ * </div>
+ * </hljs>
+ *
+ * <i><b>Note:</b> The code above shows usage with the `md-truncate` component which provides an
+ * ellipsis if the title is longer than the width of the Toolbar.</i>
+ *
+ * ## CSS & Styles
+ *
+ * The `<md-toolbar>` provides a few custom CSS classes that you may use to enhance the
+ * functionality of your toolbar.
+ *
+ * <div>
+ * <docs-css-api-table>
+ *
+ * <docs-css-selector code="md-toolbar .md-toolbar-tools">
+ * The `md-toolbar-tools` class provides quite a bit of automatic styling for your toolbar
+ * buttons and text. When applied, it will center the buttons and text vertically for you.
+ * </docs-css-selector>
+ *
+ * </docs-css-api-table>
+ * </div>
+ *
+ * ### Private Classes
+ *
+ * Currently, the only private class is the `md-toolbar-transitions` class. All other classes are
+ * considered public.
+ *
+ * @param {boolean=} md-scroll-shrink Whether the header should shrink away as
+ * the user scrolls down, and reveal itself as the user scrolls up.
+ *
+ * _**Note (1):** for scrollShrink to work, the toolbar must be a sibling of a
+ * `md-content` element, placed before it. See the scroll shrink demo._
+ *
+ * _**Note (2):** The `md-scroll-shrink` attribute is only parsed on component
+ * initialization, it does not watch for scope changes._
+ *
+ *
+ * @param {number=} md-shrink-speed-factor How much to change the speed of the toolbar's
+ * shrinking by. For example, if 0.25 is given then the toolbar will shrink
+ * at one fourth the rate at which the user scrolls down. Default 0.5.
+ *
+ */
+
+function mdToolbarDirective($$rAF, $mdConstant, $mdUtil, $mdTheming, $animate, $timeout) {
+ var translateY = angular.bind(null, $mdUtil.supplant, 'translate3d(0,{0}px,0)');
+
+ return {
+ template: '',
+ restrict: 'E',
+
+ link: function(scope, element, attr) {
+
+ element.addClass('_md'); // private md component indicator for styling
+ $mdTheming(element);
+
+ $mdUtil.nextTick(function () {
+ element.addClass('_md-toolbar-transitions'); // adding toolbar transitions after digest
+ }, false);
+
+ if (angular.isDefined(attr.mdScrollShrink)) {
+ setupScrollShrink();
+ }
+
+ function setupScrollShrink() {
+
+ var toolbarHeight;
+ var contentElement;
+ var disableScrollShrink = angular.noop;
+
+ // Current "y" position of scroll
+ // Store the last scroll top position
+ var y = 0;
+ var prevScrollTop = 0;
+ var shrinkSpeedFactor = attr.mdShrinkSpeedFactor || 0.5;
+
+ var debouncedContentScroll = $$rAF.throttle(onContentScroll);
+ var debouncedUpdateHeight = $mdUtil.debounce(updateToolbarHeight, 5 * 1000);
+
+ // Wait for $mdContentLoaded event from mdContent directive.
+ // If the mdContent element is a sibling of our toolbar, hook it up
+ // to scroll events.
+
+ scope.$on('$mdContentLoaded', onMdContentLoad);
+
+ // If the toolbar is used inside an ng-if statement, we may miss the
+ // $mdContentLoaded event, so we attempt to fake it if we have a
+ // md-content close enough.
+
+ attr.$observe('mdScrollShrink', onChangeScrollShrink);
+
+ // If the toolbar has ngShow or ngHide we need to update height immediately as it changed
+ // and not wait for $mdUtil.debounce to happen
+
+ if (attr.ngShow) { scope.$watch(attr.ngShow, updateToolbarHeight); }
+ if (attr.ngHide) { scope.$watch(attr.ngHide, updateToolbarHeight); }
+
+ // If the scope is destroyed (which could happen with ng-if), make sure
+ // to disable scroll shrinking again
+
+ scope.$on('$destroy', disableScrollShrink);
+
+ /**
+ * @param {string} shrinkWithScroll value of md-scroll-shrink attribute
+ */
+ function onChangeScrollShrink(shrinkWithScroll) {
+ var closestContent = $mdUtil.getSiblings(element, 'md-content');
+
+ // If there are content elements, fake the call using the first content element.
+ // This might still fail if the content element isn't a sibling of the toolbar.
+ if (!contentElement && closestContent.length) {
+ onMdContentLoad(null, closestContent[0]);
+ }
+
+ // Evaluate the expression
+ shrinkWithScroll = scope.$eval(shrinkWithScroll);
+
+ // Disable only if the attribute's expression evaluates to false
+ if (shrinkWithScroll === false) {
+ disableScrollShrink();
+ } else {
+ disableScrollShrink = enableScrollShrink();
+ }
+ }
+
+ /**
+ * @param {null} $event $mdContentLoaded always has a null event
+ * @param {JQLite} newContentEl JQLite object containing an md-content
+ */
+ function onMdContentLoad($event, newContentEl) {
+ // Toolbar and content must be siblings
+ if (newContentEl && element.parent()[0] === newContentEl.parent()[0]) {
+ // unhook old content event listener if exists
+ if (contentElement) {
+ contentElement.off('scroll', debouncedContentScroll);
+ }
+
+ contentElement = newContentEl;
+ disableScrollShrink = enableScrollShrink();
+ }
+ }
+
+ /**
+ *
+ */
+ function onContentScroll(e) {
+ var scrollTop = e ? e.target.scrollTop : prevScrollTop;
+
+ debouncedUpdateHeight();
+
+ y = Math.min(
+ toolbarHeight / shrinkSpeedFactor,
+ Math.max(0, y + scrollTop - prevScrollTop)
+ );
+
+ element.css($mdConstant.CSS.TRANSFORM, translateY([-y * shrinkSpeedFactor]));
+ contentElement.css($mdConstant.CSS.TRANSFORM, translateY([(toolbarHeight - y) * shrinkSpeedFactor]));
+
+ prevScrollTop = scrollTop;
+
+ $mdUtil.nextTick(function() {
+ var hasWhiteFrame = element.hasClass('md-whiteframe-z1');
+
+ if (hasWhiteFrame && !y) {
+ $animate.removeClass(element, 'md-whiteframe-z1');
+ } else if (!hasWhiteFrame && y) {
+ $animate.addClass(element, 'md-whiteframe-z1');
+ }
+ });
+
+ }
+
+ /**
+ *
+ */
+ function enableScrollShrink() {
+ if (!contentElement) return angular.noop; // no md-content
+
+ contentElement.on('scroll', debouncedContentScroll);
+ contentElement.attr('scroll-shrink', 'true');
+
+ $timeout(updateToolbarHeight);
+
+ return function disableScrollShrink() {
+ contentElement.off('scroll', debouncedContentScroll);
+ contentElement.attr('scroll-shrink', 'false');
+
+ updateToolbarHeight();
+ };
+ }
+
+ /**
+ *
+ */
+ function updateToolbarHeight() {
+ toolbarHeight = element.prop('offsetHeight');
+ // Add a negative margin-top the size of the toolbar to the content el.
+ // The content will start transformed down the toolbarHeight amount,
+ // so everything looks normal.
+ //
+ // As the user scrolls down, the content will be transformed up slowly
+ // to put the content underneath where the toolbar was.
+ var margin = (-toolbarHeight * shrinkSpeedFactor) + 'px';
+
+ contentElement.css({
+ "margin-top": margin,
+ "margin-bottom": margin
+ });
+
+ onContentScroll();
+ }
+
+ }
+
+ }
+ };
+
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.tooltip
+ */
+MdTooltipDirective.$inject = ["$timeout", "$window", "$$rAF", "$document", "$interpolate", "$mdUtil", "$mdPanel", "$$mdTooltipRegistry"];
+angular
+ .module('material.components.tooltip', [
+ 'material.core',
+ 'material.components.panel'
+ ])
+ .directive('mdTooltip', MdTooltipDirective)
+ .service('$$mdTooltipRegistry', MdTooltipRegistry);
+
+
+/**
+ * @ngdoc directive
+ * @name mdTooltip
+ * @module material.components.tooltip
+ * @description
+ * Tooltips are used to describe elements that are interactive and primarily
+ * graphical (not textual).
+ *
+ * Place a `<md-tooltip>` as a child of the element it describes.
+ *
+ * A tooltip will activate when the user hovers over, focuses, or touches the
+ * parent element.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-button class="md-fab md-accent" aria-label="Play">
+ * <md-tooltip>Play Music</md-tooltip>
+ * <md-icon md-svg-src="img/icons/ic_play_arrow_24px.svg"></md-icon>
+ * </md-button>
+ * </hljs>
+ *
+ * @param {number=} md-z-index The visual level that the tooltip will appear
+ * in comparison with the rest of the elements of the application.
+ * @param {expression=} md-visible Boolean bound to whether the tooltip is
+ * currently visible.
+ * @param {number=} md-delay How many milliseconds to wait to show the tooltip
+ * after the user hovers over, focuses, or touches the parent element.
+ * Defaults to 0ms on non-touch devices and 75ms on touch.
+ * @param {boolean=} md-autohide If present or provided with a boolean value,
+ * the tooltip will hide on mouse leave, regardless of focus.
+ * @param {string=} md-direction The direction that the tooltip is shown,
+ * relative to the parent element. Supports top, right, bottom, and left.
+ * Defaults to bottom.
+ */
+function MdTooltipDirective($timeout, $window, $$rAF, $document, $interpolate,
+ $mdUtil, $mdPanel, $$mdTooltipRegistry) {
+
+ var ENTER_EVENTS = 'focus touchstart mouseenter';
+ var LEAVE_EVENTS = 'blur touchcancel mouseleave';
+ var TOOLTIP_DEFAULT_Z_INDEX = 100;
+ var TOOLTIP_DEFAULT_SHOW_DELAY = 0;
+ var TOOLTIP_DEFAULT_DIRECTION = 'bottom';
+ var TOOLTIP_DIRECTIONS = {
+ top: { x: $mdPanel.xPosition.CENTER, y: $mdPanel.yPosition.ABOVE },
+ right: { x: $mdPanel.xPosition.OFFSET_END, y: $mdPanel.yPosition.CENTER },
+ bottom: { x: $mdPanel.xPosition.CENTER, y: $mdPanel.yPosition.BELOW },
+ left: { x: $mdPanel.xPosition.OFFSET_START, y: $mdPanel.yPosition.CENTER }
+ };
+
+ return {
+ restrict: 'E',
+ priority: 210, // Before ngAria
+ scope: {
+ mdZIndex: '=?mdZIndex',
+ mdDelay: '=?mdDelay',
+ mdVisible: '=?mdVisible',
+ mdAutohide: '=?mdAutohide',
+ mdDirection: '@?mdDirection' // Do not expect expressions.
+ },
+ link: linkFunc
+ };
+
+ function linkFunc(scope, element, attr) {
+ // Set constants.
+ var tooltipId = 'md-tooltip-' + $mdUtil.nextUid();
+ var parent = $mdUtil.getParentWithPointerEvents(element);
+ var debouncedOnResize = $$rAF.throttle(updatePosition);
+ var mouseActive = false;
+ var origin, position, panelPosition, panelRef, autohide, showTimeout,
+ elementFocusedOnWindowBlur = null;
+
+ // Set defaults
+ setDefaults();
+
+ // Set parent aria-label.
+ addAriaLabel();
+
+ // Remove the element from its current DOM position.
+ element.detach();
+
+ updatePosition();
+ bindEvents();
+ configureWatchers();
+
+ function setDefaults() {
+ scope.mdZIndex = scope.mdZIndex || TOOLTIP_DEFAULT_Z_INDEX;
+ scope.mdDelay = scope.mdDelay || TOOLTIP_DEFAULT_SHOW_DELAY;
+ if (!TOOLTIP_DIRECTIONS[scope.mdDirection]) {
+ scope.mdDirection = TOOLTIP_DEFAULT_DIRECTION;
+ }
+ }
+
+ function addAriaLabel(labelText) {
+ // Only interpolate the text from the HTML element because otherwise the custom text could
+ // be interpolated twice and cause XSS violations.
+ var interpolatedText = labelText || $interpolate(element.text().trim())(scope.$parent);
+
+ // Only add the `aria-label` to the parent if there isn't already one, if there isn't an
+ // already present `aria-labelledby`, or if the previous `aria-label` was added by the
+ // tooltip directive.
+ if (
+ (!parent.attr('aria-label') && !parent.attr('aria-labelledby')) ||
+ parent.attr('md-labeled-by-tooltip')
+ ) {
+ parent.attr('aria-label', interpolatedText);
+
+ // Set the `md-labeled-by-tooltip` attribute if it has not already been set.
+ if (!parent.attr('md-labeled-by-tooltip')) {
+ parent.attr('md-labeled-by-tooltip', tooltipId);
+ }
+ }
+ }
+
+ function updatePosition() {
+ setDefaults();
+
+ // If the panel has already been created, remove the current origin
+ // class from the panel element.
+ if (panelRef && panelRef.panelEl) {
+ panelRef.panelEl.removeClass(origin);
+ }
+
+ // Set the panel element origin class based off of the current
+ // mdDirection.
+ origin = 'md-origin-' + scope.mdDirection;
+
+ // Create the position of the panel based off of the mdDirection.
+ position = TOOLTIP_DIRECTIONS[scope.mdDirection];
+
+ // Using the newly created position object, use the MdPanel
+ // panelPosition API to build the panel's position.
+ panelPosition = $mdPanel.newPanelPosition()
+ .relativeTo(parent)
+ .addPanelPosition(position.x, position.y);
+
+ // If the panel has already been created, add the new origin class to
+ // the panel element and update it's position with the panelPosition.
+ if (panelRef && panelRef.panelEl) {
+ panelRef.panelEl.addClass(origin);
+ panelRef.updatePosition(panelPosition);
+ }
+ }
+
+ function bindEvents() {
+ // Add a mutationObserver where there is support for it and the need
+ // for it in the form of viable host(parent[0]).
+ if (parent[0] && 'MutationObserver' in $window) {
+ // Use a mutationObserver to tackle #2602.
+ var attributeObserver = new MutationObserver(function(mutations) {
+ if (isDisabledMutation(mutations)) {
+ $mdUtil.nextTick(function() {
+ setVisible(false);
+ });
+ }
+ });
+
+ attributeObserver.observe(parent[0], {
+ attributes: true
+ });
+ }
+
+ elementFocusedOnWindowBlur = false;
+
+ $$mdTooltipRegistry.register('scroll', windowScrollEventHandler, true);
+ $$mdTooltipRegistry.register('blur', windowBlurEventHandler);
+ $$mdTooltipRegistry.register('resize', debouncedOnResize);
+
+ scope.$on('$destroy', onDestroy);
+
+ // To avoid 'synthetic clicks', we listen to mousedown instead of
+ // 'click'.
+ parent.on('mousedown', mousedownEventHandler);
+ parent.on(ENTER_EVENTS, enterEventHandler);
+
+ function isDisabledMutation(mutations) {
+ mutations.some(function(mutation) {
+ return mutation.attributeName === 'disabled' && parent[0].disabled;
+ });
+ return false;
+ }
+
+ function windowScrollEventHandler() {
+ setVisible(false);
+ }
+
+ function windowBlurEventHandler() {
+ elementFocusedOnWindowBlur = document.activeElement === parent[0];
+ }
+
+ function enterEventHandler($event) {
+ // Prevent the tooltip from showing when the window is receiving
+ // focus.
+ if ($event.type === 'focus' && elementFocusedOnWindowBlur) {
+ elementFocusedOnWindowBlur = false;
+ } else if (!scope.mdVisible) {
+ parent.on(LEAVE_EVENTS, leaveEventHandler);
+ setVisible(true);
+
+ // If the user is on a touch device, we should bind the tap away
+ // after the 'touched' in order to prevent the tooltip being
+ // removed immediately.
+ if ($event.type === 'touchstart') {
+ parent.one('touchend', function() {
+ $mdUtil.nextTick(function() {
+ $document.one('touchend', leaveEventHandler);
+ }, false);
+ });
+ }
+ }
+ }
+
+ function leaveEventHandler() {
+ autohide = scope.hasOwnProperty('mdAutohide') ?
+ scope.mdAutohide :
+ attr.hasOwnProperty('mdAutohide');
+
+ if (autohide || mouseActive ||
+ $document[0].activeElement !== parent[0]) {
+ // When a show timeout is currently in progress, then we have
+ // to cancel it, otherwise the tooltip will remain showing
+ // without focus or hover.
+ if (showTimeout) {
+ $timeout.cancel(showTimeout);
+ setVisible.queued = false;
+ showTimeout = null;
+ }
+
+ parent.off(LEAVE_EVENTS, leaveEventHandler);
+ parent.triggerHandler('blur');
+ setVisible(false);
+ }
+ mouseActive = false;
+ }
+
+ function mousedownEventHandler() {
+ mouseActive = true;
+ }
+
+ function onDestroy() {
+ $$mdTooltipRegistry.deregister('scroll', windowScrollEventHandler, true);
+ $$mdTooltipRegistry.deregister('blur', windowBlurEventHandler);
+ $$mdTooltipRegistry.deregister('resize', debouncedOnResize);
+
+ parent
+ .off(ENTER_EVENTS, enterEventHandler)
+ .off(LEAVE_EVENTS, leaveEventHandler)
+ .off('mousedown', mousedownEventHandler);
+
+ // Trigger the handler in case any of the tooltips are
+ // still visible.
+ leaveEventHandler();
+ attributeObserver && attributeObserver.disconnect();
+ }
+ }
+
+ function configureWatchers() {
+ if (element[0] && 'MutationObserver' in $window) {
+ var attributeObserver = new MutationObserver(function(mutations) {
+ mutations.forEach(function(mutation) {
+ if (mutation.attributeName === 'md-visible' &&
+ !scope.visibleWatcher) {
+ scope.visibleWatcher = scope.$watch('mdVisible',
+ onVisibleChanged);
+ }
+ });
+ });
+
+ attributeObserver.observe(element[0], {
+ attributes: true
+ });
+
+ // Build watcher only if mdVisible is being used.
+ if (attr.hasOwnProperty('mdVisible')) {
+ scope.visibleWatcher = scope.$watch('mdVisible',
+ onVisibleChanged);
+ }
+ } else {
+ // MutationObserver not supported
+ scope.visibleWatcher = scope.$watch('mdVisible', onVisibleChanged);
+ }
+
+ // Direction watcher
+ scope.$watch('mdDirection', updatePosition);
+
+ // Clean up if the element or parent was removed via jqLite's .remove.
+ // A couple of notes:
+ // - In these cases the scope might not have been destroyed, which
+ // is why we destroy it manually. An example of this can be having
+ // `md-visible="false"` and adding tooltips while they're
+ // invisible. If `md-visible` becomes true, at some point, you'd
+ // usually get a lot of tooltips.
+ // - We use `.one`, not `.on`, because this only needs to fire once.
+ // If we were using `.on`, it would get thrown into an infinite
+ // loop.
+ // - This kicks off the scope's `$destroy` event which finishes the
+ // cleanup.
+ element.one('$destroy', onElementDestroy);
+ parent.one('$destroy', onElementDestroy);
+ scope.$on('$destroy', function() {
+ setVisible(false);
+ panelRef && panelRef.destroy();
+ attributeObserver && attributeObserver.disconnect();
+ element.remove();
+ });
+
+ // Updates the aria-label when the element text changes. This watch
+ // doesn't need to be set up if the element doesn't have any data
+ // bindings.
+ if (element.text().indexOf($interpolate.startSymbol()) > -1) {
+ scope.$watch(function() {
+ return element.text().trim();
+ }, addAriaLabel);
+ }
+
+ function onElementDestroy() {
+ scope.$destroy();
+ }
+ }
+
+ function setVisible(value) {
+ // Break if passed value is already in queue or there is no queue and
+ // passed value is current in the controller.
+ if (setVisible.queued && setVisible.value === !!value ||
+ !setVisible.queued && scope.mdVisible === !!value) {
+ return;
+ }
+ setVisible.value = !!value;
+
+ if (!setVisible.queued) {
+ if (value) {
+ setVisible.queued = true;
+ showTimeout = $timeout(function() {
+ scope.mdVisible = setVisible.value;
+ setVisible.queued = false;
+ showTimeout = null;
+ if (!scope.visibleWatcher) {
+ onVisibleChanged(scope.mdVisible);
+ }
+ }, scope.mdDelay);
+ } else {
+ $mdUtil.nextTick(function() {
+ scope.mdVisible = false;
+ if (!scope.visibleWatcher) {
+ onVisibleChanged(false);
+ }
+ });
+ }
+ }
+ }
+
+ function onVisibleChanged(isVisible) {
+ isVisible ? showTooltip() : hideTooltip();
+ }
+
+ function showTooltip() {
+ // Do not show the tooltip if the text is empty.
+ if (!element[0].textContent.trim()) {
+ throw new Error('Text for the tooltip has not been provided. ' +
+ 'Please include text within the mdTooltip element.');
+ }
+
+ if (!panelRef) {
+ var attachTo = angular.element(document.body);
+ var panelAnimation = $mdPanel.newPanelAnimation()
+ .openFrom(parent)
+ .closeTo(parent)
+ .withAnimation({
+ open: 'md-show',
+ close: 'md-hide'
+ });
+
+ var panelConfig = {
+ id: tooltipId,
+ attachTo: attachTo,
+ contentElement: element,
+ propagateContainerEvents: true,
+ panelClass: 'md-tooltip',
+ animation: panelAnimation,
+ position: panelPosition,
+ zIndex: scope.mdZIndex,
+ focusOnOpen: false,
+ onDomAdded: function() {
+ panelRef.panelEl.addClass(origin);
+ }
+ };
+
+ panelRef = $mdPanel.create(panelConfig);
+ }
+
+ panelRef.open().then(function() {
+ panelRef.panelEl.attr('role', 'tooltip');
+ });
+ }
+
+ function hideTooltip() {
+ panelRef && panelRef.close();
+ }
+ }
+
+}
+
+
+/**
+ * Service that is used to reduce the amount of listeners that are being
+ * registered on the `window` by the tooltip component. Works by collecting
+ * the individual event handlers and dispatching them from a global handler.
+ *
+ * @ngInject
+ */
+function MdTooltipRegistry() {
+ var listeners = {};
+ var ngWindow = angular.element(window);
+
+ return {
+ register: register,
+ deregister: deregister
+ };
+
+ /**
+ * Global event handler that dispatches the registered handlers in the
+ * service.
+ * @param {!Event} event Event object passed in by the browser
+ */
+ function globalEventHandler(event) {
+ if (listeners[event.type]) {
+ listeners[event.type].forEach(function(currentHandler) {
+ currentHandler.call(this, event);
+ }, this);
+ }
+ }
+
+ /**
+ * Registers a new handler with the service.
+ * @param {string} type Type of event to be registered.
+ * @param {!Function} handler Event handler.
+ * @param {boolean} useCapture Whether to use event capturing.
+ */
+ function register(type, handler, useCapture) {
+ var handlers = listeners[type] = listeners[type] || [];
+
+ if (!handlers.length) {
+ useCapture ? window.addEventListener(type, globalEventHandler, true) :
+ ngWindow.on(type, globalEventHandler);
+ }
+
+ if (handlers.indexOf(handler) === -1) {
+ handlers.push(handler);
+ }
+ }
+
+ /**
+ * Removes an event handler from the service.
+ * @param {string} type Type of event handler.
+ * @param {!Function} handler The event handler itself.
+ * @param {boolean} useCapture Whether the event handler used event capturing.
+ */
+ function deregister(type, handler, useCapture) {
+ var handlers = listeners[type];
+ var index = handlers ? handlers.indexOf(handler) : -1;
+
+ if (index > -1) {
+ handlers.splice(index, 1);
+
+ if (handlers.length === 0) {
+ useCapture ? window.removeEventListener(type, globalEventHandler, true) :
+ ngWindow.off(type, globalEventHandler);
+ }
+ }
+ }
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.truncate
+ */
+MdTruncateController.$inject = ["$element"];
+angular.module('material.components.truncate', ['material.core'])
+ .directive('mdTruncate', MdTruncateDirective);
+
+/**
+ * @ngdoc directive
+ * @name mdTruncate
+ * @module material.components.truncate
+ * @restrict AE
+ * @description
+ *
+ * The `md-truncate` component displays a label that will automatically clip text which is wider
+ * than the component. By default, it displays an ellipsis, but you may apply the `md-clip` CSS
+ * class to override this default and use a standard "clipping" approach.
+ *
+ * <i><b>Note:</b> The `md-truncate` component does not automatically adjust it's width. You must
+ * provide the `flex` attribute, or some other CSS-based width management. See the
+ * <a ng-href="./demo/truncate">demos</a> for examples.</i>
+ *
+ * @usage
+ *
+ * ### As an Element
+ *
+ * <hljs lang="html">
+ * <div layout="row">
+ * <md-button>Back</md-button>
+ *
+ * <md-truncate flex>Chapter 1 - The Way of the Old West</md-truncate>
+ *
+ * <md-button>Forward</md-button>
+ * </div>
+ * </hljs>
+ *
+ * ### As an Attribute
+ *
+ * <hljs lang="html">
+ * <h2 md-truncate style="max-width: 100px;">Some Title With a Lot of Text</h2>
+ * </hljs>
+ *
+ * ## CSS & Styles
+ *
+ * `<md-truncate>` provides two CSS classes that you may use to control the type of clipping.
+ *
+ * <i><b>Note:</b> The `md-truncate` also applies a setting of `width: 0;` when used with the `flex`
+ * attribute to fix an issue with the flex element not shrinking properly.</i>
+ *
+ * <div>
+ * <docs-css-api-table>
+ *
+ * <docs-css-selector code=".md-ellipsis">
+ * Assigns the "ellipsis" behavior (default) which will cut off mid-word and append an ellipsis
+ * (…) to the end of the text.
+ * </docs-css-selector>
+ *
+ * <docs-css-selector code=".md-clip">
+ * Assigns the "clipping" behavior which will simply chop off the text. This may happen
+ * mid-word or even mid-character.
+ * </docs-css-selector>
+ *
+ * </docs-css-api-table>
+ * </div>
+ */
+function MdTruncateDirective() {
+ return {
+ restrict: 'AE',
+
+ controller: MdTruncateController
+ };
+}
+
+/**
+ * Controller for the <md-truncate> component.
+ *
+ * @param $element The md-truncate element.
+ *
+ * @constructor
+ * @ngInject
+ */
+function MdTruncateController($element) {
+ $element.addClass('md-truncate');
+}
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.virtualRepeat
+ */
+VirtualRepeatContainerController.$inject = ["$$rAF", "$mdUtil", "$mdConstant", "$parse", "$rootScope", "$window", "$scope", "$element", "$attrs"];
+VirtualRepeatController.$inject = ["$scope", "$element", "$attrs", "$browser", "$document", "$rootScope", "$$rAF", "$mdUtil"];
+VirtualRepeatDirective.$inject = ["$parse"];
+angular.module('material.components.virtualRepeat', [
+ 'material.core',
+ 'material.components.showHide'
+])
+.directive('mdVirtualRepeatContainer', VirtualRepeatContainerDirective)
+.directive('mdVirtualRepeat', VirtualRepeatDirective)
+.directive('mdForceHeight', ForceHeightDirective);
+
+
+/**
+ * @ngdoc directive
+ * @name mdVirtualRepeatContainer
+ * @module material.components.virtualRepeat
+ * @restrict E
+ * @description
+ * `md-virtual-repeat-container` provides the scroll container for
+ * <a ng-href="api/directive/mdVirtualRepeat">md-virtual-repeat</a>.
+ *
+ * VirtualRepeat is a limited substitute for `ng-repeat` that renders only
+ * enough DOM nodes to fill the container, recycling them as the user scrolls.
+ *
+ * Once an element is not visible anymore, the Virtual Repeat recycles the element and reuses it
+ * for another visible item by replacing the previous data set with the set of currently visible
+ * elements.
+ *
+ * ### Common Issues
+ *
+ * - When having one-time bindings inside of the view template, the Virtual Repeat will not properly
+ * update the bindings for new items, since the view will be recycled.
+ * - Directives inside of a Virtual Repeat will be only compiled (linked) once, because those
+ * items will be recycled and used for other items.
+ * The Virtual Repeat just updates the scope bindings.
+ *
+ *
+ * ### Notes
+ *
+ * > The VirtualRepeat is a similar implementation to the Android
+ * [RecyclerView](https://developer.android.com/reference/android/support/v7/widget/RecyclerView.html).
+ *
+ * <!-- This comment forces a break between blockquotes //-->
+ *
+ * > Please also review the <a ng-href="api/directive/mdVirtualRepeat">mdVirtualRepeat</a>
+ * documentation for more information.
+ *
+ *
+ * @usage
+ * <hljs lang="html">
+ *
+ * <md-virtual-repeat-container md-top-index="topIndex">
+ * <div md-virtual-repeat="i in items" md-item-size="20">Hello {{i}}!</div>
+ * </md-virtual-repeat-container>
+ * </hljs>
+ *
+ * @param {boolean=} md-auto-shrink When present and the container will shrink to fit
+ * the number of items in the `md-virtual-repeat`.
+ * @param {number=} md-auto-shrink-min Minimum number of items that md-auto-shrink
+ * will shrink to. Default: `0`.
+ * @param {boolean=} md-orient-horizontal Whether the container should scroll horizontally.
+ * The default is `false` which indicates vertical orientation and scrolling.
+ * @param {number=} md-top-index Binds the index of the item that is at the top of the scroll
+ * container to `$scope`. It can both read and set the scroll position.
+ */
+function VirtualRepeatContainerDirective() {
+ return {
+ controller: VirtualRepeatContainerController,
+ template: virtualRepeatContainerTemplate,
+ compile: function virtualRepeatContainerCompile($element, $attrs) {
+ $element
+ .addClass('md-virtual-repeat-container')
+ .addClass($attrs.hasOwnProperty('mdOrientHorizontal')
+ ? 'md-orient-horizontal'
+ : 'md-orient-vertical');
+ }
+ };
+}
+
+
+function virtualRepeatContainerTemplate($element) {
+ return '<div class="md-virtual-repeat-scroller" role="presentation">' +
+ '<div class="md-virtual-repeat-sizer" role="presentation"></div>' +
+ '<div class="md-virtual-repeat-offsetter" role="presentation">' +
+ $element[0].innerHTML +
+ '</div></div>';
+}
+
+/**
+ * Number of additional elements to render above and below the visible area inside
+ * of the virtual repeat container. A higher number results in less flicker when scrolling
+ * very quickly in Safari, but comes with a higher rendering and dirty-checking cost.
+ * @const {number}
+ */
+var NUM_EXTRA = 3;
+
+/** @ngInject */
+function VirtualRepeatContainerController($$rAF, $mdUtil, $mdConstant, $parse, $rootScope, $window,
+ $scope, $element, $attrs) {
+ this.$rootScope = $rootScope;
+ this.$scope = $scope;
+ this.$element = $element;
+ this.$attrs = $attrs;
+
+ /** @type {number} The width or height of the container */
+ this.size = 0;
+ /** @type {number} The scroll width or height of the scroller */
+ this.scrollSize = 0;
+ /** @type {number} The scrollLeft or scrollTop of the scroller */
+ this.scrollOffset = 0;
+ /** @type {boolean} Whether the scroller is oriented horizontally */
+ this.horizontal = this.$attrs.hasOwnProperty('mdOrientHorizontal');
+ /** @type {!VirtualRepeatController} The repeater inside of this container */
+ this.repeater = null;
+ /** @type {boolean} Whether auto-shrink is enabled */
+ this.autoShrink = this.$attrs.hasOwnProperty('mdAutoShrink');
+ /** @type {number} Minimum number of items to auto-shrink to */
+ this.autoShrinkMin = parseInt(this.$attrs.mdAutoShrinkMin, 10) || 0;
+ /** @type {?number} Original container size when shrank */
+ this.originalSize = null;
+ /** @type {number} Amount to offset the total scroll size by. */
+ this.offsetSize = parseInt(this.$attrs.mdOffsetSize, 10) || 0;
+ /** @type {?string} height or width element style on the container prior to auto-shrinking. */
+ this.oldElementSize = null;
+ /** @type {!number} Maximum amount of pixels allowed for a single DOM element */
+ this.maxElementPixels = $mdConstant.ELEMENT_MAX_PIXELS;
+ /** @type {string} Direction of the text */
+ this.ltr = !$mdUtil.isRtl(this.$attrs);
+
+ if (this.$attrs.mdTopIndex) {
+ /** @type {function(angular.Scope): number} Binds to topIndex on AngularJS scope */
+ this.bindTopIndex = $parse(this.$attrs.mdTopIndex);
+ /** @type {number} The index of the item that is at the top of the scroll container */
+ this.topIndex = this.bindTopIndex(this.$scope);
+
+ if (!angular.isDefined(this.topIndex)) {
+ this.topIndex = 0;
+ this.bindTopIndex.assign(this.$scope, 0);
+ }
+
+ this.$scope.$watch(this.bindTopIndex, angular.bind(this, function(newIndex) {
+ if (newIndex !== this.topIndex) {
+ this.scrollToIndex(newIndex);
+ }
+ }));
+ } else {
+ this.topIndex = 0;
+ }
+
+ this.scroller = $element[0].querySelector('.md-virtual-repeat-scroller');
+ this.sizer = this.scroller.querySelector('.md-virtual-repeat-sizer');
+ this.offsetter = this.scroller.querySelector('.md-virtual-repeat-offsetter');
+
+ // After the DOM stabilizes, measure the initial size of the container and
+ // make a best effort at re-measuring as it changes.
+ var boundUpdateSize = angular.bind(this, this.updateSize);
+
+ $$rAF(angular.bind(this, function() {
+ boundUpdateSize();
+
+ var debouncedUpdateSize = $mdUtil.debounce(boundUpdateSize, 10, null, false);
+ var jWindow = angular.element($window);
+
+ // Make one more attempt to get the size if it is 0.
+ // This is not by any means a perfect approach, but there's really no
+ // silver bullet here.
+ if (!this.size) {
+ debouncedUpdateSize();
+ }
+
+ jWindow.on('resize', debouncedUpdateSize);
+ $scope.$on('$destroy', function() {
+ jWindow.off('resize', debouncedUpdateSize);
+ });
+
+ $scope.$emit('$md-resize-enable');
+ $scope.$on('$md-resize', boundUpdateSize);
+ }));
+}
+
+
+/** Called by the md-virtual-repeat inside of the container at startup. */
+VirtualRepeatContainerController.prototype.register = function(repeaterCtrl) {
+ this.repeater = repeaterCtrl;
+
+ angular.element(this.scroller)
+ .on('scroll wheel touchmove touchend', angular.bind(this, this.handleScroll_));
+};
+
+
+/** @return {boolean} Whether the container is configured for horizontal scrolling. */
+VirtualRepeatContainerController.prototype.isHorizontal = function() {
+ return this.horizontal;
+};
+
+
+/** @return {number} The size (width or height) of the container. */
+VirtualRepeatContainerController.prototype.getSize = function() {
+ return this.size;
+};
+
+
+/**
+ * Resizes the container.
+ * @private
+ * @param {number} size The new size to set.
+ */
+VirtualRepeatContainerController.prototype.setSize_ = function(size) {
+ var dimension = this.getDimensionName_();
+
+ this.size = size;
+ this.$element[0].style[dimension] = size + 'px';
+};
+
+
+VirtualRepeatContainerController.prototype.unsetSize_ = function() {
+ this.$element[0].style[this.getDimensionName_()] = this.oldElementSize;
+ this.oldElementSize = null;
+};
+
+
+/** Instructs the container to re-measure its size. */
+VirtualRepeatContainerController.prototype.updateSize = function() {
+ // If the original size is already determined, we can skip the update.
+ if (this.originalSize) return;
+
+ var size = this.isHorizontal()
+ ? this.$element[0].clientWidth
+ : this.$element[0].clientHeight;
+
+ if (size) {
+ this.size = size;
+ }
+
+ // Recheck the scroll position after updating the size. This resolves
+ // problems that can result if the scroll position was measured while the
+ // element was display: none or detached from the document.
+ this.handleScroll_();
+
+ this.repeater && this.repeater.containerUpdated();
+};
+
+
+/** @return {number} The container's scrollHeight or scrollWidth. */
+VirtualRepeatContainerController.prototype.getScrollSize = function() {
+ return this.scrollSize;
+};
+
+/**
+ * @returns {string} either width or height dimension
+ * @private
+ */
+VirtualRepeatContainerController.prototype.getDimensionName_ = function() {
+ return this.isHorizontal() ? 'width' : 'height';
+};
+
+
+/**
+ * Sets the scroller element to the specified size.
+ * @private
+ * @param {number} size The new size.
+ */
+VirtualRepeatContainerController.prototype.sizeScroller_ = function(size) {
+ var dimension = this.getDimensionName_();
+ var crossDimension = this.isHorizontal() ? 'height' : 'width';
+
+ // Clear any existing dimensions.
+ this.sizer.innerHTML = '';
+
+ // If the size falls within the browser's maximum explicit size for a single element, we can
+ // set the size and be done. Otherwise, we have to create children that add up the the desired
+ // size.
+ if (size < this.maxElementPixels) {
+ this.sizer.style[dimension] = size + 'px';
+ } else {
+ this.sizer.style[dimension] = 'auto';
+ this.sizer.style[crossDimension] = 'auto';
+
+ // Divide the total size we have to render into N max-size pieces.
+ var numChildren = Math.floor(size / this.maxElementPixels);
+
+ // Element template to clone for each max-size piece.
+ var sizerChild = document.createElement('div');
+ sizerChild.style[dimension] = this.maxElementPixels + 'px';
+ sizerChild.style[crossDimension] = '1px';
+
+ for (var i = 0; i < numChildren; i++) {
+ this.sizer.appendChild(sizerChild.cloneNode(false));
+ }
+
+ // Re-use the element template for the remainder.
+ sizerChild.style[dimension] = (size - (numChildren * this.maxElementPixels)) + 'px';
+ this.sizer.appendChild(sizerChild);
+ }
+};
+
+
+/**
+ * If auto-shrinking is enabled, shrinks or unshrinks as appropriate.
+ * @private
+ * @param {number} size The new size.
+ */
+VirtualRepeatContainerController.prototype.autoShrink_ = function(size) {
+ var shrinkSize = Math.max(size, this.autoShrinkMin * this.repeater.getItemSize());
+
+ if (this.autoShrink && shrinkSize !== this.size) {
+ if (this.oldElementSize === null) {
+ this.oldElementSize = this.$element[0].style[this.getDimensionName_()];
+ }
+
+ var currentSize = this.originalSize || this.size;
+
+ if (!currentSize || shrinkSize < currentSize) {
+ if (!this.originalSize) {
+ this.originalSize = this.size;
+ }
+
+ // Now we update the containers size, because shrinking is enabled.
+ this.setSize_(shrinkSize);
+ } else if (this.originalSize !== null) {
+ // Set the size back to our initial size.
+ this.unsetSize_();
+
+ var _originalSize = this.originalSize;
+ this.originalSize = null;
+
+ // We determine the repeaters size again, if the original size was zero.
+ // The originalSize needs to be null, to be able to determine the size.
+ if (!_originalSize) this.updateSize();
+
+ // Apply the original size or the determined size back to the container, because
+ // it has been overwritten before, in the shrink block.
+ this.setSize_(_originalSize || this.size);
+ }
+
+ this.repeater.containerUpdated();
+ }
+};
+
+
+/**
+ * Sets the scrollHeight or scrollWidth. Called by the repeater based on
+ * its item count and item size.
+ * @param {number} itemsSize The total size of the items.
+ */
+VirtualRepeatContainerController.prototype.setScrollSize = function(itemsSize) {
+ var size = itemsSize + this.offsetSize;
+ if (this.scrollSize === size) return;
+
+ this.sizeScroller_(size);
+ this.autoShrink_(size);
+ this.scrollSize = size;
+};
+
+
+/** @return {number} The container's current scroll offset. */
+VirtualRepeatContainerController.prototype.getScrollOffset = function() {
+ return this.scrollOffset;
+};
+
+/**
+ * Scrolls to a given scrollTop position.
+ * @param {number} position
+ */
+VirtualRepeatContainerController.prototype.scrollTo = function(position) {
+ this.scroller[this.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = position;
+ this.handleScroll_();
+};
+
+/**
+ * Scrolls the item with the given index to the top of the scroll container.
+ * @param {number} index
+ */
+VirtualRepeatContainerController.prototype.scrollToIndex = function(index) {
+ var itemSize = this.repeater.getItemSize();
+ var itemsLength = this.repeater.itemsLength;
+ if (index > itemsLength) {
+ index = itemsLength - 1;
+ }
+ this.scrollTo(itemSize * index);
+};
+
+VirtualRepeatContainerController.prototype.resetScroll = function() {
+ this.scrollTo(0);
+};
+
+
+VirtualRepeatContainerController.prototype.handleScroll_ = function() {
+ if (!this.ltr && !this.maxSize) {
+ this.scroller.scrollLeft = this.scrollSize;
+ this.maxSize = this.scroller.scrollLeft;
+ }
+ var offset = this.isHorizontal() ?
+ (this.ltr ? this.scroller.scrollLeft : this.maxSize - this.scroller.scrollLeft)
+ : this.scroller.scrollTop;
+ if (this.scrollSize < this.size) return;
+ if (offset > this.scrollSize - this.size) {
+ offset = this.scrollSize - this.size;
+ }
+ if (offset === this.scrollOffset) return;
+
+ var itemSize = this.repeater.getItemSize();
+ if (!itemSize) return;
+
+ var numItems = Math.max(0, Math.floor(offset / itemSize) - NUM_EXTRA);
+
+ var transform = (this.isHorizontal() ? 'translateX(' : 'translateY(') +
+ (!this.isHorizontal() || this.ltr ? (numItems * itemSize) : - (numItems * itemSize)) + 'px)';
+
+ this.scrollOffset = offset;
+ this.offsetter.style.webkitTransform = transform;
+ this.offsetter.style.transform = transform;
+
+ if (this.bindTopIndex) {
+ var topIndex = Math.floor(offset / itemSize);
+ if (topIndex !== this.topIndex && topIndex < this.repeater.getItemCount()) {
+ this.topIndex = topIndex;
+ this.bindTopIndex.assign(this.$scope, topIndex);
+ if (!this.$rootScope.$$phase) this.$scope.$digest();
+ }
+ }
+
+ this.repeater.containerUpdated();
+};
+
+
+/**
+ * @ngdoc directive
+ * @name mdVirtualRepeat
+ * @module material.components.virtualRepeat
+ * @restrict A
+ * @priority 1000
+ * @description
+ * The `md-virtual-repeat` attribute is applied to a template that is repeated using virtual
+ * scrolling. This provides smooth and performant scrolling through very large lists of elements.
+ *
+ * Virtual repeat is a limited substitute for `ng-repeat` that renders only
+ * enough DOM nodes to fill the container, recycling them as the user scrolls.
+ *
+ * ### Notes
+ *
+ * - Arrays are supported for iteration by default.
+ * - An object can used use if `md-on-demand` is specified and the object implements the interface
+ * described in the `md-on-demand` <a ng-href="#attributes">documentation</a>.
+ * - `trackBy`, `as` alias, and `(key, value)` syntax from `ng-repeat` are not supported.
+ *
+ * ### On-Demand Async Item Loading
+ *
+ * When using the `md-on-demand` attribute and loading some asynchronous data,
+ * the `getItemAtIndex` function will mostly return nothing.
+ *
+ * <hljs lang="js">
+ * DynamicItems.prototype.getItemAtIndex = function(index) {
+ * if (this.pages[index]) {
+ * return this.pages[index];
+ * } else {
+ * // This is an asynchronous action and does not return any value.
+ * this.loadPage(index);
+ * }
+ * };
+ * </hljs>
+ *
+ * This means that the Virtual Repeat will not have any value for the given index.<br/>
+ * After the data loading completes, the user expects the Virtual Repeat to recognize the change.
+ *
+ * To make sure that the Virtual Repeat properly detects any change, you need to run the operation
+ * in another digest.
+ *
+ * <hljs lang="js">
+ * DynamicItems.prototype.loadPage = function(index) {
+ * var self = this;
+ *
+ * // Trigger a new digest by using $timeout
+ * $timeout(function() {
+ * self.pages[index] = Data;
+ * });
+ * };
+ * </hljs>
+ *
+ * > <b>Note:</b> Please also review the
+ * <a ng-href="api/directive/mdVirtualRepeatContainer">VirtualRepeatContainer</a> documentation
+ * for more information.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-virtual-repeat-container>
+ * <div md-virtual-repeat="i in items">Hello {{i}}!</div>
+ * </md-virtual-repeat-container>
+ *
+ * <md-virtual-repeat-container md-orient-horizontal>
+ * <div md-virtual-repeat="i in items" md-item-size="20">Hello {{i}}!</div>
+ * </md-virtual-repeat-container>
+ * </hljs>
+ *
+ * @param {expression=} md-extra-name Evaluates to an additional name to which the current iterated
+ * item can be assigned on the repeated scope (needed for use in `md-autocomplete`).
+ * @param {number=} md-item-size Optional height or width of the repeated elements (which **must be
+ * identical for each element**). Virtual repeat will attempt to read the size from the DOM,
+ * if missing, but it still assumes that all repeated nodes have the **same height**
+ * (when scrolling vertically) or **same width** (when scrolling horizontally).
+ * @param {boolean=} md-on-demand When present, treats the `md-virtual-repeat` argument as an object
+ * that can fetch rows rather than an array.
+ *
+ * **NOTE:** This object **must** implement the following interface with two methods:
+ *
+ * - `getItemAtIndex` - `{function(index): Object}`: The item at that `index` or `null` if it is
+ * not yet loaded (it should start downloading the item in that case).
+ * - `getLength` - `{function(): number}`: The data length to which the repeater container
+ * should be sized. Ideally, when the count is known, this method should return it.
+ * Otherwise, return a higher number than the currently loaded items to produce an
+ * infinite-scroll behavior.
+ */
+function VirtualRepeatDirective($parse) {
+ return {
+ controller: VirtualRepeatController,
+ priority: 1000,
+ require: ['mdVirtualRepeat', '^^mdVirtualRepeatContainer'],
+ restrict: 'A',
+ terminal: true,
+ transclude: 'element',
+ compile: function VirtualRepeatCompile($element, $attrs) {
+ var expression = $attrs.mdVirtualRepeat;
+ var match = expression.match(/^\s*([\s\S]+?)\s+in\s+([\s\S]+?)\s*$/);
+ var repeatName = match[1];
+ var repeatListExpression = $parse(match[2]);
+ var extraName = $attrs.mdExtraName && $parse($attrs.mdExtraName);
+
+ return function VirtualRepeatLink($scope, $element, $attrs, ctrl, $transclude) {
+ ctrl[0].link_(ctrl[1], $transclude, repeatName, repeatListExpression, extraName);
+ };
+ }
+ };
+}
+
+
+/** @ngInject */
+function VirtualRepeatController($scope, $element, $attrs, $browser, $document, $rootScope,
+ $$rAF, $mdUtil) {
+ this.$scope = $scope;
+ this.$element = $element;
+ this.$attrs = $attrs;
+ this.$browser = $browser;
+ this.$document = $document;
+ this.$mdUtil = $mdUtil;
+ this.$rootScope = $rootScope;
+ this.$$rAF = $$rAF;
+
+ /** @type {boolean} Whether we are in on-demand mode. */
+ this.onDemand = $mdUtil.parseAttributeBoolean($attrs.mdOnDemand);
+ /** @type {!Function} Backup reference to $browser.$$checkUrlChange */
+ this.browserCheckUrlChange = $browser.$$checkUrlChange;
+ /** @type {number} Most recent starting repeat index (based on scroll offset) */
+ this.newStartIndex = 0;
+ /** @type {number} Most recent ending repeat index (based on scroll offset) */
+ this.newEndIndex = 0;
+ /** @type {number} Most recent end visible index (based on scroll offset) */
+ this.newVisibleEnd = 0;
+ /** @type {number} Previous starting repeat index (based on scroll offset) */
+ this.startIndex = 0;
+ /** @type {number} Previous ending repeat index (based on scroll offset) */
+ this.endIndex = 0;
+ /** @type {?number} Height/width of repeated elements. */
+ this.itemSize = $scope.$eval($attrs.mdItemSize) || null;
+
+ /** @type {boolean} Whether this is the first time that items are rendered. */
+ this.isFirstRender = true;
+
+ /**
+ * @private {boolean} Whether the items in the list are already being updated. Used to prevent
+ * nested calls to virtualRepeatUpdate_.
+ */
+ this.isVirtualRepeatUpdating_ = false;
+
+ /** @type {number} Most recently seen length of items. */
+ this.itemsLength = 0;
+
+ /**
+ * @type {!Function} Unwatch callback for item size (when md-items-size is
+ * not specified), or angular.noop otherwise.
+ */
+ this.unwatchItemSize_ = angular.noop;
+
+ /**
+ * Presently rendered blocks by repeat index.
+ * @type {Object<number, !VirtualRepeatController.Block>}
+ */
+ this.blocks = {};
+ /** @type {Array<!VirtualRepeatController.Block>} A pool of presently unused blocks. */
+ this.pooledBlocks = [];
+
+ $scope.$on('$destroy', angular.bind(this, this.cleanupBlocks_));
+}
+
+
+/**
+ * An object representing a repeated item.
+ * @typedef {{element: !jqLite, new: boolean, scope: !angular.Scope}}
+ */
+VirtualRepeatController.Block;
+
+
+/**
+ * Called at startup by the md-virtual-repeat postLink function.
+ * @param {!VirtualRepeatContainerController} container The container's controller.
+ * @param {!Function} transclude The repeated element's bound transclude function.
+ * @param {string} repeatName The left hand side of the repeat expression, indicating
+ * the name for each item in the array.
+ * @param {!Function} repeatListExpression A compiled expression based on the right hand side
+ * of the repeat expression. Points to the array to repeat over.
+ * @param {string|undefined} extraName The optional extra repeatName.
+ */
+VirtualRepeatController.prototype.link_ =
+ function(container, transclude, repeatName, repeatListExpression, extraName) {
+ this.container = container;
+ this.transclude = transclude;
+ this.repeatName = repeatName;
+ this.rawRepeatListExpression = repeatListExpression;
+ this.extraName = extraName;
+ this.sized = false;
+
+ this.repeatListExpression = angular.bind(this, this.repeatListExpression_);
+
+ this.container.register(this);
+};
+
+
+/** @private Cleans up unused blocks. */
+VirtualRepeatController.prototype.cleanupBlocks_ = function() {
+ angular.forEach(this.pooledBlocks, function cleanupBlock(block) {
+ block.element.remove();
+ });
+};
+
+
+/** @private Attempts to set itemSize by measuring a repeated element in the dom */
+VirtualRepeatController.prototype.readItemSize_ = function() {
+ if (this.itemSize) {
+ // itemSize was successfully read in a different asynchronous call.
+ return;
+ }
+
+ this.items = this.repeatListExpression(this.$scope);
+ this.parentNode = this.$element[0].parentNode;
+ var block = this.getBlock_(0);
+ if (!block.element[0].parentNode) {
+ this.parentNode.appendChild(block.element[0]);
+ }
+
+ this.itemSize = block.element[0][
+ this.container.isHorizontal() ? 'offsetWidth' : 'offsetHeight'] || null;
+
+ this.blocks[0] = block;
+ this.poolBlock_(0);
+
+ if (this.itemSize) {
+ this.containerUpdated();
+ }
+};
+
+
+/**
+ * Returns the user-specified repeat list, transforming it into an array-like
+ * object in the case of infinite scroll/dynamic load mode.
+ * @param {!angular.Scope} scope The scope.
+ * @return {!Array|!Object} An array or array-like object for iteration.
+ */
+VirtualRepeatController.prototype.repeatListExpression_ = function(scope) {
+ var repeatList = this.rawRepeatListExpression(scope);
+
+ if (this.onDemand && repeatList) {
+ var virtualList = new VirtualRepeatModelArrayLike(repeatList);
+ virtualList.$$includeIndexes(this.newStartIndex, this.newVisibleEnd);
+ return virtualList;
+ } else {
+ return repeatList;
+ }
+};
+
+
+/**
+ * Called by the container. Informs us that the container's scroll or size has
+ * changed.
+ */
+VirtualRepeatController.prototype.containerUpdated = function() {
+ // If itemSize is unknown, attempt to measure it.
+ if (!this.itemSize) {
+ // Make sure to clean up watchers if we can (see #8178)
+ if (this.unwatchItemSize_ && this.unwatchItemSize_ !== angular.noop){
+ this.unwatchItemSize_();
+ }
+ this.unwatchItemSize_ = this.$scope.$watchCollection(
+ this.repeatListExpression,
+ angular.bind(this, function(items) {
+ if (items && items.length) {
+ this.readItemSize_();
+ }
+ }));
+ if (!this.$rootScope.$$phase) this.$scope.$digest();
+
+ return;
+ } else if (!this.sized) {
+ this.items = this.repeatListExpression(this.$scope);
+ }
+
+ if (!this.sized) {
+ this.unwatchItemSize_();
+ this.sized = true;
+ this.$scope.$watchCollection(this.repeatListExpression,
+ angular.bind(this, function(items, oldItems) {
+ if (!this.isVirtualRepeatUpdating_) {
+ this.virtualRepeatUpdate_(items, oldItems);
+ }
+ }));
+ }
+
+ this.updateIndexes_();
+
+ if (this.newStartIndex !== this.startIndex ||
+ this.newEndIndex !== this.endIndex ||
+ this.container.getScrollOffset() > this.container.getScrollSize()) {
+ if (this.items instanceof VirtualRepeatModelArrayLike) {
+ this.items.$$includeIndexes(this.newStartIndex, this.newEndIndex);
+ }
+ this.virtualRepeatUpdate_(this.items, this.items);
+ }
+};
+
+
+/**
+ * Called by the container. Returns the size of a single repeated item.
+ * @return {?number} size of a repeated item.
+ */
+VirtualRepeatController.prototype.getItemSize = function() {
+ return this.itemSize;
+};
+
+
+/**
+ * Called by the container.
+ * @return {?number} the most recently seen length of items.
+ */
+VirtualRepeatController.prototype.getItemCount = function() {
+ return this.itemsLength;
+};
+
+
+/**
+ * Updates the order and visible offset of repeated blocks in response to scrolling
+ * or updates to `items`.
+ * @param {Array} items visible elements
+ * @param {Array} oldItems previously visible elements
+ * @private
+ */
+VirtualRepeatController.prototype.virtualRepeatUpdate_ = function(items, oldItems) {
+ this.isVirtualRepeatUpdating_ = true;
+
+ var itemsLength = items && items.length || 0;
+ var lengthChanged = false;
+
+ // If the number of items shrank, keep the scroll position.
+ if (this.items && itemsLength < this.items.length && this.container.getScrollOffset() !== 0) {
+ this.items = items;
+ var previousScrollOffset = this.container.getScrollOffset();
+ this.container.resetScroll();
+ this.container.scrollTo(previousScrollOffset);
+ }
+
+ if (itemsLength !== this.itemsLength) {
+ lengthChanged = true;
+ this.itemsLength = itemsLength;
+ }
+
+ this.items = items;
+ if (items !== oldItems || lengthChanged) {
+ this.updateIndexes_();
+ }
+
+ this.parentNode = this.$element[0].parentNode;
+
+ if (lengthChanged) {
+ this.container.setScrollSize(itemsLength * this.itemSize);
+ }
+
+ // Detach and pool any blocks that are no longer in the viewport.
+ Object.keys(this.blocks).forEach(function(blockIndex) {
+ var index = parseInt(blockIndex, 10);
+ if (index < this.newStartIndex || index >= this.newEndIndex) {
+ this.poolBlock_(index);
+ }
+ }, this);
+
+ // Add needed blocks.
+ // For performance reasons, temporarily block browser url checks as we digest
+ // the restored block scopes ($$checkUrlChange reads window.location to
+ // check for changes and trigger route change, etc, which we don't need when
+ // trying to scroll at 60fps).
+ this.$browser.$$checkUrlChange = angular.noop;
+
+ var i, block,
+ newStartBlocks = [],
+ newEndBlocks = [];
+
+ // Collect blocks at the top.
+ for (i = this.newStartIndex; i < this.newEndIndex && this.blocks[i] == null; i++) {
+ block = this.getBlock_(i);
+ this.updateBlock_(block, i);
+ newStartBlocks.push(block);
+ }
+
+ // Update blocks that are already rendered.
+ for (; this.blocks[i] != null; i++) {
+ this.updateBlock_(this.blocks[i], i);
+ }
+ var maxIndex = i - 1;
+
+ // Collect blocks at the end.
+ for (; i < this.newEndIndex; i++) {
+ block = this.getBlock_(i);
+ this.updateBlock_(block, i);
+ newEndBlocks.push(block);
+ }
+
+ // Attach collected blocks to the document.
+ if (newStartBlocks.length) {
+ this.parentNode.insertBefore(
+ this.domFragmentFromBlocks_(newStartBlocks),
+ this.$element[0].nextSibling);
+ }
+ if (newEndBlocks.length) {
+ this.parentNode.insertBefore(
+ this.domFragmentFromBlocks_(newEndBlocks),
+ this.blocks[maxIndex] && this.blocks[maxIndex].element[0].nextSibling);
+ }
+
+ // Restore $$checkUrlChange.
+ this.$browser.$$checkUrlChange = this.browserCheckUrlChange;
+
+ this.startIndex = this.newStartIndex;
+ this.endIndex = this.newEndIndex;
+
+ if (this.isFirstRender) {
+ this.isFirstRender = false;
+ var firstRenderStartIndex = this.$attrs.mdStartIndex ?
+ this.$scope.$eval(this.$attrs.mdStartIndex) :
+ this.container.topIndex;
+
+ // The first call to virtualRepeatUpdate_ may not be when the virtual repeater is ready.
+ // Introduce a slight delay so that the update happens when it is actually ready.
+ this.$mdUtil.nextTick(function() {
+ this.container.scrollToIndex(firstRenderStartIndex);
+ }.bind(this));
+ }
+
+ this.isVirtualRepeatUpdating_ = false;
+};
+
+
+/**
+ * @param {number} index Where the block is to be in the repeated list.
+ * @return {!VirtualRepeatController.Block} A new or pooled block to place at the specified index.
+ * @private
+ */
+VirtualRepeatController.prototype.getBlock_ = function(index) {
+ if (this.pooledBlocks.length) {
+ return this.pooledBlocks.pop();
+ }
+
+ var block;
+ this.transclude(angular.bind(this, function(clone, scope) {
+ block = {
+ element: clone,
+ new: true,
+ scope: scope
+ };
+
+ this.updateScope_(scope, index);
+ this.parentNode.appendChild(clone[0]);
+ }));
+
+ return block;
+};
+
+
+/**
+ * Updates and if not in a digest cycle, digests the specified block's scope to the data
+ * at the specified index.
+ * @param {!VirtualRepeatController.Block} block The block whose scope should be updated.
+ * @param {number} index The index to set.
+ * @private
+ */
+VirtualRepeatController.prototype.updateBlock_ = function(block, index) {
+ this.blocks[index] = block;
+
+ if (!block.new &&
+ (block.scope.$index === index && block.scope[this.repeatName] === this.items[index])) {
+ return;
+ }
+ block.new = false;
+
+ // Update and digest the block's scope.
+ this.updateScope_(block.scope, index);
+
+ // Perform digest before reattaching the block.
+ // Any resulting synchronous DOM mutations should be much faster as a result.
+ // This might break some directives.
+ if (!this.$rootScope.$$phase) {
+ block.scope.$digest();
+ }
+};
+
+
+/**
+ * Updates scope to the data at the specified index.
+ * @param {!angular.Scope} scope The scope which should be updated.
+ * @param {number} index The index to set.
+ * @private
+ */
+VirtualRepeatController.prototype.updateScope_ = function(scope, index) {
+ scope.$index = index;
+ scope[this.repeatName] = this.items && this.items[index];
+ if (this.extraName) scope[this.extraName(this.$scope)] = this.items[index];
+};
+
+
+/**
+ * Pools the block at the specified index (Pulls its element out of the dom and stores it).
+ * @param {number} index The index at which the block to pool is stored.
+ * @private
+ */
+VirtualRepeatController.prototype.poolBlock_ = function(index) {
+ this.pooledBlocks.push(this.blocks[index]);
+ this.parentNode.removeChild(this.blocks[index].element[0]);
+ delete this.blocks[index];
+};
+
+
+/**
+ * Produces a dom fragment containing the elements from the list of blocks.
+ * @param {!Array<!VirtualRepeatController.Block>} blocks The blocks whose elements
+ * should be added to the document fragment.
+ * @return {DocumentFragment}
+ * @private
+ */
+VirtualRepeatController.prototype.domFragmentFromBlocks_ = function(blocks) {
+ var fragment = this.$document[0].createDocumentFragment();
+ blocks.forEach(function(block) {
+ fragment.appendChild(block.element[0]);
+ });
+ return fragment;
+};
+
+
+/**
+ * Updates start and end indexes based on length of repeated items and container size.
+ * @private
+ */
+VirtualRepeatController.prototype.updateIndexes_ = function() {
+ var itemsLength = this.items ? this.items.length : 0;
+ var containerLength = Math.ceil(this.container.getSize() / this.itemSize);
+
+ this.newStartIndex = Math.max(0, Math.min(
+ itemsLength - containerLength,
+ Math.floor(this.container.getScrollOffset() / this.itemSize)));
+ this.newVisibleEnd = this.newStartIndex + containerLength + NUM_EXTRA;
+ this.newEndIndex = Math.min(itemsLength, this.newVisibleEnd);
+ this.newStartIndex = Math.max(0, this.newStartIndex - NUM_EXTRA);
+};
+
+/**
+ * This VirtualRepeatModelArrayLike class enforces the interface requirements
+ * for infinite scrolling within a mdVirtualRepeatContainer.
+ *
+ * @param {Object} model An object with this interface must implement the following interface with
+ * two (2) methods:
+ *
+ * getItemAtIndex: function(index) -> item at that index or null if it is not yet
+ * loaded (It should start downloading the item in that case).
+ *
+ * getLength: function() -> number The data length to which the repeater container
+ * should be sized. Ideally, when the count is known, this method should return it.
+ * Otherwise, return a higher number than the currently loaded items to produce an
+ * infinite-scroll behavior.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-virtual-repeat-container md-orient-horizontal>
+ * <div md-virtual-repeat="i in items" md-on-demand>
+ * Hello {{i}}!
+ * </div>
+ * </md-virtual-repeat-container>
+ * </hljs>
+ *
+ */
+function VirtualRepeatModelArrayLike(model) {
+ if (!angular.isFunction(model.getItemAtIndex) ||
+ !angular.isFunction(model.getLength)) {
+ throw Error('When md-on-demand is enabled, the Object passed to md-virtual-repeat must ' +
+ 'implement functions getItemAtIndex() and getLength().');
+ }
+
+ this.model = model;
+}
+
+/**
+ * @param {number} start
+ * @param {number} end
+ */
+VirtualRepeatModelArrayLike.prototype.$$includeIndexes = function(start, end) {
+ for (var i = start; i < end; i++) {
+ if (!this.hasOwnProperty(i)) {
+ this[i] = this.model.getItemAtIndex(i);
+ }
+ }
+ this.length = this.model.getLength();
+};
+
+/**
+ * @ngdoc directive
+ * @name mdForceHeight
+ * @module material.components.virtualRepeat
+ * @restrict A
+ * @description
+ *
+ * Force an element to have a certain `px` height. This is used in place of a style tag in order to
+ * conform to the
+ * <a href="https://developer.mozilla.org/docs/Web/HTTP/Headers/Content-Security-Policy/script-src">
+ * Content Security Policy</a> regarding `unsafe-inline` `<style>` tags.
+ *
+ * This directive is related to <a ng-href="api/directive/mdVirtualRepeat">mdVirtualRepeat</a>.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div md-force-height="'100px'"></div>
+ * </hljs>
+ */
+function ForceHeightDirective($mdUtil) {
+ return {
+ restrict: 'A',
+ link: function(scope, element, attrs) {
+ var height = scope.$eval(attrs.mdForceHeight) || null;
+
+ if (height && element) {
+ element[0].style.height = height;
+ }
+ }
+ };
+}
+ForceHeightDirective.$inject = ['$mdUtil'];
+
+})();
+(function(){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.whiteframe
+ */
+MdWhiteframeDirective.$inject = ["$log"];
+angular
+ .module('material.components.whiteframe', ['material.core'])
+ .directive('mdWhiteframe', MdWhiteframeDirective);
+
+/**
+ * @ngdoc directive
+ * @module material.components.whiteframe
+ * @name mdWhiteframe
+ *
+ * @description
+ * The md-whiteframe directive allows you to apply an elevation shadow to an element.
+ *
+ * The attribute values needs to be a number between 1 and 24 or -1.
+ * When set to -1 no style is applied.
+ *
+ * ### Notes
+ * - If there is no value specified it defaults to 4dp.
+ * - If the value is not valid it defaults to 4dp.
+
+ * @usage
+ * <hljs lang="html">
+ * <div md-whiteframe="3">
+ * <span>Elevation of 3dp</span>
+ * </div>
+ * </hljs>
+ *
+ * <hljs lang="html">
+ * <div md-whiteframe="-1">
+ * <span>No elevation shadow applied</span>
+ * </div>
+ * </hljs>
+ *
+ * <hljs lang="html">
+ * <div ng-init="elevation = 5" md-whiteframe="{{elevation}}">
+ * <span>Elevation of 5dp with an interpolated value</span>
+ * </div>
+ * </hljs>
+ */
+function MdWhiteframeDirective($log) {
+ var DISABLE_DP = -1;
+ var MIN_DP = 1;
+ var MAX_DP = 24;
+ var DEFAULT_DP = 4;
+
+ return {
+ link: postLink
+ };
+
+ function postLink(scope, element, attr) {
+ var oldClass = '';
+
+ attr.$observe('mdWhiteframe', function(elevation) {
+ elevation = parseInt(elevation, 10) || DEFAULT_DP;
+
+ if (elevation != DISABLE_DP && (elevation > MAX_DP || elevation < MIN_DP)) {
+ $log.warn('md-whiteframe attribute value is invalid. It should be a number between ' + MIN_DP + ' and ' + MAX_DP, element[0]);
+ elevation = DEFAULT_DP;
+ }
+
+ var newClass = elevation == DISABLE_DP ? '' : 'md-whiteframe-' + elevation + 'dp';
+ attr.$updateClass(newClass, oldClass);
+ oldClass = newClass;
+ });
+ }
+}
+
+
+})();
+(function(){
+angular.module("material.core").constant("$MD_THEME_CSS", "md-autocomplete.md-THEME_NAME-theme{background:\"{{background-hue-1}}\"}md-autocomplete.md-THEME_NAME-theme[disabled]:not([md-floating-label]){background:\"{{background-hue-2}}\"}md-autocomplete.md-THEME_NAME-theme button md-icon path{fill:\"{{background-600}}\"}md-autocomplete.md-THEME_NAME-theme button:after{background:\"{{background-600-0.3}}\"}md-autocomplete.md-THEME_NAME-theme input{color:\"{{foreground-1}}\"}md-autocomplete.md-THEME_NAME-theme.md-accent md-input-container.md-input-focused .md-input{border-color:\"{{accent-color}}\"}md-autocomplete.md-THEME_NAME-theme.md-accent md-input-container.md-input-focused label,md-autocomplete.md-THEME_NAME-theme.md-accent md-input-container.md-input-focused md-icon{color:\"{{accent-color}}\"}md-autocomplete.md-THEME_NAME-theme.md-accent md-progress-linear .md-container{background-color:\"{{accent-100}}\"}md-autocomplete.md-THEME_NAME-theme.md-accent md-progress-linear .md-bar{background-color:\"{{accent-color}}\"}md-autocomplete.md-THEME_NAME-theme.md-warn md-input-container.md-input-focused .md-input{border-color:\"{{warn-A700}}\"}md-autocomplete.md-THEME_NAME-theme.md-warn md-input-container.md-input-focused label,md-autocomplete.md-THEME_NAME-theme.md-warn md-input-container.md-input-focused md-icon{color:\"{{warn-A700}}\"}md-autocomplete.md-THEME_NAME-theme.md-warn md-progress-linear .md-container{background-color:\"{{warn-100}}\"}md-autocomplete.md-THEME_NAME-theme.md-warn md-progress-linear .md-bar{background-color:\"{{warn-color}}\"}.md-autocomplete-standard-list-container.md-THEME_NAME-theme,.md-autocomplete-suggestions-container.md-THEME_NAME-theme{background:\"{{background-hue-1}}\"}.md-autocomplete-standard-list-container.md-THEME_NAME-theme .md-autocomplete-suggestion,.md-autocomplete-suggestions-container.md-THEME_NAME-theme .md-autocomplete-suggestion{color:\"{{foreground-1}}\"}.md-autocomplete-standard-list-container.md-THEME_NAME-theme .md-autocomplete-suggestion.selected,.md-autocomplete-standard-list-container.md-THEME_NAME-theme .md-autocomplete-suggestion:hover,.md-autocomplete-suggestions-container.md-THEME_NAME-theme .md-autocomplete-suggestion.selected,.md-autocomplete-suggestions-container.md-THEME_NAME-theme .md-autocomplete-suggestion:hover{background:\"{{background-500-0.18}}\"}md-backdrop{background-color:\"{{background-900-0.0}}\"}md-backdrop.md-opaque.md-THEME_NAME-theme{background-color:\"{{background-900-1.0}}\"}md-bottom-sheet.md-THEME_NAME-theme{background-color:\"{{background-color}}\";border-top-color:\"{{background-hue-3}}\"}md-bottom-sheet.md-THEME_NAME-theme.md-list md-list-item{color:\"{{foreground-1}}\"}md-bottom-sheet.md-THEME_NAME-theme .md-subheader{background-color:\"{{background-color}}\";color:\"{{foreground-1}}\"}.md-button.md-THEME_NAME-theme:not([disabled]).md-focused,.md-button.md-THEME_NAME-theme:not([disabled]):hover{background-color:\"{{background-500-0.2}}\"}.md-button.md-THEME_NAME-theme:not([disabled]).md-icon-button:hover{background-color:transparent}.md-button.md-THEME_NAME-theme.md-fab{background-color:\"{{accent-color}}\";color:\"{{accent-contrast}}\"}.md-button.md-THEME_NAME-theme.md-fab md-icon{color:\"{{accent-contrast}}\"}.md-button.md-THEME_NAME-theme.md-fab:not([disabled]).md-focused,.md-button.md-THEME_NAME-theme.md-fab:not([disabled]):hover{background-color:\"{{accent-A700}}\"}.md-button.md-THEME_NAME-theme.md-primary{color:\"{{primary-color}}\"}.md-button.md-THEME_NAME-theme.md-primary.md-fab,.md-button.md-THEME_NAME-theme.md-primary.md-raised{background-color:\"{{primary-color}}\";color:\"{{primary-contrast}}\"}.md-button.md-THEME_NAME-theme.md-primary.md-fab:not([disabled]) md-icon,.md-button.md-THEME_NAME-theme.md-primary.md-raised:not([disabled]) md-icon{color:\"{{primary-contrast}}\"}.md-button.md-THEME_NAME-theme.md-primary.md-fab:not([disabled]).md-focused,.md-button.md-THEME_NAME-theme.md-primary.md-fab:not([disabled]):hover,.md-button.md-THEME_NAME-theme.md-primary.md-raised:not([disabled]).md-focused,.md-button.md-THEME_NAME-theme.md-primary.md-raised:not([disabled]):hover{background-color:\"{{primary-600}}\"}.md-button.md-THEME_NAME-theme.md-primary:not([disabled]) md-icon{color:\"{{primary-color}}\"}.md-button.md-THEME_NAME-theme.md-raised{background-color:\"{{background-50}}\";color:\"{{background-900}}\"}.md-button.md-THEME_NAME-theme.md-raised:not([disabled]) md-icon{color:\"{{background-900}}\"}.md-button.md-THEME_NAME-theme.md-raised:not([disabled]):hover{background-color:\"{{background-50}}\"}.md-button.md-THEME_NAME-theme.md-raised:not([disabled]).md-focused{background-color:\"{{background-200}}\"}.md-button.md-THEME_NAME-theme.md-warn{color:\"{{warn-color}}\"}.md-button.md-THEME_NAME-theme.md-warn.md-fab,.md-button.md-THEME_NAME-theme.md-warn.md-raised{background-color:\"{{warn-color}}\";color:\"{{warn-contrast}}\"}.md-button.md-THEME_NAME-theme.md-warn.md-fab:not([disabled]) md-icon,.md-button.md-THEME_NAME-theme.md-warn.md-raised:not([disabled]) md-icon{color:\"{{warn-contrast}}\"}.md-button.md-THEME_NAME-theme.md-warn.md-fab:not([disabled]).md-focused,.md-button.md-THEME_NAME-theme.md-warn.md-fab:not([disabled]):hover,.md-button.md-THEME_NAME-theme.md-warn.md-raised:not([disabled]).md-focused,.md-button.md-THEME_NAME-theme.md-warn.md-raised:not([disabled]):hover{background-color:\"{{warn-600}}\"}.md-button.md-THEME_NAME-theme.md-warn:not([disabled]) md-icon{color:\"{{warn-color}}\"}.md-button.md-THEME_NAME-theme.md-accent{color:\"{{accent-color}}\"}.md-button.md-THEME_NAME-theme.md-accent.md-fab,.md-button.md-THEME_NAME-theme.md-accent.md-raised{background-color:\"{{accent-color}}\";color:\"{{accent-contrast}}\"}.md-button.md-THEME_NAME-theme.md-accent.md-fab:not([disabled]) md-icon,.md-button.md-THEME_NAME-theme.md-accent.md-raised:not([disabled]) md-icon{color:\"{{accent-contrast}}\"}.md-button.md-THEME_NAME-theme.md-accent.md-fab:not([disabled]).md-focused,.md-button.md-THEME_NAME-theme.md-accent.md-fab:not([disabled]):hover,.md-button.md-THEME_NAME-theme.md-accent.md-raised:not([disabled]).md-focused,.md-button.md-THEME_NAME-theme.md-accent.md-raised:not([disabled]):hover{background-color:\"{{accent-A700}}\"}.md-button.md-THEME_NAME-theme.md-accent:not([disabled]) md-icon{color:\"{{accent-color}}\"}.md-button.md-THEME_NAME-theme.md-accent[disabled],.md-button.md-THEME_NAME-theme.md-fab[disabled],.md-button.md-THEME_NAME-theme.md-raised[disabled],.md-button.md-THEME_NAME-theme.md-warn[disabled],.md-button.md-THEME_NAME-theme[disabled]{color:\"{{foreground-3}}\";cursor:default}.md-button.md-THEME_NAME-theme.md-accent[disabled] md-icon,.md-button.md-THEME_NAME-theme.md-fab[disabled] md-icon,.md-button.md-THEME_NAME-theme.md-raised[disabled] md-icon,.md-button.md-THEME_NAME-theme.md-warn[disabled] md-icon,.md-button.md-THEME_NAME-theme[disabled] md-icon{color:\"{{foreground-3}}\"}.md-button.md-THEME_NAME-theme.md-fab[disabled],.md-button.md-THEME_NAME-theme.md-raised[disabled]{background-color:\"{{foreground-4}}\"}.md-button.md-THEME_NAME-theme[disabled]{background-color:transparent}._md a.md-THEME_NAME-theme:not(.md-button).md-primary{color:\"{{primary-color}}\"}._md a.md-THEME_NAME-theme:not(.md-button).md-primary:hover{color:\"{{primary-700}}\"}._md a.md-THEME_NAME-theme:not(.md-button).md-accent{color:\"{{accent-color}}\"}._md a.md-THEME_NAME-theme:not(.md-button).md-accent:hover{color:\"{{accent-A700}}\"}._md a.md-THEME_NAME-theme:not(.md-button).md-warn{color:\"{{warn-color}}\"}._md a.md-THEME_NAME-theme:not(.md-button).md-warn:hover{color:\"{{warn-700}}\"}md-card.md-THEME_NAME-theme{background-color:\"{{background-hue-1}}\";border-radius:2px;color:\"{{foreground-1}}\"}md-card.md-THEME_NAME-theme .md-card-image{border-radius:2px 2px 0 0}md-card.md-THEME_NAME-theme md-card-header md-card-avatar md-icon{background-color:\"{{foreground-3}}\";color:\"{{background-color}}\"}md-card.md-THEME_NAME-theme md-card-header md-card-header-text .md-subhead,md-card.md-THEME_NAME-theme md-card-title md-card-title-text:not(:only-child) .md-subhead{color:\"{{foreground-2}}\"}md-checkbox.md-THEME_NAME-theme .md-ripple{color:\"{{accent-A700}}\"}md-checkbox.md-THEME_NAME-theme.md-checked .md-ripple{color:\"{{background-600}}\"}md-checkbox.md-THEME_NAME-theme.md-checked.md-focused .md-container:before{background-color:\"{{accent-color-0.26}}\"}md-checkbox.md-THEME_NAME-theme .md-ink-ripple{color:\"{{foreground-2}}\"}md-checkbox.md-THEME_NAME-theme.md-checked .md-ink-ripple{color:\"{{accent-color-0.87}}\"}md-checkbox.md-THEME_NAME-theme:not(.md-checked) .md-icon{border-color:\"{{foreground-2}}\"}md-checkbox.md-THEME_NAME-theme.md-checked .md-icon{background-color:\"{{accent-color-0.87}}\"}md-checkbox.md-THEME_NAME-theme.md-checked .md-icon:after{border-color:\"{{background-default}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-primary .md-ripple{color:\"{{primary-600}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-primary.md-checked .md-ripple{color:\"{{background-600}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-primary .md-ink-ripple{color:\"{{foreground-2}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-primary.md-checked .md-ink-ripple{color:\"{{primary-color-0.87}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-primary:not(.md-checked) .md-icon{border-color:\"{{foreground-2}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-primary.md-checked .md-icon{background-color:\"{{primary-color-0.87}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-primary.md-checked.md-focused .md-container:before{background-color:\"{{primary-color-0.26}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-primary.md-checked .md-icon:after{border-color:\"{{primary-contrast-0.87}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-primary .md-indeterminate[disabled] .md-container{color:\"{{foreground-3}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-warn .md-ripple{color:\"{{warn-600}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-warn .md-ink-ripple{color:\"{{foreground-2}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-warn.md-checked .md-ink-ripple{color:\"{{warn-color-0.87}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-warn:not(.md-checked) .md-icon{border-color:\"{{foreground-2}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-warn.md-checked .md-icon{background-color:\"{{warn-color-0.87}}\"}md-checkbox.md-THEME_NAME-theme:not([disabled]).md-warn.md-checked.md-focused:not([disabled]) .md-container:before{background-color:\"{{warn-color-0.26}}\"}md-checkbox.md-THEME_NAME-theme[disabled]:not(.md-checked) .md-icon{border-color:\"{{foreground-3}}\"}md-checkbox.md-THEME_NAME-theme[disabled].md-checked .md-icon{background-color:\"{{foreground-3}}\"}md-checkbox.md-THEME_NAME-theme[disabled] .md-label{color:\"{{foreground-3}}\"}md-chips.md-THEME_NAME-theme .md-chips{box-shadow:0 1px \"{{foreground-4}}\"}md-chips.md-THEME_NAME-theme .md-chips.md-focused{box-shadow:0 2px \"{{primary-color}}\"}md-chips.md-THEME_NAME-theme .md-chips .md-chip-input-container input{color:\"{{foreground-1}}\"}md-chips.md-THEME_NAME-theme .md-chips .md-chip-input-container input::-webkit-input-placeholder{color:\"{{foreground-3}}\"}md-chips.md-THEME_NAME-theme .md-chips .md-chip-input-container input:-ms-input-placeholder{color:\"{{foreground-3}}\"}md-chips.md-THEME_NAME-theme .md-chips .md-chip-input-container input::-ms-input-placeholder{color:\"{{foreground-3}}\"}md-chips.md-THEME_NAME-theme .md-chips .md-chip-input-container input::placeholder{color:\"{{foreground-3}}\"}md-chips.md-THEME_NAME-theme .md-chips .md-chip-input-container input:-moz-placeholder,md-chips.md-THEME_NAME-theme .md-chips .md-chip-input-container input::-moz-placeholder{color:\"{{foreground-3}}\";opacity:1}md-chips.md-THEME_NAME-theme md-chip{background:\"{{background-300}}\";color:\"{{background-800}}\"}md-chips.md-THEME_NAME-theme md-chip md-icon{color:\"{{background-700}}\"}md-chips.md-THEME_NAME-theme md-chip.md-focused{background:\"{{primary-color}}\";color:\"{{primary-contrast}}\"}md-chips.md-THEME_NAME-theme md-chip.md-focused md-icon{color:\"{{primary-contrast}}\"}md-chips.md-THEME_NAME-theme md-chip._md-chip-editing{background:transparent;color:\"{{background-800}}\"}md-chips.md-THEME_NAME-theme .md-chip-remove-container button.md-chip-remove md-icon,md-chips.md-THEME_NAME-theme .md-chip-remove-container buttonmd-chip-remove md-icon{fill:\"{{foreground-2}}\";color:\"{{foreground-2}}\"}.md-contact-suggestion span.md-contact-email{color:\"{{background-400}}\"}md-content.md-THEME_NAME-theme{background-color:\"{{background-default}}\";color:\"{{foreground-1}}\"}.md-THEME_NAME-theme .md-calendar{background:\"{{background-hue-1}}\";color:\"{{foreground-1-0.87}}\"}.md-THEME_NAME-theme .md-calendar tr:last-child td{border-bottom-color:\"{{background-hue-2}}\"}.md-THEME_NAME-theme .md-calendar-day-header{background:\"{{background-500-0.32}}\";color:\"{{foreground-1-0.87}}\"}.md-THEME_NAME-theme .md-calendar-date.md-calendar-date-today .md-calendar-date-selection-indicator{border:1px solid \"{{primary-500}}\"}.md-THEME_NAME-theme .md-calendar-date.md-calendar-date-today.md-calendar-date-disabled{color:\"{{primary-500-0.6}}\"}.md-calendar-date.md-focus .md-THEME_NAME-theme .md-calendar-date-selection-indicator,.md-THEME_NAME-theme .md-calendar-date-selection-indicator:hover{background:\"{{background-500-0.32}}\"}.md-THEME_NAME-theme .md-calendar-date.md-calendar-selected-date .md-calendar-date-selection-indicator,.md-THEME_NAME-theme .md-calendar-date.md-focus.md-calendar-selected-date .md-calendar-date-selection-indicator{background:\"{{primary-500}}\";border-color:transparent;color:\"{{primary-500-contrast}}\"}.md-THEME_NAME-theme .md-calendar-date-disabled,.md-THEME_NAME-theme .md-calendar-month-label-disabled{color:\"{{foreground-3}}\"}.md-THEME_NAME-theme .md-calendar-month-label md-icon,.md-THEME_NAME-theme .md-datepicker-input{color:\"{{foreground-1}}\"}.md-THEME_NAME-theme .md-datepicker-input::-webkit-input-placeholder{color:\"{{foreground-3}}\"}.md-THEME_NAME-theme .md-datepicker-input:-ms-input-placeholder{color:\"{{foreground-3}}\"}.md-THEME_NAME-theme .md-datepicker-input::-ms-input-placeholder{color:\"{{foreground-3}}\"}.md-THEME_NAME-theme .md-datepicker-input::placeholder{color:\"{{foreground-3}}\"}.md-THEME_NAME-theme .md-datepicker-input:-moz-placeholder,.md-THEME_NAME-theme .md-datepicker-input::-moz-placeholder{color:\"{{foreground-3}}\";opacity:1}.md-THEME_NAME-theme .md-datepicker-input-container{border-bottom-color:\"{{foreground-4}}\"}.md-THEME_NAME-theme .md-datepicker-input-container.md-datepicker-focused{border-bottom-color:\"{{primary-color}}\"}.md-accent .md-THEME_NAME-theme .md-datepicker-input-container.md-datepicker-focused{border-bottom-color:\"{{accent-color}}\"}.md-THEME_NAME-theme .md-datepicker-input-container.md-datepicker-invalid,.md-warn .md-THEME_NAME-theme .md-datepicker-input-container.md-datepicker-focused{border-bottom-color:\"{{warn-A700}}\"}.md-THEME_NAME-theme .md-datepicker-calendar-pane{border-color:\"{{background-hue-1}}\"}.md-THEME_NAME-theme .md-datepicker-triangle-button .md-datepicker-expand-triangle{border-top-color:\"{{foreground-2}}\"}.md-THEME_NAME-theme .md-datepicker-open .md-datepicker-calendar-icon{color:\"{{primary-color}}\"}.md-accent .md-THEME_NAME-theme .md-datepicker-open .md-datepicker-calendar-icon,.md-THEME_NAME-theme .md-datepicker-open.md-accent .md-datepicker-calendar-icon{color:\"{{accent-color}}\"}.md-THEME_NAME-theme .md-datepicker-open.md-warn .md-datepicker-calendar-icon,.md-warn .md-THEME_NAME-theme .md-datepicker-open .md-datepicker-calendar-icon{color:\"{{warn-A700}}\"}.md-THEME_NAME-theme .md-datepicker-calendar{background:\"{{background-hue-1}}\"}.md-THEME_NAME-theme .md-datepicker-input-mask-opaque{box-shadow:0 0 0 9999px \"{{background-hue-1}}\"}.md-THEME_NAME-theme .md-datepicker-open .md-datepicker-input-container{background:\"{{background-hue-1}}\"}md-dialog.md-THEME_NAME-theme{background-color:\"{{background-hue-1}}\";border-radius:4px;color:\"{{foreground-1}}\"}md-dialog.md-THEME_NAME-theme.md-content-overflow md-dialog-actions{border-top-color:\"{{foreground-4}}\"}md-divider.md-THEME_NAME-theme{border-color:\"{{foreground-4}}\"}md-fab-speed-dial.md-THEME_NAME-theme md-fab-trigger .md-fab.md-button[disabled]{background-color:\"{{foreground-4}}\"}md-fab-speed-dial.md-THEME_NAME-theme md-fab-actions .md-fab-action-item .md-button.md-fab.md-raised.md-mini.md-focused,md-fab-speed-dial.md-THEME_NAME-theme md-fab-actions .md-fab-action-item .md-button.md-fab.md-raised.md-mini:hover{background-color:\"{{background-500}}\"}md-icon.md-THEME_NAME-theme{color:\"{{foreground-2}}\"}md-icon.md-THEME_NAME-theme.md-primary{color:\"{{primary-color}}\"}md-icon.md-THEME_NAME-theme.md-accent{color:\"{{accent-color}}\"}md-icon.md-THEME_NAME-theme.md-warn{color:\"{{warn-color}}\"}md-input-container.md-THEME_NAME-theme .md-input{border-color:\"{{background-default-contrast-divider}}\";color:\"{{background-default-contrast}}\"}md-input-container.md-THEME_NAME-theme .md-input::-webkit-input-placeholder{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme .md-input:-ms-input-placeholder{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme .md-input::-ms-input-placeholder{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme .md-input::placeholder{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme .md-input:-moz-placeholder,md-input-container.md-THEME_NAME-theme .md-input::-moz-placeholder{color:\"{{background-default-contrast-secondary}}\";opacity:1}md-input-container.md-THEME_NAME-theme>md-icon{color:\"{{background-default-contrast}}\"}md-input-container.md-THEME_NAME-theme .md-placeholder,md-input-container.md-THEME_NAME-theme label{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme label.md-required:after{color:\"{{warn-A700}}\"}md-input-container.md-THEME_NAME-theme:not(.md-input-focused):not(.md-input-invalid) label.md-required:after{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme .md-input-message-animation,md-input-container.md-THEME_NAME-theme .md-input-messages-animation{color:\"{{warn-A700}}\"}md-input-container.md-THEME_NAME-theme .md-input-message-animation .md-char-counter,md-input-container.md-THEME_NAME-theme .md-input-messages-animation .md-char-counter{color:\"{{background-default-contrast}}\"}md-input-container.md-THEME_NAME-theme.md-input-focused .md-input::-webkit-input-placeholder{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme.md-input-focused .md-input:-ms-input-placeholder{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme.md-input-focused .md-input::-ms-input-placeholder{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme.md-input-focused .md-input::placeholder{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme.md-input-focused .md-input:-moz-placeholder,md-input-container.md-THEME_NAME-theme.md-input-focused .md-input::-moz-placeholder{color:\"{{background-default-contrast-secondary}}\";opacity:1}md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-has-value label{color:\"{{background-default-contrast-secondary}}\"}md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-focused .md-input,md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-resized .md-input{border-color:\"{{primary-color}}\"}md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-focused label,md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-focused md-icon{color:\"{{primary-color}}\"}md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-focused.md-accent .md-input{border-color:\"{{accent-color}}\"}md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-focused.md-accent label,md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-focused.md-accent md-icon{color:\"{{accent-color}}\"}md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-focused.md-warn .md-input{border-color:\"{{warn-A700}}\"}md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-focused.md-warn label,md-input-container.md-THEME_NAME-theme:not(.md-input-invalid).md-input-focused.md-warn md-icon{color:\"{{warn-A700}}\"}md-input-container.md-THEME_NAME-theme.md-input-invalid .md-input{border-color:\"{{warn-A700}}\"}md-input-container.md-THEME_NAME-theme.md-input-invalid .md-char-counter,md-input-container.md-THEME_NAME-theme.md-input-invalid .md-input-message-animation,md-input-container.md-THEME_NAME-theme.md-input-invalid label{color:\"{{warn-A700}}\"}[disabled] md-input-container.md-THEME_NAME-theme .md-input,md-input-container.md-THEME_NAME-theme .md-input[disabled]{background-image:linear-gradient(90deg,\"{{background-default-contrast-disabled}}\" 0,\"{{background-default-contrast-disabled}}\" 33%,transparent 0);background-image:-ms-linear-gradient(left,transparent 0,\"{{background-default-contrast-disabled}}\" 100%);border-bottom-color:transparent;color:\"{{background-default-contrast-disabled}}\"}md-list.md-THEME_NAME-theme md-list-item.md-2-line .md-list-item-text h3,md-list.md-THEME_NAME-theme md-list-item.md-2-line .md-list-item-text h4,md-list.md-THEME_NAME-theme md-list-item.md-3-line .md-list-item-text h3,md-list.md-THEME_NAME-theme md-list-item.md-3-line .md-list-item-text h4{color:\"{{foreground-1}}\"}md-list.md-THEME_NAME-theme md-list-item.md-2-line .md-list-item-text p,md-list.md-THEME_NAME-theme md-list-item.md-3-line .md-list-item-text p{color:\"{{foreground-2}}\"}md-list.md-THEME_NAME-theme .md-proxy-focus.md-focused div.md-no-style{background-color:\"{{background-100}}\"}md-list.md-THEME_NAME-theme md-list-item .md-avatar-icon{background-color:\"{{foreground-3}}\";color:\"{{background-color}}\"}md-list.md-THEME_NAME-theme md-list-item>md-icon{color:\"{{foreground-2}}\"}md-list.md-THEME_NAME-theme md-list-item>md-icon.md-highlight{color:\"{{primary-color}}\"}md-list.md-THEME_NAME-theme md-list-item>md-icon.md-highlight.md-accent{color:\"{{accent-color}}\"}md-menu-content.md-THEME_NAME-theme{background-color:\"{{background-hue-1}}\"}md-menu-content.md-THEME_NAME-theme md-menu-item{color:\"{{foreground-1}}\"}md-menu-content.md-THEME_NAME-theme md-menu-item md-icon{color:\"{{foreground-2}}\"}md-menu-content.md-THEME_NAME-theme md-menu-item .md-button[disabled],md-menu-content.md-THEME_NAME-theme md-menu-item .md-button[disabled] md-icon{color:\"{{foreground-3}}\"}md-menu-content.md-THEME_NAME-theme md-menu-divider{background-color:\"{{foreground-4}}\"}md-menu-bar.md-THEME_NAME-theme>button.md-button{border-radius:2px;color:\"{{foreground-1}}\"}md-menu-bar.md-THEME_NAME-theme md-menu>button{color:\"{{foreground-1}}\"}md-menu-bar.md-THEME_NAME-theme md-menu.md-open>button,md-menu-bar.md-THEME_NAME-theme md-menu>button:focus{background-color:\"{{ background-500-0.18}}\";outline:none}md-menu-bar.md-THEME_NAME-theme.md-open:not(.md-keyboard-mode) md-menu:hover>button{background-color:\"{{ background-500-0.18}}\"}md-menu-bar.md-THEME_NAME-theme:not(.md-keyboard-mode):not(.md-open) md-menu button:focus,md-menu-bar.md-THEME_NAME-theme:not(.md-keyboard-mode):not(.md-open) md-menu button:hover{background:transparent}md-menu-content.md-THEME_NAME-theme .md-menu>.md-button:after{color:\"{{foreground-2}}\"}md-menu-content.md-THEME_NAME-theme .md-menu.md-open>.md-button{background-color:\"{{ background-500-0.18}}\"}md-toolbar.md-THEME_NAME-theme.md-menu-toolbar{background-color:\"{{background-hue-1}}\";color:\"{{foreground-1}}\"}md-toolbar.md-THEME_NAME-theme.md-menu-toolbar md-toolbar-filler{background-color:\"{{primary-color}}\";color:\"{{primary-contrast}}\"}md-toolbar.md-THEME_NAME-theme.md-menu-toolbar md-toolbar-filler md-icon{color:\"{{primary-contrast}}\"}md-nav-bar.md-THEME_NAME-theme .md-nav-bar{background-color:transparent;border-color:\"{{foreground-4}}\"}md-nav-bar.md-THEME_NAME-theme .md-button._md-nav-button.md-unselected{color:\"{{foreground-2}}\"}md-nav-bar.md-THEME_NAME-theme .md-button._md-nav-button[disabled]{color:\"{{foreground-3}}\"}md-nav-bar.md-THEME_NAME-theme md-nav-ink-bar{background:\"{{accent-color}}\";color:\"{{accent-color}}\"}md-nav-bar.md-THEME_NAME-theme.md-accent>.md-nav-bar{background-color:\"{{accent-color}}\"}md-nav-bar.md-THEME_NAME-theme.md-accent>.md-nav-bar .md-button._md-nav-button{color:\"{{accent-A100}}\"}md-nav-bar.md-THEME_NAME-theme.md-accent>.md-nav-bar .md-button._md-nav-button.md-active,md-nav-bar.md-THEME_NAME-theme.md-accent>.md-nav-bar .md-button._md-nav-button.md-focused{color:\"{{accent-contrast}}\"}md-nav-bar.md-THEME_NAME-theme.md-accent>.md-nav-bar .md-button._md-nav-button.md-focused{background:\"{{accent-contrast-0.1}}\"}md-nav-bar.md-THEME_NAME-theme.md-accent>.md-nav-bar md-nav-ink-bar{background:\"{{primary-600-1}}\";color:\"{{primary-600-1}}\"}md-nav-bar.md-THEME_NAME-theme.md-warn>.md-nav-bar{background-color:\"{{warn-color}}\"}md-nav-bar.md-THEME_NAME-theme.md-warn>.md-nav-bar .md-button._md-nav-button{color:\"{{warn-100}}\"}md-nav-bar.md-THEME_NAME-theme.md-warn>.md-nav-bar .md-button._md-nav-button.md-active,md-nav-bar.md-THEME_NAME-theme.md-warn>.md-nav-bar .md-button._md-nav-button.md-focused{color:\"{{warn-contrast}}\"}md-nav-bar.md-THEME_NAME-theme.md-warn>.md-nav-bar .md-button._md-nav-button.md-focused{background:\"{{warn-contrast-0.1}}\"}md-nav-bar.md-THEME_NAME-theme.md-primary>.md-nav-bar{background-color:\"{{primary-color}}\"}md-nav-bar.md-THEME_NAME-theme.md-primary>.md-nav-bar .md-button._md-nav-button{color:\"{{primary-100}}\"}md-nav-bar.md-THEME_NAME-theme.md-primary>.md-nav-bar .md-button._md-nav-button.md-active,md-nav-bar.md-THEME_NAME-theme.md-primary>.md-nav-bar .md-button._md-nav-button.md-focused{color:\"{{primary-contrast}}\"}md-nav-bar.md-THEME_NAME-theme.md-primary>.md-nav-bar .md-button._md-nav-button.md-focused{background:\"{{primary-contrast-0.1}}\"}md-toolbar>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar{background-color:\"{{primary-color}}\"}md-toolbar>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button{color:\"{{primary-100}}\"}md-toolbar>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button.md-active,md-toolbar>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button.md-focused{color:\"{{primary-contrast}}\"}md-toolbar>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button.md-focused{background:\"{{primary-contrast-0.1}}\"}md-toolbar.md-accent>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar{background-color:\"{{accent-color}}\"}md-toolbar.md-accent>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button{color:\"{{accent-A100}}\"}md-toolbar.md-accent>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button.md-active,md-toolbar.md-accent>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button.md-focused{color:\"{{accent-contrast}}\"}md-toolbar.md-accent>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button.md-focused{background:\"{{accent-contrast-0.1}}\"}md-toolbar.md-accent>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar md-nav-ink-bar{background:\"{{primary-600-1}}\";color:\"{{primary-600-1}}\"}md-toolbar.md-warn>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar{background-color:\"{{warn-color}}\"}md-toolbar.md-warn>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button{color:\"{{warn-100}}\"}md-toolbar.md-warn>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button.md-active,md-toolbar.md-warn>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button.md-focused{color:\"{{warn-contrast}}\"}md-toolbar.md-warn>md-nav-bar.md-THEME_NAME-theme>.md-nav-bar .md-button._md-nav-button.md-focused{background:\"{{warn-contrast-0.1}}\"}._md-panel-backdrop.md-THEME_NAME-theme{background-color:\"{{background-900-1.0}}\"}md-progress-circular.md-THEME_NAME-theme path{stroke:\"{{primary-color}}\"}md-progress-circular.md-THEME_NAME-theme.md-warn path{stroke:\"{{warn-color}}\"}md-progress-circular.md-THEME_NAME-theme.md-accent path{stroke:\"{{accent-color}}\"}md-progress-linear.md-THEME_NAME-theme .md-container{background-color:\"{{primary-100}}\"}md-progress-linear.md-THEME_NAME-theme .md-bar{background-color:\"{{primary-color}}\"}md-progress-linear.md-THEME_NAME-theme.md-warn .md-container{background-color:\"{{warn-100}}\"}md-progress-linear.md-THEME_NAME-theme.md-warn .md-bar{background-color:\"{{warn-color}}\"}md-progress-linear.md-THEME_NAME-theme.md-accent .md-container{background-color:\"{{accent-100}}\"}md-progress-linear.md-THEME_NAME-theme.md-accent .md-bar{background-color:\"{{accent-color}}\"}md-progress-linear.md-THEME_NAME-theme[md-mode=buffer].md-primary .md-bar1{background-color:\"{{primary-100}}\"}md-progress-linear.md-THEME_NAME-theme[md-mode=buffer].md-primary .md-dashed:before{background:radial-gradient(\"{{primary-100}}\" 0,\"{{primary-100}}\" 16%,transparent 42%)}md-progress-linear.md-THEME_NAME-theme[md-mode=buffer].md-warn .md-bar1{background-color:\"{{warn-100}}\"}md-progress-linear.md-THEME_NAME-theme[md-mode=buffer].md-warn .md-dashed:before{background:radial-gradient(\"{{warn-100}}\" 0,\"{{warn-100}}\" 16%,transparent 42%)}md-progress-linear.md-THEME_NAME-theme[md-mode=buffer].md-accent .md-bar1{background-color:\"{{accent-100}}\"}md-progress-linear.md-THEME_NAME-theme[md-mode=buffer].md-accent .md-dashed:before{background:radial-gradient(\"{{accent-100}}\" 0,\"{{accent-100}}\" 16%,transparent 42%)}md-radio-button.md-THEME_NAME-theme .md-off{border-color:\"{{foreground-2}}\"}md-radio-button.md-THEME_NAME-theme .md-on{background-color:\"{{accent-color-0.87}}\"}md-radio-button.md-THEME_NAME-theme.md-checked .md-off{border-color:\"{{accent-color-0.87}}\"}md-radio-button.md-THEME_NAME-theme.md-checked .md-ink-ripple{color:\"{{accent-color-0.87}}\"}md-radio-button.md-THEME_NAME-theme .md-container .md-ripple{color:\"{{accent-A700}}\"}md-radio-button.md-THEME_NAME-theme:not([disabled]).md-primary .md-on,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-primary .md-on,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-primary .md-on,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-primary .md-on{background-color:\"{{primary-color-0.87}}\"}md-radio-button.md-THEME_NAME-theme:not([disabled]).md-primary.md-checked .md-off,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-primary.md-checked .md-off,md-radio-button.md-THEME_NAME-theme:not([disabled]).md-primary .md-checked .md-off,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-primary .md-checked .md-off,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-primary.md-checked .md-off,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-primary.md-checked .md-off,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-primary .md-checked .md-off,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-primary .md-checked .md-off{border-color:\"{{primary-color-0.87}}\"}md-radio-button.md-THEME_NAME-theme:not([disabled]).md-primary.md-checked .md-ink-ripple,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-primary.md-checked .md-ink-ripple,md-radio-button.md-THEME_NAME-theme:not([disabled]).md-primary .md-checked .md-ink-ripple,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-primary .md-checked .md-ink-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-primary.md-checked .md-ink-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-primary.md-checked .md-ink-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-primary .md-checked .md-ink-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-primary .md-checked .md-ink-ripple{color:\"{{primary-color-0.87}}\"}md-radio-button.md-THEME_NAME-theme:not([disabled]).md-primary .md-container .md-ripple,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-primary .md-container .md-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-primary .md-container .md-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-primary .md-container .md-ripple{color:\"{{primary-600}}\"}md-radio-button.md-THEME_NAME-theme:not([disabled]).md-warn .md-on,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-warn .md-on,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-warn .md-on,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-warn .md-on{background-color:\"{{warn-color-0.87}}\"}md-radio-button.md-THEME_NAME-theme:not([disabled]).md-warn.md-checked .md-off,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-warn.md-checked .md-off,md-radio-button.md-THEME_NAME-theme:not([disabled]).md-warn .md-checked .md-off,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-warn .md-checked .md-off,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-warn.md-checked .md-off,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-warn.md-checked .md-off,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-warn .md-checked .md-off,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-warn .md-checked .md-off{border-color:\"{{warn-color-0.87}}\"}md-radio-button.md-THEME_NAME-theme:not([disabled]).md-warn.md-checked .md-ink-ripple,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-warn.md-checked .md-ink-ripple,md-radio-button.md-THEME_NAME-theme:not([disabled]).md-warn .md-checked .md-ink-ripple,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-warn .md-checked .md-ink-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-warn.md-checked .md-ink-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-warn.md-checked .md-ink-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-warn .md-checked .md-ink-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-warn .md-checked .md-ink-ripple{color:\"{{warn-color-0.87}}\"}md-radio-button.md-THEME_NAME-theme:not([disabled]).md-warn .md-container .md-ripple,md-radio-button.md-THEME_NAME-theme:not([disabled]) .md-warn .md-container .md-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]).md-warn .md-container .md-ripple,md-radio-group.md-THEME_NAME-theme:not([disabled]) .md-warn .md-container .md-ripple{color:\"{{warn-600}}\"}md-radio-button.md-THEME_NAME-theme[disabled],md-radio-group.md-THEME_NAME-theme[disabled]{color:\"{{foreground-3}}\"}md-radio-button.md-THEME_NAME-theme[disabled] .md-container .md-off,md-radio-button.md-THEME_NAME-theme[disabled] .md-container .md-on,md-radio-group.md-THEME_NAME-theme[disabled] .md-container .md-off,md-radio-group.md-THEME_NAME-theme[disabled] .md-container .md-on{border-color:\"{{foreground-3}}\"}md-radio-group.md-THEME_NAME-theme .md-checked .md-ink-ripple{color:\"{{accent-color-0.26}}\"}md-radio-group.md-THEME_NAME-theme .md-checked:not([disabled]).md-primary .md-ink-ripple,md-radio-group.md-THEME_NAME-theme.md-primary .md-checked:not([disabled]) .md-ink-ripple{color:\"{{primary-color-0.26}}\"}md-radio-group.md-THEME_NAME-theme.md-focused.ng-empty>md-radio-button:first-child .md-container:before{background-color:\"{{foreground-3-0.26}}\"}md-radio-group.md-THEME_NAME-theme.md-focused:not(:empty) .md-checked .md-container:before{background-color:\"{{accent-color-0.26}}\"}md-radio-group.md-THEME_NAME-theme.md-focused:not(:empty) .md-checked.md-primary .md-container:before,md-radio-group.md-THEME_NAME-theme.md-focused:not(:empty).md-primary .md-checked .md-container:before{background-color:\"{{primary-color-0.26}}\"}md-radio-group.md-THEME_NAME-theme.md-focused:not(:empty) .md-checked.md-warn .md-container:before,md-radio-group.md-THEME_NAME-theme.md-focused:not(:empty).md-warn .md-checked .md-container:before{background-color:\"{{warn-color-0.26}}\"}md-input-container md-select.md-THEME_NAME-theme .md-select-value span:first-child:after{color:\"{{warn-A700}}\"}md-input-container:not(.md-input-focused):not(.md-input-invalid) md-select.md-THEME_NAME-theme .md-select-value span:first-child:after{color:\"{{foreground-3}}\"}md-input-container.md-input-focused:not(.md-input-has-value) md-select.md-THEME_NAME-theme .md-select-value,md-input-container.md-input-focused:not(.md-input-has-value) md-select.md-THEME_NAME-theme .md-select-value.md-select-placeholder{color:\"{{primary-color}}\"}md-input-container.md-input-invalid md-select.md-THEME_NAME-theme .md-select-value{border-bottom-color:\"{{warn-A700}}\"!important;color:\"{{warn-A700}}\"!important}md-input-container.md-input-invalid md-select.md-THEME_NAME-theme.md-no-underline .md-select-value{border-bottom-color:transparent!important}md-input-container:not(.md-input-invalid).md-input-focused.md-accent .md-select-value{border-color:\"{{accent-color}}\"}md-input-container:not(.md-input-invalid).md-input-focused.md-accent .md-select-value span{color:\"{{accent-color}}\"}md-input-container:not(.md-input-invalid).md-input-focused.md-warn .md-select-value{border-color:\"{{warn-A700}}\"}md-input-container:not(.md-input-invalid).md-input-focused.md-warn .md-select-value span{color:\"{{warn-A700}}\"}md-select.md-THEME_NAME-theme[disabled] .md-select-value{background-image:linear-gradient(90deg,\"{{foreground-3}}\" 0,\"{{foreground-3}}\" 33%,transparent 0);background-image:-ms-linear-gradient(left,transparent 0,\"{{foreground-3}}\" 100%);border-bottom-color:transparent}md-select.md-THEME_NAME-theme .md-select-value{border-bottom-color:\"{{foreground-4}}\"}md-select.md-THEME_NAME-theme .md-select-value.md-select-placeholder{color:\"{{foreground-3}}\"}md-select.md-THEME_NAME-theme .md-select-value span:first-child:after{color:\"{{warn-A700}}\"}md-select.md-THEME_NAME-theme.md-no-underline .md-select-value{border-bottom-color:transparent!important}md-select.md-THEME_NAME-theme.ng-invalid.ng-touched .md-select-value{border-bottom-color:\"{{warn-A700}}\"!important;color:\"{{warn-A700}}\"!important}md-select.md-THEME_NAME-theme.ng-invalid.ng-touched.md-no-underline .md-select-value{border-bottom-color:transparent!important}md-select.md-THEME_NAME-theme:not([disabled]):focus .md-select-value{border-bottom-color:\"{{primary-color}}\";color:\"{{ foreground-1 }}\"}md-select.md-THEME_NAME-theme:not([disabled]):focus .md-select-value.md-select-placeholder{color:\"{{ foreground-1 }}\"}md-select.md-THEME_NAME-theme:not([disabled]):focus.md-no-underline .md-select-value{border-bottom-color:transparent!important}md-select.md-THEME_NAME-theme:not([disabled]):focus.md-accent .md-select-value{border-bottom-color:\"{{accent-color}}\"}md-select.md-THEME_NAME-theme:not([disabled]):focus.md-warn .md-select-value{border-bottom-color:\"{{warn-color}}\"}md-select.md-THEME_NAME-theme[disabled] .md-select-icon,md-select.md-THEME_NAME-theme[disabled] .md-select-value,md-select.md-THEME_NAME-theme[disabled] .md-select-value.md-select-placeholder{color:\"{{foreground-3}}\"}md-select.md-THEME_NAME-theme .md-select-icon{color:\"{{foreground-2}}\"}md-select-menu.md-THEME_NAME-theme md-content{background-color:\"{{background-hue-1}}\"}md-select-menu.md-THEME_NAME-theme md-content md-optgroup{color:\"{{foreground-2}}\"}md-select-menu.md-THEME_NAME-theme md-content md-option{color:\"{{foreground-1}}\"}md-select-menu.md-THEME_NAME-theme md-content md-option[disabled] .md-text{color:\"{{foreground-3}}\"}md-select-menu.md-THEME_NAME-theme md-content md-option:not([disabled]):hover{background-color:\"{{background-500-0.10}}\"}md-select-menu.md-THEME_NAME-theme md-content md-option:not([disabled]).md-focused,md-select-menu.md-THEME_NAME-theme md-content md-option:not([disabled]):focus{background-color:\"{{background-500-0.18}}\"}md-select-menu.md-THEME_NAME-theme md-content md-option[selected]{color:\"{{primary-500}}\"}md-select-menu.md-THEME_NAME-theme md-content md-option[selected].md-focused,md-select-menu.md-THEME_NAME-theme md-content md-option[selected]:focus{color:\"{{primary-600}}\"}md-select-menu.md-THEME_NAME-theme md-content md-option[selected].md-accent{color:\"{{accent-color}}\"}md-select-menu.md-THEME_NAME-theme md-content md-option[selected].md-accent.md-focused,md-select-menu.md-THEME_NAME-theme md-content md-option[selected].md-accent:focus{color:\"{{accent-A700}}\"}.md-checkbox-enabled.md-THEME_NAME-theme .md-ripple{color:\"{{primary-600}}\"}.md-checkbox-enabled.md-THEME_NAME-theme[selected] .md-ripple{color:\"{{background-600}}\"}.md-checkbox-enabled.md-THEME_NAME-theme .md-ink-ripple{color:\"{{foreground-2}}\"}.md-checkbox-enabled.md-THEME_NAME-theme[selected] .md-ink-ripple{color:\"{{primary-color-0.87}}\"}.md-checkbox-enabled.md-THEME_NAME-theme:not(.md-checked) .md-icon{border-color:\"{{foreground-2}}\"}.md-checkbox-enabled.md-THEME_NAME-theme[selected] .md-icon{background-color:\"{{primary-color-0.87}}\"}.md-checkbox-enabled.md-THEME_NAME-theme[selected].md-focused .md-container:before{background-color:\"{{primary-color-0.26}}\"}.md-checkbox-enabled.md-THEME_NAME-theme[selected] .md-icon:after{border-color:\"{{primary-contrast-0.87}}\"}.md-checkbox-enabled.md-THEME_NAME-theme .md-indeterminate[disabled] .md-container{color:\"{{foreground-3}}\"}.md-checkbox-enabled.md-THEME_NAME-theme md-option .md-text{color:\"{{foreground-1}}\"}md-sidenav.md-THEME_NAME-theme,md-sidenav.md-THEME_NAME-theme md-content{background-color:\"{{background-hue-1}}\"}md-slider.md-THEME_NAME-theme .md-track{background-color:\"{{foreground-3}}\"}md-slider.md-THEME_NAME-theme .md-track-ticks{color:\"{{background-contrast}}\"}md-slider.md-THEME_NAME-theme .md-focus-ring{background-color:\"{{accent-A200-0.2}}\"}md-slider.md-THEME_NAME-theme .md-disabled-thumb{background-color:\"{{background-color}}\";border-color:\"{{background-color}}\"}md-slider.md-THEME_NAME-theme.md-min .md-thumb:after{background-color:\"{{background-color}}\";border-color:\"{{foreground-3}}\"}md-slider.md-THEME_NAME-theme.md-min .md-focus-ring{background-color:\"{{foreground-3-0.38}}\"}md-slider.md-THEME_NAME-theme.md-min[md-discrete] .md-thumb:after{background-color:\"{{background-contrast}}\";border-color:transparent}md-slider.md-THEME_NAME-theme.md-min[md-discrete] .md-sign{background-color:\"{{background-400}}\"}md-slider.md-THEME_NAME-theme.md-min[md-discrete] .md-sign:after{border-top-color:\"{{background-400}}\"}md-slider.md-THEME_NAME-theme.md-min[md-discrete][md-vertical] .md-sign:after{border-left-color:\"{{background-400}}\";border-top-color:transparent}md-slider.md-THEME_NAME-theme .md-track.md-track-fill{background-color:\"{{accent-color}}\"}md-slider.md-THEME_NAME-theme .md-thumb:after{background-color:\"{{accent-color}}\";border-color:\"{{accent-color}}\"}md-slider.md-THEME_NAME-theme .md-sign{background-color:\"{{accent-color}}\"}md-slider.md-THEME_NAME-theme .md-sign:after{border-top-color:\"{{accent-color}}\"}md-slider.md-THEME_NAME-theme[md-vertical] .md-sign:after{border-left-color:\"{{accent-color}}\";border-top-color:transparent}md-slider.md-THEME_NAME-theme .md-thumb-text{color:\"{{accent-contrast}}\"}md-slider.md-THEME_NAME-theme.md-warn .md-focus-ring{background-color:\"{{warn-200-0.38}}\"}md-slider.md-THEME_NAME-theme.md-warn .md-track.md-track-fill{background-color:\"{{warn-color}}\"}md-slider.md-THEME_NAME-theme.md-warn .md-thumb:after{background-color:\"{{warn-color}}\";border-color:\"{{warn-color}}\"}md-slider.md-THEME_NAME-theme.md-warn .md-sign{background-color:\"{{warn-color}}\"}md-slider.md-THEME_NAME-theme.md-warn .md-sign:after{border-top-color:\"{{warn-color}}\"}md-slider.md-THEME_NAME-theme.md-warn[md-vertical] .md-sign:after{border-left-color:\"{{warn-color}}\";border-top-color:transparent}md-slider.md-THEME_NAME-theme.md-warn .md-thumb-text{color:\"{{warn-contrast}}\"}md-slider.md-THEME_NAME-theme.md-primary .md-focus-ring{background-color:\"{{primary-200-0.38}}\"}md-slider.md-THEME_NAME-theme.md-primary .md-track.md-track-fill{background-color:\"{{primary-color}}\"}md-slider.md-THEME_NAME-theme.md-primary .md-thumb:after{background-color:\"{{primary-color}}\";border-color:\"{{primary-color}}\"}md-slider.md-THEME_NAME-theme.md-primary .md-sign{background-color:\"{{primary-color}}\"}md-slider.md-THEME_NAME-theme.md-primary .md-sign:after{border-top-color:\"{{primary-color}}\"}md-slider.md-THEME_NAME-theme.md-primary[md-vertical] .md-sign:after{border-left-color:\"{{primary-color}}\";border-top-color:transparent}md-slider.md-THEME_NAME-theme.md-primary .md-thumb-text{color:\"{{primary-contrast}}\"}md-slider.md-THEME_NAME-theme[disabled] .md-thumb:after{border-color:transparent}md-slider.md-THEME_NAME-theme[disabled]:not(.md-min) .md-thumb:after,md-slider.md-THEME_NAME-theme[disabled][md-discrete] .md-thumb:after{background-color:\"{{foreground-3}}\";border-color:transparent}md-slider.md-THEME_NAME-theme[disabled][readonly] .md-sign{background-color:\"{{background-400}}\"}md-slider.md-THEME_NAME-theme[disabled][readonly] .md-sign:after{border-top-color:\"{{background-400}}\"}md-slider.md-THEME_NAME-theme[disabled][readonly][md-vertical] .md-sign:after{border-left-color:\"{{background-400}}\";border-top-color:transparent}md-slider.md-THEME_NAME-theme[disabled][readonly] .md-disabled-thumb{background-color:transparent;border-color:transparent}md-slider-container[disabled]>:first-child:not(md-slider),md-slider-container[disabled]>:last-child:not(md-slider){color:\"{{foreground-3}}\"}.md-subheader.md-THEME_NAME-theme{background-color:\"{{background-default}}\";color:\"{{ foreground-2-0.54 }}\"}.md-subheader.md-THEME_NAME-theme.md-primary{color:\"{{primary-color}}\"}.md-subheader.md-THEME_NAME-theme.md-accent{color:\"{{accent-color}}\"}.md-subheader.md-THEME_NAME-theme.md-warn{color:\"{{warn-color}}\"}md-switch.md-THEME_NAME-theme .md-ink-ripple{color:\"{{background-500}}\"}md-switch.md-THEME_NAME-theme .md-thumb{background-color:\"{{background-50}}\"}md-switch.md-THEME_NAME-theme .md-bar{background-color:\"{{background-500}}\"}md-switch.md-THEME_NAME-theme.md-focused:not(.md-checked) .md-thumb:before,md-switch.md-THEME_NAME-theme.md-focused[disabled] .md-thumb:before{background-color:\"{{foreground-4}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]) .md-ink-ripple{color:\"{{accent-color}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]) .md-thumb{background-color:\"{{accent-color}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]) .md-bar{background-color:\"{{accent-color-0.5}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]).md-focused .md-thumb:before{background-color:\"{{accent-color-0.26}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]).md-primary .md-ink-ripple{color:\"{{primary-color}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]).md-primary .md-thumb{background-color:\"{{primary-color}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]).md-primary .md-bar{background-color:\"{{primary-color-0.5}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]).md-primary.md-focused .md-thumb:before{background-color:\"{{primary-color-0.26}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]).md-warn .md-ink-ripple{color:\"{{warn-color}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]).md-warn .md-thumb{background-color:\"{{warn-color}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]).md-warn .md-bar{background-color:\"{{warn-color-0.5}}\"}md-switch.md-THEME_NAME-theme.md-checked:not([disabled]).md-warn.md-focused .md-thumb:before{background-color:\"{{warn-color-0.26}}\"}md-switch.md-THEME_NAME-theme[disabled] .md-thumb{background-color:\"{{background-400}}\"}md-switch.md-THEME_NAME-theme[disabled] .md-bar{background-color:\"{{foreground-4}}\"}md-tabs.md-THEME_NAME-theme md-tabs-wrapper{background-color:transparent;border-color:\"{{foreground-4}}\"}md-tabs.md-THEME_NAME-theme md-next-button md-icon,md-tabs.md-THEME_NAME-theme md-prev-button md-icon{color:\"{{foreground-2}}\"}md-tabs.md-THEME_NAME-theme md-ink-bar{background:\"{{accent-color}}\";color:\"{{accent-color}}\"}md-tabs.md-THEME_NAME-theme .md-tab{color:\"{{foreground-2}}\"}md-tabs.md-THEME_NAME-theme .md-tab[disabled],md-tabs.md-THEME_NAME-theme .md-tab[disabled] md-icon{color:\"{{foreground-3}}\"}md-tabs.md-THEME_NAME-theme .md-tab.md-active,md-tabs.md-THEME_NAME-theme .md-tab.md-active md-icon,md-tabs.md-THEME_NAME-theme .md-tab.md-focused,md-tabs.md-THEME_NAME-theme .md-tab.md-focused md-icon{color:\"{{accent-color}}\"}md-tabs.md-THEME_NAME-theme .md-tab.md-focused{background:\"{{primary-color-0.1}}\"}md-tabs.md-THEME_NAME-theme .md-tab .md-ripple-container{color:\"{{accent-A100}}\"}md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper{background-color:\"{{accent-500}}\"}md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]),md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]) md-icon,md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper md-next-button md-icon,md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper md-prev-button md-icon{color:\"{{accent-500-contrast-0.7}}\"}md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active,md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active md-icon,md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused,md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused md-icon{color:\"{{accent-500-contrast-1}}\"}md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused{background:\"{{accent-500-contrast-0.1}}\"}md-tabs.md-THEME_NAME-theme.md-accent>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-ink-bar{background:\"{{accent-500-contrast}}\";color:\"{{accent-500-contrast}}\"}md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper{background-color:\"{{primary-color}}\"}md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper md-next-button md-icon,md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper md-prev-button md-icon{color:\"{{primary-contrast}}\"}md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]),md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]) md-icon{color:\"{{primary-contrast-0.7}}\"}md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active,md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active md-icon,md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused,md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused md-icon{color:\"{{primary-contrast}}\"}md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused{background:\"{{primary-contrast-0.1}}\"}md-tabs.md-THEME_NAME-theme.md-primary>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-ink-bar{background:\"{{accent-color}}\";color:\"{{accent-color}}\"}md-tabs.md-THEME_NAME-theme.md-primary.md-no-ink-bar-color>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-ink-bar{background:\"{{primary-contrast}}\";color:\"{{primary-contrast}}\"}md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper{background-color:\"{{warn-500}}\"}md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper md-next-button md-icon,md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper md-prev-button md-icon{color:\"{{warn-500-contrast}}\"}md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]),md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]) md-icon{color:\"{{warn-500-contrast-0.7}}\"}md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active,md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active md-icon,md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused,md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused md-icon{color:\"{{warn-500-contrast-1}}\"}md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused{background:\"{{warn-500-contrast-0.1}}\"}md-tabs.md-THEME_NAME-theme.md-warn>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-ink-bar{background:\"{{warn-500-contrast}}\";color:\"{{warn-500-contrast}}\"}md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper{background-color:\"{{primary-color}}\"}md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper md-next-button md-icon,md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper md-prev-button md-icon{color:\"{{primary-contrast}}\"}md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]),md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]) md-icon{color:\"{{primary-contrast-0.7}}\"}md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active,md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active md-icon,md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused,md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused md-icon{color:\"{{primary-contrast}}\"}md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused{background:\"{{primary-contrast-0.1}}\"}md-toolbar>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-ink-bar{background:\"{{accent-color}}\";color:\"{{accent-color}}\"}md-toolbar>md-tabs.md-THEME_NAME-theme.md-no-ink-bar-color>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-ink-bar{background:\"{{primary-contrast}}\";color:\"{{primary-contrast}}\"}md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper{background-color:\"{{accent-500}}\"}md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]),md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]) md-icon,md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper md-next-button md-icon,md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper md-prev-button md-icon{color:\"{{accent-500-contrast-0.7}}\"}md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active,md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active md-icon,md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused,md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused md-icon{color:\"{{accent-500-contrast-1}}\"}md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused{background:\"{{accent-500-contrast-0.1}}\"}md-toolbar.md-accent>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-ink-bar{background:\"{{accent-500-contrast}}\";color:\"{{accent-500-contrast}}\"}md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper{background-color:\"{{warn-500}}\"}md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper md-next-button md-icon,md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper md-prev-button md-icon{color:\"{{warn-500-contrast}}\"}md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]),md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]) md-icon{color:\"{{warn-500-contrast-0.7}}\"}md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active,md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-active md-icon,md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused,md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused md-icon{color:\"{{warn-500-contrast-1}}\"}md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-tab-item:not([disabled]).md-focused{background:\"{{warn-500-contrast-0.1}}\"}md-toolbar.md-warn>md-tabs.md-THEME_NAME-theme>md-tabs-wrapper>md-tabs-canvas>md-pagination-wrapper>md-ink-bar{background:\"{{warn-500-contrast}}\";color:\"{{warn-500-contrast}}\"}md-toast.md-THEME_NAME-theme .md-toast-content{background-color:#323232;color:\"{{background-50}}\"}md-toast.md-THEME_NAME-theme .md-toast-content .md-button{color:\"{{background-50}}\"}md-toast.md-THEME_NAME-theme .md-toast-content .md-button.md-highlight{color:\"{{accent-color}}\"}md-toast.md-THEME_NAME-theme .md-toast-content .md-button.md-highlight.md-primary{color:\"{{primary-color}}\"}md-toast.md-THEME_NAME-theme .md-toast-content .md-button.md-highlight.md-warn{color:\"{{warn-color}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar){background-color:\"{{primary-color}}\";color:\"{{primary-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-icon{fill:\"{{primary-contrast}}\";color:\"{{primary-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) .md-button[disabled] md-icon{fill:\"{{primary-contrast-0.26}}\";color:\"{{primary-contrast-0.26}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float] .md-input{border-color:\"{{primary-default-contrast-divider}}\";color:\"{{primary-default-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float] .md-input::-webkit-input-placeholder{color:\"{{primary-default-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float] .md-input:-ms-input-placeholder{color:\"{{primary-default-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float] .md-input::-ms-input-placeholder{color:\"{{primary-default-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float] .md-input::placeholder{color:\"{{primary-default-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float] .md-input:-moz-placeholder,md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float] .md-input::-moz-placeholder{color:\"{{primary-default-contrast-hint}}\";opacity:1}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float].md-input-focused .md-input::-webkit-input-placeholder{color:\"{{primary-default-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float].md-input-focused .md-input:-ms-input-placeholder{color:\"{{primary-default-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float].md-input-focused .md-input::-ms-input-placeholder{color:\"{{primary-default-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float].md-input-focused .md-input::placeholder{color:\"{{primary-default-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float].md-input-focused .md-input:-moz-placeholder,md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float].md-input-focused .md-input::-moz-placeholder{color:\"{{primary-default-contrast-secondary}}\";opacity:1}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float]:not(.md-input-invalid).md-input-focused .md-input,md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float]:not(.md-input-invalid).md-input-resized .md-input{border-color:\"{{primary-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float]:not(.md-input-invalid).md-input-focused.md-accent .md-input{border-color:\"{{accent-color}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar) md-input-container[md-no-float]:not(.md-input-invalid).md-input-focused.md-warn .md-input{border-color:\"{{warn-A700}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent{background-color:\"{{accent-500}}\";color:\"{{accent-500-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent .md-ink-ripple{color:\"{{accent-500-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-icon{fill:\"{{accent-500-contrast}}\";color:\"{{accent-500-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent .md-button[disabled] md-icon{fill:\"{{accent-500-contrast-0.26}}\";color:\"{{accent-500-contrast-0.26}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float] .md-input{border-color:\"{{accent-500-contrast-divider}}\";color:\"{{accent-500-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float] .md-input::-webkit-input-placeholder{color:\"{{accent-500-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float] .md-input:-ms-input-placeholder{color:\"{{accent-500-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float] .md-input::-ms-input-placeholder{color:\"{{accent-500-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float] .md-input::placeholder{color:\"{{accent-500-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float] .md-input:-moz-placeholder,md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float] .md-input::-moz-placeholder{color:\"{{accent-500-contrast-hint}}\";opacity:1}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float].md-input-focused .md-input::-webkit-input-placeholder{color:\"{{accent-500-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float].md-input-focused .md-input:-ms-input-placeholder{color:\"{{accent-500-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float].md-input-focused .md-input::-ms-input-placeholder{color:\"{{accent-500-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float].md-input-focused .md-input::placeholder{color:\"{{accent-500-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float].md-input-focused .md-input:-moz-placeholder,md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float].md-input-focused .md-input::-moz-placeholder{color:\"{{accent-500-contrast-secondary}}\";opacity:1}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float]:not(.md-input-invalid).md-input-focused .md-input,md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float]:not(.md-input-invalid).md-input-resized .md-input{border-color:\"{{primary-color}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float]:not(.md-input-invalid).md-input-focused.md-accent .md-input{border-color:\"{{accent-500-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-accent md-input-container[md-no-float]:not(.md-input-invalid).md-input-focused.md-warn .md-input{border-color:\"{{warn-A700}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn{background-color:\"{{warn-500}}\";color:\"{{warn-500-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-icon{fill:\"{{warn-500-contrast}}\";color:\"{{warn-500-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float] .md-input{border-color:\"{{warn-500-contrast-divider}}\";color:\"{{warn-500-contrast}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float] .md-input::-webkit-input-placeholder{color:\"{{warn-500-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float] .md-input:-ms-input-placeholder{color:\"{{warn-500-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float] .md-input::-ms-input-placeholder{color:\"{{warn-500-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float] .md-input::placeholder{color:\"{{warn-500-contrast-hint}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float] .md-input:-moz-placeholder,md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float] .md-input::-moz-placeholder{color:\"{{warn-500-contrast-hint}}\";opacity:1}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float].md-input-focused .md-input::-webkit-input-placeholder{color:\"{{warn-500-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float].md-input-focused .md-input:-ms-input-placeholder{color:\"{{warn-500-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float].md-input-focused .md-input::-ms-input-placeholder{color:\"{{warn-500-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float].md-input-focused .md-input::placeholder{color:\"{{warn-500-contrast-secondary}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float].md-input-focused .md-input:-moz-placeholder,md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float].md-input-focused .md-input::-moz-placeholder{color:\"{{warn-500-contrast-secondary}}\";opacity:1}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float]:not(.md-input-invalid).md-input-focused .md-input,md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float]:not(.md-input-invalid).md-input-resized .md-input{border-color:\"{{primary-color}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float]:not(.md-input-invalid).md-input-focused.md-accent .md-input{border-color:\"{{accent-color}}\"}md-toolbar.md-THEME_NAME-theme:not(.md-menu-toolbar).md-warn md-input-container[md-no-float]:not(.md-input-invalid).md-input-focused.md-warn .md-input{border-color:\"{{warn-500-contrast}}\"}.md-panel.md-tooltip.md-THEME_NAME-theme{background-color:\"{{background-700}}\";color:\"{{background-700-contrast}}\"}body.md-THEME_NAME-theme,html.md-THEME_NAME-theme{background-color:\"{{background-color}}\";color:\"{{foreground-1}}\"}");
+})();
+
+
+})(window, window.angular);;window.ngMaterial={version:{full: "1.2.3"}};
+
+/***/ }),
+
+/***/ "./node_modules/angular-material/index.js":
+/*!************************************************!*\
+ !*** ./node_modules/angular-material/index.js ***!
+ \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+// Should already be required, here for clarity
+__webpack_require__(/*! angular */ "./node_modules/angular/index-exposed.js");
+
+// Load Angular and dependent libs
+__webpack_require__(/*! angular-animate */ "./node_modules/angular-animate/index.js");
+__webpack_require__(/*! angular-aria */ "./node_modules/angular-aria/index.js");
+
+// Now load Angular Material
+__webpack_require__(/*! ./angular-material */ "./node_modules/angular-material/angular-material.js");
+
+// Export namespace
+module.exports = 'ngMaterial';
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-messages/angular-messages.js":
+/*!***********************************************************!*\
+ !*** ./node_modules/angular-messages/angular-messages.js ***!
+ \***********************************************************/
+/***/ (() => {
+
+/**
+ * @license AngularJS v1.8.2
+ * (c) 2010-2020 Google LLC. http://angularjs.org
+ * License: MIT
+ */
+(function(window, angular) {'use strict';
+
+var forEach;
+var isArray;
+var isString;
+var jqLite;
+
+/**
+ * @ngdoc module
+ * @name ngMessages
+ * @description
+ *
+ * The `ngMessages` module provides enhanced support for displaying messages within templates
+ * (typically within forms or when rendering message objects that return key/value data).
+ * Instead of relying on JavaScript code and/or complex ng-if statements within your form template to
+ * show and hide error messages specific to the state of an input field, the `ngMessages` and
+ * `ngMessage` directives are designed to handle the complexity, inheritance and priority
+ * sequencing based on the order of how the messages are defined in the template.
+ *
+ * Currently, the ngMessages module only contains the code for the `ngMessages`, `ngMessagesInclude`
+ * `ngMessage`, `ngMessageExp` and `ngMessageDefault` directives.
+ *
+ * ## Usage
+ * The `ngMessages` directive allows keys in a key/value collection to be associated with a child element
+ * (or 'message') that will show or hide based on the truthiness of that key's value in the collection. A common use
+ * case for `ngMessages` is to display error messages for inputs using the `$error` object exposed by the
+ * {@link ngModel ngModel} directive.
+ *
+ * The child elements of the `ngMessages` directive are matched to the collection keys by a `ngMessage` or
+ * `ngMessageExp` directive. The value of these attributes must match a key in the collection that is provided by
+ * the `ngMessages` directive.
+ *
+ * Consider the following example, which illustrates a typical use case of `ngMessages`. Within the form `myForm` we
+ * have a text input named `myField` which is bound to the scope variable `field` using the {@link ngModel ngModel}
+ * directive.
+ *
+ * The `myField` field is a required input of type `email` with a maximum length of 15 characters.
+ *
+ * ```html
+ * <form name="myForm">
+ * <label>
+ * Enter text:
+ * <input type="email" ng-model="field" name="myField" required maxlength="15" />
+ * </label>
+ * <div ng-messages="myForm.myField.$error" role="alert">
+ * <div ng-message="required">Please enter a value for this field.</div>
+ * <div ng-message="email">This field must be a valid email address.</div>
+ * <div ng-message="maxlength">This field can be at most 15 characters long.</div>
+ * </div>
+ * </form>
+ * ```
+ *
+ * In order to show error messages corresponding to `myField` we first create an element with an `ngMessages` attribute
+ * set to the `$error` object owned by the `myField` input in our `myForm` form.
+ *
+ * Within this element we then create separate elements for each of the possible errors that `myField` could have.
+ * The `ngMessage` attribute is used to declare which element(s) will appear for which error - for example,
+ * setting `ng-message="required"` specifies that this particular element should be displayed when there
+ * is no value present for the required field `myField` (because the key `required` will be `true` in the object
+ * `myForm.myField.$error`).
+ *
+ * ### Message order
+ *
+ * By default, `ngMessages` will only display one message for a particular key/value collection at any time. If more
+ * than one message (or error) key is currently true, then which message is shown is determined by the order of messages
+ * in the HTML template code (messages declared first are prioritised). This mechanism means the developer does not have
+ * to prioritize messages using custom JavaScript code.
+ *
+ * Given the following error object for our example (which informs us that the field `myField` currently has both the
+ * `required` and `email` errors):
+ *
+ * ```javascript
+ * <!-- keep in mind that ngModel automatically sets these error flags -->
+ * myField.$error = { required : true, email: true, maxlength: false };
+ * ```
+ * The `required` message will be displayed to the user since it appears before the `email` message in the DOM.
+ * Once the user types a single character, the `required` message will disappear (since the field now has a value)
+ * but the `email` message will be visible because it is still applicable.
+ *
+ * ### Displaying multiple messages at the same time
+ *
+ * While `ngMessages` will by default only display one error element at a time, the `ng-messages-multiple` attribute can
+ * be applied to the `ngMessages` container element to cause it to display all applicable error messages at once:
+ *
+ * ```html
+ * <!-- attribute-style usage -->
+ * <div ng-messages="myForm.myField.$error" ng-messages-multiple>...</div>
+ *
+ * <!-- element-style usage -->
+ * <ng-messages for="myForm.myField.$error" multiple>...</ng-messages>
+ * ```
+ *
+ * ## Reusing and Overriding Messages
+ * In addition to prioritization, ngMessages also allows for including messages from a remote or an inline
+ * template. This allows for generic collection of messages to be reused across multiple parts of an
+ * application.
+ *
+ * ```html
+ * <script type="text/ng-template" id="error-messages">
+ * <div ng-message="required">This field is required</div>
+ * <div ng-message="minlength">This field is too short</div>
+ * </script>
+ *
+ * <div ng-messages="myForm.myField.$error" role="alert">
+ * <div ng-messages-include="error-messages"></div>
+ * </div>
+ * ```
+ *
+ * However, including generic messages may not be useful enough to match all input fields, therefore,
+ * `ngMessages` provides the ability to override messages defined in the remote template by redefining
+ * them within the directive container.
+ *
+ * ```html
+ * <!-- a generic template of error messages known as "my-custom-messages" -->
+ * <script type="text/ng-template" id="my-custom-messages">
+ * <div ng-message="required">This field is required</div>
+ * <div ng-message="minlength">This field is too short</div>
+ * </script>
+ *
+ * <form name="myForm">
+ * <label>
+ * Email address
+ * <input type="email"
+ * id="email"
+ * name="myEmail"
+ * ng-model="email"
+ * minlength="5"
+ * required />
+ * </label>
+ * <!-- any ng-message elements that appear BEFORE the ng-messages-include will
+ * override the messages present in the ng-messages-include template -->
+ * <div ng-messages="myForm.myEmail.$error" role="alert">
+ * <!-- this required message has overridden the template message -->
+ * <div ng-message="required">You did not enter your email address</div>
+ *
+ * <!-- this is a brand new message and will appear last in the prioritization -->
+ * <div ng-message="email">Your email address is invalid</div>
+ *
+ * <!-- and here are the generic error messages -->
+ * <div ng-messages-include="my-custom-messages"></div>
+ * </div>
+ * </form>
+ * ```
+ *
+ * In the example HTML code above the message that is set on required will override the corresponding
+ * required message defined within the remote template. Therefore, with particular input fields (such
+ * email addresses, date fields, autocomplete inputs, etc...), specialized error messages can be applied
+ * while more generic messages can be used to handle other, more general input errors.
+ *
+ * ## Dynamic Messaging
+ * ngMessages also supports using expressions to dynamically change key values. Using arrays and
+ * repeaters to list messages is also supported. This means that the code below will be able to
+ * fully adapt itself and display the appropriate message when any of the expression data changes:
+ *
+ * ```html
+ * <form name="myForm">
+ * <label>
+ * Email address
+ * <input type="email"
+ * name="myEmail"
+ * ng-model="email"
+ * minlength="5"
+ * required />
+ * </label>
+ * <div ng-messages="myForm.myEmail.$error" role="alert">
+ * <div ng-message="required">You did not enter your email address</div>
+ * <div ng-repeat="errorMessage in errorMessages">
+ * <!-- use ng-message-exp for a message whose key is given by an expression -->
+ * <div ng-message-exp="errorMessage.type">{{ errorMessage.text }}</div>
+ * </div>
+ * </div>
+ * </form>
+ * ```
+ *
+ * The `errorMessage.type` expression can be a string value or it can be an array so
+ * that multiple errors can be associated with a single error message:
+ *
+ * ```html
+ * <label>
+ * Email address
+ * <input type="email"
+ * ng-model="data.email"
+ * name="myEmail"
+ * ng-minlength="5"
+ * ng-maxlength="100"
+ * required />
+ * </label>
+ * <div ng-messages="myForm.myEmail.$error" role="alert">
+ * <div ng-message-exp="'required'">You did not enter your email address</div>
+ * <div ng-message-exp="['minlength', 'maxlength']">
+ * Your email must be between 5 and 100 characters long
+ * </div>
+ * </div>
+ * ```
+ *
+ * Feel free to use other structural directives such as ng-if and ng-switch to further control
+ * what messages are active and when. Be careful, if you place ng-message on the same element
+ * as these structural directives, AngularJS may not be able to determine if a message is active
+ * or not. Therefore it is best to place the ng-message on a child element of the structural
+ * directive.
+ *
+ * ```html
+ * <div ng-messages="myForm.myEmail.$error" role="alert">
+ * <div ng-if="showRequiredError">
+ * <div ng-message="required">Please enter something</div>
+ * </div>
+ * </div>
+ * ```
+ *
+ * ## Animations
+ * If the `ngAnimate` module is active within the application then the `ngMessages`, `ngMessage` and
+ * `ngMessageExp` directives will trigger animations whenever any messages are added and removed from
+ * the DOM by the `ngMessages` directive.
+ *
+ * Whenever the `ngMessages` directive contains one or more visible messages then the `.ng-active` CSS
+ * class will be added to the element. The `.ng-inactive` CSS class will be applied when there are no
+ * messages present. Therefore, CSS transitions and keyframes as well as JavaScript animations can
+ * hook into the animations whenever these classes are added/removed.
+ *
+ * Let's say that our HTML code for our messages container looks like so:
+ *
+ * ```html
+ * <div ng-messages="myMessages" class="my-messages" role="alert">
+ * <div ng-message="alert" class="some-message">...</div>
+ * <div ng-message="fail" class="some-message">...</div>
+ * </div>
+ * ```
+ *
+ * Then the CSS animation code for the message container looks like so:
+ *
+ * ```css
+ * .my-messages {
+ * transition:1s linear all;
+ * }
+ * .my-messages.ng-active {
+ * // messages are visible
+ * }
+ * .my-messages.ng-inactive {
+ * // messages are hidden
+ * }
+ * ```
+ *
+ * Whenever an inner message is attached (becomes visible) or removed (becomes hidden) then the enter
+ * and leave animation is triggered for each particular element bound to the `ngMessage` directive.
+ *
+ * Therefore, the CSS code for the inner messages looks like so:
+ *
+ * ```css
+ * .some-message {
+ * transition:1s linear all;
+ * }
+ *
+ * .some-message.ng-enter {}
+ * .some-message.ng-enter.ng-enter-active {}
+ *
+ * .some-message.ng-leave {}
+ * .some-message.ng-leave.ng-leave-active {}
+ * ```
+ *
+ * {@link ngAnimate See the ngAnimate docs} to learn how to use JavaScript animations or to learn
+ * more about ngAnimate.
+ *
+ * ## Displaying a default message
+ * If the ngMessages renders no inner ngMessage directive (i.e. when none of the truthy
+ * keys are matched by a defined message), then it will render a default message
+ * using the {@link ngMessageDefault} directive.
+ * Note that matched messages will always take precedence over unmatched messages. That means
+ * the default message will not be displayed when another message is matched. This is also
+ * true for `ng-messages-multiple`.
+ *
+ * ```html
+ * <div ng-messages="myForm.myField.$error" role="alert">
+ * <div ng-message="required">This field is required</div>
+ * <div ng-message="minlength">This field is too short</div>
+ * <div ng-message-default>This field has an input error</div>
+ * </div>
+ * ```
+ *
+
+ */
+angular.module('ngMessages', [], function initAngularHelpers() {
+ // Access helpers from AngularJS core.
+ // Do it inside a `config` block to ensure `window.angular` is available.
+ forEach = angular.forEach;
+ isArray = angular.isArray;
+ isString = angular.isString;
+ jqLite = angular.element;
+})
+ .info({ angularVersion: '1.8.2' })
+
+ /**
+ * @ngdoc directive
+ * @module ngMessages
+ * @name ngMessages
+ * @restrict AE
+ *
+ * @description
+ * `ngMessages` is a directive that is designed to show and hide messages based on the state
+ * of a key/value object that it listens on. The directive itself complements error message
+ * reporting with the `ngModel` $error object (which stores a key/value state of validation errors).
+ *
+ * `ngMessages` manages the state of internal messages within its container element. The internal
+ * messages use the `ngMessage` directive and will be inserted/removed from the page depending
+ * on if they're present within the key/value object. By default, only one message will be displayed
+ * at a time and this depends on the prioritization of the messages within the template. (This can
+ * be changed by using the `ng-messages-multiple` or `multiple` attribute on the directive container.)
+ *
+ * A remote template can also be used (With {@link ngMessagesInclude}) to promote message
+ * reusability and messages can also be overridden.
+ *
+ * A default message can also be displayed when no `ngMessage` directive is inserted, using the
+ * {@link ngMessageDefault} directive.
+ *
+ * {@link module:ngMessages Click here} to learn more about `ngMessages` and `ngMessage`.
+ *
+ * @usage
+ * ```html
+ * <!-- using attribute directives -->
+ * <ANY ng-messages="expression" role="alert">
+ * <ANY ng-message="stringValue">...</ANY>
+ * <ANY ng-message="stringValue1, stringValue2, ...">...</ANY>
+ * <ANY ng-message-exp="expressionValue">...</ANY>
+ * <ANY ng-message-default>...</ANY>
+ * </ANY>
+ *
+ * <!-- or by using element directives -->
+ * <ng-messages for="expression" role="alert">
+ * <ng-message when="stringValue">...</ng-message>
+ * <ng-message when="stringValue1, stringValue2, ...">...</ng-message>
+ * <ng-message when-exp="expressionValue">...</ng-message>
+ * <ng-message-default>...</ng-message-default>
+ * </ng-messages>
+ * ```
+ *
+ * @param {string} ngMessages an AngularJS expression evaluating to a key/value object
+ * (this is typically the $error object on an ngModel instance).
+ * @param {string=} ngMessagesMultiple|multiple when set, all messages will be displayed with true
+ *
+ * @example
+ * <example name="ngMessages-directive" module="ngMessagesExample"
+ * deps="angular-messages.js"
+ * animations="true" fixBase="true">
+ * <file name="index.html">
+ * <form name="myForm">
+ * <label>
+ * Enter your name:
+ * <input type="text"
+ * name="myName"
+ * ng-model="name"
+ * ng-minlength="5"
+ * ng-maxlength="20"
+ * required />
+ * </label>
+ * <pre>myForm.myName.$error = {{ myForm.myName.$error | json }}</pre>
+ *
+ * <div ng-messages="myForm.myName.$error" style="color:maroon" role="alert">
+ * <div ng-message="required">You did not enter a field</div>
+ * <div ng-message="minlength">Your field is too short</div>
+ * <div ng-message="maxlength">Your field is too long</div>
+ * <div ng-message-default>This field has an input error</div>
+ * </div>
+ * </form>
+ * </file>
+ * <file name="script.js">
+ * angular.module('ngMessagesExample', ['ngMessages']);
+ * </file>
+ * </example>
+ */
+ .directive('ngMessages', ['$animate', function($animate) {
+ var ACTIVE_CLASS = 'ng-active';
+ var INACTIVE_CLASS = 'ng-inactive';
+
+ return {
+ require: 'ngMessages',
+ restrict: 'AE',
+ controller: ['$element', '$scope', '$attrs', function NgMessagesCtrl($element, $scope, $attrs) {
+ var ctrl = this;
+ var latestKey = 0;
+ var nextAttachId = 0;
+
+ this.getAttachId = function getAttachId() { return nextAttachId++; };
+
+ var messages = this.messages = {};
+ var renderLater, cachedCollection;
+
+ this.render = function(collection) {
+ collection = collection || {};
+
+ renderLater = false;
+ cachedCollection = collection;
+
+ // this is true if the attribute is empty or if the attribute value is truthy
+ var multiple = isAttrTruthy($scope, $attrs.ngMessagesMultiple) ||
+ isAttrTruthy($scope, $attrs.multiple);
+
+ var unmatchedMessages = [];
+ var matchedKeys = {};
+ var truthyKeys = 0;
+ var messageItem = ctrl.head;
+ var messageFound = false;
+ var totalMessages = 0;
+
+ // we use != instead of !== to allow for both undefined and null values
+ while (messageItem != null) {
+ totalMessages++;
+ var messageCtrl = messageItem.message;
+
+ var messageUsed = false;
+ if (!messageFound) {
+ forEach(collection, function(value, key) {
+ if (truthy(value) && !messageUsed) {
+ truthyKeys++;
+
+ if (messageCtrl.test(key)) {
+ // this is to prevent the same error name from showing up twice
+ if (matchedKeys[key]) return;
+ matchedKeys[key] = true;
+
+ messageUsed = true;
+ messageCtrl.attach();
+ }
+ }
+ });
+ }
+
+ if (messageUsed) {
+ // unless we want to display multiple messages then we should
+ // set a flag here to avoid displaying the next message in the list
+ messageFound = !multiple;
+ } else {
+ unmatchedMessages.push(messageCtrl);
+ }
+
+ messageItem = messageItem.next;
+ }
+
+ forEach(unmatchedMessages, function(messageCtrl) {
+ messageCtrl.detach();
+ });
+
+ var messageMatched = unmatchedMessages.length !== totalMessages;
+ var attachDefault = ctrl.default && !messageMatched && truthyKeys > 0;
+
+ if (attachDefault) {
+ ctrl.default.attach();
+ } else if (ctrl.default) {
+ ctrl.default.detach();
+ }
+
+ if (messageMatched || attachDefault) {
+ $animate.setClass($element, ACTIVE_CLASS, INACTIVE_CLASS);
+ } else {
+ $animate.setClass($element, INACTIVE_CLASS, ACTIVE_CLASS);
+ }
+ };
+
+ $scope.$watchCollection($attrs.ngMessages || $attrs['for'], ctrl.render);
+
+ this.reRender = function() {
+ if (!renderLater) {
+ renderLater = true;
+ $scope.$evalAsync(function() {
+ if (renderLater && cachedCollection) {
+ ctrl.render(cachedCollection);
+ }
+ });
+ }
+ };
+
+ this.register = function(comment, messageCtrl, isDefault) {
+ if (isDefault) {
+ ctrl.default = messageCtrl;
+ } else {
+ var nextKey = latestKey.toString();
+ messages[nextKey] = {
+ message: messageCtrl
+ };
+ insertMessageNode($element[0], comment, nextKey);
+ comment.$$ngMessageNode = nextKey;
+ latestKey++;
+ }
+
+ ctrl.reRender();
+ };
+
+ this.deregister = function(comment, isDefault) {
+ if (isDefault) {
+ delete ctrl.default;
+ } else {
+ var key = comment.$$ngMessageNode;
+ delete comment.$$ngMessageNode;
+ removeMessageNode($element[0], comment, key);
+ delete messages[key];
+ }
+ ctrl.reRender();
+ };
+
+ function findPreviousMessage(parent, comment) {
+ var prevNode = comment;
+ var parentLookup = [];
+
+ while (prevNode && prevNode !== parent) {
+ var prevKey = prevNode.$$ngMessageNode;
+ if (prevKey && prevKey.length) {
+ return messages[prevKey];
+ }
+
+ // dive deeper into the DOM and examine its children for any ngMessage
+ // comments that may be in an element that appears deeper in the list
+ if (prevNode.childNodes.length && parentLookup.indexOf(prevNode) === -1) {
+ parentLookup.push(prevNode);
+ prevNode = prevNode.childNodes[prevNode.childNodes.length - 1];
+ } else if (prevNode.previousSibling) {
+ prevNode = prevNode.previousSibling;
+ } else {
+ prevNode = prevNode.parentNode;
+ parentLookup.push(prevNode);
+ }
+ }
+ }
+
+ function insertMessageNode(parent, comment, key) {
+ var messageNode = messages[key];
+ if (!ctrl.head) {
+ ctrl.head = messageNode;
+ } else {
+ var match = findPreviousMessage(parent, comment);
+ if (match) {
+ messageNode.next = match.next;
+ match.next = messageNode;
+ } else {
+ messageNode.next = ctrl.head;
+ ctrl.head = messageNode;
+ }
+ }
+ }
+
+ function removeMessageNode(parent, comment, key) {
+ var messageNode = messages[key];
+
+ // This message node may have already been removed by a call to deregister()
+ if (!messageNode) return;
+
+ var match = findPreviousMessage(parent, comment);
+ if (match) {
+ match.next = messageNode.next;
+ } else {
+ ctrl.head = messageNode.next;
+ }
+ }
+ }]
+ };
+
+ function isAttrTruthy(scope, attr) {
+ return (isString(attr) && attr.length === 0) || //empty attribute
+ truthy(scope.$eval(attr));
+ }
+
+ function truthy(val) {
+ return isString(val) ? val.length : !!val;
+ }
+ }])
+
+ /**
+ * @ngdoc directive
+ * @name ngMessagesInclude
+ * @restrict AE
+ * @scope
+ *
+ * @description
+ * `ngMessagesInclude` is a directive with the purpose to import existing ngMessage template
+ * code from a remote template and place the downloaded template code into the exact spot
+ * that the ngMessagesInclude directive is placed within the ngMessages container. This allows
+ * for a series of pre-defined messages to be reused and also allows for the developer to
+ * determine what messages are overridden due to the placement of the ngMessagesInclude directive.
+ *
+ * @usage
+ * ```html
+ * <!-- using attribute directives -->
+ * <ANY ng-messages="expression" role="alert">
+ * <ANY ng-messages-include="remoteTplString">...</ANY>
+ * </ANY>
+ *
+ * <!-- or by using element directives -->
+ * <ng-messages for="expression" role="alert">
+ * <ng-messages-include src="expressionValue1">...</ng-messages-include>
+ * </ng-messages>
+ * ```
+ *
+ * {@link module:ngMessages Click here} to learn more about `ngMessages` and `ngMessage`.
+ *
+ * @param {string} ngMessagesInclude|src a string value corresponding to the remote template.
+ */
+ .directive('ngMessagesInclude',
+ ['$templateRequest', '$document', '$compile', function($templateRequest, $document, $compile) {
+
+ return {
+ restrict: 'AE',
+ require: '^^ngMessages', // we only require this for validation sake
+ link: function($scope, element, attrs) {
+ var src = attrs.ngMessagesInclude || attrs.src;
+ $templateRequest(src).then(function(html) {
+ if ($scope.$$destroyed) return;
+
+ if (isString(html) && !html.trim()) {
+ // Empty template - nothing to compile
+ replaceElementWithMarker(element, src);
+ } else {
+ // Non-empty template - compile and link
+ $compile(html)($scope, function(contents) {
+ element.after(contents);
+ replaceElementWithMarker(element, src);
+ });
+ }
+ });
+ }
+ };
+
+ // Helpers
+ function replaceElementWithMarker(element, src) {
+ // A comment marker is placed for debugging purposes
+ var comment = $compile.$$createComment ?
+ $compile.$$createComment('ngMessagesInclude', src) :
+ $document[0].createComment(' ngMessagesInclude: ' + src + ' ');
+ var marker = jqLite(comment);
+ element.after(marker);
+
+ // Don't pollute the DOM anymore by keeping an empty directive element
+ element.remove();
+ }
+ }])
+
+ /**
+ * @ngdoc directive
+ * @name ngMessage
+ * @restrict AE
+ * @scope
+ * @priority 1
+ *
+ * @description
+ * `ngMessage` is a directive with the purpose to show and hide a particular message.
+ * For `ngMessage` to operate, a parent `ngMessages` directive on a parent DOM element
+ * must be situated since it determines which messages are visible based on the state
+ * of the provided key/value map that `ngMessages` listens on.
+ *
+ * More information about using `ngMessage` can be found in the
+ * {@link module:ngMessages `ngMessages` module documentation}.
+ *
+ * @usage
+ * ```html
+ * <!-- using attribute directives -->
+ * <ANY ng-messages="expression" role="alert">
+ * <ANY ng-message="stringValue">...</ANY>
+ * <ANY ng-message="stringValue1, stringValue2, ...">...</ANY>
+ * </ANY>
+ *
+ * <!-- or by using element directives -->
+ * <ng-messages for="expression" role="alert">
+ * <ng-message when="stringValue">...</ng-message>
+ * <ng-message when="stringValue1, stringValue2, ...">...</ng-message>
+ * </ng-messages>
+ * ```
+ *
+ * @param {expression} ngMessage|when a string value corresponding to the message key.
+ */
+ .directive('ngMessage', ngMessageDirectiveFactory())
+
+
+ /**
+ * @ngdoc directive
+ * @name ngMessageExp
+ * @restrict AE
+ * @priority 1
+ * @scope
+ *
+ * @description
+ * `ngMessageExp` is the same as {@link directive:ngMessage `ngMessage`}, but instead of a static
+ * value, it accepts an expression to be evaluated for the message key.
+ *
+ * @usage
+ * ```html
+ * <!-- using attribute directives -->
+ * <ANY ng-messages="expression">
+ * <ANY ng-message-exp="expressionValue">...</ANY>
+ * </ANY>
+ *
+ * <!-- or by using element directives -->
+ * <ng-messages for="expression">
+ * <ng-message when-exp="expressionValue">...</ng-message>
+ * </ng-messages>
+ * ```
+ *
+ * {@link module:ngMessages Click here} to learn more about `ngMessages` and `ngMessage`.
+ *
+ * @param {expression} ngMessageExp|whenExp an expression value corresponding to the message key.
+ */
+ .directive('ngMessageExp', ngMessageDirectiveFactory())
+
+ /**
+ * @ngdoc directive
+ * @name ngMessageDefault
+ * @restrict AE
+ * @scope
+ *
+ * @description
+ * `ngMessageDefault` is a directive with the purpose to show and hide a default message for
+ * {@link directive:ngMessages}, when none of provided messages matches.
+ *
+ * More information about using `ngMessageDefault` can be found in the
+ * {@link module:ngMessages `ngMessages` module documentation}.
+ *
+ * @usage
+ * ```html
+ * <!-- using attribute directives -->
+ * <ANY ng-messages="expression" role="alert">
+ * <ANY ng-message="stringValue">...</ANY>
+ * <ANY ng-message="stringValue1, stringValue2, ...">...</ANY>
+ * <ANY ng-message-default>...</ANY>
+ * </ANY>
+ *
+ * <!-- or by using element directives -->
+ * <ng-messages for="expression" role="alert">
+ * <ng-message when="stringValue">...</ng-message>
+ * <ng-message when="stringValue1, stringValue2, ...">...</ng-message>
+ * <ng-message-default>...</ng-message-default>
+ * </ng-messages>
+ *
+ */
+ .directive('ngMessageDefault', ngMessageDirectiveFactory(true));
+
+function ngMessageDirectiveFactory(isDefault) {
+ return ['$animate', function($animate) {
+ return {
+ restrict: 'AE',
+ transclude: 'element',
+ priority: 1, // must run before ngBind, otherwise the text is set on the comment
+ terminal: true,
+ require: '^^ngMessages',
+ link: function(scope, element, attrs, ngMessagesCtrl, $transclude) {
+ var commentNode, records, staticExp, dynamicExp;
+
+ if (!isDefault) {
+ commentNode = element[0];
+ staticExp = attrs.ngMessage || attrs.when;
+ dynamicExp = attrs.ngMessageExp || attrs.whenExp;
+
+ var assignRecords = function(items) {
+ records = items
+ ? (isArray(items)
+ ? items
+ : items.split(/[\s,]+/))
+ : null;
+ ngMessagesCtrl.reRender();
+ };
+
+ if (dynamicExp) {
+ assignRecords(scope.$eval(dynamicExp));
+ scope.$watchCollection(dynamicExp, assignRecords);
+ } else {
+ assignRecords(staticExp);
+ }
+ }
+
+ var currentElement, messageCtrl;
+ ngMessagesCtrl.register(commentNode, messageCtrl = {
+ test: function(name) {
+ return contains(records, name);
+ },
+ attach: function() {
+ if (!currentElement) {
+ $transclude(function(elm, newScope) {
+ $animate.enter(elm, null, element);
+ currentElement = elm;
+
+ // Each time we attach this node to a message we get a new id that we can match
+ // when we are destroying the node later.
+ var $$attachId = currentElement.$$attachId = ngMessagesCtrl.getAttachId();
+
+ // in the event that the element or a parent element is destroyed
+ // by another structural directive then it's time
+ // to deregister the message from the controller
+ currentElement.on('$destroy', function() {
+ // If the message element was removed via a call to `detach` then `currentElement` will be null
+ // So this handler only handles cases where something else removed the message element.
+ if (currentElement && currentElement.$$attachId === $$attachId) {
+ ngMessagesCtrl.deregister(commentNode, isDefault);
+ messageCtrl.detach();
+ }
+ newScope.$destroy();
+ });
+ });
+ }
+ },
+ detach: function() {
+ if (currentElement) {
+ var elm = currentElement;
+ currentElement = null;
+ $animate.leave(elm);
+ }
+ }
+ }, isDefault);
+
+ // We need to ensure that this directive deregisters itself when it no longer exists
+ // Normally this is done when the attached element is destroyed; but if this directive
+ // gets removed before we attach the message to the DOM there is nothing to watch
+ // in which case we must deregister when the containing scope is destroyed.
+ scope.$on('$destroy', function() {
+ ngMessagesCtrl.deregister(commentNode, isDefault);
+ });
+ }
+ };
+ }];
+
+ function contains(collection, key) {
+ if (collection) {
+ return isArray(collection)
+ ? collection.indexOf(key) >= 0
+ : collection.hasOwnProperty(key);
+ }
+ }
+}
+
+
+})(window, window.angular);
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-messages/index.js":
+/*!************************************************!*\
+ !*** ./node_modules/angular-messages/index.js ***!
+ \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+__webpack_require__(/*! ./angular-messages */ "./node_modules/angular-messages/angular-messages.js");
+module.exports = 'ngMessages';
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-rateit/dist/ng-rateit.js":
+/*!*******************************************************!*\
+ !*** ./node_modules/angular-rateit/dist/ng-rateit.js ***!
+ \*******************************************************/
+/***/ (() => {
+
+angular.module('ngRateIt', ['ng'])
+.directive('ngRateIt', ["$q", function( $q ) {
+ 'use strict';
+
+ /*jslint unparam:true */
+ var link = function ($scope, $element, $attrs) {
+
+ if(!$attrs.readOnly){
+ $scope.readOnly = function(){return false;};
+ }
+
+ if(!$attrs.resetable){
+ $scope.resetable = function(){return true;};
+ }
+
+ if(!$attrs.beforeRated){
+ $scope.beforeRated = function(){var d = $q.defer(); d.resolve(); return d.promise;};
+ }
+
+ if(!$attrs.rated){
+ $scope.rated = function(){return;};
+ }
+
+ if(!$attrs.beforeReset){
+ $scope.beforeReset = function(){var d = $q.defer(); d.resolve(); return d.promise;};
+ }
+
+ if(!$attrs.reset){
+ $scope.reset = function(){return;};
+ }
+
+ };
+ /*jslint unparam:false */
+
+ return {
+ scope:{
+ ngModel : '=',
+ min : '=?min',
+ max : '=?max',
+ step : '=?step',
+ readOnly : '&?readOnly',
+ pristine : '=?pristine',
+ resetable : '&?resetable',
+ starWidth : '=?starWidth',
+ starHeight : '=?starHeight',
+ canelWidth : '=?canelWidth',
+ cancelHeight : '=?cancelHeight',
+ rated : '&?rated',
+ reset : '&?reset',
+ beforeRated : '&?beforeRated',
+ beforeReset : '&?beforeReset'
+ },
+ templateUrl: 'ngRateIt/ng-rate-it.html',
+ require: 'ngModel',
+ replace: true,
+ link: link,
+ controller: 'ngRateItController'
+ };
+
+}])
+.controller('ngRateItController', ["$scope", "$timeout", function ( $scope, $timeout ) {
+ 'use strict';
+
+ $scope.isTouch = !! window.hasOwnProperty("ontouchstart") || window.navigator.msMaxTouchPoints > 0;
+ $scope.orgValue = angular.copy($scope.ngModel);
+
+ $scope.min = $scope.min || 0;
+ $scope.max = $scope.max || 5;
+ $scope.step = $scope.step || 0.5;
+
+ $scope.pristine = $scope.orgValue === $scope.ngModel;
+
+ $scope.starWidth = $scope.starWidth || 16;
+ $scope.starPartWidth = $scope.starWidth * $scope.step;
+ $scope.starHeight = $scope.starHeight || 16;
+ $scope.canelWidth = $scope.canelWidth || $scope.starWidth;
+ $scope.cancelHeight = $scope.cancelHeight || $scope.starHeight;
+
+ var diff = $scope.max - $scope.min,
+ steps = diff / $scope.step,
+ garbage = $scope.$watch('ngModel', function () {
+ $scope.pristine = $scope.orgValue === $scope.ngModel;
+ }),
+
+ getValue = function (index) {
+ return (index+1) / steps * diff;
+ };
+
+ $scope.getStartParts = function () {
+ return new Array(steps);
+ };
+
+ $scope.getStarOffset = function (index) {
+ var ratio = 1/$scope.step,
+ offset = -($scope.starWidth/ratio)*(index%ratio);
+ return offset;
+ };
+
+ $scope.isSelected = function (index) {
+ return getValue(index) <= $scope.ngModel-$scope.min;
+ };
+
+ $scope.removeRating = function () {
+ if ($scope.resetable() && !$scope.readOnly()) {
+ $scope.beforeReset({rating:$scope.ngModel}).then(function () {
+ $scope.ngModel = $scope.min;
+ $scope.reset({rating:$scope.ngModel});
+ });
+ }
+ };
+
+ $scope.setValue = function (index) {
+ if (!$scope.readOnly()) {
+ var tmpValue = angular.copy($scope.min + getValue(index));
+
+ $scope.beforeRated({rating:tmpValue}).then(function () {
+ $scope.ngModel = tmpValue;
+ $timeout(function () {
+ $scope.rated({rating:$scope.ngModel});
+ });
+ });
+ }
+ };
+
+ $scope.$on('$destroy', function () {
+ garbage();
+ });
+
+}])
+.run(['$templateCache', function ($templateCache) {
+ 'use strict';
+
+ $templateCache.put('ngRateIt/ng-rate-it.html',
+
+ '<div class="ngrateiti needsclick" ng-class="{\'ngrateit-readonly\': readOnly()}">' +
+
+ '<a ' +
+ 'ng-if="!readOnly() && resetable()"' +
+ 'ng-click="removeRating()"' +
+ 'class="ngrateit-reset ngrateit-star needsclick"' +
+ 'ng-style="{\'width\': canelWidth+\'px\', \'height\':cancelHeight+\'px\'}"' +
+ '></a>' +
+
+ '<div ng-if="!hide" id="origin" class="ngrateit-rating needsclick" ng-class="{\'ngrateit-hashover\':!isTouch}">' +
+ '<span ' +
+ 'class="ngrateit-star ngrateit-bg-star needsclick"' +
+ 'ng-repeat="i in getStartParts() track by $index" ' +
+ 'ng-class="{\'ngrateit-selected\': isSelected($index) }"' +
+ 'ng-click="setValue($index)"' +
+ 'ng-style="{\'width\': starPartWidth+\'px\', \'height\':starHeight+\'px\', \'background-position\': getStarOffset($index)+\'px 0\'}"' +
+ '></span>' +
+ '</div>' +
+ '</div>'
+
+ );
+
+}]);
+
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-resource/angular-resource.js":
+/*!***********************************************************!*\
+ !*** ./node_modules/angular-resource/angular-resource.js ***!
+ \***********************************************************/
+/***/ (() => {
+
+/**
+ * @license AngularJS v1.8.2
+ * (c) 2010-2020 Google LLC. http://angularjs.org
+ * License: MIT
+ */
+(function(window, angular) {'use strict';
+
+var $resourceMinErr = angular.$$minErr('$resource');
+
+// Helper functions and regex to lookup a dotted path on an object
+// stopping at undefined/null. The path must be composed of ASCII
+// identifiers (just like $parse)
+var MEMBER_NAME_REGEX = /^(\.[a-zA-Z_$@][0-9a-zA-Z_$@]*)+$/;
+
+function isValidDottedPath(path) {
+ return (path != null && path !== '' && path !== 'hasOwnProperty' &&
+ MEMBER_NAME_REGEX.test('.' + path));
+}
+
+function lookupDottedPath(obj, path) {
+ if (!isValidDottedPath(path)) {
+ throw $resourceMinErr('badmember', 'Dotted member path "@{0}" is invalid.', path);
+ }
+ var keys = path.split('.');
+ for (var i = 0, ii = keys.length; i < ii && angular.isDefined(obj); i++) {
+ var key = keys[i];
+ obj = (obj !== null) ? obj[key] : undefined;
+ }
+ return obj;
+}
+
+/**
+ * Create a shallow copy of an object and clear other fields from the destination
+ */
+function shallowClearAndCopy(src, dst) {
+ dst = dst || {};
+
+ angular.forEach(dst, function(value, key) {
+ delete dst[key];
+ });
+
+ for (var key in src) {
+ if (src.hasOwnProperty(key) && !(key.charAt(0) === '$' && key.charAt(1) === '$')) {
+ dst[key] = src[key];
+ }
+ }
+
+ return dst;
+}
+
+/**
+ * @ngdoc module
+ * @name ngResource
+ * @description
+ *
+ * The `ngResource` module provides interaction support with RESTful services
+ * via the $resource service.
+ *
+ * See {@link ngResource.$resourceProvider} and {@link ngResource.$resource} for usage.
+ */
+
+/**
+ * @ngdoc provider
+ * @name $resourceProvider
+ *
+ * @description
+ *
+ * Use `$resourceProvider` to change the default behavior of the {@link ngResource.$resource}
+ * service.
+ *
+ * ## Dependencies
+ * Requires the {@link ngResource } module to be installed.
+ *
+ */
+
+/**
+ * @ngdoc service
+ * @name $resource
+ * @requires $http
+ * @requires ng.$log
+ * @requires $q
+ * @requires ng.$timeout
+ *
+ * @description
+ * A factory which creates a resource object that lets you interact with
+ * [RESTful](http://en.wikipedia.org/wiki/Representational_State_Transfer) server-side data sources.
+ *
+ * The returned resource object has action methods which provide high-level behaviors without
+ * the need to interact with the low level {@link ng.$http $http} service.
+ *
+ * Requires the {@link ngResource `ngResource`} module to be installed.
+ *
+ * By default, trailing slashes will be stripped from the calculated URLs,
+ * which can pose problems with server backends that do not expect that
+ * behavior. This can be disabled by configuring the `$resourceProvider` like
+ * this:
+ *
+ * ```js
+ app.config(['$resourceProvider', function($resourceProvider) {
+ // Don't strip trailing slashes from calculated URLs
+ $resourceProvider.defaults.stripTrailingSlashes = false;
+ }]);
+ * ```
+ *
+ * @param {string} url A parameterized URL template with parameters prefixed by `:` as in
+ * `/user/:username`. If you are using a URL with a port number (e.g.
+ * `http://example.com:8080/api`), it will be respected.
+ *
+ * If you are using a url with a suffix, just add the suffix, like this:
+ * `$resource('http://example.com/resource.json')` or `$resource('http://example.com/:id.json')`
+ * or even `$resource('http://example.com/resource/:resource_id.:format')`
+ * If the parameter before the suffix is empty, :resource_id in this case, then the `/.` will be
+ * collapsed down to a single `.`. If you need this sequence to appear and not collapse then you
+ * can escape it with `/\.`.
+ *
+ * @param {Object=} paramDefaults Default values for `url` parameters. These can be overridden in
+ * `actions` methods. If a parameter value is a function, it will be called every time
+ * a param value needs to be obtained for a request (unless the param was overridden). The
+ * function will be passed the current data value as an argument.
+ *
+ * Each key value in the parameter object is first bound to url template if present and then any
+ * excess keys are appended to the url search query after the `?`.
+ *
+ * Given a template `/path/:verb` and parameter `{verb: 'greet', salutation: 'Hello'}` results in
+ * URL `/path/greet?salutation=Hello`.
+ *
+ * If the parameter value is prefixed with `@`, then the value for that parameter will be
+ * extracted from the corresponding property on the `data` object (provided when calling actions
+ * with a request body).
+ * For example, if the `defaultParam` object is `{someParam: '@someProp'}` then the value of
+ * `someParam` will be `data.someProp`.
+ * Note that the parameter will be ignored, when calling a "GET" action method (i.e. an action
+ * method that does not accept a request body).
+ *
+ * @param {Object.<Object>=} actions Hash with declaration of custom actions that will be available
+ * in addition to the default set of resource actions (see below). If a custom action has the same
+ * key as a default action (e.g. `save`), then the default action will be *overwritten*, and not
+ * extended.
+ *
+ * The declaration should be created in the format of {@link ng.$http#usage $http.config}:
+ *
+ * {
+ * action1: {method:?, params:?, isArray:?, headers:?, ...},
+ * action2: {method:?, params:?, isArray:?, headers:?, ...},
+ * ...
+ * }
+ *
+ * Where:
+ *
+ * - **`action`** – {string} – The name of action. This name becomes the name of the method on
+ * your resource object.
+ * - **`method`** – {string} – Case insensitive HTTP method (e.g. `GET`, `POST`, `PUT`,
+ * `DELETE`, `JSONP`, etc).
+ * - **`params`** – {Object=} – Optional set of pre-bound parameters for this action. If any of
+ * the parameter value is a function, it will be called every time when a param value needs to
+ * be obtained for a request (unless the param was overridden). The function will be passed the
+ * current data value as an argument.
+ * - **`url`** – {string} – Action specific `url` override. The url templating is supported just
+ * like for the resource-level urls.
+ * - **`isArray`** – {boolean=} – If true then the returned object for this action is an array,
+ * see `returns` section.
+ * - **`transformRequest`** –
+ * `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
+ * Transform function or an array of such functions. The transform function takes the http
+ * request body and headers and returns its transformed (typically serialized) version.
+ * By default, transformRequest will contain one function that checks if the request data is
+ * an object and serializes it using `angular.toJson`. To prevent this behavior, set
+ * `transformRequest` to an empty array: `transformRequest: []`
+ * - **`transformResponse`** –
+ * `{function(data, headersGetter, status)|Array.<function(data, headersGetter, status)>}` –
+ * Transform function or an array of such functions. The transform function takes the HTTP
+ * response body, headers and status and returns its transformed (typically deserialized)
+ * version.
+ * By default, transformResponse will contain one function that checks if the response looks
+ * like a JSON string and deserializes it using `angular.fromJson`. To prevent this behavior,
+ * set `transformResponse` to an empty array: `transformResponse: []`
+ * - **`cache`** – `{boolean|Cache}` – A boolean value or object created with
+ * {@link ng.$cacheFactory `$cacheFactory`} to enable or disable caching of the HTTP response.
+ * See {@link $http#caching $http Caching} for more information.
+ * - **`timeout`** – `{number}` – Timeout in milliseconds.<br />
+ * **Note:** In contrast to {@link ng.$http#usage $http.config}, {@link ng.$q promises} are
+ * **not** supported in `$resource`, because the same value would be used for multiple requests.
+ * If you are looking for a way to cancel requests, you should use the `cancellable` option.
+ * - **`cancellable`** – `{boolean}` – If true, the request made by a "non-instance" call will be
+ * cancelled (if not already completed) by calling `$cancelRequest()` on the call's return
+ * value. Calling `$cancelRequest()` for a non-cancellable or an already completed/cancelled
+ * request will have no effect.
+ * - **`withCredentials`** – `{boolean}` – Whether to set the `withCredentials` flag on the
+ * XHR object. See
+ * [XMLHttpRequest.withCredentials](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials)
+ * for more information.
+ * - **`responseType`** – `{string}` – See
+ * [XMLHttpRequest.responseType](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType).
+ * - **`interceptor`** – `{Object=}` – The interceptor object has four optional methods -
+ * `request`, `requestError`, `response`, and `responseError`. See
+ * {@link ng.$http#interceptors $http interceptors} for details. Note that
+ * `request`/`requestError` interceptors are applied before calling `$http`, thus before any
+ * global `$http` interceptors. Also, rejecting or throwing an error inside the `request`
+ * interceptor will result in calling the `responseError` interceptor.
+ * The resource instance or collection is available on the `resource` property of the
+ * `http response` object passed to `response`/`responseError` interceptors.
+ * Keep in mind that the associated promise will be resolved with the value returned by the
+ * response interceptors. Make sure you return an appropriate value and not the `response`
+ * object passed as input. For reference, the default `response` interceptor (which gets applied
+ * if you don't specify a custom one) returns `response.resource`.<br />
+ * See {@link ngResource.$resource#using-interceptors below} for an example of using
+ * interceptors in `$resource`.
+ * - **`hasBody`** – `{boolean}` – If true, then the request will have a body.
+ * If not specified, then only POST, PUT and PATCH requests will have a body. *
+ * @param {Object} options Hash with custom settings that should extend the
+ * default `$resourceProvider` behavior. The supported options are:
+ *
+ * - **`stripTrailingSlashes`** – {boolean} – If true then the trailing
+ * slashes from any calculated URL will be stripped. (Defaults to true.)
+ * - **`cancellable`** – {boolean} – If true, the request made by a "non-instance" call will be
+ * cancelled (if not already completed) by calling `$cancelRequest()` on the call's return value.
+ * This can be overwritten per action. (Defaults to false.)
+ *
+ * @returns {Object} A resource "class" object with methods for the default set of resource actions
+ * optionally extended with custom `actions`. The default set contains these actions:
+ * ```js
+ * {
+ * 'get': {method: 'GET'},
+ * 'save': {method: 'POST'},
+ * 'query': {method: 'GET', isArray: true},
+ * 'remove': {method: 'DELETE'},
+ * 'delete': {method: 'DELETE'}
+ * }
+ * ```
+ *
+ * Calling these methods invoke {@link ng.$http} with the specified http method, destination and
+ * parameters. When the data is returned from the server then the object is an instance of the
+ * resource class. The actions `save`, `remove` and `delete` are available on it as methods with
+ * the `$` prefix. This allows you to easily perform CRUD operations (create, read, update,
+ * delete) on server-side data like this:
+ * ```js
+ * var User = $resource('/user/:userId', {userId: '@id'});
+ * User.get({userId: 123}).$promise.then(function(user) {
+ * user.abc = true;
+ * user.$save();
+ * });
+ * ```
+ *
+ * It is important to realize that invoking a `$resource` object method immediately returns an
+ * empty reference (object or array depending on `isArray`). Once the data is returned from the
+ * server the existing reference is populated with the actual data. This is a useful trick since
+ * usually the resource is assigned to a model which is then rendered by the view. Having an empty
+ * object results in no rendering, once the data arrives from the server then the object is
+ * populated with the data and the view automatically re-renders itself showing the new data. This
+ * means that in most cases one never has to write a callback function for the action methods.
+ *
+ * The action methods on the class object or instance object can be invoked with the following
+ * parameters:
+ *
+ * - "class" actions without a body: `Resource.action([parameters], [success], [error])`
+ * - "class" actions with a body: `Resource.action([parameters], postData, [success], [error])`
+ * - instance actions: `instance.$action([parameters], [success], [error])`
+ *
+ *
+ * When calling instance methods, the instance itself is used as the request body (if the action
+ * should have a body). By default, only actions using `POST`, `PUT` or `PATCH` have request
+ * bodies, but you can use the `hasBody` configuration option to specify whether an action
+ * should have a body or not (regardless of its HTTP method).
+ *
+ *
+ * Success callback is called with (value (Object|Array), responseHeaders (Function),
+ * status (number), statusText (string)) arguments, where `value` is the populated resource
+ * instance or collection object. The error callback is called with (httpResponse) argument.
+ *
+ * Class actions return an empty instance (with the additional properties listed below).
+ * Instance actions return a promise for the operation.
+ *
+ * The Resource instances and collections have these additional properties:
+ *
+ * - `$promise`: The {@link ng.$q promise} of the original server interaction that created this
+ * instance or collection.
+ *
+ * On success, the promise is resolved with the same resource instance or collection object,
+ * updated with data from server. This makes it easy to use in the
+ * {@link ngRoute.$routeProvider `resolve` section of `$routeProvider.when()`} to defer view
+ * rendering until the resource(s) are loaded.
+ *
+ * On failure, the promise is rejected with the {@link ng.$http http response} object.
+ *
+ * If an interceptor object was provided, the promise will instead be resolved with the value
+ * returned by the response interceptor (on success) or responceError interceptor (on failure).
+ *
+ * - `$resolved`: `true` after first server interaction is completed (either with success or
+ * rejection), `false` before that. Knowing if the Resource has been resolved is useful in
+ * data-binding. If there is a response/responseError interceptor and it returns a promise,
+ * `$resolved` will wait for that too.
+ *
+ * The Resource instances and collections have these additional methods:
+ *
+ * - `$cancelRequest`: If there is a cancellable, pending request related to the instance or
+ * collection, calling this method will abort the request.
+ *
+ * The Resource instances have these additional methods:
+ *
+ * - `toJSON`: It returns a simple object without any of the extra properties added as part of
+ * the Resource API. This object can be serialized through {@link angular.toJson} safely
+ * without attaching AngularJS-specific fields. Notice that `JSON.stringify` (and
+ * `angular.toJson`) automatically use this method when serializing a Resource instance
+ * (see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#toJSON%28%29_behavior)).
+ *
+ * @example
+ *
+ * ### Basic usage
+ *
+ ```js
+ // Define a CreditCard class
+ var CreditCard = $resource('/users/:userId/cards/:cardId',
+ {userId: 123, cardId: '@id'}, {
+ charge: {method: 'POST', params: {charge: true}}
+ });
+
+ // We can retrieve a collection from the server
+ var cards = CreditCard.query();
+ // GET: /users/123/cards
+ // server returns: [{id: 456, number: '1234', name: 'Smith'}]
+
+ // Wait for the request to complete
+ cards.$promise.then(function() {
+ var card = cards[0];
+
+ // Each item is an instance of CreditCard
+ expect(card instanceof CreditCard).toEqual(true);
+
+ // Non-GET methods are mapped onto the instances
+ card.name = 'J. Smith';
+ card.$save();
+ // POST: /users/123/cards/456 {id: 456, number: '1234', name: 'J. Smith'}
+ // server returns: {id: 456, number: '1234', name: 'J. Smith'}
+
+ // Our custom method is mapped as well (since it uses POST)
+ card.$charge({amount: 9.99});
+ // POST: /users/123/cards/456?amount=9.99&charge=true {id: 456, number: '1234', name: 'J. Smith'}
+ });
+
+ // We can create an instance as well
+ var newCard = new CreditCard({number: '0123'});
+ newCard.name = 'Mike Smith';
+
+ var savePromise = newCard.$save();
+ // POST: /users/123/cards {number: '0123', name: 'Mike Smith'}
+ // server returns: {id: 789, number: '0123', name: 'Mike Smith'}
+
+ savePromise.then(function() {
+ // Once the promise is resolved, the created instance
+ // is populated with the data returned by the server
+ expect(newCard.id).toEqual(789);
+ });
+ ```
+ *
+ * The object returned from a call to `$resource` is a resource "class" which has one "static"
+ * method for each action in the definition.
+ *
+ * Calling these methods invokes `$http` on the `url` template with the given HTTP `method`,
+ * `params` and `headers`.
+ *
+ * @example
+ *
+ * ### Accessing the response
+ *
+ * When the data is returned from the server then the object is an instance of the resource type and
+ * all of the non-GET methods are available with `$` prefix. This allows you to easily support CRUD
+ * operations (create, read, update, delete) on server-side data.
+ *
+ ```js
+ var User = $resource('/users/:userId', {userId: '@id'});
+ User.get({userId: 123}).$promise.then(function(user) {
+ user.abc = true;
+ user.$save();
+ });
+ ```
+ *
+ * It's worth noting that the success callback for `get`, `query` and other methods gets called with
+ * the resource instance (populated with the data that came from the server) as well as an `$http`
+ * header getter function, the HTTP status code and the response status text. So one could rewrite
+ * the above example and get access to HTTP headers as follows:
+ *
+ ```js
+ var User = $resource('/users/:userId', {userId: '@id'});
+ User.get({userId: 123}, function(user, getResponseHeaders) {
+ user.abc = true;
+ user.$save(function(user, putResponseHeaders) {
+ // `user` => saved `User` object
+ // `putResponseHeaders` => `$http` header getter
+ });
+ });
+ ```
+ *
+ * @example
+ *
+ * ### Creating custom actions
+ *
+ * In this example we create a custom method on our resource to make a PUT request:
+ *
+ ```js
+ var app = angular.module('app', ['ngResource']);
+
+ // Some APIs expect a PUT request in the format URL/object/ID
+ // Here we are creating an 'update' method
+ app.factory('Notes', ['$resource', function($resource) {
+ return $resource('/notes/:id', {id: '@id'}, {
+ update: {method: 'PUT'}
+ });
+ }]);
+
+ // In our controller we get the ID from the URL using `$location`
+ app.controller('NotesCtrl', ['$location', 'Notes', function($location, Notes) {
+ // First, retrieve the corresponding `Note` object from the server
+ // (Assuming a URL of the form `.../notes?id=XYZ`)
+ var noteId = $location.search().id;
+ var note = Notes.get({id: noteId});
+
+ note.$promise.then(function() {
+ note.content = 'Hello, world!';
+
+ // Now call `update` to save the changes on the server
+ Notes.update(note);
+ // This will PUT /notes/ID with the note object as the request payload
+
+ // Since `update` is a non-GET method, it will also be available on the instance
+ // (prefixed with `$`), so we could replace the `Note.update()` call with:
+ //note.$update();
+ });
+ }]);
+ ```
+ *
+ * @example
+ *
+ * ### Cancelling requests
+ *
+ * If an action's configuration specifies that it is cancellable, you can cancel the request related
+ * to an instance or collection (as long as it is a result of a "non-instance" call):
+ *
+ ```js
+ // ...defining the `Hotel` resource...
+ var Hotel = $resource('/api/hotels/:id', {id: '@id'}, {
+ // Let's make the `query()` method cancellable
+ query: {method: 'get', isArray: true, cancellable: true}
+ });
+
+ // ...somewhere in the PlanVacationController...
+ ...
+ this.onDestinationChanged = function onDestinationChanged(destination) {
+ // We don't care about any pending request for hotels
+ // in a different destination any more
+ if (this.availableHotels) {
+ this.availableHotels.$cancelRequest();
+ }
+
+ // Let's query for hotels in `destination`
+ // (calls: /api/hotels?location=<destination>)
+ this.availableHotels = Hotel.query({location: destination});
+ };
+ ```
+ *
+ * @example
+ *
+ * ### Using interceptors
+ *
+ * You can use interceptors to transform the request or response, perform additional operations, and
+ * modify the returned instance/collection. The following example, uses `request` and `response`
+ * interceptors to augment the returned instance with additional info:
+ *
+ ```js
+ var Thing = $resource('/api/things/:id', {id: '@id'}, {
+ save: {
+ method: 'POST',
+ interceptor: {
+ request: function(config) {
+ // Before the request is sent out, store a timestamp on the request config
+ config.requestTimestamp = Date.now();
+ return config;
+ },
+ response: function(response) {
+ // Get the instance from the response object
+ var instance = response.resource;
+
+ // Augment the instance with a custom `saveLatency` property, computed as the time
+ // between sending the request and receiving the response.
+ instance.saveLatency = Date.now() - response.config.requestTimestamp;
+
+ // Return the instance
+ return instance;
+ }
+ }
+ }
+ });
+
+ Thing.save({foo: 'bar'}).$promise.then(function(thing) {
+ console.log('That thing was saved in ' + thing.saveLatency + 'ms.');
+ });
+ ```
+ *
+ */
+angular.module('ngResource', ['ng']).
+ info({ angularVersion: '1.8.2' }).
+ provider('$resource', function ResourceProvider() {
+ var PROTOCOL_AND_IPV6_REGEX = /^https?:\/\/\[[^\]]*][^/]*/;
+
+ var provider = this;
+
+ /**
+ * @ngdoc property
+ * @name $resourceProvider#defaults
+ * @description
+ * Object containing default options used when creating `$resource` instances.
+ *
+ * The default values satisfy a wide range of usecases, but you may choose to overwrite any of
+ * them to further customize your instances. The available properties are:
+ *
+ * - **stripTrailingSlashes** – `{boolean}` – If true, then the trailing slashes from any
+ * calculated URL will be stripped.<br />
+ * (Defaults to true.)
+ * - **cancellable** – `{boolean}` – If true, the request made by a "non-instance" call will be
+ * cancelled (if not already completed) by calling `$cancelRequest()` on the call's return
+ * value. For more details, see {@link ngResource.$resource}. This can be overwritten per
+ * resource class or action.<br />
+ * (Defaults to false.)
+ * - **actions** - `{Object.<Object>}` - A hash with default actions declarations. Actions are
+ * high-level methods corresponding to RESTful actions/methods on resources. An action may
+ * specify what HTTP method to use, what URL to hit, if the return value will be a single
+ * object or a collection (array) of objects etc. For more details, see
+ * {@link ngResource.$resource}. The actions can also be enhanced or overwritten per resource
+ * class.<br />
+ * The default actions are:
+ * ```js
+ * {
+ * get: {method: 'GET'},
+ * save: {method: 'POST'},
+ * query: {method: 'GET', isArray: true},
+ * remove: {method: 'DELETE'},
+ * delete: {method: 'DELETE'}
+ * }
+ * ```
+ *
+ * #### Example
+ *
+ * For example, you can specify a new `update` action that uses the `PUT` HTTP verb:
+ *
+ * ```js
+ * angular.
+ * module('myApp').
+ * config(['$resourceProvider', function ($resourceProvider) {
+ * $resourceProvider.defaults.actions.update = {
+ * method: 'PUT'
+ * };
+ * }]);
+ * ```
+ *
+ * Or you can even overwrite the whole `actions` list and specify your own:
+ *
+ * ```js
+ * angular.
+ * module('myApp').
+ * config(['$resourceProvider', function ($resourceProvider) {
+ * $resourceProvider.defaults.actions = {
+ * create: {method: 'POST'},
+ * get: {method: 'GET'},
+ * getAll: {method: 'GET', isArray:true},
+ * update: {method: 'PUT'},
+ * delete: {method: 'DELETE'}
+ * };
+ * });
+ * ```
+ *
+ */
+ this.defaults = {
+ // Strip slashes by default
+ stripTrailingSlashes: true,
+
+ // Make non-instance requests cancellable (via `$cancelRequest()`)
+ cancellable: false,
+
+ // Default actions configuration
+ actions: {
+ 'get': {method: 'GET'},
+ 'save': {method: 'POST'},
+ 'query': {method: 'GET', isArray: true},
+ 'remove': {method: 'DELETE'},
+ 'delete': {method: 'DELETE'}
+ }
+ };
+
+ this.$get = ['$http', '$log', '$q', '$timeout', function($http, $log, $q, $timeout) {
+
+ var noop = angular.noop,
+ forEach = angular.forEach,
+ extend = angular.extend,
+ copy = angular.copy,
+ isArray = angular.isArray,
+ isDefined = angular.isDefined,
+ isFunction = angular.isFunction,
+ isNumber = angular.isNumber,
+ encodeUriQuery = angular.$$encodeUriQuery,
+ encodeUriSegment = angular.$$encodeUriSegment;
+
+ function Route(template, defaults) {
+ this.template = template;
+ this.defaults = extend({}, provider.defaults, defaults);
+ this.urlParams = {};
+ }
+
+ Route.prototype = {
+ setUrlParams: function(config, params, actionUrl) {
+ var self = this,
+ url = actionUrl || self.template,
+ val,
+ encodedVal,
+ protocolAndIpv6 = '';
+
+ var urlParams = self.urlParams = Object.create(null);
+ forEach(url.split(/\W/), function(param) {
+ if (param === 'hasOwnProperty') {
+ throw $resourceMinErr('badname', 'hasOwnProperty is not a valid parameter name.');
+ }
+ if (!(new RegExp('^\\d+$').test(param)) && param &&
+ (new RegExp('(^|[^\\\\]):' + param + '(\\W|$)').test(url))) {
+ urlParams[param] = {
+ isQueryParamValue: (new RegExp('\\?.*=:' + param + '(?:\\W|$)')).test(url)
+ };
+ }
+ });
+ url = url.replace(/\\:/g, ':');
+ url = url.replace(PROTOCOL_AND_IPV6_REGEX, function(match) {
+ protocolAndIpv6 = match;
+ return '';
+ });
+
+ params = params || {};
+ forEach(self.urlParams, function(paramInfo, urlParam) {
+ val = params.hasOwnProperty(urlParam) ? params[urlParam] : self.defaults[urlParam];
+ if (isDefined(val) && val !== null) {
+ if (paramInfo.isQueryParamValue) {
+ encodedVal = encodeUriQuery(val, true);
+ } else {
+ encodedVal = encodeUriSegment(val);
+ }
+ url = url.replace(new RegExp(':' + urlParam + '(\\W|$)', 'g'), function(match, p1) {
+ return encodedVal + p1;
+ });
+ } else {
+ url = url.replace(new RegExp('(/?):' + urlParam + '(\\W|$)', 'g'), function(match,
+ leadingSlashes, tail) {
+ if (tail.charAt(0) === '/') {
+ return tail;
+ } else {
+ return leadingSlashes + tail;
+ }
+ });
+ }
+ });
+
+ // strip trailing slashes and set the url (unless this behavior is specifically disabled)
+ if (self.defaults.stripTrailingSlashes) {
+ url = url.replace(/\/+$/, '') || '/';
+ }
+
+ // Collapse `/.` if found in the last URL path segment before the query.
+ // E.g. `http://url.com/id/.format?q=x` becomes `http://url.com/id.format?q=x`.
+ url = url.replace(/\/\.(?=\w+($|\?))/, '.');
+ // Replace escaped `/\.` with `/.`.
+ // (If `\.` comes from a param value, it will be encoded as `%5C.`.)
+ config.url = protocolAndIpv6 + url.replace(/\/(\\|%5C)\./, '/.');
+
+
+ // set params - delegate param encoding to $http
+ forEach(params, function(value, key) {
+ if (!self.urlParams[key]) {
+ config.params = config.params || {};
+ config.params[key] = value;
+ }
+ });
+ }
+ };
+
+
+ function resourceFactory(url, paramDefaults, actions, options) {
+ var route = new Route(url, options);
+
+ actions = extend({}, provider.defaults.actions, actions);
+
+ function extractParams(data, actionParams) {
+ var ids = {};
+ actionParams = extend({}, paramDefaults, actionParams);
+ forEach(actionParams, function(value, key) {
+ if (isFunction(value)) { value = value(data); }
+ ids[key] = value && value.charAt && value.charAt(0) === '@' ?
+ lookupDottedPath(data, value.substr(1)) : value;
+ });
+ return ids;
+ }
+
+ function defaultResponseInterceptor(response) {
+ return response.resource;
+ }
+
+ function Resource(value) {
+ shallowClearAndCopy(value || {}, this);
+ }
+
+ Resource.prototype.toJSON = function() {
+ var data = extend({}, this);
+ delete data.$promise;
+ delete data.$resolved;
+ delete data.$cancelRequest;
+ return data;
+ };
+
+ forEach(actions, function(action, name) {
+ var hasBody = action.hasBody === true || (action.hasBody !== false && /^(POST|PUT|PATCH)$/i.test(action.method));
+ var numericTimeout = action.timeout;
+ var cancellable = isDefined(action.cancellable) ?
+ action.cancellable : route.defaults.cancellable;
+
+ if (numericTimeout && !isNumber(numericTimeout)) {
+ $log.debug('ngResource:\n' +
+ ' Only numeric values are allowed as `timeout`.\n' +
+ ' Promises are not supported in $resource, because the same value would ' +
+ 'be used for multiple requests. If you are looking for a way to cancel ' +
+ 'requests, you should use the `cancellable` option.');
+ delete action.timeout;
+ numericTimeout = null;
+ }
+
+ Resource[name] = function(a1, a2, a3, a4) {
+ var params = {}, data, onSuccess, onError;
+
+ switch (arguments.length) {
+ case 4:
+ onError = a4;
+ onSuccess = a3;
+ // falls through
+ case 3:
+ case 2:
+ if (isFunction(a2)) {
+ if (isFunction(a1)) {
+ onSuccess = a1;
+ onError = a2;
+ break;
+ }
+
+ onSuccess = a2;
+ onError = a3;
+ // falls through
+ } else {
+ params = a1;
+ data = a2;
+ onSuccess = a3;
+ break;
+ }
+ // falls through
+ case 1:
+ if (isFunction(a1)) onSuccess = a1;
+ else if (hasBody) data = a1;
+ else params = a1;
+ break;
+ case 0: break;
+ default:
+ throw $resourceMinErr('badargs',
+ 'Expected up to 4 arguments [params, data, success, error], got {0} arguments',
+ arguments.length);
+ }
+
+ var isInstanceCall = this instanceof Resource;
+ var value = isInstanceCall ? data : (action.isArray ? [] : new Resource(data));
+ var httpConfig = {};
+ var requestInterceptor = action.interceptor && action.interceptor.request || undefined;
+ var requestErrorInterceptor = action.interceptor && action.interceptor.requestError ||
+ undefined;
+ var responseInterceptor = action.interceptor && action.interceptor.response ||
+ defaultResponseInterceptor;
+ var responseErrorInterceptor = action.interceptor && action.interceptor.responseError ||
+ $q.reject;
+ var successCallback = onSuccess ? function(val) {
+ onSuccess(val, response.headers, response.status, response.statusText);
+ } : undefined;
+ var errorCallback = onError || undefined;
+ var timeoutDeferred;
+ var numericTimeoutPromise;
+ var response;
+
+ forEach(action, function(value, key) {
+ switch (key) {
+ default:
+ httpConfig[key] = copy(value);
+ break;
+ case 'params':
+ case 'isArray':
+ case 'interceptor':
+ case 'cancellable':
+ break;
+ }
+ });
+
+ if (!isInstanceCall && cancellable) {
+ timeoutDeferred = $q.defer();
+ httpConfig.timeout = timeoutDeferred.promise;
+
+ if (numericTimeout) {
+ numericTimeoutPromise = $timeout(timeoutDeferred.resolve, numericTimeout);
+ }
+ }
+
+ if (hasBody) httpConfig.data = data;
+ route.setUrlParams(httpConfig,
+ extend({}, extractParams(data, action.params || {}), params),
+ action.url);
+
+ // Start the promise chain
+ var promise = $q.
+ resolve(httpConfig).
+ then(requestInterceptor).
+ catch(requestErrorInterceptor).
+ then($http);
+
+ promise = promise.then(function(resp) {
+ var data = resp.data;
+
+ if (data) {
+ // Need to convert action.isArray to boolean in case it is undefined
+ if (isArray(data) !== (!!action.isArray)) {
+ throw $resourceMinErr('badcfg',
+ 'Error in resource configuration for action `{0}`. Expected response to ' +
+ 'contain an {1} but got an {2} (Request: {3} {4})', name, action.isArray ? 'array' : 'object',
+ isArray(data) ? 'array' : 'object', httpConfig.method, httpConfig.url);
+ }
+ if (action.isArray) {
+ value.length = 0;
+ forEach(data, function(item) {
+ if (typeof item === 'object') {
+ value.push(new Resource(item));
+ } else {
+ // Valid JSON values may be string literals, and these should not be converted
+ // into objects. These items will not have access to the Resource prototype
+ // methods, but unfortunately there
+ value.push(item);
+ }
+ });
+ } else {
+ var promise = value.$promise; // Save the promise
+ shallowClearAndCopy(data, value);
+ value.$promise = promise; // Restore the promise
+ }
+ }
+
+ resp.resource = value;
+ response = resp;
+ return responseInterceptor(resp);
+ }, function(rejectionOrResponse) {
+ rejectionOrResponse.resource = value;
+ response = rejectionOrResponse;
+ return responseErrorInterceptor(rejectionOrResponse);
+ });
+
+ promise = promise['finally'](function() {
+ value.$resolved = true;
+ if (!isInstanceCall && cancellable) {
+ value.$cancelRequest = noop;
+ $timeout.cancel(numericTimeoutPromise);
+ timeoutDeferred = numericTimeoutPromise = httpConfig.timeout = null;
+ }
+ });
+
+ // Run the `success`/`error` callbacks, but do not let them affect the returned promise.
+ promise.then(successCallback, errorCallback);
+
+ if (!isInstanceCall) {
+ // we are creating instance / collection
+ // - set the initial promise
+ // - return the instance / collection
+ value.$promise = promise;
+ value.$resolved = false;
+ if (cancellable) value.$cancelRequest = cancelRequest;
+
+ return value;
+ }
+
+ // instance call
+ return promise;
+
+ function cancelRequest(value) {
+ promise.catch(noop);
+ if (timeoutDeferred !== null) {
+ timeoutDeferred.resolve(value);
+ }
+ }
+ };
+
+
+ Resource.prototype['$' + name] = function(params, success, error) {
+ if (isFunction(params)) {
+ error = success; success = params; params = {};
+ }
+ var result = Resource[name].call(this, params, this, success, error);
+ return result.$promise || result;
+ };
+ });
+
+ return Resource;
+ }
+
+ return resourceFactory;
+ }];
+ });
+
+
+})(window, window.angular);
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-resource/index.js":
+/*!************************************************!*\
+ !*** ./node_modules/angular-resource/index.js ***!
+ \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+__webpack_require__(/*! ./angular-resource */ "./node_modules/angular-resource/angular-resource.js");
+module.exports = 'ngResource';
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-sanitize/angular-sanitize.js":
+/*!***********************************************************!*\
+ !*** ./node_modules/angular-sanitize/angular-sanitize.js ***!
+ \***********************************************************/
+/***/ (() => {
+
+/**
+ * @license AngularJS v1.8.2
+ * (c) 2010-2020 Google LLC. http://angularjs.org
+ * License: MIT
+ */
+(function(window, angular) {'use strict';
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Any commits to this file should be reviewed with security in mind. *
+ * Changes to this file can potentially create security vulnerabilities. *
+ * An approval from 2 Core members with history of modifying *
+ * this file is required. *
+ * *
+ * Does the change somehow allow for arbitrary javascript to be executed? *
+ * Or allows for someone to change the prototype of built-in objects? *
+ * Or gives undesired access to variables likes document or window? *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+var $sanitizeMinErr = angular.$$minErr('$sanitize');
+var bind;
+var extend;
+var forEach;
+var isArray;
+var isDefined;
+var lowercase;
+var noop;
+var nodeContains;
+var htmlParser;
+var htmlSanitizeWriter;
+
+/**
+ * @ngdoc module
+ * @name ngSanitize
+ * @description
+ *
+ * The `ngSanitize` module provides functionality to sanitize HTML.
+ *
+ * See {@link ngSanitize.$sanitize `$sanitize`} for usage.
+ */
+
+/**
+ * @ngdoc service
+ * @name $sanitize
+ * @kind function
+ *
+ * @description
+ * Sanitizes an html string by stripping all potentially dangerous tokens.
+ *
+ * The input is sanitized by parsing the HTML into tokens. All safe tokens (from a trusted URI list) are
+ * then serialized back to a properly escaped HTML string. This means that no unsafe input can make
+ * it into the returned string.
+ *
+ * The trusted URIs for URL sanitization of attribute values is configured using the functions
+ * `aHrefSanitizationTrustedUrlList` and `imgSrcSanitizationTrustedUrlList` of {@link $compileProvider}.
+ *
+ * The input may also contain SVG markup if this is enabled via {@link $sanitizeProvider}.
+ *
+ * @param {string} html HTML input.
+ * @returns {string} Sanitized HTML.
+ *
+ * @example
+ <example module="sanitizeExample" deps="angular-sanitize.js" name="sanitize-service">
+ <file name="index.html">
+ <script>
+ angular.module('sanitizeExample', ['ngSanitize'])
+ .controller('ExampleController', ['$scope', '$sce', function($scope, $sce) {
+ $scope.snippet =
+ '<p style="color:blue">an html\n' +
+ '<em onmouseover="this.textContent=\'PWN3D!\'">click here</em>\n' +
+ 'snippet</p>';
+ $scope.deliberatelyTrustDangerousSnippet = function() {
+ return $sce.trustAsHtml($scope.snippet);
+ };
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ Snippet: <textarea ng-model="snippet" cols="60" rows="3"></textarea>
+ <table>
+ <tr>
+ <td>Directive</td>
+ <td>How</td>
+ <td>Source</td>
+ <td>Rendered</td>
+ </tr>
+ <tr id="bind-html-with-sanitize">
+ <td>ng-bind-html</td>
+ <td>Automatically uses $sanitize</td>
+ <td><pre><div ng-bind-html="snippet"><br/></div></pre></td>
+ <td><div ng-bind-html="snippet"></div></td>
+ </tr>
+ <tr id="bind-html-with-trust">
+ <td>ng-bind-html</td>
+ <td>Bypass $sanitize by explicitly trusting the dangerous value</td>
+ <td>
+ <pre><div ng-bind-html="deliberatelyTrustDangerousSnippet()">
+</div></pre>
+ </td>
+ <td><div ng-bind-html="deliberatelyTrustDangerousSnippet()"></div></td>
+ </tr>
+ <tr id="bind-default">
+ <td>ng-bind</td>
+ <td>Automatically escapes</td>
+ <td><pre><div ng-bind="snippet"><br/></div></pre></td>
+ <td><div ng-bind="snippet"></div></td>
+ </tr>
+ </table>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should sanitize the html snippet by default', function() {
+ expect(element(by.css('#bind-html-with-sanitize div')).getAttribute('innerHTML')).
+ toBe('<p>an html\n<em>click here</em>\nsnippet</p>');
+ });
+
+ it('should inline raw snippet if bound to a trusted value', function() {
+ expect(element(by.css('#bind-html-with-trust div')).getAttribute('innerHTML')).
+ toBe("<p style=\"color:blue\">an html\n" +
+ "<em onmouseover=\"this.textContent='PWN3D!'\">click here</em>\n" +
+ "snippet</p>");
+ });
+
+ it('should escape snippet without any filter', function() {
+ expect(element(by.css('#bind-default div')).getAttribute('innerHTML')).
+ toBe("<p style=\"color:blue\">an html\n" +
+ "<em onmouseover=\"this.textContent='PWN3D!'\">click here</em>\n" +
+ "snippet</p>");
+ });
+
+ it('should update', function() {
+ element(by.model('snippet')).clear();
+ element(by.model('snippet')).sendKeys('new <b onclick="alert(1)">text</b>');
+ expect(element(by.css('#bind-html-with-sanitize div')).getAttribute('innerHTML')).
+ toBe('new <b>text</b>');
+ expect(element(by.css('#bind-html-with-trust div')).getAttribute('innerHTML')).toBe(
+ 'new <b onclick="alert(1)">text</b>');
+ expect(element(by.css('#bind-default div')).getAttribute('innerHTML')).toBe(
+ "new <b onclick=\"alert(1)\">text</b>");
+ });
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc provider
+ * @name $sanitizeProvider
+ * @this
+ *
+ * @description
+ * Creates and configures {@link $sanitize} instance.
+ */
+function $SanitizeProvider() {
+ var hasBeenInstantiated = false;
+ var svgEnabled = false;
+
+ this.$get = ['$$sanitizeUri', function($$sanitizeUri) {
+ hasBeenInstantiated = true;
+ if (svgEnabled) {
+ extend(validElements, svgElements);
+ }
+ return function(html) {
+ var buf = [];
+ htmlParser(html, htmlSanitizeWriter(buf, function(uri, isImage) {
+ return !/^unsafe:/.test($$sanitizeUri(uri, isImage));
+ }));
+ return buf.join('');
+ };
+ }];
+
+
+ /**
+ * @ngdoc method
+ * @name $sanitizeProvider#enableSvg
+ * @kind function
+ *
+ * @description
+ * Enables a subset of svg to be supported by the sanitizer.
+ *
+ * <div class="alert alert-warning">
+ * <p>By enabling this setting without taking other precautions, you might expose your
+ * application to click-hijacking attacks. In these attacks, sanitized svg elements could be positioned
+ * outside of the containing element and be rendered over other elements on the page (e.g. a login
+ * link). Such behavior can then result in phishing incidents.</p>
+ *
+ * <p>To protect against these, explicitly setup `overflow: hidden` css rule for all potential svg
+ * tags within the sanitized content:</p>
+ *
+ * <br>
+ *
+ * <pre><code>
+ * .rootOfTheIncludedContent svg {
+ * overflow: hidden !important;
+ * }
+ * </code></pre>
+ * </div>
+ *
+ * @param {boolean=} flag Enable or disable SVG support in the sanitizer.
+ * @returns {boolean|$sanitizeProvider} Returns the currently configured value if called
+ * without an argument or self for chaining otherwise.
+ */
+ this.enableSvg = function(enableSvg) {
+ if (isDefined(enableSvg)) {
+ svgEnabled = enableSvg;
+ return this;
+ } else {
+ return svgEnabled;
+ }
+ };
+
+
+ /**
+ * @ngdoc method
+ * @name $sanitizeProvider#addValidElements
+ * @kind function
+ *
+ * @description
+ * Extends the built-in lists of valid HTML/SVG elements, i.e. elements that are considered safe
+ * and are not stripped off during sanitization. You can extend the following lists of elements:
+ *
+ * - `htmlElements`: A list of elements (tag names) to extend the current list of safe HTML
+ * elements. HTML elements considered safe will not be removed during sanitization. All other
+ * elements will be stripped off.
+ *
+ * - `htmlVoidElements`: This is similar to `htmlElements`, but marks the elements as
+ * "void elements" (similar to HTML
+ * [void elements](https://rawgit.com/w3c/html/html5.1-2/single-page.html#void-elements)). These
+ * elements have no end tag and cannot have content.
+ *
+ * - `svgElements`: This is similar to `htmlElements`, but for SVG elements. This list is only
+ * taken into account if SVG is {@link ngSanitize.$sanitizeProvider#enableSvg enabled} for
+ * `$sanitize`.
+ *
+ * <div class="alert alert-info">
+ * This method must be called during the {@link angular.Module#config config} phase. Once the
+ * `$sanitize` service has been instantiated, this method has no effect.
+ * </div>
+ *
+ * <div class="alert alert-warning">
+ * Keep in mind that extending the built-in lists of elements may expose your app to XSS or
+ * other vulnerabilities. Be very mindful of the elements you add.
+ * </div>
+ *
+ * @param {Array<String>|Object} elements - A list of valid HTML elements or an object with one or
+ * more of the following properties:
+ * - **htmlElements** - `{Array<String>}` - A list of elements to extend the current list of
+ * HTML elements.
+ * - **htmlVoidElements** - `{Array<String>}` - A list of elements to extend the current list of
+ * void HTML elements; i.e. elements that do not have an end tag.
+ * - **svgElements** - `{Array<String>}` - A list of elements to extend the current list of SVG
+ * elements. The list of SVG elements is only taken into account if SVG is
+ * {@link ngSanitize.$sanitizeProvider#enableSvg enabled} for `$sanitize`.
+ *
+ * Passing an array (`[...]`) is equivalent to passing `{htmlElements: [...]}`.
+ *
+ * @return {$sanitizeProvider} Returns self for chaining.
+ */
+ this.addValidElements = function(elements) {
+ if (!hasBeenInstantiated) {
+ if (isArray(elements)) {
+ elements = {htmlElements: elements};
+ }
+
+ addElementsTo(svgElements, elements.svgElements);
+ addElementsTo(voidElements, elements.htmlVoidElements);
+ addElementsTo(validElements, elements.htmlVoidElements);
+ addElementsTo(validElements, elements.htmlElements);
+ }
+
+ return this;
+ };
+
+
+ /**
+ * @ngdoc method
+ * @name $sanitizeProvider#addValidAttrs
+ * @kind function
+ *
+ * @description
+ * Extends the built-in list of valid attributes, i.e. attributes that are considered safe and are
+ * not stripped off during sanitization.
+ *
+ * **Note**:
+ * The new attributes will not be treated as URI attributes, which means their values will not be
+ * sanitized as URIs using `$compileProvider`'s
+ * {@link ng.$compileProvider#aHrefSanitizationTrustedUrlList aHrefSanitizationTrustedUrlList} and
+ * {@link ng.$compileProvider#imgSrcSanitizationTrustedUrlList imgSrcSanitizationTrustedUrlList}.
+ *
+ * <div class="alert alert-info">
+ * This method must be called during the {@link angular.Module#config config} phase. Once the
+ * `$sanitize` service has been instantiated, this method has no effect.
+ * </div>
+ *
+ * <div class="alert alert-warning">
+ * Keep in mind that extending the built-in list of attributes may expose your app to XSS or
+ * other vulnerabilities. Be very mindful of the attributes you add.
+ * </div>
+ *
+ * @param {Array<String>} attrs - A list of valid attributes.
+ *
+ * @returns {$sanitizeProvider} Returns self for chaining.
+ */
+ this.addValidAttrs = function(attrs) {
+ if (!hasBeenInstantiated) {
+ extend(validAttrs, arrayToMap(attrs, true));
+ }
+ return this;
+ };
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ // Private stuff
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+
+ bind = angular.bind;
+ extend = angular.extend;
+ forEach = angular.forEach;
+ isArray = angular.isArray;
+ isDefined = angular.isDefined;
+ lowercase = angular.$$lowercase;
+ noop = angular.noop;
+
+ htmlParser = htmlParserImpl;
+ htmlSanitizeWriter = htmlSanitizeWriterImpl;
+
+ nodeContains = window.Node.prototype.contains || /** @this */ function(arg) {
+ // eslint-disable-next-line no-bitwise
+ return !!(this.compareDocumentPosition(arg) & 16);
+ };
+
+ // Regular Expressions for parsing tags and attributes
+ var SURROGATE_PAIR_REGEXP = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g,
+ // Match everything outside of normal chars and " (quote character)
+ NON_ALPHANUMERIC_REGEXP = /([^#-~ |!])/g;
+
+
+ // Good source of info about elements and attributes
+ // http://dev.w3.org/html5/spec/Overview.html#semantics
+ // http://simon.html5.org/html-elements
+
+ // Safe Void Elements - HTML5
+ // http://dev.w3.org/html5/spec/Overview.html#void-elements
+ var voidElements = stringToMap('area,br,col,hr,img,wbr');
+
+ // Elements that you can, intentionally, leave open (and which close themselves)
+ // http://dev.w3.org/html5/spec/Overview.html#optional-tags
+ var optionalEndTagBlockElements = stringToMap('colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr'),
+ optionalEndTagInlineElements = stringToMap('rp,rt'),
+ optionalEndTagElements = extend({},
+ optionalEndTagInlineElements,
+ optionalEndTagBlockElements);
+
+ // Safe Block Elements - HTML5
+ var blockElements = extend({}, optionalEndTagBlockElements, stringToMap('address,article,' +
+ 'aside,blockquote,caption,center,del,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,' +
+ 'h6,header,hgroup,hr,ins,map,menu,nav,ol,pre,section,table,ul'));
+
+ // Inline Elements - HTML5
+ var inlineElements = extend({}, optionalEndTagInlineElements, stringToMap('a,abbr,acronym,b,' +
+ 'bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,q,ruby,rp,rt,s,' +
+ 'samp,small,span,strike,strong,sub,sup,time,tt,u,var'));
+
+ // SVG Elements
+ // https://wiki.whatwg.org/wiki/Sanitization_rules#svg_Elements
+ // Note: the elements animate,animateColor,animateMotion,animateTransform,set are intentionally omitted.
+ // They can potentially allow for arbitrary javascript to be executed. See #11290
+ var svgElements = stringToMap('circle,defs,desc,ellipse,font-face,font-face-name,font-face-src,g,glyph,' +
+ 'hkern,image,linearGradient,line,marker,metadata,missing-glyph,mpath,path,polygon,polyline,' +
+ 'radialGradient,rect,stop,svg,switch,text,title,tspan');
+
+ // Blocked Elements (will be stripped)
+ var blockedElements = stringToMap('script,style');
+
+ var validElements = extend({},
+ voidElements,
+ blockElements,
+ inlineElements,
+ optionalEndTagElements);
+
+ //Attributes that have href and hence need to be sanitized
+ var uriAttrs = stringToMap('background,cite,href,longdesc,src,xlink:href,xml:base');
+
+ var htmlAttrs = stringToMap('abbr,align,alt,axis,bgcolor,border,cellpadding,cellspacing,class,clear,' +
+ 'color,cols,colspan,compact,coords,dir,face,headers,height,hreflang,hspace,' +
+ 'ismap,lang,language,nohref,nowrap,rel,rev,rows,rowspan,rules,' +
+ 'scope,scrolling,shape,size,span,start,summary,tabindex,target,title,type,' +
+ 'valign,value,vspace,width');
+
+ // SVG attributes (without "id" and "name" attributes)
+ // https://wiki.whatwg.org/wiki/Sanitization_rules#svg_Attributes
+ var svgAttrs = stringToMap('accent-height,accumulate,additive,alphabetic,arabic-form,ascent,' +
+ 'baseProfile,bbox,begin,by,calcMode,cap-height,class,color,color-rendering,content,' +
+ 'cx,cy,d,dx,dy,descent,display,dur,end,fill,fill-rule,font-family,font-size,font-stretch,' +
+ 'font-style,font-variant,font-weight,from,fx,fy,g1,g2,glyph-name,gradientUnits,hanging,' +
+ 'height,horiz-adv-x,horiz-origin-x,ideographic,k,keyPoints,keySplines,keyTimes,lang,' +
+ 'marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mathematical,' +
+ 'max,min,offset,opacity,orient,origin,overline-position,overline-thickness,panose-1,' +
+ 'path,pathLength,points,preserveAspectRatio,r,refX,refY,repeatCount,repeatDur,' +
+ 'requiredExtensions,requiredFeatures,restart,rotate,rx,ry,slope,stemh,stemv,stop-color,' +
+ 'stop-opacity,strikethrough-position,strikethrough-thickness,stroke,stroke-dasharray,' +
+ 'stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,' +
+ 'stroke-width,systemLanguage,target,text-anchor,to,transform,type,u1,u2,underline-position,' +
+ 'underline-thickness,unicode,unicode-range,units-per-em,values,version,viewBox,visibility,' +
+ 'width,widths,x,x-height,x1,x2,xlink:actuate,xlink:arcrole,xlink:role,xlink:show,xlink:title,' +
+ 'xlink:type,xml:base,xml:lang,xml:space,xmlns,xmlns:xlink,y,y1,y2,zoomAndPan', true);
+
+ var validAttrs = extend({},
+ uriAttrs,
+ svgAttrs,
+ htmlAttrs);
+
+ function stringToMap(str, lowercaseKeys) {
+ return arrayToMap(str.split(','), lowercaseKeys);
+ }
+
+ function arrayToMap(items, lowercaseKeys) {
+ var obj = {}, i;
+ for (i = 0; i < items.length; i++) {
+ obj[lowercaseKeys ? lowercase(items[i]) : items[i]] = true;
+ }
+ return obj;
+ }
+
+ function addElementsTo(elementsMap, newElements) {
+ if (newElements && newElements.length) {
+ extend(elementsMap, arrayToMap(newElements));
+ }
+ }
+
+ /**
+ * Create an inert document that contains the dirty HTML that needs sanitizing.
+ * We use the DOMParser API by default and fall back to createHTMLDocument if DOMParser is not
+ * available.
+ */
+ var getInertBodyElement /* function(html: string): HTMLBodyElement */ = (function(window, document) {
+ if (isDOMParserAvailable()) {
+ return getInertBodyElement_DOMParser;
+ }
+
+ if (!document || !document.implementation) {
+ throw $sanitizeMinErr('noinert', 'Can\'t create an inert html document');
+ }
+ var inertDocument = document.implementation.createHTMLDocument('inert');
+ var inertBodyElement = (inertDocument.documentElement || inertDocument.getDocumentElement()).querySelector('body');
+ return getInertBodyElement_InertDocument;
+
+ function isDOMParserAvailable() {
+ try {
+ return !!getInertBodyElement_DOMParser('');
+ } catch (e) {
+ return false;
+ }
+ }
+
+ function getInertBodyElement_DOMParser(html) {
+ // We add this dummy element to ensure that the rest of the content is parsed as expected
+ // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the `<head>` tag.
+ html = '<remove></remove>' + html;
+ try {
+ var body = new window.DOMParser().parseFromString(html, 'text/html').body;
+ body.firstChild.remove();
+ return body;
+ } catch (e) {
+ return undefined;
+ }
+ }
+
+ function getInertBodyElement_InertDocument(html) {
+ inertBodyElement.innerHTML = html;
+
+ // Support: IE 9-11 only
+ // strip custom-namespaced attributes on IE<=11
+ if (document.documentMode) {
+ stripCustomNsAttrs(inertBodyElement);
+ }
+
+ return inertBodyElement;
+ }
+ })(window, window.document);
+
+ /**
+ * @example
+ * htmlParser(htmlString, {
+ * start: function(tag, attrs) {},
+ * end: function(tag) {},
+ * chars: function(text) {},
+ * comment: function(text) {}
+ * });
+ *
+ * @param {string} html string
+ * @param {object} handler
+ */
+ function htmlParserImpl(html, handler) {
+ if (html === null || html === undefined) {
+ html = '';
+ } else if (typeof html !== 'string') {
+ html = '' + html;
+ }
+
+ var inertBodyElement = getInertBodyElement(html);
+ if (!inertBodyElement) return '';
+
+ //mXSS protection
+ var mXSSAttempts = 5;
+ do {
+ if (mXSSAttempts === 0) {
+ throw $sanitizeMinErr('uinput', 'Failed to sanitize html because the input is unstable');
+ }
+ mXSSAttempts--;
+
+ // trigger mXSS if it is going to happen by reading and writing the innerHTML
+ html = inertBodyElement.innerHTML;
+ inertBodyElement = getInertBodyElement(html);
+ } while (html !== inertBodyElement.innerHTML);
+
+ var node = inertBodyElement.firstChild;
+ while (node) {
+ switch (node.nodeType) {
+ case 1: // ELEMENT_NODE
+ handler.start(node.nodeName.toLowerCase(), attrToMap(node.attributes));
+ break;
+ case 3: // TEXT NODE
+ handler.chars(node.textContent);
+ break;
+ }
+
+ var nextNode;
+ if (!(nextNode = node.firstChild)) {
+ if (node.nodeType === 1) {
+ handler.end(node.nodeName.toLowerCase());
+ }
+ nextNode = getNonDescendant('nextSibling', node);
+ if (!nextNode) {
+ while (nextNode == null) {
+ node = getNonDescendant('parentNode', node);
+ if (node === inertBodyElement) break;
+ nextNode = getNonDescendant('nextSibling', node);
+ if (node.nodeType === 1) {
+ handler.end(node.nodeName.toLowerCase());
+ }
+ }
+ }
+ }
+ node = nextNode;
+ }
+
+ while ((node = inertBodyElement.firstChild)) {
+ inertBodyElement.removeChild(node);
+ }
+ }
+
+ function attrToMap(attrs) {
+ var map = {};
+ for (var i = 0, ii = attrs.length; i < ii; i++) {
+ var attr = attrs[i];
+ map[attr.name] = attr.value;
+ }
+ return map;
+ }
+
+
+ /**
+ * Escapes all potentially dangerous characters, so that the
+ * resulting string can be safely inserted into attribute or
+ * element text.
+ * @param value
+ * @returns {string} escaped text
+ */
+ function encodeEntities(value) {
+ return value.
+ replace(/&/g, '&').
+ replace(SURROGATE_PAIR_REGEXP, function(value) {
+ var hi = value.charCodeAt(0);
+ var low = value.charCodeAt(1);
+ return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';';
+ }).
+ replace(NON_ALPHANUMERIC_REGEXP, function(value) {
+ return '&#' + value.charCodeAt(0) + ';';
+ }).
+ replace(/</g, '<').
+ replace(/>/g, '>');
+ }
+
+ /**
+ * create an HTML/XML writer which writes to buffer
+ * @param {Array} buf use buf.join('') to get out sanitized html string
+ * @returns {object} in the form of {
+ * start: function(tag, attrs) {},
+ * end: function(tag) {},
+ * chars: function(text) {},
+ * comment: function(text) {}
+ * }
+ */
+ function htmlSanitizeWriterImpl(buf, uriValidator) {
+ var ignoreCurrentElement = false;
+ var out = bind(buf, buf.push);
+ return {
+ start: function(tag, attrs) {
+ tag = lowercase(tag);
+ if (!ignoreCurrentElement && blockedElements[tag]) {
+ ignoreCurrentElement = tag;
+ }
+ if (!ignoreCurrentElement && validElements[tag] === true) {
+ out('<');
+ out(tag);
+ forEach(attrs, function(value, key) {
+ var lkey = lowercase(key);
+ var isImage = (tag === 'img' && lkey === 'src') || (lkey === 'background');
+ if (validAttrs[lkey] === true &&
+ (uriAttrs[lkey] !== true || uriValidator(value, isImage))) {
+ out(' ');
+ out(key);
+ out('="');
+ out(encodeEntities(value));
+ out('"');
+ }
+ });
+ out('>');
+ }
+ },
+ end: function(tag) {
+ tag = lowercase(tag);
+ if (!ignoreCurrentElement && validElements[tag] === true && voidElements[tag] !== true) {
+ out('</');
+ out(tag);
+ out('>');
+ }
+ // eslint-disable-next-line eqeqeq
+ if (tag == ignoreCurrentElement) {
+ ignoreCurrentElement = false;
+ }
+ },
+ chars: function(chars) {
+ if (!ignoreCurrentElement) {
+ out(encodeEntities(chars));
+ }
+ }
+ };
+ }
+
+
+ /**
+ * When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1' attribute to declare
+ * ns1 namespace and prefixes the attribute with 'ns1' (e.g. 'ns1:xlink:foo'). This is undesirable since we don't want
+ * to allow any of these custom attributes. This method strips them all.
+ *
+ * @param node Root element to process
+ */
+ function stripCustomNsAttrs(node) {
+ while (node) {
+ if (node.nodeType === window.Node.ELEMENT_NODE) {
+ var attrs = node.attributes;
+ for (var i = 0, l = attrs.length; i < l; i++) {
+ var attrNode = attrs[i];
+ var attrName = attrNode.name.toLowerCase();
+ if (attrName === 'xmlns:ns1' || attrName.lastIndexOf('ns1:', 0) === 0) {
+ node.removeAttributeNode(attrNode);
+ i--;
+ l--;
+ }
+ }
+ }
+
+ var nextNode = node.firstChild;
+ if (nextNode) {
+ stripCustomNsAttrs(nextNode);
+ }
+
+ node = getNonDescendant('nextSibling', node);
+ }
+ }
+
+ function getNonDescendant(propName, node) {
+ // An element is clobbered if its `propName` property points to one of its descendants
+ var nextNode = node[propName];
+ if (nextNode && nodeContains.call(node, nextNode)) {
+ throw $sanitizeMinErr('elclob', 'Failed to sanitize html because the element is clobbered: {0}', node.outerHTML || node.outerText);
+ }
+ return nextNode;
+ }
+}
+
+function sanitizeText(chars) {
+ var buf = [];
+ var writer = htmlSanitizeWriter(buf, noop);
+ writer.chars(chars);
+ return buf.join('');
+}
+
+
+// define ngSanitize module and register $sanitize service
+angular.module('ngSanitize', [])
+ .provider('$sanitize', $SanitizeProvider)
+ .info({ angularVersion: '1.8.2' });
+
+/**
+ * @ngdoc filter
+ * @name linky
+ * @kind function
+ *
+ * @description
+ * Finds links in text input and turns them into html links. Supports `http/https/ftp/sftp/mailto` and
+ * plain email address links.
+ *
+ * Requires the {@link ngSanitize `ngSanitize`} module to be installed.
+ *
+ * @param {string} text Input text.
+ * @param {string} [target] Window (`_blank|_self|_parent|_top`) or named frame to open links in.
+ * @param {object|function(url)} [attributes] Add custom attributes to the link element.
+ *
+ * Can be one of:
+ *
+ * - `object`: A map of attributes
+ * - `function`: Takes the url as a parameter and returns a map of attributes
+ *
+ * If the map of attributes contains a value for `target`, it overrides the value of
+ * the target parameter.
+ *
+ *
+ * @returns {string} Html-linkified and {@link $sanitize sanitized} text.
+ *
+ * @usage
+ <span ng-bind-html="linky_expression | linky"></span>
+ *
+ * @example
+ <example module="linkyExample" deps="angular-sanitize.js" name="linky-filter">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ Snippet: <textarea ng-model="snippet" cols="60" rows="3"></textarea>
+ <table>
+ <tr>
+ <th>Filter</th>
+ <th>Source</th>
+ <th>Rendered</th>
+ </tr>
+ <tr id="linky-filter">
+ <td>linky filter</td>
+ <td>
+ <pre><div ng-bind-html="snippet | linky"><br></div></pre>
+ </td>
+ <td>
+ <div ng-bind-html="snippet | linky"></div>
+ </td>
+ </tr>
+ <tr id="linky-target">
+ <td>linky target</td>
+ <td>
+ <pre><div ng-bind-html="snippetWithSingleURL | linky:'_blank'"><br></div></pre>
+ </td>
+ <td>
+ <div ng-bind-html="snippetWithSingleURL | linky:'_blank'"></div>
+ </td>
+ </tr>
+ <tr id="linky-custom-attributes">
+ <td>linky custom attributes</td>
+ <td>
+ <pre><div ng-bind-html="snippetWithSingleURL | linky:'_self':{rel: 'nofollow'}"><br></div></pre>
+ </td>
+ <td>
+ <div ng-bind-html="snippetWithSingleURL | linky:'_self':{rel: 'nofollow'}"></div>
+ </td>
+ </tr>
+ <tr id="escaped-html">
+ <td>no filter</td>
+ <td><pre><div ng-bind="snippet"><br></div></pre></td>
+ <td><div ng-bind="snippet"></div></td>
+ </tr>
+ </table>
+ </file>
+ <file name="script.js">
+ angular.module('linkyExample', ['ngSanitize'])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.snippet =
+ 'Pretty text with some links:\n' +
+ 'http://angularjs.org/,\n' +
+ 'mailto:us@somewhere.org,\n' +
+ 'another@somewhere.org,\n' +
+ 'and one more: ftp://127.0.0.1/.';
+ $scope.snippetWithSingleURL = 'http://angularjs.org/';
+ }]);
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should linkify the snippet with urls', function() {
+ expect(element(by.id('linky-filter')).element(by.binding('snippet | linky')).getText()).
+ toBe('Pretty text with some links: http://angularjs.org/, us@somewhere.org, ' +
+ 'another@somewhere.org, and one more: ftp://127.0.0.1/.');
+ expect(element.all(by.css('#linky-filter a')).count()).toEqual(4);
+ });
+
+ it('should not linkify snippet without the linky filter', function() {
+ expect(element(by.id('escaped-html')).element(by.binding('snippet')).getText()).
+ toBe('Pretty text with some links: http://angularjs.org/, mailto:us@somewhere.org, ' +
+ 'another@somewhere.org, and one more: ftp://127.0.0.1/.');
+ expect(element.all(by.css('#escaped-html a')).count()).toEqual(0);
+ });
+
+ it('should update', function() {
+ element(by.model('snippet')).clear();
+ element(by.model('snippet')).sendKeys('new http://link.');
+ expect(element(by.id('linky-filter')).element(by.binding('snippet | linky')).getText()).
+ toBe('new http://link.');
+ expect(element.all(by.css('#linky-filter a')).count()).toEqual(1);
+ expect(element(by.id('escaped-html')).element(by.binding('snippet')).getText())
+ .toBe('new http://link.');
+ });
+
+ it('should work with the target property', function() {
+ expect(element(by.id('linky-target')).
+ element(by.binding("snippetWithSingleURL | linky:'_blank'")).getText()).
+ toBe('http://angularjs.org/');
+ expect(element(by.css('#linky-target a')).getAttribute('target')).toEqual('_blank');
+ });
+
+ it('should optionally add custom attributes', function() {
+ expect(element(by.id('linky-custom-attributes')).
+ element(by.binding("snippetWithSingleURL | linky:'_self':{rel: 'nofollow'}")).getText()).
+ toBe('http://angularjs.org/');
+ expect(element(by.css('#linky-custom-attributes a')).getAttribute('rel')).toEqual('nofollow');
+ });
+ </file>
+ </example>
+ */
+angular.module('ngSanitize').filter('linky', ['$sanitize', function($sanitize) {
+ var LINKY_URL_REGEXP =
+ /((s?ftp|https?):\/\/|(www\.)|(mailto:)?[A-Za-z0-9._%+-]+@)\S*[^\s.;,(){}<>"\u201d\u2019]/i,
+ MAILTO_REGEXP = /^mailto:/i;
+
+ var linkyMinErr = angular.$$minErr('linky');
+ var isDefined = angular.isDefined;
+ var isFunction = angular.isFunction;
+ var isObject = angular.isObject;
+ var isString = angular.isString;
+
+ return function(text, target, attributes) {
+ if (text == null || text === '') return text;
+ if (!isString(text)) throw linkyMinErr('notstring', 'Expected string but received: {0}', text);
+
+ var attributesFn =
+ isFunction(attributes) ? attributes :
+ isObject(attributes) ? function getAttributesObject() {return attributes;} :
+ function getEmptyAttributesObject() {return {};};
+
+ var match;
+ var raw = text;
+ var html = [];
+ var url;
+ var i;
+ while ((match = raw.match(LINKY_URL_REGEXP))) {
+ // We can not end in these as they are sometimes found at the end of the sentence
+ url = match[0];
+ // if we did not match ftp/http/www/mailto then assume mailto
+ if (!match[2] && !match[4]) {
+ url = (match[3] ? 'http://' : 'mailto:') + url;
+ }
+ i = match.index;
+ addText(raw.substr(0, i));
+ addLink(url, match[0].replace(MAILTO_REGEXP, ''));
+ raw = raw.substring(i + match[0].length);
+ }
+ addText(raw);
+ return $sanitize(html.join(''));
+
+ function addText(text) {
+ if (!text) {
+ return;
+ }
+ html.push(sanitizeText(text));
+ }
+
+ function addLink(url, text) {
+ var key, linkAttributes = attributesFn(url);
+ html.push('<a ');
+
+ for (key in linkAttributes) {
+ html.push(key + '="' + linkAttributes[key] + '" ');
+ }
+
+ if (isDefined(target) && !('target' in linkAttributes)) {
+ html.push('target="',
+ target,
+ '" ');
+ }
+ html.push('href="',
+ url.replace(/"/g, '"'),
+ '">');
+ addText(text);
+ html.push('</a>');
+ }
+ };
+}]);
+
+
+})(window, window.angular);
+
+
+/***/ }),
+
+/***/ "./node_modules/angular-sanitize/index.js":
+/*!************************************************!*\
+ !*** ./node_modules/angular-sanitize/index.js ***!
+ \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+__webpack_require__(/*! ./angular-sanitize */ "./node_modules/angular-sanitize/angular-sanitize.js");
+module.exports = 'ngSanitize';
+
+
+/***/ }),
+
+/***/ "./node_modules/angular/angular.js":
+/*!*****************************************!*\
+ !*** ./node_modules/angular/angular.js ***!
+ \*****************************************/
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+/* provided dependency */ var __webpack_provided_window_dot_jQuery = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js");
+/**
+ * @license AngularJS v1.8.2
+ * (c) 2010-2020 Google LLC. http://angularjs.org
+ * License: MIT
+ */
+(function(window) {'use strict';
+
+/* exported
+ minErrConfig,
+ errorHandlingConfig,
+ isValidObjectMaxDepth
+*/
+
+var minErrConfig = {
+ objectMaxDepth: 5,
+ urlErrorParamsEnabled: true
+};
+
+/**
+ * @ngdoc function
+ * @name angular.errorHandlingConfig
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Configure several aspects of error handling in AngularJS if used as a setter or return the
+ * current configuration if used as a getter. The following options are supported:
+ *
+ * - **objectMaxDepth**: The maximum depth to which objects are traversed when stringified for error messages.
+ *
+ * Omitted or undefined options will leave the corresponding configuration values unchanged.
+ *
+ * @param {Object=} config - The configuration object. May only contain the options that need to be
+ * updated. Supported keys:
+ *
+ * * `objectMaxDepth` **{Number}** - The max depth for stringifying objects. Setting to a
+ * non-positive or non-numeric value, removes the max depth limit.
+ * Default: 5
+ *
+ * * `urlErrorParamsEnabled` **{Boolean}** - Specifies whether the generated error url will
+ * contain the parameters of the thrown error. Disabling the parameters can be useful if the
+ * generated error url is very long.
+ *
+ * Default: true. When used without argument, it returns the current value.
+ */
+function errorHandlingConfig(config) {
+ if (isObject(config)) {
+ if (isDefined(config.objectMaxDepth)) {
+ minErrConfig.objectMaxDepth = isValidObjectMaxDepth(config.objectMaxDepth) ? config.objectMaxDepth : NaN;
+ }
+ if (isDefined(config.urlErrorParamsEnabled) && isBoolean(config.urlErrorParamsEnabled)) {
+ minErrConfig.urlErrorParamsEnabled = config.urlErrorParamsEnabled;
+ }
+ } else {
+ return minErrConfig;
+ }
+}
+
+/**
+ * @private
+ * @param {Number} maxDepth
+ * @return {boolean}
+ */
+function isValidObjectMaxDepth(maxDepth) {
+ return isNumber(maxDepth) && maxDepth > 0;
+}
+
+
+/**
+ * @description
+ *
+ * This object provides a utility for producing rich Error messages within
+ * AngularJS. It can be called as follows:
+ *
+ * var exampleMinErr = minErr('example');
+ * throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
+ *
+ * The above creates an instance of minErr in the example namespace. The
+ * resulting error will have a namespaced error code of example.one. The
+ * resulting error will replace {0} with the value of foo, and {1} with the
+ * value of bar. The object is not restricted in the number of arguments it can
+ * take.
+ *
+ * If fewer arguments are specified than necessary for interpolation, the extra
+ * interpolation markers will be preserved in the final string.
+ *
+ * Since data will be parsed statically during a build step, some restrictions
+ * are applied with respect to how minErr instances are created and called.
+ * Instances should have names of the form namespaceMinErr for a minErr created
+ * using minErr('namespace'). Error codes, namespaces and template strings
+ * should all be static strings, not variables or general expressions.
+ *
+ * @param {string} module The namespace to use for the new minErr instance.
+ * @param {function} ErrorConstructor Custom error constructor to be instantiated when returning
+ * error from returned function, for cases when a particular type of error is useful.
+ * @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance
+ */
+
+function minErr(module, ErrorConstructor) {
+ ErrorConstructor = ErrorConstructor || Error;
+
+ var url = 'https://errors.angularjs.org/1.8.2/';
+ var regex = url.replace('.', '\\.') + '[\\s\\S]*';
+ var errRegExp = new RegExp(regex, 'g');
+
+ return function() {
+ var code = arguments[0],
+ template = arguments[1],
+ message = '[' + (module ? module + ':' : '') + code + '] ',
+ templateArgs = sliceArgs(arguments, 2).map(function(arg) {
+ return toDebugString(arg, minErrConfig.objectMaxDepth);
+ }),
+ paramPrefix, i;
+
+ // A minErr message has two parts: the message itself and the url that contains the
+ // encoded message.
+ // The message's parameters can contain other error messages which also include error urls.
+ // To prevent the messages from getting too long, we strip the error urls from the parameters.
+
+ message += template.replace(/\{\d+\}/g, function(match) {
+ var index = +match.slice(1, -1);
+
+ if (index < templateArgs.length) {
+ return templateArgs[index].replace(errRegExp, '');
+ }
+
+ return match;
+ });
+
+ message += '\n' + url + (module ? module + '/' : '') + code;
+
+ if (minErrConfig.urlErrorParamsEnabled) {
+ for (i = 0, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
+ message += paramPrefix + 'p' + i + '=' + encodeURIComponent(templateArgs[i]);
+ }
+ }
+
+ return new ErrorConstructor(message);
+ };
+}
+
+/* We need to tell ESLint what variables are being exported */
+/* exported
+ angular,
+ msie,
+ jqLite,
+ jQuery,
+ slice,
+ splice,
+ push,
+ toString,
+ minErrConfig,
+ errorHandlingConfig,
+ isValidObjectMaxDepth,
+ ngMinErr,
+ angularModule,
+ uid,
+ REGEX_STRING_REGEXP,
+ VALIDITY_STATE_PROPERTY,
+
+ lowercase,
+ uppercase,
+ nodeName_,
+ isArrayLike,
+ forEach,
+ forEachSorted,
+ reverseParams,
+ nextUid,
+ setHashKey,
+ extend,
+ toInt,
+ inherit,
+ merge,
+ noop,
+ identity,
+ valueFn,
+ isUndefined,
+ isDefined,
+ isObject,
+ isBlankObject,
+ isString,
+ isNumber,
+ isNumberNaN,
+ isDate,
+ isError,
+ isArray,
+ isFunction,
+ isRegExp,
+ isWindow,
+ isScope,
+ isFile,
+ isFormData,
+ isBlob,
+ isBoolean,
+ isPromiseLike,
+ trim,
+ escapeForRegexp,
+ isElement,
+ makeMap,
+ includes,
+ arrayRemove,
+ copy,
+ simpleCompare,
+ equals,
+ csp,
+ jq,
+ concat,
+ sliceArgs,
+ bind,
+ toJsonReplacer,
+ toJson,
+ fromJson,
+ convertTimezoneToLocal,
+ timezoneToOffset,
+ addDateMinutes,
+ startingTag,
+ tryDecodeURIComponent,
+ parseKeyValue,
+ toKeyValue,
+ encodeUriSegment,
+ encodeUriQuery,
+ angularInit,
+ bootstrap,
+ getTestability,
+ snake_case,
+ bindJQuery,
+ assertArg,
+ assertArgFn,
+ assertNotHasOwnProperty,
+ getter,
+ getBlockNodes,
+ hasOwnProperty,
+ createMap,
+ stringify,
+ UNSAFE_restoreLegacyJqLiteXHTMLReplacement,
+
+ NODE_TYPE_ELEMENT,
+ NODE_TYPE_ATTRIBUTE,
+ NODE_TYPE_TEXT,
+ NODE_TYPE_COMMENT,
+ NODE_TYPE_DOCUMENT,
+ NODE_TYPE_DOCUMENT_FRAGMENT
+*/
+
+////////////////////////////////////
+
+/**
+ * @ngdoc module
+ * @name ng
+ * @module ng
+ * @installation
+ * @description
+ *
+ * The ng module is loaded by default when an AngularJS application is started. The module itself
+ * contains the essential components for an AngularJS application to function. The table below
+ * lists a high level breakdown of each of the services/factories, filters, directives and testing
+ * components available within this core module.
+ *
+ */
+
+var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
+
+// The name of a form control's ValidityState property.
+// This is used so that it's possible for internal tests to create mock ValidityStates.
+var VALIDITY_STATE_PROPERTY = 'validity';
+
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/**
+ * @private
+ *
+ * @description Converts the specified string to lowercase.
+ * @param {string} string String to be converted to lowercase.
+ * @returns {string} Lowercased string.
+ */
+var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};
+
+/**
+ * @private
+ *
+ * @description Converts the specified string to uppercase.
+ * @param {string} string String to be converted to uppercase.
+ * @returns {string} Uppercased string.
+ */
+var uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;};
+
+
+var
+ msie, // holds major version number for IE, or NaN if UA is not IE.
+ jqLite, // delay binding since jQuery could be loaded after us.
+ jQuery, // delay binding
+ slice = [].slice,
+ splice = [].splice,
+ push = [].push,
+ toString = Object.prototype.toString,
+ getPrototypeOf = Object.getPrototypeOf,
+ ngMinErr = minErr('ng'),
+
+ /** @name angular */
+ angular = window.angular || (window.angular = {}),
+ angularModule,
+ uid = 0;
+
+// Support: IE 9-11 only
+/**
+ * documentMode is an IE-only property
+ * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
+ */
+msie = window.document.documentMode;
+
+
+/**
+ * @private
+ * @param {*} obj
+ * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
+ * String ...)
+ */
+function isArrayLike(obj) {
+
+ // `null`, `undefined` and `window` are not array-like
+ if (obj == null || isWindow(obj)) return false;
+
+ // arrays, strings and jQuery/jqLite objects are array like
+ // * jqLite is either the jQuery or jqLite constructor function
+ // * we have to check the existence of jqLite first as this method is called
+ // via the forEach method when constructing the jqLite object in the first place
+ if (isArray(obj) || isString(obj) || (jqLite && obj instanceof jqLite)) return true;
+
+ // Support: iOS 8.2 (not reproducible in simulator)
+ // "length" in obj used to prevent JIT error (gh-11508)
+ var length = 'length' in Object(obj) && obj.length;
+
+ // NodeList objects (with `item` method) and
+ // other objects with suitable length characteristics are array-like
+ return isNumber(length) && (length >= 0 && (length - 1) in obj || typeof obj.item === 'function');
+
+}
+
+/**
+ * @ngdoc function
+ * @name angular.forEach
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Invokes the `iterator` function once for each item in `obj` collection, which can be either an
+ * object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value`
+ * is the value of an object property or an array element, `key` is the object property key or
+ * array element index and obj is the `obj` itself. Specifying a `context` for the function is optional.
+ *
+ * It is worth noting that `.forEach` does not iterate over inherited properties because it filters
+ * using the `hasOwnProperty` method.
+ *
+ * Unlike ES262's
+ * [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18),
+ * providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just
+ * return the value provided.
+ *
+ ```js
+ var values = {name: 'misko', gender: 'male'};
+ var log = [];
+ angular.forEach(values, function(value, key) {
+ this.push(key + ': ' + value);
+ }, log);
+ expect(log).toEqual(['name: misko', 'gender: male']);
+ ```
+ *
+ * @param {Object|Array} obj Object to iterate over.
+ * @param {Function} iterator Iterator function.
+ * @param {Object=} context Object to become context (`this`) for the iterator function.
+ * @returns {Object|Array} Reference to `obj`.
+ */
+
+function forEach(obj, iterator, context) {
+ var key, length;
+ if (obj) {
+ if (isFunction(obj)) {
+ for (key in obj) {
+ if (key !== 'prototype' && key !== 'length' && key !== 'name' && obj.hasOwnProperty(key)) {
+ iterator.call(context, obj[key], key, obj);
+ }
+ }
+ } else if (isArray(obj) || isArrayLike(obj)) {
+ var isPrimitive = typeof obj !== 'object';
+ for (key = 0, length = obj.length; key < length; key++) {
+ if (isPrimitive || key in obj) {
+ iterator.call(context, obj[key], key, obj);
+ }
+ }
+ } else if (obj.forEach && obj.forEach !== forEach) {
+ obj.forEach(iterator, context, obj);
+ } else if (isBlankObject(obj)) {
+ // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
+ for (key in obj) {
+ iterator.call(context, obj[key], key, obj);
+ }
+ } else if (typeof obj.hasOwnProperty === 'function') {
+ // Slow path for objects inheriting Object.prototype, hasOwnProperty check needed
+ for (key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ iterator.call(context, obj[key], key, obj);
+ }
+ }
+ } else {
+ // Slow path for objects which do not have a method `hasOwnProperty`
+ for (key in obj) {
+ if (hasOwnProperty.call(obj, key)) {
+ iterator.call(context, obj[key], key, obj);
+ }
+ }
+ }
+ }
+ return obj;
+}
+
+function forEachSorted(obj, iterator, context) {
+ var keys = Object.keys(obj).sort();
+ for (var i = 0; i < keys.length; i++) {
+ iterator.call(context, obj[keys[i]], keys[i]);
+ }
+ return keys;
+}
+
+
+/**
+ * when using forEach the params are value, key, but it is often useful to have key, value.
+ * @param {function(string, *)} iteratorFn
+ * @returns {function(*, string)}
+ */
+function reverseParams(iteratorFn) {
+ return function(value, key) {iteratorFn(key, value);};
+}
+
+/**
+ * A consistent way of creating unique IDs in angular.
+ *
+ * Using simple numbers allows us to generate 28.6 million unique ids per second for 10 years before
+ * we hit number precision issues in JavaScript.
+ *
+ * Math.pow(2,53) / 60 / 60 / 24 / 365 / 10 = 28.6M
+ *
+ * @returns {number} an unique alpha-numeric string
+ */
+function nextUid() {
+ return ++uid;
+}
+
+
+/**
+ * Set or clear the hashkey for an object.
+ * @param obj object
+ * @param h the hashkey (!truthy to delete the hashkey)
+ */
+function setHashKey(obj, h) {
+ if (h) {
+ obj.$$hashKey = h;
+ } else {
+ delete obj.$$hashKey;
+ }
+}
+
+
+function baseExtend(dst, objs, deep) {
+ var h = dst.$$hashKey;
+
+ for (var i = 0, ii = objs.length; i < ii; ++i) {
+ var obj = objs[i];
+ if (!isObject(obj) && !isFunction(obj)) continue;
+ var keys = Object.keys(obj);
+ for (var j = 0, jj = keys.length; j < jj; j++) {
+ var key = keys[j];
+ var src = obj[key];
+
+ if (deep && isObject(src)) {
+ if (isDate(src)) {
+ dst[key] = new Date(src.valueOf());
+ } else if (isRegExp(src)) {
+ dst[key] = new RegExp(src);
+ } else if (src.nodeName) {
+ dst[key] = src.cloneNode(true);
+ } else if (isElement(src)) {
+ dst[key] = src.clone();
+ } else {
+ if (key !== '__proto__') {
+ if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};
+ baseExtend(dst[key], [src], true);
+ }
+ }
+ } else {
+ dst[key] = src;
+ }
+ }
+ }
+
+ setHashKey(dst, h);
+ return dst;
+}
+
+/**
+ * @ngdoc function
+ * @name angular.extend
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
+ * to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
+ * by passing an empty object as the target: `var object = angular.extend({}, object1, object2)`.
+ *
+ * **Note:** Keep in mind that `angular.extend` does not support recursive merge (deep copy). Use
+ * {@link angular.merge} for this.
+ *
+ * @param {Object} dst Destination object.
+ * @param {...Object} src Source object(s).
+ * @returns {Object} Reference to `dst`.
+ */
+function extend(dst) {
+ return baseExtend(dst, slice.call(arguments, 1), false);
+}
+
+
+/**
+* @ngdoc function
+* @name angular.merge
+* @module ng
+* @kind function
+*
+* @description
+* Deeply extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
+* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
+* by passing an empty object as the target: `var object = angular.merge({}, object1, object2)`.
+*
+* Unlike {@link angular.extend extend()}, `merge()` recursively descends into object properties of source
+* objects, performing a deep copy.
+*
+* @deprecated
+* sinceVersion="1.6.5"
+* This function is deprecated, but will not be removed in the 1.x lifecycle.
+* There are edge cases (see {@link angular.merge#known-issues known issues}) that are not
+* supported by this function. We suggest using another, similar library for all-purpose merging,
+* such as [lodash's merge()](https://lodash.com/docs/4.17.4#merge).
+*
+* @knownIssue
+* This is a list of (known) object types that are not handled correctly by this function:
+* - [`Blob`](https://developer.mozilla.org/docs/Web/API/Blob)
+* - [`MediaStream`](https://developer.mozilla.org/docs/Web/API/MediaStream)
+* - [`CanvasGradient`](https://developer.mozilla.org/docs/Web/API/CanvasGradient)
+* - AngularJS {@link $rootScope.Scope scopes};
+*
+* `angular.merge` also does not support merging objects with circular references.
+*
+* @param {Object} dst Destination object.
+* @param {...Object} src Source object(s).
+* @returns {Object} Reference to `dst`.
+*/
+function merge(dst) {
+ return baseExtend(dst, slice.call(arguments, 1), true);
+}
+
+
+
+function toInt(str) {
+ return parseInt(str, 10);
+}
+
+var isNumberNaN = Number.isNaN || function isNumberNaN(num) {
+ // eslint-disable-next-line no-self-compare
+ return num !== num;
+};
+
+
+function inherit(parent, extra) {
+ return extend(Object.create(parent), extra);
+}
+
+/**
+ * @ngdoc function
+ * @name angular.noop
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * A function that performs no operations. This function can be useful when writing code in the
+ * functional style.
+ ```js
+ function foo(callback) {
+ var result = calculateResult();
+ (callback || angular.noop)(result);
+ }
+ ```
+ */
+function noop() {}
+noop.$inject = [];
+
+
+/**
+ * @ngdoc function
+ * @name angular.identity
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * A function that returns its first argument. This function is useful when writing code in the
+ * functional style.
+ *
+ ```js
+ function transformer(transformationFn, value) {
+ return (transformationFn || angular.identity)(value);
+ };
+
+ // E.g.
+ function getResult(fn, input) {
+ return (fn || angular.identity)(input);
+ };
+
+ getResult(function(n) { return n * 2; }, 21); // returns 42
+ getResult(null, 21); // returns 21
+ getResult(undefined, 21); // returns 21
+ ```
+ *
+ * @param {*} value to be returned.
+ * @returns {*} the value passed in.
+ */
+function identity($) {return $;}
+identity.$inject = [];
+
+
+function valueFn(value) {return function valueRef() {return value;};}
+
+function hasCustomToString(obj) {
+ return isFunction(obj.toString) && obj.toString !== toString;
+}
+
+
+/**
+ * @ngdoc function
+ * @name angular.isUndefined
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a reference is undefined.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is undefined.
+ */
+function isUndefined(value) {return typeof value === 'undefined';}
+
+
+/**
+ * @ngdoc function
+ * @name angular.isDefined
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a reference is defined.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is defined.
+ */
+function isDefined(value) {return typeof value !== 'undefined';}
+
+
+/**
+ * @ngdoc function
+ * @name angular.isObject
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
+ * considered to be objects. Note that JavaScript arrays are objects.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is an `Object` but not `null`.
+ */
+function isObject(value) {
+ // http://jsperf.com/isobject4
+ return value !== null && typeof value === 'object';
+}
+
+
+/**
+ * Determine if a value is an object with a null prototype
+ *
+ * @returns {boolean} True if `value` is an `Object` with a null prototype
+ */
+function isBlankObject(value) {
+ return value !== null && typeof value === 'object' && !getPrototypeOf(value);
+}
+
+
+/**
+ * @ngdoc function
+ * @name angular.isString
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a reference is a `String`.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a `String`.
+ */
+function isString(value) {return typeof value === 'string';}
+
+
+/**
+ * @ngdoc function
+ * @name angular.isNumber
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a reference is a `Number`.
+ *
+ * This includes the "special" numbers `NaN`, `+Infinity` and `-Infinity`.
+ *
+ * If you wish to exclude these then you can use the native
+ * [`isFinite'](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite)
+ * method.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a `Number`.
+ */
+function isNumber(value) {return typeof value === 'number';}
+
+
+/**
+ * @ngdoc function
+ * @name angular.isDate
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a value is a date.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a `Date`.
+ */
+function isDate(value) {
+ return toString.call(value) === '[object Date]';
+}
+
+
+/**
+ * @ngdoc function
+ * @name angular.isArray
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a reference is an `Array`.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is an `Array`.
+ */
+function isArray(arr) {
+ return Array.isArray(arr) || arr instanceof Array;
+}
+
+/**
+ * @description
+ * Determines if a reference is an `Error`.
+ * Loosely based on https://www.npmjs.com/package/iserror
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is an `Error`.
+ */
+function isError(value) {
+ var tag = toString.call(value);
+ switch (tag) {
+ case '[object Error]': return true;
+ case '[object Exception]': return true;
+ case '[object DOMException]': return true;
+ default: return value instanceof Error;
+ }
+}
+
+/**
+ * @ngdoc function
+ * @name angular.isFunction
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a reference is a `Function`.
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a `Function`.
+ */
+function isFunction(value) {return typeof value === 'function';}
+
+
+/**
+ * Determines if a value is a regular expression object.
+ *
+ * @private
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a `RegExp`.
+ */
+function isRegExp(value) {
+ return toString.call(value) === '[object RegExp]';
+}
+
+
+/**
+ * Checks if `obj` is a window object.
+ *
+ * @private
+ * @param {*} obj Object to check
+ * @returns {boolean} True if `obj` is a window obj.
+ */
+function isWindow(obj) {
+ return obj && obj.window === obj;
+}
+
+
+function isScope(obj) {
+ return obj && obj.$evalAsync && obj.$watch;
+}
+
+
+function isFile(obj) {
+ return toString.call(obj) === '[object File]';
+}
+
+
+function isFormData(obj) {
+ return toString.call(obj) === '[object FormData]';
+}
+
+
+function isBlob(obj) {
+ return toString.call(obj) === '[object Blob]';
+}
+
+
+function isBoolean(value) {
+ return typeof value === 'boolean';
+}
+
+
+function isPromiseLike(obj) {
+ return obj && isFunction(obj.then);
+}
+
+
+var TYPED_ARRAY_REGEXP = /^\[object (?:Uint8|Uint8Clamped|Uint16|Uint32|Int8|Int16|Int32|Float32|Float64)Array]$/;
+function isTypedArray(value) {
+ return value && isNumber(value.length) && TYPED_ARRAY_REGEXP.test(toString.call(value));
+}
+
+function isArrayBuffer(obj) {
+ return toString.call(obj) === '[object ArrayBuffer]';
+}
+
+
+var trim = function(value) {
+ return isString(value) ? value.trim() : value;
+};
+
+// Copied from:
+// http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
+// Prereq: s is a string.
+var escapeForRegexp = function(s) {
+ return s
+ .replace(/([-()[\]{}+?*.$^|,:#<!\\])/g, '\\$1')
+ // eslint-disable-next-line no-control-regex
+ .replace(/\x08/g, '\\x08');
+};
+
+
+/**
+ * @ngdoc function
+ * @name angular.isElement
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a reference is a DOM element (or wrapped jQuery element).
+ *
+ * @param {*} value Reference to check.
+ * @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
+ */
+function isElement(node) {
+ return !!(node &&
+ (node.nodeName // We are a direct element.
+ || (node.prop && node.attr && node.find))); // We have an on and find method part of jQuery API.
+}
+
+/**
+ * @param str 'key1,key2,...'
+ * @returns {object} in the form of {key1:true, key2:true, ...}
+ */
+function makeMap(str) {
+ var obj = {}, items = str.split(','), i;
+ for (i = 0; i < items.length; i++) {
+ obj[items[i]] = true;
+ }
+ return obj;
+}
+
+
+function nodeName_(element) {
+ return lowercase(element.nodeName || (element[0] && element[0].nodeName));
+}
+
+function includes(array, obj) {
+ return Array.prototype.indexOf.call(array, obj) !== -1;
+}
+
+function arrayRemove(array, value) {
+ var index = array.indexOf(value);
+ if (index >= 0) {
+ array.splice(index, 1);
+ }
+ return index;
+}
+
+/**
+ * @ngdoc function
+ * @name angular.copy
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Creates a deep copy of `source`, which should be an object or an array. This functions is used
+ * internally, mostly in the change-detection code. It is not intended as an all-purpose copy
+ * function, and has several limitations (see below).
+ *
+ * * If no destination is supplied, a copy of the object or array is created.
+ * * If a destination is provided, all of its elements (for arrays) or properties (for objects)
+ * are deleted and then all elements/properties from the source are copied to it.
+ * * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
+ * * If `source` is identical to `destination` an exception will be thrown.
+ *
+ * <br />
+ *
+ * <div class="alert alert-warning">
+ * Only enumerable properties are taken into account. Non-enumerable properties (both on `source`
+ * and on `destination`) will be ignored.
+ * </div>
+ *
+ * <div class="alert alert-warning">
+ * `angular.copy` does not check if destination and source are of the same type. It's the
+ * developer's responsibility to make sure they are compatible.
+ * </div>
+ *
+ * @knownIssue
+ * This is a non-exhaustive list of object types / features that are not handled correctly by
+ * `angular.copy`. Note that since this functions is used by the change detection code, this
+ * means binding or watching objects of these types (or that include these types) might not work
+ * correctly.
+ * - [`File`](https://developer.mozilla.org/docs/Web/API/File)
+ * - [`Map`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Map)
+ * - [`ImageData`](https://developer.mozilla.org/docs/Web/API/ImageData)
+ * - [`MediaStream`](https://developer.mozilla.org/docs/Web/API/MediaStream)
+ * - [`Set`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set)
+ * - [`WeakMap`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WeakMap)
+ * - [`getter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get)/
+ * [`setter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/set)
+ *
+ * @param {*} source The source that will be used to make a copy. Can be any type, including
+ * primitives, `null`, and `undefined`.
+ * @param {(Object|Array)=} destination Destination into which the source is copied. If provided,
+ * must be of the same type as `source`.
+ * @returns {*} The copy or updated `destination`, if `destination` was specified.
+ *
+ * @example
+ <example module="copyExample" name="angular-copy">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <form novalidate class="simple-form">
+ <label>Name: <input type="text" ng-model="user.name" /></label><br />
+ <label>Age: <input type="number" ng-model="user.age" /></label><br />
+ Gender: <label><input type="radio" ng-model="user.gender" value="male" />male</label>
+ <label><input type="radio" ng-model="user.gender" value="female" />female</label><br />
+ <button ng-click="reset()">RESET</button>
+ <button ng-click="update(user)">SAVE</button>
+ </form>
+ <pre>form = {{user | json}}</pre>
+ <pre>leader = {{leader | json}}</pre>
+ </div>
+ </file>
+ <file name="script.js">
+ // Module: copyExample
+ angular.
+ module('copyExample', []).
+ controller('ExampleController', ['$scope', function($scope) {
+ $scope.leader = {};
+
+ $scope.reset = function() {
+ // Example with 1 argument
+ $scope.user = angular.copy($scope.leader);
+ };
+
+ $scope.update = function(user) {
+ // Example with 2 arguments
+ angular.copy(user, $scope.leader);
+ };
+
+ $scope.reset();
+ }]);
+ </file>
+ </example>
+ */
+function copy(source, destination, maxDepth) {
+ var stackSource = [];
+ var stackDest = [];
+ maxDepth = isValidObjectMaxDepth(maxDepth) ? maxDepth : NaN;
+
+ if (destination) {
+ if (isTypedArray(destination) || isArrayBuffer(destination)) {
+ throw ngMinErr('cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
+ }
+ if (source === destination) {
+ throw ngMinErr('cpi', 'Can\'t copy! Source and destination are identical.');
+ }
+
+ // Empty the destination object
+ if (isArray(destination)) {
+ destination.length = 0;
+ } else {
+ forEach(destination, function(value, key) {
+ if (key !== '$$hashKey') {
+ delete destination[key];
+ }
+ });
+ }
+
+ stackSource.push(source);
+ stackDest.push(destination);
+ return copyRecurse(source, destination, maxDepth);
+ }
+
+ return copyElement(source, maxDepth);
+
+ function copyRecurse(source, destination, maxDepth) {
+ maxDepth--;
+ if (maxDepth < 0) {
+ return '...';
+ }
+ var h = destination.$$hashKey;
+ var key;
+ if (isArray(source)) {
+ for (var i = 0, ii = source.length; i < ii; i++) {
+ destination.push(copyElement(source[i], maxDepth));
+ }
+ } else if (isBlankObject(source)) {
+ // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
+ for (key in source) {
+ destination[key] = copyElement(source[key], maxDepth);
+ }
+ } else if (source && typeof source.hasOwnProperty === 'function') {
+ // Slow path, which must rely on hasOwnProperty
+ for (key in source) {
+ if (source.hasOwnProperty(key)) {
+ destination[key] = copyElement(source[key], maxDepth);
+ }
+ }
+ } else {
+ // Slowest path --- hasOwnProperty can't be called as a method
+ for (key in source) {
+ if (hasOwnProperty.call(source, key)) {
+ destination[key] = copyElement(source[key], maxDepth);
+ }
+ }
+ }
+ setHashKey(destination, h);
+ return destination;
+ }
+
+ function copyElement(source, maxDepth) {
+ // Simple values
+ if (!isObject(source)) {
+ return source;
+ }
+
+ // Already copied values
+ var index = stackSource.indexOf(source);
+ if (index !== -1) {
+ return stackDest[index];
+ }
+
+ if (isWindow(source) || isScope(source)) {
+ throw ngMinErr('cpws',
+ 'Can\'t copy! Making copies of Window or Scope instances is not supported.');
+ }
+
+ var needsRecurse = false;
+ var destination = copyType(source);
+
+ if (destination === undefined) {
+ destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
+ needsRecurse = true;
+ }
+
+ stackSource.push(source);
+ stackDest.push(destination);
+
+ return needsRecurse
+ ? copyRecurse(source, destination, maxDepth)
+ : destination;
+ }
+
+ function copyType(source) {
+ switch (toString.call(source)) {
+ case '[object Int8Array]':
+ case '[object Int16Array]':
+ case '[object Int32Array]':
+ case '[object Float32Array]':
+ case '[object Float64Array]':
+ case '[object Uint8Array]':
+ case '[object Uint8ClampedArray]':
+ case '[object Uint16Array]':
+ case '[object Uint32Array]':
+ return new source.constructor(copyElement(source.buffer), source.byteOffset, source.length);
+
+ case '[object ArrayBuffer]':
+ // Support: IE10
+ if (!source.slice) {
+ // If we're in this case we know the environment supports ArrayBuffer
+ /* eslint-disable no-undef */
+ var copied = new ArrayBuffer(source.byteLength);
+ new Uint8Array(copied).set(new Uint8Array(source));
+ /* eslint-enable */
+ return copied;
+ }
+ return source.slice(0);
+
+ case '[object Boolean]':
+ case '[object Number]':
+ case '[object String]':
+ case '[object Date]':
+ return new source.constructor(source.valueOf());
+
+ case '[object RegExp]':
+ var re = new RegExp(source.source, source.toString().match(/[^/]*$/)[0]);
+ re.lastIndex = source.lastIndex;
+ return re;
+
+ case '[object Blob]':
+ return new source.constructor([source], {type: source.type});
+ }
+
+ if (isFunction(source.cloneNode)) {
+ return source.cloneNode(true);
+ }
+ }
+}
+
+
+// eslint-disable-next-line no-self-compare
+function simpleCompare(a, b) { return a === b || (a !== a && b !== b); }
+
+
+/**
+ * @ngdoc function
+ * @name angular.equals
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if two objects or two values are equivalent. Supports value types, regular
+ * expressions, arrays and objects.
+ *
+ * Two objects or values are considered equivalent if at least one of the following is true:
+ *
+ * * Both objects or values pass `===` comparison.
+ * * Both objects or values are of the same type and all of their properties are equal by
+ * comparing them with `angular.equals`.
+ * * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
+ * * Both values represent the same regular expression (In JavaScript,
+ * /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
+ * representation matches).
+ *
+ * During a property comparison, properties of `function` type and properties with names
+ * that begin with `$` are ignored.
+ *
+ * Scope and DOMWindow objects are being compared only by identify (`===`).
+ *
+ * @param {*} o1 Object or value to compare.
+ * @param {*} o2 Object or value to compare.
+ * @returns {boolean} True if arguments are equal.
+ *
+ * @example
+ <example module="equalsExample" name="equalsExample">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <form novalidate>
+ <h3>User 1</h3>
+ Name: <input type="text" ng-model="user1.name">
+ Age: <input type="number" ng-model="user1.age">
+
+ <h3>User 2</h3>
+ Name: <input type="text" ng-model="user2.name">
+ Age: <input type="number" ng-model="user2.age">
+
+ <div>
+ <br/>
+ <input type="button" value="Compare" ng-click="compare()">
+ </div>
+ User 1: <pre>{{user1 | json}}</pre>
+ User 2: <pre>{{user2 | json}}</pre>
+ Equal: <pre>{{result}}</pre>
+ </form>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('equalsExample', []).controller('ExampleController', ['$scope', function($scope) {
+ $scope.user1 = {};
+ $scope.user2 = {};
+ $scope.compare = function() {
+ $scope.result = angular.equals($scope.user1, $scope.user2);
+ };
+ }]);
+ </file>
+ </example>
+ */
+function equals(o1, o2) {
+ if (o1 === o2) return true;
+ if (o1 === null || o2 === null) return false;
+ // eslint-disable-next-line no-self-compare
+ if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
+ var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
+ if (t1 === t2 && t1 === 'object') {
+ if (isArray(o1)) {
+ if (!isArray(o2)) return false;
+ if ((length = o1.length) === o2.length) {
+ for (key = 0; key < length; key++) {
+ if (!equals(o1[key], o2[key])) return false;
+ }
+ return true;
+ }
+ } else if (isDate(o1)) {
+ if (!isDate(o2)) return false;
+ return simpleCompare(o1.getTime(), o2.getTime());
+ } else if (isRegExp(o1)) {
+ if (!isRegExp(o2)) return false;
+ return o1.toString() === o2.toString();
+ } else {
+ if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
+ isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
+ keySet = createMap();
+ for (key in o1) {
+ if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
+ if (!equals(o1[key], o2[key])) return false;
+ keySet[key] = true;
+ }
+ for (key in o2) {
+ if (!(key in keySet) &&
+ key.charAt(0) !== '$' &&
+ isDefined(o2[key]) &&
+ !isFunction(o2[key])) return false;
+ }
+ return true;
+ }
+ }
+ return false;
+}
+
+var csp = function() {
+ if (!isDefined(csp.rules)) {
+
+
+ var ngCspElement = (window.document.querySelector('[ng-csp]') ||
+ window.document.querySelector('[data-ng-csp]'));
+
+ if (ngCspElement) {
+ var ngCspAttribute = ngCspElement.getAttribute('ng-csp') ||
+ ngCspElement.getAttribute('data-ng-csp');
+ csp.rules = {
+ noUnsafeEval: !ngCspAttribute || (ngCspAttribute.indexOf('no-unsafe-eval') !== -1),
+ noInlineStyle: !ngCspAttribute || (ngCspAttribute.indexOf('no-inline-style') !== -1)
+ };
+ } else {
+ csp.rules = {
+ noUnsafeEval: noUnsafeEval(),
+ noInlineStyle: false
+ };
+ }
+ }
+
+ return csp.rules;
+
+ function noUnsafeEval() {
+ try {
+ // eslint-disable-next-line no-new, no-new-func
+ new Function('');
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+};
+
+/**
+ * @ngdoc directive
+ * @module ng
+ * @name ngJq
+ *
+ * @element ANY
+ * @param {string=} ngJq the name of the library available under `window`
+ * to be used for angular.element
+ * @description
+ * Use this directive to force the angular.element library. This should be
+ * used to force either jqLite by leaving ng-jq blank or setting the name of
+ * the jquery variable under window (eg. jQuery).
+ *
+ * Since AngularJS looks for this directive when it is loaded (doesn't wait for the
+ * DOMContentLoaded event), it must be placed on an element that comes before the script
+ * which loads angular. Also, only the first instance of `ng-jq` will be used and all
+ * others ignored.
+ *
+ * @example
+ * This example shows how to force jqLite using the `ngJq` directive to the `html` tag.
+ ```html
+ <!doctype html>
+ <html ng-app ng-jq>
+ ...
+ ...
+ </html>
+ ```
+ * @example
+ * This example shows how to use a jQuery based library of a different name.
+ * The library name must be available at the top most 'window'.
+ ```html
+ <!doctype html>
+ <html ng-app ng-jq="jQueryLib">
+ ...
+ ...
+ </html>
+ ```
+ */
+var jq = function() {
+ if (isDefined(jq.name_)) return jq.name_;
+ var el;
+ var i, ii = ngAttrPrefixes.length, prefix, name;
+ for (i = 0; i < ii; ++i) {
+ prefix = ngAttrPrefixes[i];
+ el = window.document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]');
+ if (el) {
+ name = el.getAttribute(prefix + 'jq');
+ break;
+ }
+ }
+
+ return (jq.name_ = name);
+};
+
+function concat(array1, array2, index) {
+ return array1.concat(slice.call(array2, index));
+}
+
+function sliceArgs(args, startIndex) {
+ return slice.call(args, startIndex || 0);
+}
+
+
+/**
+ * @ngdoc function
+ * @name angular.bind
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
+ * `fn`). You can supply optional `args` that are prebound to the function. This feature is also
+ * known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
+ * distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
+ *
+ * @param {Object} self Context which `fn` should be evaluated in.
+ * @param {function()} fn Function to be bound.
+ * @param {...*} args Optional arguments to be prebound to the `fn` function call.
+ * @returns {function()} Function that wraps the `fn` with all the specified bindings.
+ */
+function bind(self, fn) {
+ var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
+ if (isFunction(fn) && !(fn instanceof RegExp)) {
+ return curryArgs.length
+ ? function() {
+ return arguments.length
+ ? fn.apply(self, concat(curryArgs, arguments, 0))
+ : fn.apply(self, curryArgs);
+ }
+ : function() {
+ return arguments.length
+ ? fn.apply(self, arguments)
+ : fn.call(self);
+ };
+ } else {
+ // In IE, native methods are not functions so they cannot be bound (note: they don't need to be).
+ return fn;
+ }
+}
+
+
+function toJsonReplacer(key, value) {
+ var val = value;
+
+ if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
+ val = undefined;
+ } else if (isWindow(value)) {
+ val = '$WINDOW';
+ } else if (value && window.document === value) {
+ val = '$DOCUMENT';
+ } else if (isScope(value)) {
+ val = '$SCOPE';
+ }
+
+ return val;
+}
+
+
+/**
+ * @ngdoc function
+ * @name angular.toJson
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
+ * stripped since AngularJS uses this notation internally.
+ *
+ * @param {Object|Array|Date|string|number|boolean} obj Input to be serialized into JSON.
+ * @param {boolean|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace.
+ * If set to an integer, the JSON output will contain that many spaces per indentation.
+ * @returns {string|undefined} JSON-ified string representing `obj`.
+ * @knownIssue
+ *
+ * The Safari browser throws a `RangeError` instead of returning `null` when it tries to stringify a `Date`
+ * object with an invalid date value. The only reliable way to prevent this is to monkeypatch the
+ * `Date.prototype.toJSON` method as follows:
+ *
+ * ```
+ * var _DatetoJSON = Date.prototype.toJSON;
+ * Date.prototype.toJSON = function() {
+ * try {
+ * return _DatetoJSON.call(this);
+ * } catch(e) {
+ * if (e instanceof RangeError) {
+ * return null;
+ * }
+ * throw e;
+ * }
+ * };
+ * ```
+ *
+ * See https://github.com/angular/angular.js/pull/14221 for more information.
+ */
+function toJson(obj, pretty) {
+ if (isUndefined(obj)) return undefined;
+ if (!isNumber(pretty)) {
+ pretty = pretty ? 2 : null;
+ }
+ return JSON.stringify(obj, toJsonReplacer, pretty);
+}
+
+
+/**
+ * @ngdoc function
+ * @name angular.fromJson
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Deserializes a JSON string.
+ *
+ * @param {string} json JSON string to deserialize.
+ * @returns {Object|Array|string|number} Deserialized JSON string.
+ */
+function fromJson(json) {
+ return isString(json)
+ ? JSON.parse(json)
+ : json;
+}
+
+
+var ALL_COLONS = /:/g;
+function timezoneToOffset(timezone, fallback) {
+ // Support: IE 9-11 only, Edge 13-15+
+ // IE/Edge do not "understand" colon (`:`) in timezone
+ timezone = timezone.replace(ALL_COLONS, '');
+ var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
+ return isNumberNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
+}
+
+
+function addDateMinutes(date, minutes) {
+ date = new Date(date.getTime());
+ date.setMinutes(date.getMinutes() + minutes);
+ return date;
+}
+
+
+function convertTimezoneToLocal(date, timezone, reverse) {
+ reverse = reverse ? -1 : 1;
+ var dateTimezoneOffset = date.getTimezoneOffset();
+ var timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
+ return addDateMinutes(date, reverse * (timezoneOffset - dateTimezoneOffset));
+}
+
+
+/**
+ * @returns {string} Returns the string representation of the element.
+ */
+function startingTag(element) {
+ element = jqLite(element).clone().empty();
+ var elemHtml = jqLite('<div></div>').append(element).html();
+ try {
+ return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
+ elemHtml.
+ match(/^(<[^>]+>)/)[1].
+ replace(/^<([\w-]+)/, function(match, nodeName) {return '<' + lowercase(nodeName);});
+ } catch (e) {
+ return lowercase(elemHtml);
+ }
+
+}
+
+
+/////////////////////////////////////////////////
+
+/**
+ * Tries to decode the URI component without throwing an exception.
+ *
+ * @private
+ * @param str value potential URI component to check.
+ * @returns {boolean} True if `value` can be decoded
+ * with the decodeURIComponent function.
+ */
+function tryDecodeURIComponent(value) {
+ try {
+ return decodeURIComponent(value);
+ } catch (e) {
+ // Ignore any invalid uri component.
+ }
+}
+
+
+/**
+ * Parses an escaped url query string into key-value pairs.
+ * @returns {Object.<string,boolean|Array>}
+ */
+function parseKeyValue(/**string*/keyValue) {
+ var obj = {};
+ forEach((keyValue || '').split('&'), function(keyValue) {
+ var splitPoint, key, val;
+ if (keyValue) {
+ key = keyValue = keyValue.replace(/\+/g,'%20');
+ splitPoint = keyValue.indexOf('=');
+ if (splitPoint !== -1) {
+ key = keyValue.substring(0, splitPoint);
+ val = keyValue.substring(splitPoint + 1);
+ }
+ key = tryDecodeURIComponent(key);
+ if (isDefined(key)) {
+ val = isDefined(val) ? tryDecodeURIComponent(val) : true;
+ if (!hasOwnProperty.call(obj, key)) {
+ obj[key] = val;
+ } else if (isArray(obj[key])) {
+ obj[key].push(val);
+ } else {
+ obj[key] = [obj[key],val];
+ }
+ }
+ }
+ });
+ return obj;
+}
+
+function toKeyValue(obj) {
+ var parts = [];
+ forEach(obj, function(value, key) {
+ if (isArray(value)) {
+ forEach(value, function(arrayValue) {
+ parts.push(encodeUriQuery(key, true) +
+ (arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true)));
+ });
+ } else {
+ parts.push(encodeUriQuery(key, true) +
+ (value === true ? '' : '=' + encodeUriQuery(value, true)));
+ }
+ });
+ return parts.length ? parts.join('&') : '';
+}
+
+
+/**
+ * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
+ * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
+ * segments:
+ * segment = *pchar
+ * pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
+ * pct-encoded = "%" HEXDIG HEXDIG
+ * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
+ * / "*" / "+" / "," / ";" / "="
+ */
+function encodeUriSegment(val) {
+ return encodeUriQuery(val, true).
+ replace(/%26/gi, '&').
+ replace(/%3D/gi, '=').
+ replace(/%2B/gi, '+');
+}
+
+
+/**
+ * This method is intended for encoding *key* or *value* parts of query component. We need a custom
+ * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
+ * encoded per http://tools.ietf.org/html/rfc3986:
+ * query = *( pchar / "/" / "?" )
+ * pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
+ * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * pct-encoded = "%" HEXDIG HEXDIG
+ * sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
+ * / "*" / "+" / "," / ";" / "="
+ */
+function encodeUriQuery(val, pctEncodeSpaces) {
+ return encodeURIComponent(val).
+ replace(/%40/gi, '@').
+ replace(/%3A/gi, ':').
+ replace(/%24/g, '$').
+ replace(/%2C/gi, ',').
+ replace(/%3B/gi, ';').
+ replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
+}
+
+var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
+
+function getNgAttribute(element, ngAttr) {
+ var attr, i, ii = ngAttrPrefixes.length;
+ for (i = 0; i < ii; ++i) {
+ attr = ngAttrPrefixes[i] + ngAttr;
+ if (isString(attr = element.getAttribute(attr))) {
+ return attr;
+ }
+ }
+ return null;
+}
+
+function allowAutoBootstrap(document) {
+ var script = document.currentScript;
+
+ if (!script) {
+ // Support: IE 9-11 only
+ // IE does not have `document.currentScript`
+ return true;
+ }
+
+ // If the `currentScript` property has been clobbered just return false, since this indicates a probable attack
+ if (!(script instanceof window.HTMLScriptElement || script instanceof window.SVGScriptElement)) {
+ return false;
+ }
+
+ var attributes = script.attributes;
+ var srcs = [attributes.getNamedItem('src'), attributes.getNamedItem('href'), attributes.getNamedItem('xlink:href')];
+
+ return srcs.every(function(src) {
+ if (!src) {
+ return true;
+ }
+ if (!src.value) {
+ return false;
+ }
+
+ var link = document.createElement('a');
+ link.href = src.value;
+
+ if (document.location.origin === link.origin) {
+ // Same-origin resources are always allowed, even for banned URL schemes.
+ return true;
+ }
+ // Disabled bootstrapping unless angular.js was loaded from a known scheme used on the web.
+ // This is to prevent angular.js bundled with browser extensions from being used to bypass the
+ // content security policy in web pages and other browser extensions.
+ switch (link.protocol) {
+ case 'http:':
+ case 'https:':
+ case 'ftp:':
+ case 'blob:':
+ case 'file:':
+ case 'data:':
+ return true;
+ default:
+ return false;
+ }
+ });
+}
+
+// Cached as it has to run during loading so that document.currentScript is available.
+var isAutoBootstrapAllowed = allowAutoBootstrap(window.document);
+
+/**
+ * @ngdoc directive
+ * @name ngApp
+ * @module ng
+ *
+ * @element ANY
+ * @param {angular.Module} ngApp an optional application
+ * {@link angular.module module} name to load.
+ * @param {boolean=} ngStrictDi if this attribute is present on the app element, the injector will be
+ * created in "strict-di" mode. This means that the application will fail to invoke functions which
+ * do not use explicit function annotation (and are thus unsuitable for minification), as described
+ * in {@link guide/di the Dependency Injection guide}, and useful debugging info will assist in
+ * tracking down the root of these bugs.
+ *
+ * @description
+ *
+ * Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
+ * designates the **root element** of the application and is typically placed near the root element
+ * of the page - e.g. on the `<body>` or `<html>` tags.
+ *
+ * There are a few things to keep in mind when using `ngApp`:
+ * - only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`
+ * found in the document will be used to define the root element to auto-bootstrap as an
+ * application. To run multiple applications in an HTML document you must manually bootstrap them using
+ * {@link angular.bootstrap} instead.
+ * - AngularJS applications cannot be nested within each other.
+ * - Do not use a directive that uses {@link ng.$compile#transclusion transclusion} on the same element as `ngApp`.
+ * This includes directives such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and
+ * {@link ngRoute.ngView `ngView`}.
+ * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
+ * causing animations to stop working and making the injector inaccessible from outside the app.
+ *
+ * You can specify an **AngularJS module** to be used as the root module for the application. This
+ * module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It
+ * should contain the application code needed or have dependencies on other modules that will
+ * contain the code. See {@link angular.module} for more information.
+ *
+ * In the example below if the `ngApp` directive were not placed on the `html` element then the
+ * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
+ * would not be resolved to `3`.
+ *
+ * @example
+ *
+ * ### Simple Usage
+ *
+ * `ngApp` is the easiest, and most common way to bootstrap an application.
+ *
+ <example module="ngAppDemo" name="ng-app">
+ <file name="index.html">
+ <div ng-controller="ngAppDemoController">
+ I can add: {{a}} + {{b}} = {{ a+b }}
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
+ $scope.a = 1;
+ $scope.b = 2;
+ });
+ </file>
+ </example>
+ *
+ * @example
+ *
+ * ### With `ngStrictDi`
+ *
+ * Using `ngStrictDi`, you would see something like this:
+ *
+ <example ng-app-included="true" name="strict-di">
+ <file name="index.html">
+ <div ng-app="ngAppStrictDemo" ng-strict-di>
+ <div ng-controller="GoodController1">
+ I can add: {{a}} + {{b}} = {{ a+b }}
+
+ <p>This renders because the controller does not fail to
+ instantiate, by using explicit annotation style (see
+ script.js for details)
+ </p>
+ </div>
+
+ <div ng-controller="GoodController2">
+ Name: <input ng-model="name"><br />
+ Hello, {{name}}!
+
+ <p>This renders because the controller does not fail to
+ instantiate, by using explicit annotation style
+ (see script.js for details)
+ </p>
+ </div>
+
+ <div ng-controller="BadController">
+ I can add: {{a}} + {{b}} = {{ a+b }}
+
+ <p>The controller could not be instantiated, due to relying
+ on automatic function annotations (which are disabled in
+ strict mode). As such, the content of this section is not
+ interpolated, and there should be an error in your web console.
+ </p>
+ </div>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('ngAppStrictDemo', [])
+ // BadController will fail to instantiate, due to relying on automatic function annotation,
+ // rather than an explicit annotation
+ .controller('BadController', function($scope) {
+ $scope.a = 1;
+ $scope.b = 2;
+ })
+ // Unlike BadController, GoodController1 and GoodController2 will not fail to be instantiated,
+ // due to using explicit annotations using the array style and $inject property, respectively.
+ .controller('GoodController1', ['$scope', function($scope) {
+ $scope.a = 1;
+ $scope.b = 2;
+ }])
+ .controller('GoodController2', GoodController2);
+ function GoodController2($scope) {
+ $scope.name = 'World';
+ }
+ GoodController2.$inject = ['$scope'];
+ </file>
+ <file name="style.css">
+ div[ng-controller] {
+ margin-bottom: 1em;
+ -webkit-border-radius: 4px;
+ border-radius: 4px;
+ border: 1px solid;
+ padding: .5em;
+ }
+ div[ng-controller^=Good] {
+ border-color: #d6e9c6;
+ background-color: #dff0d8;
+ color: #3c763d;
+ }
+ div[ng-controller^=Bad] {
+ border-color: #ebccd1;
+ background-color: #f2dede;
+ color: #a94442;
+ margin-bottom: 0;
+ }
+ </file>
+ </example>
+ */
+function angularInit(element, bootstrap) {
+ var appElement,
+ module,
+ config = {};
+
+ // The element `element` has priority over any other element.
+ forEach(ngAttrPrefixes, function(prefix) {
+ var name = prefix + 'app';
+
+ if (!appElement && element.hasAttribute && element.hasAttribute(name)) {
+ appElement = element;
+ module = element.getAttribute(name);
+ }
+ });
+ forEach(ngAttrPrefixes, function(prefix) {
+ var name = prefix + 'app';
+ var candidate;
+
+ if (!appElement && (candidate = element.querySelector('[' + name.replace(':', '\\:') + ']'))) {
+ appElement = candidate;
+ module = candidate.getAttribute(name);
+ }
+ });
+ if (appElement) {
+ if (!isAutoBootstrapAllowed) {
+ window.console.error('AngularJS: disabling automatic bootstrap. <script> protocol indicates ' +
+ 'an extension, document.location.href does not match.');
+ return;
+ }
+ config.strictDi = getNgAttribute(appElement, 'strict-di') !== null;
+ bootstrap(appElement, module ? [module] : [], config);
+ }
+}
+
+/**
+ * @ngdoc function
+ * @name angular.bootstrap
+ * @module ng
+ * @description
+ * Use this function to manually start up AngularJS application.
+ *
+ * For more information, see the {@link guide/bootstrap Bootstrap guide}.
+ *
+ * AngularJS will detect if it has been loaded into the browser more than once and only allow the
+ * first loaded script to be bootstrapped and will report a warning to the browser console for
+ * each of the subsequent scripts. This prevents strange results in applications, where otherwise
+ * multiple instances of AngularJS try to work on the DOM.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** Protractor based end-to-end tests cannot use this function to bootstrap manually.
+ * They must use {@link ng.directive:ngApp ngApp}.
+ * </div>
+ *
+ * <div class="alert alert-warning">
+ * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
+ * such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
+ * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
+ * causing animations to stop working and making the injector inaccessible from outside the app.
+ * </div>
+ *
+ * ```html
+ * <!doctype html>
+ * <html>
+ * <body>
+ * <div ng-controller="WelcomeController">
+ * {{greeting}}
+ * </div>
+ *
+ * <script src="angular.js"></script>
+ * <script>
+ * var app = angular.module('demo', [])
+ * .controller('WelcomeController', function($scope) {
+ * $scope.greeting = 'Welcome!';
+ * });
+ * angular.bootstrap(document, ['demo']);
+ * </script>
+ * </body>
+ * </html>
+ * ```
+ *
+ * @param {DOMElement} element DOM element which is the root of AngularJS application.
+ * @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
+ * Each item in the array should be the name of a predefined module or a (DI annotated)
+ * function that will be invoked by the injector as a `config` block.
+ * See: {@link angular.module modules}
+ * @param {Object=} config an object for defining configuration options for the application. The
+ * following keys are supported:
+ *
+ * * `strictDi` - disable automatic function annotation for the application. This is meant to
+ * assist in finding bugs which break minified code. Defaults to `false`.
+ *
+ * @returns {auto.$injector} Returns the newly created injector for this app.
+ */
+function bootstrap(element, modules, config) {
+ if (!isObject(config)) config = {};
+ var defaultConfig = {
+ strictDi: false
+ };
+ config = extend(defaultConfig, config);
+ var doBootstrap = function() {
+ element = jqLite(element);
+
+ if (element.injector()) {
+ var tag = (element[0] === window.document) ? 'document' : startingTag(element);
+ // Encode angle brackets to prevent input from being sanitized to empty string #8683.
+ throw ngMinErr(
+ 'btstrpd',
+ 'App already bootstrapped with this element \'{0}\'',
+ tag.replace(/</,'<').replace(/>/,'>'));
+ }
+
+ modules = modules || [];
+ modules.unshift(['$provide', function($provide) {
+ $provide.value('$rootElement', element);
+ }]);
+
+ if (config.debugInfoEnabled) {
+ // Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`.
+ modules.push(['$compileProvider', function($compileProvider) {
+ $compileProvider.debugInfoEnabled(true);
+ }]);
+ }
+
+ modules.unshift('ng');
+ var injector = createInjector(modules, config.strictDi);
+ injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
+ function bootstrapApply(scope, element, compile, injector) {
+ scope.$apply(function() {
+ element.data('$injector', injector);
+ compile(element)(scope);
+ });
+ }]
+ );
+ return injector;
+ };
+
+ var NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/;
+ var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
+
+ if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) {
+ config.debugInfoEnabled = true;
+ window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, '');
+ }
+
+ if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
+ return doBootstrap();
+ }
+
+ window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');
+ angular.resumeBootstrap = function(extraModules) {
+ forEach(extraModules, function(module) {
+ modules.push(module);
+ });
+ return doBootstrap();
+ };
+
+ if (isFunction(angular.resumeDeferredBootstrap)) {
+ angular.resumeDeferredBootstrap();
+ }
+}
+
+/**
+ * @ngdoc function
+ * @name angular.reloadWithDebugInfo
+ * @module ng
+ * @description
+ * Use this function to reload the current application with debug information turned on.
+ * This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`.
+ *
+ * See {@link ng.$compileProvider#debugInfoEnabled} for more.
+ */
+function reloadWithDebugInfo() {
+ window.name = 'NG_ENABLE_DEBUG_INFO!' + window.name;
+ window.location.reload();
+}
+
+/**
+ * @name angular.getTestability
+ * @module ng
+ * @description
+ * Get the testability service for the instance of AngularJS on the given
+ * element.
+ * @param {DOMElement} element DOM element which is the root of AngularJS application.
+ */
+function getTestability(rootElement) {
+ var injector = angular.element(rootElement).injector();
+ if (!injector) {
+ throw ngMinErr('test',
+ 'no injector found for element argument to getTestability');
+ }
+ return injector.get('$$testability');
+}
+
+var SNAKE_CASE_REGEXP = /[A-Z]/g;
+function snake_case(name, separator) {
+ separator = separator || '_';
+ return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
+ return (pos ? separator : '') + letter.toLowerCase();
+ });
+}
+
+var bindJQueryFired = false;
+function bindJQuery() {
+ var originalCleanData;
+
+ if (bindJQueryFired) {
+ return;
+ }
+
+ // bind to jQuery if present;
+ var jqName = jq();
+ jQuery = isUndefined(jqName) ? __webpack_provided_window_dot_jQuery : // use jQuery (if present)
+ !jqName ? undefined : // use jqLite
+ window[jqName]; // use jQuery specified by `ngJq`
+
+ // Use jQuery if it exists with proper functionality, otherwise default to us.
+ // AngularJS 1.2+ requires jQuery 1.7+ for on()/off() support.
+ // AngularJS 1.3+ technically requires at least jQuery 2.1+ but it may work with older
+ // versions. It will not work for sure with jQuery <1.7, though.
+ if (jQuery && jQuery.fn.on) {
+ jqLite = jQuery;
+ extend(jQuery.fn, {
+ scope: JQLitePrototype.scope,
+ isolateScope: JQLitePrototype.isolateScope,
+ controller: /** @type {?} */ (JQLitePrototype).controller,
+ injector: JQLitePrototype.injector,
+ inheritedData: JQLitePrototype.inheritedData
+ });
+ } else {
+ jqLite = JQLite;
+ }
+
+ // All nodes removed from the DOM via various jqLite/jQuery APIs like .remove()
+ // are passed through jqLite/jQuery.cleanData. Monkey-patch this method to fire
+ // the $destroy event on all removed nodes.
+ originalCleanData = jqLite.cleanData;
+ jqLite.cleanData = function(elems) {
+ var events;
+ for (var i = 0, elem; (elem = elems[i]) != null; i++) {
+ events = (jqLite._data(elem) || {}).events;
+ if (events && events.$destroy) {
+ jqLite(elem).triggerHandler('$destroy');
+ }
+ }
+ originalCleanData(elems);
+ };
+
+ angular.element = jqLite;
+
+ // Prevent double-proxying.
+ bindJQueryFired = true;
+}
+
+/**
+ * @ngdoc function
+ * @name angular.UNSAFE_restoreLegacyJqLiteXHTMLReplacement
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Restores the pre-1.8 behavior of jqLite that turns XHTML-like strings like
+ * `<div /><span />` to `<div></div><span></span>` instead of `<div><span></span></div>`.
+ * The new behavior is a security fix. Thus, if you need to call this function, please try to adjust
+ * your code for this change and remove your use of this function as soon as possible.
+
+ * Note that this only patches jqLite. If you use jQuery 3.5.0 or newer, please read the
+ * [jQuery 3.5 upgrade guide](https://jquery.com/upgrade-guide/3.5/) for more details
+ * about the workarounds.
+ */
+function UNSAFE_restoreLegacyJqLiteXHTMLReplacement() {
+ JQLite.legacyXHTMLReplacement = true;
+}
+
+/**
+ * throw error if the argument is falsy.
+ */
+function assertArg(arg, name, reason) {
+ if (!arg) {
+ throw ngMinErr('areq', 'Argument \'{0}\' is {1}', (name || '?'), (reason || 'required'));
+ }
+ return arg;
+}
+
+function assertArgFn(arg, name, acceptArrayAnnotation) {
+ if (acceptArrayAnnotation && isArray(arg)) {
+ arg = arg[arg.length - 1];
+ }
+
+ assertArg(isFunction(arg), name, 'not a function, got ' +
+ (arg && typeof arg === 'object' ? arg.constructor.name || 'Object' : typeof arg));
+ return arg;
+}
+
+/**
+ * throw error if the name given is hasOwnProperty
+ * @param {String} name the name to test
+ * @param {String} context the context in which the name is used, such as module or directive
+ */
+function assertNotHasOwnProperty(name, context) {
+ if (name === 'hasOwnProperty') {
+ throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
+ }
+}
+
+/**
+ * Return the value accessible from the object by path. Any undefined traversals are ignored
+ * @param {Object} obj starting object
+ * @param {String} path path to traverse
+ * @param {boolean} [bindFnToScope=true]
+ * @returns {Object} value as accessible by path
+ */
+//TODO(misko): this function needs to be removed
+function getter(obj, path, bindFnToScope) {
+ if (!path) return obj;
+ var keys = path.split('.');
+ var key;
+ var lastInstance = obj;
+ var len = keys.length;
+
+ for (var i = 0; i < len; i++) {
+ key = keys[i];
+ if (obj) {
+ obj = (lastInstance = obj)[key];
+ }
+ }
+ if (!bindFnToScope && isFunction(obj)) {
+ return bind(lastInstance, obj);
+ }
+ return obj;
+}
+
+/**
+ * Return the DOM siblings between the first and last node in the given array.
+ * @param {Array} array like object
+ * @returns {Array} the inputted object or a jqLite collection containing the nodes
+ */
+function getBlockNodes(nodes) {
+ // TODO(perf): update `nodes` instead of creating a new object?
+ var node = nodes[0];
+ var endNode = nodes[nodes.length - 1];
+ var blockNodes;
+
+ for (var i = 1; node !== endNode && (node = node.nextSibling); i++) {
+ if (blockNodes || nodes[i] !== node) {
+ if (!blockNodes) {
+ blockNodes = jqLite(slice.call(nodes, 0, i));
+ }
+ blockNodes.push(node);
+ }
+ }
+
+ return blockNodes || nodes;
+}
+
+
+/**
+ * Creates a new object without a prototype. This object is useful for lookup without having to
+ * guard against prototypically inherited properties via hasOwnProperty.
+ *
+ * Related micro-benchmarks:
+ * - http://jsperf.com/object-create2
+ * - http://jsperf.com/proto-map-lookup/2
+ * - http://jsperf.com/for-in-vs-object-keys2
+ *
+ * @returns {Object}
+ */
+function createMap() {
+ return Object.create(null);
+}
+
+function stringify(value) {
+ if (value == null) { // null || undefined
+ return '';
+ }
+ switch (typeof value) {
+ case 'string':
+ break;
+ case 'number':
+ value = '' + value;
+ break;
+ default:
+ if (hasCustomToString(value) && !isArray(value) && !isDate(value)) {
+ value = value.toString();
+ } else {
+ value = toJson(value);
+ }
+ }
+
+ return value;
+}
+
+var NODE_TYPE_ELEMENT = 1;
+var NODE_TYPE_ATTRIBUTE = 2;
+var NODE_TYPE_TEXT = 3;
+var NODE_TYPE_COMMENT = 8;
+var NODE_TYPE_DOCUMENT = 9;
+var NODE_TYPE_DOCUMENT_FRAGMENT = 11;
+
+/**
+ * @ngdoc type
+ * @name angular.Module
+ * @module ng
+ * @description
+ *
+ * Interface for configuring AngularJS {@link angular.module modules}.
+ */
+
+function setupModuleLoader(window) {
+
+ var $injectorMinErr = minErr('$injector');
+ var ngMinErr = minErr('ng');
+
+ function ensure(obj, name, factory) {
+ return obj[name] || (obj[name] = factory());
+ }
+
+ var angular = ensure(window, 'angular', Object);
+
+ // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
+ angular.$$minErr = angular.$$minErr || minErr;
+
+ return ensure(angular, 'module', function() {
+ /** @type {Object.<string, angular.Module>} */
+ var modules = {};
+
+ /**
+ * @ngdoc function
+ * @name angular.module
+ * @module ng
+ * @description
+ *
+ * The `angular.module` is a global place for creating, registering and retrieving AngularJS
+ * modules.
+ * All modules (AngularJS core or 3rd party) that should be available to an application must be
+ * registered using this mechanism.
+ *
+ * Passing one argument retrieves an existing {@link angular.Module},
+ * whereas passing more than one argument creates a new {@link angular.Module}
+ *
+ *
+ * # Module
+ *
+ * A module is a collection of services, directives, controllers, filters, and configuration information.
+ * `angular.module` is used to configure the {@link auto.$injector $injector}.
+ *
+ * ```js
+ * // Create a new module
+ * var myModule = angular.module('myModule', []);
+ *
+ * // register a new service
+ * myModule.value('appName', 'MyCoolApp');
+ *
+ * // configure existing services inside initialization blocks.
+ * myModule.config(['$locationProvider', function($locationProvider) {
+ * // Configure existing providers
+ * $locationProvider.hashPrefix('!');
+ * }]);
+ * ```
+ *
+ * Then you can create an injector and load your modules like this:
+ *
+ * ```js
+ * var injector = angular.injector(['ng', 'myModule'])
+ * ```
+ *
+ * However it's more likely that you'll just use
+ * {@link ng.directive:ngApp ngApp} or
+ * {@link angular.bootstrap} to simplify this process for you.
+ *
+ * @param {!string} name The name of the module to create or retrieve.
+ * @param {!Array.<string>=} requires If specified then new module is being created. If
+ * unspecified then the module is being retrieved for further configuration.
+ * @param {Function=} configFn Optional configuration function for the module. Same as
+ * {@link angular.Module#config Module#config()}.
+ * @returns {angular.Module} new module with the {@link angular.Module} api.
+ */
+ return function module(name, requires, configFn) {
+
+ var info = {};
+
+ var assertNotHasOwnProperty = function(name, context) {
+ if (name === 'hasOwnProperty') {
+ throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
+ }
+ };
+
+ assertNotHasOwnProperty(name, 'module');
+ if (requires && modules.hasOwnProperty(name)) {
+ modules[name] = null;
+ }
+ return ensure(modules, name, function() {
+ if (!requires) {
+ throw $injectorMinErr('nomod', 'Module \'{0}\' is not available! You either misspelled ' +
+ 'the module name or forgot to load it. If registering a module ensure that you ' +
+ 'specify the dependencies as the second argument.', name);
+ }
+
+ /** @type {!Array.<Array.<*>>} */
+ var invokeQueue = [];
+
+ /** @type {!Array.<Function>} */
+ var configBlocks = [];
+
+ /** @type {!Array.<Function>} */
+ var runBlocks = [];
+
+ var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
+
+ /** @type {angular.Module} */
+ var moduleInstance = {
+ // Private state
+ _invokeQueue: invokeQueue,
+ _configBlocks: configBlocks,
+ _runBlocks: runBlocks,
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#info
+ * @module ng
+ *
+ * @param {Object=} info Information about the module
+ * @returns {Object|Module} The current info object for this module if called as a getter,
+ * or `this` if called as a setter.
+ *
+ * @description
+ * Read and write custom information about this module.
+ * For example you could put the version of the module in here.
+ *
+ * ```js
+ * angular.module('myModule', []).info({ version: '1.0.0' });
+ * ```
+ *
+ * The version could then be read back out by accessing the module elsewhere:
+ *
+ * ```
+ * var version = angular.module('myModule').info().version;
+ * ```
+ *
+ * You can also retrieve this information during runtime via the
+ * {@link $injector#modules `$injector.modules`} property:
+ *
+ * ```js
+ * var version = $injector.modules['myModule'].info().version;
+ * ```
+ */
+ info: function(value) {
+ if (isDefined(value)) {
+ if (!isObject(value)) throw ngMinErr('aobj', 'Argument \'{0}\' must be an object', 'value');
+ info = value;
+ return this;
+ }
+ return info;
+ },
+
+ /**
+ * @ngdoc property
+ * @name angular.Module#requires
+ * @module ng
+ *
+ * @description
+ * Holds the list of modules which the injector will load before the current module is
+ * loaded.
+ */
+ requires: requires,
+
+ /**
+ * @ngdoc property
+ * @name angular.Module#name
+ * @module ng
+ *
+ * @description
+ * Name of the module.
+ */
+ name: name,
+
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#provider
+ * @module ng
+ * @param {string} name service name
+ * @param {Function} providerType Construction function for creating new instance of the
+ * service.
+ * @description
+ * See {@link auto.$provide#provider $provide.provider()}.
+ */
+ provider: invokeLaterAndSetModuleName('$provide', 'provider'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#factory
+ * @module ng
+ * @param {string} name service name
+ * @param {Function} providerFunction Function for creating new instance of the service.
+ * @description
+ * See {@link auto.$provide#factory $provide.factory()}.
+ */
+ factory: invokeLaterAndSetModuleName('$provide', 'factory'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#service
+ * @module ng
+ * @param {string} name service name
+ * @param {Function} constructor A constructor function that will be instantiated.
+ * @description
+ * See {@link auto.$provide#service $provide.service()}.
+ */
+ service: invokeLaterAndSetModuleName('$provide', 'service'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#value
+ * @module ng
+ * @param {string} name service name
+ * @param {*} object Service instance object.
+ * @description
+ * See {@link auto.$provide#value $provide.value()}.
+ */
+ value: invokeLater('$provide', 'value'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#constant
+ * @module ng
+ * @param {string} name constant name
+ * @param {*} object Constant value.
+ * @description
+ * Because the constants are fixed, they get applied before other provide methods.
+ * See {@link auto.$provide#constant $provide.constant()}.
+ */
+ constant: invokeLater('$provide', 'constant', 'unshift'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#decorator
+ * @module ng
+ * @param {string} name The name of the service to decorate.
+ * @param {Function} decorFn This function will be invoked when the service needs to be
+ * instantiated and should return the decorated service instance.
+ * @description
+ * See {@link auto.$provide#decorator $provide.decorator()}.
+ */
+ decorator: invokeLaterAndSetModuleName('$provide', 'decorator', configBlocks),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#animation
+ * @module ng
+ * @param {string} name animation name
+ * @param {Function} animationFactory Factory function for creating new instance of an
+ * animation.
+ * @description
+ *
+ * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
+ *
+ *
+ * Defines an animation hook that can be later used with
+ * {@link $animate $animate} service and directives that use this service.
+ *
+ * ```js
+ * module.animation('.animation-name', function($inject1, $inject2) {
+ * return {
+ * eventName : function(element, done) {
+ * //code to run the animation
+ * //once complete, then run done()
+ * return function cancellationFunction(element) {
+ * //code to cancel the animation
+ * }
+ * }
+ * }
+ * })
+ * ```
+ *
+ * See {@link ng.$animateProvider#register $animateProvider.register()} and
+ * {@link ngAnimate ngAnimate module} for more information.
+ */
+ animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#filter
+ * @module ng
+ * @param {string} name Filter name - this must be a valid AngularJS expression identifier
+ * @param {Function} filterFactory Factory function for creating new instance of filter.
+ * @description
+ * See {@link ng.$filterProvider#register $filterProvider.register()}.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
+ * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
+ * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
+ * (`myapp_subsection_filterx`).
+ * </div>
+ */
+ filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#controller
+ * @module ng
+ * @param {string|Object} name Controller name, or an object map of controllers where the
+ * keys are the names and the values are the constructors.
+ * @param {Function} constructor Controller constructor function.
+ * @description
+ * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
+ */
+ controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#directive
+ * @module ng
+ * @param {string|Object} name Directive name, or an object map of directives where the
+ * keys are the names and the values are the factories.
+ * @param {Function} directiveFactory Factory function for creating new instance of
+ * directives.
+ * @description
+ * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
+ */
+ directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#component
+ * @module ng
+ * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
+ * or an object map of components where the keys are the names and the values are the component definition objects.
+ * @param {Object} options Component definition object (a simplified
+ * {@link ng.$compile#directive-definition-object directive definition object})
+ *
+ * @description
+ * See {@link ng.$compileProvider#component $compileProvider.component()}.
+ */
+ component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#config
+ * @module ng
+ * @param {Function} configFn Execute this function on module load. Useful for service
+ * configuration.
+ * @description
+ * Use this method to configure services by injecting their
+ * {@link angular.Module#provider `providers`}, e.g. for adding routes to the
+ * {@link ngRoute.$routeProvider $routeProvider}.
+ *
+ * Note that you can only inject {@link angular.Module#provider `providers`} and
+ * {@link angular.Module#constant `constants`} into this function.
+ *
+ * For more about how to configure services, see
+ * {@link providers#provider-recipe Provider Recipe}.
+ */
+ config: config,
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#run
+ * @module ng
+ * @param {Function} initializationFn Execute this function after injector creation.
+ * Useful for application initialization.
+ * @description
+ * Use this method to register work which should be performed when the injector is done
+ * loading all modules.
+ */
+ run: function(block) {
+ runBlocks.push(block);
+ return this;
+ }
+ };
+
+ if (configFn) {
+ config(configFn);
+ }
+
+ return moduleInstance;
+
+ /**
+ * @param {string} provider
+ * @param {string} method
+ * @param {String=} insertMethod
+ * @returns {angular.Module}
+ */
+ function invokeLater(provider, method, insertMethod, queue) {
+ if (!queue) queue = invokeQueue;
+ return function() {
+ queue[insertMethod || 'push']([provider, method, arguments]);
+ return moduleInstance;
+ };
+ }
+
+ /**
+ * @param {string} provider
+ * @param {string} method
+ * @returns {angular.Module}
+ */
+ function invokeLaterAndSetModuleName(provider, method, queue) {
+ if (!queue) queue = invokeQueue;
+ return function(recipeName, factoryFunction) {
+ if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
+ queue.push([provider, method, arguments]);
+ return moduleInstance;
+ };
+ }
+ });
+ };
+ });
+
+}
+
+/* global shallowCopy: true */
+
+/**
+ * Creates a shallow copy of an object, an array or a primitive.
+ *
+ * Assumes that there are no proto properties for objects.
+ */
+function shallowCopy(src, dst) {
+ if (isArray(src)) {
+ dst = dst || [];
+
+ for (var i = 0, ii = src.length; i < ii; i++) {
+ dst[i] = src[i];
+ }
+ } else if (isObject(src)) {
+ dst = dst || {};
+
+ for (var key in src) {
+ if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) {
+ dst[key] = src[key];
+ }
+ }
+ }
+
+ return dst || src;
+}
+
+/* exported toDebugString */
+
+function serializeObject(obj, maxDepth) {
+ var seen = [];
+
+ // There is no direct way to stringify object until reaching a specific depth
+ // and a very deep object can cause a performance issue, so we copy the object
+ // based on this specific depth and then stringify it.
+ if (isValidObjectMaxDepth(maxDepth)) {
+ // This file is also included in `angular-loader`, so `copy()` might not always be available in
+ // the closure. Therefore, it is lazily retrieved as `angular.copy()` when needed.
+ obj = angular.copy(obj, null, maxDepth);
+ }
+ return JSON.stringify(obj, function(key, val) {
+ val = toJsonReplacer(key, val);
+ if (isObject(val)) {
+
+ if (seen.indexOf(val) >= 0) return '...';
+
+ seen.push(val);
+ }
+ return val;
+ });
+}
+
+function toDebugString(obj, maxDepth) {
+ if (typeof obj === 'function') {
+ return obj.toString().replace(/ \{[\s\S]*$/, '');
+ } else if (isUndefined(obj)) {
+ return 'undefined';
+ } else if (typeof obj !== 'string') {
+ return serializeObject(obj, maxDepth);
+ }
+ return obj;
+}
+
+/* global angularModule: true,
+ version: true,
+
+ $CompileProvider,
+
+ htmlAnchorDirective,
+ inputDirective,
+ hiddenInputBrowserCacheDirective,
+ formDirective,
+ scriptDirective,
+ selectDirective,
+ optionDirective,
+ ngBindDirective,
+ ngBindHtmlDirective,
+ ngBindTemplateDirective,
+ ngClassDirective,
+ ngClassEvenDirective,
+ ngClassOddDirective,
+ ngCloakDirective,
+ ngControllerDirective,
+ ngFormDirective,
+ ngHideDirective,
+ ngIfDirective,
+ ngIncludeDirective,
+ ngIncludeFillContentDirective,
+ ngInitDirective,
+ ngNonBindableDirective,
+ ngPluralizeDirective,
+ ngRefDirective,
+ ngRepeatDirective,
+ ngShowDirective,
+ ngStyleDirective,
+ ngSwitchDirective,
+ ngSwitchWhenDirective,
+ ngSwitchDefaultDirective,
+ ngOptionsDirective,
+ ngTranscludeDirective,
+ ngModelDirective,
+ ngListDirective,
+ ngChangeDirective,
+ patternDirective,
+ patternDirective,
+ requiredDirective,
+ requiredDirective,
+ minlengthDirective,
+ minlengthDirective,
+ maxlengthDirective,
+ maxlengthDirective,
+ ngValueDirective,
+ ngModelOptionsDirective,
+ ngAttributeAliasDirectives,
+ ngEventDirectives,
+
+ $AnchorScrollProvider,
+ $AnimateProvider,
+ $CoreAnimateCssProvider,
+ $$CoreAnimateJsProvider,
+ $$CoreAnimateQueueProvider,
+ $$AnimateRunnerFactoryProvider,
+ $$AnimateAsyncRunFactoryProvider,
+ $BrowserProvider,
+ $CacheFactoryProvider,
+ $ControllerProvider,
+ $DateProvider,
+ $DocumentProvider,
+ $$IsDocumentHiddenProvider,
+ $ExceptionHandlerProvider,
+ $FilterProvider,
+ $$ForceReflowProvider,
+ $InterpolateProvider,
+ $$IntervalFactoryProvider,
+ $IntervalProvider,
+ $HttpProvider,
+ $HttpParamSerializerProvider,
+ $HttpParamSerializerJQLikeProvider,
+ $HttpBackendProvider,
+ $xhrFactoryProvider,
+ $jsonpCallbacksProvider,
+ $LocationProvider,
+ $LogProvider,
+ $$MapProvider,
+ $ParseProvider,
+ $RootScopeProvider,
+ $QProvider,
+ $$QProvider,
+ $$SanitizeUriProvider,
+ $SceProvider,
+ $SceDelegateProvider,
+ $SnifferProvider,
+ $$TaskTrackerFactoryProvider,
+ $TemplateCacheProvider,
+ $TemplateRequestProvider,
+ $$TestabilityProvider,
+ $TimeoutProvider,
+ $$RAFProvider,
+ $WindowProvider,
+ $$jqLiteProvider,
+ $$CookieReaderProvider
+*/
+
+
+/**
+ * @ngdoc object
+ * @name angular.version
+ * @module ng
+ * @description
+ * An object that contains information about the current AngularJS version.
+ *
+ * This object has the following properties:
+ *
+ * - `full` – `{string}` – Full version string, such as "0.9.18".
+ * - `major` – `{number}` – Major version number, such as "0".
+ * - `minor` – `{number}` – Minor version number, such as "9".
+ * - `dot` – `{number}` – Dot version number, such as "18".
+ * - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
+ */
+var version = {
+ // These placeholder strings will be replaced by grunt's `build` task.
+ // They need to be double- or single-quoted.
+ full: '1.8.2',
+ major: 1,
+ minor: 8,
+ dot: 2,
+ codeName: 'meteoric-mining'
+};
+
+
+function publishExternalAPI(angular) {
+ extend(angular, {
+ 'errorHandlingConfig': errorHandlingConfig,
+ 'bootstrap': bootstrap,
+ 'copy': copy,
+ 'extend': extend,
+ 'merge': merge,
+ 'equals': equals,
+ 'element': jqLite,
+ 'forEach': forEach,
+ 'injector': createInjector,
+ 'noop': noop,
+ 'bind': bind,
+ 'toJson': toJson,
+ 'fromJson': fromJson,
+ 'identity': identity,
+ 'isUndefined': isUndefined,
+ 'isDefined': isDefined,
+ 'isString': isString,
+ 'isFunction': isFunction,
+ 'isObject': isObject,
+ 'isNumber': isNumber,
+ 'isElement': isElement,
+ 'isArray': isArray,
+ 'version': version,
+ 'isDate': isDate,
+ 'callbacks': {$$counter: 0},
+ 'getTestability': getTestability,
+ 'reloadWithDebugInfo': reloadWithDebugInfo,
+ 'UNSAFE_restoreLegacyJqLiteXHTMLReplacement': UNSAFE_restoreLegacyJqLiteXHTMLReplacement,
+ '$$minErr': minErr,
+ '$$csp': csp,
+ '$$encodeUriSegment': encodeUriSegment,
+ '$$encodeUriQuery': encodeUriQuery,
+ '$$lowercase': lowercase,
+ '$$stringify': stringify,
+ '$$uppercase': uppercase
+ });
+
+ angularModule = setupModuleLoader(window);
+
+ angularModule('ng', ['ngLocale'], ['$provide',
+ function ngModule($provide) {
+ // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
+ $provide.provider({
+ $$sanitizeUri: $$SanitizeUriProvider
+ });
+ $provide.provider('$compile', $CompileProvider).
+ directive({
+ a: htmlAnchorDirective,
+ input: inputDirective,
+ textarea: inputDirective,
+ form: formDirective,
+ script: scriptDirective,
+ select: selectDirective,
+ option: optionDirective,
+ ngBind: ngBindDirective,
+ ngBindHtml: ngBindHtmlDirective,
+ ngBindTemplate: ngBindTemplateDirective,
+ ngClass: ngClassDirective,
+ ngClassEven: ngClassEvenDirective,
+ ngClassOdd: ngClassOddDirective,
+ ngCloak: ngCloakDirective,
+ ngController: ngControllerDirective,
+ ngForm: ngFormDirective,
+ ngHide: ngHideDirective,
+ ngIf: ngIfDirective,
+ ngInclude: ngIncludeDirective,
+ ngInit: ngInitDirective,
+ ngNonBindable: ngNonBindableDirective,
+ ngPluralize: ngPluralizeDirective,
+ ngRef: ngRefDirective,
+ ngRepeat: ngRepeatDirective,
+ ngShow: ngShowDirective,
+ ngStyle: ngStyleDirective,
+ ngSwitch: ngSwitchDirective,
+ ngSwitchWhen: ngSwitchWhenDirective,
+ ngSwitchDefault: ngSwitchDefaultDirective,
+ ngOptions: ngOptionsDirective,
+ ngTransclude: ngTranscludeDirective,
+ ngModel: ngModelDirective,
+ ngList: ngListDirective,
+ ngChange: ngChangeDirective,
+ pattern: patternDirective,
+ ngPattern: patternDirective,
+ required: requiredDirective,
+ ngRequired: requiredDirective,
+ minlength: minlengthDirective,
+ ngMinlength: minlengthDirective,
+ maxlength: maxlengthDirective,
+ ngMaxlength: maxlengthDirective,
+ ngValue: ngValueDirective,
+ ngModelOptions: ngModelOptionsDirective
+ }).
+ directive({
+ ngInclude: ngIncludeFillContentDirective,
+ input: hiddenInputBrowserCacheDirective
+ }).
+ directive(ngAttributeAliasDirectives).
+ directive(ngEventDirectives);
+ $provide.provider({
+ $anchorScroll: $AnchorScrollProvider,
+ $animate: $AnimateProvider,
+ $animateCss: $CoreAnimateCssProvider,
+ $$animateJs: $$CoreAnimateJsProvider,
+ $$animateQueue: $$CoreAnimateQueueProvider,
+ $$AnimateRunner: $$AnimateRunnerFactoryProvider,
+ $$animateAsyncRun: $$AnimateAsyncRunFactoryProvider,
+ $browser: $BrowserProvider,
+ $cacheFactory: $CacheFactoryProvider,
+ $controller: $ControllerProvider,
+ $document: $DocumentProvider,
+ $$isDocumentHidden: $$IsDocumentHiddenProvider,
+ $exceptionHandler: $ExceptionHandlerProvider,
+ $filter: $FilterProvider,
+ $$forceReflow: $$ForceReflowProvider,
+ $interpolate: $InterpolateProvider,
+ $interval: $IntervalProvider,
+ $$intervalFactory: $$IntervalFactoryProvider,
+ $http: $HttpProvider,
+ $httpParamSerializer: $HttpParamSerializerProvider,
+ $httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider,
+ $httpBackend: $HttpBackendProvider,
+ $xhrFactory: $xhrFactoryProvider,
+ $jsonpCallbacks: $jsonpCallbacksProvider,
+ $location: $LocationProvider,
+ $log: $LogProvider,
+ $parse: $ParseProvider,
+ $rootScope: $RootScopeProvider,
+ $q: $QProvider,
+ $$q: $$QProvider,
+ $sce: $SceProvider,
+ $sceDelegate: $SceDelegateProvider,
+ $sniffer: $SnifferProvider,
+ $$taskTrackerFactory: $$TaskTrackerFactoryProvider,
+ $templateCache: $TemplateCacheProvider,
+ $templateRequest: $TemplateRequestProvider,
+ $$testability: $$TestabilityProvider,
+ $timeout: $TimeoutProvider,
+ $window: $WindowProvider,
+ $$rAF: $$RAFProvider,
+ $$jqLite: $$jqLiteProvider,
+ $$Map: $$MapProvider,
+ $$cookieReader: $$CookieReaderProvider
+ });
+ }
+ ])
+ .info({ angularVersion: '1.8.2' });
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Any commits to this file should be reviewed with security in mind. *
+ * Changes to this file can potentially create security vulnerabilities. *
+ * An approval from 2 Core members with history of modifying *
+ * this file is required. *
+ * *
+ * Does the change somehow allow for arbitrary javascript to be executed? *
+ * Or allows for someone to change the prototype of built-in objects? *
+ * Or gives undesired access to variables likes document or window? *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* global
+ JQLitePrototype: true,
+ BOOLEAN_ATTR: true,
+ ALIASED_ATTR: true
+*/
+
+//////////////////////////////////
+//JQLite
+//////////////////////////////////
+
+/**
+ * @ngdoc function
+ * @name angular.element
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
+ *
+ * If jQuery is available, `angular.element` is an alias for the
+ * [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`
+ * delegates to AngularJS's built-in subset of jQuery, called "jQuery lite" or **jqLite**.
+ *
+ * jqLite is a tiny, API-compatible subset of jQuery that allows
+ * AngularJS to manipulate the DOM in a cross-browser compatible way. jqLite implements only the most
+ * commonly needed functionality with the goal of having a very small footprint.
+ *
+ * To use `jQuery`, simply ensure it is loaded before the `angular.js` file. You can also use the
+ * {@link ngJq `ngJq`} directive to specify that jqlite should be used over jQuery, or to use a
+ * specific version of jQuery if multiple versions exist on the page.
+ *
+ * <div class="alert alert-info">**Note:** All element references in AngularJS are always wrapped with jQuery or
+ * jqLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.</div>
+ *
+ * <div class="alert alert-warning">**Note:** Keep in mind that this function will not find elements
+ * by tag name / CSS selector. For lookups by tag name, try instead `angular.element(document).find(...)`
+ * or `$document.find()`, or use the standard DOM APIs, e.g. `document.querySelectorAll()`.</div>
+ *
+ * ## AngularJS's jqLite
+ * jqLite provides only the following jQuery methods:
+ *
+ * - [`addClass()`](http://api.jquery.com/addClass/) - Does not support a function as first argument
+ * - [`after()`](http://api.jquery.com/after/)
+ * - [`append()`](http://api.jquery.com/append/) - Contrary to jQuery, this doesn't clone elements
+ * so will not work correctly when invoked on a jqLite object containing more than one DOM node
+ * - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
+ * - [`bind()`](http://api.jquery.com/bind/) (_deprecated_, use [`on()`](http://api.jquery.com/on/)) - Does not support namespaces, selectors or eventData
+ * - [`children()`](http://api.jquery.com/children/) - Does not support selectors
+ * - [`clone()`](http://api.jquery.com/clone/)
+ * - [`contents()`](http://api.jquery.com/contents/)
+ * - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyle()`.
+ * As a setter, does not convert numbers to strings or append 'px', and also does not have automatic property prefixing.
+ * - [`data()`](http://api.jquery.com/data/)
+ * - [`detach()`](http://api.jquery.com/detach/)
+ * - [`empty()`](http://api.jquery.com/empty/)
+ * - [`eq()`](http://api.jquery.com/eq/)
+ * - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
+ * - [`hasClass()`](http://api.jquery.com/hasClass/)
+ * - [`html()`](http://api.jquery.com/html/)
+ * - [`next()`](http://api.jquery.com/next/) - Does not support selectors
+ * - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
+ * - [`off()`](http://api.jquery.com/off/) - Does not support namespaces, selectors or event object as parameter
+ * - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors
+ * - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
+ * - [`prepend()`](http://api.jquery.com/prepend/)
+ * - [`prop()`](http://api.jquery.com/prop/)
+ * - [`ready()`](http://api.jquery.com/ready/) (_deprecated_, use `angular.element(callback)` instead of `angular.element(document).ready(callback)`)
+ * - [`remove()`](http://api.jquery.com/remove/)
+ * - [`removeAttr()`](http://api.jquery.com/removeAttr/) - Does not support multiple attributes
+ * - [`removeClass()`](http://api.jquery.com/removeClass/) - Does not support a function as first argument
+ * - [`removeData()`](http://api.jquery.com/removeData/)
+ * - [`replaceWith()`](http://api.jquery.com/replaceWith/)
+ * - [`text()`](http://api.jquery.com/text/)
+ * - [`toggleClass()`](http://api.jquery.com/toggleClass/) - Does not support a function as first argument
+ * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers
+ * - [`unbind()`](http://api.jquery.com/unbind/) (_deprecated_, use [`off()`](http://api.jquery.com/off/)) - Does not support namespaces or event object as parameter
+ * - [`val()`](http://api.jquery.com/val/)
+ * - [`wrap()`](http://api.jquery.com/wrap/)
+ *
+ * jqLite also provides a method restoring pre-1.8 insecure treatment of XHTML-like tags.
+ * This legacy behavior turns input like `<div /><span />` to `<div></div><span></span>`
+ * instead of `<div><span></span></div>` like version 1.8 & newer do. To restore it, invoke:
+ * ```js
+ * angular.UNSAFE_restoreLegacyJqLiteXHTMLReplacement();
+ * ```
+ * Note that this only patches jqLite. If you use jQuery 3.5.0 or newer, please read the
+ * [jQuery 3.5 upgrade guide](https://jquery.com/upgrade-guide/3.5/) for more details
+ * about the workarounds.
+ *
+ * ## jQuery/jqLite Extras
+ * AngularJS also provides the following additional methods and events to both jQuery and jqLite:
+ *
+ * ### Events
+ * - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event
+ * on all DOM nodes being removed. This can be used to clean up any 3rd party bindings to the DOM
+ * element before it is removed.
+ *
+ * ### Methods
+ * - `controller(name)` - retrieves the controller of the current element or its parent. By default
+ * retrieves controller associated with the `ngController` directive. If `name` is provided as
+ * camelCase directive name, then the controller for this directive will be retrieved (e.g.
+ * `'ngModel'`).
+ * - `injector()` - retrieves the injector of the current element or its parent.
+ * - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current
+ * element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to
+ * be enabled.
+ * - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the
+ * current element. This getter should be used only on elements that contain a directive which starts a new isolate
+ * scope. Calling `scope()` on this element always returns the original non-isolate scope.
+ * Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled.
+ * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
+ * parent element is reached.
+ *
+ * @knownIssue You cannot spy on `angular.element` if you are using Jasmine version 1.x. See
+ * https://github.com/angular/angular.js/issues/14251 for more information.
+ *
+ * @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
+ * @returns {Object} jQuery object.
+ */
+
+JQLite.expando = 'ng339';
+
+var jqCache = JQLite.cache = {},
+ jqId = 1;
+
+/*
+ * !!! This is an undocumented "private" function !!!
+ */
+JQLite._data = function(node) {
+ //jQuery always returns an object on cache miss
+ return this.cache[node[this.expando]] || {};
+};
+
+function jqNextId() { return ++jqId; }
+
+
+var DASH_LOWERCASE_REGEXP = /-([a-z])/g;
+var MS_HACK_REGEXP = /^-ms-/;
+var MOUSE_EVENT_MAP = { mouseleave: 'mouseout', mouseenter: 'mouseover' };
+var jqLiteMinErr = minErr('jqLite');
+
+/**
+ * Converts kebab-case to camelCase.
+ * There is also a special case for the ms prefix starting with a lowercase letter.
+ * @param name Name to normalize
+ */
+function cssKebabToCamel(name) {
+ return kebabToCamel(name.replace(MS_HACK_REGEXP, 'ms-'));
+}
+
+function fnCamelCaseReplace(all, letter) {
+ return letter.toUpperCase();
+}
+
+/**
+ * Converts kebab-case to camelCase.
+ * @param name Name to normalize
+ */
+function kebabToCamel(name) {
+ return name
+ .replace(DASH_LOWERCASE_REGEXP, fnCamelCaseReplace);
+}
+
+var SINGLE_TAG_REGEXP = /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/;
+var HTML_REGEXP = /<|&#?\w+;/;
+var TAG_NAME_REGEXP = /<([\w:-]+)/;
+var XHTML_TAG_REGEXP = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi;
+
+// Table parts need to be wrapped with `<table>` or they're
+// stripped to their contents when put in a div.
+// XHTML parsers do not magically insert elements in the
+// same way that tag soup parsers do, so we cannot shorten
+// this by omitting <tbody> or other required elements.
+var wrapMap = {
+ thead: ['table'],
+ col: ['colgroup', 'table'],
+ tr: ['tbody', 'table'],
+ td: ['tr', 'tbody', 'table']
+};
+
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+// Support: IE <10 only
+// IE 9 requires an option wrapper & it needs to have the whole table structure
+// set up in advance; assigning `"<td></td>"` to `tr.innerHTML` doesn't work, etc.
+var wrapMapIE9 = {
+ option: [1, '<select multiple="multiple">', '</select>'],
+ _default: [0, '', '']
+};
+
+for (var key in wrapMap) {
+ var wrapMapValueClosing = wrapMap[key];
+ var wrapMapValue = wrapMapValueClosing.slice().reverse();
+ wrapMapIE9[key] = [wrapMapValue.length, '<' + wrapMapValue.join('><') + '>', '</' + wrapMapValueClosing.join('></') + '>'];
+}
+
+wrapMapIE9.optgroup = wrapMapIE9.option;
+
+function jqLiteIsTextNode(html) {
+ return !HTML_REGEXP.test(html);
+}
+
+function jqLiteAcceptsData(node) {
+ // The window object can accept data but has no nodeType
+ // Otherwise we are only interested in elements (1) and documents (9)
+ var nodeType = node.nodeType;
+ return nodeType === NODE_TYPE_ELEMENT || !nodeType || nodeType === NODE_TYPE_DOCUMENT;
+}
+
+function jqLiteHasData(node) {
+ for (var key in jqCache[node.ng339]) {
+ return true;
+ }
+ return false;
+}
+
+function jqLiteBuildFragment(html, context) {
+ var tmp, tag, wrap, finalHtml,
+ fragment = context.createDocumentFragment(),
+ nodes = [], i;
+
+ if (jqLiteIsTextNode(html)) {
+ // Convert non-html into a text node
+ nodes.push(context.createTextNode(html));
+ } else {
+ // Convert html into DOM nodes
+ tmp = fragment.appendChild(context.createElement('div'));
+ tag = (TAG_NAME_REGEXP.exec(html) || ['', ''])[1].toLowerCase();
+ finalHtml = JQLite.legacyXHTMLReplacement ?
+ html.replace(XHTML_TAG_REGEXP, '<$1></$2>') :
+ html;
+
+ if (msie < 10) {
+ wrap = wrapMapIE9[tag] || wrapMapIE9._default;
+ tmp.innerHTML = wrap[1] + finalHtml + wrap[2];
+
+ // Descend through wrappers to the right content
+ i = wrap[0];
+ while (i--) {
+ tmp = tmp.firstChild;
+ }
+ } else {
+ wrap = wrapMap[tag] || [];
+
+ // Create wrappers & descend into them
+ i = wrap.length;
+ while (--i > -1) {
+ tmp.appendChild(window.document.createElement(wrap[i]));
+ tmp = tmp.firstChild;
+ }
+
+ tmp.innerHTML = finalHtml;
+ }
+
+ nodes = concat(nodes, tmp.childNodes);
+
+ tmp = fragment.firstChild;
+ tmp.textContent = '';
+ }
+
+ // Remove wrapper from fragment
+ fragment.textContent = '';
+ fragment.innerHTML = ''; // Clear inner HTML
+ forEach(nodes, function(node) {
+ fragment.appendChild(node);
+ });
+
+ return fragment;
+}
+
+function jqLiteParseHTML(html, context) {
+ context = context || window.document;
+ var parsed;
+
+ if ((parsed = SINGLE_TAG_REGEXP.exec(html))) {
+ return [context.createElement(parsed[1])];
+ }
+
+ if ((parsed = jqLiteBuildFragment(html, context))) {
+ return parsed.childNodes;
+ }
+
+ return [];
+}
+
+function jqLiteWrapNode(node, wrapper) {
+ var parent = node.parentNode;
+
+ if (parent) {
+ parent.replaceChild(wrapper, node);
+ }
+
+ wrapper.appendChild(node);
+}
+
+
+// IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
+var jqLiteContains = window.Node.prototype.contains || /** @this */ function(arg) {
+ // eslint-disable-next-line no-bitwise
+ return !!(this.compareDocumentPosition(arg) & 16);
+};
+
+/////////////////////////////////////////////
+function JQLite(element) {
+ if (element instanceof JQLite) {
+ return element;
+ }
+
+ var argIsString;
+
+ if (isString(element)) {
+ element = trim(element);
+ argIsString = true;
+ }
+ if (!(this instanceof JQLite)) {
+ if (argIsString && element.charAt(0) !== '<') {
+ throw jqLiteMinErr('nosel', 'Looking up elements via selectors is not supported by jqLite! See: http://docs.angularjs.org/api/angular.element');
+ }
+ return new JQLite(element);
+ }
+
+ if (argIsString) {
+ jqLiteAddNodes(this, jqLiteParseHTML(element));
+ } else if (isFunction(element)) {
+ jqLiteReady(element);
+ } else {
+ jqLiteAddNodes(this, element);
+ }
+}
+
+function jqLiteClone(element) {
+ return element.cloneNode(true);
+}
+
+function jqLiteDealoc(element, onlyDescendants) {
+ if (!onlyDescendants && jqLiteAcceptsData(element)) jqLite.cleanData([element]);
+
+ if (element.querySelectorAll) {
+ jqLite.cleanData(element.querySelectorAll('*'));
+ }
+}
+
+function isEmptyObject(obj) {
+ var name;
+
+ for (name in obj) {
+ return false;
+ }
+ return true;
+}
+
+function removeIfEmptyData(element) {
+ var expandoId = element.ng339;
+ var expandoStore = expandoId && jqCache[expandoId];
+
+ var events = expandoStore && expandoStore.events;
+ var data = expandoStore && expandoStore.data;
+
+ if ((!data || isEmptyObject(data)) && (!events || isEmptyObject(events))) {
+ delete jqCache[expandoId];
+ element.ng339 = undefined; // don't delete DOM expandos. IE and Chrome don't like it
+ }
+}
+
+function jqLiteOff(element, type, fn, unsupported) {
+ if (isDefined(unsupported)) throw jqLiteMinErr('offargs', 'jqLite#off() does not support the `selector` argument');
+
+ var expandoStore = jqLiteExpandoStore(element);
+ var events = expandoStore && expandoStore.events;
+ var handle = expandoStore && expandoStore.handle;
+
+ if (!handle) return; //no listeners registered
+
+ if (!type) {
+ for (type in events) {
+ if (type !== '$destroy') {
+ element.removeEventListener(type, handle);
+ }
+ delete events[type];
+ }
+ } else {
+
+ var removeHandler = function(type) {
+ var listenerFns = events[type];
+ if (isDefined(fn)) {
+ arrayRemove(listenerFns || [], fn);
+ }
+ if (!(isDefined(fn) && listenerFns && listenerFns.length > 0)) {
+ element.removeEventListener(type, handle);
+ delete events[type];
+ }
+ };
+
+ forEach(type.split(' '), function(type) {
+ removeHandler(type);
+ if (MOUSE_EVENT_MAP[type]) {
+ removeHandler(MOUSE_EVENT_MAP[type]);
+ }
+ });
+ }
+
+ removeIfEmptyData(element);
+}
+
+function jqLiteRemoveData(element, name) {
+ var expandoId = element.ng339;
+ var expandoStore = expandoId && jqCache[expandoId];
+
+ if (expandoStore) {
+ if (name) {
+ delete expandoStore.data[name];
+ } else {
+ expandoStore.data = {};
+ }
+
+ removeIfEmptyData(element);
+ }
+}
+
+
+function jqLiteExpandoStore(element, createIfNecessary) {
+ var expandoId = element.ng339,
+ expandoStore = expandoId && jqCache[expandoId];
+
+ if (createIfNecessary && !expandoStore) {
+ element.ng339 = expandoId = jqNextId();
+ expandoStore = jqCache[expandoId] = {events: {}, data: {}, handle: undefined};
+ }
+
+ return expandoStore;
+}
+
+
+function jqLiteData(element, key, value) {
+ if (jqLiteAcceptsData(element)) {
+ var prop;
+
+ var isSimpleSetter = isDefined(value);
+ var isSimpleGetter = !isSimpleSetter && key && !isObject(key);
+ var massGetter = !key;
+ var expandoStore = jqLiteExpandoStore(element, !isSimpleGetter);
+ var data = expandoStore && expandoStore.data;
+
+ if (isSimpleSetter) { // data('key', value)
+ data[kebabToCamel(key)] = value;
+ } else {
+ if (massGetter) { // data()
+ return data;
+ } else {
+ if (isSimpleGetter) { // data('key')
+ // don't force creation of expandoStore if it doesn't exist yet
+ return data && data[kebabToCamel(key)];
+ } else { // mass-setter: data({key1: val1, key2: val2})
+ for (prop in key) {
+ data[kebabToCamel(prop)] = key[prop];
+ }
+ }
+ }
+ }
+ }
+}
+
+function jqLiteHasClass(element, selector) {
+ if (!element.getAttribute) return false;
+ return ((' ' + (element.getAttribute('class') || '') + ' ').replace(/[\n\t]/g, ' ').
+ indexOf(' ' + selector + ' ') > -1);
+}
+
+function jqLiteRemoveClass(element, cssClasses) {
+ if (cssClasses && element.setAttribute) {
+ var existingClasses = (' ' + (element.getAttribute('class') || '') + ' ')
+ .replace(/[\n\t]/g, ' ');
+ var newClasses = existingClasses;
+
+ forEach(cssClasses.split(' '), function(cssClass) {
+ cssClass = trim(cssClass);
+ newClasses = newClasses.replace(' ' + cssClass + ' ', ' ');
+ });
+
+ if (newClasses !== existingClasses) {
+ element.setAttribute('class', trim(newClasses));
+ }
+ }
+}
+
+function jqLiteAddClass(element, cssClasses) {
+ if (cssClasses && element.setAttribute) {
+ var existingClasses = (' ' + (element.getAttribute('class') || '') + ' ')
+ .replace(/[\n\t]/g, ' ');
+ var newClasses = existingClasses;
+
+ forEach(cssClasses.split(' '), function(cssClass) {
+ cssClass = trim(cssClass);
+ if (newClasses.indexOf(' ' + cssClass + ' ') === -1) {
+ newClasses += cssClass + ' ';
+ }
+ });
+
+ if (newClasses !== existingClasses) {
+ element.setAttribute('class', trim(newClasses));
+ }
+ }
+}
+
+
+function jqLiteAddNodes(root, elements) {
+ // THIS CODE IS VERY HOT. Don't make changes without benchmarking.
+
+ if (elements) {
+
+ // if a Node (the most common case)
+ if (elements.nodeType) {
+ root[root.length++] = elements;
+ } else {
+ var length = elements.length;
+
+ // if an Array or NodeList and not a Window
+ if (typeof length === 'number' && elements.window !== elements) {
+ if (length) {
+ for (var i = 0; i < length; i++) {
+ root[root.length++] = elements[i];
+ }
+ }
+ } else {
+ root[root.length++] = elements;
+ }
+ }
+ }
+}
+
+
+function jqLiteController(element, name) {
+ return jqLiteInheritedData(element, '$' + (name || 'ngController') + 'Controller');
+}
+
+function jqLiteInheritedData(element, name, value) {
+ // if element is the document object work with the html element instead
+ // this makes $(document).scope() possible
+ if (element.nodeType === NODE_TYPE_DOCUMENT) {
+ element = element.documentElement;
+ }
+ var names = isArray(name) ? name : [name];
+
+ while (element) {
+ for (var i = 0, ii = names.length; i < ii; i++) {
+ if (isDefined(value = jqLite.data(element, names[i]))) return value;
+ }
+
+ // If dealing with a document fragment node with a host element, and no parent, use the host
+ // element as the parent. This enables directives within a Shadow DOM or polyfilled Shadow DOM
+ // to lookup parent controllers.
+ element = element.parentNode || (element.nodeType === NODE_TYPE_DOCUMENT_FRAGMENT && element.host);
+ }
+}
+
+function jqLiteEmpty(element) {
+ jqLiteDealoc(element, true);
+ while (element.firstChild) {
+ element.removeChild(element.firstChild);
+ }
+}
+
+function jqLiteRemove(element, keepData) {
+ if (!keepData) jqLiteDealoc(element);
+ var parent = element.parentNode;
+ if (parent) parent.removeChild(element);
+}
+
+
+function jqLiteDocumentLoaded(action, win) {
+ win = win || window;
+ if (win.document.readyState === 'complete') {
+ // Force the action to be run async for consistent behavior
+ // from the action's point of view
+ // i.e. it will definitely not be in a $apply
+ win.setTimeout(action);
+ } else {
+ // No need to unbind this handler as load is only ever called once
+ jqLite(win).on('load', action);
+ }
+}
+
+function jqLiteReady(fn) {
+ function trigger() {
+ window.document.removeEventListener('DOMContentLoaded', trigger);
+ window.removeEventListener('load', trigger);
+ fn();
+ }
+
+ // check if document is already loaded
+ if (window.document.readyState === 'complete') {
+ window.setTimeout(fn);
+ } else {
+ // We can not use jqLite since we are not done loading and jQuery could be loaded later.
+
+ // Works for modern browsers and IE9
+ window.document.addEventListener('DOMContentLoaded', trigger);
+
+ // Fallback to window.onload for others
+ window.addEventListener('load', trigger);
+ }
+}
+
+//////////////////////////////////////////
+// Functions which are declared directly.
+//////////////////////////////////////////
+var JQLitePrototype = JQLite.prototype = {
+ ready: jqLiteReady,
+ toString: function() {
+ var value = [];
+ forEach(this, function(e) { value.push('' + e);});
+ return '[' + value.join(', ') + ']';
+ },
+
+ eq: function(index) {
+ return (index >= 0) ? jqLite(this[index]) : jqLite(this[this.length + index]);
+ },
+
+ length: 0,
+ push: push,
+ sort: [].sort,
+ splice: [].splice
+};
+
+//////////////////////////////////////////
+// Functions iterating getter/setters.
+// these functions return self on setter and
+// value on get.
+//////////////////////////////////////////
+var BOOLEAN_ATTR = {};
+forEach('multiple,selected,checked,disabled,readOnly,required,open'.split(','), function(value) {
+ BOOLEAN_ATTR[lowercase(value)] = value;
+});
+var BOOLEAN_ELEMENTS = {};
+forEach('input,select,option,textarea,button,form,details'.split(','), function(value) {
+ BOOLEAN_ELEMENTS[value] = true;
+});
+var ALIASED_ATTR = {
+ 'ngMinlength': 'minlength',
+ 'ngMaxlength': 'maxlength',
+ 'ngMin': 'min',
+ 'ngMax': 'max',
+ 'ngPattern': 'pattern',
+ 'ngStep': 'step'
+};
+
+function getBooleanAttrName(element, name) {
+ // check dom last since we will most likely fail on name
+ var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];
+
+ // booleanAttr is here twice to minimize DOM access
+ return booleanAttr && BOOLEAN_ELEMENTS[nodeName_(element)] && booleanAttr;
+}
+
+function getAliasedAttrName(name) {
+ return ALIASED_ATTR[name];
+}
+
+forEach({
+ data: jqLiteData,
+ removeData: jqLiteRemoveData,
+ hasData: jqLiteHasData,
+ cleanData: function jqLiteCleanData(nodes) {
+ for (var i = 0, ii = nodes.length; i < ii; i++) {
+ jqLiteRemoveData(nodes[i]);
+ jqLiteOff(nodes[i]);
+ }
+ }
+}, function(fn, name) {
+ JQLite[name] = fn;
+});
+
+forEach({
+ data: jqLiteData,
+ inheritedData: jqLiteInheritedData,
+
+ scope: function(element) {
+ // Can't use jqLiteData here directly so we stay compatible with jQuery!
+ return jqLite.data(element, '$scope') || jqLiteInheritedData(element.parentNode || element, ['$isolateScope', '$scope']);
+ },
+
+ isolateScope: function(element) {
+ // Can't use jqLiteData here directly so we stay compatible with jQuery!
+ return jqLite.data(element, '$isolateScope') || jqLite.data(element, '$isolateScopeNoTemplate');
+ },
+
+ controller: jqLiteController,
+
+ injector: function(element) {
+ return jqLiteInheritedData(element, '$injector');
+ },
+
+ removeAttr: function(element, name) {
+ element.removeAttribute(name);
+ },
+
+ hasClass: jqLiteHasClass,
+
+ css: function(element, name, value) {
+ name = cssKebabToCamel(name);
+
+ if (isDefined(value)) {
+ element.style[name] = value;
+ } else {
+ return element.style[name];
+ }
+ },
+
+ attr: function(element, name, value) {
+ var ret;
+ var nodeType = element.nodeType;
+ if (nodeType === NODE_TYPE_TEXT || nodeType === NODE_TYPE_ATTRIBUTE || nodeType === NODE_TYPE_COMMENT ||
+ !element.getAttribute) {
+ return;
+ }
+
+ var lowercasedName = lowercase(name);
+ var isBooleanAttr = BOOLEAN_ATTR[lowercasedName];
+
+ if (isDefined(value)) {
+ // setter
+
+ if (value === null || (value === false && isBooleanAttr)) {
+ element.removeAttribute(name);
+ } else {
+ element.setAttribute(name, isBooleanAttr ? lowercasedName : value);
+ }
+ } else {
+ // getter
+
+ ret = element.getAttribute(name);
+
+ if (isBooleanAttr && ret !== null) {
+ ret = lowercasedName;
+ }
+ // Normalize non-existing attributes to undefined (as jQuery).
+ return ret === null ? undefined : ret;
+ }
+ },
+
+ prop: function(element, name, value) {
+ if (isDefined(value)) {
+ element[name] = value;
+ } else {
+ return element[name];
+ }
+ },
+
+ text: (function() {
+ getText.$dv = '';
+ return getText;
+
+ function getText(element, value) {
+ if (isUndefined(value)) {
+ var nodeType = element.nodeType;
+ return (nodeType === NODE_TYPE_ELEMENT || nodeType === NODE_TYPE_TEXT) ? element.textContent : '';
+ }
+ element.textContent = value;
+ }
+ })(),
+
+ val: function(element, value) {
+ if (isUndefined(value)) {
+ if (element.multiple && nodeName_(element) === 'select') {
+ var result = [];
+ forEach(element.options, function(option) {
+ if (option.selected) {
+ result.push(option.value || option.text);
+ }
+ });
+ return result;
+ }
+ return element.value;
+ }
+ element.value = value;
+ },
+
+ html: function(element, value) {
+ if (isUndefined(value)) {
+ return element.innerHTML;
+ }
+ jqLiteDealoc(element, true);
+ element.innerHTML = value;
+ },
+
+ empty: jqLiteEmpty
+}, function(fn, name) {
+ /**
+ * Properties: writes return selection, reads return first value
+ */
+ JQLite.prototype[name] = function(arg1, arg2) {
+ var i, key;
+ var nodeCount = this.length;
+
+ // jqLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it
+ // in a way that survives minification.
+ // jqLiteEmpty takes no arguments but is a setter.
+ if (fn !== jqLiteEmpty &&
+ (isUndefined((fn.length === 2 && (fn !== jqLiteHasClass && fn !== jqLiteController)) ? arg1 : arg2))) {
+ if (isObject(arg1)) {
+
+ // we are a write, but the object properties are the key/values
+ for (i = 0; i < nodeCount; i++) {
+ if (fn === jqLiteData) {
+ // data() takes the whole object in jQuery
+ fn(this[i], arg1);
+ } else {
+ for (key in arg1) {
+ fn(this[i], key, arg1[key]);
+ }
+ }
+ }
+ // return self for chaining
+ return this;
+ } else {
+ // we are a read, so read the first child.
+ // TODO: do we still need this?
+ var value = fn.$dv;
+ // Only if we have $dv do we iterate over all, otherwise it is just the first element.
+ var jj = (isUndefined(value)) ? Math.min(nodeCount, 1) : nodeCount;
+ for (var j = 0; j < jj; j++) {
+ var nodeValue = fn(this[j], arg1, arg2);
+ value = value ? value + nodeValue : nodeValue;
+ }
+ return value;
+ }
+ } else {
+ // we are a write, so apply to all children
+ for (i = 0; i < nodeCount; i++) {
+ fn(this[i], arg1, arg2);
+ }
+ // return self for chaining
+ return this;
+ }
+ };
+});
+
+function createEventHandler(element, events) {
+ var eventHandler = function(event, type) {
+ // jQuery specific api
+ event.isDefaultPrevented = function() {
+ return event.defaultPrevented;
+ };
+
+ var eventFns = events[type || event.type];
+ var eventFnsLength = eventFns ? eventFns.length : 0;
+
+ if (!eventFnsLength) return;
+
+ if (isUndefined(event.immediatePropagationStopped)) {
+ var originalStopImmediatePropagation = event.stopImmediatePropagation;
+ event.stopImmediatePropagation = function() {
+ event.immediatePropagationStopped = true;
+
+ if (event.stopPropagation) {
+ event.stopPropagation();
+ }
+
+ if (originalStopImmediatePropagation) {
+ originalStopImmediatePropagation.call(event);
+ }
+ };
+ }
+
+ event.isImmediatePropagationStopped = function() {
+ return event.immediatePropagationStopped === true;
+ };
+
+ // Some events have special handlers that wrap the real handler
+ var handlerWrapper = eventFns.specialHandlerWrapper || defaultHandlerWrapper;
+
+ // Copy event handlers in case event handlers array is modified during execution.
+ if ((eventFnsLength > 1)) {
+ eventFns = shallowCopy(eventFns);
+ }
+
+ for (var i = 0; i < eventFnsLength; i++) {
+ if (!event.isImmediatePropagationStopped()) {
+ handlerWrapper(element, event, eventFns[i]);
+ }
+ }
+ };
+
+ // TODO: this is a hack for angularMocks/clearDataCache that makes it possible to deregister all
+ // events on `element`
+ eventHandler.elem = element;
+ return eventHandler;
+}
+
+function defaultHandlerWrapper(element, event, handler) {
+ handler.call(element, event);
+}
+
+function specialMouseHandlerWrapper(target, event, handler) {
+ // Refer to jQuery's implementation of mouseenter & mouseleave
+ // Read about mouseenter and mouseleave:
+ // http://www.quirksmode.org/js/events_mouse.html#link8
+ var related = event.relatedTarget;
+ // For mousenter/leave call the handler if related is outside the target.
+ // NB: No relatedTarget if the mouse left/entered the browser window
+ if (!related || (related !== target && !jqLiteContains.call(target, related))) {
+ handler.call(target, event);
+ }
+}
+
+//////////////////////////////////////////
+// Functions iterating traversal.
+// These functions chain results into a single
+// selector.
+//////////////////////////////////////////
+forEach({
+ removeData: jqLiteRemoveData,
+
+ on: function jqLiteOn(element, type, fn, unsupported) {
+ if (isDefined(unsupported)) throw jqLiteMinErr('onargs', 'jqLite#on() does not support the `selector` or `eventData` parameters');
+
+ // Do not add event handlers to non-elements because they will not be cleaned up.
+ if (!jqLiteAcceptsData(element)) {
+ return;
+ }
+
+ var expandoStore = jqLiteExpandoStore(element, true);
+ var events = expandoStore.events;
+ var handle = expandoStore.handle;
+
+ if (!handle) {
+ handle = expandoStore.handle = createEventHandler(element, events);
+ }
+
+ // http://jsperf.com/string-indexof-vs-split
+ var types = type.indexOf(' ') >= 0 ? type.split(' ') : [type];
+ var i = types.length;
+
+ var addHandler = function(type, specialHandlerWrapper, noEventListener) {
+ var eventFns = events[type];
+
+ if (!eventFns) {
+ eventFns = events[type] = [];
+ eventFns.specialHandlerWrapper = specialHandlerWrapper;
+ if (type !== '$destroy' && !noEventListener) {
+ element.addEventListener(type, handle);
+ }
+ }
+
+ eventFns.push(fn);
+ };
+
+ while (i--) {
+ type = types[i];
+ if (MOUSE_EVENT_MAP[type]) {
+ addHandler(MOUSE_EVENT_MAP[type], specialMouseHandlerWrapper);
+ addHandler(type, undefined, true);
+ } else {
+ addHandler(type);
+ }
+ }
+ },
+
+ off: jqLiteOff,
+
+ one: function(element, type, fn) {
+ element = jqLite(element);
+
+ //add the listener twice so that when it is called
+ //you can remove the original function and still be
+ //able to call element.off(ev, fn) normally
+ element.on(type, function onFn() {
+ element.off(type, fn);
+ element.off(type, onFn);
+ });
+ element.on(type, fn);
+ },
+
+ replaceWith: function(element, replaceNode) {
+ var index, parent = element.parentNode;
+ jqLiteDealoc(element);
+ forEach(new JQLite(replaceNode), function(node) {
+ if (index) {
+ parent.insertBefore(node, index.nextSibling);
+ } else {
+ parent.replaceChild(node, element);
+ }
+ index = node;
+ });
+ },
+
+ children: function(element) {
+ var children = [];
+ forEach(element.childNodes, function(element) {
+ if (element.nodeType === NODE_TYPE_ELEMENT) {
+ children.push(element);
+ }
+ });
+ return children;
+ },
+
+ contents: function(element) {
+ return element.contentDocument || element.childNodes || [];
+ },
+
+ append: function(element, node) {
+ var nodeType = element.nodeType;
+ if (nodeType !== NODE_TYPE_ELEMENT && nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT) return;
+
+ node = new JQLite(node);
+
+ for (var i = 0, ii = node.length; i < ii; i++) {
+ var child = node[i];
+ element.appendChild(child);
+ }
+ },
+
+ prepend: function(element, node) {
+ if (element.nodeType === NODE_TYPE_ELEMENT) {
+ var index = element.firstChild;
+ forEach(new JQLite(node), function(child) {
+ element.insertBefore(child, index);
+ });
+ }
+ },
+
+ wrap: function(element, wrapNode) {
+ jqLiteWrapNode(element, jqLite(wrapNode).eq(0).clone()[0]);
+ },
+
+ remove: jqLiteRemove,
+
+ detach: function(element) {
+ jqLiteRemove(element, true);
+ },
+
+ after: function(element, newElement) {
+ var index = element, parent = element.parentNode;
+
+ if (parent) {
+ newElement = new JQLite(newElement);
+
+ for (var i = 0, ii = newElement.length; i < ii; i++) {
+ var node = newElement[i];
+ parent.insertBefore(node, index.nextSibling);
+ index = node;
+ }
+ }
+ },
+
+ addClass: jqLiteAddClass,
+ removeClass: jqLiteRemoveClass,
+
+ toggleClass: function(element, selector, condition) {
+ if (selector) {
+ forEach(selector.split(' '), function(className) {
+ var classCondition = condition;
+ if (isUndefined(classCondition)) {
+ classCondition = !jqLiteHasClass(element, className);
+ }
+ (classCondition ? jqLiteAddClass : jqLiteRemoveClass)(element, className);
+ });
+ }
+ },
+
+ parent: function(element) {
+ var parent = element.parentNode;
+ return parent && parent.nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT ? parent : null;
+ },
+
+ next: function(element) {
+ return element.nextElementSibling;
+ },
+
+ find: function(element, selector) {
+ if (element.getElementsByTagName) {
+ return element.getElementsByTagName(selector);
+ } else {
+ return [];
+ }
+ },
+
+ clone: jqLiteClone,
+
+ triggerHandler: function(element, event, extraParameters) {
+
+ var dummyEvent, eventFnsCopy, handlerArgs;
+ var eventName = event.type || event;
+ var expandoStore = jqLiteExpandoStore(element);
+ var events = expandoStore && expandoStore.events;
+ var eventFns = events && events[eventName];
+
+ if (eventFns) {
+ // Create a dummy event to pass to the handlers
+ dummyEvent = {
+ preventDefault: function() { this.defaultPrevented = true; },
+ isDefaultPrevented: function() { return this.defaultPrevented === true; },
+ stopImmediatePropagation: function() { this.immediatePropagationStopped = true; },
+ isImmediatePropagationStopped: function() { return this.immediatePropagationStopped === true; },
+ stopPropagation: noop,
+ type: eventName,
+ target: element
+ };
+
+ // If a custom event was provided then extend our dummy event with it
+ if (event.type) {
+ dummyEvent = extend(dummyEvent, event);
+ }
+
+ // Copy event handlers in case event handlers array is modified during execution.
+ eventFnsCopy = shallowCopy(eventFns);
+ handlerArgs = extraParameters ? [dummyEvent].concat(extraParameters) : [dummyEvent];
+
+ forEach(eventFnsCopy, function(fn) {
+ if (!dummyEvent.isImmediatePropagationStopped()) {
+ fn.apply(element, handlerArgs);
+ }
+ });
+ }
+ }
+}, function(fn, name) {
+ /**
+ * chaining functions
+ */
+ JQLite.prototype[name] = function(arg1, arg2, arg3) {
+ var value;
+
+ for (var i = 0, ii = this.length; i < ii; i++) {
+ if (isUndefined(value)) {
+ value = fn(this[i], arg1, arg2, arg3);
+ if (isDefined(value)) {
+ // any function which returns a value needs to be wrapped
+ value = jqLite(value);
+ }
+ } else {
+ jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3));
+ }
+ }
+ return isDefined(value) ? value : this;
+ };
+});
+
+// bind legacy bind/unbind to on/off
+JQLite.prototype.bind = JQLite.prototype.on;
+JQLite.prototype.unbind = JQLite.prototype.off;
+
+
+// Provider for private $$jqLite service
+/** @this */
+function $$jqLiteProvider() {
+ this.$get = function $$jqLite() {
+ return extend(JQLite, {
+ hasClass: function(node, classes) {
+ if (node.attr) node = node[0];
+ return jqLiteHasClass(node, classes);
+ },
+ addClass: function(node, classes) {
+ if (node.attr) node = node[0];
+ return jqLiteAddClass(node, classes);
+ },
+ removeClass: function(node, classes) {
+ if (node.attr) node = node[0];
+ return jqLiteRemoveClass(node, classes);
+ }
+ });
+ };
+}
+
+/**
+ * Computes a hash of an 'obj'.
+ * Hash of a:
+ * string is string
+ * number is number as string
+ * object is either result of calling $$hashKey function on the object or uniquely generated id,
+ * that is also assigned to the $$hashKey property of the object.
+ *
+ * @param obj
+ * @returns {string} hash string such that the same input will have the same hash string.
+ * The resulting string key is in 'type:hashKey' format.
+ */
+function hashKey(obj, nextUidFn) {
+ var key = obj && obj.$$hashKey;
+
+ if (key) {
+ if (typeof key === 'function') {
+ key = obj.$$hashKey();
+ }
+ return key;
+ }
+
+ var objType = typeof obj;
+ if (objType === 'function' || (objType === 'object' && obj !== null)) {
+ key = obj.$$hashKey = objType + ':' + (nextUidFn || nextUid)();
+ } else {
+ key = objType + ':' + obj;
+ }
+
+ return key;
+}
+
+// A minimal ES2015 Map implementation.
+// Should be bug/feature equivalent to the native implementations of supported browsers
+// (for the features required in Angular).
+// See https://kangax.github.io/compat-table/es6/#test-Map
+var nanKey = Object.create(null);
+function NgMapShim() {
+ this._keys = [];
+ this._values = [];
+ this._lastKey = NaN;
+ this._lastIndex = -1;
+}
+NgMapShim.prototype = {
+ _idx: function(key) {
+ if (key !== this._lastKey) {
+ this._lastKey = key;
+ this._lastIndex = this._keys.indexOf(key);
+ }
+ return this._lastIndex;
+ },
+ _transformKey: function(key) {
+ return isNumberNaN(key) ? nanKey : key;
+ },
+ get: function(key) {
+ key = this._transformKey(key);
+ var idx = this._idx(key);
+ if (idx !== -1) {
+ return this._values[idx];
+ }
+ },
+ has: function(key) {
+ key = this._transformKey(key);
+ var idx = this._idx(key);
+ return idx !== -1;
+ },
+ set: function(key, value) {
+ key = this._transformKey(key);
+ var idx = this._idx(key);
+ if (idx === -1) {
+ idx = this._lastIndex = this._keys.length;
+ }
+ this._keys[idx] = key;
+ this._values[idx] = value;
+
+ // Support: IE11
+ // Do not `return this` to simulate the partial IE11 implementation
+ },
+ delete: function(key) {
+ key = this._transformKey(key);
+ var idx = this._idx(key);
+ if (idx === -1) {
+ return false;
+ }
+ this._keys.splice(idx, 1);
+ this._values.splice(idx, 1);
+ this._lastKey = NaN;
+ this._lastIndex = -1;
+ return true;
+ }
+};
+
+// For now, always use `NgMapShim`, even if `window.Map` is available. Some native implementations
+// are still buggy (often in subtle ways) and can cause hard-to-debug failures. When native `Map`
+// implementations get more stable, we can reconsider switching to `window.Map` (when available).
+var NgMap = NgMapShim;
+
+var $$MapProvider = [/** @this */function() {
+ this.$get = [function() {
+ return NgMap;
+ }];
+}];
+
+/**
+ * @ngdoc function
+ * @module ng
+ * @name angular.injector
+ * @kind function
+ *
+ * @description
+ * Creates an injector object that can be used for retrieving services as well as for
+ * dependency injection (see {@link guide/di dependency injection}).
+ *
+ * @param {Array.<string|Function>} modules A list of module functions or their aliases. See
+ * {@link angular.module}. The `ng` module must be explicitly added.
+ * @param {boolean=} [strictDi=false] Whether the injector should be in strict mode, which
+ * disallows argument name annotation inference.
+ * @returns {injector} Injector object. See {@link auto.$injector $injector}.
+ *
+ * @example
+ * Typical usage
+ * ```js
+ * // create an injector
+ * var $injector = angular.injector(['ng']);
+ *
+ * // use the injector to kick off your application
+ * // use the type inference to auto inject arguments, or use implicit injection
+ * $injector.invoke(function($rootScope, $compile, $document) {
+ * $compile($document)($rootScope);
+ * $rootScope.$digest();
+ * });
+ * ```
+ *
+ * Sometimes you want to get access to the injector of a currently running AngularJS app
+ * from outside AngularJS. Perhaps, you want to inject and compile some markup after the
+ * application has been bootstrapped. You can do this using the extra `injector()` added
+ * to JQuery/jqLite elements. See {@link angular.element}.
+ *
+ * *This is fairly rare but could be the case if a third party library is injecting the
+ * markup.*
+ *
+ * In the following example a new block of HTML containing a `ng-controller`
+ * directive is added to the end of the document body by JQuery. We then compile and link
+ * it into the current AngularJS scope.
+ *
+ * ```js
+ * var $div = $('<div ng-controller="MyCtrl">{{content.label}}</div>');
+ * $(document.body).append($div);
+ *
+ * angular.element(document).injector().invoke(function($compile) {
+ * var scope = angular.element($div).scope();
+ * $compile($div)(scope);
+ * });
+ * ```
+ */
+
+
+/**
+ * @ngdoc module
+ * @name auto
+ * @installation
+ * @description
+ *
+ * Implicit module which gets automatically added to each {@link auto.$injector $injector}.
+ */
+
+var ARROW_ARG = /^([^(]+?)=>/;
+var FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m;
+var FN_ARG_SPLIT = /,/;
+var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
+var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
+var $injectorMinErr = minErr('$injector');
+
+function stringifyFn(fn) {
+ return Function.prototype.toString.call(fn);
+}
+
+function extractArgs(fn) {
+ var fnText = stringifyFn(fn).replace(STRIP_COMMENTS, ''),
+ args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
+ return args;
+}
+
+function anonFn(fn) {
+ // For anonymous functions, showing at the very least the function signature can help in
+ // debugging.
+ var args = extractArgs(fn);
+ if (args) {
+ return 'function(' + (args[1] || '').replace(/[\s\r\n]+/, ' ') + ')';
+ }
+ return 'fn';
+}
+
+function annotate(fn, strictDi, name) {
+ var $inject,
+ argDecl,
+ last;
+
+ if (typeof fn === 'function') {
+ if (!($inject = fn.$inject)) {
+ $inject = [];
+ if (fn.length) {
+ if (strictDi) {
+ if (!isString(name) || !name) {
+ name = fn.name || anonFn(fn);
+ }
+ throw $injectorMinErr('strictdi',
+ '{0} is not using explicit annotation and cannot be invoked in strict mode', name);
+ }
+ argDecl = extractArgs(fn);
+ forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg) {
+ arg.replace(FN_ARG, function(all, underscore, name) {
+ $inject.push(name);
+ });
+ });
+ }
+ fn.$inject = $inject;
+ }
+ } else if (isArray(fn)) {
+ last = fn.length - 1;
+ assertArgFn(fn[last], 'fn');
+ $inject = fn.slice(0, last);
+ } else {
+ assertArgFn(fn, 'fn', true);
+ }
+ return $inject;
+}
+
+///////////////////////////////////////
+
+/**
+ * @ngdoc service
+ * @name $injector
+ *
+ * @description
+ *
+ * `$injector` is used to retrieve object instances as defined by
+ * {@link auto.$provide provider}, instantiate types, invoke methods,
+ * and load modules.
+ *
+ * The following always holds true:
+ *
+ * ```js
+ * var $injector = angular.injector();
+ * expect($injector.get('$injector')).toBe($injector);
+ * expect($injector.invoke(function($injector) {
+ * return $injector;
+ * })).toBe($injector);
+ * ```
+ *
+ * ## Injection Function Annotation
+ *
+ * JavaScript does not have annotations, and annotations are needed for dependency injection. The
+ * following are all valid ways of annotating function with injection arguments and are equivalent.
+ *
+ * ```js
+ * // inferred (only works if code not minified/obfuscated)
+ * $injector.invoke(function(serviceA){});
+ *
+ * // annotated
+ * function explicit(serviceA) {};
+ * explicit.$inject = ['serviceA'];
+ * $injector.invoke(explicit);
+ *
+ * // inline
+ * $injector.invoke(['serviceA', function(serviceA){}]);
+ * ```
+ *
+ * ### Inference
+ *
+ * In JavaScript calling `toString()` on a function returns the function definition. The definition
+ * can then be parsed and the function arguments can be extracted. This method of discovering
+ * annotations is disallowed when the injector is in strict mode.
+ * *NOTE:* This does not work with minification, and obfuscation tools since these tools change the
+ * argument names.
+ *
+ * ### `$inject` Annotation
+ * By adding an `$inject` property onto a function the injection parameters can be specified.
+ *
+ * ### Inline
+ * As an array of injection names, where the last item in the array is the function to call.
+ */
+
+/**
+ * @ngdoc property
+ * @name $injector#modules
+ * @type {Object}
+ * @description
+ * A hash containing all the modules that have been loaded into the
+ * $injector.
+ *
+ * You can use this property to find out information about a module via the
+ * {@link angular.Module#info `myModule.info(...)`} method.
+ *
+ * For example:
+ *
+ * ```
+ * var info = $injector.modules['ngAnimate'].info();
+ * ```
+ *
+ * **Do not use this property to attempt to modify the modules after the application
+ * has been bootstrapped.**
+ */
+
+
+/**
+ * @ngdoc method
+ * @name $injector#get
+ *
+ * @description
+ * Return an instance of the service.
+ *
+ * @param {string} name The name of the instance to retrieve.
+ * @param {string=} caller An optional string to provide the origin of the function call for error messages.
+ * @return {*} The instance.
+ */
+
+/**
+ * @ngdoc method
+ * @name $injector#invoke
+ *
+ * @description
+ * Invoke the method and supply the method arguments from the `$injector`.
+ *
+ * @param {Function|Array.<string|Function>} fn The injectable function to invoke. Function parameters are
+ * injected according to the {@link guide/di $inject Annotation} rules.
+ * @param {Object=} self The `this` for the invoked method.
+ * @param {Object=} locals Optional object. If preset then any argument names are read from this
+ * object first, before the `$injector` is consulted.
+ * @returns {*} the value returned by the invoked `fn` function.
+ */
+
+/**
+ * @ngdoc method
+ * @name $injector#has
+ *
+ * @description
+ * Allows the user to query if the particular service exists.
+ *
+ * @param {string} name Name of the service to query.
+ * @returns {boolean} `true` if injector has given service.
+ */
+
+/**
+ * @ngdoc method
+ * @name $injector#instantiate
+ * @description
+ * Create a new instance of JS type. The method takes a constructor function, invokes the new
+ * operator, and supplies all of the arguments to the constructor function as specified by the
+ * constructor annotation.
+ *
+ * @param {Function} Type Annotated constructor function.
+ * @param {Object=} locals Optional object. If preset then any argument names are read from this
+ * object first, before the `$injector` is consulted.
+ * @returns {Object} new instance of `Type`.
+ */
+
+/**
+ * @ngdoc method
+ * @name $injector#annotate
+ *
+ * @description
+ * Returns an array of service names which the function is requesting for injection. This API is
+ * used by the injector to determine which services need to be injected into the function when the
+ * function is invoked. There are three ways in which the function can be annotated with the needed
+ * dependencies.
+ *
+ * #### Argument names
+ *
+ * The simplest form is to extract the dependencies from the arguments of the function. This is done
+ * by converting the function into a string using `toString()` method and extracting the argument
+ * names.
+ * ```js
+ * // Given
+ * function MyController($scope, $route) {
+ * // ...
+ * }
+ *
+ * // Then
+ * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
+ * ```
+ *
+ * You can disallow this method by using strict injection mode.
+ *
+ * This method does not work with code minification / obfuscation. For this reason the following
+ * annotation strategies are supported.
+ *
+ * #### The `$inject` property
+ *
+ * If a function has an `$inject` property and its value is an array of strings, then the strings
+ * represent names of services to be injected into the function.
+ * ```js
+ * // Given
+ * var MyController = function(obfuscatedScope, obfuscatedRoute) {
+ * // ...
+ * }
+ * // Define function dependencies
+ * MyController['$inject'] = ['$scope', '$route'];
+ *
+ * // Then
+ * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
+ * ```
+ *
+ * #### The array notation
+ *
+ * It is often desirable to inline Injected functions and that's when setting the `$inject` property
+ * is very inconvenient. In these situations using the array notation to specify the dependencies in
+ * a way that survives minification is a better choice:
+ *
+ * ```js
+ * // We wish to write this (not minification / obfuscation safe)
+ * injector.invoke(function($compile, $rootScope) {
+ * // ...
+ * });
+ *
+ * // We are forced to write break inlining
+ * var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {
+ * // ...
+ * };
+ * tmpFn.$inject = ['$compile', '$rootScope'];
+ * injector.invoke(tmpFn);
+ *
+ * // To better support inline function the inline annotation is supported
+ * injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {
+ * // ...
+ * }]);
+ *
+ * // Therefore
+ * expect(injector.annotate(
+ * ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
+ * ).toEqual(['$compile', '$rootScope']);
+ * ```
+ *
+ * @param {Function|Array.<string|Function>} fn Function for which dependent service names need to
+ * be retrieved as described above.
+ *
+ * @param {boolean=} [strictDi=false] Disallow argument name annotation inference.
+ *
+ * @returns {Array.<string>} The names of the services which the function requires.
+ */
+/**
+ * @ngdoc method
+ * @name $injector#loadNewModules
+ *
+ * @description
+ *
+ * **This is a dangerous API, which you use at your own risk!**
+ *
+ * Add the specified modules to the current injector.
+ *
+ * This method will add each of the injectables to the injector and execute all of the config and run
+ * blocks for each module passed to the method.
+ *
+ * If a module has already been loaded into the injector then it will not be loaded again.
+ *
+ * * The application developer is responsible for loading the code containing the modules; and for
+ * ensuring that lazy scripts are not downloaded and executed more often that desired.
+ * * Previously compiled HTML will not be affected by newly loaded directives, filters and components.
+ * * Modules cannot be unloaded.
+ *
+ * You can use {@link $injector#modules `$injector.modules`} to check whether a module has been loaded
+ * into the injector, which may indicate whether the script has been executed already.
+ *
+ * @example
+ * Here is an example of loading a bundle of modules, with a utility method called `getScript`:
+ *
+ * ```javascript
+ * app.factory('loadModule', function($injector) {
+ * return function loadModule(moduleName, bundleUrl) {
+ * return getScript(bundleUrl).then(function() { $injector.loadNewModules([moduleName]); });
+ * };
+ * })
+ * ```
+ *
+ * @param {Array<String|Function|Array>=} mods an array of modules to load into the application.
+ * Each item in the array should be the name of a predefined module or a (DI annotated)
+ * function that will be invoked by the injector as a `config` block.
+ * See: {@link angular.module modules}
+ */
+
+
+/**
+ * @ngdoc service
+ * @name $provide
+ *
+ * @description
+ *
+ * The {@link auto.$provide $provide} service has a number of methods for registering components
+ * with the {@link auto.$injector $injector}. Many of these functions are also exposed on
+ * {@link angular.Module}.
+ *
+ * An AngularJS **service** is a singleton object created by a **service factory**. These **service
+ * factories** are functions which, in turn, are created by a **service provider**.
+ * The **service providers** are constructor functions. When instantiated they must contain a
+ * property called `$get`, which holds the **service factory** function.
+ *
+ * When you request a service, the {@link auto.$injector $injector} is responsible for finding the
+ * correct **service provider**, instantiating it and then calling its `$get` **service factory**
+ * function to get the instance of the **service**.
+ *
+ * Often services have no configuration options and there is no need to add methods to the service
+ * provider. The provider will be no more than a constructor function with a `$get` property. For
+ * these cases the {@link auto.$provide $provide} service has additional helper methods to register
+ * services without specifying a provider.
+ *
+ * * {@link auto.$provide#provider provider(name, provider)} - registers a **service provider** with the
+ * {@link auto.$injector $injector}
+ * * {@link auto.$provide#constant constant(name, obj)} - registers a value/object that can be accessed by
+ * providers and services.
+ * * {@link auto.$provide#value value(name, obj)} - registers a value/object that can only be accessed by
+ * services, not providers.
+ * * {@link auto.$provide#factory factory(name, fn)} - registers a service **factory function**
+ * that will be wrapped in a **service provider** object, whose `$get` property will contain the
+ * given factory function.
+ * * {@link auto.$provide#service service(name, Fn)} - registers a **constructor function**
+ * that will be wrapped in a **service provider** object, whose `$get` property will instantiate
+ * a new object using the given constructor function.
+ * * {@link auto.$provide#decorator decorator(name, decorFn)} - registers a **decorator function** that
+ * will be able to modify or replace the implementation of another service.
+ *
+ * See the individual methods for more information and examples.
+ */
+
+/**
+ * @ngdoc method
+ * @name $provide#provider
+ * @description
+ *
+ * Register a **provider function** with the {@link auto.$injector $injector}. Provider functions
+ * are constructor functions, whose instances are responsible for "providing" a factory for a
+ * service.
+ *
+ * Service provider names start with the name of the service they provide followed by `Provider`.
+ * For example, the {@link ng.$log $log} service has a provider called
+ * {@link ng.$logProvider $logProvider}.
+ *
+ * Service provider objects can have additional methods which allow configuration of the provider
+ * and its service. Importantly, you can configure what kind of service is created by the `$get`
+ * method, or how that service will act. For example, the {@link ng.$logProvider $logProvider} has a
+ * method {@link ng.$logProvider#debugEnabled debugEnabled}
+ * which lets you specify whether the {@link ng.$log $log} service will log debug messages to the
+ * console or not.
+ *
+ * It is possible to inject other providers into the provider function,
+ * but the injected provider must have been defined before the one that requires it.
+ *
+ * @param {string} name The name of the instance. NOTE: the provider will be available under `name +
+ 'Provider'` key.
+ * @param {(Object|function())} provider If the provider is:
+ *
+ * - `Object`: then it should have a `$get` method. The `$get` method will be invoked using
+ * {@link auto.$injector#invoke $injector.invoke()} when an instance needs to be created.
+ * - `Constructor`: a new instance of the provider will be created using
+ * {@link auto.$injector#instantiate $injector.instantiate()}, then treated as `object`.
+ *
+ * @returns {Object} registered provider instance
+
+ * @example
+ *
+ * The following example shows how to create a simple event tracking service and register it using
+ * {@link auto.$provide#provider $provide.provider()}.
+ *
+ * ```js
+ * // Define the eventTracker provider
+ * function EventTrackerProvider() {
+ * var trackingUrl = '/track';
+ *
+ * // A provider method for configuring where the tracked events should been saved
+ * this.setTrackingUrl = function(url) {
+ * trackingUrl = url;
+ * };
+ *
+ * // The service factory function
+ * this.$get = ['$http', function($http) {
+ * var trackedEvents = {};
+ * return {
+ * // Call this to track an event
+ * event: function(event) {
+ * var count = trackedEvents[event] || 0;
+ * count += 1;
+ * trackedEvents[event] = count;
+ * return count;
+ * },
+ * // Call this to save the tracked events to the trackingUrl
+ * save: function() {
+ * $http.post(trackingUrl, trackedEvents);
+ * }
+ * };
+ * }];
+ * }
+ *
+ * describe('eventTracker', function() {
+ * var postSpy;
+ *
+ * beforeEach(module(function($provide) {
+ * // Register the eventTracker provider
+ * $provide.provider('eventTracker', EventTrackerProvider);
+ * }));
+ *
+ * beforeEach(module(function(eventTrackerProvider) {
+ * // Configure eventTracker provider
+ * eventTrackerProvider.setTrackingUrl('/custom-track');
+ * }));
+ *
+ * it('tracks events', inject(function(eventTracker) {
+ * expect(eventTracker.event('login')).toEqual(1);
+ * expect(eventTracker.event('login')).toEqual(2);
+ * }));
+ *
+ * it('saves to the tracking url', inject(function(eventTracker, $http) {
+ * postSpy = spyOn($http, 'post');
+ * eventTracker.event('login');
+ * eventTracker.save();
+ * expect(postSpy).toHaveBeenCalled();
+ * expect(postSpy.mostRecentCall.args[0]).not.toEqual('/track');
+ * expect(postSpy.mostRecentCall.args[0]).toEqual('/custom-track');
+ * expect(postSpy.mostRecentCall.args[1]).toEqual({ 'login': 1 });
+ * }));
+ * });
+ * ```
+ */
+
+/**
+ * @ngdoc method
+ * @name $provide#factory
+ * @description
+ *
+ * Register a **service factory**, which will be called to return the service instance.
+ * This is short for registering a service where its provider consists of only a `$get` property,
+ * which is the given service factory function.
+ * You should use {@link auto.$provide#factory $provide.factory(getFn)} if you do not need to
+ * configure your service in a provider.
+ *
+ * @param {string} name The name of the instance.
+ * @param {Function|Array.<string|Function>} $getFn The injectable $getFn for the instance creation.
+ * Internally this is a short hand for `$provide.provider(name, {$get: $getFn})`.
+ * @returns {Object} registered provider instance
+ *
+ * @example
+ * Here is an example of registering a service
+ * ```js
+ * $provide.factory('ping', ['$http', function($http) {
+ * return function ping() {
+ * return $http.send('/ping');
+ * };
+ * }]);
+ * ```
+ * You would then inject and use this service like this:
+ * ```js
+ * someModule.controller('Ctrl', ['ping', function(ping) {
+ * ping();
+ * }]);
+ * ```
+ */
+
+
+/**
+ * @ngdoc method
+ * @name $provide#service
+ * @description
+ *
+ * Register a **service constructor**, which will be invoked with `new` to create the service
+ * instance.
+ * This is short for registering a service where its provider's `$get` property is a factory
+ * function that returns an instance instantiated by the injector from the service constructor
+ * function.
+ *
+ * Internally it looks a bit like this:
+ *
+ * ```
+ * {
+ * $get: function() {
+ * return $injector.instantiate(constructor);
+ * }
+ * }
+ * ```
+ *
+ *
+ * You should use {@link auto.$provide#service $provide.service(class)} if you define your service
+ * as a type/class.
+ *
+ * @param {string} name The name of the instance.
+ * @param {Function|Array.<string|Function>} constructor An injectable class (constructor function)
+ * that will be instantiated.
+ * @returns {Object} registered provider instance
+ *
+ * @example
+ * Here is an example of registering a service using
+ * {@link auto.$provide#service $provide.service(class)}.
+ * ```js
+ * var Ping = function($http) {
+ * this.$http = $http;
+ * };
+ *
+ * Ping.$inject = ['$http'];
+ *
+ * Ping.prototype.send = function() {
+ * return this.$http.get('/ping');
+ * };
+ * $provide.service('ping', Ping);
+ * ```
+ * You would then inject and use this service like this:
+ * ```js
+ * someModule.controller('Ctrl', ['ping', function(ping) {
+ * ping.send();
+ * }]);
+ * ```
+ */
+
+
+/**
+ * @ngdoc method
+ * @name $provide#value
+ * @description
+ *
+ * Register a **value service** with the {@link auto.$injector $injector}, such as a string, a
+ * number, an array, an object or a function. This is short for registering a service where its
+ * provider's `$get` property is a factory function that takes no arguments and returns the **value
+ * service**. That also means it is not possible to inject other services into a value service.
+ *
+ * Value services are similar to constant services, except that they cannot be injected into a
+ * module configuration function (see {@link angular.Module#config}) but they can be overridden by
+ * an AngularJS {@link auto.$provide#decorator decorator}.
+ *
+ * @param {string} name The name of the instance.
+ * @param {*} value The value.
+ * @returns {Object} registered provider instance
+ *
+ * @example
+ * Here are some examples of creating value services.
+ * ```js
+ * $provide.value('ADMIN_USER', 'admin');
+ *
+ * $provide.value('RoleLookup', { admin: 0, writer: 1, reader: 2 });
+ *
+ * $provide.value('halfOf', function(value) {
+ * return value / 2;
+ * });
+ * ```
+ */
+
+
+/**
+ * @ngdoc method
+ * @name $provide#constant
+ * @description
+ *
+ * Register a **constant service** with the {@link auto.$injector $injector}, such as a string,
+ * a number, an array, an object or a function. Like the {@link auto.$provide#value value}, it is not
+ * possible to inject other services into a constant.
+ *
+ * But unlike {@link auto.$provide#value value}, a constant can be
+ * injected into a module configuration function (see {@link angular.Module#config}) and it cannot
+ * be overridden by an AngularJS {@link auto.$provide#decorator decorator}.
+ *
+ * @param {string} name The name of the constant.
+ * @param {*} value The constant value.
+ * @returns {Object} registered instance
+ *
+ * @example
+ * Here a some examples of creating constants:
+ * ```js
+ * $provide.constant('SHARD_HEIGHT', 306);
+ *
+ * $provide.constant('MY_COLOURS', ['red', 'blue', 'grey']);
+ *
+ * $provide.constant('double', function(value) {
+ * return value * 2;
+ * });
+ * ```
+ */
+
+
+/**
+ * @ngdoc method
+ * @name $provide#decorator
+ * @description
+ *
+ * Register a **decorator function** with the {@link auto.$injector $injector}. A decorator function
+ * intercepts the creation of a service, allowing it to override or modify the behavior of the
+ * service. The return value of the decorator function may be the original service, or a new service
+ * that replaces (or wraps and delegates to) the original service.
+ *
+ * You can find out more about using decorators in the {@link guide/decorators} guide.
+ *
+ * @param {string} name The name of the service to decorate.
+ * @param {Function|Array.<string|Function>} decorator This function will be invoked when the service needs to be
+ * provided and should return the decorated service instance. The function is called using
+ * the {@link auto.$injector#invoke injector.invoke} method and is therefore fully injectable.
+ * Local injection arguments:
+ *
+ * * `$delegate` - The original service instance, which can be replaced, monkey patched, configured,
+ * decorated or delegated to.
+ *
+ * @example
+ * Here we decorate the {@link ng.$log $log} service to convert warnings to errors by intercepting
+ * calls to {@link ng.$log#error $log.warn()}.
+ * ```js
+ * $provide.decorator('$log', ['$delegate', function($delegate) {
+ * $delegate.warn = $delegate.error;
+ * return $delegate;
+ * }]);
+ * ```
+ */
+
+
+function createInjector(modulesToLoad, strictDi) {
+ strictDi = (strictDi === true);
+ var INSTANTIATING = {},
+ providerSuffix = 'Provider',
+ path = [],
+ loadedModules = new NgMap(),
+ providerCache = {
+ $provide: {
+ provider: supportObject(provider),
+ factory: supportObject(factory),
+ service: supportObject(service),
+ value: supportObject(value),
+ constant: supportObject(constant),
+ decorator: decorator
+ }
+ },
+ providerInjector = (providerCache.$injector =
+ createInternalInjector(providerCache, function(serviceName, caller) {
+ if (angular.isString(caller)) {
+ path.push(caller);
+ }
+ throw $injectorMinErr('unpr', 'Unknown provider: {0}', path.join(' <- '));
+ })),
+ instanceCache = {},
+ protoInstanceInjector =
+ createInternalInjector(instanceCache, function(serviceName, caller) {
+ var provider = providerInjector.get(serviceName + providerSuffix, caller);
+ return instanceInjector.invoke(
+ provider.$get, provider, undefined, serviceName);
+ }),
+ instanceInjector = protoInstanceInjector;
+
+ providerCache['$injector' + providerSuffix] = { $get: valueFn(protoInstanceInjector) };
+ instanceInjector.modules = providerInjector.modules = createMap();
+ var runBlocks = loadModules(modulesToLoad);
+ instanceInjector = protoInstanceInjector.get('$injector');
+ instanceInjector.strictDi = strictDi;
+ forEach(runBlocks, function(fn) { if (fn) instanceInjector.invoke(fn); });
+
+ instanceInjector.loadNewModules = function(mods) {
+ forEach(loadModules(mods), function(fn) { if (fn) instanceInjector.invoke(fn); });
+ };
+
+
+ return instanceInjector;
+
+ ////////////////////////////////////
+ // $provider
+ ////////////////////////////////////
+
+ function supportObject(delegate) {
+ return function(key, value) {
+ if (isObject(key)) {
+ forEach(key, reverseParams(delegate));
+ } else {
+ return delegate(key, value);
+ }
+ };
+ }
+
+ function provider(name, provider_) {
+ assertNotHasOwnProperty(name, 'service');
+ if (isFunction(provider_) || isArray(provider_)) {
+ provider_ = providerInjector.instantiate(provider_);
+ }
+ if (!provider_.$get) {
+ throw $injectorMinErr('pget', 'Provider \'{0}\' must define $get factory method.', name);
+ }
+ return (providerCache[name + providerSuffix] = provider_);
+ }
+
+ function enforceReturnValue(name, factory) {
+ return /** @this */ function enforcedReturnValue() {
+ var result = instanceInjector.invoke(factory, this);
+ if (isUndefined(result)) {
+ throw $injectorMinErr('undef', 'Provider \'{0}\' must return a value from $get factory method.', name);
+ }
+ return result;
+ };
+ }
+
+ function factory(name, factoryFn, enforce) {
+ return provider(name, {
+ $get: enforce !== false ? enforceReturnValue(name, factoryFn) : factoryFn
+ });
+ }
+
+ function service(name, constructor) {
+ return factory(name, ['$injector', function($injector) {
+ return $injector.instantiate(constructor);
+ }]);
+ }
+
+ function value(name, val) { return factory(name, valueFn(val), false); }
+
+ function constant(name, value) {
+ assertNotHasOwnProperty(name, 'constant');
+ providerCache[name] = value;
+ instanceCache[name] = value;
+ }
+
+ function decorator(serviceName, decorFn) {
+ var origProvider = providerInjector.get(serviceName + providerSuffix),
+ orig$get = origProvider.$get;
+
+ origProvider.$get = function() {
+ var origInstance = instanceInjector.invoke(orig$get, origProvider);
+ return instanceInjector.invoke(decorFn, null, {$delegate: origInstance});
+ };
+ }
+
+ ////////////////////////////////////
+ // Module Loading
+ ////////////////////////////////////
+ function loadModules(modulesToLoad) {
+ assertArg(isUndefined(modulesToLoad) || isArray(modulesToLoad), 'modulesToLoad', 'not an array');
+ var runBlocks = [], moduleFn;
+ forEach(modulesToLoad, function(module) {
+ if (loadedModules.get(module)) return;
+ loadedModules.set(module, true);
+
+ function runInvokeQueue(queue) {
+ var i, ii;
+ for (i = 0, ii = queue.length; i < ii; i++) {
+ var invokeArgs = queue[i],
+ provider = providerInjector.get(invokeArgs[0]);
+
+ provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
+ }
+ }
+
+ try {
+ if (isString(module)) {
+ moduleFn = angularModule(module);
+ instanceInjector.modules[module] = moduleFn;
+ runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks);
+ runInvokeQueue(moduleFn._invokeQueue);
+ runInvokeQueue(moduleFn._configBlocks);
+ } else if (isFunction(module)) {
+ runBlocks.push(providerInjector.invoke(module));
+ } else if (isArray(module)) {
+ runBlocks.push(providerInjector.invoke(module));
+ } else {
+ assertArgFn(module, 'module');
+ }
+ } catch (e) {
+ if (isArray(module)) {
+ module = module[module.length - 1];
+ }
+ if (e.message && e.stack && e.stack.indexOf(e.message) === -1) {
+ // Safari & FF's stack traces don't contain error.message content
+ // unlike those of Chrome and IE
+ // So if stack doesn't contain message, we create a new string that contains both.
+ // Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.
+ // eslint-disable-next-line no-ex-assign
+ e = e.message + '\n' + e.stack;
+ }
+ throw $injectorMinErr('modulerr', 'Failed to instantiate module {0} due to:\n{1}',
+ module, e.stack || e.message || e);
+ }
+ });
+ return runBlocks;
+ }
+
+ ////////////////////////////////////
+ // internal Injector
+ ////////////////////////////////////
+
+ function createInternalInjector(cache, factory) {
+
+ function getService(serviceName, caller) {
+ if (cache.hasOwnProperty(serviceName)) {
+ if (cache[serviceName] === INSTANTIATING) {
+ throw $injectorMinErr('cdep', 'Circular dependency found: {0}',
+ serviceName + ' <- ' + path.join(' <- '));
+ }
+ return cache[serviceName];
+ } else {
+ try {
+ path.unshift(serviceName);
+ cache[serviceName] = INSTANTIATING;
+ cache[serviceName] = factory(serviceName, caller);
+ return cache[serviceName];
+ } catch (err) {
+ if (cache[serviceName] === INSTANTIATING) {
+ delete cache[serviceName];
+ }
+ throw err;
+ } finally {
+ path.shift();
+ }
+ }
+ }
+
+
+ function injectionArgs(fn, locals, serviceName) {
+ var args = [],
+ $inject = createInjector.$$annotate(fn, strictDi, serviceName);
+
+ for (var i = 0, length = $inject.length; i < length; i++) {
+ var key = $inject[i];
+ if (typeof key !== 'string') {
+ throw $injectorMinErr('itkn',
+ 'Incorrect injection token! Expected service name as string, got {0}', key);
+ }
+ args.push(locals && locals.hasOwnProperty(key) ? locals[key] :
+ getService(key, serviceName));
+ }
+ return args;
+ }
+
+ function isClass(func) {
+ // Support: IE 9-11 only
+ // IE 9-11 do not support classes and IE9 leaks with the code below.
+ if (msie || typeof func !== 'function') {
+ return false;
+ }
+ var result = func.$$ngIsClass;
+ if (!isBoolean(result)) {
+ result = func.$$ngIsClass = /^class\b/.test(stringifyFn(func));
+ }
+ return result;
+ }
+
+ function invoke(fn, self, locals, serviceName) {
+ if (typeof locals === 'string') {
+ serviceName = locals;
+ locals = null;
+ }
+
+ var args = injectionArgs(fn, locals, serviceName);
+ if (isArray(fn)) {
+ fn = fn[fn.length - 1];
+ }
+
+ if (!isClass(fn)) {
+ // http://jsperf.com/angularjs-invoke-apply-vs-switch
+ // #5388
+ return fn.apply(self, args);
+ } else {
+ args.unshift(null);
+ return new (Function.prototype.bind.apply(fn, args))();
+ }
+ }
+
+
+ function instantiate(Type, locals, serviceName) {
+ // Check if Type is annotated and use just the given function at n-1 as parameter
+ // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
+ var ctor = (isArray(Type) ? Type[Type.length - 1] : Type);
+ var args = injectionArgs(Type, locals, serviceName);
+ // Empty object at position 0 is ignored for invocation with `new`, but required.
+ args.unshift(null);
+ return new (Function.prototype.bind.apply(ctor, args))();
+ }
+
+
+ return {
+ invoke: invoke,
+ instantiate: instantiate,
+ get: getService,
+ annotate: createInjector.$$annotate,
+ has: function(name) {
+ return providerCache.hasOwnProperty(name + providerSuffix) || cache.hasOwnProperty(name);
+ }
+ };
+ }
+}
+
+createInjector.$$annotate = annotate;
+
+/**
+ * @ngdoc provider
+ * @name $anchorScrollProvider
+ * @this
+ *
+ * @description
+ * Use `$anchorScrollProvider` to disable automatic scrolling whenever
+ * {@link ng.$location#hash $location.hash()} changes.
+ */
+function $AnchorScrollProvider() {
+
+ var autoScrollingEnabled = true;
+
+ /**
+ * @ngdoc method
+ * @name $anchorScrollProvider#disableAutoScrolling
+ *
+ * @description
+ * By default, {@link ng.$anchorScroll $anchorScroll()} will automatically detect changes to
+ * {@link ng.$location#hash $location.hash()} and scroll to the element matching the new hash.<br />
+ * Use this method to disable automatic scrolling.
+ *
+ * If automatic scrolling is disabled, one must explicitly call
+ * {@link ng.$anchorScroll $anchorScroll()} in order to scroll to the element related to the
+ * current hash.
+ */
+ this.disableAutoScrolling = function() {
+ autoScrollingEnabled = false;
+ };
+
+ /**
+ * @ngdoc service
+ * @name $anchorScroll
+ * @kind function
+ * @requires $window
+ * @requires $location
+ * @requires $rootScope
+ *
+ * @description
+ * When called, it scrolls to the element related to the specified `hash` or (if omitted) to the
+ * current value of {@link ng.$location#hash $location.hash()}, according to the rules specified
+ * in the
+ * [HTML5 spec](http://www.w3.org/html/wg/drafts/html/master/browsers.html#an-indicated-part-of-the-document).
+ *
+ * It also watches the {@link ng.$location#hash $location.hash()} and automatically scrolls to
+ * match any anchor whenever it changes. This can be disabled by calling
+ * {@link ng.$anchorScrollProvider#disableAutoScrolling $anchorScrollProvider.disableAutoScrolling()}.
+ *
+ * Additionally, you can use its {@link ng.$anchorScroll#yOffset yOffset} property to specify a
+ * vertical scroll-offset (either fixed or dynamic).
+ *
+ * @param {string=} hash The hash specifying the element to scroll to. If omitted, the value of
+ * {@link ng.$location#hash $location.hash()} will be used.
+ *
+ * @property {(number|function|jqLite)} yOffset
+ * If set, specifies a vertical scroll-offset. This is often useful when there are fixed
+ * positioned elements at the top of the page, such as navbars, headers etc.
+ *
+ * `yOffset` can be specified in various ways:
+ * - **number**: A fixed number of pixels to be used as offset.<br /><br />
+ * - **function**: A getter function called everytime `$anchorScroll()` is executed. Must return
+ * a number representing the offset (in pixels).<br /><br />
+ * - **jqLite**: A jqLite/jQuery element to be used for specifying the offset. The distance from
+ * the top of the page to the element's bottom will be used as offset.<br />
+ * **Note**: The element will be taken into account only as long as its `position` is set to
+ * `fixed`. This option is useful, when dealing with responsive navbars/headers that adjust
+ * their height and/or positioning according to the viewport's size.
+ *
+ * <br />
+ * <div class="alert alert-warning">
+ * In order for `yOffset` to work properly, scrolling should take place on the document's root and
+ * not some child element.
+ * </div>
+ *
+ * @example
+ <example module="anchorScrollExample" name="anchor-scroll">
+ <file name="index.html">
+ <div id="scrollArea" ng-controller="ScrollController">
+ <a ng-click="gotoBottom()">Go to bottom</a>
+ <a id="bottom"></a> You're at the bottom!
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('anchorScrollExample', [])
+ .controller('ScrollController', ['$scope', '$location', '$anchorScroll',
+ function($scope, $location, $anchorScroll) {
+ $scope.gotoBottom = function() {
+ // set the location.hash to the id of
+ // the element you wish to scroll to.
+ $location.hash('bottom');
+
+ // call $anchorScroll()
+ $anchorScroll();
+ };
+ }]);
+ </file>
+ <file name="style.css">
+ #scrollArea {
+ height: 280px;
+ overflow: auto;
+ }
+
+ #bottom {
+ display: block;
+ margin-top: 2000px;
+ }
+ </file>
+ </example>
+ *
+ * <hr />
+ * The example below illustrates the use of a vertical scroll-offset (specified as a fixed value).
+ * See {@link ng.$anchorScroll#yOffset $anchorScroll.yOffset} for more details.
+ *
+ * @example
+ <example module="anchorScrollOffsetExample" name="anchor-scroll-offset">
+ <file name="index.html">
+ <div class="fixed-header" ng-controller="headerCtrl">
+ <a href="" ng-click="gotoAnchor(x)" ng-repeat="x in [1,2,3,4,5]">
+ Go to anchor {{x}}
+ </a>
+ </div>
+ <div id="anchor{{x}}" class="anchor" ng-repeat="x in [1,2,3,4,5]">
+ Anchor {{x}} of 5
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('anchorScrollOffsetExample', [])
+ .run(['$anchorScroll', function($anchorScroll) {
+ $anchorScroll.yOffset = 50; // always scroll by 50 extra pixels
+ }])
+ .controller('headerCtrl', ['$anchorScroll', '$location', '$scope',
+ function($anchorScroll, $location, $scope) {
+ $scope.gotoAnchor = function(x) {
+ var newHash = 'anchor' + x;
+ if ($location.hash() !== newHash) {
+ // set the $location.hash to `newHash` and
+ // $anchorScroll will automatically scroll to it
+ $location.hash('anchor' + x);
+ } else {
+ // call $anchorScroll() explicitly,
+ // since $location.hash hasn't changed
+ $anchorScroll();
+ }
+ };
+ }
+ ]);
+ </file>
+ <file name="style.css">
+ body {
+ padding-top: 50px;
+ }
+
+ .anchor {
+ border: 2px dashed DarkOrchid;
+ padding: 10px 10px 200px 10px;
+ }
+
+ .fixed-header {
+ background-color: rgba(0, 0, 0, 0.2);
+ height: 50px;
+ position: fixed;
+ top: 0; left: 0; right: 0;
+ }
+
+ .fixed-header > a {
+ display: inline-block;
+ margin: 5px 15px;
+ }
+ </file>
+ </example>
+ */
+ this.$get = ['$window', '$location', '$rootScope', function($window, $location, $rootScope) {
+ var document = $window.document;
+
+ // Helper function to get first anchor from a NodeList
+ // (using `Array#some()` instead of `angular#forEach()` since it's more performant
+ // and working in all supported browsers.)
+ function getFirstAnchor(list) {
+ var result = null;
+ Array.prototype.some.call(list, function(element) {
+ if (nodeName_(element) === 'a') {
+ result = element;
+ return true;
+ }
+ });
+ return result;
+ }
+
+ function getYOffset() {
+
+ var offset = scroll.yOffset;
+
+ if (isFunction(offset)) {
+ offset = offset();
+ } else if (isElement(offset)) {
+ var elem = offset[0];
+ var style = $window.getComputedStyle(elem);
+ if (style.position !== 'fixed') {
+ offset = 0;
+ } else {
+ offset = elem.getBoundingClientRect().bottom;
+ }
+ } else if (!isNumber(offset)) {
+ offset = 0;
+ }
+
+ return offset;
+ }
+
+ function scrollTo(elem) {
+ if (elem) {
+ elem.scrollIntoView();
+
+ var offset = getYOffset();
+
+ if (offset) {
+ // `offset` is the number of pixels we should scroll UP in order to align `elem` properly.
+ // This is true ONLY if the call to `elem.scrollIntoView()` initially aligns `elem` at the
+ // top of the viewport.
+ //
+ // IF the number of pixels from the top of `elem` to the end of the page's content is less
+ // than the height of the viewport, then `elem.scrollIntoView()` will align the `elem` some
+ // way down the page.
+ //
+ // This is often the case for elements near the bottom of the page.
+ //
+ // In such cases we do not need to scroll the whole `offset` up, just the difference between
+ // the top of the element and the offset, which is enough to align the top of `elem` at the
+ // desired position.
+ var elemTop = elem.getBoundingClientRect().top;
+ $window.scrollBy(0, elemTop - offset);
+ }
+ } else {
+ $window.scrollTo(0, 0);
+ }
+ }
+
+ function scroll(hash) {
+ // Allow numeric hashes
+ hash = isString(hash) ? hash : isNumber(hash) ? hash.toString() : $location.hash();
+ var elm;
+
+ // empty hash, scroll to the top of the page
+ if (!hash) scrollTo(null);
+
+ // element with given id
+ else if ((elm = document.getElementById(hash))) scrollTo(elm);
+
+ // first anchor with given name :-D
+ else if ((elm = getFirstAnchor(document.getElementsByName(hash)))) scrollTo(elm);
+
+ // no element and hash === 'top', scroll to the top of the page
+ else if (hash === 'top') scrollTo(null);
+ }
+
+ // does not scroll when user clicks on anchor link that is currently on
+ // (no url change, no $location.hash() change), browser native does scroll
+ if (autoScrollingEnabled) {
+ $rootScope.$watch(function autoScrollWatch() {return $location.hash();},
+ function autoScrollWatchAction(newVal, oldVal) {
+ // skip the initial scroll if $location.hash is empty
+ if (newVal === oldVal && newVal === '') return;
+
+ jqLiteDocumentLoaded(function() {
+ $rootScope.$evalAsync(scroll);
+ });
+ });
+ }
+
+ return scroll;
+ }];
+}
+
+var $animateMinErr = minErr('$animate');
+var ELEMENT_NODE = 1;
+var NG_ANIMATE_CLASSNAME = 'ng-animate';
+
+function mergeClasses(a,b) {
+ if (!a && !b) return '';
+ if (!a) return b;
+ if (!b) return a;
+ if (isArray(a)) a = a.join(' ');
+ if (isArray(b)) b = b.join(' ');
+ return a + ' ' + b;
+}
+
+function extractElementNode(element) {
+ for (var i = 0; i < element.length; i++) {
+ var elm = element[i];
+ if (elm.nodeType === ELEMENT_NODE) {
+ return elm;
+ }
+ }
+}
+
+function splitClasses(classes) {
+ if (isString(classes)) {
+ classes = classes.split(' ');
+ }
+
+ // Use createMap() to prevent class assumptions involving property names in
+ // Object.prototype
+ var obj = createMap();
+ forEach(classes, function(klass) {
+ // sometimes the split leaves empty string values
+ // incase extra spaces were applied to the options
+ if (klass.length) {
+ obj[klass] = true;
+ }
+ });
+ return obj;
+}
+
+// if any other type of options value besides an Object value is
+// passed into the $animate.method() animation then this helper code
+// will be run which will ignore it. While this patch is not the
+// greatest solution to this, a lot of existing plugins depend on
+// $animate to either call the callback (< 1.2) or return a promise
+// that can be changed. This helper function ensures that the options
+// are wiped clean incase a callback function is provided.
+function prepareAnimateOptions(options) {
+ return isObject(options)
+ ? options
+ : {};
+}
+
+var $$CoreAnimateJsProvider = /** @this */ function() {
+ this.$get = noop;
+};
+
+// this is prefixed with Core since it conflicts with
+// the animateQueueProvider defined in ngAnimate/animateQueue.js
+var $$CoreAnimateQueueProvider = /** @this */ function() {
+ var postDigestQueue = new NgMap();
+ var postDigestElements = [];
+
+ this.$get = ['$$AnimateRunner', '$rootScope',
+ function($$AnimateRunner, $rootScope) {
+ return {
+ enabled: noop,
+ on: noop,
+ off: noop,
+ pin: noop,
+
+ push: function(element, event, options, domOperation) {
+ if (domOperation) {
+ domOperation();
+ }
+
+ options = options || {};
+ if (options.from) {
+ element.css(options.from);
+ }
+ if (options.to) {
+ element.css(options.to);
+ }
+
+ if (options.addClass || options.removeClass) {
+ addRemoveClassesPostDigest(element, options.addClass, options.removeClass);
+ }
+
+ var runner = new $$AnimateRunner();
+
+ // since there are no animations to run the runner needs to be
+ // notified that the animation call is complete.
+ runner.complete();
+ return runner;
+ }
+ };
+
+
+ function updateData(data, classes, value) {
+ var changed = false;
+ if (classes) {
+ classes = isString(classes) ? classes.split(' ') :
+ isArray(classes) ? classes : [];
+ forEach(classes, function(className) {
+ if (className) {
+ changed = true;
+ data[className] = value;
+ }
+ });
+ }
+ return changed;
+ }
+
+ function handleCSSClassChanges() {
+ forEach(postDigestElements, function(element) {
+ var data = postDigestQueue.get(element);
+ if (data) {
+ var existing = splitClasses(element.attr('class'));
+ var toAdd = '';
+ var toRemove = '';
+ forEach(data, function(status, className) {
+ var hasClass = !!existing[className];
+ if (status !== hasClass) {
+ if (status) {
+ toAdd += (toAdd.length ? ' ' : '') + className;
+ } else {
+ toRemove += (toRemove.length ? ' ' : '') + className;
+ }
+ }
+ });
+
+ forEach(element, function(elm) {
+ if (toAdd) {
+ jqLiteAddClass(elm, toAdd);
+ }
+ if (toRemove) {
+ jqLiteRemoveClass(elm, toRemove);
+ }
+ });
+ postDigestQueue.delete(element);
+ }
+ });
+ postDigestElements.length = 0;
+ }
+
+
+ function addRemoveClassesPostDigest(element, add, remove) {
+ var data = postDigestQueue.get(element) || {};
+
+ var classesAdded = updateData(data, add, true);
+ var classesRemoved = updateData(data, remove, false);
+
+ if (classesAdded || classesRemoved) {
+
+ postDigestQueue.set(element, data);
+ postDigestElements.push(element);
+
+ if (postDigestElements.length === 1) {
+ $rootScope.$$postDigest(handleCSSClassChanges);
+ }
+ }
+ }
+ }];
+};
+
+/**
+ * @ngdoc provider
+ * @name $animateProvider
+ *
+ * @description
+ * Default implementation of $animate that doesn't perform any animations, instead just
+ * synchronously performs DOM updates and resolves the returned runner promise.
+ *
+ * In order to enable animations the `ngAnimate` module has to be loaded.
+ *
+ * To see the functional implementation check out `src/ngAnimate/animate.js`.
+ */
+var $AnimateProvider = ['$provide', /** @this */ function($provide) {
+ var provider = this;
+ var classNameFilter = null;
+ var customFilter = null;
+
+ this.$$registeredAnimations = Object.create(null);
+
+ /**
+ * @ngdoc method
+ * @name $animateProvider#register
+ *
+ * @description
+ * Registers a new injectable animation factory function. The factory function produces the
+ * animation object which contains callback functions for each event that is expected to be
+ * animated.
+ *
+ * * `eventFn`: `function(element, ... , doneFunction, options)`
+ * The element to animate, the `doneFunction` and the options fed into the animation. Depending
+ * on the type of animation additional arguments will be injected into the animation function. The
+ * list below explains the function signatures for the different animation methods:
+ *
+ * - setClass: function(element, addedClasses, removedClasses, doneFunction, options)
+ * - addClass: function(element, addedClasses, doneFunction, options)
+ * - removeClass: function(element, removedClasses, doneFunction, options)
+ * - enter, leave, move: function(element, doneFunction, options)
+ * - animate: function(element, fromStyles, toStyles, doneFunction, options)
+ *
+ * Make sure to trigger the `doneFunction` once the animation is fully complete.
+ *
+ * ```js
+ * return {
+ * //enter, leave, move signature
+ * eventFn : function(element, done, options) {
+ * //code to run the animation
+ * //once complete, then run done()
+ * return function endFunction(wasCancelled) {
+ * //code to cancel the animation
+ * }
+ * }
+ * }
+ * ```
+ *
+ * @param {string} name The name of the animation (this is what the class-based CSS value will be compared to).
+ * @param {Function} factory The factory function that will be executed to return the animation
+ * object.
+ */
+ this.register = function(name, factory) {
+ if (name && name.charAt(0) !== '.') {
+ throw $animateMinErr('notcsel', 'Expecting class selector starting with \'.\' got \'{0}\'.', name);
+ }
+
+ var key = name + '-animation';
+ provider.$$registeredAnimations[name.substr(1)] = key;
+ $provide.factory(key, factory);
+ };
+
+ /**
+ * @ngdoc method
+ * @name $animateProvider#customFilter
+ *
+ * @description
+ * Sets and/or returns the custom filter function that is used to "filter" animations, i.e.
+ * determine if an animation is allowed or not. When no filter is specified (the default), no
+ * animation will be blocked. Setting the `customFilter` value will only allow animations for
+ * which the filter function's return value is truthy.
+ *
+ * This allows to easily create arbitrarily complex rules for filtering animations, such as
+ * allowing specific events only, or enabling animations on specific subtrees of the DOM, etc.
+ * Filtering animations can also boost performance for low-powered devices, as well as
+ * applications containing a lot of structural operations.
+ *
+ * <div class="alert alert-success">
+ * **Best Practice:**
+ * Keep the filtering function as lean as possible, because it will be called for each DOM
+ * action (e.g. insertion, removal, class change) performed by "animation-aware" directives.
+ * See {@link guide/animations#which-directives-support-animations- here} for a list of built-in
+ * directives that support animations.
+ * Performing computationally expensive or time-consuming operations on each call of the
+ * filtering function can make your animations sluggish.
+ * </div>
+ *
+ * **Note:** If present, `customFilter` will be checked before
+ * {@link $animateProvider#classNameFilter classNameFilter}.
+ *
+ * @param {Function=} filterFn - The filter function which will be used to filter all animations.
+ * If a falsy value is returned, no animation will be performed. The function will be called
+ * with the following arguments:
+ * - **node** `{DOMElement}` - The DOM element to be animated.
+ * - **event** `{String}` - The name of the animation event (e.g. `enter`, `leave`, `addClass`
+ * etc).
+ * - **options** `{Object}` - A collection of options/styles used for the animation.
+ * @return {Function} The current filter function or `null` if there is none set.
+ */
+ this.customFilter = function(filterFn) {
+ if (arguments.length === 1) {
+ customFilter = isFunction(filterFn) ? filterFn : null;
+ }
+
+ return customFilter;
+ };
+
+ /**
+ * @ngdoc method
+ * @name $animateProvider#classNameFilter
+ *
+ * @description
+ * Sets and/or returns the CSS class regular expression that is checked when performing
+ * an animation. Upon bootstrap the classNameFilter value is not set at all and will
+ * therefore enable $animate to attempt to perform an animation on any element that is triggered.
+ * When setting the `classNameFilter` value, animations will only be performed on elements
+ * that successfully match the filter expression. This in turn can boost performance
+ * for low-powered devices as well as applications containing a lot of structural operations.
+ *
+ * **Note:** If present, `classNameFilter` will be checked after
+ * {@link $animateProvider#customFilter customFilter}. If `customFilter` is present and returns
+ * false, `classNameFilter` will not be checked.
+ *
+ * @param {RegExp=} expression The className expression which will be checked against all animations
+ * @return {RegExp} The current CSS className expression value. If null then there is no expression value
+ */
+ this.classNameFilter = function(expression) {
+ if (arguments.length === 1) {
+ classNameFilter = (expression instanceof RegExp) ? expression : null;
+ if (classNameFilter) {
+ var reservedRegex = new RegExp('[(\\s|\\/)]' + NG_ANIMATE_CLASSNAME + '[(\\s|\\/)]');
+ if (reservedRegex.test(classNameFilter.toString())) {
+ classNameFilter = null;
+ throw $animateMinErr('nongcls', '$animateProvider.classNameFilter(regex) prohibits accepting a regex value which matches/contains the "{0}" CSS class.', NG_ANIMATE_CLASSNAME);
+ }
+ }
+ }
+ return classNameFilter;
+ };
+
+ this.$get = ['$$animateQueue', function($$animateQueue) {
+ function domInsert(element, parentElement, afterElement) {
+ // if for some reason the previous element was removed
+ // from the dom sometime before this code runs then let's
+ // just stick to using the parent element as the anchor
+ if (afterElement) {
+ var afterNode = extractElementNode(afterElement);
+ if (afterNode && !afterNode.parentNode && !afterNode.previousElementSibling) {
+ afterElement = null;
+ }
+ }
+ if (afterElement) {
+ afterElement.after(element);
+ } else {
+ parentElement.prepend(element);
+ }
+ }
+
+ /**
+ * @ngdoc service
+ * @name $animate
+ * @description The $animate service exposes a series of DOM utility methods that provide support
+ * for animation hooks. The default behavior is the application of DOM operations, however,
+ * when an animation is detected (and animations are enabled), $animate will do the heavy lifting
+ * to ensure that animation runs with the triggered DOM operation.
+ *
+ * By default $animate doesn't trigger any animations. This is because the `ngAnimate` module isn't
+ * included and only when it is active then the animation hooks that `$animate` triggers will be
+ * functional. Once active then all structural `ng-` directives will trigger animations as they perform
+ * their DOM-related operations (enter, leave and move). Other directives such as `ngClass`,
+ * `ngShow`, `ngHide` and `ngMessages` also provide support for animations.
+ *
+ * It is recommended that the`$animate` service is always used when executing DOM-related procedures within directives.
+ *
+ * To learn more about enabling animation support, click here to visit the
+ * {@link ngAnimate ngAnimate module page}.
+ */
+ return {
+ // we don't call it directly since non-existant arguments may
+ // be interpreted as null within the sub enabled function
+
+ /**
+ *
+ * @ngdoc method
+ * @name $animate#on
+ * @kind function
+ * @description Sets up an event listener to fire whenever the animation event (enter, leave, move, etc...)
+ * has fired on the given element or among any of its children. Once the listener is fired, the provided callback
+ * is fired with the following params:
+ *
+ * ```js
+ * $animate.on('enter', container,
+ * function callback(element, phase) {
+ * // cool we detected an enter animation within the container
+ * }
+ * );
+ * ```
+ *
+ * <div class="alert alert-warning">
+ * **Note**: Generally, the events that are fired correspond 1:1 to `$animate` method names,
+ * e.g. {@link ng.$animate#addClass addClass()} will fire `addClass`, and {@link ng.ngClass}
+ * will fire `addClass` if classes are added, and `removeClass` if classes are removed.
+ * However, there are two exceptions:
+ *
+ * <ul>
+ * <li>if both an {@link ng.$animate#addClass addClass()} and a
+ * {@link ng.$animate#removeClass removeClass()} action are performed during the same
+ * animation, the event fired will be `setClass`. This is true even for `ngClass`.</li>
+ * <li>an {@link ng.$animate#animate animate()} call that adds and removes classes will fire
+ * the `setClass` event, but if it either removes or adds classes,
+ * it will fire `animate` instead.</li>
+ * </ul>
+ *
+ * </div>
+ *
+ * @param {string} event the animation event that will be captured (e.g. enter, leave, move, addClass, removeClass, etc...)
+ * @param {DOMElement} container the container element that will capture each of the animation events that are fired on itself
+ * as well as among its children
+ * @param {Function} callback the callback function that will be fired when the listener is triggered.
+ *
+ * The arguments present in the callback function are:
+ * * `element` - The captured DOM element that the animation was fired on.
+ * * `phase` - The phase of the animation. The two possible phases are **start** (when the animation starts) and **close** (when it ends).
+ * * `data` - an object with these properties:
+ * * addClass - `{string|null}` - space-separated CSS classes to add to the element
+ * * removeClass - `{string|null}` - space-separated CSS classes to remove from the element
+ * * from - `{Object|null}` - CSS properties & values at the beginning of the animation
+ * * to - `{Object|null}` - CSS properties & values at the end of the animation
+ *
+ * Note that the callback does not trigger a scope digest. Wrap your call into a
+ * {@link $rootScope.Scope#$apply scope.$apply} to propagate changes to the scope.
+ */
+ on: $$animateQueue.on,
+
+ /**
+ *
+ * @ngdoc method
+ * @name $animate#off
+ * @kind function
+ * @description Deregisters an event listener based on the event which has been associated with the provided element. This method
+ * can be used in three different ways depending on the arguments:
+ *
+ * ```js
+ * // remove all the animation event listeners listening for `enter`
+ * $animate.off('enter');
+ *
+ * // remove listeners for all animation events from the container element
+ * $animate.off(container);
+ *
+ * // remove all the animation event listeners listening for `enter` on the given element and its children
+ * $animate.off('enter', container);
+ *
+ * // remove the event listener function provided by `callback` that is set
+ * // to listen for `enter` on the given `container` as well as its children
+ * $animate.off('enter', container, callback);
+ * ```
+ *
+ * @param {string|DOMElement} event|container the animation event (e.g. enter, leave, move,
+ * addClass, removeClass, etc...), or the container element. If it is the element, all other
+ * arguments are ignored.
+ * @param {DOMElement=} container the container element the event listener was placed on
+ * @param {Function=} callback the callback function that was registered as the listener
+ */
+ off: $$animateQueue.off,
+
+ /**
+ * @ngdoc method
+ * @name $animate#pin
+ * @kind function
+ * @description Associates the provided element with a host parent element to allow the element to be animated even if it exists
+ * outside of the DOM structure of the AngularJS application. By doing so, any animation triggered via `$animate` can be issued on the
+ * element despite being outside the realm of the application or within another application. Say for example if the application
+ * was bootstrapped on an element that is somewhere inside of the `<body>` tag, but we wanted to allow for an element to be situated
+ * as a direct child of `document.body`, then this can be achieved by pinning the element via `$animate.pin(element)`. Keep in mind
+ * that calling `$animate.pin(element, parentElement)` will not actually insert into the DOM anywhere; it will just create the association.
+ *
+ * Note that this feature is only active when the `ngAnimate` module is used.
+ *
+ * @param {DOMElement} element the external element that will be pinned
+ * @param {DOMElement} parentElement the host parent element that will be associated with the external element
+ */
+ pin: $$animateQueue.pin,
+
+ /**
+ *
+ * @ngdoc method
+ * @name $animate#enabled
+ * @kind function
+ * @description Used to get and set whether animations are enabled or not on the entire application or on an element and its children. This
+ * function can be called in four ways:
+ *
+ * ```js
+ * // returns true or false
+ * $animate.enabled();
+ *
+ * // changes the enabled state for all animations
+ * $animate.enabled(false);
+ * $animate.enabled(true);
+ *
+ * // returns true or false if animations are enabled for an element
+ * $animate.enabled(element);
+ *
+ * // changes the enabled state for an element and its children
+ * $animate.enabled(element, true);
+ * $animate.enabled(element, false);
+ * ```
+ *
+ * @param {DOMElement=} element the element that will be considered for checking/setting the enabled state
+ * @param {boolean=} enabled whether or not the animations will be enabled for the element
+ *
+ * @return {boolean} whether or not animations are enabled
+ */
+ enabled: $$animateQueue.enabled,
+
+ /**
+ * @ngdoc method
+ * @name $animate#cancel
+ * @kind function
+ * @description Cancels the provided animation and applies the end state of the animation.
+ * Note that this does not cancel the underlying operation, e.g. the setting of classes or
+ * adding the element to the DOM.
+ *
+ * @param {animationRunner} animationRunner An animation runner returned by an $animate function.
+ *
+ * @example
+ <example module="animationExample" deps="angular-animate.js" animations="true" name="animate-cancel">
+ <file name="app.js">
+ angular.module('animationExample', ['ngAnimate']).component('cancelExample', {
+ templateUrl: 'template.html',
+ controller: function($element, $animate) {
+ this.runner = null;
+
+ this.addClass = function() {
+ this.runner = $animate.addClass($element.find('div'), 'red');
+ var ctrl = this;
+ this.runner.finally(function() {
+ ctrl.runner = null;
+ });
+ };
+
+ this.removeClass = function() {
+ this.runner = $animate.removeClass($element.find('div'), 'red');
+ var ctrl = this;
+ this.runner.finally(function() {
+ ctrl.runner = null;
+ });
+ };
+
+ this.cancel = function() {
+ $animate.cancel(this.runner);
+ };
+ }
+ });
+ </file>
+ <file name="template.html">
+ <p>
+ <button id="add" ng-click="$ctrl.addClass()">Add</button>
+ <button ng-click="$ctrl.removeClass()">Remove</button>
+ <br>
+ <button id="cancel" ng-click="$ctrl.cancel()" ng-disabled="!$ctrl.runner">Cancel</button>
+ <br>
+ <div id="target">CSS-Animated Text</div>
+ </p>
+ </file>
+ <file name="index.html">
+ <cancel-example></cancel-example>
+ </file>
+ <file name="style.css">
+ .red-add, .red-remove {
+ transition: all 4s cubic-bezier(0.250, 0.460, 0.450, 0.940);
+ }
+
+ .red,
+ .red-add.red-add-active {
+ color: #FF0000;
+ font-size: 40px;
+ }
+
+ .red-remove.red-remove-active {
+ font-size: 10px;
+ color: black;
+ }
+
+ </file>
+ </example>
+ */
+ cancel: function(runner) {
+ if (runner.cancel) {
+ runner.cancel();
+ }
+ },
+
+ /**
+ *
+ * @ngdoc method
+ * @name $animate#enter
+ * @kind function
+ * @description Inserts the element into the DOM either after the `after` element (if provided) or
+ * as the first child within the `parent` element and then triggers an animation.
+ * A promise is returned that will be resolved during the next digest once the animation
+ * has completed.
+ *
+ * @param {DOMElement} element the element which will be inserted into the DOM
+ * @param {DOMElement} parent the parent element which will append the element as
+ * a child (so long as the after element is not present)
+ * @param {DOMElement=} after the sibling element after which the element will be appended
+ * @param {object=} options an optional collection of options/styles that will be applied to the element.
+ * The object can have the following properties:
+ *
+ * - **addClass** - `{string}` - space-separated CSS classes to add to element
+ * - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`
+ * - **removeClass** - `{string}` - space-separated CSS classes to remove from element
+ * - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`
+ *
+ * @return {Runner} the animation runner
+ */
+ enter: function(element, parent, after, options) {
+ parent = parent && jqLite(parent);
+ after = after && jqLite(after);
+ parent = parent || after.parent();
+ domInsert(element, parent, after);
+ return $$animateQueue.push(element, 'enter', prepareAnimateOptions(options));
+ },
+
+ /**
+ *
+ * @ngdoc method
+ * @name $animate#move
+ * @kind function
+ * @description Inserts (moves) the element into its new position in the DOM either after
+ * the `after` element (if provided) or as the first child within the `parent` element
+ * and then triggers an animation. A promise is returned that will be resolved
+ * during the next digest once the animation has completed.
+ *
+ * @param {DOMElement} element the element which will be moved into the new DOM position
+ * @param {DOMElement} parent the parent element which will append the element as
+ * a child (so long as the after element is not present)
+ * @param {DOMElement=} after the sibling element after which the element will be appended
+ * @param {object=} options an optional collection of options/styles that will be applied to the element.
+ * The object can have the following properties:
+ *
+ * - **addClass** - `{string}` - space-separated CSS classes to add to element
+ * - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`
+ * - **removeClass** - `{string}` - space-separated CSS classes to remove from element
+ * - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`
+ *
+ * @return {Runner} the animation runner
+ */
+ move: function(element, parent, after, options) {
+ parent = parent && jqLite(parent);
+ after = after && jqLite(after);
+ parent = parent || after.parent();
+ domInsert(element, parent, after);
+ return $$animateQueue.push(element, 'move', prepareAnimateOptions(options));
+ },
+
+ /**
+ * @ngdoc method
+ * @name $animate#leave
+ * @kind function
+ * @description Triggers an animation and then removes the element from the DOM.
+ * When the function is called a promise is returned that will be resolved during the next
+ * digest once the animation has completed.
+ *
+ * @param {DOMElement} element the element which will be removed from the DOM
+ * @param {object=} options an optional collection of options/styles that will be applied to the element.
+ * The object can have the following properties:
+ *
+ * - **addClass** - `{string}` - space-separated CSS classes to add to element
+ * - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`
+ * - **removeClass** - `{string}` - space-separated CSS classes to remove from element
+ * - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`
+ *
+ * @return {Runner} the animation runner
+ */
+ leave: function(element, options) {
+ return $$animateQueue.push(element, 'leave', prepareAnimateOptions(options), function() {
+ element.remove();
+ });
+ },
+
+ /**
+ * @ngdoc method
+ * @name $animate#addClass
+ * @kind function
+ *
+ * @description Triggers an addClass animation surrounding the addition of the provided CSS class(es). Upon
+ * execution, the addClass operation will only be handled after the next digest and it will not trigger an
+ * animation if element already contains the CSS class or if the class is removed at a later step.
+ * Note that class-based animations are treated differently compared to structural animations
+ * (like enter, move and leave) since the CSS classes may be added/removed at different points
+ * depending if CSS or JavaScript animations are used.
+ *
+ * @param {DOMElement} element the element which the CSS classes will be applied to
+ * @param {string} className the CSS class(es) that will be added (multiple classes are separated via spaces)
+ * @param {object=} options an optional collection of options/styles that will be applied to the element.
+ * The object can have the following properties:
+ *
+ * - **removeClass** - `{string}` - space-separated CSS classes to remove from element
+ * - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`
+ * - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`
+ *
+ * @return {Runner} animationRunner the animation runner
+ */
+ addClass: function(element, className, options) {
+ options = prepareAnimateOptions(options);
+ options.addClass = mergeClasses(options.addclass, className);
+ return $$animateQueue.push(element, 'addClass', options);
+ },
+
+ /**
+ * @ngdoc method
+ * @name $animate#removeClass
+ * @kind function
+ *
+ * @description Triggers a removeClass animation surrounding the removal of the provided CSS class(es). Upon
+ * execution, the removeClass operation will only be handled after the next digest and it will not trigger an
+ * animation if element does not contain the CSS class or if the class is added at a later step.
+ * Note that class-based animations are treated differently compared to structural animations
+ * (like enter, move and leave) since the CSS classes may be added/removed at different points
+ * depending if CSS or JavaScript animations are used.
+ *
+ * @param {DOMElement} element the element which the CSS classes will be applied to
+ * @param {string} className the CSS class(es) that will be removed (multiple classes are separated via spaces)
+ * @param {object=} options an optional collection of options/styles that will be applied to the element.
+ * The object can have the following properties:
+ *
+ * - **addClass** - `{string}` - space-separated CSS classes to add to element
+ * - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`
+ * - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`
+ *
+ * @return {Runner} the animation runner
+ */
+ removeClass: function(element, className, options) {
+ options = prepareAnimateOptions(options);
+ options.removeClass = mergeClasses(options.removeClass, className);
+ return $$animateQueue.push(element, 'removeClass', options);
+ },
+
+ /**
+ * @ngdoc method
+ * @name $animate#setClass
+ * @kind function
+ *
+ * @description Performs both the addition and removal of a CSS classes on an element and (during the process)
+ * triggers an animation surrounding the class addition/removal. Much like `$animate.addClass` and
+ * `$animate.removeClass`, `setClass` will only evaluate the classes being added/removed once a digest has
+ * passed. Note that class-based animations are treated differently compared to structural animations
+ * (like enter, move and leave) since the CSS classes may be added/removed at different points
+ * depending if CSS or JavaScript animations are used.
+ *
+ * @param {DOMElement} element the element which the CSS classes will be applied to
+ * @param {string} add the CSS class(es) that will be added (multiple classes are separated via spaces)
+ * @param {string} remove the CSS class(es) that will be removed (multiple classes are separated via spaces)
+ * @param {object=} options an optional collection of options/styles that will be applied to the element.
+ * The object can have the following properties:
+ *
+ * - **addClass** - `{string}` - space-separated CSS classes to add to element
+ * - **removeClass** - `{string}` - space-separated CSS classes to remove from element
+ * - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`
+ * - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`
+ *
+ * @return {Runner} the animation runner
+ */
+ setClass: function(element, add, remove, options) {
+ options = prepareAnimateOptions(options);
+ options.addClass = mergeClasses(options.addClass, add);
+ options.removeClass = mergeClasses(options.removeClass, remove);
+ return $$animateQueue.push(element, 'setClass', options);
+ },
+
+ /**
+ * @ngdoc method
+ * @name $animate#animate
+ * @kind function
+ *
+ * @description Performs an inline animation on the element which applies the provided to and from CSS styles to the element.
+ * If any detected CSS transition, keyframe or JavaScript matches the provided className value, then the animation will take
+ * on the provided styles. For example, if a transition animation is set for the given className, then the provided `from` and
+ * `to` styles will be applied alongside the given transition. If the CSS style provided in `from` does not have a corresponding
+ * style in `to`, the style in `from` is applied immediately, and no animation is run.
+ * If a JavaScript animation is detected then the provided styles will be given in as function parameters into the `animate`
+ * method (or as part of the `options` parameter):
+ *
+ * ```js
+ * ngModule.animation('.my-inline-animation', function() {
+ * return {
+ * animate : function(element, from, to, done, options) {
+ * //animation
+ * done();
+ * }
+ * }
+ * });
+ * ```
+ *
+ * @param {DOMElement} element the element which the CSS styles will be applied to
+ * @param {object} from the from (starting) CSS styles that will be applied to the element and across the animation.
+ * @param {object} to the to (destination) CSS styles that will be applied to the element and across the animation.
+ * @param {string=} className an optional CSS class that will be applied to the element for the duration of the animation. If
+ * this value is left as empty then a CSS class of `ng-inline-animate` will be applied to the element.
+ * (Note that if no animation is detected then this value will not be applied to the element.)
+ * @param {object=} options an optional collection of options/styles that will be applied to the element.
+ * The object can have the following properties:
+ *
+ * - **addClass** - `{string}` - space-separated CSS classes to add to element
+ * - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`
+ * - **removeClass** - `{string}` - space-separated CSS classes to remove from element
+ * - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`
+ *
+ * @return {Runner} the animation runner
+ */
+ animate: function(element, from, to, className, options) {
+ options = prepareAnimateOptions(options);
+ options.from = options.from ? extend(options.from, from) : from;
+ options.to = options.to ? extend(options.to, to) : to;
+
+ className = className || 'ng-inline-animate';
+ options.tempClasses = mergeClasses(options.tempClasses, className);
+ return $$animateQueue.push(element, 'animate', options);
+ }
+ };
+ }];
+}];
+
+var $$AnimateAsyncRunFactoryProvider = /** @this */ function() {
+ this.$get = ['$$rAF', function($$rAF) {
+ var waitQueue = [];
+
+ function waitForTick(fn) {
+ waitQueue.push(fn);
+ if (waitQueue.length > 1) return;
+ $$rAF(function() {
+ for (var i = 0; i < waitQueue.length; i++) {
+ waitQueue[i]();
+ }
+ waitQueue = [];
+ });
+ }
+
+ return function() {
+ var passed = false;
+ waitForTick(function() {
+ passed = true;
+ });
+ return function(callback) {
+ if (passed) {
+ callback();
+ } else {
+ waitForTick(callback);
+ }
+ };
+ };
+ }];
+};
+
+var $$AnimateRunnerFactoryProvider = /** @this */ function() {
+ this.$get = ['$q', '$sniffer', '$$animateAsyncRun', '$$isDocumentHidden', '$timeout',
+ function($q, $sniffer, $$animateAsyncRun, $$isDocumentHidden, $timeout) {
+
+ var INITIAL_STATE = 0;
+ var DONE_PENDING_STATE = 1;
+ var DONE_COMPLETE_STATE = 2;
+
+ AnimateRunner.chain = function(chain, callback) {
+ var index = 0;
+
+ next();
+ function next() {
+ if (index === chain.length) {
+ callback(true);
+ return;
+ }
+
+ chain[index](function(response) {
+ if (response === false) {
+ callback(false);
+ return;
+ }
+ index++;
+ next();
+ });
+ }
+ };
+
+ AnimateRunner.all = function(runners, callback) {
+ var count = 0;
+ var status = true;
+ forEach(runners, function(runner) {
+ runner.done(onProgress);
+ });
+
+ function onProgress(response) {
+ status = status && response;
+ if (++count === runners.length) {
+ callback(status);
+ }
+ }
+ };
+
+ function AnimateRunner(host) {
+ this.setHost(host);
+
+ var rafTick = $$animateAsyncRun();
+ var timeoutTick = function(fn) {
+ $timeout(fn, 0, false);
+ };
+
+ this._doneCallbacks = [];
+ this._tick = function(fn) {
+ if ($$isDocumentHidden()) {
+ timeoutTick(fn);
+ } else {
+ rafTick(fn);
+ }
+ };
+ this._state = 0;
+ }
+
+ AnimateRunner.prototype = {
+ setHost: function(host) {
+ this.host = host || {};
+ },
+
+ done: function(fn) {
+ if (this._state === DONE_COMPLETE_STATE) {
+ fn();
+ } else {
+ this._doneCallbacks.push(fn);
+ }
+ },
+
+ progress: noop,
+
+ getPromise: function() {
+ if (!this.promise) {
+ var self = this;
+ this.promise = $q(function(resolve, reject) {
+ self.done(function(status) {
+ if (status === false) {
+ reject();
+ } else {
+ resolve();
+ }
+ });
+ });
+ }
+ return this.promise;
+ },
+
+ then: function(resolveHandler, rejectHandler) {
+ return this.getPromise().then(resolveHandler, rejectHandler);
+ },
+
+ 'catch': function(handler) {
+ return this.getPromise()['catch'](handler);
+ },
+
+ 'finally': function(handler) {
+ return this.getPromise()['finally'](handler);
+ },
+
+ pause: function() {
+ if (this.host.pause) {
+ this.host.pause();
+ }
+ },
+
+ resume: function() {
+ if (this.host.resume) {
+ this.host.resume();
+ }
+ },
+
+ end: function() {
+ if (this.host.end) {
+ this.host.end();
+ }
+ this._resolve(true);
+ },
+
+ cancel: function() {
+ if (this.host.cancel) {
+ this.host.cancel();
+ }
+ this._resolve(false);
+ },
+
+ complete: function(response) {
+ var self = this;
+ if (self._state === INITIAL_STATE) {
+ self._state = DONE_PENDING_STATE;
+ self._tick(function() {
+ self._resolve(response);
+ });
+ }
+ },
+
+ _resolve: function(response) {
+ if (this._state !== DONE_COMPLETE_STATE) {
+ forEach(this._doneCallbacks, function(fn) {
+ fn(response);
+ });
+ this._doneCallbacks.length = 0;
+ this._state = DONE_COMPLETE_STATE;
+ }
+ }
+ };
+
+ return AnimateRunner;
+ }];
+};
+
+/* exported $CoreAnimateCssProvider */
+
+/**
+ * @ngdoc service
+ * @name $animateCss
+ * @kind object
+ * @this
+ *
+ * @description
+ * This is the core version of `$animateCss`. By default, only when the `ngAnimate` is included,
+ * then the `$animateCss` service will actually perform animations.
+ *
+ * Click here {@link ngAnimate.$animateCss to read the documentation for $animateCss}.
+ */
+var $CoreAnimateCssProvider = function() {
+ this.$get = ['$$rAF', '$q', '$$AnimateRunner', function($$rAF, $q, $$AnimateRunner) {
+
+ return function(element, initialOptions) {
+ // all of the animation functions should create
+ // a copy of the options data, however, if a
+ // parent service has already created a copy then
+ // we should stick to using that
+ var options = initialOptions || {};
+ if (!options.$$prepared) {
+ options = copy(options);
+ }
+
+ // there is no point in applying the styles since
+ // there is no animation that goes on at all in
+ // this version of $animateCss.
+ if (options.cleanupStyles) {
+ options.from = options.to = null;
+ }
+
+ if (options.from) {
+ element.css(options.from);
+ options.from = null;
+ }
+
+ var closed, runner = new $$AnimateRunner();
+ return {
+ start: run,
+ end: run
+ };
+
+ function run() {
+ $$rAF(function() {
+ applyAnimationContents();
+ if (!closed) {
+ runner.complete();
+ }
+ closed = true;
+ });
+ return runner;
+ }
+
+ function applyAnimationContents() {
+ if (options.addClass) {
+ element.addClass(options.addClass);
+ options.addClass = null;
+ }
+ if (options.removeClass) {
+ element.removeClass(options.removeClass);
+ options.removeClass = null;
+ }
+ if (options.to) {
+ element.css(options.to);
+ options.to = null;
+ }
+ }
+ };
+ }];
+};
+
+/* global getHash: true, stripHash: false */
+
+function getHash(url) {
+ var index = url.indexOf('#');
+ return index === -1 ? '' : url.substr(index);
+}
+
+function trimEmptyHash(url) {
+ return url.replace(/#$/, '');
+}
+
+/**
+ * ! This is a private undocumented service !
+ *
+ * @name $browser
+ * @requires $log
+ * @description
+ * This object has two goals:
+ *
+ * - hide all the global state in the browser caused by the window object
+ * - abstract away all the browser specific features and inconsistencies
+ *
+ * For tests we provide {@link ngMock.$browser mock implementation} of the `$browser`
+ * service, which can be used for convenient testing of the application without the interaction with
+ * the real browser apis.
+ */
+/**
+ * @param {object} window The global window object.
+ * @param {object} document jQuery wrapped document.
+ * @param {object} $log window.console or an object with the same interface.
+ * @param {object} $sniffer $sniffer service
+ */
+function Browser(window, document, $log, $sniffer, $$taskTrackerFactory) {
+ var self = this,
+ location = window.location,
+ history = window.history,
+ setTimeout = window.setTimeout,
+ clearTimeout = window.clearTimeout,
+ pendingDeferIds = {},
+ taskTracker = $$taskTrackerFactory($log);
+
+ self.isMock = false;
+
+ //////////////////////////////////////////////////////////////
+ // Task-tracking API
+ //////////////////////////////////////////////////////////////
+
+ // TODO(vojta): remove this temporary api
+ self.$$completeOutstandingRequest = taskTracker.completeTask;
+ self.$$incOutstandingRequestCount = taskTracker.incTaskCount;
+
+ // TODO(vojta): prefix this method with $$ ?
+ self.notifyWhenNoOutstandingRequests = taskTracker.notifyWhenNoPendingTasks;
+
+ //////////////////////////////////////////////////////////////
+ // URL API
+ //////////////////////////////////////////////////////////////
+
+ var cachedState, lastHistoryState,
+ lastBrowserUrl = location.href,
+ baseElement = document.find('base'),
+ pendingLocation = null,
+ getCurrentState = !$sniffer.history ? noop : function getCurrentState() {
+ try {
+ return history.state;
+ } catch (e) {
+ // MSIE can reportedly throw when there is no state (UNCONFIRMED).
+ }
+ };
+
+ cacheState();
+
+ /**
+ * @name $browser#url
+ *
+ * @description
+ * GETTER:
+ * Without any argument, this method just returns current value of `location.href` (with a
+ * trailing `#` stripped of if the hash is empty).
+ *
+ * SETTER:
+ * With at least one argument, this method sets url to new value.
+ * If html5 history api supported, `pushState`/`replaceState` is used, otherwise
+ * `location.href`/`location.replace` is used.
+ * Returns its own instance to allow chaining.
+ *
+ * NOTE: this api is intended for use only by the `$location` service. Please use the
+ * {@link ng.$location $location service} to change url.
+ *
+ * @param {string} url New url (when used as setter)
+ * @param {boolean=} replace Should new url replace current history record?
+ * @param {object=} state State object to use with `pushState`/`replaceState`
+ */
+ self.url = function(url, replace, state) {
+ // In modern browsers `history.state` is `null` by default; treating it separately
+ // from `undefined` would cause `$browser.url('/foo')` to change `history.state`
+ // to undefined via `pushState`. Instead, let's change `undefined` to `null` here.
+ if (isUndefined(state)) {
+ state = null;
+ }
+
+ // Android Browser BFCache causes location, history reference to become stale.
+ if (location !== window.location) location = window.location;
+ if (history !== window.history) history = window.history;
+
+ // setter
+ if (url) {
+ var sameState = lastHistoryState === state;
+
+ // Normalize the inputted URL
+ url = urlResolve(url).href;
+
+ // Don't change anything if previous and current URLs and states match. This also prevents
+ // IE<10 from getting into redirect loop when in LocationHashbangInHtml5Url mode.
+ // See https://github.com/angular/angular.js/commit/ffb2701
+ if (lastBrowserUrl === url && (!$sniffer.history || sameState)) {
+ return self;
+ }
+ var sameBase = lastBrowserUrl && stripHash(lastBrowserUrl) === stripHash(url);
+ lastBrowserUrl = url;
+ lastHistoryState = state;
+ // Don't use history API if only the hash changed
+ // due to a bug in IE10/IE11 which leads
+ // to not firing a `hashchange` nor `popstate` event
+ // in some cases (see #9143).
+ if ($sniffer.history && (!sameBase || !sameState)) {
+ history[replace ? 'replaceState' : 'pushState'](state, '', url);
+ cacheState();
+ } else {
+ if (!sameBase) {
+ pendingLocation = url;
+ }
+ if (replace) {
+ location.replace(url);
+ } else if (!sameBase) {
+ location.href = url;
+ } else {
+ location.hash = getHash(url);
+ }
+ if (location.href !== url) {
+ pendingLocation = url;
+ }
+ }
+ if (pendingLocation) {
+ pendingLocation = url;
+ }
+ return self;
+ // getter
+ } else {
+ // - pendingLocation is needed as browsers don't allow to read out
+ // the new location.href if a reload happened or if there is a bug like in iOS 9 (see
+ // https://openradar.appspot.com/22186109).
+ return trimEmptyHash(pendingLocation || location.href);
+ }
+ };
+
+ /**
+ * @name $browser#state
+ *
+ * @description
+ * This method is a getter.
+ *
+ * Return history.state or null if history.state is undefined.
+ *
+ * @returns {object} state
+ */
+ self.state = function() {
+ return cachedState;
+ };
+
+ var urlChangeListeners = [],
+ urlChangeInit = false;
+
+ function cacheStateAndFireUrlChange() {
+ pendingLocation = null;
+ fireStateOrUrlChange();
+ }
+
+ // This variable should be used *only* inside the cacheState function.
+ var lastCachedState = null;
+ function cacheState() {
+ // This should be the only place in $browser where `history.state` is read.
+ cachedState = getCurrentState();
+ cachedState = isUndefined(cachedState) ? null : cachedState;
+
+ // Prevent callbacks fo fire twice if both hashchange & popstate were fired.
+ if (equals(cachedState, lastCachedState)) {
+ cachedState = lastCachedState;
+ }
+
+ lastCachedState = cachedState;
+ lastHistoryState = cachedState;
+ }
+
+ function fireStateOrUrlChange() {
+ var prevLastHistoryState = lastHistoryState;
+ cacheState();
+
+ if (lastBrowserUrl === self.url() && prevLastHistoryState === cachedState) {
+ return;
+ }
+
+ lastBrowserUrl = self.url();
+ lastHistoryState = cachedState;
+ forEach(urlChangeListeners, function(listener) {
+ listener(self.url(), cachedState);
+ });
+ }
+
+ /**
+ * @name $browser#onUrlChange
+ *
+ * @description
+ * Register callback function that will be called, when url changes.
+ *
+ * It's only called when the url is changed from outside of AngularJS:
+ * - user types different url into address bar
+ * - user clicks on history (forward/back) button
+ * - user clicks on a link
+ *
+ * It's not called when url is changed by $browser.url() method
+ *
+ * The listener gets called with new url as parameter.
+ *
+ * NOTE: this api is intended for use only by the $location service. Please use the
+ * {@link ng.$location $location service} to monitor url changes in AngularJS apps.
+ *
+ * @param {function(string)} listener Listener function to be called when url changes.
+ * @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous.
+ */
+ self.onUrlChange = function(callback) {
+ // TODO(vojta): refactor to use node's syntax for events
+ if (!urlChangeInit) {
+ // We listen on both (hashchange/popstate) when available, as some browsers don't
+ // fire popstate when user changes the address bar and don't fire hashchange when url
+ // changed by push/replaceState
+
+ // html5 history api - popstate event
+ if ($sniffer.history) jqLite(window).on('popstate', cacheStateAndFireUrlChange);
+ // hashchange event
+ jqLite(window).on('hashchange', cacheStateAndFireUrlChange);
+
+ urlChangeInit = true;
+ }
+
+ urlChangeListeners.push(callback);
+ return callback;
+ };
+
+ /**
+ * @private
+ * Remove popstate and hashchange handler from window.
+ *
+ * NOTE: this api is intended for use only by $rootScope.
+ */
+ self.$$applicationDestroyed = function() {
+ jqLite(window).off('hashchange popstate', cacheStateAndFireUrlChange);
+ };
+
+ /**
+ * Checks whether the url has changed outside of AngularJS.
+ * Needs to be exported to be able to check for changes that have been done in sync,
+ * as hashchange/popstate events fire in async.
+ */
+ self.$$checkUrlChange = fireStateOrUrlChange;
+
+ //////////////////////////////////////////////////////////////
+ // Misc API
+ //////////////////////////////////////////////////////////////
+
+ /**
+ * @name $browser#baseHref
+ *
+ * @description
+ * Returns current <base href>
+ * (always relative - without domain)
+ *
+ * @returns {string} The current base href
+ */
+ self.baseHref = function() {
+ var href = baseElement.attr('href');
+ return href ? href.replace(/^(https?:)?\/\/[^/]*/, '') : '';
+ };
+
+ /**
+ * @name $browser#defer
+ * @param {function()} fn A function, who's execution should be deferred.
+ * @param {number=} [delay=0] Number of milliseconds to defer the function execution.
+ * @param {string=} [taskType=DEFAULT_TASK_TYPE] The type of task that is deferred.
+ * @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`.
+ *
+ * @description
+ * Executes a fn asynchronously via `setTimeout(fn, delay)`.
+ *
+ * Unlike when calling `setTimeout` directly, in test this function is mocked and instead of using
+ * `setTimeout` in tests, the fns are queued in an array, which can be programmatically flushed
+ * via `$browser.defer.flush()`.
+ *
+ */
+ self.defer = function(fn, delay, taskType) {
+ var timeoutId;
+
+ delay = delay || 0;
+ taskType = taskType || taskTracker.DEFAULT_TASK_TYPE;
+
+ taskTracker.incTaskCount(taskType);
+ timeoutId = setTimeout(function() {
+ delete pendingDeferIds[timeoutId];
+ taskTracker.completeTask(fn, taskType);
+ }, delay);
+ pendingDeferIds[timeoutId] = taskType;
+
+ return timeoutId;
+ };
+
+
+ /**
+ * @name $browser#defer.cancel
+ *
+ * @description
+ * Cancels a deferred task identified with `deferId`.
+ *
+ * @param {*} deferId Token returned by the `$browser.defer` function.
+ * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
+ * canceled.
+ */
+ self.defer.cancel = function(deferId) {
+ if (pendingDeferIds.hasOwnProperty(deferId)) {
+ var taskType = pendingDeferIds[deferId];
+ delete pendingDeferIds[deferId];
+ clearTimeout(deferId);
+ taskTracker.completeTask(noop, taskType);
+ return true;
+ }
+ return false;
+ };
+
+}
+
+/** @this */
+function $BrowserProvider() {
+ this.$get = ['$window', '$log', '$sniffer', '$document', '$$taskTrackerFactory',
+ function($window, $log, $sniffer, $document, $$taskTrackerFactory) {
+ return new Browser($window, $document, $log, $sniffer, $$taskTrackerFactory);
+ }];
+}
+
+/**
+ * @ngdoc service
+ * @name $cacheFactory
+ * @this
+ *
+ * @description
+ * Factory that constructs {@link $cacheFactory.Cache Cache} objects and gives access to
+ * them.
+ *
+ * ```js
+ *
+ * var cache = $cacheFactory('cacheId');
+ * expect($cacheFactory.get('cacheId')).toBe(cache);
+ * expect($cacheFactory.get('noSuchCacheId')).not.toBeDefined();
+ *
+ * cache.put("key", "value");
+ * cache.put("another key", "another value");
+ *
+ * // We've specified no options on creation
+ * expect(cache.info()).toEqual({id: 'cacheId', size: 2});
+ *
+ * ```
+ *
+ *
+ * @param {string} cacheId Name or id of the newly created cache.
+ * @param {object=} options Options object that specifies the cache behavior. Properties:
+ *
+ * - `{number=}` `capacity` — turns the cache into LRU cache.
+ *
+ * @returns {object} Newly created cache object with the following set of methods:
+ *
+ * - `{object}` `info()` — Returns id, size, and options of cache.
+ * - `{{*}}` `put({string} key, {*} value)` — Puts a new key-value pair into the cache and returns
+ * it.
+ * - `{{*}}` `get({string} key)` — Returns cached value for `key` or undefined for cache miss.
+ * - `{void}` `remove({string} key)` — Removes a key-value pair from the cache.
+ * - `{void}` `removeAll()` — Removes all cached values.
+ * - `{void}` `destroy()` — Removes references to this cache from $cacheFactory.
+ *
+ * @example
+ <example module="cacheExampleApp" name="cache-factory">
+ <file name="index.html">
+ <div ng-controller="CacheController">
+ <input ng-model="newCacheKey" placeholder="Key">
+ <input ng-model="newCacheValue" placeholder="Value">
+ <button ng-click="put(newCacheKey, newCacheValue)">Cache</button>
+
+ <p ng-if="keys.length">Cached Values</p>
+ <div ng-repeat="key in keys">
+ <span ng-bind="key"></span>
+ <span>: </span>
+ <b ng-bind="cache.get(key)"></b>
+ </div>
+
+ <p>Cache Info</p>
+ <div ng-repeat="(key, value) in cache.info()">
+ <span ng-bind="key"></span>
+ <span>: </span>
+ <b ng-bind="value"></b>
+ </div>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('cacheExampleApp', []).
+ controller('CacheController', ['$scope', '$cacheFactory', function($scope, $cacheFactory) {
+ $scope.keys = [];
+ $scope.cache = $cacheFactory('cacheId');
+ $scope.put = function(key, value) {
+ if (angular.isUndefined($scope.cache.get(key))) {
+ $scope.keys.push(key);
+ }
+ $scope.cache.put(key, angular.isUndefined(value) ? null : value);
+ };
+ }]);
+ </file>
+ <file name="style.css">
+ p {
+ margin: 10px 0 3px;
+ }
+ </file>
+ </example>
+ */
+function $CacheFactoryProvider() {
+
+ this.$get = function() {
+ var caches = {};
+
+ function cacheFactory(cacheId, options) {
+ if (cacheId in caches) {
+ throw minErr('$cacheFactory')('iid', 'CacheId \'{0}\' is already taken!', cacheId);
+ }
+
+ var size = 0,
+ stats = extend({}, options, {id: cacheId}),
+ data = createMap(),
+ capacity = (options && options.capacity) || Number.MAX_VALUE,
+ lruHash = createMap(),
+ freshEnd = null,
+ staleEnd = null;
+
+ /**
+ * @ngdoc type
+ * @name $cacheFactory.Cache
+ *
+ * @description
+ * A cache object used to store and retrieve data, primarily used by
+ * {@link $templateRequest $templateRequest} and the {@link ng.directive:script script}
+ * directive to cache templates and other data.
+ *
+ * ```js
+ * angular.module('superCache')
+ * .factory('superCache', ['$cacheFactory', function($cacheFactory) {
+ * return $cacheFactory('super-cache');
+ * }]);
+ * ```
+ *
+ * Example test:
+ *
+ * ```js
+ * it('should behave like a cache', inject(function(superCache) {
+ * superCache.put('key', 'value');
+ * superCache.put('another key', 'another value');
+ *
+ * expect(superCache.info()).toEqual({
+ * id: 'super-cache',
+ * size: 2
+ * });
+ *
+ * superCache.remove('another key');
+ * expect(superCache.get('another key')).toBeUndefined();
+ *
+ * superCache.removeAll();
+ * expect(superCache.info()).toEqual({
+ * id: 'super-cache',
+ * size: 0
+ * });
+ * }));
+ * ```
+ */
+ return (caches[cacheId] = {
+
+ /**
+ * @ngdoc method
+ * @name $cacheFactory.Cache#put
+ * @kind function
+ *
+ * @description
+ * Inserts a named entry into the {@link $cacheFactory.Cache Cache} object to be
+ * retrieved later, and incrementing the size of the cache if the key was not already
+ * present in the cache. If behaving like an LRU cache, it will also remove stale
+ * entries from the set.
+ *
+ * It will not insert undefined values into the cache.
+ *
+ * @param {string} key the key under which the cached data is stored.
+ * @param {*} value the value to store alongside the key. If it is undefined, the key
+ * will not be stored.
+ * @returns {*} the value stored.
+ */
+ put: function(key, value) {
+ if (isUndefined(value)) return;
+ if (capacity < Number.MAX_VALUE) {
+ var lruEntry = lruHash[key] || (lruHash[key] = {key: key});
+
+ refresh(lruEntry);
+ }
+
+ if (!(key in data)) size++;
+ data[key] = value;
+
+ if (size > capacity) {
+ this.remove(staleEnd.key);
+ }
+
+ return value;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $cacheFactory.Cache#get
+ * @kind function
+ *
+ * @description
+ * Retrieves named data stored in the {@link $cacheFactory.Cache Cache} object.
+ *
+ * @param {string} key the key of the data to be retrieved
+ * @returns {*} the value stored.
+ */
+ get: function(key) {
+ if (capacity < Number.MAX_VALUE) {
+ var lruEntry = lruHash[key];
+
+ if (!lruEntry) return;
+
+ refresh(lruEntry);
+ }
+
+ return data[key];
+ },
+
+
+ /**
+ * @ngdoc method
+ * @name $cacheFactory.Cache#remove
+ * @kind function
+ *
+ * @description
+ * Removes an entry from the {@link $cacheFactory.Cache Cache} object.
+ *
+ * @param {string} key the key of the entry to be removed
+ */
+ remove: function(key) {
+ if (capacity < Number.MAX_VALUE) {
+ var lruEntry = lruHash[key];
+
+ if (!lruEntry) return;
+
+ if (lruEntry === freshEnd) freshEnd = lruEntry.p;
+ if (lruEntry === staleEnd) staleEnd = lruEntry.n;
+ link(lruEntry.n,lruEntry.p);
+
+ delete lruHash[key];
+ }
+
+ if (!(key in data)) return;
+
+ delete data[key];
+ size--;
+ },
+
+
+ /**
+ * @ngdoc method
+ * @name $cacheFactory.Cache#removeAll
+ * @kind function
+ *
+ * @description
+ * Clears the cache object of any entries.
+ */
+ removeAll: function() {
+ data = createMap();
+ size = 0;
+ lruHash = createMap();
+ freshEnd = staleEnd = null;
+ },
+
+
+ /**
+ * @ngdoc method
+ * @name $cacheFactory.Cache#destroy
+ * @kind function
+ *
+ * @description
+ * Destroys the {@link $cacheFactory.Cache Cache} object entirely,
+ * removing it from the {@link $cacheFactory $cacheFactory} set.
+ */
+ destroy: function() {
+ data = null;
+ stats = null;
+ lruHash = null;
+ delete caches[cacheId];
+ },
+
+
+ /**
+ * @ngdoc method
+ * @name $cacheFactory.Cache#info
+ * @kind function
+ *
+ * @description
+ * Retrieve information regarding a particular {@link $cacheFactory.Cache Cache}.
+ *
+ * @returns {object} an object with the following properties:
+ * <ul>
+ * <li>**id**: the id of the cache instance</li>
+ * <li>**size**: the number of entries kept in the cache instance</li>
+ * <li>**...**: any additional properties from the options object when creating the
+ * cache.</li>
+ * </ul>
+ */
+ info: function() {
+ return extend({}, stats, {size: size});
+ }
+ });
+
+
+ /**
+ * makes the `entry` the freshEnd of the LRU linked list
+ */
+ function refresh(entry) {
+ if (entry !== freshEnd) {
+ if (!staleEnd) {
+ staleEnd = entry;
+ } else if (staleEnd === entry) {
+ staleEnd = entry.n;
+ }
+
+ link(entry.n, entry.p);
+ link(entry, freshEnd);
+ freshEnd = entry;
+ freshEnd.n = null;
+ }
+ }
+
+
+ /**
+ * bidirectionally links two entries of the LRU linked list
+ */
+ function link(nextEntry, prevEntry) {
+ if (nextEntry !== prevEntry) {
+ if (nextEntry) nextEntry.p = prevEntry; //p stands for previous, 'prev' didn't minify
+ if (prevEntry) prevEntry.n = nextEntry; //n stands for next, 'next' didn't minify
+ }
+ }
+ }
+
+
+ /**
+ * @ngdoc method
+ * @name $cacheFactory#info
+ *
+ * @description
+ * Get information about all the caches that have been created
+ *
+ * @returns {Object} - key-value map of `cacheId` to the result of calling `cache#info`
+ */
+ cacheFactory.info = function() {
+ var info = {};
+ forEach(caches, function(cache, cacheId) {
+ info[cacheId] = cache.info();
+ });
+ return info;
+ };
+
+
+ /**
+ * @ngdoc method
+ * @name $cacheFactory#get
+ *
+ * @description
+ * Get access to a cache object by the `cacheId` used when it was created.
+ *
+ * @param {string} cacheId Name or id of a cache to access.
+ * @returns {object} Cache object identified by the cacheId or undefined if no such cache.
+ */
+ cacheFactory.get = function(cacheId) {
+ return caches[cacheId];
+ };
+
+
+ return cacheFactory;
+ };
+}
+
+/**
+ * @ngdoc service
+ * @name $templateCache
+ * @this
+ *
+ * @description
+ * `$templateCache` is a {@link $cacheFactory.Cache Cache object} created by the
+ * {@link ng.$cacheFactory $cacheFactory}.
+ *
+ * The first time a template is used, it is loaded in the template cache for quick retrieval. You
+ * can load templates directly into the cache in a `script` tag, by using {@link $templateRequest},
+ * or by consuming the `$templateCache` service directly.
+ *
+ * Adding via the `script` tag:
+ *
+ * ```html
+ * <script type="text/ng-template" id="templateId.html">
+ * <p>This is the content of the template</p>
+ * </script>
+ * ```
+ *
+ * **Note:** the `script` tag containing the template does not need to be included in the `head` of
+ * the document, but it must be a descendent of the {@link ng.$rootElement $rootElement} (e.g.
+ * element with {@link ngApp} attribute), otherwise the template will be ignored.
+ *
+ * Adding via the `$templateCache` service:
+ *
+ * ```js
+ * var myApp = angular.module('myApp', []);
+ * myApp.run(function($templateCache) {
+ * $templateCache.put('templateId.html', 'This is the content of the template');
+ * });
+ * ```
+ *
+ * To retrieve the template later, simply use it in your component:
+ * ```js
+ * myApp.component('myComponent', {
+ * templateUrl: 'templateId.html'
+ * });
+ * ```
+ *
+ * or get it via the `$templateCache` service:
+ * ```js
+ * $templateCache.get('templateId.html')
+ * ```
+ *
+ */
+function $TemplateCacheProvider() {
+ this.$get = ['$cacheFactory', function($cacheFactory) {
+ return $cacheFactory('templates');
+ }];
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Any commits to this file should be reviewed with security in mind. *
+ * Changes to this file can potentially create security vulnerabilities. *
+ * An approval from 2 Core members with history of modifying *
+ * this file is required. *
+ * *
+ * Does the change somehow allow for arbitrary javascript to be executed? *
+ * Or allows for someone to change the prototype of built-in objects? *
+ * Or gives undesired access to variables like document or window? *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* ! VARIABLE/FUNCTION NAMING CONVENTIONS THAT APPLY TO THIS FILE!
+ *
+ * DOM-related variables:
+ *
+ * - "node" - DOM Node
+ * - "element" - DOM Element or Node
+ * - "$node" or "$element" - jqLite-wrapped node or element
+ *
+ *
+ * Compiler related stuff:
+ *
+ * - "linkFn" - linking fn of a single directive
+ * - "nodeLinkFn" - function that aggregates all linking fns for a particular node
+ * - "childLinkFn" - function that aggregates all linking fns for child nodes of a particular node
+ * - "compositeLinkFn" - function that aggregates all linking fns for a compilation root (nodeList)
+ */
+
+
+/**
+ * @ngdoc service
+ * @name $compile
+ * @kind function
+ *
+ * @description
+ * Compiles an HTML string or DOM into a template and produces a template function, which
+ * can then be used to link {@link ng.$rootScope.Scope `scope`} and the template together.
+ *
+ * The compilation is a process of walking the DOM tree and matching DOM elements to
+ * {@link ng.$compileProvider#directive directives}.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** This document is an in-depth reference of all directive options.
+ * For a gentle introduction to directives with examples of common use cases,
+ * see the {@link guide/directive directive guide}.
+ * </div>
+ *
+ * ## Comprehensive Directive API
+ *
+ * There are many different options for a directive.
+ *
+ * The difference resides in the return value of the factory function.
+ * You can either return a {@link $compile#directive-definition-object Directive Definition Object (see below)}
+ * that defines the directive properties, or just the `postLink` function (all other properties will have
+ * the default values).
+ *
+ * <div class="alert alert-success">
+ * **Best Practice:** It's recommended to use the "directive definition object" form.
+ * </div>
+ *
+ * Here's an example directive declared with a Directive Definition Object:
+ *
+ * ```js
+ * var myModule = angular.module(...);
+ *
+ * myModule.directive('directiveName', function factory(injectables) {
+ * var directiveDefinitionObject = {
+ * {@link $compile#-priority- priority}: 0,
+ * {@link $compile#-template- template}: '<div></div>', // or // function(tElement, tAttrs) { ... },
+ * // or
+ * // {@link $compile#-templateurl- templateUrl}: 'directive.html', // or // function(tElement, tAttrs) { ... },
+ * {@link $compile#-transclude- transclude}: false,
+ * {@link $compile#-restrict- restrict}: 'A',
+ * {@link $compile#-templatenamespace- templateNamespace}: 'html',
+ * {@link $compile#-scope- scope}: false,
+ * {@link $compile#-controller- controller}: function($scope, $element, $attrs, $transclude, otherInjectables) { ... },
+ * {@link $compile#-controlleras- controllerAs}: 'stringIdentifier',
+ * {@link $compile#-bindtocontroller- bindToController}: false,
+ * {@link $compile#-require- require}: 'siblingDirectiveName', // or // ['^parentDirectiveName', '?optionalDirectiveName', '?^optionalParent'],
+ * {@link $compile#-multielement- multiElement}: false,
+ * {@link $compile#-compile- compile}: function compile(tElement, tAttrs, transclude) {
+ * return {
+ * {@link $compile#pre-linking-function pre}: function preLink(scope, iElement, iAttrs, controller) { ... },
+ * {@link $compile#post-linking-function post}: function postLink(scope, iElement, iAttrs, controller) { ... }
+ * }
+ * // or
+ * // return function postLink( ... ) { ... }
+ * },
+ * // or
+ * // {@link $compile#-link- link}: {
+ * // {@link $compile#pre-linking-function pre}: function preLink(scope, iElement, iAttrs, controller) { ... },
+ * // {@link $compile#post-linking-function post}: function postLink(scope, iElement, iAttrs, controller) { ... }
+ * // }
+ * // or
+ * // {@link $compile#-link- link}: function postLink( ... ) { ... }
+ * };
+ * return directiveDefinitionObject;
+ * });
+ * ```
+ *
+ * <div class="alert alert-warning">
+ * **Note:** Any unspecified options will use the default value. You can see the default values below.
+ * </div>
+ *
+ * Therefore the above can be simplified as:
+ *
+ * ```js
+ * var myModule = angular.module(...);
+ *
+ * myModule.directive('directiveName', function factory(injectables) {
+ * var directiveDefinitionObject = {
+ * link: function postLink(scope, iElement, iAttrs) { ... }
+ * };
+ * return directiveDefinitionObject;
+ * // or
+ * // return function postLink(scope, iElement, iAttrs) { ... }
+ * });
+ * ```
+ *
+ * ### Life-cycle hooks
+ * Directive controllers can provide the following methods that are called by AngularJS at points in the life-cycle of the
+ * directive:
+ * * `$onInit()` - Called on each controller after all the controllers on an element have been constructed and
+ * had their bindings initialized (and before the pre & post linking functions for the directives on
+ * this element). This is a good place to put initialization code for your controller.
+ * * `$onChanges(changesObj)` - Called whenever one-way (`<`) or interpolation (`@`) bindings are updated. The
+ * `changesObj` is a hash whose keys are the names of the bound properties that have changed, and the values are an
+ * object of the form `{ currentValue, previousValue, isFirstChange() }`. Use this hook to trigger updates within a
+ * component such as cloning the bound value to prevent accidental mutation of the outer value. Note that this will
+ * also be called when your bindings are initialized.
+ * * `$doCheck()` - Called on each turn of the digest cycle. Provides an opportunity to detect and act on
+ * changes. Any actions that you wish to take in response to the changes that you detect must be
+ * invoked from this hook; implementing this has no effect on when `$onChanges` is called. For example, this hook
+ * could be useful if you wish to perform a deep equality check, or to check a Date object, changes to which would not
+ * be detected by AngularJS's change detector and thus not trigger `$onChanges`. This hook is invoked with no arguments;
+ * if detecting changes, you must store the previous value(s) for comparison to the current values.
+ * * `$onDestroy()` - Called on a controller when its containing scope is destroyed. Use this hook for releasing
+ * external resources, watches and event handlers. Note that components have their `$onDestroy()` hooks called in
+ * the same order as the `$scope.$broadcast` events are triggered, which is top down. This means that parent
+ * components will have their `$onDestroy()` hook called before child components.
+ * * `$postLink()` - Called after this controller's element and its children have been linked. Similar to the post-link
+ * function this hook can be used to set up DOM event handlers and do direct DOM manipulation.
+ * Note that child elements that contain `templateUrl` directives will not have been compiled and linked since
+ * they are waiting for their template to load asynchronously and their own compilation and linking has been
+ * suspended until that occurs.
+ *
+ * #### Comparison with life-cycle hooks in the new Angular
+ * The new Angular also uses life-cycle hooks for its components. While the AngularJS life-cycle hooks are similar there are
+ * some differences that you should be aware of, especially when it comes to moving your code from AngularJS to Angular:
+ *
+ * * AngularJS hooks are prefixed with `$`, such as `$onInit`. Angular hooks are prefixed with `ng`, such as `ngOnInit`.
+ * * AngularJS hooks can be defined on the controller prototype or added to the controller inside its constructor.
+ * In Angular you can only define hooks on the prototype of the Component class.
+ * * Due to the differences in change-detection, you may get many more calls to `$doCheck` in AngularJS than you would to
+ * `ngDoCheck` in Angular.
+ * * Changes to the model inside `$doCheck` will trigger new turns of the digest loop, which will cause the changes to be
+ * propagated throughout the application.
+ * Angular does not allow the `ngDoCheck` hook to trigger a change outside of the component. It will either throw an
+ * error or do nothing depending upon the state of `enableProdMode()`.
+ *
+ * #### Life-cycle hook examples
+ *
+ * This example shows how you can check for mutations to a Date object even though the identity of the object
+ * has not changed.
+ *
+ * <example name="doCheckDateExample" module="do-check-module">
+ * <file name="app.js">
+ * angular.module('do-check-module', [])
+ * .component('app', {
+ * template:
+ * 'Month: <input ng-model="$ctrl.month" ng-change="$ctrl.updateDate()">' +
+ * 'Date: {{ $ctrl.date }}' +
+ * '<test date="$ctrl.date"></test>',
+ * controller: function() {
+ * this.date = new Date();
+ * this.month = this.date.getMonth();
+ * this.updateDate = function() {
+ * this.date.setMonth(this.month);
+ * };
+ * }
+ * })
+ * .component('test', {
+ * bindings: { date: '<' },
+ * template:
+ * '<pre>{{ $ctrl.log | json }}</pre>',
+ * controller: function() {
+ * var previousValue;
+ * this.log = [];
+ * this.$doCheck = function() {
+ * var currentValue = this.date && this.date.valueOf();
+ * if (previousValue !== currentValue) {
+ * this.log.push('doCheck: date mutated: ' + this.date);
+ * previousValue = currentValue;
+ * }
+ * };
+ * }
+ * });
+ * </file>
+ * <file name="index.html">
+ * <app></app>
+ * </file>
+ * </example>
+ *
+ * This example show how you might use `$doCheck` to trigger changes in your component's inputs even if the
+ * actual identity of the component doesn't change. (Be aware that cloning and deep equality checks on large
+ * arrays or objects can have a negative impact on your application performance.)
+ *
+ * <example name="doCheckArrayExample" module="do-check-module">
+ * <file name="index.html">
+ * <div ng-init="items = []">
+ * <button ng-click="items.push(items.length)">Add Item</button>
+ * <button ng-click="items = []">Reset Items</button>
+ * <pre>{{ items }}</pre>
+ * <test items="items"></test>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('do-check-module', [])
+ * .component('test', {
+ * bindings: { items: '<' },
+ * template:
+ * '<pre>{{ $ctrl.log | json }}</pre>',
+ * controller: function() {
+ * this.log = [];
+ *
+ * this.$doCheck = function() {
+ * if (this.items_ref !== this.items) {
+ * this.log.push('doCheck: items changed');
+ * this.items_ref = this.items;
+ * }
+ * if (!angular.equals(this.items_clone, this.items)) {
+ * this.log.push('doCheck: items mutated');
+ * this.items_clone = angular.copy(this.items);
+ * }
+ * };
+ * }
+ * });
+ * </file>
+ * </example>
+ *
+ *
+ * ### Directive Definition Object
+ *
+ * The directive definition object provides instructions to the {@link ng.$compile
+ * compiler}. The attributes are:
+ *
+ * #### `multiElement`
+ * When this property is set to true (default is `false`), the HTML compiler will collect DOM nodes between
+ * nodes with the attributes `directive-name-start` and `directive-name-end`, and group them
+ * together as the directive elements. It is recommended that this feature be used on directives
+ * which are not strictly behavioral (such as {@link ngClick}), and which
+ * do not manipulate or replace child nodes (such as {@link ngInclude}).
+ *
+ * #### `priority`
+ * When there are multiple directives defined on a single DOM element, sometimes it
+ * is necessary to specify the order in which the directives are applied. The `priority` is used
+ * to sort the directives before their `compile` functions get called. Priority is defined as a
+ * number. Directives with greater numerical `priority` are compiled first. Pre-link functions
+ * are also run in priority order, but post-link functions are run in reverse order. The order
+ * of directives with the same priority is undefined. The default priority is `0`.
+ *
+ * #### `terminal`
+ * If set to true then the current `priority` will be the last set of directives
+ * which will execute (any directives at the current priority will still execute
+ * as the order of execution on same `priority` is undefined). Note that expressions
+ * and other directives used in the directive's template will also be excluded from execution.
+ *
+ * #### `scope`
+ * The scope property can be `false`, `true`, or an object:
+ *
+ * * **`false` (default):** No scope will be created for the directive. The directive will use its
+ * parent's scope.
+ *
+ * * **`true`:** A new child scope that prototypically inherits from its parent will be created for
+ * the directive's element. If multiple directives on the same element request a new scope,
+ * only one new scope is created.
+ *
+ * * **`{...}` (an object hash):** A new "isolate" scope is created for the directive's template.
+ * The 'isolate' scope differs from normal scope in that it does not prototypically
+ * inherit from its parent scope. This is useful when creating reusable components, which should not
+ * accidentally read or modify data in the parent scope. Note that an isolate scope
+ * directive without a `template` or `templateUrl` will not apply the isolate scope
+ * to its children elements.
+ *
+ * The 'isolate' scope object hash defines a set of local scope properties derived from attributes on the
+ * directive's element. These local properties are useful for aliasing values for templates. The keys in
+ * the object hash map to the name of the property on the isolate scope; the values define how the property
+ * is bound to the parent scope, via matching attributes on the directive's element:
+ *
+ * * `@` or `@attr` - bind a local scope property to the value of DOM attribute. The result is
+ * always a string since DOM attributes are strings. If no `attr` name is specified then the
+ * attribute name is assumed to be the same as the local name. Given `<my-component
+ * my-attr="hello {{name}}">` and the isolate scope definition `scope: { localName:'@myAttr' }`,
+ * the directive's scope property `localName` will reflect the interpolated value of `hello
+ * {{name}}`. As the `name` attribute changes so will the `localName` property on the directive's
+ * scope. The `name` is read from the parent scope (not the directive's scope).
+ *
+ * * `=` or `=attr` - set up a bidirectional binding between a local scope property and an expression
+ * passed via the attribute `attr`. The expression is evaluated in the context of the parent scope.
+ * If no `attr` name is specified then the attribute name is assumed to be the same as the local
+ * name. Given `<my-component my-attr="parentModel">` and the isolate scope definition `scope: {
+ * localModel: '=myAttr' }`, the property `localModel` on the directive's scope will reflect the
+ * value of `parentModel` on the parent scope. Changes to `parentModel` will be reflected in
+ * `localModel` and vice versa. If the binding expression is non-assignable, or if the attribute
+ * isn't optional and doesn't exist, an exception
+ * ({@link error/$compile/nonassign `$compile:nonassign`}) will be thrown upon discovering changes
+ * to the local value, since it will be impossible to sync them back to the parent scope.
+ *
+ * By default, the {@link ng.$rootScope.Scope#$watch `$watch`}
+ * method is used for tracking changes, and the equality check is based on object identity.
+ * However, if an object literal or an array literal is passed as the binding expression, the
+ * equality check is done by value (using the {@link angular.equals} function). It's also possible
+ * to watch the evaluated value shallowly with {@link ng.$rootScope.Scope#$watchCollection
+ * `$watchCollection`}: use `=*` or `=*attr`
+ *
+ * * `<` or `<attr` - set up a one-way (one-directional) binding between a local scope property and an
+ * expression passed via the attribute `attr`. The expression is evaluated in the context of the
+ * parent scope. If no `attr` name is specified then the attribute name is assumed to be the same as the
+ * local name.
+ *
+ * For example, given `<my-component my-attr="parentModel">` and directive definition of
+ * `scope: { localModel:'<myAttr' }`, then the isolated scope property `localModel` will reflect the
+ * value of `parentModel` on the parent scope. Any changes to `parentModel` will be reflected
+ * in `localModel`, but changes in `localModel` will not reflect in `parentModel`. There are however
+ * two caveats:
+ * 1. one-way binding does not copy the value from the parent to the isolate scope, it simply
+ * sets the same value. That means if your bound value is an object, changes to its properties
+ * in the isolated scope will be reflected in the parent scope (because both reference the same object).
+ * 2. one-way binding watches changes to the **identity** of the parent value. That means the
+ * {@link ng.$rootScope.Scope#$watch `$watch`} on the parent value only fires if the reference
+ * to the value has changed. In most cases, this should not be of concern, but can be important
+ * to know if you one-way bind to an object, and then replace that object in the isolated scope.
+ * If you now change a property of the object in your parent scope, the change will not be
+ * propagated to the isolated scope, because the identity of the object on the parent scope
+ * has not changed. Instead you must assign a new object.
+ *
+ * One-way binding is useful if you do not plan to propagate changes to your isolated scope bindings
+ * back to the parent. However, it does not make this completely impossible.
+ *
+ * By default, the {@link ng.$rootScope.Scope#$watch `$watch`}
+ * method is used for tracking changes, and the equality check is based on object identity.
+ * It's also possible to watch the evaluated value shallowly with
+ * {@link ng.$rootScope.Scope#$watchCollection `$watchCollection`}: use `<*` or `<*attr`
+ *
+ * * `&` or `&attr` - provides a way to execute an expression in the context of the parent scope. If
+ * no `attr` name is specified then the attribute name is assumed to be the same as the local name.
+ * Given `<my-component my-attr="count = count + value">` and the isolate scope definition `scope: {
+ * localFn:'&myAttr' }`, the isolate scope property `localFn` will point to a function wrapper for
+ * the `count = count + value` expression. Often it's desirable to pass data from the isolated scope
+ * via an expression to the parent scope. This can be done by passing a map of local variable names
+ * and values into the expression wrapper fn. For example, if the expression is `increment(amount)`
+ * then we can specify the amount value by calling the `localFn` as `localFn({amount: 22})`.
+ *
+ * All 4 kinds of bindings (`@`, `=`, `<`, and `&`) can be made optional by adding `?` to the expression.
+ * The marker must come after the mode and before the attribute name.
+ * See the {@link error/$compile/iscp Invalid Isolate Scope Definition error} for definition examples.
+ * This is useful to refine the interface directives provide.
+ * One subtle difference between optional and non-optional happens **when the binding attribute is not
+ * set**:
+ * - the binding is optional: the property will not be defined
+ * - the binding is not optional: the property is defined
+ *
+ * ```js
+ *app.directive('testDir', function() {
+ return {
+ scope: {
+ notoptional: '=',
+ optional: '=?',
+ },
+ bindToController: true,
+ controller: function() {
+ this.$onInit = function() {
+ console.log(this.hasOwnProperty('notoptional')) // true
+ console.log(this.hasOwnProperty('optional')) // false
+ }
+ }
+ }
+ })
+ *```
+ *
+ *
+ * ##### Combining directives with different scope defintions
+ *
+ * In general it's possible to apply more than one directive to one element, but there might be limitations
+ * depending on the type of scope required by the directives. The following points will help explain these limitations.
+ * For simplicity only two directives are taken into account, but it is also applicable for several directives:
+ *
+ * * **no scope** + **no scope** => Two directives which don't require their own scope will use their parent's scope
+ * * **child scope** + **no scope** => Both directives will share one single child scope
+ * * **child scope** + **child scope** => Both directives will share one single child scope
+ * * **isolated scope** + **no scope** => The isolated directive will use it's own created isolated scope. The other directive will use
+ * its parent's scope
+ * * **isolated scope** + **child scope** => **Won't work!** Only one scope can be related to one element. Therefore these directives cannot
+ * be applied to the same element.
+ * * **isolated scope** + **isolated scope** => **Won't work!** Only one scope can be related to one element. Therefore these directives
+ * cannot be applied to the same element.
+ *
+ *
+ * #### `bindToController`
+ * This property is used to bind scope properties directly to the controller. It can be either
+ * `true` or an object hash with the same format as the `scope` property.
+ *
+ * When an isolate scope is used for a directive (see above), `bindToController: true` will
+ * allow a component to have its properties bound to the controller, rather than to scope.
+ *
+ * After the controller is instantiated, the initial values of the isolate scope bindings will be bound to the controller
+ * properties. You can access these bindings once they have been initialized by providing a controller method called
+ * `$onInit`, which is called after all the controllers on an element have been constructed and had their bindings
+ * initialized.
+ *
+ * It is also possible to set `bindToController` to an object hash with the same format as the `scope` property.
+ * This will set up the scope bindings to the controller directly. Note that `scope` can still be used
+ * to define which kind of scope is created. By default, no scope is created. Use `scope: {}` to create an isolate
+ * scope (useful for component directives).
+ *
+ * If both `bindToController` and `scope` are defined and have object hashes, `bindToController` overrides `scope`.
+ *
+ *
+ * #### `controller`
+ * Controller constructor function. The controller is instantiated before the
+ * pre-linking phase and can be accessed by other directives (see
+ * `require` attribute). This allows the directives to communicate with each other and augment
+ * each other's behavior. The controller is injectable (and supports bracket notation) with the following locals:
+ *
+ * * `$scope` - Current scope associated with the element
+ * * `$element` - Current element
+ * * `$attrs` - Current attributes object for the element
+ * * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope:
+ * `function([scope], cloneLinkingFn, futureParentElement, slotName)`:
+ * * `scope`: (optional) override the scope.
+ * * `cloneLinkingFn`: (optional) argument to create clones of the original transcluded content.
+ * * `futureParentElement` (optional):
+ * * defines the parent to which the `cloneLinkingFn` will add the cloned elements.
+ * * default: `$element.parent()` resp. `$element` for `transclude:'element'` resp. `transclude:true`.
+ * * only needed for transcludes that are allowed to contain non html elements (e.g. SVG elements)
+ * and when the `cloneLinkingFn` is passed,
+ * as those elements need to created and cloned in a special way when they are defined outside their
+ * usual containers (e.g. like `<svg>`).
+ * * See also the `directive.templateNamespace` property.
+ * * `slotName`: (optional) the name of the slot to transclude. If falsy (e.g. `null`, `undefined` or `''`)
+ * then the default transclusion is provided.
+ * The `$transclude` function also has a method on it, `$transclude.isSlotFilled(slotName)`, which returns
+ * `true` if the specified slot contains content (i.e. one or more DOM nodes).
+ *
+ * #### `require`
+ * Require another directive and inject its controller as the fourth argument to the linking function. The
+ * `require` property can be a string, an array or an object:
+ * * a **string** containing the name of the directive to pass to the linking function
+ * * an **array** containing the names of directives to pass to the linking function. The argument passed to the
+ * linking function will be an array of controllers in the same order as the names in the `require` property
+ * * an **object** whose property values are the names of the directives to pass to the linking function. The argument
+ * passed to the linking function will also be an object with matching keys, whose values will hold the corresponding
+ * controllers.
+ *
+ * If the `require` property is an object and `bindToController` is truthy, then the required controllers are
+ * bound to the controller using the keys of the `require` property. This binding occurs after all the controllers
+ * have been constructed but before `$onInit` is called.
+ * If the name of the required controller is the same as the local name (the key), the name can be
+ * omitted. For example, `{parentDir: '^^'}` is equivalent to `{parentDir: '^^parentDir'}`.
+ * See the {@link $compileProvider#component} helper for an example of how this can be used.
+ * If no such required directive(s) can be found, or if the directive does not have a controller, then an error is
+ * raised (unless no link function is specified and the required controllers are not being bound to the directive
+ * controller, in which case error checking is skipped). The name can be prefixed with:
+ *
+ * * (no prefix) - Locate the required controller on the current element. Throw an error if not found.
+ * * `?` - Attempt to locate the required controller or pass `null` to the `link` fn if not found.
+ * * `^` - Locate the required controller by searching the element and its parents. Throw an error if not found.
+ * * `^^` - Locate the required controller by searching the element's parents. Throw an error if not found.
+ * * `?^` - Attempt to locate the required controller by searching the element and its parents or pass
+ * `null` to the `link` fn if not found.
+ * * `?^^` - Attempt to locate the required controller by searching the element's parents, or pass
+ * `null` to the `link` fn if not found.
+ *
+ *
+ * #### `controllerAs`
+ * Identifier name for a reference to the controller in the directive's scope.
+ * This allows the controller to be referenced from the directive template. This is especially
+ * useful when a directive is used as component, i.e. with an `isolate` scope. It's also possible
+ * to use it in a directive without an `isolate` / `new` scope, but you need to be aware that the
+ * `controllerAs` reference might overwrite a property that already exists on the parent scope.
+ *
+ *
+ * #### `restrict`
+ * String of subset of `EACM` which restricts the directive to a specific directive
+ * declaration style. If omitted, the defaults (elements and attributes) are used.
+ *
+ * * `E` - Element name (default): `<my-directive></my-directive>`
+ * * `A` - Attribute (default): `<div my-directive="exp"></div>`
+ * * `C` - Class: `<div class="my-directive: exp;"></div>`
+ * * `M` - Comment: `<!-- directive: my-directive exp -->`
+ *
+ *
+ * #### `templateNamespace`
+ * String representing the document type used by the markup in the template.
+ * AngularJS needs this information as those elements need to be created and cloned
+ * in a special way when they are defined outside their usual containers like `<svg>` and `<math>`.
+ *
+ * * `html` - All root nodes in the template are HTML. Root nodes may also be
+ * top-level elements such as `<svg>` or `<math>`.
+ * * `svg` - The root nodes in the template are SVG elements (excluding `<math>`).
+ * * `math` - The root nodes in the template are MathML elements (excluding `<svg>`).
+ *
+ * If no `templateNamespace` is specified, then the namespace is considered to be `html`.
+ *
+ * #### `template`
+ * HTML markup that may:
+ * * Replace the contents of the directive's element (default).
+ * * Replace the directive's element itself (if `replace` is true - DEPRECATED).
+ * * Wrap the contents of the directive's element (if `transclude` is true).
+ *
+ * Value may be:
+ *
+ * * A string. For example `<div red-on-hover>{{delete_str}}</div>`.
+ * * A function which takes two arguments `tElement` and `tAttrs` (described in the `compile`
+ * function api below) and returns a string value.
+ *
+ *
+ * #### `templateUrl`
+ * This is similar to `template` but the template is loaded from the specified URL, asynchronously.
+ *
+ * Because template loading is asynchronous the compiler will suspend compilation of directives on that element
+ * for later when the template has been resolved. In the meantime it will continue to compile and link
+ * sibling and parent elements as though this element had not contained any directives.
+ *
+ * The compiler does not suspend the entire compilation to wait for templates to be loaded because this
+ * would result in the whole app "stalling" until all templates are loaded asynchronously - even in the
+ * case when only one deeply nested directive has `templateUrl`.
+ *
+ * Template loading is asynchronous even if the template has been preloaded into the {@link $templateCache}.
+ *
+ * You can specify `templateUrl` as a string representing the URL or as a function which takes two
+ * arguments `tElement` and `tAttrs` (described in the `compile` function api below) and returns
+ * a string value representing the url. In either case, the template URL is passed through {@link
+ * $sce#getTrustedResourceUrl $sce.getTrustedResourceUrl}.
+ *
+ *
+ * #### `replace`
+ * <div class="alert alert-danger">
+ * **Note:** `replace` is deprecated in AngularJS and has been removed in the new Angular (v2+).
+ * </div>
+ *
+ * Specifies what the template should replace. Defaults to `false`.
+ *
+ * * `true` - the template will replace the directive's element.
+ * * `false` - the template will replace the contents of the directive's element.
+ *
+ * The replacement process migrates all of the attributes / classes from the old element to the new
+ * one. See the {@link guide/directive#template-expanding-directive
+ * Directives Guide} for an example.
+ *
+ * There are very few scenarios where element replacement is required for the application function,
+ * the main one being reusable custom components that are used within SVG contexts
+ * (because SVG doesn't work with custom elements in the DOM tree).
+ *
+ * #### `transclude`
+ * Extract the contents of the element where the directive appears and make it available to the directive.
+ * The contents are compiled and provided to the directive as a **transclusion function**. See the
+ * {@link $compile#transclusion Transclusion} section below.
+ *
+ *
+ * #### `compile`
+ *
+ * ```js
+ * function compile(tElement, tAttrs, transclude) { ... }
+ * ```
+ *
+ * The compile function deals with transforming the template DOM. Since most directives do not do
+ * template transformation, it is not used often. The compile function takes the following arguments:
+ *
+ * * `tElement` - template element - The element where the directive has been declared. It is
+ * safe to do template transformation on the element and child elements only.
+ *
+ * * `tAttrs` - template attributes - Normalized list of attributes declared on this element shared
+ * between all directive compile functions.
+ *
+ * * `transclude` - [*DEPRECATED*!] A transclude linking function: `function(scope, cloneLinkingFn)`
+ *
+ * <div class="alert alert-warning">
+ * **Note:** The template instance and the link instance may be different objects if the template has
+ * been cloned. For this reason it is **not** safe to do anything other than DOM transformations that
+ * apply to all cloned DOM nodes within the compile function. Specifically, DOM listener registration
+ * should be done in a linking function rather than in a compile function.
+ * </div>
+
+ * <div class="alert alert-warning">
+ * **Note:** The compile function cannot handle directives that recursively use themselves in their
+ * own templates or compile functions. Compiling these directives results in an infinite loop and
+ * stack overflow errors.
+ *
+ * This can be avoided by manually using `$compile` in the postLink function to imperatively compile
+ * a directive's template instead of relying on automatic template compilation via `template` or
+ * `templateUrl` declaration or manual compilation inside the compile function.
+ * </div>
+ *
+ * <div class="alert alert-danger">
+ * **Note:** The `transclude` function that is passed to the compile function is deprecated, as it
+ * e.g. does not know about the right outer scope. Please use the transclude function that is passed
+ * to the link function instead.
+ * </div>
+
+ * A compile function can have a return value which can be either a function or an object.
+ *
+ * * returning a (post-link) function - is equivalent to registering the linking function via the
+ * `link` property of the config object when the compile function is empty.
+ *
+ * * returning an object with function(s) registered via `pre` and `post` properties - allows you to
+ * control when a linking function should be called during the linking phase. See info about
+ * pre-linking and post-linking functions below.
+ *
+ *
+ * #### `link`
+ * This property is used only if the `compile` property is not defined.
+ *
+ * ```js
+ * function link(scope, iElement, iAttrs, controller, transcludeFn) { ... }
+ * ```
+ *
+ * The link function is responsible for registering DOM listeners as well as updating the DOM. It is
+ * executed after the template has been cloned. This is where most of the directive logic will be
+ * put.
+ *
+ * * `scope` - {@link ng.$rootScope.Scope Scope} - The scope to be used by the
+ * directive for registering {@link ng.$rootScope.Scope#$watch watches}.
+ *
+ * * `iElement` - instance element - The element where the directive is to be used. It is safe to
+ * manipulate the children of the element only in `postLink` function since the children have
+ * already been linked.
+ *
+ * * `iAttrs` - instance attributes - Normalized list of attributes declared on this element shared
+ * between all directive linking functions.
+ *
+ * * `controller` - the directive's required controller instance(s) - Instances are shared
+ * among all directives, which allows the directives to use the controllers as a communication
+ * channel. The exact value depends on the directive's `require` property:
+ * * no controller(s) required: the directive's own controller, or `undefined` if it doesn't have one
+ * * `string`: the controller instance
+ * * `array`: array of controller instances
+ *
+ * If a required controller cannot be found, and it is optional, the instance is `null`,
+ * otherwise the {@link error:$compile:ctreq Missing Required Controller} error is thrown.
+ *
+ * Note that you can also require the directive's own controller - it will be made available like
+ * any other controller.
+ *
+ * * `transcludeFn` - A transclude linking function pre-bound to the correct transclusion scope.
+ * This is the same as the `$transclude` parameter of directive controllers,
+ * see {@link ng.$compile#-controller- the controller section for details}.
+ * `function([scope], cloneLinkingFn, futureParentElement)`.
+ *
+ * #### Pre-linking function
+ *
+ * Executed before the child elements are linked. Not safe to do DOM transformation since the
+ * compiler linking function will fail to locate the correct elements for linking.
+ *
+ * #### Post-linking function
+ *
+ * Executed after the child elements are linked.
+ *
+ * Note that child elements that contain `templateUrl` directives will not have been compiled
+ * and linked since they are waiting for their template to load asynchronously and their own
+ * compilation and linking has been suspended until that occurs.
+ *
+ * It is safe to do DOM transformation in the post-linking function on elements that are not waiting
+ * for their async templates to be resolved.
+ *
+ *
+ * ### Transclusion
+ *
+ * Transclusion is the process of extracting a collection of DOM elements from one part of the DOM and
+ * copying them to another part of the DOM, while maintaining their connection to the original AngularJS
+ * scope from where they were taken.
+ *
+ * Transclusion is used (often with {@link ngTransclude}) to insert the
+ * original contents of a directive's element into a specified place in the template of the directive.
+ * The benefit of transclusion, over simply moving the DOM elements manually, is that the transcluded
+ * content has access to the properties on the scope from which it was taken, even if the directive
+ * has isolated scope.
+ * See the {@link guide/directive#creating-a-directive-that-wraps-other-elements Directives Guide}.
+ *
+ * This makes it possible for the widget to have private state for its template, while the transcluded
+ * content has access to its originating scope.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** When testing an element transclude directive you must not place the directive at the root of the
+ * DOM fragment that is being compiled. See {@link guide/unit-testing#testing-transclusion-directives
+ * Testing Transclusion Directives}.
+ * </div>
+ *
+ * There are three kinds of transclusion depending upon whether you want to transclude just the contents of the
+ * directive's element, the entire element or multiple parts of the element contents:
+ *
+ * * `true` - transclude the content (i.e. the child nodes) of the directive's element.
+ * * `'element'` - transclude the whole of the directive's element including any directives on this
+ * element that are defined at a lower priority than this directive. When used, the `template`
+ * property is ignored.
+ * * **`{...}` (an object hash):** - map elements of the content onto transclusion "slots" in the template.
+ *
+ * **Multi-slot transclusion** is declared by providing an object for the `transclude` property.
+ *
+ * This object is a map where the keys are the name of the slot to fill and the value is an element selector
+ * used to match the HTML to the slot. The element selector should be in normalized form (e.g. `myElement`)
+ * and will match the standard element variants (e.g. `my-element`, `my:element`, `data-my-element`, etc).
+ *
+ * For further information check out the guide on {@link guide/directive#matching-directives Matching Directives}.
+ *
+ * If the element selector is prefixed with a `?` then that slot is optional.
+ *
+ * For example, the transclude object `{ slotA: '?myCustomElement' }` maps `<my-custom-element>` elements to
+ * the `slotA` slot, which can be accessed via the `$transclude` function or via the {@link ngTransclude} directive.
+ *
+ * Slots that are not marked as optional (`?`) will trigger a compile time error if there are no matching elements
+ * in the transclude content. If you wish to know if an optional slot was filled with content, then you can call
+ * `$transclude.isSlotFilled(slotName)` on the transclude function passed to the directive's link function and
+ * injectable into the directive's controller.
+ *
+ *
+ * #### Transclusion Functions
+ *
+ * When a directive requests transclusion, the compiler extracts its contents and provides a **transclusion
+ * function** to the directive's `link` function and `controller`. This transclusion function is a special
+ * **linking function** that will return the compiled contents linked to a new transclusion scope.
+ *
+ * <div class="alert alert-info">
+ * If you are just using {@link ngTransclude} then you don't need to worry about this function, since
+ * ngTransclude will deal with it for us.
+ * </div>
+ *
+ * If you want to manually control the insertion and removal of the transcluded content in your directive
+ * then you must use this transclude function. When you call a transclude function it returns a jqLite/JQuery
+ * object that contains the compiled DOM, which is linked to the correct transclusion scope.
+ *
+ * When you call a transclusion function you can pass in a **clone attach function**. This function accepts
+ * two parameters, `function(clone, scope) { ... }`, where the `clone` is a fresh compiled copy of your transcluded
+ * content and the `scope` is the newly created transclusion scope, which the clone will be linked to.
+ *
+ * <div class="alert alert-info">
+ * **Best Practice**: Always provide a `cloneFn` (clone attach function) when you call a transclude function
+ * since you then get a fresh clone of the original DOM and also have access to the new transclusion scope.
+ * </div>
+ *
+ * It is normal practice to attach your transcluded content (`clone`) to the DOM inside your **clone
+ * attach function**:
+ *
+ * ```js
+ * var transcludedContent, transclusionScope;
+ *
+ * $transclude(function(clone, scope) {
+ * element.append(clone);
+ * transcludedContent = clone;
+ * transclusionScope = scope;
+ * });
+ * ```
+ *
+ * Later, if you want to remove the transcluded content from your DOM then you should also destroy the
+ * associated transclusion scope:
+ *
+ * ```js
+ * transcludedContent.remove();
+ * transclusionScope.$destroy();
+ * ```
+ *
+ * <div class="alert alert-info">
+ * **Best Practice**: if you intend to add and remove transcluded content manually in your directive
+ * (by calling the transclude function to get the DOM and calling `element.remove()` to remove it),
+ * then you are also responsible for calling `$destroy` on the transclusion scope.
+ * </div>
+ *
+ * The built-in DOM manipulation directives, such as {@link ngIf}, {@link ngSwitch} and {@link ngRepeat}
+ * automatically destroy their transcluded clones as necessary so you do not need to worry about this if
+ * you are simply using {@link ngTransclude} to inject the transclusion into your directive.
+ *
+ *
+ * #### Transclusion Scopes
+ *
+ * When you call a transclude function it returns a DOM fragment that is pre-bound to a **transclusion
+ * scope**. This scope is special, in that it is a child of the directive's scope (and so gets destroyed
+ * when the directive's scope gets destroyed) but it inherits the properties of the scope from which it
+ * was taken.
+ *
+ * For example consider a directive that uses transclusion and isolated scope. The DOM hierarchy might look
+ * like this:
+ *
+ * ```html
+ * <div ng-app>
+ * <div isolate>
+ * <div transclusion>
+ * </div>
+ * </div>
+ * </div>
+ * ```
+ *
+ * The `$parent` scope hierarchy will look like this:
+ *
+ ```
+ - $rootScope
+ - isolate
+ - transclusion
+ ```
+ *
+ * but the scopes will inherit prototypically from different scopes to their `$parent`.
+ *
+ ```
+ - $rootScope
+ - transclusion
+ - isolate
+ ```
+ *
+ *
+ * ### Attributes
+ *
+ * The {@link ng.$compile.directive.Attributes Attributes} object - passed as a parameter in the
+ * `link()` or `compile()` functions. It has a variety of uses.
+ *
+ * * *Accessing normalized attribute names:* Directives like `ngBind` can be expressed in many ways:
+ * `ng:bind`, `data-ng-bind`, or `x-ng-bind`. The attributes object allows for normalized access
+ * to the attributes.
+ *
+ * * *Directive inter-communication:* All directives share the same instance of the attributes
+ * object which allows the directives to use the attributes object as inter directive
+ * communication.
+ *
+ * * *Supports interpolation:* Interpolation attributes are assigned to the attribute object
+ * allowing other directives to read the interpolated value.
+ *
+ * * *Observing interpolated attributes:* Use `$observe` to observe the value changes of attributes
+ * that contain interpolation (e.g. `src="{{bar}}"`). Not only is this very efficient but it's also
+ * the only way to easily get the actual value because during the linking phase the interpolation
+ * hasn't been evaluated yet and so the value is at this time set to `undefined`.
+ *
+ * ```js
+ * function linkingFn(scope, elm, attrs, ctrl) {
+ * // get the attribute value
+ * console.log(attrs.ngModel);
+ *
+ * // change the attribute
+ * attrs.$set('ngModel', 'new value');
+ *
+ * // observe changes to interpolated attribute
+ * attrs.$observe('ngModel', function(value) {
+ * console.log('ngModel has changed value to ' + value);
+ * });
+ * }
+ * ```
+ *
+ * ## Example
+ *
+ * <div class="alert alert-warning">
+ * **Note**: Typically directives are registered with `module.directive`. The example below is
+ * to illustrate how `$compile` works.
+ * </div>
+ *
+ <example module="compileExample" name="compile">
+ <file name="index.html">
+ <script>
+ angular.module('compileExample', [], function($compileProvider) {
+ // Configure new 'compile' directive by passing a directive
+ // factory function. The factory function injects '$compile'.
+ $compileProvider.directive('compile', function($compile) {
+ // The directive factory creates a link function.
+ return function(scope, element, attrs) {
+ scope.$watch(
+ function(scope) {
+ // Watch the 'compile' expression for changes.
+ return scope.$eval(attrs.compile);
+ },
+ function(value) {
+ // When the 'compile' expression changes
+ // assign it into the current DOM.
+ element.html(value);
+
+ // Compile the new DOM and link it to the current scope.
+ // NOTE: we only compile '.childNodes' so that we
+ // don't get into an infinite loop compiling ourselves.
+ $compile(element.contents())(scope);
+ }
+ );
+ };
+ });
+ })
+ .controller('GreeterController', ['$scope', function($scope) {
+ $scope.name = 'AngularJS';
+ $scope.html = 'Hello {{name}}';
+ }]);
+ </script>
+ <div ng-controller="GreeterController">
+ <input ng-model="name"> <br/>
+ <textarea ng-model="html"></textarea> <br/>
+ <div compile="html"></div>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should auto compile', function() {
+ var textarea = $('textarea');
+ var output = $('div[compile]');
+ // The initial state reads 'Hello AngularJS'.
+ expect(output.getText()).toBe('Hello AngularJS');
+ textarea.clear();
+ textarea.sendKeys('{{name}}!');
+ expect(output.getText()).toBe('AngularJS!');
+ });
+ </file>
+ </example>
+
+ *
+ *
+ * @param {string|DOMElement} element Element or HTML string to compile into a template function.
+ * @param {function(angular.Scope, cloneAttachFn=)} transclude function available to directives - DEPRECATED.
+ *
+ * <div class="alert alert-danger">
+ * **Note:** Passing a `transclude` function to the $compile function is deprecated, as it
+ * e.g. will not use the right outer scope. Please pass the transclude function as a
+ * `parentBoundTranscludeFn` to the link function instead.
+ * </div>
+ *
+ * @param {number} maxPriority only apply directives lower than given priority (Only effects the
+ * root element(s), not their children)
+ * @returns {function(scope, cloneAttachFn=, options=)} a link function which is used to bind template
+ * (a DOM element/tree) to a scope. Where:
+ *
+ * * `scope` - A {@link ng.$rootScope.Scope Scope} to bind to.
+ * * `cloneAttachFn` - If `cloneAttachFn` is provided, then the link function will clone the
+ * `template` and call the `cloneAttachFn` function allowing the caller to attach the
+ * cloned elements to the DOM document at the appropriate place. The `cloneAttachFn` is
+ * called as: <br/> `cloneAttachFn(clonedElement, scope)` where:
+ *
+ * * `clonedElement` - is a clone of the original `element` passed into the compiler.
+ * * `scope` - is the current scope with which the linking function is working with.
+ *
+ * * `options` - An optional object hash with linking options. If `options` is provided, then the following
+ * keys may be used to control linking behavior:
+ *
+ * * `parentBoundTranscludeFn` - the transclude function made available to
+ * directives; if given, it will be passed through to the link functions of
+ * directives found in `element` during compilation.
+ * * `transcludeControllers` - an object hash with keys that map controller names
+ * to a hash with the key `instance`, which maps to the controller instance;
+ * if given, it will make the controllers available to directives on the compileNode:
+ * ```
+ * {
+ * parent: {
+ * instance: parentControllerInstance
+ * }
+ * }
+ * ```
+ * * `futureParentElement` - defines the parent to which the `cloneAttachFn` will add
+ * the cloned elements; only needed for transcludes that are allowed to contain non HTML
+ * elements (e.g. SVG elements). See also the `directive.controller` property.
+ *
+ * Calling the linking function returns the element of the template. It is either the original
+ * element passed in, or the clone of the element if the `cloneAttachFn` is provided.
+ *
+ * After linking the view is not updated until after a call to `$digest`, which typically is done by
+ * AngularJS automatically.
+ *
+ * If you need access to the bound view, there are two ways to do it:
+ *
+ * - If you are not asking the linking function to clone the template, create the DOM element(s)
+ * before you send them to the compiler and keep this reference around.
+ * ```js
+ * var element = angular.element('<p>{{total}}</p>');
+ * $compile(element)(scope);
+ * ```
+ *
+ * - if on the other hand, you need the element to be cloned, the view reference from the original
+ * example would not point to the clone, but rather to the original template that was cloned. In
+ * this case, you can access the clone either via the `cloneAttachFn` or the value returned by the
+ * linking function:
+ * ```js
+ * var templateElement = angular.element('<p>{{total}}</p>');
+ * var clonedElement = $compile(templateElement)(scope, function(clonedElement, scope) {
+ * // Attach the clone to DOM document at the right place.
+ * });
+ *
+ * // Now we have reference to the cloned DOM via `clonedElement`.
+ * // NOTE: The `clonedElement` returned by the linking function is the same as the
+ * // `clonedElement` passed to `cloneAttachFn`.
+ * ```
+ *
+ *
+ * For information on how the compiler works, see the
+ * {@link guide/compiler AngularJS HTML Compiler} section of the Developer Guide.
+ *
+ * @knownIssue
+ *
+ * ### Double Compilation
+ *
+ Double compilation occurs when an already compiled part of the DOM gets
+ compiled again. This is an undesired effect and can lead to misbehaving directives, performance issues,
+ and memory leaks. Refer to the Compiler Guide {@link guide/compiler#double-compilation-and-how-to-avoid-it
+ section on double compilation} for an in-depth explanation and ways to avoid it.
+
+ * @knownIssue
+
+ ### Issues with `replace: true`
+ *
+ * <div class="alert alert-danger">
+ * **Note**: {@link $compile#-replace- `replace: true`} is deprecated and not recommended to use,
+ * mainly due to the issues listed here. It has been completely removed in the new Angular.
+ * </div>
+ *
+ * #### Attribute values are not merged
+ *
+ * When a `replace` directive encounters the same attribute on the original and the replace node,
+ * it will simply deduplicate the attribute and join the values with a space or with a `;` in case of
+ * the `style` attribute.
+ * ```html
+ * Original Node: <span class="original" style="color: red;"></span>
+ * Replace Template: <span class="replaced" style="background: blue;"></span>
+ * Result: <span class="original replaced" style="color: red; background: blue;"></span>
+ * ```
+ *
+ * That means attributes that contain AngularJS expressions will not be merged correctly, e.g.
+ * {@link ngShow} or {@link ngClass} will cause a {@link $parse} error:
+ *
+ * ```html
+ * Original Node: <span ng-class="{'something': something}" ng-show="!condition"></span>
+ * Replace Template: <span ng-class="{'else': else}" ng-show="otherCondition"></span>
+ * Result: <span ng-class="{'something': something} {'else': else}" ng-show="!condition otherCondition"></span>
+ * ```
+ *
+ * See issue [#5695](https://github.com/angular/angular.js/issues/5695).
+ *
+ * #### Directives are not deduplicated before compilation
+ *
+ * When the original node and the replace template declare the same directive(s), they will be
+ * {@link guide/compiler#double-compilation-and-how-to-avoid-it compiled twice} because the compiler
+ * does not deduplicate them. In many cases, this is not noticeable, but e.g. {@link ngModel} will
+ * attach `$formatters` and `$parsers` twice.
+ *
+ * See issue [#2573](https://github.com/angular/angular.js/issues/2573).
+ *
+ * #### `transclude: element` in the replace template root can have unexpected effects
+ *
+ * When the replace template has a directive at the root node that uses
+ * {@link $compile#-transclude- `transclude: element`}, e.g.
+ * {@link ngIf} or {@link ngRepeat}, the DOM structure or scope inheritance can be incorrect.
+ * See the following issues:
+ *
+ * - Incorrect scope on replaced element:
+ * [#9837](https://github.com/angular/angular.js/issues/9837)
+ * - Different DOM between `template` and `templateUrl`:
+ * [#10612](https://github.com/angular/angular.js/issues/14326)
+ *
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngProp
+ * @restrict A
+ * @element ANY
+ *
+ * @usage
+ *
+ * ```html
+ * <ANY ng-prop-propname="expression">
+ * </ANY>
+ * ```
+ *
+ * or with uppercase letters in property (e.g. "propName"):
+ *
+ *
+ * ```html
+ * <ANY ng-prop-prop_name="expression">
+ * </ANY>
+ * ```
+ *
+ *
+ * @description
+ * The `ngProp` directive binds an expression to a DOM element property.
+ * `ngProp` allows writing to arbitrary properties by including
+ * the property name in the attribute, e.g. `ng-prop-value="'my value'"` binds 'my value' to
+ * the `value` property.
+ *
+ * Usually, it's not necessary to write to properties in AngularJS, as the built-in directives
+ * handle the most common use cases (instead of the above example, you would use {@link ngValue}).
+ *
+ * However, [custom elements](https://developer.mozilla.org/docs/Web/Web_Components/Using_custom_elements)
+ * often use custom properties to hold data, and `ngProp` can be used to provide input to these
+ * custom elements.
+ *
+ * ## Binding to camelCase properties
+ *
+ * Since HTML attributes are case-insensitive, camelCase properties like `innerHTML` must be escaped.
+ * AngularJS uses the underscore (_) in front of a character to indicate that it is uppercase, so
+ * `innerHTML` must be written as `ng-prop-inner_h_t_m_l="expression"` (Note that this is just an
+ * example, and for binding HTML {@link ngBindHtml} should be used.
+ *
+ * ## Security
+ *
+ * Binding expressions to arbitrary properties poses a security risk, as properties like `innerHTML`
+ * can insert potentially dangerous HTML into the application, e.g. script tags that execute
+ * malicious code.
+ * For this reason, `ngProp` applies Strict Contextual Escaping with the {@link ng.$sce $sce service}.
+ * This means vulnerable properties require their content to be "trusted", based on the
+ * context of the property. For example, the `innerHTML` is in the `HTML` context, and the
+ * `iframe.src` property is in the `RESOURCE_URL` context, which requires that values written to
+ * this property are trusted as a `RESOURCE_URL`.
+ *
+ * This can be set explicitly by calling $sce.trustAs(type, value) on the value that is
+ * trusted before passing it to the `ng-prop-*` directive. There are exist shorthand methods for
+ * each context type in the form of {@link ng.$sce#trustAsResourceUrl $sce.trustAsResourceUrl()} et al.
+ *
+ * In some cases you can also rely upon automatic sanitization of untrusted values - see below.
+ *
+ * Based on the context, other options may exist to mark a value as trusted / configure the behavior
+ * of {@link ng.$sce}. For example, to restrict the `RESOURCE_URL` context to specific origins, use
+ * the {@link $sceDelegateProvider#trustedResourceUrlList trustedResourceUrlList()}
+ * and {@link $sceDelegateProvider#bannedResourceUrlList bannedResourceUrlList()}.
+ *
+ * {@link ng.$sce#what-trusted-context-types-are-supported- Find out more about the different context types}.
+ *
+ * ### HTML Sanitization
+ *
+ * By default, `$sce` will throw an error if it detects untrusted HTML content, and will not bind the
+ * content.
+ * However, if you include the {@link ngSanitize ngSanitize module}, it will try to sanitize the
+ * potentially dangerous HTML, e.g. strip non-trusted tags and attributes when binding to
+ * `innerHTML`.
+ *
+ * @example
+ * ### Binding to different contexts
+ *
+ * <example name="ngProp" module="exampleNgProp">
+ * <file name="app.js">
+ * angular.module('exampleNgProp', [])
+ * .component('main', {
+ * templateUrl: 'main.html',
+ * controller: function($sce) {
+ * this.safeContent = '<strong>Safe content</strong>';
+ * this.unsafeContent = '<button onclick="alert(\'Hello XSS!\')">Click for XSS</button>';
+ * this.trustedUnsafeContent = $sce.trustAsHtml(this.unsafeContent);
+ * }
+ * });
+ * </file>
+ * <file name="main.html">
+ * <div>
+ * <div class="prop-unit">
+ * Binding to a property without security context:
+ * <div class="prop-binding" ng-prop-inner_text="$ctrl.safeContent"></div>
+ * <span class="prop-note">innerText</span> (safeContent)
+ * </div>
+ *
+ * <div class="prop-unit">
+ * "Safe" content that requires a security context will throw because the contents could potentially be dangerous ...
+ * <div class="prop-binding" ng-prop-inner_h_t_m_l="$ctrl.safeContent"></div>
+ * <span class="prop-note">innerHTML</span> (safeContent)
+ * </div>
+ *
+ * <div class="prop-unit">
+ * ... so that actually dangerous content cannot be executed:
+ * <div class="prop-binding" ng-prop-inner_h_t_m_l="$ctrl.unsafeContent"></div>
+ * <span class="prop-note">innerHTML</span> (unsafeContent)
+ * </div>
+ *
+ * <div class="prop-unit">
+ * ... but unsafe Content that has been trusted explicitly works - only do this if you are 100% sure!
+ * <div class="prop-binding" ng-prop-inner_h_t_m_l="$ctrl.trustedUnsafeContent"></div>
+ * <span class="prop-note">innerHTML</span> (trustedUnsafeContent)
+ * </div>
+ * </div>
+ * </file>
+ * <file name="index.html">
+ * <main></main>
+ * </file>
+ * <file name="styles.css">
+ * .prop-unit {
+ * margin-bottom: 10px;
+ * }
+ *
+ * .prop-binding {
+ * min-height: 30px;
+ * border: 1px solid blue;
+ * }
+ *
+ * .prop-note {
+ * font-family: Monospace;
+ * }
+ * </file>
+ * </example>
+ *
+ *
+ * @example
+ * ### Binding to innerHTML with ngSanitize
+ *
+ * <example name="ngProp" module="exampleNgProp" deps="angular-sanitize.js">
+ * <file name="app.js">
+ * angular.module('exampleNgProp', ['ngSanitize'])
+ * .component('main', {
+ * templateUrl: 'main.html',
+ * controller: function($sce) {
+ * this.safeContent = '<strong>Safe content</strong>';
+ * this.unsafeContent = '<button onclick="alert(\'Hello XSS!\')">Click for XSS</button>';
+ * this.trustedUnsafeContent = $sce.trustAsHtml(this.unsafeContent);
+ * }
+ * });
+ * </file>
+ * <file name="main.html">
+ * <div>
+ * <div class="prop-unit">
+ * "Safe" content will be sanitized ...
+ * <div class="prop-binding" ng-prop-inner_h_t_m_l="$ctrl.safeContent"></div>
+ * <span class="prop-note">innerHTML</span> (safeContent)
+ * </div>
+ *
+ * <div class="prop-unit">
+ * ... as will dangerous content:
+ * <div class="prop-binding" ng-prop-inner_h_t_m_l="$ctrl.unsafeContent"></div>
+ * <span class="prop-note">innerHTML</span> (unsafeContent)
+ * </div>
+ *
+ * <div class="prop-unit">
+ * ... and content that has been trusted explicitly works the same as without ngSanitize:
+ * <div class="prop-binding" ng-prop-inner_h_t_m_l="$ctrl.trustedUnsafeContent"></div>
+ * <span class="prop-note">innerHTML</span> (trustedUnsafeContent)
+ * </div>
+ * </div>
+ * </file>
+ * <file name="index.html">
+ * <main></main>
+ * </file>
+ * <file name="styles.css">
+ * .prop-unit {
+ * margin-bottom: 10px;
+ * }
+ *
+ * .prop-binding {
+ * min-height: 30px;
+ * border: 1px solid blue;
+ * }
+ *
+ * .prop-note {
+ * font-family: Monospace;
+ * }
+ * </file>
+ * </example>
+ *
+ */
+
+/** @ngdoc directive
+ * @name ngOn
+ * @restrict A
+ * @element ANY
+ *
+ * @usage
+ *
+ * ```html
+ * <ANY ng-on-eventname="expression">
+ * </ANY>
+ * ```
+ *
+ * or with uppercase letters in property (e.g. "eventName"):
+ *
+ *
+ * ```html
+ * <ANY ng-on-event_name="expression">
+ * </ANY>
+ * ```
+ *
+ * @description
+ * The `ngOn` directive adds an event listener to a DOM element via
+ * {@link angular.element angular.element().on()}, and evaluates an expression when the event is
+ * fired.
+ * `ngOn` allows adding listeners for arbitrary events by including
+ * the event name in the attribute, e.g. `ng-on-drop="onDrop()"` executes the 'onDrop()' expression
+ * when the `drop` event is fired.
+ *
+ * AngularJS provides specific directives for many events, such as {@link ngClick}, so in most
+ * cases it is not necessary to use `ngOn`. However, AngularJS does not support all events
+ * (e.g. the `drop` event in the example above), and new events might be introduced in later DOM
+ * standards.
+ *
+ * Another use-case for `ngOn` is listening to
+ * [custom events](https://developer.mozilla.org/docs/Web/Guide/Events/Creating_and_triggering_events)
+ * fired by
+ * [custom elements](https://developer.mozilla.org/docs/Web/Web_Components/Using_custom_elements).
+ *
+ * ## Binding to camelCase properties
+ *
+ * Since HTML attributes are case-insensitive, camelCase properties like `myEvent` must be escaped.
+ * AngularJS uses the underscore (_) in front of a character to indicate that it is uppercase, so
+ * `myEvent` must be written as `ng-on-my_event="expression"`.
+ *
+ * @example
+ * ### Bind to built-in DOM events
+ *
+ * <example name="ngOn" module="exampleNgOn">
+ * <file name="app.js">
+ * angular.module('exampleNgOn', [])
+ * .component('main', {
+ * templateUrl: 'main.html',
+ * controller: function() {
+ * this.clickCount = 0;
+ * this.mouseoverCount = 0;
+ *
+ * this.loadingState = 0;
+ * }
+ * });
+ * </file>
+ * <file name="main.html">
+ * <div>
+ * This is equivalent to `ngClick` and `ngMouseover`:<br>
+ * <button
+ * ng-on-click="$ctrl.clickCount = $ctrl.clickCount + 1"
+ * ng-on-mouseover="$ctrl.mouseoverCount = $ctrl.mouseoverCount + 1">Click or mouseover</button><br>
+ * clickCount: {{$ctrl.clickCount}}<br>
+ * mouseover: {{$ctrl.mouseoverCount}}
+ *
+ * <hr>
+ *
+ * For the `error` and `load` event on images no built-in AngularJS directives exist:<br>
+ * <img src="thisimagedoesnotexist.png" ng-on-error="$ctrl.loadingState = -1" ng-on-load="$ctrl.loadingState = 1"><br>
+ * <div ng-switch="$ctrl.loadingState">
+ * <span ng-switch-when="0">Image is loading</span>
+ * <span ng-switch-when="-1">Image load error</span>
+ * <span ng-switch-when="1">Image loaded successfully</span>
+ * </div>
+ * </div>
+ * </file>
+ * <file name="index.html">
+ * <main></main>
+ * </file>
+ * </example>
+ *
+ *
+ * @example
+ * ### Bind to custom DOM events
+ *
+ * <example name="ngOnCustom" module="exampleNgOn">
+ * <file name="app.js">
+ * angular.module('exampleNgOn', [])
+ * .component('main', {
+ * templateUrl: 'main.html',
+ * controller: function() {
+ * this.eventLog = '';
+ *
+ * this.listener = function($event) {
+ * this.eventLog = 'Event with type "' + $event.type + '" fired at ' + $event.detail;
+ * };
+ * }
+ * })
+ * .component('childComponent', {
+ * templateUrl: 'child.html',
+ * controller: function($element) {
+ * this.fireEvent = function() {
+ * var event = new CustomEvent('customtype', { detail: new Date()});
+ *
+ * $element[0].dispatchEvent(event);
+ * };
+ * }
+ * });
+ * </file>
+ * <file name="main.html">
+ * <child-component ng-on-customtype="$ctrl.listener($event)"></child-component><br>
+ * <span>Event log: {{$ctrl.eventLog}}</span>
+ * </file>
+ * <file name="child.html">
+ <button ng-click="$ctrl.fireEvent()">Fire custom event</button>
+ * </file>
+ * <file name="index.html">
+ * <main></main>
+ * </file>
+ * </example>
+ */
+
+var $compileMinErr = minErr('$compile');
+
+function UNINITIALIZED_VALUE() {}
+var _UNINITIALIZED_VALUE = new UNINITIALIZED_VALUE();
+
+/**
+ * @ngdoc provider
+ * @name $compileProvider
+ *
+ * @description
+ */
+$CompileProvider.$inject = ['$provide', '$$sanitizeUriProvider'];
+/** @this */
+function $CompileProvider($provide, $$sanitizeUriProvider) {
+ var hasDirectives = {},
+ Suffix = 'Directive',
+ COMMENT_DIRECTIVE_REGEXP = /^\s*directive:\s*([\w-]+)\s+(.*)$/,
+ CLASS_DIRECTIVE_REGEXP = /(([\w-]+)(?::([^;]+))?;?)/,
+ ALL_OR_NOTHING_ATTRS = makeMap('ngSrc,ngSrcset,src,srcset'),
+ REQUIRE_PREFIX_REGEXP = /^(?:(\^\^?)?(\?)?(\^\^?)?)?/;
+
+ // Ref: http://developers.whatwg.org/webappapis.html#event-handler-idl-attributes
+ // The assumption is that future DOM event attribute names will begin with
+ // 'on' and be composed of only English letters.
+ var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;
+ var bindingCache = createMap();
+
+ function parseIsolateBindings(scope, directiveName, isController) {
+ var LOCAL_REGEXP = /^([@&]|[=<](\*?))(\??)\s*([\w$]*)$/;
+
+ var bindings = createMap();
+
+ forEach(scope, function(definition, scopeName) {
+ definition = definition.trim();
+
+ if (definition in bindingCache) {
+ bindings[scopeName] = bindingCache[definition];
+ return;
+ }
+ var match = definition.match(LOCAL_REGEXP);
+
+ if (!match) {
+ throw $compileMinErr('iscp',
+ 'Invalid {3} for directive \'{0}\'.' +
+ ' Definition: {... {1}: \'{2}\' ...}',
+ directiveName, scopeName, definition,
+ (isController ? 'controller bindings definition' :
+ 'isolate scope definition'));
+ }
+
+ bindings[scopeName] = {
+ mode: match[1][0],
+ collection: match[2] === '*',
+ optional: match[3] === '?',
+ attrName: match[4] || scopeName
+ };
+ if (match[4]) {
+ bindingCache[definition] = bindings[scopeName];
+ }
+ });
+
+ return bindings;
+ }
+
+ function parseDirectiveBindings(directive, directiveName) {
+ var bindings = {
+ isolateScope: null,
+ bindToController: null
+ };
+ if (isObject(directive.scope)) {
+ if (directive.bindToController === true) {
+ bindings.bindToController = parseIsolateBindings(directive.scope,
+ directiveName, true);
+ bindings.isolateScope = {};
+ } else {
+ bindings.isolateScope = parseIsolateBindings(directive.scope,
+ directiveName, false);
+ }
+ }
+ if (isObject(directive.bindToController)) {
+ bindings.bindToController =
+ parseIsolateBindings(directive.bindToController, directiveName, true);
+ }
+ if (bindings.bindToController && !directive.controller) {
+ // There is no controller
+ throw $compileMinErr('noctrl',
+ 'Cannot bind to controller without directive \'{0}\'s controller.',
+ directiveName);
+ }
+ return bindings;
+ }
+
+ function assertValidDirectiveName(name) {
+ var letter = name.charAt(0);
+ if (!letter || letter !== lowercase(letter)) {
+ throw $compileMinErr('baddir', 'Directive/Component name \'{0}\' is invalid. The first character must be a lowercase letter', name);
+ }
+ if (name !== name.trim()) {
+ throw $compileMinErr('baddir',
+ 'Directive/Component name \'{0}\' is invalid. The name should not contain leading or trailing whitespaces',
+ name);
+ }
+ }
+
+ function getDirectiveRequire(directive) {
+ var require = directive.require || (directive.controller && directive.name);
+
+ if (!isArray(require) && isObject(require)) {
+ forEach(require, function(value, key) {
+ var match = value.match(REQUIRE_PREFIX_REGEXP);
+ var name = value.substring(match[0].length);
+ if (!name) require[key] = match[0] + key;
+ });
+ }
+
+ return require;
+ }
+
+ function getDirectiveRestrict(restrict, name) {
+ if (restrict && !(isString(restrict) && /[EACM]/.test(restrict))) {
+ throw $compileMinErr('badrestrict',
+ 'Restrict property \'{0}\' of directive \'{1}\' is invalid',
+ restrict,
+ name);
+ }
+
+ return restrict || 'EA';
+ }
+
+ /**
+ * @ngdoc method
+ * @name $compileProvider#directive
+ * @kind function
+ *
+ * @description
+ * Register a new directive with the compiler.
+ *
+ * @param {string|Object} name Name of the directive in camel-case (i.e. `ngBind` which will match
+ * as `ng-bind`), or an object map of directives where the keys are the names and the values
+ * are the factories.
+ * @param {Function|Array} directiveFactory An injectable directive factory function. See the
+ * {@link guide/directive directive guide} and the {@link $compile compile API} for more info.
+ * @returns {ng.$compileProvider} Self for chaining.
+ */
+ this.directive = function registerDirective(name, directiveFactory) {
+ assertArg(name, 'name');
+ assertNotHasOwnProperty(name, 'directive');
+ if (isString(name)) {
+ assertValidDirectiveName(name);
+ assertArg(directiveFactory, 'directiveFactory');
+ if (!hasDirectives.hasOwnProperty(name)) {
+ hasDirectives[name] = [];
+ $provide.factory(name + Suffix, ['$injector', '$exceptionHandler',
+ function($injector, $exceptionHandler) {
+ var directives = [];
+ forEach(hasDirectives[name], function(directiveFactory, index) {
+ try {
+ var directive = $injector.invoke(directiveFactory);
+ if (isFunction(directive)) {
+ directive = { compile: valueFn(directive) };
+ } else if (!directive.compile && directive.link) {
+ directive.compile = valueFn(directive.link);
+ }
+ directive.priority = directive.priority || 0;
+ directive.index = index;
+ directive.name = directive.name || name;
+ directive.require = getDirectiveRequire(directive);
+ directive.restrict = getDirectiveRestrict(directive.restrict, name);
+ directive.$$moduleName = directiveFactory.$$moduleName;
+ directives.push(directive);
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ });
+ return directives;
+ }]);
+ }
+ hasDirectives[name].push(directiveFactory);
+ } else {
+ forEach(name, reverseParams(registerDirective));
+ }
+ return this;
+ };
+
+ /**
+ * @ngdoc method
+ * @name $compileProvider#component
+ * @module ng
+ * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
+ * or an object map of components where the keys are the names and the values are the component definition objects.
+ * @param {Object} options Component definition object (a simplified
+ * {@link ng.$compile#directive-definition-object directive definition object}),
+ * with the following properties (all optional):
+ *
+ * - `controller` – `{(string|function()=}` – controller constructor function that should be
+ * associated with newly created scope or the name of a {@link ng.$compile#-controller-
+ * registered controller} if passed as a string. An empty `noop` function by default.
+ * - `controllerAs` – `{string=}` – identifier name for to reference the controller in the component's scope.
+ * If present, the controller will be published to scope under the `controllerAs` name.
+ * If not present, this will default to be `$ctrl`.
+ * - `template` – `{string=|function()=}` – html template as a string or a function that
+ * returns an html template as a string which should be used as the contents of this component.
+ * Empty string by default.
+ *
+ * If `template` is a function, then it is {@link auto.$injector#invoke injected} with
+ * the following locals:
+ *
+ * - `$element` - Current element
+ * - `$attrs` - Current attributes object for the element
+ *
+ * - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html
+ * template that should be used as the contents of this component.
+ *
+ * If `templateUrl` is a function, then it is {@link auto.$injector#invoke injected} with
+ * the following locals:
+ *
+ * - `$element` - Current element
+ * - `$attrs` - Current attributes object for the element
+ *
+ * - `bindings` – `{object=}` – defines bindings between DOM attributes and component properties.
+ * Component properties are always bound to the component controller and not to the scope.
+ * See {@link ng.$compile#-bindtocontroller- `bindToController`}.
+ * - `transclude` – `{boolean=}` – whether {@link $compile#transclusion content transclusion} is enabled.
+ * Disabled by default.
+ * - `require` - `{Object<string, string>=}` - requires the controllers of other directives and binds them to
+ * this component's controller. The object keys specify the property names under which the required
+ * controllers (object values) will be bound. See {@link ng.$compile#-require- `require`}.
+ * - `$...` – additional properties to attach to the directive factory function and the controller
+ * constructor function. (This is used by the component router to annotate)
+ *
+ * @returns {ng.$compileProvider} the compile provider itself, for chaining of function calls.
+ * @description
+ * Register a **component definition** with the compiler. This is a shorthand for registering a special
+ * type of directive, which represents a self-contained UI component in your application. Such components
+ * are always isolated (i.e. `scope: {}`) and are always restricted to elements (i.e. `restrict: 'E'`).
+ *
+ * Component definitions are very simple and do not require as much configuration as defining general
+ * directives. Component definitions usually consist only of a template and a controller backing it.
+ *
+ * In order to make the definition easier, components enforce best practices like use of `controllerAs`,
+ * `bindToController`. They always have **isolate scope** and are restricted to elements.
+ *
+ * Here are a few examples of how you would usually define components:
+ *
+ * ```js
+ * var myMod = angular.module(...);
+ * myMod.component('myComp', {
+ * template: '<div>My name is {{$ctrl.name}}</div>',
+ * controller: function() {
+ * this.name = 'shahar';
+ * }
+ * });
+ *
+ * myMod.component('myComp', {
+ * template: '<div>My name is {{$ctrl.name}}</div>',
+ * bindings: {name: '@'}
+ * });
+ *
+ * myMod.component('myComp', {
+ * templateUrl: 'views/my-comp.html',
+ * controller: 'MyCtrl',
+ * controllerAs: 'ctrl',
+ * bindings: {name: '@'}
+ * });
+ *
+ * ```
+ * For more examples, and an in-depth guide, see the {@link guide/component component guide}.
+ *
+ * <br />
+ * See also {@link ng.$compileProvider#directive $compileProvider.directive()}.
+ */
+ this.component = function registerComponent(name, options) {
+ if (!isString(name)) {
+ forEach(name, reverseParams(bind(this, registerComponent)));
+ return this;
+ }
+
+ var controller = options.controller || function() {};
+
+ function factory($injector) {
+ function makeInjectable(fn) {
+ if (isFunction(fn) || isArray(fn)) {
+ return /** @this */ function(tElement, tAttrs) {
+ return $injector.invoke(fn, this, {$element: tElement, $attrs: tAttrs});
+ };
+ } else {
+ return fn;
+ }
+ }
+
+ var template = (!options.template && !options.templateUrl ? '' : options.template);
+ var ddo = {
+ controller: controller,
+ controllerAs: identifierForController(options.controller) || options.controllerAs || '$ctrl',
+ template: makeInjectable(template),
+ templateUrl: makeInjectable(options.templateUrl),
+ transclude: options.transclude,
+ scope: {},
+ bindToController: options.bindings || {},
+ restrict: 'E',
+ require: options.require
+ };
+
+ // Copy annotations (starting with $) over to the DDO
+ forEach(options, function(val, key) {
+ if (key.charAt(0) === '$') ddo[key] = val;
+ });
+
+ return ddo;
+ }
+
+ // TODO(pete) remove the following `forEach` before we release 1.6.0
+ // The component-router@0.2.0 looks for the annotations on the controller constructor
+ // Nothing in AngularJS looks for annotations on the factory function but we can't remove
+ // it from 1.5.x yet.
+
+ // Copy any annotation properties (starting with $) over to the factory and controller constructor functions
+ // These could be used by libraries such as the new component router
+ forEach(options, function(val, key) {
+ if (key.charAt(0) === '$') {
+ factory[key] = val;
+ // Don't try to copy over annotations to named controller
+ if (isFunction(controller)) controller[key] = val;
+ }
+ });
+
+ factory.$inject = ['$injector'];
+
+ return this.directive(name, factory);
+ };
+
+
+ /**
+ * @ngdoc method
+ * @name $compileProvider#aHrefSanitizationTrustedUrlList
+ * @kind function
+ *
+ * @description
+ * Retrieves or overrides the default regular expression that is used for determining trusted safe
+ * urls during a[href] sanitization.
+ *
+ * The sanitization is a security measure aimed at preventing XSS attacks via html links.
+ *
+ * Any url about to be assigned to a[href] via data-binding is first normalized and turned into
+ * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationTrustedUrlList`
+ * regular expression. If a match is found, the original url is written into the dom. Otherwise,
+ * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
+ *
+ * @param {RegExp=} regexp New regexp to trust urls with.
+ * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
+ * chaining otherwise.
+ */
+ this.aHrefSanitizationTrustedUrlList = function(regexp) {
+ if (isDefined(regexp)) {
+ $$sanitizeUriProvider.aHrefSanitizationTrustedUrlList(regexp);
+ return this;
+ } else {
+ return $$sanitizeUriProvider.aHrefSanitizationTrustedUrlList();
+ }
+ };
+
+
+ /**
+ * @ngdoc method
+ * @name $compileProvider#aHrefSanitizationWhitelist
+ * @kind function
+ *
+ * @deprecated
+ * sinceVersion="1.8.1"
+ *
+ * This method is deprecated. Use {@link $compileProvider#aHrefSanitizationTrustedUrlList
+ * aHrefSanitizationTrustedUrlList} instead.
+ */
+ Object.defineProperty(this, 'aHrefSanitizationWhitelist', {
+ get: function() {
+ return this.aHrefSanitizationTrustedUrlList;
+ },
+ set: function(value) {
+ this.aHrefSanitizationTrustedUrlList = value;
+ }
+ });
+
+
+ /**
+ * @ngdoc method
+ * @name $compileProvider#imgSrcSanitizationTrustedUrlList
+ * @kind function
+ *
+ * @description
+ * Retrieves or overrides the default regular expression that is used for determining trusted safe
+ * urls during img[src] sanitization.
+ *
+ * The sanitization is a security measure aimed at prevent XSS attacks via html links.
+ *
+ * Any url about to be assigned to img[src] via data-binding is first normalized and turned into
+ * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationTrustedUrlList`
+ * regular expression. If a match is found, the original url is written into the dom. Otherwise,
+ * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
+ *
+ * @param {RegExp=} regexp New regexp to trust urls with.
+ * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
+ * chaining otherwise.
+ */
+ this.imgSrcSanitizationTrustedUrlList = function(regexp) {
+ if (isDefined(regexp)) {
+ $$sanitizeUriProvider.imgSrcSanitizationTrustedUrlList(regexp);
+ return this;
+ } else {
+ return $$sanitizeUriProvider.imgSrcSanitizationTrustedUrlList();
+ }
+ };
+
+
+ /**
+ * @ngdoc method
+ * @name $compileProvider#imgSrcSanitizationWhitelist
+ * @kind function
+ *
+ * @deprecated
+ * sinceVersion="1.8.1"
+ *
+ * This method is deprecated. Use {@link $compileProvider#imgSrcSanitizationTrustedUrlList
+ * imgSrcSanitizationTrustedUrlList} instead.
+ */
+ Object.defineProperty(this, 'imgSrcSanitizationWhitelist', {
+ get: function() {
+ return this.imgSrcSanitizationTrustedUrlList;
+ },
+ set: function(value) {
+ this.imgSrcSanitizationTrustedUrlList = value;
+ }
+ });
+
+ /**
+ * @ngdoc method
+ * @name $compileProvider#debugInfoEnabled
+ *
+ * @param {boolean=} enabled update the debugInfoEnabled state if provided, otherwise just return the
+ * current debugInfoEnabled state
+ * @returns {*} current value if used as getter or itself (chaining) if used as setter
+ *
+ * @kind function
+ *
+ * @description
+ * Call this method to enable/disable various debug runtime information in the compiler such as adding
+ * binding information and a reference to the current scope on to DOM elements.
+ * If enabled, the compiler will add the following to DOM elements that have been bound to the scope
+ * * `ng-binding` CSS class
+ * * `ng-scope` and `ng-isolated-scope` CSS classes
+ * * `$binding` data property containing an array of the binding expressions
+ * * Data properties used by the {@link angular.element#methods `scope()`/`isolateScope()` methods} to return
+ * the element's scope.
+ * * Placeholder comments will contain information about what directive and binding caused the placeholder.
+ * E.g. `<!-- ngIf: shouldShow() -->`.
+ *
+ * You may want to disable this in production for a significant performance boost. See
+ * {@link guide/production#disabling-debug-data Disabling Debug Data} for more.
+ *
+ * The default value is true.
+ */
+ var debugInfoEnabled = true;
+ this.debugInfoEnabled = function(enabled) {
+ if (isDefined(enabled)) {
+ debugInfoEnabled = enabled;
+ return this;
+ }
+ return debugInfoEnabled;
+ };
+
+ /**
+ * @ngdoc method
+ * @name $compileProvider#strictComponentBindingsEnabled
+ *
+ * @param {boolean=} enabled update the strictComponentBindingsEnabled state if provided,
+ * otherwise return the current strictComponentBindingsEnabled state.
+ * @returns {*} current value if used as getter or itself (chaining) if used as setter
+ *
+ * @kind function
+ *
+ * @description
+ * Call this method to enable / disable the strict component bindings check. If enabled, the
+ * compiler will enforce that all scope / controller bindings of a
+ * {@link $compileProvider#directive directive} / {@link $compileProvider#component component}
+ * that are not set as optional with `?`, must be provided when the directive is instantiated.
+ * If not provided, the compiler will throw the
+ * {@link error/$compile/missingattr $compile:missingattr error}.
+ *
+ * The default value is false.
+ */
+ var strictComponentBindingsEnabled = false;
+ this.strictComponentBindingsEnabled = function(enabled) {
+ if (isDefined(enabled)) {
+ strictComponentBindingsEnabled = enabled;
+ return this;
+ }
+ return strictComponentBindingsEnabled;
+ };
+
+ var TTL = 10;
+ /**
+ * @ngdoc method
+ * @name $compileProvider#onChangesTtl
+ * @description
+ *
+ * Sets the number of times `$onChanges` hooks can trigger new changes before giving up and
+ * assuming that the model is unstable.
+ *
+ * The current default is 10 iterations.
+ *
+ * In complex applications it's possible that dependencies between `$onChanges` hooks and bindings will result
+ * in several iterations of calls to these hooks. However if an application needs more than the default 10
+ * iterations to stabilize then you should investigate what is causing the model to continuously change during
+ * the `$onChanges` hook execution.
+ *
+ * Increasing the TTL could have performance implications, so you should not change it without proper justification.
+ *
+ * @param {number} limit The number of `$onChanges` hook iterations.
+ * @returns {number|object} the current limit (or `this` if called as a setter for chaining)
+ */
+ this.onChangesTtl = function(value) {
+ if (arguments.length) {
+ TTL = value;
+ return this;
+ }
+ return TTL;
+ };
+
+ var commentDirectivesEnabledConfig = true;
+ /**
+ * @ngdoc method
+ * @name $compileProvider#commentDirectivesEnabled
+ * @description
+ *
+ * It indicates to the compiler
+ * whether or not directives on comments should be compiled.
+ * Defaults to `true`.
+ *
+ * Calling this function with false disables the compilation of directives
+ * on comments for the whole application.
+ * This results in a compilation performance gain,
+ * as the compiler doesn't have to check comments when looking for directives.
+ * This should however only be used if you are sure that no comment directives are used in
+ * the application (including any 3rd party directives).
+ *
+ * @param {boolean} enabled `false` if the compiler may ignore directives on comments
+ * @returns {boolean|object} the current value (or `this` if called as a setter for chaining)
+ */
+ this.commentDirectivesEnabled = function(value) {
+ if (arguments.length) {
+ commentDirectivesEnabledConfig = value;
+ return this;
+ }
+ return commentDirectivesEnabledConfig;
+ };
+
+
+ var cssClassDirectivesEnabledConfig = true;
+ /**
+ * @ngdoc method
+ * @name $compileProvider#cssClassDirectivesEnabled
+ * @description
+ *
+ * It indicates to the compiler
+ * whether or not directives on element classes should be compiled.
+ * Defaults to `true`.
+ *
+ * Calling this function with false disables the compilation of directives
+ * on element classes for the whole application.
+ * This results in a compilation performance gain,
+ * as the compiler doesn't have to check element classes when looking for directives.
+ * This should however only be used if you are sure that no class directives are used in
+ * the application (including any 3rd party directives).
+ *
+ * @param {boolean} enabled `false` if the compiler may ignore directives on element classes
+ * @returns {boolean|object} the current value (or `this` if called as a setter for chaining)
+ */
+ this.cssClassDirectivesEnabled = function(value) {
+ if (arguments.length) {
+ cssClassDirectivesEnabledConfig = value;
+ return this;
+ }
+ return cssClassDirectivesEnabledConfig;
+ };
+
+
+ /**
+ * The security context of DOM Properties.
+ * @private
+ */
+ var PROP_CONTEXTS = createMap();
+
+ /**
+ * @ngdoc method
+ * @name $compileProvider#addPropertySecurityContext
+ * @description
+ *
+ * Defines the security context for DOM properties bound by ng-prop-*.
+ *
+ * @param {string} elementName The element name or '*' to match any element.
+ * @param {string} propertyName The DOM property name.
+ * @param {string} ctx The {@link $sce} security context in which this value is safe for use, e.g. `$sce.URL`
+ * @returns {object} `this` for chaining
+ */
+ this.addPropertySecurityContext = function(elementName, propertyName, ctx) {
+ var key = (elementName.toLowerCase() + '|' + propertyName.toLowerCase());
+
+ if (key in PROP_CONTEXTS && PROP_CONTEXTS[key] !== ctx) {
+ throw $compileMinErr('ctxoverride', 'Property context \'{0}.{1}\' already set to \'{2}\', cannot override to \'{3}\'.', elementName, propertyName, PROP_CONTEXTS[key], ctx);
+ }
+
+ PROP_CONTEXTS[key] = ctx;
+ return this;
+ };
+
+ /* Default property contexts.
+ *
+ * Copy of https://github.com/angular/angular/blob/6.0.6/packages/compiler/src/schema/dom_security_schema.ts#L31-L58
+ * Changing:
+ * - SecurityContext.* => SCE_CONTEXTS/$sce.*
+ * - STYLE => CSS
+ * - various URL => MEDIA_URL
+ * - *|formAction, form|action URL => RESOURCE_URL (like the attribute)
+ */
+ (function registerNativePropertyContexts() {
+ function registerContext(ctx, values) {
+ forEach(values, function(v) { PROP_CONTEXTS[v.toLowerCase()] = ctx; });
+ }
+
+ registerContext(SCE_CONTEXTS.HTML, [
+ 'iframe|srcdoc',
+ '*|innerHTML',
+ '*|outerHTML'
+ ]);
+ registerContext(SCE_CONTEXTS.CSS, ['*|style']);
+ registerContext(SCE_CONTEXTS.URL, [
+ 'area|href', 'area|ping',
+ 'a|href', 'a|ping',
+ 'blockquote|cite',
+ 'body|background',
+ 'del|cite',
+ 'input|src',
+ 'ins|cite',
+ 'q|cite'
+ ]);
+ registerContext(SCE_CONTEXTS.MEDIA_URL, [
+ 'audio|src',
+ 'img|src', 'img|srcset',
+ 'source|src', 'source|srcset',
+ 'track|src',
+ 'video|src', 'video|poster'
+ ]);
+ registerContext(SCE_CONTEXTS.RESOURCE_URL, [
+ '*|formAction',
+ 'applet|code', 'applet|codebase',
+ 'base|href',
+ 'embed|src',
+ 'frame|src',
+ 'form|action',
+ 'head|profile',
+ 'html|manifest',
+ 'iframe|src',
+ 'link|href',
+ 'media|src',
+ 'object|codebase', 'object|data',
+ 'script|src'
+ ]);
+ })();
+
+
+ this.$get = [
+ '$injector', '$interpolate', '$exceptionHandler', '$templateRequest', '$parse',
+ '$controller', '$rootScope', '$sce', '$animate',
+ function($injector, $interpolate, $exceptionHandler, $templateRequest, $parse,
+ $controller, $rootScope, $sce, $animate) {
+
+ var SIMPLE_ATTR_NAME = /^\w/;
+ var specialAttrHolder = window.document.createElement('div');
+
+
+ var commentDirectivesEnabled = commentDirectivesEnabledConfig;
+ var cssClassDirectivesEnabled = cssClassDirectivesEnabledConfig;
+
+
+ var onChangesTtl = TTL;
+ // The onChanges hooks should all be run together in a single digest
+ // When changes occur, the call to trigger their hooks will be added to this queue
+ var onChangesQueue;
+
+ // This function is called in a $$postDigest to trigger all the onChanges hooks in a single digest
+ function flushOnChangesQueue() {
+ try {
+ if (!(--onChangesTtl)) {
+ // We have hit the TTL limit so reset everything
+ onChangesQueue = undefined;
+ throw $compileMinErr('infchng', '{0} $onChanges() iterations reached. Aborting!\n', TTL);
+ }
+ // We must run this hook in an apply since the $$postDigest runs outside apply
+ $rootScope.$apply(function() {
+ for (var i = 0, ii = onChangesQueue.length; i < ii; ++i) {
+ try {
+ onChangesQueue[i]();
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ }
+ // Reset the queue to trigger a new schedule next time there is a change
+ onChangesQueue = undefined;
+ });
+ } finally {
+ onChangesTtl++;
+ }
+ }
+
+
+ function sanitizeSrcset(value, invokeType) {
+ if (!value) {
+ return value;
+ }
+ if (!isString(value)) {
+ throw $compileMinErr('srcset', 'Can\'t pass trusted values to `{0}`: "{1}"', invokeType, value.toString());
+ }
+
+ // Such values are a bit too complex to handle automatically inside $sce.
+ // Instead, we sanitize each of the URIs individually, which works, even dynamically.
+
+ // It's not possible to work around this using `$sce.trustAsMediaUrl`.
+ // If you want to programmatically set explicitly trusted unsafe URLs, you should use
+ // `$sce.trustAsHtml` on the whole `img` tag and inject it into the DOM using the
+ // `ng-bind-html` directive.
+
+ var result = '';
+
+ // first check if there are spaces because it's not the same pattern
+ var trimmedSrcset = trim(value);
+ // ( 999x ,| 999w ,| ,|, )
+ var srcPattern = /(\s+\d+x\s*,|\s+\d+w\s*,|\s+,|,\s+)/;
+ var pattern = /\s/.test(trimmedSrcset) ? srcPattern : /(,)/;
+
+ // split srcset into tuple of uri and descriptor except for the last item
+ var rawUris = trimmedSrcset.split(pattern);
+
+ // for each tuples
+ var nbrUrisWith2parts = Math.floor(rawUris.length / 2);
+ for (var i = 0; i < nbrUrisWith2parts; i++) {
+ var innerIdx = i * 2;
+ // sanitize the uri
+ result += $sce.getTrustedMediaUrl(trim(rawUris[innerIdx]));
+ // add the descriptor
+ result += ' ' + trim(rawUris[innerIdx + 1]);
+ }
+
+ // split the last item into uri and descriptor
+ var lastTuple = trim(rawUris[i * 2]).split(/\s/);
+
+ // sanitize the last uri
+ result += $sce.getTrustedMediaUrl(trim(lastTuple[0]));
+
+ // and add the last descriptor if any
+ if (lastTuple.length === 2) {
+ result += (' ' + trim(lastTuple[1]));
+ }
+ return result;
+ }
+
+
+ function Attributes(element, attributesToCopy) {
+ if (attributesToCopy) {
+ var keys = Object.keys(attributesToCopy);
+ var i, l, key;
+
+ for (i = 0, l = keys.length; i < l; i++) {
+ key = keys[i];
+ this[key] = attributesToCopy[key];
+ }
+ } else {
+ this.$attr = {};
+ }
+
+ this.$$element = element;
+ }
+
+ Attributes.prototype = {
+ /**
+ * @ngdoc method
+ * @name $compile.directive.Attributes#$normalize
+ * @kind function
+ *
+ * @description
+ * Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with `x-` or
+ * `data-`) to its normalized, camelCase form.
+ *
+ * Also there is special case for Moz prefix starting with upper case letter.
+ *
+ * For further information check out the guide on {@link guide/directive#matching-directives Matching Directives}
+ *
+ * @param {string} name Name to normalize
+ */
+ $normalize: directiveNormalize,
+
+
+ /**
+ * @ngdoc method
+ * @name $compile.directive.Attributes#$addClass
+ * @kind function
+ *
+ * @description
+ * Adds the CSS class value specified by the classVal parameter to the element. If animations
+ * are enabled then an animation will be triggered for the class addition.
+ *
+ * @param {string} classVal The className value that will be added to the element
+ */
+ $addClass: function(classVal) {
+ if (classVal && classVal.length > 0) {
+ $animate.addClass(this.$$element, classVal);
+ }
+ },
+
+ /**
+ * @ngdoc method
+ * @name $compile.directive.Attributes#$removeClass
+ * @kind function
+ *
+ * @description
+ * Removes the CSS class value specified by the classVal parameter from the element. If
+ * animations are enabled then an animation will be triggered for the class removal.
+ *
+ * @param {string} classVal The className value that will be removed from the element
+ */
+ $removeClass: function(classVal) {
+ if (classVal && classVal.length > 0) {
+ $animate.removeClass(this.$$element, classVal);
+ }
+ },
+
+ /**
+ * @ngdoc method
+ * @name $compile.directive.Attributes#$updateClass
+ * @kind function
+ *
+ * @description
+ * Adds and removes the appropriate CSS class values to the element based on the difference
+ * between the new and old CSS class values (specified as newClasses and oldClasses).
+ *
+ * @param {string} newClasses The current CSS className value
+ * @param {string} oldClasses The former CSS className value
+ */
+ $updateClass: function(newClasses, oldClasses) {
+ var toAdd = tokenDifference(newClasses, oldClasses);
+ if (toAdd && toAdd.length) {
+ $animate.addClass(this.$$element, toAdd);
+ }
+
+ var toRemove = tokenDifference(oldClasses, newClasses);
+ if (toRemove && toRemove.length) {
+ $animate.removeClass(this.$$element, toRemove);
+ }
+ },
+
+ /**
+ * Set a normalized attribute on the element in a way such that all directives
+ * can share the attribute. This function properly handles boolean attributes.
+ * @param {string} key Normalized key. (ie ngAttribute)
+ * @param {string|boolean} value The value to set. If `null` attribute will be deleted.
+ * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
+ * Defaults to true.
+ * @param {string=} attrName Optional none normalized name. Defaults to key.
+ */
+ $set: function(key, value, writeAttr, attrName) {
+ // TODO: decide whether or not to throw an error if "class"
+ // is set through this function since it may cause $updateClass to
+ // become unstable.
+
+ var node = this.$$element[0],
+ booleanKey = getBooleanAttrName(node, key),
+ aliasedKey = getAliasedAttrName(key),
+ observer = key,
+ nodeName;
+
+ if (booleanKey) {
+ this.$$element.prop(key, value);
+ attrName = booleanKey;
+ } else if (aliasedKey) {
+ this[aliasedKey] = value;
+ observer = aliasedKey;
+ }
+
+ this[key] = value;
+
+ // translate normalized key to actual key
+ if (attrName) {
+ this.$attr[key] = attrName;
+ } else {
+ attrName = this.$attr[key];
+ if (!attrName) {
+ this.$attr[key] = attrName = snake_case(key, '-');
+ }
+ }
+
+ nodeName = nodeName_(this.$$element);
+
+ // Sanitize img[srcset] values.
+ if (nodeName === 'img' && key === 'srcset') {
+ this[key] = value = sanitizeSrcset(value, '$set(\'srcset\', value)');
+ }
+
+ if (writeAttr !== false) {
+ if (value === null || isUndefined(value)) {
+ this.$$element.removeAttr(attrName);
+ } else {
+ if (SIMPLE_ATTR_NAME.test(attrName)) {
+ // jQuery skips special boolean attrs treatment in XML nodes for
+ // historical reasons and hence AngularJS cannot freely call
+ // `.attr(attrName, false) with such attributes. To avoid issues
+ // in XHTML, call `removeAttr` in such cases instead.
+ // See https://github.com/jquery/jquery/issues/4249
+ if (booleanKey && value === false) {
+ this.$$element.removeAttr(attrName);
+ } else {
+ this.$$element.attr(attrName, value);
+ }
+ } else {
+ setSpecialAttr(this.$$element[0], attrName, value);
+ }
+ }
+ }
+
+ // fire observers
+ var $$observers = this.$$observers;
+ if ($$observers) {
+ forEach($$observers[observer], function(fn) {
+ try {
+ fn(value);
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ });
+ }
+ },
+
+
+ /**
+ * @ngdoc method
+ * @name $compile.directive.Attributes#$observe
+ * @kind function
+ *
+ * @description
+ * Observes an interpolated attribute.
+ *
+ * The observer function will be invoked once during the next `$digest` following
+ * compilation. The observer is then invoked whenever the interpolated value
+ * changes.
+ *
+ * @param {string} key Normalized key. (ie ngAttribute) .
+ * @param {function(interpolatedValue)} fn Function that will be called whenever
+ the interpolated value of the attribute changes.
+ * See the {@link guide/interpolation#how-text-and-attribute-bindings-work Interpolation
+ * guide} for more info.
+ * @returns {function()} Returns a deregistration function for this observer.
+ */
+ $observe: function(key, fn) {
+ var attrs = this,
+ $$observers = (attrs.$$observers || (attrs.$$observers = createMap())),
+ listeners = ($$observers[key] || ($$observers[key] = []));
+
+ listeners.push(fn);
+ $rootScope.$evalAsync(function() {
+ if (!listeners.$$inter && attrs.hasOwnProperty(key) && !isUndefined(attrs[key])) {
+ // no one registered attribute interpolation function, so lets call it manually
+ fn(attrs[key]);
+ }
+ });
+
+ return function() {
+ arrayRemove(listeners, fn);
+ };
+ }
+ };
+
+ function setSpecialAttr(element, attrName, value) {
+ // Attributes names that do not start with letters (such as `(click)`) cannot be set using `setAttribute`
+ // so we have to jump through some hoops to get such an attribute
+ // https://github.com/angular/angular.js/pull/13318
+ specialAttrHolder.innerHTML = '<span ' + attrName + '>';
+ var attributes = specialAttrHolder.firstChild.attributes;
+ var attribute = attributes[0];
+ // We have to remove the attribute from its container element before we can add it to the destination element
+ attributes.removeNamedItem(attribute.name);
+ attribute.value = value;
+ element.attributes.setNamedItem(attribute);
+ }
+
+ function safeAddClass($element, className) {
+ try {
+ $element.addClass(className);
+ } catch (e) {
+ // ignore, since it means that we are trying to set class on
+ // SVG element, where class name is read-only.
+ }
+ }
+
+
+ var startSymbol = $interpolate.startSymbol(),
+ endSymbol = $interpolate.endSymbol(),
+ denormalizeTemplate = (startSymbol === '{{' && endSymbol === '}}')
+ ? identity
+ : function denormalizeTemplate(template) {
+ return template.replace(/\{\{/g, startSymbol).replace(/}}/g, endSymbol);
+ },
+ NG_PREFIX_BINDING = /^ng(Attr|Prop|On)([A-Z].*)$/;
+ var MULTI_ELEMENT_DIR_RE = /^(.+)Start$/;
+
+ compile.$$addBindingInfo = debugInfoEnabled ? function $$addBindingInfo($element, binding) {
+ var bindings = $element.data('$binding') || [];
+
+ if (isArray(binding)) {
+ bindings = bindings.concat(binding);
+ } else {
+ bindings.push(binding);
+ }
+
+ $element.data('$binding', bindings);
+ } : noop;
+
+ compile.$$addBindingClass = debugInfoEnabled ? function $$addBindingClass($element) {
+ safeAddClass($element, 'ng-binding');
+ } : noop;
+
+ compile.$$addScopeInfo = debugInfoEnabled ? function $$addScopeInfo($element, scope, isolated, noTemplate) {
+ var dataName = isolated ? (noTemplate ? '$isolateScopeNoTemplate' : '$isolateScope') : '$scope';
+ $element.data(dataName, scope);
+ } : noop;
+
+ compile.$$addScopeClass = debugInfoEnabled ? function $$addScopeClass($element, isolated) {
+ safeAddClass($element, isolated ? 'ng-isolate-scope' : 'ng-scope');
+ } : noop;
+
+ compile.$$createComment = function(directiveName, comment) {
+ var content = '';
+ if (debugInfoEnabled) {
+ content = ' ' + (directiveName || '') + ': ';
+ if (comment) content += comment + ' ';
+ }
+ return window.document.createComment(content);
+ };
+
+ return compile;
+
+ //================================
+
+ function compile($compileNodes, transcludeFn, maxPriority, ignoreDirective,
+ previousCompileContext) {
+ if (!($compileNodes instanceof jqLite)) {
+ // jquery always rewraps, whereas we need to preserve the original selector so that we can
+ // modify it.
+ $compileNodes = jqLite($compileNodes);
+ }
+ var compositeLinkFn =
+ compileNodes($compileNodes, transcludeFn, $compileNodes,
+ maxPriority, ignoreDirective, previousCompileContext);
+ compile.$$addScopeClass($compileNodes);
+ var namespace = null;
+ return function publicLinkFn(scope, cloneConnectFn, options) {
+ if (!$compileNodes) {
+ throw $compileMinErr('multilink', 'This element has already been linked.');
+ }
+ assertArg(scope, 'scope');
+
+ if (previousCompileContext && previousCompileContext.needsNewScope) {
+ // A parent directive did a replace and a directive on this element asked
+ // for transclusion, which caused us to lose a layer of element on which
+ // we could hold the new transclusion scope, so we will create it manually
+ // here.
+ scope = scope.$parent.$new();
+ }
+
+ options = options || {};
+ var parentBoundTranscludeFn = options.parentBoundTranscludeFn,
+ transcludeControllers = options.transcludeControllers,
+ futureParentElement = options.futureParentElement;
+
+ // When `parentBoundTranscludeFn` is passed, it is a
+ // `controllersBoundTransclude` function (it was previously passed
+ // as `transclude` to directive.link) so we must unwrap it to get
+ // its `boundTranscludeFn`
+ if (parentBoundTranscludeFn && parentBoundTranscludeFn.$$boundTransclude) {
+ parentBoundTranscludeFn = parentBoundTranscludeFn.$$boundTransclude;
+ }
+
+ if (!namespace) {
+ namespace = detectNamespaceForChildElements(futureParentElement);
+ }
+ var $linkNode;
+ if (namespace !== 'html') {
+ // When using a directive with replace:true and templateUrl the $compileNodes
+ // (or a child element inside of them)
+ // might change, so we need to recreate the namespace adapted compileNodes
+ // for call to the link function.
+ // Note: This will already clone the nodes...
+ $linkNode = jqLite(
+ wrapTemplate(namespace, jqLite('<div></div>').append($compileNodes).html())
+ );
+ } else if (cloneConnectFn) {
+ // important!!: we must call our jqLite.clone() since the jQuery one is trying to be smart
+ // and sometimes changes the structure of the DOM.
+ $linkNode = JQLitePrototype.clone.call($compileNodes);
+ } else {
+ $linkNode = $compileNodes;
+ }
+
+ if (transcludeControllers) {
+ for (var controllerName in transcludeControllers) {
+ $linkNode.data('$' + controllerName + 'Controller', transcludeControllers[controllerName].instance);
+ }
+ }
+
+ compile.$$addScopeInfo($linkNode, scope);
+
+ if (cloneConnectFn) cloneConnectFn($linkNode, scope);
+ if (compositeLinkFn) compositeLinkFn(scope, $linkNode, $linkNode, parentBoundTranscludeFn);
+
+ if (!cloneConnectFn) {
+ $compileNodes = compositeLinkFn = null;
+ }
+ return $linkNode;
+ };
+ }
+
+ function detectNamespaceForChildElements(parentElement) {
+ // TODO: Make this detect MathML as well...
+ var node = parentElement && parentElement[0];
+ if (!node) {
+ return 'html';
+ } else {
+ return nodeName_(node) !== 'foreignobject' && toString.call(node).match(/SVG/) ? 'svg' : 'html';
+ }
+ }
+
+ /**
+ * Compile function matches each node in nodeList against the directives. Once all directives
+ * for a particular node are collected their compile functions are executed. The compile
+ * functions return values - the linking functions - are combined into a composite linking
+ * function, which is the a linking function for the node.
+ *
+ * @param {NodeList} nodeList an array of nodes or NodeList to compile
+ * @param {function(angular.Scope, cloneAttachFn=)} transcludeFn A linking function, where the
+ * scope argument is auto-generated to the new child of the transcluded parent scope.
+ * @param {DOMElement=} $rootElement If the nodeList is the root of the compilation tree then
+ * the rootElement must be set the jqLite collection of the compile root. This is
+ * needed so that the jqLite collection items can be replaced with widgets.
+ * @param {number=} maxPriority Max directive priority.
+ * @returns {Function} A composite linking function of all of the matched directives or null.
+ */
+ function compileNodes(nodeList, transcludeFn, $rootElement, maxPriority, ignoreDirective,
+ previousCompileContext) {
+ var linkFns = [],
+ // `nodeList` can be either an element's `.childNodes` (live NodeList)
+ // or a jqLite/jQuery collection or an array
+ notLiveList = isArray(nodeList) || (nodeList instanceof jqLite),
+ attrs, directives, nodeLinkFn, childNodes, childLinkFn, linkFnFound, nodeLinkFnFound;
+
+
+ for (var i = 0; i < nodeList.length; i++) {
+ attrs = new Attributes();
+
+ // Support: IE 11 only
+ // Workaround for #11781 and #14924
+ if (msie === 11) {
+ mergeConsecutiveTextNodes(nodeList, i, notLiveList);
+ }
+
+ // We must always refer to `nodeList[i]` hereafter,
+ // since the nodes can be replaced underneath us.
+ directives = collectDirectives(nodeList[i], [], attrs, i === 0 ? maxPriority : undefined,
+ ignoreDirective);
+
+ nodeLinkFn = (directives.length)
+ ? applyDirectivesToNode(directives, nodeList[i], attrs, transcludeFn, $rootElement,
+ null, [], [], previousCompileContext)
+ : null;
+
+ if (nodeLinkFn && nodeLinkFn.scope) {
+ compile.$$addScopeClass(attrs.$$element);
+ }
+
+ childLinkFn = (nodeLinkFn && nodeLinkFn.terminal ||
+ !(childNodes = nodeList[i].childNodes) ||
+ !childNodes.length)
+ ? null
+ : compileNodes(childNodes,
+ nodeLinkFn ? (
+ (nodeLinkFn.transcludeOnThisElement || !nodeLinkFn.templateOnThisElement)
+ && nodeLinkFn.transclude) : transcludeFn);
+
+ if (nodeLinkFn || childLinkFn) {
+ linkFns.push(i, nodeLinkFn, childLinkFn);
+ linkFnFound = true;
+ nodeLinkFnFound = nodeLinkFnFound || nodeLinkFn;
+ }
+
+ //use the previous context only for the first element in the virtual group
+ previousCompileContext = null;
+ }
+
+ // return a linking function if we have found anything, null otherwise
+ return linkFnFound ? compositeLinkFn : null;
+
+ function compositeLinkFn(scope, nodeList, $rootElement, parentBoundTranscludeFn) {
+ var nodeLinkFn, childLinkFn, node, childScope, i, ii, idx, childBoundTranscludeFn;
+ var stableNodeList;
+
+
+ if (nodeLinkFnFound) {
+ // copy nodeList so that if a nodeLinkFn removes or adds an element at this DOM level our
+ // offsets don't get screwed up
+ var nodeListLength = nodeList.length;
+ stableNodeList = new Array(nodeListLength);
+
+ // create a sparse array by only copying the elements which have a linkFn
+ for (i = 0; i < linkFns.length; i += 3) {
+ idx = linkFns[i];
+ stableNodeList[idx] = nodeList[idx];
+ }
+ } else {
+ stableNodeList = nodeList;
+ }
+
+ for (i = 0, ii = linkFns.length; i < ii;) {
+ node = stableNodeList[linkFns[i++]];
+ nodeLinkFn = linkFns[i++];
+ childLinkFn = linkFns[i++];
+
+ if (nodeLinkFn) {
+ if (nodeLinkFn.scope) {
+ childScope = scope.$new();
+ compile.$$addScopeInfo(jqLite(node), childScope);
+ } else {
+ childScope = scope;
+ }
+
+ if (nodeLinkFn.transcludeOnThisElement) {
+ childBoundTranscludeFn = createBoundTranscludeFn(
+ scope, nodeLinkFn.transclude, parentBoundTranscludeFn);
+
+ } else if (!nodeLinkFn.templateOnThisElement && parentBoundTranscludeFn) {
+ childBoundTranscludeFn = parentBoundTranscludeFn;
+
+ } else if (!parentBoundTranscludeFn && transcludeFn) {
+ childBoundTranscludeFn = createBoundTranscludeFn(scope, transcludeFn);
+
+ } else {
+ childBoundTranscludeFn = null;
+ }
+
+ nodeLinkFn(childLinkFn, childScope, node, $rootElement, childBoundTranscludeFn);
+
+ } else if (childLinkFn) {
+ childLinkFn(scope, node.childNodes, undefined, parentBoundTranscludeFn);
+ }
+ }
+ }
+ }
+
+ function mergeConsecutiveTextNodes(nodeList, idx, notLiveList) {
+ var node = nodeList[idx];
+ var parent = node.parentNode;
+ var sibling;
+
+ if (node.nodeType !== NODE_TYPE_TEXT) {
+ return;
+ }
+
+ while (true) {
+ sibling = parent ? node.nextSibling : nodeList[idx + 1];
+ if (!sibling || sibling.nodeType !== NODE_TYPE_TEXT) {
+ break;
+ }
+
+ node.nodeValue = node.nodeValue + sibling.nodeValue;
+
+ if (sibling.parentNode) {
+ sibling.parentNode.removeChild(sibling);
+ }
+ if (notLiveList && sibling === nodeList[idx + 1]) {
+ nodeList.splice(idx + 1, 1);
+ }
+ }
+ }
+
+ function createBoundTranscludeFn(scope, transcludeFn, previousBoundTranscludeFn) {
+ function boundTranscludeFn(transcludedScope, cloneFn, controllers, futureParentElement, containingScope) {
+
+ if (!transcludedScope) {
+ transcludedScope = scope.$new(false, containingScope);
+ transcludedScope.$$transcluded = true;
+ }
+
+ return transcludeFn(transcludedScope, cloneFn, {
+ parentBoundTranscludeFn: previousBoundTranscludeFn,
+ transcludeControllers: controllers,
+ futureParentElement: futureParentElement
+ });
+ }
+
+ // We need to attach the transclusion slots onto the `boundTranscludeFn`
+ // so that they are available inside the `controllersBoundTransclude` function
+ var boundSlots = boundTranscludeFn.$$slots = createMap();
+ for (var slotName in transcludeFn.$$slots) {
+ if (transcludeFn.$$slots[slotName]) {
+ boundSlots[slotName] = createBoundTranscludeFn(scope, transcludeFn.$$slots[slotName], previousBoundTranscludeFn);
+ } else {
+ boundSlots[slotName] = null;
+ }
+ }
+
+ return boundTranscludeFn;
+ }
+
+ /**
+ * Looks for directives on the given node and adds them to the directive collection which is
+ * sorted.
+ *
+ * @param node Node to search.
+ * @param directives An array to which the directives are added to. This array is sorted before
+ * the function returns.
+ * @param attrs The shared attrs object which is used to populate the normalized attributes.
+ * @param {number=} maxPriority Max directive priority.
+ */
+ function collectDirectives(node, directives, attrs, maxPriority, ignoreDirective) {
+ var nodeType = node.nodeType,
+ attrsMap = attrs.$attr,
+ match,
+ nodeName,
+ className;
+
+ switch (nodeType) {
+ case NODE_TYPE_ELEMENT: /* Element */
+
+ nodeName = nodeName_(node);
+
+ // use the node name: <directive>
+ addDirective(directives,
+ directiveNormalize(nodeName), 'E', maxPriority, ignoreDirective);
+
+ // iterate over the attributes
+ for (var attr, name, nName, value, ngPrefixMatch, nAttrs = node.attributes,
+ j = 0, jj = nAttrs && nAttrs.length; j < jj; j++) {
+ var attrStartName = false;
+ var attrEndName = false;
+
+ var isNgAttr = false, isNgProp = false, isNgEvent = false;
+ var multiElementMatch;
+
+ attr = nAttrs[j];
+ name = attr.name;
+ value = attr.value;
+
+ nName = directiveNormalize(name.toLowerCase());
+
+ // Support ng-attr-*, ng-prop-* and ng-on-*
+ if ((ngPrefixMatch = nName.match(NG_PREFIX_BINDING))) {
+ isNgAttr = ngPrefixMatch[1] === 'Attr';
+ isNgProp = ngPrefixMatch[1] === 'Prop';
+ isNgEvent = ngPrefixMatch[1] === 'On';
+
+ // Normalize the non-prefixed name
+ name = name.replace(PREFIX_REGEXP, '')
+ .toLowerCase()
+ .substr(4 + ngPrefixMatch[1].length).replace(/_(.)/g, function(match, letter) {
+ return letter.toUpperCase();
+ });
+
+ // Support *-start / *-end multi element directives
+ } else if ((multiElementMatch = nName.match(MULTI_ELEMENT_DIR_RE)) && directiveIsMultiElement(multiElementMatch[1])) {
+ attrStartName = name;
+ attrEndName = name.substr(0, name.length - 5) + 'end';
+ name = name.substr(0, name.length - 6);
+ }
+
+ if (isNgProp || isNgEvent) {
+ attrs[nName] = value;
+ attrsMap[nName] = attr.name;
+
+ if (isNgProp) {
+ addPropertyDirective(node, directives, nName, name);
+ } else {
+ addEventDirective(directives, nName, name);
+ }
+ } else {
+ // Update nName for cases where a prefix was removed
+ // NOTE: the .toLowerCase() is unnecessary and causes https://github.com/angular/angular.js/issues/16624 for ng-attr-*
+ nName = directiveNormalize(name.toLowerCase());
+ attrsMap[nName] = name;
+
+ if (isNgAttr || !attrs.hasOwnProperty(nName)) {
+ attrs[nName] = value;
+ if (getBooleanAttrName(node, nName)) {
+ attrs[nName] = true; // presence means true
+ }
+ }
+
+ addAttrInterpolateDirective(node, directives, value, nName, isNgAttr);
+ addDirective(directives, nName, 'A', maxPriority, ignoreDirective, attrStartName,
+ attrEndName);
+ }
+ }
+
+ if (nodeName === 'input' && node.getAttribute('type') === 'hidden') {
+ // Hidden input elements can have strange behaviour when navigating back to the page
+ // This tells the browser not to try to cache and reinstate previous values
+ node.setAttribute('autocomplete', 'off');
+ }
+
+ // use class as directive
+ if (!cssClassDirectivesEnabled) break;
+ className = node.className;
+ if (isObject(className)) {
+ // Maybe SVGAnimatedString
+ className = className.animVal;
+ }
+ if (isString(className) && className !== '') {
+ while ((match = CLASS_DIRECTIVE_REGEXP.exec(className))) {
+ nName = directiveNormalize(match[2]);
+ if (addDirective(directives, nName, 'C', maxPriority, ignoreDirective)) {
+ attrs[nName] = trim(match[3]);
+ }
+ className = className.substr(match.index + match[0].length);
+ }
+ }
+ break;
+ case NODE_TYPE_TEXT: /* Text Node */
+ addTextInterpolateDirective(directives, node.nodeValue);
+ break;
+ case NODE_TYPE_COMMENT: /* Comment */
+ if (!commentDirectivesEnabled) break;
+ collectCommentDirectives(node, directives, attrs, maxPriority, ignoreDirective);
+ break;
+ }
+
+ directives.sort(byPriority);
+ return directives;
+ }
+
+ function collectCommentDirectives(node, directives, attrs, maxPriority, ignoreDirective) {
+ // function created because of performance, try/catch disables
+ // the optimization of the whole function #14848
+ try {
+ var match = COMMENT_DIRECTIVE_REGEXP.exec(node.nodeValue);
+ if (match) {
+ var nName = directiveNormalize(match[1]);
+ if (addDirective(directives, nName, 'M', maxPriority, ignoreDirective)) {
+ attrs[nName] = trim(match[2]);
+ }
+ }
+ } catch (e) {
+ // turns out that under some circumstances IE9 throws errors when one attempts to read
+ // comment's node value.
+ // Just ignore it and continue. (Can't seem to reproduce in test case.)
+ }
+ }
+
+ /**
+ * Given a node with a directive-start it collects all of the siblings until it finds
+ * directive-end.
+ * @param node
+ * @param attrStart
+ * @param attrEnd
+ * @returns {*}
+ */
+ function groupScan(node, attrStart, attrEnd) {
+ var nodes = [];
+ var depth = 0;
+ if (attrStart && node.hasAttribute && node.hasAttribute(attrStart)) {
+ do {
+ if (!node) {
+ throw $compileMinErr('uterdir',
+ 'Unterminated attribute, found \'{0}\' but no matching \'{1}\' found.',
+ attrStart, attrEnd);
+ }
+ if (node.nodeType === NODE_TYPE_ELEMENT) {
+ if (node.hasAttribute(attrStart)) depth++;
+ if (node.hasAttribute(attrEnd)) depth--;
+ }
+ nodes.push(node);
+ node = node.nextSibling;
+ } while (depth > 0);
+ } else {
+ nodes.push(node);
+ }
+
+ return jqLite(nodes);
+ }
+
+ /**
+ * Wrapper for linking function which converts normal linking function into a grouped
+ * linking function.
+ * @param linkFn
+ * @param attrStart
+ * @param attrEnd
+ * @returns {Function}
+ */
+ function groupElementsLinkFnWrapper(linkFn, attrStart, attrEnd) {
+ return function groupedElementsLink(scope, element, attrs, controllers, transcludeFn) {
+ element = groupScan(element[0], attrStart, attrEnd);
+ return linkFn(scope, element, attrs, controllers, transcludeFn);
+ };
+ }
+
+ /**
+ * A function generator that is used to support both eager and lazy compilation
+ * linking function.
+ * @param eager
+ * @param $compileNodes
+ * @param transcludeFn
+ * @param maxPriority
+ * @param ignoreDirective
+ * @param previousCompileContext
+ * @returns {Function}
+ */
+ function compilationGenerator(eager, $compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext) {
+ var compiled;
+
+ if (eager) {
+ return compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext);
+ }
+ return /** @this */ function lazyCompilation() {
+ if (!compiled) {
+ compiled = compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext);
+
+ // Null out all of these references in order to make them eligible for garbage collection
+ // since this is a potentially long lived closure
+ $compileNodes = transcludeFn = previousCompileContext = null;
+ }
+ return compiled.apply(this, arguments);
+ };
+ }
+
+ /**
+ * Once the directives have been collected, their compile functions are executed. This method
+ * is responsible for inlining directive templates as well as terminating the application
+ * of the directives if the terminal directive has been reached.
+ *
+ * @param {Array} directives Array of collected directives to execute their compile function.
+ * this needs to be pre-sorted by priority order.
+ * @param {Node} compileNode The raw DOM node to apply the compile functions to
+ * @param {Object} templateAttrs The shared attribute function
+ * @param {function(angular.Scope, cloneAttachFn=)} transcludeFn A linking function, where the
+ * scope argument is auto-generated to the new
+ * child of the transcluded parent scope.
+ * @param {JQLite} jqCollection If we are working on the root of the compile tree then this
+ * argument has the root jqLite array so that we can replace nodes
+ * on it.
+ * @param {Object=} originalReplaceDirective An optional directive that will be ignored when
+ * compiling the transclusion.
+ * @param {Array.<Function>} preLinkFns
+ * @param {Array.<Function>} postLinkFns
+ * @param {Object} previousCompileContext Context used for previous compilation of the current
+ * node
+ * @returns {Function} linkFn
+ */
+ function applyDirectivesToNode(directives, compileNode, templateAttrs, transcludeFn,
+ jqCollection, originalReplaceDirective, preLinkFns, postLinkFns,
+ previousCompileContext) {
+ previousCompileContext = previousCompileContext || {};
+
+ var terminalPriority = -Number.MAX_VALUE,
+ newScopeDirective = previousCompileContext.newScopeDirective,
+ controllerDirectives = previousCompileContext.controllerDirectives,
+ newIsolateScopeDirective = previousCompileContext.newIsolateScopeDirective,
+ templateDirective = previousCompileContext.templateDirective,
+ nonTlbTranscludeDirective = previousCompileContext.nonTlbTranscludeDirective,
+ hasTranscludeDirective = false,
+ hasTemplate = false,
+ hasElementTranscludeDirective = previousCompileContext.hasElementTranscludeDirective,
+ $compileNode = templateAttrs.$$element = jqLite(compileNode),
+ directive,
+ directiveName,
+ $template,
+ replaceDirective = originalReplaceDirective,
+ childTranscludeFn = transcludeFn,
+ linkFn,
+ didScanForMultipleTransclusion = false,
+ mightHaveMultipleTransclusionError = false,
+ directiveValue;
+
+ // executes all directives on the current element
+ for (var i = 0, ii = directives.length; i < ii; i++) {
+ directive = directives[i];
+ var attrStart = directive.$$start;
+ var attrEnd = directive.$$end;
+
+ // collect multiblock sections
+ if (attrStart) {
+ $compileNode = groupScan(compileNode, attrStart, attrEnd);
+ }
+ $template = undefined;
+
+ if (terminalPriority > directive.priority) {
+ break; // prevent further processing of directives
+ }
+
+ directiveValue = directive.scope;
+
+ if (directiveValue) {
+
+ // skip the check for directives with async templates, we'll check the derived sync
+ // directive when the template arrives
+ if (!directive.templateUrl) {
+ if (isObject(directiveValue)) {
+ // This directive is trying to add an isolated scope.
+ // Check that there is no scope of any kind already
+ assertNoDuplicate('new/isolated scope', newIsolateScopeDirective || newScopeDirective,
+ directive, $compileNode);
+ newIsolateScopeDirective = directive;
+ } else {
+ // This directive is trying to add a child scope.
+ // Check that there is no isolated scope already
+ assertNoDuplicate('new/isolated scope', newIsolateScopeDirective, directive,
+ $compileNode);
+ }
+ }
+
+ newScopeDirective = newScopeDirective || directive;
+ }
+
+ directiveName = directive.name;
+
+ // If we encounter a condition that can result in transclusion on the directive,
+ // then scan ahead in the remaining directives for others that may cause a multiple
+ // transclusion error to be thrown during the compilation process. If a matching directive
+ // is found, then we know that when we encounter a transcluded directive, we need to eagerly
+ // compile the `transclude` function rather than doing it lazily in order to throw
+ // exceptions at the correct time
+ if (!didScanForMultipleTransclusion && ((directive.replace && (directive.templateUrl || directive.template))
+ || (directive.transclude && !directive.$$tlb))) {
+ var candidateDirective;
+
+ for (var scanningIndex = i + 1; (candidateDirective = directives[scanningIndex++]);) {
+ if ((candidateDirective.transclude && !candidateDirective.$$tlb)
+ || (candidateDirective.replace && (candidateDirective.templateUrl || candidateDirective.template))) {
+ mightHaveMultipleTransclusionError = true;
+ break;
+ }
+ }
+
+ didScanForMultipleTransclusion = true;
+ }
+
+ if (!directive.templateUrl && directive.controller) {
+ controllerDirectives = controllerDirectives || createMap();
+ assertNoDuplicate('\'' + directiveName + '\' controller',
+ controllerDirectives[directiveName], directive, $compileNode);
+ controllerDirectives[directiveName] = directive;
+ }
+
+ directiveValue = directive.transclude;
+
+ if (directiveValue) {
+ hasTranscludeDirective = true;
+
+ // Special case ngIf and ngRepeat so that we don't complain about duplicate transclusion.
+ // This option should only be used by directives that know how to safely handle element transclusion,
+ // where the transcluded nodes are added or replaced after linking.
+ if (!directive.$$tlb) {
+ assertNoDuplicate('transclusion', nonTlbTranscludeDirective, directive, $compileNode);
+ nonTlbTranscludeDirective = directive;
+ }
+
+ if (directiveValue === 'element') {
+ hasElementTranscludeDirective = true;
+ terminalPriority = directive.priority;
+ $template = $compileNode;
+ $compileNode = templateAttrs.$$element =
+ jqLite(compile.$$createComment(directiveName, templateAttrs[directiveName]));
+ compileNode = $compileNode[0];
+ replaceWith(jqCollection, sliceArgs($template), compileNode);
+
+ childTranscludeFn = compilationGenerator(mightHaveMultipleTransclusionError, $template, transcludeFn, terminalPriority,
+ replaceDirective && replaceDirective.name, {
+ // Don't pass in:
+ // - controllerDirectives - otherwise we'll create duplicates controllers
+ // - newIsolateScopeDirective or templateDirective - combining templates with
+ // element transclusion doesn't make sense.
+ //
+ // We need only nonTlbTranscludeDirective so that we prevent putting transclusion
+ // on the same element more than once.
+ nonTlbTranscludeDirective: nonTlbTranscludeDirective
+ });
+ } else {
+
+ var slots = createMap();
+
+ if (!isObject(directiveValue)) {
+ $template = jqLite(jqLiteClone(compileNode)).contents();
+ } else {
+
+ // We have transclusion slots,
+ // collect them up, compile them and store their transclusion functions
+ $template = window.document.createDocumentFragment();
+
+ var slotMap = createMap();
+ var filledSlots = createMap();
+
+ // Parse the element selectors
+ forEach(directiveValue, function(elementSelector, slotName) {
+ // If an element selector starts with a ? then it is optional
+ var optional = (elementSelector.charAt(0) === '?');
+ elementSelector = optional ? elementSelector.substring(1) : elementSelector;
+
+ slotMap[elementSelector] = slotName;
+
+ // We explicitly assign `null` since this implies that a slot was defined but not filled.
+ // Later when calling boundTransclusion functions with a slot name we only error if the
+ // slot is `undefined`
+ slots[slotName] = null;
+
+ // filledSlots contains `true` for all slots that are either optional or have been
+ // filled. This is used to check that we have not missed any required slots
+ filledSlots[slotName] = optional;
+ });
+
+ // Add the matching elements into their slot
+ forEach($compileNode.contents(), function(node) {
+ var slotName = slotMap[directiveNormalize(nodeName_(node))];
+ if (slotName) {
+ filledSlots[slotName] = true;
+ slots[slotName] = slots[slotName] || window.document.createDocumentFragment();
+ slots[slotName].appendChild(node);
+ } else {
+ $template.appendChild(node);
+ }
+ });
+
+ // Check for required slots that were not filled
+ forEach(filledSlots, function(filled, slotName) {
+ if (!filled) {
+ throw $compileMinErr('reqslot', 'Required transclusion slot `{0}` was not filled.', slotName);
+ }
+ });
+
+ for (var slotName in slots) {
+ if (slots[slotName]) {
+ // Only define a transclusion function if the slot was filled
+ var slotCompileNodes = jqLite(slots[slotName].childNodes);
+ slots[slotName] = compilationGenerator(mightHaveMultipleTransclusionError, slotCompileNodes, transcludeFn);
+ }
+ }
+
+ $template = jqLite($template.childNodes);
+ }
+
+ $compileNode.empty(); // clear contents
+ childTranscludeFn = compilationGenerator(mightHaveMultipleTransclusionError, $template, transcludeFn, undefined,
+ undefined, { needsNewScope: directive.$$isolateScope || directive.$$newScope});
+ childTranscludeFn.$$slots = slots;
+ }
+ }
+
+ if (directive.template) {
+ hasTemplate = true;
+ assertNoDuplicate('template', templateDirective, directive, $compileNode);
+ templateDirective = directive;
+
+ directiveValue = (isFunction(directive.template))
+ ? directive.template($compileNode, templateAttrs)
+ : directive.template;
+
+ directiveValue = denormalizeTemplate(directiveValue);
+
+ if (directive.replace) {
+ replaceDirective = directive;
+ if (jqLiteIsTextNode(directiveValue)) {
+ $template = [];
+ } else {
+ $template = removeComments(wrapTemplate(directive.templateNamespace, trim(directiveValue)));
+ }
+ compileNode = $template[0];
+
+ if ($template.length !== 1 || compileNode.nodeType !== NODE_TYPE_ELEMENT) {
+ throw $compileMinErr('tplrt',
+ 'Template for directive \'{0}\' must have exactly one root element. {1}',
+ directiveName, '');
+ }
+
+ replaceWith(jqCollection, $compileNode, compileNode);
+
+ var newTemplateAttrs = {$attr: {}};
+
+ // combine directives from the original node and from the template:
+ // - take the array of directives for this element
+ // - split it into two parts, those that already applied (processed) and those that weren't (unprocessed)
+ // - collect directives from the template and sort them by priority
+ // - combine directives as: processed + template + unprocessed
+ var templateDirectives = collectDirectives(compileNode, [], newTemplateAttrs);
+ var unprocessedDirectives = directives.splice(i + 1, directives.length - (i + 1));
+
+ if (newIsolateScopeDirective || newScopeDirective) {
+ // The original directive caused the current element to be replaced but this element
+ // also needs to have a new scope, so we need to tell the template directives
+ // that they would need to get their scope from further up, if they require transclusion
+ markDirectiveScope(templateDirectives, newIsolateScopeDirective, newScopeDirective);
+ }
+ directives = directives.concat(templateDirectives).concat(unprocessedDirectives);
+ mergeTemplateAttributes(templateAttrs, newTemplateAttrs);
+
+ ii = directives.length;
+ } else {
+ $compileNode.html(directiveValue);
+ }
+ }
+
+ if (directive.templateUrl) {
+ hasTemplate = true;
+ assertNoDuplicate('template', templateDirective, directive, $compileNode);
+ templateDirective = directive;
+
+ if (directive.replace) {
+ replaceDirective = directive;
+ }
+
+ // eslint-disable-next-line no-func-assign
+ nodeLinkFn = compileTemplateUrl(directives.splice(i, directives.length - i), $compileNode,
+ templateAttrs, jqCollection, hasTranscludeDirective && childTranscludeFn, preLinkFns, postLinkFns, {
+ controllerDirectives: controllerDirectives,
+ newScopeDirective: (newScopeDirective !== directive) && newScopeDirective,
+ newIsolateScopeDirective: newIsolateScopeDirective,
+ templateDirective: templateDirective,
+ nonTlbTranscludeDirective: nonTlbTranscludeDirective
+ });
+ ii = directives.length;
+ } else if (directive.compile) {
+ try {
+ linkFn = directive.compile($compileNode, templateAttrs, childTranscludeFn);
+ var context = directive.$$originalDirective || directive;
+ if (isFunction(linkFn)) {
+ addLinkFns(null, bind(context, linkFn), attrStart, attrEnd);
+ } else if (linkFn) {
+ addLinkFns(bind(context, linkFn.pre), bind(context, linkFn.post), attrStart, attrEnd);
+ }
+ } catch (e) {
+ $exceptionHandler(e, startingTag($compileNode));
+ }
+ }
+
+ if (directive.terminal) {
+ nodeLinkFn.terminal = true;
+ terminalPriority = Math.max(terminalPriority, directive.priority);
+ }
+
+ }
+
+ nodeLinkFn.scope = newScopeDirective && newScopeDirective.scope === true;
+ nodeLinkFn.transcludeOnThisElement = hasTranscludeDirective;
+ nodeLinkFn.templateOnThisElement = hasTemplate;
+ nodeLinkFn.transclude = childTranscludeFn;
+
+ previousCompileContext.hasElementTranscludeDirective = hasElementTranscludeDirective;
+
+ // might be normal or delayed nodeLinkFn depending on if templateUrl is present
+ return nodeLinkFn;
+
+ ////////////////////
+
+ function addLinkFns(pre, post, attrStart, attrEnd) {
+ if (pre) {
+ if (attrStart) pre = groupElementsLinkFnWrapper(pre, attrStart, attrEnd);
+ pre.require = directive.require;
+ pre.directiveName = directiveName;
+ if (newIsolateScopeDirective === directive || directive.$$isolateScope) {
+ pre = cloneAndAnnotateFn(pre, {isolateScope: true});
+ }
+ preLinkFns.push(pre);
+ }
+ if (post) {
+ if (attrStart) post = groupElementsLinkFnWrapper(post, attrStart, attrEnd);
+ post.require = directive.require;
+ post.directiveName = directiveName;
+ if (newIsolateScopeDirective === directive || directive.$$isolateScope) {
+ post = cloneAndAnnotateFn(post, {isolateScope: true});
+ }
+ postLinkFns.push(post);
+ }
+ }
+
+ function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn) {
+ var i, ii, linkFn, isolateScope, controllerScope, elementControllers, transcludeFn, $element,
+ attrs, scopeBindingInfo;
+
+ if (compileNode === linkNode) {
+ attrs = templateAttrs;
+ $element = templateAttrs.$$element;
+ } else {
+ $element = jqLite(linkNode);
+ attrs = new Attributes($element, templateAttrs);
+ }
+
+ controllerScope = scope;
+ if (newIsolateScopeDirective) {
+ isolateScope = scope.$new(true);
+ } else if (newScopeDirective) {
+ controllerScope = scope.$parent;
+ }
+
+ if (boundTranscludeFn) {
+ // track `boundTranscludeFn` so it can be unwrapped if `transcludeFn`
+ // is later passed as `parentBoundTranscludeFn` to `publicLinkFn`
+ transcludeFn = controllersBoundTransclude;
+ transcludeFn.$$boundTransclude = boundTranscludeFn;
+ // expose the slots on the `$transclude` function
+ transcludeFn.isSlotFilled = function(slotName) {
+ return !!boundTranscludeFn.$$slots[slotName];
+ };
+ }
+
+ if (controllerDirectives) {
+ elementControllers = setupControllers($element, attrs, transcludeFn, controllerDirectives, isolateScope, scope, newIsolateScopeDirective);
+ }
+
+ if (newIsolateScopeDirective) {
+ // Initialize isolate scope bindings for new isolate scope directive.
+ compile.$$addScopeInfo($element, isolateScope, true, !(templateDirective && (templateDirective === newIsolateScopeDirective ||
+ templateDirective === newIsolateScopeDirective.$$originalDirective)));
+ compile.$$addScopeClass($element, true);
+ isolateScope.$$isolateBindings =
+ newIsolateScopeDirective.$$isolateBindings;
+ scopeBindingInfo = initializeDirectiveBindings(scope, attrs, isolateScope,
+ isolateScope.$$isolateBindings,
+ newIsolateScopeDirective);
+ if (scopeBindingInfo.removeWatches) {
+ isolateScope.$on('$destroy', scopeBindingInfo.removeWatches);
+ }
+ }
+
+ // Initialize bindToController bindings
+ for (var name in elementControllers) {
+ var controllerDirective = controllerDirectives[name];
+ var controller = elementControllers[name];
+ var bindings = controllerDirective.$$bindings.bindToController;
+
+ controller.instance = controller();
+ $element.data('$' + controllerDirective.name + 'Controller', controller.instance);
+ controller.bindingInfo =
+ initializeDirectiveBindings(controllerScope, attrs, controller.instance, bindings, controllerDirective);
+ }
+
+ // Bind the required controllers to the controller, if `require` is an object and `bindToController` is truthy
+ forEach(controllerDirectives, function(controllerDirective, name) {
+ var require = controllerDirective.require;
+ if (controllerDirective.bindToController && !isArray(require) && isObject(require)) {
+ extend(elementControllers[name].instance, getControllers(name, require, $element, elementControllers));
+ }
+ });
+
+ // Handle the init and destroy lifecycle hooks on all controllers that have them
+ forEach(elementControllers, function(controller) {
+ var controllerInstance = controller.instance;
+ if (isFunction(controllerInstance.$onChanges)) {
+ try {
+ controllerInstance.$onChanges(controller.bindingInfo.initialChanges);
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ }
+ if (isFunction(controllerInstance.$onInit)) {
+ try {
+ controllerInstance.$onInit();
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ }
+ if (isFunction(controllerInstance.$doCheck)) {
+ controllerScope.$watch(function() { controllerInstance.$doCheck(); });
+ controllerInstance.$doCheck();
+ }
+ if (isFunction(controllerInstance.$onDestroy)) {
+ controllerScope.$on('$destroy', function callOnDestroyHook() {
+ controllerInstance.$onDestroy();
+ });
+ }
+ });
+
+ // PRELINKING
+ for (i = 0, ii = preLinkFns.length; i < ii; i++) {
+ linkFn = preLinkFns[i];
+ invokeLinkFn(linkFn,
+ linkFn.isolateScope ? isolateScope : scope,
+ $element,
+ attrs,
+ linkFn.require && getControllers(linkFn.directiveName, linkFn.require, $element, elementControllers),
+ transcludeFn
+ );
+ }
+
+ // RECURSION
+ // We only pass the isolate scope, if the isolate directive has a template,
+ // otherwise the child elements do not belong to the isolate directive.
+ var scopeToChild = scope;
+ if (newIsolateScopeDirective && (newIsolateScopeDirective.template || newIsolateScopeDirective.templateUrl === null)) {
+ scopeToChild = isolateScope;
+ }
+ if (childLinkFn) {
+ childLinkFn(scopeToChild, linkNode.childNodes, undefined, boundTranscludeFn);
+ }
+
+ // POSTLINKING
+ for (i = postLinkFns.length - 1; i >= 0; i--) {
+ linkFn = postLinkFns[i];
+ invokeLinkFn(linkFn,
+ linkFn.isolateScope ? isolateScope : scope,
+ $element,
+ attrs,
+ linkFn.require && getControllers(linkFn.directiveName, linkFn.require, $element, elementControllers),
+ transcludeFn
+ );
+ }
+
+ // Trigger $postLink lifecycle hooks
+ forEach(elementControllers, function(controller) {
+ var controllerInstance = controller.instance;
+ if (isFunction(controllerInstance.$postLink)) {
+ controllerInstance.$postLink();
+ }
+ });
+
+ // This is the function that is injected as `$transclude`.
+ // Note: all arguments are optional!
+ function controllersBoundTransclude(scope, cloneAttachFn, futureParentElement, slotName) {
+ var transcludeControllers;
+ // No scope passed in:
+ if (!isScope(scope)) {
+ slotName = futureParentElement;
+ futureParentElement = cloneAttachFn;
+ cloneAttachFn = scope;
+ scope = undefined;
+ }
+
+ if (hasElementTranscludeDirective) {
+ transcludeControllers = elementControllers;
+ }
+ if (!futureParentElement) {
+ futureParentElement = hasElementTranscludeDirective ? $element.parent() : $element;
+ }
+ if (slotName) {
+ // slotTranscludeFn can be one of three things:
+ // * a transclude function - a filled slot
+ // * `null` - an optional slot that was not filled
+ // * `undefined` - a slot that was not declared (i.e. invalid)
+ var slotTranscludeFn = boundTranscludeFn.$$slots[slotName];
+ if (slotTranscludeFn) {
+ return slotTranscludeFn(scope, cloneAttachFn, transcludeControllers, futureParentElement, scopeToChild);
+ } else if (isUndefined(slotTranscludeFn)) {
+ throw $compileMinErr('noslot',
+ 'No parent directive that requires a transclusion with slot name "{0}". ' +
+ 'Element: {1}',
+ slotName, startingTag($element));
+ }
+ } else {
+ return boundTranscludeFn(scope, cloneAttachFn, transcludeControllers, futureParentElement, scopeToChild);
+ }
+ }
+ }
+ }
+
+ function getControllers(directiveName, require, $element, elementControllers) {
+ var value;
+
+ if (isString(require)) {
+ var match = require.match(REQUIRE_PREFIX_REGEXP);
+ var name = require.substring(match[0].length);
+ var inheritType = match[1] || match[3];
+ var optional = match[2] === '?';
+
+ //If only parents then start at the parent element
+ if (inheritType === '^^') {
+ $element = $element.parent();
+ //Otherwise attempt getting the controller from elementControllers in case
+ //the element is transcluded (and has no data) and to avoid .data if possible
+ } else {
+ value = elementControllers && elementControllers[name];
+ value = value && value.instance;
+ }
+
+ if (!value) {
+ var dataName = '$' + name + 'Controller';
+
+ if (inheritType === '^^' && $element[0] && $element[0].nodeType === NODE_TYPE_DOCUMENT) {
+ // inheritedData() uses the documentElement when it finds the document, so we would
+ // require from the element itself.
+ value = null;
+ } else {
+ value = inheritType ? $element.inheritedData(dataName) : $element.data(dataName);
+ }
+ }
+
+ if (!value && !optional) {
+ throw $compileMinErr('ctreq',
+ 'Controller \'{0}\', required by directive \'{1}\', can\'t be found!',
+ name, directiveName);
+ }
+ } else if (isArray(require)) {
+ value = [];
+ for (var i = 0, ii = require.length; i < ii; i++) {
+ value[i] = getControllers(directiveName, require[i], $element, elementControllers);
+ }
+ } else if (isObject(require)) {
+ value = {};
+ forEach(require, function(controller, property) {
+ value[property] = getControllers(directiveName, controller, $element, elementControllers);
+ });
+ }
+
+ return value || null;
+ }
+
+ function setupControllers($element, attrs, transcludeFn, controllerDirectives, isolateScope, scope, newIsolateScopeDirective) {
+ var elementControllers = createMap();
+ for (var controllerKey in controllerDirectives) {
+ var directive = controllerDirectives[controllerKey];
+ var locals = {
+ $scope: directive === newIsolateScopeDirective || directive.$$isolateScope ? isolateScope : scope,
+ $element: $element,
+ $attrs: attrs,
+ $transclude: transcludeFn
+ };
+
+ var controller = directive.controller;
+ if (controller === '@') {
+ controller = attrs[directive.name];
+ }
+
+ var controllerInstance = $controller(controller, locals, true, directive.controllerAs);
+
+ // For directives with element transclusion the element is a comment.
+ // In this case .data will not attach any data.
+ // Instead, we save the controllers for the element in a local hash and attach to .data
+ // later, once we have the actual element.
+ elementControllers[directive.name] = controllerInstance;
+ $element.data('$' + directive.name + 'Controller', controllerInstance.instance);
+ }
+ return elementControllers;
+ }
+
+ // Depending upon the context in which a directive finds itself it might need to have a new isolated
+ // or child scope created. For instance:
+ // * if the directive has been pulled into a template because another directive with a higher priority
+ // asked for element transclusion
+ // * if the directive itself asks for transclusion but it is at the root of a template and the original
+ // element was replaced. See https://github.com/angular/angular.js/issues/12936
+ function markDirectiveScope(directives, isolateScope, newScope) {
+ for (var j = 0, jj = directives.length; j < jj; j++) {
+ directives[j] = inherit(directives[j], {$$isolateScope: isolateScope, $$newScope: newScope});
+ }
+ }
+
+ /**
+ * looks up the directive and decorates it with exception handling and proper parameters. We
+ * call this the boundDirective.
+ *
+ * @param {string} name name of the directive to look up.
+ * @param {string} location The directive must be found in specific format.
+ * String containing any of theses characters:
+ *
+ * * `E`: element name
+ * * `A': attribute
+ * * `C`: class
+ * * `M`: comment
+ * @returns {boolean} true if directive was added.
+ */
+ function addDirective(tDirectives, name, location, maxPriority, ignoreDirective, startAttrName,
+ endAttrName) {
+ if (name === ignoreDirective) return null;
+ var match = null;
+ if (hasDirectives.hasOwnProperty(name)) {
+ for (var directive, directives = $injector.get(name + Suffix),
+ i = 0, ii = directives.length; i < ii; i++) {
+ directive = directives[i];
+ if ((isUndefined(maxPriority) || maxPriority > directive.priority) &&
+ directive.restrict.indexOf(location) !== -1) {
+ if (startAttrName) {
+ directive = inherit(directive, {$$start: startAttrName, $$end: endAttrName});
+ }
+ if (!directive.$$bindings) {
+ var bindings = directive.$$bindings =
+ parseDirectiveBindings(directive, directive.name);
+ if (isObject(bindings.isolateScope)) {
+ directive.$$isolateBindings = bindings.isolateScope;
+ }
+ }
+ tDirectives.push(directive);
+ match = directive;
+ }
+ }
+ }
+ return match;
+ }
+
+
+ /**
+ * looks up the directive and returns true if it is a multi-element directive,
+ * and therefore requires DOM nodes between -start and -end markers to be grouped
+ * together.
+ *
+ * @param {string} name name of the directive to look up.
+ * @returns true if directive was registered as multi-element.
+ */
+ function directiveIsMultiElement(name) {
+ if (hasDirectives.hasOwnProperty(name)) {
+ for (var directive, directives = $injector.get(name + Suffix),
+ i = 0, ii = directives.length; i < ii; i++) {
+ directive = directives[i];
+ if (directive.multiElement) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * When the element is replaced with HTML template then the new attributes
+ * on the template need to be merged with the existing attributes in the DOM.
+ * The desired effect is to have both of the attributes present.
+ *
+ * @param {object} dst destination attributes (original DOM)
+ * @param {object} src source attributes (from the directive template)
+ */
+ function mergeTemplateAttributes(dst, src) {
+ var srcAttr = src.$attr,
+ dstAttr = dst.$attr;
+
+ // reapply the old attributes to the new element
+ forEach(dst, function(value, key) {
+ if (key.charAt(0) !== '$') {
+ if (src[key] && src[key] !== value) {
+ if (value.length) {
+ value += (key === 'style' ? ';' : ' ') + src[key];
+ } else {
+ value = src[key];
+ }
+ }
+ dst.$set(key, value, true, srcAttr[key]);
+ }
+ });
+
+ // copy the new attributes on the old attrs object
+ forEach(src, function(value, key) {
+ // Check if we already set this attribute in the loop above.
+ // `dst` will never contain hasOwnProperty as DOM parser won't let it.
+ // You will get an "InvalidCharacterError: DOM Exception 5" error if you
+ // have an attribute like "has-own-property" or "data-has-own-property", etc.
+ if (!dst.hasOwnProperty(key) && key.charAt(0) !== '$') {
+ dst[key] = value;
+
+ if (key !== 'class' && key !== 'style') {
+ dstAttr[key] = srcAttr[key];
+ }
+ }
+ });
+ }
+
+
+ function compileTemplateUrl(directives, $compileNode, tAttrs,
+ $rootElement, childTranscludeFn, preLinkFns, postLinkFns, previousCompileContext) {
+ var linkQueue = [],
+ afterTemplateNodeLinkFn,
+ afterTemplateChildLinkFn,
+ beforeTemplateCompileNode = $compileNode[0],
+ origAsyncDirective = directives.shift(),
+ derivedSyncDirective = inherit(origAsyncDirective, {
+ templateUrl: null, transclude: null, replace: null, $$originalDirective: origAsyncDirective
+ }),
+ templateUrl = (isFunction(origAsyncDirective.templateUrl))
+ ? origAsyncDirective.templateUrl($compileNode, tAttrs)
+ : origAsyncDirective.templateUrl,
+ templateNamespace = origAsyncDirective.templateNamespace;
+
+ $compileNode.empty();
+
+ $templateRequest(templateUrl)
+ .then(function(content) {
+ var compileNode, tempTemplateAttrs, $template, childBoundTranscludeFn;
+
+ content = denormalizeTemplate(content);
+
+ if (origAsyncDirective.replace) {
+ if (jqLiteIsTextNode(content)) {
+ $template = [];
+ } else {
+ $template = removeComments(wrapTemplate(templateNamespace, trim(content)));
+ }
+ compileNode = $template[0];
+
+ if ($template.length !== 1 || compileNode.nodeType !== NODE_TYPE_ELEMENT) {
+ throw $compileMinErr('tplrt',
+ 'Template for directive \'{0}\' must have exactly one root element. {1}',
+ origAsyncDirective.name, templateUrl);
+ }
+
+ tempTemplateAttrs = {$attr: {}};
+ replaceWith($rootElement, $compileNode, compileNode);
+ var templateDirectives = collectDirectives(compileNode, [], tempTemplateAttrs);
+
+ if (isObject(origAsyncDirective.scope)) {
+ // the original directive that caused the template to be loaded async required
+ // an isolate scope
+ markDirectiveScope(templateDirectives, true);
+ }
+ directives = templateDirectives.concat(directives);
+ mergeTemplateAttributes(tAttrs, tempTemplateAttrs);
+ } else {
+ compileNode = beforeTemplateCompileNode;
+ $compileNode.html(content);
+ }
+
+ directives.unshift(derivedSyncDirective);
+
+ afterTemplateNodeLinkFn = applyDirectivesToNode(directives, compileNode, tAttrs,
+ childTranscludeFn, $compileNode, origAsyncDirective, preLinkFns, postLinkFns,
+ previousCompileContext);
+ forEach($rootElement, function(node, i) {
+ if (node === compileNode) {
+ $rootElement[i] = $compileNode[0];
+ }
+ });
+ afterTemplateChildLinkFn = compileNodes($compileNode[0].childNodes, childTranscludeFn);
+
+ while (linkQueue.length) {
+ var scope = linkQueue.shift(),
+ beforeTemplateLinkNode = linkQueue.shift(),
+ linkRootElement = linkQueue.shift(),
+ boundTranscludeFn = linkQueue.shift(),
+ linkNode = $compileNode[0];
+
+ if (scope.$$destroyed) continue;
+
+ if (beforeTemplateLinkNode !== beforeTemplateCompileNode) {
+ var oldClasses = beforeTemplateLinkNode.className;
+
+ if (!(previousCompileContext.hasElementTranscludeDirective &&
+ origAsyncDirective.replace)) {
+ // it was cloned therefore we have to clone as well.
+ linkNode = jqLiteClone(compileNode);
+ }
+ replaceWith(linkRootElement, jqLite(beforeTemplateLinkNode), linkNode);
+
+ // Copy in CSS classes from original node
+ safeAddClass(jqLite(linkNode), oldClasses);
+ }
+ if (afterTemplateNodeLinkFn.transcludeOnThisElement) {
+ childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude, boundTranscludeFn);
+ } else {
+ childBoundTranscludeFn = boundTranscludeFn;
+ }
+ afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, linkNode, $rootElement,
+ childBoundTranscludeFn);
+ }
+ linkQueue = null;
+ }).catch(function(error) {
+ if (isError(error)) {
+ $exceptionHandler(error);
+ }
+ });
+
+ return function delayedNodeLinkFn(ignoreChildLinkFn, scope, node, rootElement, boundTranscludeFn) {
+ var childBoundTranscludeFn = boundTranscludeFn;
+ if (scope.$$destroyed) return;
+ if (linkQueue) {
+ linkQueue.push(scope,
+ node,
+ rootElement,
+ childBoundTranscludeFn);
+ } else {
+ if (afterTemplateNodeLinkFn.transcludeOnThisElement) {
+ childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude, boundTranscludeFn);
+ }
+ afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, node, rootElement, childBoundTranscludeFn);
+ }
+ };
+ }
+
+
+ /**
+ * Sorting function for bound directives.
+ */
+ function byPriority(a, b) {
+ var diff = b.priority - a.priority;
+ if (diff !== 0) return diff;
+ if (a.name !== b.name) return (a.name < b.name) ? -1 : 1;
+ return a.index - b.index;
+ }
+
+ function assertNoDuplicate(what, previousDirective, directive, element) {
+
+ function wrapModuleNameIfDefined(moduleName) {
+ return moduleName ?
+ (' (module: ' + moduleName + ')') :
+ '';
+ }
+
+ if (previousDirective) {
+ throw $compileMinErr('multidir', 'Multiple directives [{0}{1}, {2}{3}] asking for {4} on: {5}',
+ previousDirective.name, wrapModuleNameIfDefined(previousDirective.$$moduleName),
+ directive.name, wrapModuleNameIfDefined(directive.$$moduleName), what, startingTag(element));
+ }
+ }
+
+
+ function addTextInterpolateDirective(directives, text) {
+ var interpolateFn = $interpolate(text, true);
+ if (interpolateFn) {
+ directives.push({
+ priority: 0,
+ compile: function textInterpolateCompileFn(templateNode) {
+ var templateNodeParent = templateNode.parent(),
+ hasCompileParent = !!templateNodeParent.length;
+
+ // When transcluding a template that has bindings in the root
+ // we don't have a parent and thus need to add the class during linking fn.
+ if (hasCompileParent) compile.$$addBindingClass(templateNodeParent);
+
+ return function textInterpolateLinkFn(scope, node) {
+ var parent = node.parent();
+ if (!hasCompileParent) compile.$$addBindingClass(parent);
+ compile.$$addBindingInfo(parent, interpolateFn.expressions);
+ scope.$watch(interpolateFn, function interpolateFnWatchAction(value) {
+ node[0].nodeValue = value;
+ });
+ };
+ }
+ });
+ }
+ }
+
+
+ function wrapTemplate(type, template) {
+ type = lowercase(type || 'html');
+ switch (type) {
+ case 'svg':
+ case 'math':
+ var wrapper = window.document.createElement('div');
+ wrapper.innerHTML = '<' + type + '>' + template + '</' + type + '>';
+ return wrapper.childNodes[0].childNodes;
+ default:
+ return template;
+ }
+ }
+
+
+ function getTrustedAttrContext(nodeName, attrNormalizedName) {
+ if (attrNormalizedName === 'srcdoc') {
+ return $sce.HTML;
+ }
+ // All nodes with src attributes require a RESOURCE_URL value, except for
+ // img and various html5 media nodes, which require the MEDIA_URL context.
+ if (attrNormalizedName === 'src' || attrNormalizedName === 'ngSrc') {
+ if (['img', 'video', 'audio', 'source', 'track'].indexOf(nodeName) === -1) {
+ return $sce.RESOURCE_URL;
+ }
+ return $sce.MEDIA_URL;
+ } else if (attrNormalizedName === 'xlinkHref') {
+ // Some xlink:href are okay, most aren't
+ if (nodeName === 'image') return $sce.MEDIA_URL;
+ if (nodeName === 'a') return $sce.URL;
+ return $sce.RESOURCE_URL;
+ } else if (
+ // Formaction
+ (nodeName === 'form' && attrNormalizedName === 'action') ||
+ // If relative URLs can go where they are not expected to, then
+ // all sorts of trust issues can arise.
+ (nodeName === 'base' && attrNormalizedName === 'href') ||
+ // links can be stylesheets or imports, which can run script in the current origin
+ (nodeName === 'link' && attrNormalizedName === 'href')
+ ) {
+ return $sce.RESOURCE_URL;
+ } else if (nodeName === 'a' && (attrNormalizedName === 'href' ||
+ attrNormalizedName === 'ngHref')) {
+ return $sce.URL;
+ }
+ }
+
+ function getTrustedPropContext(nodeName, propNormalizedName) {
+ var prop = propNormalizedName.toLowerCase();
+ return PROP_CONTEXTS[nodeName + '|' + prop] || PROP_CONTEXTS['*|' + prop];
+ }
+
+ function sanitizeSrcsetPropertyValue(value) {
+ return sanitizeSrcset($sce.valueOf(value), 'ng-prop-srcset');
+ }
+ function addPropertyDirective(node, directives, attrName, propName) {
+ if (EVENT_HANDLER_ATTR_REGEXP.test(propName)) {
+ throw $compileMinErr('nodomevents', 'Property bindings for HTML DOM event properties are disallowed');
+ }
+
+ var nodeName = nodeName_(node);
+ var trustedContext = getTrustedPropContext(nodeName, propName);
+
+ var sanitizer = identity;
+ // Sanitize img[srcset] + source[srcset] values.
+ if (propName === 'srcset' && (nodeName === 'img' || nodeName === 'source')) {
+ sanitizer = sanitizeSrcsetPropertyValue;
+ } else if (trustedContext) {
+ sanitizer = $sce.getTrusted.bind($sce, trustedContext);
+ }
+
+ directives.push({
+ priority: 100,
+ compile: function ngPropCompileFn(_, attr) {
+ var ngPropGetter = $parse(attr[attrName]);
+ var ngPropWatch = $parse(attr[attrName], function sceValueOf(val) {
+ // Unwrap the value to compare the actual inner safe value, not the wrapper object.
+ return $sce.valueOf(val);
+ });
+
+ return {
+ pre: function ngPropPreLinkFn(scope, $element) {
+ function applyPropValue() {
+ var propValue = ngPropGetter(scope);
+ $element[0][propName] = sanitizer(propValue);
+ }
+
+ applyPropValue();
+ scope.$watch(ngPropWatch, applyPropValue);
+ }
+ };
+ }
+ });
+ }
+
+ function addEventDirective(directives, attrName, eventName) {
+ directives.push(
+ createEventDirective($parse, $rootScope, $exceptionHandler, attrName, eventName, /*forceAsync=*/false)
+ );
+ }
+
+ function addAttrInterpolateDirective(node, directives, value, name, isNgAttr) {
+ var nodeName = nodeName_(node);
+ var trustedContext = getTrustedAttrContext(nodeName, name);
+ var mustHaveExpression = !isNgAttr;
+ var allOrNothing = ALL_OR_NOTHING_ATTRS[name] || isNgAttr;
+
+ var interpolateFn = $interpolate(value, mustHaveExpression, trustedContext, allOrNothing);
+
+ // no interpolation found -> ignore
+ if (!interpolateFn) return;
+
+ if (name === 'multiple' && nodeName === 'select') {
+ throw $compileMinErr('selmulti',
+ 'Binding to the \'multiple\' attribute is not supported. Element: {0}',
+ startingTag(node));
+ }
+
+ if (EVENT_HANDLER_ATTR_REGEXP.test(name)) {
+ throw $compileMinErr('nodomevents', 'Interpolations for HTML DOM event attributes are disallowed');
+ }
+
+ directives.push({
+ priority: 100,
+ compile: function() {
+ return {
+ pre: function attrInterpolatePreLinkFn(scope, element, attr) {
+ var $$observers = (attr.$$observers || (attr.$$observers = createMap()));
+
+ // If the attribute has changed since last $interpolate()ed
+ var newValue = attr[name];
+ if (newValue !== value) {
+ // we need to interpolate again since the attribute value has been updated
+ // (e.g. by another directive's compile function)
+ // ensure unset/empty values make interpolateFn falsy
+ interpolateFn = newValue && $interpolate(newValue, true, trustedContext, allOrNothing);
+ value = newValue;
+ }
+
+ // if attribute was updated so that there is no interpolation going on we don't want to
+ // register any observers
+ if (!interpolateFn) return;
+
+ // initialize attr object so that it's ready in case we need the value for isolate
+ // scope initialization, otherwise the value would not be available from isolate
+ // directive's linking fn during linking phase
+ attr[name] = interpolateFn(scope);
+
+ ($$observers[name] || ($$observers[name] = [])).$$inter = true;
+ (attr.$$observers && attr.$$observers[name].$$scope || scope).
+ $watch(interpolateFn, function interpolateFnWatchAction(newValue, oldValue) {
+ //special case for class attribute addition + removal
+ //so that class changes can tap into the animation
+ //hooks provided by the $animate service. Be sure to
+ //skip animations when the first digest occurs (when
+ //both the new and the old values are the same) since
+ //the CSS classes are the non-interpolated values
+ if (name === 'class' && newValue !== oldValue) {
+ attr.$updateClass(newValue, oldValue);
+ } else {
+ attr.$set(name, newValue);
+ }
+ });
+ }
+ };
+ }
+ });
+ }
+
+
+ /**
+ * This is a special jqLite.replaceWith, which can replace items which
+ * have no parents, provided that the containing jqLite collection is provided.
+ *
+ * @param {JqLite=} $rootElement The root of the compile tree. Used so that we can replace nodes
+ * in the root of the tree.
+ * @param {JqLite} elementsToRemove The jqLite element which we are going to replace. We keep
+ * the shell, but replace its DOM node reference.
+ * @param {Node} newNode The new DOM node.
+ */
+ function replaceWith($rootElement, elementsToRemove, newNode) {
+ var firstElementToRemove = elementsToRemove[0],
+ removeCount = elementsToRemove.length,
+ parent = firstElementToRemove.parentNode,
+ i, ii;
+
+ if ($rootElement) {
+ for (i = 0, ii = $rootElement.length; i < ii; i++) {
+ if ($rootElement[i] === firstElementToRemove) {
+ $rootElement[i++] = newNode;
+ for (var j = i, j2 = j + removeCount - 1,
+ jj = $rootElement.length;
+ j < jj; j++, j2++) {
+ if (j2 < jj) {
+ $rootElement[j] = $rootElement[j2];
+ } else {
+ delete $rootElement[j];
+ }
+ }
+ $rootElement.length -= removeCount - 1;
+
+ // If the replaced element is also the jQuery .context then replace it
+ // .context is a deprecated jQuery api, so we should set it only when jQuery set it
+ // http://api.jquery.com/context/
+ if ($rootElement.context === firstElementToRemove) {
+ $rootElement.context = newNode;
+ }
+ break;
+ }
+ }
+ }
+
+ if (parent) {
+ parent.replaceChild(newNode, firstElementToRemove);
+ }
+
+ // Append all the `elementsToRemove` to a fragment. This will...
+ // - remove them from the DOM
+ // - allow them to still be traversed with .nextSibling
+ // - allow a single fragment.qSA to fetch all elements being removed
+ var fragment = window.document.createDocumentFragment();
+ for (i = 0; i < removeCount; i++) {
+ fragment.appendChild(elementsToRemove[i]);
+ }
+
+ if (jqLite.hasData(firstElementToRemove)) {
+ // Copy over user data (that includes AngularJS's $scope etc.). Don't copy private
+ // data here because there's no public interface in jQuery to do that and copying over
+ // event listeners (which is the main use of private data) wouldn't work anyway.
+ jqLite.data(newNode, jqLite.data(firstElementToRemove));
+
+ // Remove $destroy event listeners from `firstElementToRemove`
+ jqLite(firstElementToRemove).off('$destroy');
+ }
+
+ // Cleanup any data/listeners on the elements and children.
+ // This includes invoking the $destroy event on any elements with listeners.
+ jqLite.cleanData(fragment.querySelectorAll('*'));
+
+ // Update the jqLite collection to only contain the `newNode`
+ for (i = 1; i < removeCount; i++) {
+ delete elementsToRemove[i];
+ }
+ elementsToRemove[0] = newNode;
+ elementsToRemove.length = 1;
+ }
+
+
+ function cloneAndAnnotateFn(fn, annotation) {
+ return extend(function() { return fn.apply(null, arguments); }, fn, annotation);
+ }
+
+
+ function invokeLinkFn(linkFn, scope, $element, attrs, controllers, transcludeFn) {
+ try {
+ linkFn(scope, $element, attrs, controllers, transcludeFn);
+ } catch (e) {
+ $exceptionHandler(e, startingTag($element));
+ }
+ }
+
+ function strictBindingsCheck(attrName, directiveName) {
+ if (strictComponentBindingsEnabled) {
+ throw $compileMinErr('missingattr',
+ 'Attribute \'{0}\' of \'{1}\' is non-optional and must be set!',
+ attrName, directiveName);
+ }
+ }
+
+ // Set up $watches for isolate scope and controller bindings.
+ function initializeDirectiveBindings(scope, attrs, destination, bindings, directive) {
+ var removeWatchCollection = [];
+ var initialChanges = {};
+ var changes;
+
+ forEach(bindings, function initializeBinding(definition, scopeName) {
+ var attrName = definition.attrName,
+ optional = definition.optional,
+ mode = definition.mode, // @, =, <, or &
+ lastValue,
+ parentGet, parentSet, compare, removeWatch;
+
+ switch (mode) {
+
+ case '@':
+ if (!optional && !hasOwnProperty.call(attrs, attrName)) {
+ strictBindingsCheck(attrName, directive.name);
+ destination[scopeName] = attrs[attrName] = undefined;
+
+ }
+ removeWatch = attrs.$observe(attrName, function(value) {
+ if (isString(value) || isBoolean(value)) {
+ var oldValue = destination[scopeName];
+ recordChanges(scopeName, value, oldValue);
+ destination[scopeName] = value;
+ }
+ });
+ attrs.$$observers[attrName].$$scope = scope;
+ lastValue = attrs[attrName];
+ if (isString(lastValue)) {
+ // If the attribute has been provided then we trigger an interpolation to ensure
+ // the value is there for use in the link fn
+ destination[scopeName] = $interpolate(lastValue)(scope);
+ } else if (isBoolean(lastValue)) {
+ // If the attributes is one of the BOOLEAN_ATTR then AngularJS will have converted
+ // the value to boolean rather than a string, so we special case this situation
+ destination[scopeName] = lastValue;
+ }
+ initialChanges[scopeName] = new SimpleChange(_UNINITIALIZED_VALUE, destination[scopeName]);
+ removeWatchCollection.push(removeWatch);
+ break;
+
+ case '=':
+ if (!hasOwnProperty.call(attrs, attrName)) {
+ if (optional) break;
+ strictBindingsCheck(attrName, directive.name);
+ attrs[attrName] = undefined;
+ }
+ if (optional && !attrs[attrName]) break;
+
+ parentGet = $parse(attrs[attrName]);
+ if (parentGet.literal) {
+ compare = equals;
+ } else {
+ compare = simpleCompare;
+ }
+ parentSet = parentGet.assign || function() {
+ // reset the change, or we will throw this exception on every $digest
+ lastValue = destination[scopeName] = parentGet(scope);
+ throw $compileMinErr('nonassign',
+ 'Expression \'{0}\' in attribute \'{1}\' used with directive \'{2}\' is non-assignable!',
+ attrs[attrName], attrName, directive.name);
+ };
+ lastValue = destination[scopeName] = parentGet(scope);
+ var parentValueWatch = function parentValueWatch(parentValue) {
+ if (!compare(parentValue, destination[scopeName])) {
+ // we are out of sync and need to copy
+ if (!compare(parentValue, lastValue)) {
+ // parent changed and it has precedence
+ destination[scopeName] = parentValue;
+ } else {
+ // if the parent can be assigned then do so
+ parentSet(scope, parentValue = destination[scopeName]);
+ }
+ }
+ lastValue = parentValue;
+ return lastValue;
+ };
+ parentValueWatch.$stateful = true;
+ if (definition.collection) {
+ removeWatch = scope.$watchCollection(attrs[attrName], parentValueWatch);
+ } else {
+ removeWatch = scope.$watch($parse(attrs[attrName], parentValueWatch), null, parentGet.literal);
+ }
+ removeWatchCollection.push(removeWatch);
+ break;
+
+ case '<':
+ if (!hasOwnProperty.call(attrs, attrName)) {
+ if (optional) break;
+ strictBindingsCheck(attrName, directive.name);
+ attrs[attrName] = undefined;
+ }
+ if (optional && !attrs[attrName]) break;
+
+ parentGet = $parse(attrs[attrName]);
+ var isLiteral = parentGet.literal;
+
+ var initialValue = destination[scopeName] = parentGet(scope);
+ initialChanges[scopeName] = new SimpleChange(_UNINITIALIZED_VALUE, destination[scopeName]);
+
+ removeWatch = scope[definition.collection ? '$watchCollection' : '$watch'](parentGet, function parentValueWatchAction(newValue, oldValue) {
+ if (oldValue === newValue) {
+ if (oldValue === initialValue || (isLiteral && equals(oldValue, initialValue))) {
+ return;
+ }
+ oldValue = initialValue;
+ }
+ recordChanges(scopeName, newValue, oldValue);
+ destination[scopeName] = newValue;
+ });
+
+ removeWatchCollection.push(removeWatch);
+ break;
+
+ case '&':
+ if (!optional && !hasOwnProperty.call(attrs, attrName)) {
+ strictBindingsCheck(attrName, directive.name);
+ }
+ // Don't assign Object.prototype method to scope
+ parentGet = attrs.hasOwnProperty(attrName) ? $parse(attrs[attrName]) : noop;
+
+ // Don't assign noop to destination if expression is not valid
+ if (parentGet === noop && optional) break;
+
+ destination[scopeName] = function(locals) {
+ return parentGet(scope, locals);
+ };
+ break;
+ }
+ });
+
+ function recordChanges(key, currentValue, previousValue) {
+ if (isFunction(destination.$onChanges) && !simpleCompare(currentValue, previousValue)) {
+ // If we have not already scheduled the top level onChangesQueue handler then do so now
+ if (!onChangesQueue) {
+ scope.$$postDigest(flushOnChangesQueue);
+ onChangesQueue = [];
+ }
+ // If we have not already queued a trigger of onChanges for this controller then do so now
+ if (!changes) {
+ changes = {};
+ onChangesQueue.push(triggerOnChangesHook);
+ }
+ // If the has been a change on this property already then we need to reuse the previous value
+ if (changes[key]) {
+ previousValue = changes[key].previousValue;
+ }
+ // Store this change
+ changes[key] = new SimpleChange(previousValue, currentValue);
+ }
+ }
+
+ function triggerOnChangesHook() {
+ destination.$onChanges(changes);
+ // Now clear the changes so that we schedule onChanges when more changes arrive
+ changes = undefined;
+ }
+
+ return {
+ initialChanges: initialChanges,
+ removeWatches: removeWatchCollection.length && function removeWatches() {
+ for (var i = 0, ii = removeWatchCollection.length; i < ii; ++i) {
+ removeWatchCollection[i]();
+ }
+ }
+ };
+ }
+ }];
+}
+
+function SimpleChange(previous, current) {
+ this.previousValue = previous;
+ this.currentValue = current;
+}
+SimpleChange.prototype.isFirstChange = function() { return this.previousValue === _UNINITIALIZED_VALUE; };
+
+
+var PREFIX_REGEXP = /^((?:x|data)[:\-_])/i;
+var SPECIAL_CHARS_REGEXP = /[:\-_]+(.)/g;
+
+/**
+ * Converts all accepted directives format into proper directive name.
+ * @param name Name to normalize
+ */
+function directiveNormalize(name) {
+ return name
+ .replace(PREFIX_REGEXP, '')
+ .replace(SPECIAL_CHARS_REGEXP, function(_, letter, offset) {
+ return offset ? letter.toUpperCase() : letter;
+ });
+}
+
+/**
+ * @ngdoc type
+ * @name $compile.directive.Attributes
+ *
+ * @description
+ * A shared object between directive compile / linking functions which contains normalized DOM
+ * element attributes. The values reflect current binding state `{{ }}`. The normalization is
+ * needed since all of these are treated as equivalent in AngularJS:
+ *
+ * ```
+ * <span ng:bind="a" ng-bind="a" data-ng-bind="a" x-ng-bind="a">
+ * ```
+ */
+
+/**
+ * @ngdoc property
+ * @name $compile.directive.Attributes#$attr
+ *
+ * @description
+ * A map of DOM element attribute names to the normalized name. This is
+ * needed to do reverse lookup from normalized name back to actual name.
+ */
+
+
+/**
+ * @ngdoc method
+ * @name $compile.directive.Attributes#$set
+ * @kind function
+ *
+ * @description
+ * Set DOM element attribute value.
+ *
+ *
+ * @param {string} name Normalized element attribute name of the property to modify. The name is
+ * reverse-translated using the {@link ng.$compile.directive.Attributes#$attr $attr}
+ * property to the original name.
+ * @param {string} value Value to set the attribute to. The value can be an interpolated string.
+ */
+
+
+
+/**
+ * Closure compiler type information
+ */
+
+function nodesetLinkingFn(
+ /* angular.Scope */ scope,
+ /* NodeList */ nodeList,
+ /* Element */ rootElement,
+ /* function(Function) */ boundTranscludeFn
+) {}
+
+function directiveLinkingFn(
+ /* nodesetLinkingFn */ nodesetLinkingFn,
+ /* angular.Scope */ scope,
+ /* Node */ node,
+ /* Element */ rootElement,
+ /* function(Function) */ boundTranscludeFn
+) {}
+
+function tokenDifference(str1, str2) {
+ var values = '',
+ tokens1 = str1.split(/\s+/),
+ tokens2 = str2.split(/\s+/);
+
+ outer:
+ for (var i = 0; i < tokens1.length; i++) {
+ var token = tokens1[i];
+ for (var j = 0; j < tokens2.length; j++) {
+ if (token === tokens2[j]) continue outer;
+ }
+ values += (values.length > 0 ? ' ' : '') + token;
+ }
+ return values;
+}
+
+function removeComments(jqNodes) {
+ jqNodes = jqLite(jqNodes);
+ var i = jqNodes.length;
+
+ if (i <= 1) {
+ return jqNodes;
+ }
+
+ while (i--) {
+ var node = jqNodes[i];
+ if (node.nodeType === NODE_TYPE_COMMENT ||
+ (node.nodeType === NODE_TYPE_TEXT && node.nodeValue.trim() === '')) {
+ splice.call(jqNodes, i, 1);
+ }
+ }
+ return jqNodes;
+}
+
+var $controllerMinErr = minErr('$controller');
+
+
+var CNTRL_REG = /^(\S+)(\s+as\s+([\w$]+))?$/;
+function identifierForController(controller, ident) {
+ if (ident && isString(ident)) return ident;
+ if (isString(controller)) {
+ var match = CNTRL_REG.exec(controller);
+ if (match) return match[3];
+ }
+}
+
+
+/**
+ * @ngdoc provider
+ * @name $controllerProvider
+ * @this
+ *
+ * @description
+ * The {@link ng.$controller $controller service} is used by AngularJS to create new
+ * controllers.
+ *
+ * This provider allows controller registration via the
+ * {@link ng.$controllerProvider#register register} method.
+ */
+function $ControllerProvider() {
+ var controllers = {};
+
+ /**
+ * @ngdoc method
+ * @name $controllerProvider#has
+ * @param {string} name Controller name to check.
+ */
+ this.has = function(name) {
+ return controllers.hasOwnProperty(name);
+ };
+
+ /**
+ * @ngdoc method
+ * @name $controllerProvider#register
+ * @param {string|Object} name Controller name, or an object map of controllers where the keys are
+ * the names and the values are the constructors.
+ * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
+ * annotations in the array notation).
+ */
+ this.register = function(name, constructor) {
+ assertNotHasOwnProperty(name, 'controller');
+ if (isObject(name)) {
+ extend(controllers, name);
+ } else {
+ controllers[name] = constructor;
+ }
+ };
+
+ this.$get = ['$injector', function($injector) {
+
+ /**
+ * @ngdoc service
+ * @name $controller
+ * @requires $injector
+ *
+ * @param {Function|string} constructor If called with a function then it's considered to be the
+ * controller constructor function. Otherwise it's considered to be a string which is used
+ * to retrieve the controller constructor using the following steps:
+ *
+ * * check if a controller with given name is registered via `$controllerProvider`
+ * * check if evaluating the string on the current scope returns a constructor
+ *
+ * The string can use the `controller as property` syntax, where the controller instance is published
+ * as the specified property on the `scope`; the `scope` must be injected into `locals` param for this
+ * to work correctly.
+ *
+ * @param {Object} locals Injection locals for Controller.
+ * @return {Object} Instance of given controller.
+ *
+ * @description
+ * `$controller` service is responsible for instantiating controllers.
+ *
+ * It's just a simple call to {@link auto.$injector $injector}, but extracted into
+ * a service, so that one can override this service with [BC version](https://gist.github.com/1649788).
+ */
+ return function $controller(expression, locals, later, ident) {
+ // PRIVATE API:
+ // param `later` --- indicates that the controller's constructor is invoked at a later time.
+ // If true, $controller will allocate the object with the correct
+ // prototype chain, but will not invoke the controller until a returned
+ // callback is invoked.
+ // param `ident` --- An optional label which overrides the label parsed from the controller
+ // expression, if any.
+ var instance, match, constructor, identifier;
+ later = later === true;
+ if (ident && isString(ident)) {
+ identifier = ident;
+ }
+
+ if (isString(expression)) {
+ match = expression.match(CNTRL_REG);
+ if (!match) {
+ throw $controllerMinErr('ctrlfmt',
+ 'Badly formed controller string \'{0}\'. ' +
+ 'Must match `__name__ as __id__` or `__name__`.', expression);
+ }
+ constructor = match[1];
+ identifier = identifier || match[3];
+ expression = controllers.hasOwnProperty(constructor)
+ ? controllers[constructor]
+ : getter(locals.$scope, constructor, true);
+
+ if (!expression) {
+ throw $controllerMinErr('ctrlreg',
+ 'The controller with the name \'{0}\' is not registered.', constructor);
+ }
+
+ assertArgFn(expression, constructor, true);
+ }
+
+ if (later) {
+ // Instantiate controller later:
+ // This machinery is used to create an instance of the object before calling the
+ // controller's constructor itself.
+ //
+ // This allows properties to be added to the controller before the constructor is
+ // invoked. Primarily, this is used for isolate scope bindings in $compile.
+ //
+ // This feature is not intended for use by applications, and is thus not documented
+ // publicly.
+ // Object creation: http://jsperf.com/create-constructor/2
+ var controllerPrototype = (isArray(expression) ?
+ expression[expression.length - 1] : expression).prototype;
+ instance = Object.create(controllerPrototype || null);
+
+ if (identifier) {
+ addIdentifier(locals, identifier, instance, constructor || expression.name);
+ }
+
+ return extend(function $controllerInit() {
+ var result = $injector.invoke(expression, instance, locals, constructor);
+ if (result !== instance && (isObject(result) || isFunction(result))) {
+ instance = result;
+ if (identifier) {
+ // If result changed, re-assign controllerAs value to scope.
+ addIdentifier(locals, identifier, instance, constructor || expression.name);
+ }
+ }
+ return instance;
+ }, {
+ instance: instance,
+ identifier: identifier
+ });
+ }
+
+ instance = $injector.instantiate(expression, locals, constructor);
+
+ if (identifier) {
+ addIdentifier(locals, identifier, instance, constructor || expression.name);
+ }
+
+ return instance;
+ };
+
+ function addIdentifier(locals, identifier, instance, name) {
+ if (!(locals && isObject(locals.$scope))) {
+ throw minErr('$controller')('noscp',
+ 'Cannot export controller \'{0}\' as \'{1}\'! No $scope object provided via `locals`.',
+ name, identifier);
+ }
+
+ locals.$scope[identifier] = instance;
+ }
+ }];
+}
+
+/**
+ * @ngdoc service
+ * @name $document
+ * @requires $window
+ * @this
+ *
+ * @description
+ * A {@link angular.element jQuery or jqLite} wrapper for the browser's `window.document` object.
+ *
+ * @example
+ <example module="documentExample" name="document">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <p>$document title: <b ng-bind="title"></b></p>
+ <p>window.document title: <b ng-bind="windowTitle"></b></p>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('documentExample', [])
+ .controller('ExampleController', ['$scope', '$document', function($scope, $document) {
+ $scope.title = $document[0].title;
+ $scope.windowTitle = angular.element(window.document)[0].title;
+ }]);
+ </file>
+ </example>
+ */
+function $DocumentProvider() {
+ this.$get = ['$window', function(window) {
+ return jqLite(window.document);
+ }];
+}
+
+
+/**
+ * @private
+ * @this
+ * Listens for document visibility change and makes the current status accessible.
+ */
+function $$IsDocumentHiddenProvider() {
+ this.$get = ['$document', '$rootScope', function($document, $rootScope) {
+ var doc = $document[0];
+ var hidden = doc && doc.hidden;
+
+ $document.on('visibilitychange', changeListener);
+
+ $rootScope.$on('$destroy', function() {
+ $document.off('visibilitychange', changeListener);
+ });
+
+ function changeListener() {
+ hidden = doc.hidden;
+ }
+
+ return function() {
+ return hidden;
+ };
+ }];
+}
+
+/**
+ * @ngdoc service
+ * @name $exceptionHandler
+ * @requires ng.$log
+ * @this
+ *
+ * @description
+ * Any uncaught exception in AngularJS expressions is delegated to this service.
+ * The default implementation simply delegates to `$log.error` which logs it into
+ * the browser console.
+ *
+ * In unit tests, if `angular-mocks.js` is loaded, this service is overridden by
+ * {@link ngMock.$exceptionHandler mock $exceptionHandler} which aids in testing.
+ *
+ * ## Example:
+ *
+ * The example below will overwrite the default `$exceptionHandler` in order to (a) log uncaught
+ * errors to the backend for later inspection by the developers and (b) to use `$log.warn()` instead
+ * of `$log.error()`.
+ *
+ * ```js
+ * angular.
+ * module('exceptionOverwrite', []).
+ * factory('$exceptionHandler', ['$log', 'logErrorsToBackend', function($log, logErrorsToBackend) {
+ * return function myExceptionHandler(exception, cause) {
+ * logErrorsToBackend(exception, cause);
+ * $log.warn(exception, cause);
+ * };
+ * }]);
+ * ```
+ *
+ * <hr />
+ * Note, that code executed in event-listeners (even those registered using jqLite's `on`/`bind`
+ * methods) does not delegate exceptions to the {@link ng.$exceptionHandler $exceptionHandler}
+ * (unless executed during a digest).
+ *
+ * If you wish, you can manually delegate exceptions, e.g.
+ * `try { ... } catch(e) { $exceptionHandler(e); }`
+ *
+ * @param {Error} exception Exception associated with the error.
+ * @param {string=} cause Optional information about the context in which
+ * the error was thrown.
+ *
+ */
+function $ExceptionHandlerProvider() {
+ this.$get = ['$log', function($log) {
+ return function(exception, cause) {
+ $log.error.apply($log, arguments);
+ };
+ }];
+}
+
+var $$ForceReflowProvider = /** @this */ function() {
+ this.$get = ['$document', function($document) {
+ return function(domNode) {
+ //the line below will force the browser to perform a repaint so
+ //that all the animated elements within the animation frame will
+ //be properly updated and drawn on screen. This is required to
+ //ensure that the preparation animation is properly flushed so that
+ //the active state picks up from there. DO NOT REMOVE THIS LINE.
+ //DO NOT OPTIMIZE THIS LINE. THE MINIFIER WILL REMOVE IT OTHERWISE WHICH
+ //WILL RESULT IN AN UNPREDICTABLE BUG THAT IS VERY HARD TO TRACK DOWN AND
+ //WILL TAKE YEARS AWAY FROM YOUR LIFE.
+ if (domNode) {
+ if (!domNode.nodeType && domNode instanceof jqLite) {
+ domNode = domNode[0];
+ }
+ } else {
+ domNode = $document[0].body;
+ }
+ return domNode.offsetWidth + 1;
+ };
+ }];
+};
+
+var APPLICATION_JSON = 'application/json';
+var CONTENT_TYPE_APPLICATION_JSON = {'Content-Type': APPLICATION_JSON + ';charset=utf-8'};
+var JSON_START = /^\[|^\{(?!\{)/;
+var JSON_ENDS = {
+ '[': /]$/,
+ '{': /}$/
+};
+var JSON_PROTECTION_PREFIX = /^\)]\}',?\n/;
+var $httpMinErr = minErr('$http');
+
+function serializeValue(v) {
+ if (isObject(v)) {
+ return isDate(v) ? v.toISOString() : toJson(v);
+ }
+ return v;
+}
+
+
+/** @this */
+function $HttpParamSerializerProvider() {
+ /**
+ * @ngdoc service
+ * @name $httpParamSerializer
+ * @description
+ *
+ * Default {@link $http `$http`} params serializer that converts objects to strings
+ * according to the following rules:
+ *
+ * * `{'foo': 'bar'}` results in `foo=bar`
+ * * `{'foo': Date.now()}` results in `foo=2015-04-01T09%3A50%3A49.262Z` (`toISOString()` and encoded representation of a Date object)
+ * * `{'foo': ['bar', 'baz']}` results in `foo=bar&foo=baz` (repeated key for each array element)
+ * * `{'foo': {'bar':'baz'}}` results in `foo=%7B%22bar%22%3A%22baz%22%7D` (stringified and encoded representation of an object)
+ *
+ * Note that serializer will sort the request parameters alphabetically.
+ */
+
+ this.$get = function() {
+ return function ngParamSerializer(params) {
+ if (!params) return '';
+ var parts = [];
+ forEachSorted(params, function(value, key) {
+ if (value === null || isUndefined(value) || isFunction(value)) return;
+ if (isArray(value)) {
+ forEach(value, function(v) {
+ parts.push(encodeUriQuery(key) + '=' + encodeUriQuery(serializeValue(v)));
+ });
+ } else {
+ parts.push(encodeUriQuery(key) + '=' + encodeUriQuery(serializeValue(value)));
+ }
+ });
+
+ return parts.join('&');
+ };
+ };
+}
+
+/** @this */
+function $HttpParamSerializerJQLikeProvider() {
+ /**
+ * @ngdoc service
+ * @name $httpParamSerializerJQLike
+ *
+ * @description
+ *
+ * Alternative {@link $http `$http`} params serializer that follows
+ * jQuery's [`param()`](http://api.jquery.com/jquery.param/) method logic.
+ * The serializer will also sort the params alphabetically.
+ *
+ * To use it for serializing `$http` request parameters, set it as the `paramSerializer` property:
+ *
+ * ```js
+ * $http({
+ * url: myUrl,
+ * method: 'GET',
+ * params: myParams,
+ * paramSerializer: '$httpParamSerializerJQLike'
+ * });
+ * ```
+ *
+ * It is also possible to set it as the default `paramSerializer` in the
+ * {@link $httpProvider#defaults `$httpProvider`}.
+ *
+ * Additionally, you can inject the serializer and use it explicitly, for example to serialize
+ * form data for submission:
+ *
+ * ```js
+ * .controller(function($http, $httpParamSerializerJQLike) {
+ * //...
+ *
+ * $http({
+ * url: myUrl,
+ * method: 'POST',
+ * data: $httpParamSerializerJQLike(myData),
+ * headers: {
+ * 'Content-Type': 'application/x-www-form-urlencoded'
+ * }
+ * });
+ *
+ * });
+ * ```
+ *
+ */
+ this.$get = function() {
+ return function jQueryLikeParamSerializer(params) {
+ if (!params) return '';
+ var parts = [];
+ serialize(params, '', true);
+ return parts.join('&');
+
+ function serialize(toSerialize, prefix, topLevel) {
+ if (isArray(toSerialize)) {
+ forEach(toSerialize, function(value, index) {
+ serialize(value, prefix + '[' + (isObject(value) ? index : '') + ']');
+ });
+ } else if (isObject(toSerialize) && !isDate(toSerialize)) {
+ forEachSorted(toSerialize, function(value, key) {
+ serialize(value, prefix +
+ (topLevel ? '' : '[') +
+ key +
+ (topLevel ? '' : ']'));
+ });
+ } else {
+ if (isFunction(toSerialize)) {
+ toSerialize = toSerialize();
+ }
+ parts.push(encodeUriQuery(prefix) + '=' +
+ (toSerialize == null ? '' : encodeUriQuery(serializeValue(toSerialize))));
+ }
+ }
+ };
+ };
+}
+
+function defaultHttpResponseTransform(data, headers) {
+ if (isString(data)) {
+ // Strip json vulnerability protection prefix and trim whitespace
+ var tempData = data.replace(JSON_PROTECTION_PREFIX, '').trim();
+
+ if (tempData) {
+ var contentType = headers('Content-Type');
+ var hasJsonContentType = contentType && (contentType.indexOf(APPLICATION_JSON) === 0);
+
+ if (hasJsonContentType || isJsonLike(tempData)) {
+ try {
+ data = fromJson(tempData);
+ } catch (e) {
+ if (!hasJsonContentType) {
+ return data;
+ }
+ throw $httpMinErr('baddata', 'Data must be a valid JSON object. Received: "{0}". ' +
+ 'Parse error: "{1}"', data, e);
+ }
+ }
+ }
+ }
+
+ return data;
+}
+
+function isJsonLike(str) {
+ var jsonStart = str.match(JSON_START);
+ return jsonStart && JSON_ENDS[jsonStart[0]].test(str);
+}
+
+/**
+ * Parse headers into key value object
+ *
+ * @param {string} headers Raw headers as a string
+ * @returns {Object} Parsed headers as key value object
+ */
+function parseHeaders(headers) {
+ var parsed = createMap(), i;
+
+ function fillInParsed(key, val) {
+ if (key) {
+ parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+ }
+ }
+
+ if (isString(headers)) {
+ forEach(headers.split('\n'), function(line) {
+ i = line.indexOf(':');
+ fillInParsed(lowercase(trim(line.substr(0, i))), trim(line.substr(i + 1)));
+ });
+ } else if (isObject(headers)) {
+ forEach(headers, function(headerVal, headerKey) {
+ fillInParsed(lowercase(headerKey), trim(headerVal));
+ });
+ }
+
+ return parsed;
+}
+
+
+/**
+ * Returns a function that provides access to parsed headers.
+ *
+ * Headers are lazy parsed when first requested.
+ * @see parseHeaders
+ *
+ * @param {(string|Object)} headers Headers to provide access to.
+ * @returns {function(string=)} Returns a getter function which if called with:
+ *
+ * - if called with an argument returns a single header value or null
+ * - if called with no arguments returns an object containing all headers.
+ */
+function headersGetter(headers) {
+ var headersObj;
+
+ return function(name) {
+ if (!headersObj) headersObj = parseHeaders(headers);
+
+ if (name) {
+ var value = headersObj[lowercase(name)];
+ if (value === undefined) {
+ value = null;
+ }
+ return value;
+ }
+
+ return headersObj;
+ };
+}
+
+
+/**
+ * Chain all given functions
+ *
+ * This function is used for both request and response transforming
+ *
+ * @param {*} data Data to transform.
+ * @param {function(string=)} headers HTTP headers getter fn.
+ * @param {number} status HTTP status code of the response.
+ * @param {(Function|Array.<Function>)} fns Function or an array of functions.
+ * @returns {*} Transformed data.
+ */
+function transformData(data, headers, status, fns) {
+ if (isFunction(fns)) {
+ return fns(data, headers, status);
+ }
+
+ forEach(fns, function(fn) {
+ data = fn(data, headers, status);
+ });
+
+ return data;
+}
+
+
+function isSuccess(status) {
+ return 200 <= status && status < 300;
+}
+
+
+/**
+ * @ngdoc provider
+ * @name $httpProvider
+ * @this
+ *
+ * @description
+ * Use `$httpProvider` to change the default behavior of the {@link ng.$http $http} service.
+ */
+function $HttpProvider() {
+ /**
+ * @ngdoc property
+ * @name $httpProvider#defaults
+ * @description
+ *
+ * Object containing default values for all {@link ng.$http $http} requests.
+ *
+ * - **`defaults.cache`** - {boolean|Object} - A boolean value or object created with
+ * {@link ng.$cacheFactory `$cacheFactory`} to enable or disable caching of HTTP responses
+ * by default. See {@link $http#caching $http Caching} for more information.
+ *
+ * - **`defaults.headers`** - {Object} - Default headers for all $http requests.
+ * Refer to {@link ng.$http#setting-http-headers $http} for documentation on
+ * setting default headers.
+ * - **`defaults.headers.common`**
+ * - **`defaults.headers.post`**
+ * - **`defaults.headers.put`**
+ * - **`defaults.headers.patch`**
+ *
+ * - **`defaults.jsonpCallbackParam`** - `{string}` - the name of the query parameter that passes the name of the
+ * callback in a JSONP request. The value of this parameter will be replaced with the expression generated by the
+ * {@link $jsonpCallbacks} service. Defaults to `'callback'`.
+ *
+ * - **`defaults.paramSerializer`** - `{string|function(Object<string,string>):string}` - A function
+ * used to the prepare string representation of request parameters (specified as an object).
+ * If specified as string, it is interpreted as a function registered with the {@link auto.$injector $injector}.
+ * Defaults to {@link ng.$httpParamSerializer $httpParamSerializer}.
+ *
+ * - **`defaults.transformRequest`** -
+ * `{Array<function(data, headersGetter)>|function(data, headersGetter)}` -
+ * An array of functions (or a single function) which are applied to the request data.
+ * By default, this is an array with one request transformation function:
+ *
+ * - If the `data` property of the request configuration object contains an object, serialize it
+ * into JSON format.
+ *
+ * - **`defaults.transformResponse`** -
+ * `{Array<function(data, headersGetter, status)>|function(data, headersGetter, status)}` -
+ * An array of functions (or a single function) which are applied to the response data. By default,
+ * this is an array which applies one response transformation function that does two things:
+ *
+ * - If XSRF prefix is detected, strip it
+ * (see {@link ng.$http#security-considerations Security Considerations in the $http docs}).
+ * - If the `Content-Type` is `application/json` or the response looks like JSON,
+ * deserialize it using a JSON parser.
+ *
+ * - **`defaults.xsrfCookieName`** - {string} - Name of cookie containing the XSRF token.
+ * Defaults value is `'XSRF-TOKEN'`.
+ *
+ * - **`defaults.xsrfHeaderName`** - {string} - Name of HTTP header to populate with the
+ * XSRF token. Defaults value is `'X-XSRF-TOKEN'`.
+ *
+ */
+ var defaults = this.defaults = {
+ // transform incoming response data
+ transformResponse: [defaultHttpResponseTransform],
+
+ // transform outgoing request data
+ transformRequest: [function(d) {
+ return isObject(d) && !isFile(d) && !isBlob(d) && !isFormData(d) ? toJson(d) : d;
+ }],
+
+ // default headers
+ headers: {
+ common: {
+ 'Accept': 'application/json, text/plain, */*'
+ },
+ post: shallowCopy(CONTENT_TYPE_APPLICATION_JSON),
+ put: shallowCopy(CONTENT_TYPE_APPLICATION_JSON),
+ patch: shallowCopy(CONTENT_TYPE_APPLICATION_JSON)
+ },
+
+ xsrfCookieName: 'XSRF-TOKEN',
+ xsrfHeaderName: 'X-XSRF-TOKEN',
+
+ paramSerializer: '$httpParamSerializer',
+
+ jsonpCallbackParam: 'callback'
+ };
+
+ var useApplyAsync = false;
+ /**
+ * @ngdoc method
+ * @name $httpProvider#useApplyAsync
+ * @description
+ *
+ * Configure $http service to combine processing of multiple http responses received at around
+ * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in
+ * significant performance improvement for bigger applications that make many HTTP requests
+ * concurrently (common during application bootstrap).
+ *
+ * Defaults to false. If no value is specified, returns the current configured value.
+ *
+ * @param {boolean=} value If true, when requests are loaded, they will schedule a deferred
+ * "apply" on the next tick, giving time for subsequent requests in a roughly ~10ms window
+ * to load and share the same digest cycle.
+ *
+ * @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining.
+ * otherwise, returns the current configured value.
+ */
+ this.useApplyAsync = function(value) {
+ if (isDefined(value)) {
+ useApplyAsync = !!value;
+ return this;
+ }
+ return useApplyAsync;
+ };
+
+ /**
+ * @ngdoc property
+ * @name $httpProvider#interceptors
+ * @description
+ *
+ * Array containing service factories for all synchronous or asynchronous {@link ng.$http $http}
+ * pre-processing of request or postprocessing of responses.
+ *
+ * These service factories are ordered by request, i.e. they are applied in the same order as the
+ * array, on request, but reverse order, on response.
+ *
+ * {@link ng.$http#interceptors Interceptors detailed info}
+ */
+ var interceptorFactories = this.interceptors = [];
+
+ /**
+ * @ngdoc property
+ * @name $httpProvider#xsrfTrustedOrigins
+ * @description
+ *
+ * Array containing URLs whose origins are trusted to receive the XSRF token. See the
+ * {@link ng.$http#security-considerations Security Considerations} sections for more details on
+ * XSRF.
+ *
+ * **Note:** An "origin" consists of the [URI scheme](https://en.wikipedia.org/wiki/URI_scheme),
+ * the [hostname](https://en.wikipedia.org/wiki/Hostname) and the
+ * [port number](https://en.wikipedia.org/wiki/Port_(computer_networking). For `http:` and
+ * `https:`, the port number can be omitted if using th default ports (80 and 443 respectively).
+ * Examples: `http://example.com`, `https://api.example.com:9876`
+ *
+ * <div class="alert alert-warning">
+ * It is not possible to trust specific URLs/paths. The `path`, `query` and `fragment` parts
+ * of a URL will be ignored. For example, `https://foo.com/path/bar?query=baz#fragment` will be
+ * treated as `https://foo.com`, meaning that **all** requests to URLs starting with
+ * `https://foo.com/` will include the XSRF token.
+ * </div>
+ *
+ * @example
+ *
+ * ```js
+ * // App served from `https://example.com/`.
+ * angular.
+ * module('xsrfTrustedOriginsExample', []).
+ * config(['$httpProvider', function($httpProvider) {
+ * $httpProvider.xsrfTrustedOrigins.push('https://api.example.com');
+ * }]).
+ * run(['$http', function($http) {
+ * // The XSRF token will be sent.
+ * $http.get('https://api.example.com/preferences').then(...);
+ *
+ * // The XSRF token will NOT be sent.
+ * $http.get('https://stats.example.com/activity').then(...);
+ * }]);
+ * ```
+ */
+ var xsrfTrustedOrigins = this.xsrfTrustedOrigins = [];
+
+ /**
+ * @ngdoc property
+ * @name $httpProvider#xsrfWhitelistedOrigins
+ * @description
+ *
+ * @deprecated
+ * sinceVersion="1.8.1"
+ *
+ * This property is deprecated. Use {@link $httpProvider#xsrfTrustedOrigins xsrfTrustedOrigins}
+ * instead.
+ */
+ Object.defineProperty(this, 'xsrfWhitelistedOrigins', {
+ get: function() {
+ return this.xsrfTrustedOrigins;
+ },
+ set: function(origins) {
+ this.xsrfTrustedOrigins = origins;
+ }
+ });
+
+ this.$get = ['$browser', '$httpBackend', '$$cookieReader', '$cacheFactory', '$rootScope', '$q', '$injector', '$sce',
+ function($browser, $httpBackend, $$cookieReader, $cacheFactory, $rootScope, $q, $injector, $sce) {
+
+ var defaultCache = $cacheFactory('$http');
+
+ /**
+ * Make sure that default param serializer is exposed as a function
+ */
+ defaults.paramSerializer = isString(defaults.paramSerializer) ?
+ $injector.get(defaults.paramSerializer) : defaults.paramSerializer;
+
+ /**
+ * Interceptors stored in reverse order. Inner interceptors before outer interceptors.
+ * The reversal is needed so that we can build up the interception chain around the
+ * server request.
+ */
+ var reversedInterceptors = [];
+
+ forEach(interceptorFactories, function(interceptorFactory) {
+ reversedInterceptors.unshift(isString(interceptorFactory)
+ ? $injector.get(interceptorFactory) : $injector.invoke(interceptorFactory));
+ });
+
+ /**
+ * A function to check request URLs against a list of allowed origins.
+ */
+ var urlIsAllowedOrigin = urlIsAllowedOriginFactory(xsrfTrustedOrigins);
+
+ /**
+ * @ngdoc service
+ * @kind function
+ * @name $http
+ * @requires ng.$httpBackend
+ * @requires $cacheFactory
+ * @requires $rootScope
+ * @requires $q
+ * @requires $injector
+ *
+ * @description
+ * The `$http` service is a core AngularJS service that facilitates communication with the remote
+ * HTTP servers via the browser's [XMLHttpRequest](https://developer.mozilla.org/en/xmlhttprequest)
+ * object or via [JSONP](http://en.wikipedia.org/wiki/JSONP).
+ *
+ * For unit testing applications that use `$http` service, see
+ * {@link ngMock.$httpBackend $httpBackend mock}.
+ *
+ * For a higher level of abstraction, please check out the {@link ngResource.$resource
+ * $resource} service.
+ *
+ * The $http API is based on the {@link ng.$q deferred/promise APIs} exposed by
+ * the $q service. While for simple usage patterns this doesn't matter much, for advanced usage
+ * it is important to familiarize yourself with these APIs and the guarantees they provide.
+ *
+ *
+ * ## General usage
+ * The `$http` service is a function which takes a single argument — a {@link $http#usage configuration object} —
+ * that is used to generate an HTTP request and returns a {@link ng.$q promise} that is
+ * resolved (request success) or rejected (request failure) with a
+ * {@link ng.$http#$http-returns response} object.
+ *
+ * ```js
+ * // Simple GET request example:
+ * $http({
+ * method: 'GET',
+ * url: '/someUrl'
+ * }).then(function successCallback(response) {
+ * // this callback will be called asynchronously
+ * // when the response is available
+ * }, function errorCallback(response) {
+ * // called asynchronously if an error occurs
+ * // or server returns response with an error status.
+ * });
+ * ```
+ *
+ *
+ * ## Shortcut methods
+ *
+ * Shortcut methods are also available. All shortcut methods require passing in the URL, and
+ * request data must be passed in for POST/PUT requests. An optional config can be passed as the
+ * last argument.
+ *
+ * ```js
+ * $http.get('/someUrl', config).then(successCallback, errorCallback);
+ * $http.post('/someUrl', data, config).then(successCallback, errorCallback);
+ * ```
+ *
+ * Complete list of shortcut methods:
+ *
+ * - {@link ng.$http#get $http.get}
+ * - {@link ng.$http#head $http.head}
+ * - {@link ng.$http#post $http.post}
+ * - {@link ng.$http#put $http.put}
+ * - {@link ng.$http#delete $http.delete}
+ * - {@link ng.$http#jsonp $http.jsonp}
+ * - {@link ng.$http#patch $http.patch}
+ *
+ *
+ * ## Writing Unit Tests that use $http
+ * When unit testing (using {@link ngMock ngMock}), it is necessary to call
+ * {@link ngMock.$httpBackend#flush $httpBackend.flush()} to flush each pending
+ * request using trained responses.
+ *
+ * ```
+ * $httpBackend.expectGET(...);
+ * $http.get(...);
+ * $httpBackend.flush();
+ * ```
+ *
+ * ## Setting HTTP Headers
+ *
+ * The $http service will automatically add certain HTTP headers to all requests. These defaults
+ * can be fully configured by accessing the `$httpProvider.defaults.headers` configuration
+ * object, which currently contains this default configuration:
+ *
+ * - `$httpProvider.defaults.headers.common` (headers that are common for all requests):
+ * - <code>Accept: application/json, text/plain, \*/\*</code>
+ * - `$httpProvider.defaults.headers.post`: (header defaults for POST requests)
+ * - `Content-Type: application/json`
+ * - `$httpProvider.defaults.headers.put` (header defaults for PUT requests)
+ * - `Content-Type: application/json`
+ *
+ * To add or overwrite these defaults, simply add or remove a property from these configuration
+ * objects. To add headers for an HTTP method other than POST or PUT, simply add a new object
+ * with the lowercased HTTP method name as the key, e.g.
+ * `$httpProvider.defaults.headers.get = { 'My-Header' : 'value' }`.
+ *
+ * The defaults can also be set at runtime via the `$http.defaults` object in the same
+ * fashion. For example:
+ *
+ * ```
+ * module.run(function($http) {
+ * $http.defaults.headers.common.Authorization = 'Basic YmVlcDpib29w';
+ * });
+ * ```
+ *
+ * In addition, you can supply a `headers` property in the config object passed when
+ * calling `$http(config)`, which overrides the defaults without changing them globally.
+ *
+ * To explicitly remove a header automatically added via $httpProvider.defaults.headers on a per request basis,
+ * Use the `headers` property, setting the desired header to `undefined`. For example:
+ *
+ * ```js
+ * var req = {
+ * method: 'POST',
+ * url: 'http://example.com',
+ * headers: {
+ * 'Content-Type': undefined
+ * },
+ * data: { test: 'test' }
+ * }
+ *
+ * $http(req).then(function(){...}, function(){...});
+ * ```
+ *
+ * ## Transforming Requests and Responses
+ *
+ * Both requests and responses can be transformed using transformation functions: `transformRequest`
+ * and `transformResponse`. These properties can be a single function that returns
+ * the transformed value (`function(data, headersGetter, status)`) or an array of such transformation functions,
+ * which allows you to `push` or `unshift` a new transformation function into the transformation chain.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** AngularJS does not make a copy of the `data` parameter before it is passed into the `transformRequest` pipeline.
+ * That means changes to the properties of `data` are not local to the transform function (since Javascript passes objects by reference).
+ * For example, when calling `$http.get(url, $scope.myObject)`, modifications to the object's properties in a transformRequest
+ * function will be reflected on the scope and in any templates where the object is data-bound.
+ * To prevent this, transform functions should have no side-effects.
+ * If you need to modify properties, it is recommended to make a copy of the data, or create new object to return.
+ * </div>
+ *
+ * ### Default Transformations
+ *
+ * The `$httpProvider` provider and `$http` service expose `defaults.transformRequest` and
+ * `defaults.transformResponse` properties. If a request does not provide its own transformations
+ * then these will be applied.
+ *
+ * You can augment or replace the default transformations by modifying these properties by adding to or
+ * replacing the array.
+ *
+ * AngularJS provides the following default transformations:
+ *
+ * Request transformations (`$httpProvider.defaults.transformRequest` and `$http.defaults.transformRequest`) is
+ * an array with one function that does the following:
+ *
+ * - If the `data` property of the request configuration object contains an object, serialize it
+ * into JSON format.
+ *
+ * Response transformations (`$httpProvider.defaults.transformResponse` and `$http.defaults.transformResponse`) is
+ * an array with one function that does the following:
+ *
+ * - If XSRF prefix is detected, strip it (see Security Considerations section below).
+ * - If the `Content-Type` is `application/json` or the response looks like JSON,
+ * deserialize it using a JSON parser.
+ *
+ *
+ * ### Overriding the Default Transformations Per Request
+ *
+ * If you wish to override the request/response transformations only for a single request then provide
+ * `transformRequest` and/or `transformResponse` properties on the configuration object passed
+ * into `$http`.
+ *
+ * Note that if you provide these properties on the config object the default transformations will be
+ * overwritten. If you wish to augment the default transformations then you must include them in your
+ * local transformation array.
+ *
+ * The following code demonstrates adding a new response transformation to be run after the default response
+ * transformations have been run.
+ *
+ * ```js
+ * function appendTransform(defaults, transform) {
+ *
+ * // We can't guarantee that the default transformation is an array
+ * defaults = angular.isArray(defaults) ? defaults : [defaults];
+ *
+ * // Append the new transformation to the defaults
+ * return defaults.concat(transform);
+ * }
+ *
+ * $http({
+ * url: '...',
+ * method: 'GET',
+ * transformResponse: appendTransform($http.defaults.transformResponse, function(value) {
+ * return doTransform(value);
+ * })
+ * });
+ * ```
+ *
+ *
+ * ## Caching
+ *
+ * {@link ng.$http `$http`} responses are not cached by default. To enable caching, you must
+ * set the config.cache value or the default cache value to TRUE or to a cache object (created
+ * with {@link ng.$cacheFactory `$cacheFactory`}). If defined, the value of config.cache takes
+ * precedence over the default cache value.
+ *
+ * In order to:
+ * * cache all responses - set the default cache value to TRUE or to a cache object
+ * * cache a specific response - set config.cache value to TRUE or to a cache object
+ *
+ * If caching is enabled, but neither the default cache nor config.cache are set to a cache object,
+ * then the default `$cacheFactory("$http")` object is used.
+ *
+ * The default cache value can be set by updating the
+ * {@link ng.$http#defaults `$http.defaults.cache`} property or the
+ * {@link $httpProvider#defaults `$httpProvider.defaults.cache`} property.
+ *
+ * When caching is enabled, {@link ng.$http `$http`} stores the response from the server using
+ * the relevant cache object. The next time the same request is made, the response is returned
+ * from the cache without sending a request to the server.
+ *
+ * Take note that:
+ *
+ * * Only GET and JSONP requests are cached.
+ * * The cache key is the request URL including search parameters; headers are not considered.
+ * * Cached responses are returned asynchronously, in the same way as responses from the server.
+ * * If multiple identical requests are made using the same cache, which is not yet populated,
+ * one request will be made to the server and remaining requests will return the same response.
+ * * A cache-control header on the response does not affect if or how responses are cached.
+ *
+ *
+ * ## Interceptors
+ *
+ * Before you start creating interceptors, be sure to understand the
+ * {@link ng.$q $q and deferred/promise APIs}.
+ *
+ * For purposes of global error handling, authentication, or any kind of synchronous or
+ * asynchronous pre-processing of request or postprocessing of responses, it is desirable to be
+ * able to intercept requests before they are handed to the server and
+ * responses before they are handed over to the application code that
+ * initiated these requests. The interceptors leverage the {@link ng.$q
+ * promise APIs} to fulfill this need for both synchronous and asynchronous pre-processing.
+ *
+ * The interceptors are service factories that are registered with the `$httpProvider` by
+ * adding them to the `$httpProvider.interceptors` array. The factory is called and
+ * injected with dependencies (if specified) and returns the interceptor.
+ *
+ * There are two kinds of interceptors (and two kinds of rejection interceptors):
+ *
+ * * `request`: interceptors get called with a http {@link $http#usage config} object. The function is free to
+ * modify the `config` object or create a new one. The function needs to return the `config`
+ * object directly, or a promise containing the `config` or a new `config` object.
+ * * `requestError`: interceptor gets called when a previous interceptor threw an error or
+ * resolved with a rejection.
+ * * `response`: interceptors get called with http `response` object. The function is free to
+ * modify the `response` object or create a new one. The function needs to return the `response`
+ * object directly, or as a promise containing the `response` or a new `response` object.
+ * * `responseError`: interceptor gets called when a previous interceptor threw an error or
+ * resolved with a rejection.
+ *
+ *
+ * ```js
+ * // register the interceptor as a service
+ * $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
+ * return {
+ * // optional method
+ * 'request': function(config) {
+ * // do something on success
+ * return config;
+ * },
+ *
+ * // optional method
+ * 'requestError': function(rejection) {
+ * // do something on error
+ * if (canRecover(rejection)) {
+ * return responseOrNewPromise
+ * }
+ * return $q.reject(rejection);
+ * },
+ *
+ *
+ *
+ * // optional method
+ * 'response': function(response) {
+ * // do something on success
+ * return response;
+ * },
+ *
+ * // optional method
+ * 'responseError': function(rejection) {
+ * // do something on error
+ * if (canRecover(rejection)) {
+ * return responseOrNewPromise
+ * }
+ * return $q.reject(rejection);
+ * }
+ * };
+ * });
+ *
+ * $httpProvider.interceptors.push('myHttpInterceptor');
+ *
+ *
+ * // alternatively, register the interceptor via an anonymous factory
+ * $httpProvider.interceptors.push(function($q, dependency1, dependency2) {
+ * return {
+ * 'request': function(config) {
+ * // same as above
+ * },
+ *
+ * 'response': function(response) {
+ * // same as above
+ * }
+ * };
+ * });
+ * ```
+ *
+ * ## Security Considerations
+ *
+ * When designing web applications, consider security threats from:
+ *
+ * - [JSON vulnerability](http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx)
+ * - [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery)
+ *
+ * Both server and the client must cooperate in order to eliminate these threats. AngularJS comes
+ * pre-configured with strategies that address these issues, but for this to work backend server
+ * cooperation is required.
+ *
+ * ### JSON Vulnerability Protection
+ *
+ * A [JSON vulnerability](http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx)
+ * allows third party website to turn your JSON resource URL into
+ * [JSONP](http://en.wikipedia.org/wiki/JSONP) request under some conditions. To
+ * counter this your server can prefix all JSON requests with following string `")]}',\n"`.
+ * AngularJS will automatically strip the prefix before processing it as JSON.
+ *
+ * For example if your server needs to return:
+ * ```js
+ * ['one','two']
+ * ```
+ *
+ * which is vulnerable to attack, your server can return:
+ * ```js
+ * )]}',
+ * ['one','two']
+ * ```
+ *
+ * AngularJS will strip the prefix, before processing the JSON.
+ *
+ *
+ * ### Cross Site Request Forgery (XSRF) Protection
+ *
+ * [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery) is an attack technique by
+ * which the attacker can trick an authenticated user into unknowingly executing actions on your
+ * website. AngularJS provides a mechanism to counter XSRF. When performing XHR requests, the
+ * $http service reads a token from a cookie (by default, `XSRF-TOKEN`) and sets it as an HTTP
+ * header (by default `X-XSRF-TOKEN`). Since only JavaScript that runs on your domain could read
+ * the cookie, your server can be assured that the XHR came from JavaScript running on your
+ * domain.
+ *
+ * To take advantage of this, your server needs to set a token in a JavaScript readable session
+ * cookie called `XSRF-TOKEN` on the first HTTP GET request. On subsequent XHR requests the
+ * server can verify that the cookie matches the `X-XSRF-TOKEN` HTTP header, and therefore be
+ * sure that only JavaScript running on your domain could have sent the request. The token must
+ * be unique for each user and must be verifiable by the server (to prevent the JavaScript from
+ * making up its own tokens). We recommend that the token is a digest of your site's
+ * authentication cookie with a [salt](https://en.wikipedia.org/wiki/Salt_(cryptography))
+ * for added security.
+ *
+ * The header will — by default — **not** be set for cross-domain requests. This
+ * prevents unauthorized servers (e.g. malicious or compromised 3rd-party APIs) from gaining
+ * access to your users' XSRF tokens and exposing them to Cross Site Request Forgery. If you
+ * want to, you can trust additional origins to also receive the XSRF token, by adding them
+ * to {@link ng.$httpProvider#xsrfTrustedOrigins xsrfTrustedOrigins}. This might be
+ * useful, for example, if your application, served from `example.com`, needs to access your API
+ * at `api.example.com`.
+ * See {@link ng.$httpProvider#xsrfTrustedOrigins $httpProvider.xsrfTrustedOrigins} for
+ * more details.
+ *
+ * <div class="alert alert-danger">
+ * **Warning**<br />
+ * Only trusted origins that you have control over and make sure you understand the
+ * implications of doing so.
+ * </div>
+ *
+ * The name of the cookie and the header can be specified using the `xsrfCookieName` and
+ * `xsrfHeaderName` properties of either `$httpProvider.defaults` at config-time,
+ * `$http.defaults` at run-time, or the per-request config object.
+ *
+ * In order to prevent collisions in environments where multiple AngularJS apps share the
+ * same domain or subdomain, we recommend that each application uses a unique cookie name.
+ *
+ *
+ * @param {object} config Object describing the request to be made and how it should be
+ * processed. The object has following properties:
+ *
+ * - **method** – `{string}` – HTTP method (e.g. 'GET', 'POST', etc)
+ * - **url** – `{string|TrustedObject}` – Absolute or relative URL of the resource that is being requested;
+ * or an object created by a call to `$sce.trustAsResourceUrl(url)`.
+ * - **params** – `{Object.<string|Object>}` – Map of strings or objects which will be serialized
+ * with the `paramSerializer` and appended as GET parameters.
+ * - **data** – `{string|Object}` – Data to be sent as the request message data.
+ * - **headers** – `{Object}` – Map of strings or functions which return strings representing
+ * HTTP headers to send to the server. If the return value of a function is null, the
+ * header will not be sent. Functions accept a config object as an argument.
+ * - **eventHandlers** - `{Object}` - Event listeners to be bound to the XMLHttpRequest object.
+ * To bind events to the XMLHttpRequest upload object, use `uploadEventHandlers`.
+ * The handler will be called in the context of a `$apply` block.
+ * - **uploadEventHandlers** - `{Object}` - Event listeners to be bound to the XMLHttpRequest upload
+ * object. To bind events to the XMLHttpRequest object, use `eventHandlers`.
+ * The handler will be called in the context of a `$apply` block.
+ * - **xsrfHeaderName** – `{string}` – Name of HTTP header to populate with the XSRF token.
+ * - **xsrfCookieName** – `{string}` – Name of cookie containing the XSRF token.
+ * - **transformRequest** –
+ * `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
+ * transform function or an array of such functions. The transform function takes the http
+ * request body and headers and returns its transformed (typically serialized) version.
+ * See {@link ng.$http#overriding-the-default-transformations-per-request
+ * Overriding the Default Transformations}
+ * - **transformResponse** –
+ * `{function(data, headersGetter, status)|Array.<function(data, headersGetter, status)>}` –
+ * transform function or an array of such functions. The transform function takes the http
+ * response body, headers and status and returns its transformed (typically deserialized) version.
+ * See {@link ng.$http#overriding-the-default-transformations-per-request
+ * Overriding the Default Transformations}
+ * - **paramSerializer** - `{string|function(Object<string,string>):string}` - A function used to
+ * prepare the string representation of request parameters (specified as an object).
+ * If specified as string, it is interpreted as function registered with the
+ * {@link $injector $injector}, which means you can create your own serializer
+ * by registering it as a {@link auto.$provide#service service}.
+ * The default serializer is the {@link $httpParamSerializer $httpParamSerializer};
+ * alternatively, you can use the {@link $httpParamSerializerJQLike $httpParamSerializerJQLike}
+ * - **cache** – `{boolean|Object}` – A boolean value or object created with
+ * {@link ng.$cacheFactory `$cacheFactory`} to enable or disable caching of the HTTP response.
+ * See {@link $http#caching $http Caching} for more information.
+ * - **timeout** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise}
+ * that should abort the request when resolved.
+ *
+ * A numerical timeout or a promise returned from {@link ng.$timeout $timeout}, will set
+ * the `xhrStatus` in the {@link $http#$http-returns response} to "timeout", and any other
+ * resolved promise will set it to "abort", following standard XMLHttpRequest behavior.
+ *
+ * - **withCredentials** - `{boolean}` - whether to set the `withCredentials` flag on the
+ * XHR object. See [requests with credentials](https://developer.mozilla.org/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials)
+ * for more information.
+ * - **responseType** - `{string}` - see
+ * [XMLHttpRequest.responseType](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#xmlhttprequest-responsetype).
+ *
+ * @returns {HttpPromise} A {@link ng.$q `Promise}` that will be resolved (request success)
+ * or rejected (request failure) with a response object.
+ *
+ * The response object has these properties:
+ *
+ * - **data** – `{string|Object}` – The response body transformed with
+ * the transform functions.
+ * - **status** – `{number}` – HTTP status code of the response.
+ * - **headers** – `{function([headerName])}` – Header getter function.
+ * - **config** – `{Object}` – The configuration object that was used
+ * to generate the request.
+ * - **statusText** – `{string}` – HTTP status text of the response.
+ * - **xhrStatus** – `{string}` – Status of the XMLHttpRequest
+ * (`complete`, `error`, `timeout` or `abort`).
+ *
+ *
+ * A response status code between 200 and 299 is considered a success status
+ * and will result in the success callback being called. Any response status
+ * code outside of that range is considered an error status and will result
+ * in the error callback being called.
+ * Also, status codes less than -1 are normalized to zero. -1 usually means
+ * the request was aborted, e.g. using a `config.timeout`. More information
+ * about the status might be available in the `xhrStatus` property.
+ *
+ * Note that if the response is a redirect, XMLHttpRequest will transparently
+ * follow it, meaning that the outcome (success or error) will be determined
+ * by the final response status code.
+ *
+ *
+ * @property {Array.<Object>} pendingRequests Array of config objects for currently pending
+ * requests. This is primarily meant to be used for debugging purposes.
+ *
+ *
+ * @example
+<example module="httpExample" name="http-service">
+<file name="index.html">
+ <div ng-controller="FetchController">
+ <select ng-model="method" aria-label="Request method">
+ <option>GET</option>
+ <option>JSONP</option>
+ </select>
+ <input type="text" ng-model="url" size="80" aria-label="URL" />
+ <button id="fetchbtn" ng-click="fetch()">fetch</button><br>
+ <button id="samplegetbtn" ng-click="updateModel('GET', 'http-hello.html')">Sample GET</button>
+ <button id="samplejsonpbtn"
+ ng-click="updateModel('JSONP',
+ 'https://angularjs.org/greet.php?name=Super%20Hero')">
+ Sample JSONP
+ </button>
+ <button id="invalidjsonpbtn"
+ ng-click="updateModel('JSONP', 'https://angularjs.org/doesntexist')">
+ Invalid JSONP
+ </button>
+ <pre>http status code: {{status}}</pre>
+ <pre>http response data: {{data}}</pre>
+ </div>
+</file>
+<file name="script.js">
+ angular.module('httpExample', [])
+ .config(['$sceDelegateProvider', function($sceDelegateProvider) {
+ // We must add the JSONP endpoint that we are using to the trusted list to show that we trust it
+ $sceDelegateProvider.trustedResourceUrlList([
+ 'self',
+ 'https://angularjs.org/**'
+ ]);
+ }])
+ .controller('FetchController', ['$scope', '$http', '$templateCache',
+ function($scope, $http, $templateCache) {
+ $scope.method = 'GET';
+ $scope.url = 'http-hello.html';
+
+ $scope.fetch = function() {
+ $scope.code = null;
+ $scope.response = null;
+
+ $http({method: $scope.method, url: $scope.url, cache: $templateCache}).
+ then(function(response) {
+ $scope.status = response.status;
+ $scope.data = response.data;
+ }, function(response) {
+ $scope.data = response.data || 'Request failed';
+ $scope.status = response.status;
+ });
+ };
+
+ $scope.updateModel = function(method, url) {
+ $scope.method = method;
+ $scope.url = url;
+ };
+ }]);
+</file>
+<file name="http-hello.html">
+ Hello, $http!
+</file>
+<file name="protractor.js" type="protractor">
+ var status = element(by.binding('status'));
+ var data = element(by.binding('data'));
+ var fetchBtn = element(by.id('fetchbtn'));
+ var sampleGetBtn = element(by.id('samplegetbtn'));
+ var invalidJsonpBtn = element(by.id('invalidjsonpbtn'));
+
+ it('should make an xhr GET request', function() {
+ sampleGetBtn.click();
+ fetchBtn.click();
+ expect(status.getText()).toMatch('200');
+ expect(data.getText()).toMatch(/Hello, \$http!/);
+ });
+
+// Commented out due to flakes. See https://github.com/angular/angular.js/issues/9185
+// it('should make a JSONP request to angularjs.org', function() {
+// var sampleJsonpBtn = element(by.id('samplejsonpbtn'));
+// sampleJsonpBtn.click();
+// fetchBtn.click();
+// expect(status.getText()).toMatch('200');
+// expect(data.getText()).toMatch(/Super Hero!/);
+// });
+
+ it('should make JSONP request to invalid URL and invoke the error handler',
+ function() {
+ invalidJsonpBtn.click();
+ fetchBtn.click();
+ expect(status.getText()).toMatch('0');
+ expect(data.getText()).toMatch('Request failed');
+ });
+</file>
+</example>
+ */
+ function $http(requestConfig) {
+
+ if (!isObject(requestConfig)) {
+ throw minErr('$http')('badreq', 'Http request configuration must be an object. Received: {0}', requestConfig);
+ }
+
+ if (!isString($sce.valueOf(requestConfig.url))) {
+ throw minErr('$http')('badreq', 'Http request configuration url must be a string or a $sce trusted object. Received: {0}', requestConfig.url);
+ }
+
+ var config = extend({
+ method: 'get',
+ transformRequest: defaults.transformRequest,
+ transformResponse: defaults.transformResponse,
+ paramSerializer: defaults.paramSerializer,
+ jsonpCallbackParam: defaults.jsonpCallbackParam
+ }, requestConfig);
+
+ config.headers = mergeHeaders(requestConfig);
+ config.method = uppercase(config.method);
+ config.paramSerializer = isString(config.paramSerializer) ?
+ $injector.get(config.paramSerializer) : config.paramSerializer;
+
+ $browser.$$incOutstandingRequestCount('$http');
+
+ var requestInterceptors = [];
+ var responseInterceptors = [];
+ var promise = $q.resolve(config);
+
+ // apply interceptors
+ forEach(reversedInterceptors, function(interceptor) {
+ if (interceptor.request || interceptor.requestError) {
+ requestInterceptors.unshift(interceptor.request, interceptor.requestError);
+ }
+ if (interceptor.response || interceptor.responseError) {
+ responseInterceptors.push(interceptor.response, interceptor.responseError);
+ }
+ });
+
+ promise = chainInterceptors(promise, requestInterceptors);
+ promise = promise.then(serverRequest);
+ promise = chainInterceptors(promise, responseInterceptors);
+ promise = promise.finally(completeOutstandingRequest);
+
+ return promise;
+
+
+ function chainInterceptors(promise, interceptors) {
+ for (var i = 0, ii = interceptors.length; i < ii;) {
+ var thenFn = interceptors[i++];
+ var rejectFn = interceptors[i++];
+
+ promise = promise.then(thenFn, rejectFn);
+ }
+
+ interceptors.length = 0;
+
+ return promise;
+ }
+
+ function completeOutstandingRequest() {
+ $browser.$$completeOutstandingRequest(noop, '$http');
+ }
+
+ function executeHeaderFns(headers, config) {
+ var headerContent, processedHeaders = {};
+
+ forEach(headers, function(headerFn, header) {
+ if (isFunction(headerFn)) {
+ headerContent = headerFn(config);
+ if (headerContent != null) {
+ processedHeaders[header] = headerContent;
+ }
+ } else {
+ processedHeaders[header] = headerFn;
+ }
+ });
+
+ return processedHeaders;
+ }
+
+ function mergeHeaders(config) {
+ var defHeaders = defaults.headers,
+ reqHeaders = extend({}, config.headers),
+ defHeaderName, lowercaseDefHeaderName, reqHeaderName;
+
+ defHeaders = extend({}, defHeaders.common, defHeaders[lowercase(config.method)]);
+
+ // using for-in instead of forEach to avoid unnecessary iteration after header has been found
+ defaultHeadersIteration:
+ for (defHeaderName in defHeaders) {
+ lowercaseDefHeaderName = lowercase(defHeaderName);
+
+ for (reqHeaderName in reqHeaders) {
+ if (lowercase(reqHeaderName) === lowercaseDefHeaderName) {
+ continue defaultHeadersIteration;
+ }
+ }
+
+ reqHeaders[defHeaderName] = defHeaders[defHeaderName];
+ }
+
+ // execute if header value is a function for merged headers
+ return executeHeaderFns(reqHeaders, shallowCopy(config));
+ }
+
+ function serverRequest(config) {
+ var headers = config.headers;
+ var reqData = transformData(config.data, headersGetter(headers), undefined, config.transformRequest);
+
+ // strip content-type if data is undefined
+ if (isUndefined(reqData)) {
+ forEach(headers, function(value, header) {
+ if (lowercase(header) === 'content-type') {
+ delete headers[header];
+ }
+ });
+ }
+
+ if (isUndefined(config.withCredentials) && !isUndefined(defaults.withCredentials)) {
+ config.withCredentials = defaults.withCredentials;
+ }
+
+ // send request
+ return sendReq(config, reqData).then(transformResponse, transformResponse);
+ }
+
+ function transformResponse(response) {
+ // make a copy since the response must be cacheable
+ var resp = extend({}, response);
+ resp.data = transformData(response.data, response.headers, response.status,
+ config.transformResponse);
+ return (isSuccess(response.status))
+ ? resp
+ : $q.reject(resp);
+ }
+ }
+
+ $http.pendingRequests = [];
+
+ /**
+ * @ngdoc method
+ * @name $http#get
+ *
+ * @description
+ * Shortcut method to perform `GET` request.
+ *
+ * @param {string|TrustedObject} url Absolute or relative URL of the resource that is being requested;
+ * or an object created by a call to `$sce.trustAsResourceUrl(url)`.
+ * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
+ * @returns {HttpPromise} A Promise that will be resolved or rejected with a response object.
+ * See {@link ng.$http#$http-returns `$http()` return value}.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $http#delete
+ *
+ * @description
+ * Shortcut method to perform `DELETE` request.
+ *
+ * @param {string|TrustedObject} url Absolute or relative URL of the resource that is being requested;
+ * or an object created by a call to `$sce.trustAsResourceUrl(url)`.
+ * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
+ * @returns {HttpPromise} A Promise that will be resolved or rejected with a response object.
+ * See {@link ng.$http#$http-returns `$http()` return value}.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $http#head
+ *
+ * @description
+ * Shortcut method to perform `HEAD` request.
+ *
+ * @param {string|TrustedObject} url Absolute or relative URL of the resource that is being requested;
+ * or an object created by a call to `$sce.trustAsResourceUrl(url)`.
+ * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
+ * @returns {HttpPromise} A Promise that will be resolved or rejected with a response object.
+ * See {@link ng.$http#$http-returns `$http()` return value}.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $http#jsonp
+ *
+ * @description
+ * Shortcut method to perform `JSONP` request.
+ *
+ * Note that, since JSONP requests are sensitive because the response is given full access to the browser,
+ * the url must be declared, via {@link $sce} as a trusted resource URL.
+ * You can trust a URL by adding it to the trusted resource URL list via
+ * {@link $sceDelegateProvider#trustedResourceUrlList `$sceDelegateProvider.trustedResourceUrlList`} or
+ * by explicitly trusting the URL via {@link $sce#trustAsResourceUrl `$sce.trustAsResourceUrl(url)`}.
+ *
+ * You should avoid generating the URL for the JSONP request from user provided data.
+ * Provide additional query parameters via `params` property of the `config` parameter, rather than
+ * modifying the URL itself.
+ *
+ * JSONP requests must specify a callback to be used in the response from the server. This callback
+ * is passed as a query parameter in the request. You must specify the name of this parameter by
+ * setting the `jsonpCallbackParam` property on the request config object.
+ *
+ * ```
+ * $http.jsonp('some/trusted/url', {jsonpCallbackParam: 'callback'})
+ * ```
+ *
+ * You can also specify a default callback parameter name in `$http.defaults.jsonpCallbackParam`.
+ * Initially this is set to `'callback'`.
+ *
+ * <div class="alert alert-danger">
+ * You can no longer use the `JSON_CALLBACK` string as a placeholder for specifying where the callback
+ * parameter value should go.
+ * </div>
+ *
+ * If you would like to customise where and how the callbacks are stored then try overriding
+ * or decorating the {@link $jsonpCallbacks} service.
+ *
+ * @param {string|TrustedObject} url Absolute or relative URL of the resource that is being requested;
+ * or an object created by a call to `$sce.trustAsResourceUrl(url)`.
+ * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
+ * @returns {HttpPromise} A Promise that will be resolved or rejected with a response object.
+ * See {@link ng.$http#$http-returns `$http()` return value}.
+ */
+ createShortMethods('get', 'delete', 'head', 'jsonp');
+
+ /**
+ * @ngdoc method
+ * @name $http#post
+ *
+ * @description
+ * Shortcut method to perform `POST` request.
+ *
+ * @param {string} url Relative or absolute URL specifying the destination of the request
+ * @param {*} data Request content
+ * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
+ * @returns {HttpPromise} A Promise that will be resolved or rejected with a response object.
+ * See {@link ng.$http#$http-returns `$http()` return value}.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $http#put
+ *
+ * @description
+ * Shortcut method to perform `PUT` request.
+ *
+ * @param {string} url Relative or absolute URL specifying the destination of the request
+ * @param {*} data Request content
+ * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
+ * @returns {HttpPromise} A Promise that will be resolved or rejected with a response object.
+ * See {@link ng.$http#$http-returns `$http()` return value}.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $http#patch
+ *
+ * @description
+ * Shortcut method to perform `PATCH` request.
+ *
+ * @param {string} url Relative or absolute URL specifying the destination of the request
+ * @param {*} data Request content
+ * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
+ * @returns {HttpPromise} A Promise that will be resolved or rejected with a response object.
+ * See {@link ng.$http#$http-returns `$http()` return value}.
+ */
+ createShortMethodsWithData('post', 'put', 'patch');
+
+ /**
+ * @ngdoc property
+ * @name $http#defaults
+ *
+ * @description
+ * Runtime equivalent of the `$httpProvider.defaults` property. Allows configuration of
+ * default headers, withCredentials as well as request and response transformations.
+ *
+ * See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
+ */
+ $http.defaults = defaults;
+
+
+ return $http;
+
+
+ function createShortMethods(names) {
+ forEach(arguments, function(name) {
+ $http[name] = function(url, config) {
+ return $http(extend({}, config || {}, {
+ method: name,
+ url: url
+ }));
+ };
+ });
+ }
+
+
+ function createShortMethodsWithData(name) {
+ forEach(arguments, function(name) {
+ $http[name] = function(url, data, config) {
+ return $http(extend({}, config || {}, {
+ method: name,
+ url: url,
+ data: data
+ }));
+ };
+ });
+ }
+
+
+ /**
+ * Makes the request.
+ *
+ * !!! ACCESSES CLOSURE VARS:
+ * $httpBackend, defaults, $log, $rootScope, defaultCache, $http.pendingRequests
+ */
+ function sendReq(config, reqData) {
+ var deferred = $q.defer(),
+ promise = deferred.promise,
+ cache,
+ cachedResp,
+ reqHeaders = config.headers,
+ isJsonp = lowercase(config.method) === 'jsonp',
+ url = config.url;
+
+ if (isJsonp) {
+ // JSONP is a pretty sensitive operation where we're allowing a script to have full access to
+ // our DOM and JS space. So we require that the URL satisfies SCE.RESOURCE_URL.
+ url = $sce.getTrustedResourceUrl(url);
+ } else if (!isString(url)) {
+ // If it is not a string then the URL must be a $sce trusted object
+ url = $sce.valueOf(url);
+ }
+
+ url = buildUrl(url, config.paramSerializer(config.params));
+
+ if (isJsonp) {
+ // Check the url and add the JSONP callback placeholder
+ url = sanitizeJsonpCallbackParam(url, config.jsonpCallbackParam);
+ }
+
+ $http.pendingRequests.push(config);
+ promise.then(removePendingReq, removePendingReq);
+
+ if ((config.cache || defaults.cache) && config.cache !== false &&
+ (config.method === 'GET' || config.method === 'JSONP')) {
+ cache = isObject(config.cache) ? config.cache
+ : isObject(/** @type {?} */ (defaults).cache)
+ ? /** @type {?} */ (defaults).cache
+ : defaultCache;
+ }
+
+ if (cache) {
+ cachedResp = cache.get(url);
+ if (isDefined(cachedResp)) {
+ if (isPromiseLike(cachedResp)) {
+ // cached request has already been sent, but there is no response yet
+ cachedResp.then(resolvePromiseWithResult, resolvePromiseWithResult);
+ } else {
+ // serving from cache
+ if (isArray(cachedResp)) {
+ resolvePromise(cachedResp[1], cachedResp[0], shallowCopy(cachedResp[2]), cachedResp[3], cachedResp[4]);
+ } else {
+ resolvePromise(cachedResp, 200, {}, 'OK', 'complete');
+ }
+ }
+ } else {
+ // put the promise for the non-transformed response into cache as a placeholder
+ cache.put(url, promise);
+ }
+ }
+
+
+ // if we won't have the response in cache, set the xsrf headers and
+ // send the request to the backend
+ if (isUndefined(cachedResp)) {
+ var xsrfValue = urlIsAllowedOrigin(config.url)
+ ? $$cookieReader()[config.xsrfCookieName || defaults.xsrfCookieName]
+ : undefined;
+ if (xsrfValue) {
+ reqHeaders[(config.xsrfHeaderName || defaults.xsrfHeaderName)] = xsrfValue;
+ }
+
+ $httpBackend(config.method, url, reqData, done, reqHeaders, config.timeout,
+ config.withCredentials, config.responseType,
+ createApplyHandlers(config.eventHandlers),
+ createApplyHandlers(config.uploadEventHandlers));
+ }
+
+ return promise;
+
+ function createApplyHandlers(eventHandlers) {
+ if (eventHandlers) {
+ var applyHandlers = {};
+ forEach(eventHandlers, function(eventHandler, key) {
+ applyHandlers[key] = function(event) {
+ if (useApplyAsync) {
+ $rootScope.$applyAsync(callEventHandler);
+ } else if ($rootScope.$$phase) {
+ callEventHandler();
+ } else {
+ $rootScope.$apply(callEventHandler);
+ }
+
+ function callEventHandler() {
+ eventHandler(event);
+ }
+ };
+ });
+ return applyHandlers;
+ }
+ }
+
+
+ /**
+ * Callback registered to $httpBackend():
+ * - caches the response if desired
+ * - resolves the raw $http promise
+ * - calls $apply
+ */
+ function done(status, response, headersString, statusText, xhrStatus) {
+ if (cache) {
+ if (isSuccess(status)) {
+ cache.put(url, [status, response, parseHeaders(headersString), statusText, xhrStatus]);
+ } else {
+ // remove promise from the cache
+ cache.remove(url);
+ }
+ }
+
+ function resolveHttpPromise() {
+ resolvePromise(response, status, headersString, statusText, xhrStatus);
+ }
+
+ if (useApplyAsync) {
+ $rootScope.$applyAsync(resolveHttpPromise);
+ } else {
+ resolveHttpPromise();
+ if (!$rootScope.$$phase) $rootScope.$apply();
+ }
+ }
+
+
+ /**
+ * Resolves the raw $http promise.
+ */
+ function resolvePromise(response, status, headers, statusText, xhrStatus) {
+ //status: HTTP response status code, 0, -1 (aborted by timeout / promise)
+ status = status >= -1 ? status : 0;
+
+ (isSuccess(status) ? deferred.resolve : deferred.reject)({
+ data: response,
+ status: status,
+ headers: headersGetter(headers),
+ config: config,
+ statusText: statusText,
+ xhrStatus: xhrStatus
+ });
+ }
+
+ function resolvePromiseWithResult(result) {
+ resolvePromise(result.data, result.status, shallowCopy(result.headers()), result.statusText, result.xhrStatus);
+ }
+
+ function removePendingReq() {
+ var idx = $http.pendingRequests.indexOf(config);
+ if (idx !== -1) $http.pendingRequests.splice(idx, 1);
+ }
+ }
+
+
+ function buildUrl(url, serializedParams) {
+ if (serializedParams.length > 0) {
+ url += ((url.indexOf('?') === -1) ? '?' : '&') + serializedParams;
+ }
+ return url;
+ }
+
+ function sanitizeJsonpCallbackParam(url, cbKey) {
+ var parts = url.split('?');
+ if (parts.length > 2) {
+ // Throw if the url contains more than one `?` query indicator
+ throw $httpMinErr('badjsonp', 'Illegal use more than one "?", in url, "{1}"', url);
+ }
+ var params = parseKeyValue(parts[1]);
+ forEach(params, function(value, key) {
+ if (value === 'JSON_CALLBACK') {
+ // Throw if the url already contains a reference to JSON_CALLBACK
+ throw $httpMinErr('badjsonp', 'Illegal use of JSON_CALLBACK in url, "{0}"', url);
+ }
+ if (key === cbKey) {
+ // Throw if the callback param was already provided
+ throw $httpMinErr('badjsonp', 'Illegal use of callback param, "{0}", in url, "{1}"', cbKey, url);
+ }
+ });
+
+ // Add in the JSON_CALLBACK callback param value
+ url += ((url.indexOf('?') === -1) ? '?' : '&') + cbKey + '=JSON_CALLBACK';
+
+ return url;
+ }
+ }];
+}
+
+/**
+ * @ngdoc service
+ * @name $xhrFactory
+ * @this
+ *
+ * @description
+ * Factory function used to create XMLHttpRequest objects.
+ *
+ * Replace or decorate this service to create your own custom XMLHttpRequest objects.
+ *
+ * ```
+ * angular.module('myApp', [])
+ * .factory('$xhrFactory', function() {
+ * return function createXhr(method, url) {
+ * return new window.XMLHttpRequest({mozSystem: true});
+ * };
+ * });
+ * ```
+ *
+ * @param {string} method HTTP method of the request (GET, POST, PUT, ..)
+ * @param {string} url URL of the request.
+ */
+function $xhrFactoryProvider() {
+ this.$get = function() {
+ return function createXhr() {
+ return new window.XMLHttpRequest();
+ };
+ };
+}
+
+/**
+ * @ngdoc service
+ * @name $httpBackend
+ * @requires $jsonpCallbacks
+ * @requires $document
+ * @requires $xhrFactory
+ * @this
+ *
+ * @description
+ * HTTP backend used by the {@link ng.$http service} that delegates to
+ * XMLHttpRequest object or JSONP and deals with browser incompatibilities.
+ *
+ * You should never need to use this service directly, instead use the higher-level abstractions:
+ * {@link ng.$http $http} or {@link ngResource.$resource $resource}.
+ *
+ * During testing this implementation is swapped with {@link ngMock.$httpBackend mock
+ * $httpBackend} which can be trained with responses.
+ */
+function $HttpBackendProvider() {
+ this.$get = ['$browser', '$jsonpCallbacks', '$document', '$xhrFactory', function($browser, $jsonpCallbacks, $document, $xhrFactory) {
+ return createHttpBackend($browser, $xhrFactory, $browser.defer, $jsonpCallbacks, $document[0]);
+ }];
+}
+
+function createHttpBackend($browser, createXhr, $browserDefer, callbacks, rawDocument) {
+ // TODO(vojta): fix the signature
+ return function(method, url, post, callback, headers, timeout, withCredentials, responseType, eventHandlers, uploadEventHandlers) {
+ url = url || $browser.url();
+
+ if (lowercase(method) === 'jsonp') {
+ var callbackPath = callbacks.createCallback(url);
+ var jsonpDone = jsonpReq(url, callbackPath, function(status, text) {
+ // jsonpReq only ever sets status to 200 (OK), 404 (ERROR) or -1 (WAITING)
+ var response = (status === 200) && callbacks.getResponse(callbackPath);
+ completeRequest(callback, status, response, '', text, 'complete');
+ callbacks.removeCallback(callbackPath);
+ });
+ } else {
+
+ var xhr = createXhr(method, url);
+ var abortedByTimeout = false;
+
+ xhr.open(method, url, true);
+ forEach(headers, function(value, key) {
+ if (isDefined(value)) {
+ xhr.setRequestHeader(key, value);
+ }
+ });
+
+ xhr.onload = function requestLoaded() {
+ var statusText = xhr.statusText || '';
+
+ // responseText is the old-school way of retrieving response (supported by IE9)
+ // response/responseType properties were introduced in XHR Level2 spec (supported by IE10)
+ var response = ('response' in xhr) ? xhr.response : xhr.responseText;
+
+ // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
+ var status = xhr.status === 1223 ? 204 : xhr.status;
+
+ // fix status code when it is 0 (0 status is undocumented).
+ // Occurs when accessing file resources or on Android 4.1 stock browser
+ // while retrieving files from application cache.
+ if (status === 0) {
+ status = response ? 200 : urlResolve(url).protocol === 'file' ? 404 : 0;
+ }
+
+ completeRequest(callback,
+ status,
+ response,
+ xhr.getAllResponseHeaders(),
+ statusText,
+ 'complete');
+ };
+
+ var requestError = function() {
+ // The response is always empty
+ // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error
+ completeRequest(callback, -1, null, null, '', 'error');
+ };
+
+ var requestAborted = function() {
+ completeRequest(callback, -1, null, null, '', abortedByTimeout ? 'timeout' : 'abort');
+ };
+
+ var requestTimeout = function() {
+ // The response is always empty
+ // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error
+ completeRequest(callback, -1, null, null, '', 'timeout');
+ };
+
+ xhr.onerror = requestError;
+ xhr.ontimeout = requestTimeout;
+ xhr.onabort = requestAborted;
+
+ forEach(eventHandlers, function(value, key) {
+ xhr.addEventListener(key, value);
+ });
+
+ forEach(uploadEventHandlers, function(value, key) {
+ xhr.upload.addEventListener(key, value);
+ });
+
+ if (withCredentials) {
+ xhr.withCredentials = true;
+ }
+
+ if (responseType) {
+ try {
+ xhr.responseType = responseType;
+ } catch (e) {
+ // WebKit added support for the json responseType value on 09/03/2013
+ // https://bugs.webkit.org/show_bug.cgi?id=73648. Versions of Safari prior to 7 are
+ // known to throw when setting the value "json" as the response type. Other older
+ // browsers implementing the responseType
+ //
+ // The json response type can be ignored if not supported, because JSON payloads are
+ // parsed on the client-side regardless.
+ if (responseType !== 'json') {
+ throw e;
+ }
+ }
+ }
+
+ xhr.send(isUndefined(post) ? null : post);
+ }
+
+ // Since we are using xhr.abort() when a request times out, we have to set a flag that
+ // indicates to requestAborted if the request timed out or was aborted.
+ //
+ // http.timeout = numerical timeout timeout
+ // http.timeout = $timeout timeout
+ // http.timeout = promise abort
+ // xhr.abort() abort (The xhr object is normally inaccessible, but
+ // can be exposed with the xhrFactory)
+ if (timeout > 0) {
+ var timeoutId = $browserDefer(function() {
+ timeoutRequest('timeout');
+ }, timeout);
+ } else if (isPromiseLike(timeout)) {
+ timeout.then(function() {
+ timeoutRequest(isDefined(timeout.$$timeoutId) ? 'timeout' : 'abort');
+ });
+ }
+
+ function timeoutRequest(reason) {
+ abortedByTimeout = reason === 'timeout';
+ if (jsonpDone) {
+ jsonpDone();
+ }
+ if (xhr) {
+ xhr.abort();
+ }
+ }
+
+ function completeRequest(callback, status, response, headersString, statusText, xhrStatus) {
+ // cancel timeout and subsequent timeout promise resolution
+ if (isDefined(timeoutId)) {
+ $browserDefer.cancel(timeoutId);
+ }
+ jsonpDone = xhr = null;
+
+ callback(status, response, headersString, statusText, xhrStatus);
+ }
+ };
+
+ function jsonpReq(url, callbackPath, done) {
+ url = url.replace('JSON_CALLBACK', callbackPath);
+ // we can't use jQuery/jqLite here because jQuery does crazy stuff with script elements, e.g.:
+ // - fetches local scripts via XHR and evals them
+ // - adds and immediately removes script elements from the document
+ var script = rawDocument.createElement('script'), callback = null;
+ script.type = 'text/javascript';
+ script.src = url;
+ script.async = true;
+
+ callback = function(event) {
+ script.removeEventListener('load', callback);
+ script.removeEventListener('error', callback);
+ rawDocument.body.removeChild(script);
+ script = null;
+ var status = -1;
+ var text = 'unknown';
+
+ if (event) {
+ if (event.type === 'load' && !callbacks.wasCalled(callbackPath)) {
+ event = { type: 'error' };
+ }
+ text = event.type;
+ status = event.type === 'error' ? 404 : 200;
+ }
+
+ if (done) {
+ done(status, text);
+ }
+ };
+
+ script.addEventListener('load', callback);
+ script.addEventListener('error', callback);
+ rawDocument.body.appendChild(script);
+ return callback;
+ }
+}
+
+var $interpolateMinErr = angular.$interpolateMinErr = minErr('$interpolate');
+$interpolateMinErr.throwNoconcat = function(text) {
+ throw $interpolateMinErr('noconcat',
+ 'Error while interpolating: {0}\nStrict Contextual Escaping disallows ' +
+ 'interpolations that concatenate multiple expressions when a trusted value is ' +
+ 'required. See http://docs.angularjs.org/api/ng.$sce', text);
+};
+
+$interpolateMinErr.interr = function(text, err) {
+ return $interpolateMinErr('interr', 'Can\'t interpolate: {0}\n{1}', text, err.toString());
+};
+
+/**
+ * @ngdoc provider
+ * @name $interpolateProvider
+ * @this
+ *
+ * @description
+ *
+ * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
+ *
+ * <div class="alert alert-danger">
+ * This feature is sometimes used to mix different markup languages, e.g. to wrap an AngularJS
+ * template within a Python Jinja template (or any other template language). Mixing templating
+ * languages is **very dangerous**. The embedding template language will not safely escape AngularJS
+ * expressions, so any user-controlled values in the template will cause Cross Site Scripting (XSS)
+ * security bugs!
+ * </div>
+ *
+ * @example
+<example name="custom-interpolation-markup" module="customInterpolationApp">
+<file name="index.html">
+<script>
+ var customInterpolationApp = angular.module('customInterpolationApp', []);
+
+ customInterpolationApp.config(function($interpolateProvider) {
+ $interpolateProvider.startSymbol('//');
+ $interpolateProvider.endSymbol('//');
+ });
+
+
+ customInterpolationApp.controller('DemoController', function() {
+ this.label = "This binding is brought you by // interpolation symbols.";
+ });
+</script>
+<div ng-controller="DemoController as demo">
+ //demo.label//
+</div>
+</file>
+<file name="protractor.js" type="protractor">
+ it('should interpolate binding with custom symbols', function() {
+ expect(element(by.binding('demo.label')).getText()).toBe('This binding is brought you by // interpolation symbols.');
+ });
+</file>
+</example>
+ */
+function $InterpolateProvider() {
+ var startSymbol = '{{';
+ var endSymbol = '}}';
+
+ /**
+ * @ngdoc method
+ * @name $interpolateProvider#startSymbol
+ * @description
+ * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
+ *
+ * @param {string=} value new value to set the starting symbol to.
+ * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+ */
+ this.startSymbol = function(value) {
+ if (value) {
+ startSymbol = value;
+ return this;
+ }
+ return startSymbol;
+ };
+
+ /**
+ * @ngdoc method
+ * @name $interpolateProvider#endSymbol
+ * @description
+ * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
+ *
+ * @param {string=} value new value to set the ending symbol to.
+ * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+ */
+ this.endSymbol = function(value) {
+ if (value) {
+ endSymbol = value;
+ return this;
+ }
+ return endSymbol;
+ };
+
+
+ this.$get = ['$parse', '$exceptionHandler', '$sce', function($parse, $exceptionHandler, $sce) {
+ var startSymbolLength = startSymbol.length,
+ endSymbolLength = endSymbol.length,
+ escapedStartRegexp = new RegExp(startSymbol.replace(/./g, escape), 'g'),
+ escapedEndRegexp = new RegExp(endSymbol.replace(/./g, escape), 'g');
+
+ function escape(ch) {
+ return '\\\\\\' + ch;
+ }
+
+ function unescapeText(text) {
+ return text.replace(escapedStartRegexp, startSymbol).
+ replace(escapedEndRegexp, endSymbol);
+ }
+
+ // TODO: this is the same as the constantWatchDelegate in parse.js
+ function constantWatchDelegate(scope, listener, objectEquality, constantInterp) {
+ var unwatch = scope.$watch(function constantInterpolateWatch(scope) {
+ unwatch();
+ return constantInterp(scope);
+ }, listener, objectEquality);
+ return unwatch;
+ }
+
+ /**
+ * @ngdoc service
+ * @name $interpolate
+ * @kind function
+ *
+ * @requires $parse
+ * @requires $sce
+ *
+ * @description
+ *
+ * Compiles a string with markup into an interpolation function. This service is used by the
+ * HTML {@link ng.$compile $compile} service for data binding. See
+ * {@link ng.$interpolateProvider $interpolateProvider} for configuring the
+ * interpolation markup.
+ *
+ *
+ * ```js
+ * var $interpolate = ...; // injected
+ * var exp = $interpolate('Hello {{name | uppercase}}!');
+ * expect(exp({name:'AngularJS'})).toEqual('Hello ANGULARJS!');
+ * ```
+ *
+ * `$interpolate` takes an optional fourth argument, `allOrNothing`. If `allOrNothing` is
+ * `true`, the interpolation function will return `undefined` unless all embedded expressions
+ * evaluate to a value other than `undefined`.
+ *
+ * ```js
+ * var $interpolate = ...; // injected
+ * var context = {greeting: 'Hello', name: undefined };
+ *
+ * // default "forgiving" mode
+ * var exp = $interpolate('{{greeting}} {{name}}!');
+ * expect(exp(context)).toEqual('Hello !');
+ *
+ * // "allOrNothing" mode
+ * exp = $interpolate('{{greeting}} {{name}}!', false, null, true);
+ * expect(exp(context)).toBeUndefined();
+ * context.name = 'AngularJS';
+ * expect(exp(context)).toEqual('Hello AngularJS!');
+ * ```
+ *
+ * `allOrNothing` is useful for interpolating URLs. `ngSrc` and `ngSrcset` use this behavior.
+ *
+ * #### Escaped Interpolation
+ * $interpolate provides a mechanism for escaping interpolation markers. Start and end markers
+ * can be escaped by preceding each of their characters with a REVERSE SOLIDUS U+005C (backslash).
+ * It will be rendered as a regular start/end marker, and will not be interpreted as an expression
+ * or binding.
+ *
+ * This enables web-servers to prevent script injection attacks and defacing attacks, to some
+ * degree, while also enabling code examples to work without relying on the
+ * {@link ng.directive:ngNonBindable ngNonBindable} directive.
+ *
+ * **For security purposes, it is strongly encouraged that web servers escape user-supplied data,
+ * replacing angle brackets (<, >) with &lt; and &gt; respectively, and replacing all
+ * interpolation start/end markers with their escaped counterparts.**
+ *
+ * Escaped interpolation markers are only replaced with the actual interpolation markers in rendered
+ * output when the $interpolate service processes the text. So, for HTML elements interpolated
+ * by {@link ng.$compile $compile}, or otherwise interpolated with the `mustHaveExpression` parameter
+ * set to `true`, the interpolated text must contain an unescaped interpolation expression. As such,
+ * this is typically useful only when user-data is used in rendering a template from the server, or
+ * when otherwise untrusted data is used by a directive.
+ *
+ * <example name="interpolation">
+ * <file name="index.html">
+ * <div ng-init="username='A user'">
+ * <p ng-init="apptitle='Escaping demo'">{{apptitle}}: \{\{ username = "defaced value"; \}\}
+ * </p>
+ * <p><strong>{{username}}</strong> attempts to inject code which will deface the
+ * application, but fails to accomplish their task, because the server has correctly
+ * escaped the interpolation start/end markers with REVERSE SOLIDUS U+005C (backslash)
+ * characters.</p>
+ * <p>Instead, the result of the attempted script injection is visible, and can be removed
+ * from the database by an administrator.</p>
+ * </div>
+ * </file>
+ * </example>
+ *
+ * @knownIssue
+ * It is currently not possible for an interpolated expression to contain the interpolation end
+ * symbol. For example, `{{ '}}' }}` will be incorrectly interpreted as `{{ ' }}` + `' }}`, i.e.
+ * an interpolated expression consisting of a single-quote (`'`) and the `' }}` string.
+ *
+ * @knownIssue
+ * All directives and components must use the standard `{{` `}}` interpolation symbols
+ * in their templates. If you change the application interpolation symbols the {@link $compile}
+ * service will attempt to denormalize the standard symbols to the custom symbols.
+ * The denormalization process is not clever enough to know not to replace instances of the standard
+ * symbols where they would not normally be treated as interpolation symbols. For example in the following
+ * code snippet the closing braces of the literal object will get incorrectly denormalized:
+ *
+ * ```
+ * <div data-context='{"context":{"id":3,"type":"page"}}">
+ * ```
+ *
+ * The workaround is to ensure that such instances are separated by whitespace:
+ * ```
+ * <div data-context='{"context":{"id":3,"type":"page"} }">
+ * ```
+ *
+ * See https://github.com/angular/angular.js/pull/14610#issuecomment-219401099 for more information.
+ *
+ * @param {string} text The text with markup to interpolate.
+ * @param {boolean=} mustHaveExpression if set to true then the interpolation string must have
+ * embedded expression in order to return an interpolation function. Strings with no
+ * embedded expression will return null for the interpolation function.
+ * @param {string=} trustedContext when provided, the returned function passes the interpolated
+ * result through {@link ng.$sce#getTrusted $sce.getTrusted(interpolatedResult,
+ * trustedContext)} before returning it. Refer to the {@link ng.$sce $sce} service that
+ * provides Strict Contextual Escaping for details.
+ * @param {boolean=} allOrNothing if `true`, then the returned function returns undefined
+ * unless all embedded expressions evaluate to a value other than `undefined`.
+ * @returns {function(context)} an interpolation function which is used to compute the
+ * interpolated string. The function has these parameters:
+ *
+ * - `context`: evaluation context for all expressions embedded in the interpolated text
+ */
+ function $interpolate(text, mustHaveExpression, trustedContext, allOrNothing) {
+ var contextAllowsConcatenation = trustedContext === $sce.URL || trustedContext === $sce.MEDIA_URL;
+
+ // Provide a quick exit and simplified result function for text with no interpolation
+ if (!text.length || text.indexOf(startSymbol) === -1) {
+ if (mustHaveExpression) return;
+
+ var unescapedText = unescapeText(text);
+ if (contextAllowsConcatenation) {
+ unescapedText = $sce.getTrusted(trustedContext, unescapedText);
+ }
+ var constantInterp = valueFn(unescapedText);
+ constantInterp.exp = text;
+ constantInterp.expressions = [];
+ constantInterp.$$watchDelegate = constantWatchDelegate;
+
+ return constantInterp;
+ }
+
+ allOrNothing = !!allOrNothing;
+ var startIndex,
+ endIndex,
+ index = 0,
+ expressions = [],
+ parseFns,
+ textLength = text.length,
+ exp,
+ concat = [],
+ expressionPositions = [],
+ singleExpression;
+
+
+ while (index < textLength) {
+ if (((startIndex = text.indexOf(startSymbol, index)) !== -1) &&
+ ((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) !== -1)) {
+ if (index !== startIndex) {
+ concat.push(unescapeText(text.substring(index, startIndex)));
+ }
+ exp = text.substring(startIndex + startSymbolLength, endIndex);
+ expressions.push(exp);
+ index = endIndex + endSymbolLength;
+ expressionPositions.push(concat.length);
+ concat.push(''); // Placeholder that will get replaced with the evaluated expression.
+ } else {
+ // we did not find an interpolation, so we have to add the remainder to the separators array
+ if (index !== textLength) {
+ concat.push(unescapeText(text.substring(index)));
+ }
+ break;
+ }
+ }
+
+ singleExpression = concat.length === 1 && expressionPositions.length === 1;
+ // Intercept expression if we need to stringify concatenated inputs, which may be SCE trusted
+ // objects rather than simple strings
+ // (we don't modify the expression if the input consists of only a single trusted input)
+ var interceptor = contextAllowsConcatenation && singleExpression ? undefined : parseStringifyInterceptor;
+ parseFns = expressions.map(function(exp) { return $parse(exp, interceptor); });
+
+ // Concatenating expressions makes it hard to reason about whether some combination of
+ // concatenated values are unsafe to use and could easily lead to XSS. By requiring that a
+ // single expression be used for some $sce-managed secure contexts (RESOURCE_URLs mostly),
+ // we ensure that the value that's used is assigned or constructed by some JS code somewhere
+ // that is more testable or make it obvious that you bound the value to some user controlled
+ // value. This helps reduce the load when auditing for XSS issues.
+
+ // Note that URL and MEDIA_URL $sce contexts do not need this, since `$sce` can sanitize the values
+ // passed to it. In that case, `$sce.getTrusted` will be called on either the single expression
+ // or on the overall concatenated string (losing trusted types used in the mix, by design).
+ // Both these methods will sanitize plain strings. Also, HTML could be included, but since it's
+ // only used in srcdoc attributes, this would not be very useful.
+
+ if (!mustHaveExpression || expressions.length) {
+ var compute = function(values) {
+ for (var i = 0, ii = expressions.length; i < ii; i++) {
+ if (allOrNothing && isUndefined(values[i])) return;
+ concat[expressionPositions[i]] = values[i];
+ }
+
+ if (contextAllowsConcatenation) {
+ // If `singleExpression` then `concat[0]` might be a "trusted" value or `null`, rather than a string
+ return $sce.getTrusted(trustedContext, singleExpression ? concat[0] : concat.join(''));
+ } else if (trustedContext && concat.length > 1) {
+ // This context does not allow more than one part, e.g. expr + string or exp + exp.
+ $interpolateMinErr.throwNoconcat(text);
+ }
+ // In an unprivileged context or only one part: just concatenate and return.
+ return concat.join('');
+ };
+
+ return extend(function interpolationFn(context) {
+ var i = 0;
+ var ii = expressions.length;
+ var values = new Array(ii);
+
+ try {
+ for (; i < ii; i++) {
+ values[i] = parseFns[i](context);
+ }
+
+ return compute(values);
+ } catch (err) {
+ $exceptionHandler($interpolateMinErr.interr(text, err));
+ }
+
+ }, {
+ // all of these properties are undocumented for now
+ exp: text, //just for compatibility with regular watchers created via $watch
+ expressions: expressions,
+ $$watchDelegate: function(scope, listener) {
+ var lastValue;
+ return scope.$watchGroup(parseFns, /** @this */ function interpolateFnWatcher(values, oldValues) {
+ var currValue = compute(values);
+ listener.call(this, currValue, values !== oldValues ? lastValue : currValue, scope);
+ lastValue = currValue;
+ });
+ }
+ });
+ }
+
+ function parseStringifyInterceptor(value) {
+ try {
+ // In concatenable contexts, getTrusted comes at the end, to avoid sanitizing individual
+ // parts of a full URL. We don't care about losing the trustedness here.
+ // In non-concatenable contexts, where there is only one expression, this interceptor is
+ // not applied to the expression.
+ value = (trustedContext && !contextAllowsConcatenation) ?
+ $sce.getTrusted(trustedContext, value) :
+ $sce.valueOf(value);
+ return allOrNothing && !isDefined(value) ? value : stringify(value);
+ } catch (err) {
+ $exceptionHandler($interpolateMinErr.interr(text, err));
+ }
+ }
+ }
+
+
+ /**
+ * @ngdoc method
+ * @name $interpolate#startSymbol
+ * @description
+ * Symbol to denote the start of expression in the interpolated string. Defaults to `{{`.
+ *
+ * Use {@link ng.$interpolateProvider#startSymbol `$interpolateProvider.startSymbol`} to change
+ * the symbol.
+ *
+ * @returns {string} start symbol.
+ */
+ $interpolate.startSymbol = function() {
+ return startSymbol;
+ };
+
+
+ /**
+ * @ngdoc method
+ * @name $interpolate#endSymbol
+ * @description
+ * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
+ *
+ * Use {@link ng.$interpolateProvider#endSymbol `$interpolateProvider.endSymbol`} to change
+ * the symbol.
+ *
+ * @returns {string} end symbol.
+ */
+ $interpolate.endSymbol = function() {
+ return endSymbol;
+ };
+
+ return $interpolate;
+ }];
+}
+
+var $intervalMinErr = minErr('$interval');
+
+/** @this */
+function $IntervalProvider() {
+ this.$get = ['$$intervalFactory', '$window',
+ function($$intervalFactory, $window) {
+ var intervals = {};
+ var setIntervalFn = function(tick, delay, deferred) {
+ var id = $window.setInterval(tick, delay);
+ intervals[id] = deferred;
+ return id;
+ };
+ var clearIntervalFn = function(id) {
+ $window.clearInterval(id);
+ delete intervals[id];
+ };
+
+ /**
+ * @ngdoc service
+ * @name $interval
+ *
+ * @description
+ * AngularJS's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
+ * milliseconds.
+ *
+ * The return value of registering an interval function is a promise. This promise will be
+ * notified upon each tick of the interval, and will be resolved after `count` iterations, or
+ * run indefinitely if `count` is not defined. The value of the notification will be the
+ * number of iterations that have run.
+ * To cancel an interval, call `$interval.cancel(promise)`.
+ *
+ * In tests you can use {@link ngMock.$interval#flush `$interval.flush(millis)`} to
+ * move forward by `millis` milliseconds and trigger any functions scheduled to run in that
+ * time.
+ *
+ * <div class="alert alert-warning">
+ * **Note**: Intervals created by this service must be explicitly destroyed when you are finished
+ * with them. In particular they are not automatically destroyed when a controller's scope or a
+ * directive's element are destroyed.
+ * You should take this into consideration and make sure to always cancel the interval at the
+ * appropriate moment. See the example below for more details on how and when to do this.
+ * </div>
+ *
+ * @param {function()} fn A function that should be called repeatedly. If no additional arguments
+ * are passed (see below), the function is called with the current iteration count.
+ * @param {number} delay Number of milliseconds between each function call.
+ * @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
+ * indefinitely.
+ * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
+ * will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
+ * @param {...*=} Pass additional parameters to the executed function.
+ * @returns {promise} A promise which will be notified on each iteration. It will resolve once all iterations of the interval complete.
+ *
+ * @example
+ * <example module="intervalExample" name="interval-service">
+ * <file name="index.html">
+ * <script>
+ * angular.module('intervalExample', [])
+ * .controller('ExampleController', ['$scope', '$interval',
+ * function($scope, $interval) {
+ * $scope.format = 'M/d/yy h:mm:ss a';
+ * $scope.blood_1 = 100;
+ * $scope.blood_2 = 120;
+ *
+ * var stop;
+ * $scope.fight = function() {
+ * // Don't start a new fight if we are already fighting
+ * if ( angular.isDefined(stop) ) return;
+ *
+ * stop = $interval(function() {
+ * if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
+ * $scope.blood_1 = $scope.blood_1 - 3;
+ * $scope.blood_2 = $scope.blood_2 - 4;
+ * } else {
+ * $scope.stopFight();
+ * }
+ * }, 100);
+ * };
+ *
+ * $scope.stopFight = function() {
+ * if (angular.isDefined(stop)) {
+ * $interval.cancel(stop);
+ * stop = undefined;
+ * }
+ * };
+ *
+ * $scope.resetFight = function() {
+ * $scope.blood_1 = 100;
+ * $scope.blood_2 = 120;
+ * };
+ *
+ * $scope.$on('$destroy', function() {
+ * // Make sure that the interval is destroyed too
+ * $scope.stopFight();
+ * });
+ * }])
+ * // Register the 'myCurrentTime' directive factory method.
+ * // We inject $interval and dateFilter service since the factory method is DI.
+ * .directive('myCurrentTime', ['$interval', 'dateFilter',
+ * function($interval, dateFilter) {
+ * // return the directive link function. (compile function not needed)
+ * return function(scope, element, attrs) {
+ * var format, // date format
+ * stopTime; // so that we can cancel the time updates
+ *
+ * // used to update the UI
+ * function updateTime() {
+ * element.text(dateFilter(new Date(), format));
+ * }
+ *
+ * // watch the expression, and update the UI on change.
+ * scope.$watch(attrs.myCurrentTime, function(value) {
+ * format = value;
+ * updateTime();
+ * });
+ *
+ * stopTime = $interval(updateTime, 1000);
+ *
+ * // listen on DOM destroy (removal) event, and cancel the next UI update
+ * // to prevent updating time after the DOM element was removed.
+ * element.on('$destroy', function() {
+ * $interval.cancel(stopTime);
+ * });
+ * }
+ * }]);
+ * </script>
+ *
+ * <div>
+ * <div ng-controller="ExampleController">
+ * <label>Date format: <input ng-model="format"></label> <hr/>
+ * Current time is: <span my-current-time="format"></span>
+ * <hr/>
+ * Blood 1 : <font color='red'>{{blood_1}}</font>
+ * Blood 2 : <font color='red'>{{blood_2}}</font>
+ * <button type="button" data-ng-click="fight()">Fight</button>
+ * <button type="button" data-ng-click="stopFight()">StopFight</button>
+ * <button type="button" data-ng-click="resetFight()">resetFight</button>
+ * </div>
+ * </div>
+ *
+ * </file>
+ * </example>
+ */
+ var interval = $$intervalFactory(setIntervalFn, clearIntervalFn);
+
+ /**
+ * @ngdoc method
+ * @name $interval#cancel
+ *
+ * @description
+ * Cancels a task associated with the `promise`.
+ *
+ * @param {Promise=} promise returned by the `$interval` function.
+ * @returns {boolean} Returns `true` if the task was successfully canceled.
+ */
+ interval.cancel = function(promise) {
+ if (!promise) return false;
+
+ if (!promise.hasOwnProperty('$$intervalId')) {
+ throw $intervalMinErr('badprom',
+ '`$interval.cancel()` called with a promise that was not generated by `$interval()`.');
+ }
+
+ if (!intervals.hasOwnProperty(promise.$$intervalId)) return false;
+
+ var id = promise.$$intervalId;
+ var deferred = intervals[id];
+
+ // Interval cancels should not report an unhandled promise.
+ markQExceptionHandled(deferred.promise);
+ deferred.reject('canceled');
+ clearIntervalFn(id);
+
+ return true;
+ };
+
+ return interval;
+ }];
+}
+
+/** @this */
+function $$IntervalFactoryProvider() {
+ this.$get = ['$browser', '$q', '$$q', '$rootScope',
+ function($browser, $q, $$q, $rootScope) {
+ return function intervalFactory(setIntervalFn, clearIntervalFn) {
+ return function intervalFn(fn, delay, count, invokeApply) {
+ var hasParams = arguments.length > 4,
+ args = hasParams ? sliceArgs(arguments, 4) : [],
+ iteration = 0,
+ skipApply = isDefined(invokeApply) && !invokeApply,
+ deferred = (skipApply ? $$q : $q).defer(),
+ promise = deferred.promise;
+
+ count = isDefined(count) ? count : 0;
+
+ function callback() {
+ if (!hasParams) {
+ fn(iteration);
+ } else {
+ fn.apply(null, args);
+ }
+ }
+
+ function tick() {
+ if (skipApply) {
+ $browser.defer(callback);
+ } else {
+ $rootScope.$evalAsync(callback);
+ }
+ deferred.notify(iteration++);
+
+ if (count > 0 && iteration >= count) {
+ deferred.resolve(iteration);
+ clearIntervalFn(promise.$$intervalId);
+ }
+
+ if (!skipApply) $rootScope.$apply();
+ }
+
+ promise.$$intervalId = setIntervalFn(tick, delay, deferred, skipApply);
+
+ return promise;
+ };
+ };
+ }];
+}
+
+/**
+ * @ngdoc service
+ * @name $jsonpCallbacks
+ * @requires $window
+ * @description
+ * This service handles the lifecycle of callbacks to handle JSONP requests.
+ * Override this service if you wish to customise where the callbacks are stored and
+ * how they vary compared to the requested url.
+ */
+var $jsonpCallbacksProvider = /** @this */ function() {
+ this.$get = function() {
+ var callbacks = angular.callbacks;
+ var callbackMap = {};
+
+ function createCallback(callbackId) {
+ var callback = function(data) {
+ callback.data = data;
+ callback.called = true;
+ };
+ callback.id = callbackId;
+ return callback;
+ }
+
+ return {
+ /**
+ * @ngdoc method
+ * @name $jsonpCallbacks#createCallback
+ * @param {string} url the url of the JSONP request
+ * @returns {string} the callback path to send to the server as part of the JSONP request
+ * @description
+ * {@link $httpBackend} calls this method to create a callback and get hold of the path to the callback
+ * to pass to the server, which will be used to call the callback with its payload in the JSONP response.
+ */
+ createCallback: function(url) {
+ var callbackId = '_' + (callbacks.$$counter++).toString(36);
+ var callbackPath = 'angular.callbacks.' + callbackId;
+ var callback = createCallback(callbackId);
+ callbackMap[callbackPath] = callbacks[callbackId] = callback;
+ return callbackPath;
+ },
+ /**
+ * @ngdoc method
+ * @name $jsonpCallbacks#wasCalled
+ * @param {string} callbackPath the path to the callback that was sent in the JSONP request
+ * @returns {boolean} whether the callback has been called, as a result of the JSONP response
+ * @description
+ * {@link $httpBackend} calls this method to find out whether the JSONP response actually called the
+ * callback that was passed in the request.
+ */
+ wasCalled: function(callbackPath) {
+ return callbackMap[callbackPath].called;
+ },
+ /**
+ * @ngdoc method
+ * @name $jsonpCallbacks#getResponse
+ * @param {string} callbackPath the path to the callback that was sent in the JSONP request
+ * @returns {*} the data received from the response via the registered callback
+ * @description
+ * {@link $httpBackend} calls this method to get hold of the data that was provided to the callback
+ * in the JSONP response.
+ */
+ getResponse: function(callbackPath) {
+ return callbackMap[callbackPath].data;
+ },
+ /**
+ * @ngdoc method
+ * @name $jsonpCallbacks#removeCallback
+ * @param {string} callbackPath the path to the callback that was sent in the JSONP request
+ * @description
+ * {@link $httpBackend} calls this method to remove the callback after the JSONP request has
+ * completed or timed-out.
+ */
+ removeCallback: function(callbackPath) {
+ var callback = callbackMap[callbackPath];
+ delete callbacks[callback.id];
+ delete callbackMap[callbackPath];
+ }
+ };
+ };
+};
+
+/**
+ * @ngdoc service
+ * @name $locale
+ *
+ * @description
+ * $locale service provides localization rules for various AngularJS components. As of right now the
+ * only public api is:
+ *
+ * * `id` – `{string}` – locale id formatted as `languageId-countryId` (e.g. `en-us`)
+ */
+
+/* global stripHash: true */
+
+var PATH_MATCH = /^([^?#]*)(\?([^#]*))?(#(.*))?$/,
+ DEFAULT_PORTS = {'http': 80, 'https': 443, 'ftp': 21};
+var $locationMinErr = minErr('$location');
+
+
+/**
+ * Encode path using encodeUriSegment, ignoring forward slashes
+ *
+ * @param {string} path Path to encode
+ * @returns {string}
+ */
+function encodePath(path) {
+ var segments = path.split('/'),
+ i = segments.length;
+
+ while (i--) {
+ // decode forward slashes to prevent them from being double encoded
+ segments[i] = encodeUriSegment(segments[i].replace(/%2F/g, '/'));
+ }
+
+ return segments.join('/');
+}
+
+function decodePath(path, html5Mode) {
+ var segments = path.split('/'),
+ i = segments.length;
+
+ while (i--) {
+ segments[i] = decodeURIComponent(segments[i]);
+ if (html5Mode) {
+ // encode forward slashes to prevent them from being mistaken for path separators
+ segments[i] = segments[i].replace(/\//g, '%2F');
+ }
+ }
+
+ return segments.join('/');
+}
+
+function normalizePath(pathValue, searchValue, hashValue) {
+ var search = toKeyValue(searchValue),
+ hash = hashValue ? '#' + encodeUriSegment(hashValue) : '',
+ path = encodePath(pathValue);
+
+ return path + (search ? '?' + search : '') + hash;
+}
+
+function parseAbsoluteUrl(absoluteUrl, locationObj) {
+ var parsedUrl = urlResolve(absoluteUrl);
+
+ locationObj.$$protocol = parsedUrl.protocol;
+ locationObj.$$host = parsedUrl.hostname;
+ locationObj.$$port = toInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
+}
+
+var DOUBLE_SLASH_REGEX = /^\s*[\\/]{2,}/;
+function parseAppUrl(url, locationObj, html5Mode) {
+
+ if (DOUBLE_SLASH_REGEX.test(url)) {
+ throw $locationMinErr('badpath', 'Invalid url "{0}".', url);
+ }
+
+ var prefixed = (url.charAt(0) !== '/');
+ if (prefixed) {
+ url = '/' + url;
+ }
+ var match = urlResolve(url);
+ var path = prefixed && match.pathname.charAt(0) === '/' ? match.pathname.substring(1) : match.pathname;
+ locationObj.$$path = decodePath(path, html5Mode);
+ locationObj.$$search = parseKeyValue(match.search);
+ locationObj.$$hash = decodeURIComponent(match.hash);
+
+ // make sure path starts with '/';
+ if (locationObj.$$path && locationObj.$$path.charAt(0) !== '/') {
+ locationObj.$$path = '/' + locationObj.$$path;
+ }
+}
+
+function startsWith(str, search) {
+ return str.slice(0, search.length) === search;
+}
+
+/**
+ *
+ * @param {string} base
+ * @param {string} url
+ * @returns {string} returns text from `url` after `base` or `undefined` if it does not begin with
+ * the expected string.
+ */
+function stripBaseUrl(base, url) {
+ if (startsWith(url, base)) {
+ return url.substr(base.length);
+ }
+}
+
+function stripHash(url) {
+ var index = url.indexOf('#');
+ return index === -1 ? url : url.substr(0, index);
+}
+
+function stripFile(url) {
+ return url.substr(0, stripHash(url).lastIndexOf('/') + 1);
+}
+
+/* return the server only (scheme://host:port) */
+function serverBase(url) {
+ return url.substring(0, url.indexOf('/', url.indexOf('//') + 2));
+}
+
+
+/**
+ * LocationHtml5Url represents a URL
+ * This object is exposed as $location service when HTML5 mode is enabled and supported
+ *
+ * @constructor
+ * @param {string} appBase application base URL
+ * @param {string} appBaseNoFile application base URL stripped of any filename
+ * @param {string} basePrefix URL path prefix
+ */
+function LocationHtml5Url(appBase, appBaseNoFile, basePrefix) {
+ this.$$html5 = true;
+ basePrefix = basePrefix || '';
+ parseAbsoluteUrl(appBase, this);
+
+
+ /**
+ * Parse given HTML5 (regular) URL string into properties
+ * @param {string} url HTML5 URL
+ * @private
+ */
+ this.$$parse = function(url) {
+ var pathUrl = stripBaseUrl(appBaseNoFile, url);
+ if (!isString(pathUrl)) {
+ throw $locationMinErr('ipthprfx', 'Invalid url "{0}", missing path prefix "{1}".', url,
+ appBaseNoFile);
+ }
+
+ parseAppUrl(pathUrl, this, true);
+
+ if (!this.$$path) {
+ this.$$path = '/';
+ }
+
+ this.$$compose();
+ };
+
+ this.$$normalizeUrl = function(url) {
+ return appBaseNoFile + url.substr(1); // first char is always '/'
+ };
+
+ this.$$parseLinkUrl = function(url, relHref) {
+ if (relHref && relHref[0] === '#') {
+ // special case for links to hash fragments:
+ // keep the old url and only replace the hash fragment
+ this.hash(relHref.slice(1));
+ return true;
+ }
+ var appUrl, prevAppUrl;
+ var rewrittenUrl;
+
+
+ if (isDefined(appUrl = stripBaseUrl(appBase, url))) {
+ prevAppUrl = appUrl;
+ if (basePrefix && isDefined(appUrl = stripBaseUrl(basePrefix, appUrl))) {
+ rewrittenUrl = appBaseNoFile + (stripBaseUrl('/', appUrl) || appUrl);
+ } else {
+ rewrittenUrl = appBase + prevAppUrl;
+ }
+ } else if (isDefined(appUrl = stripBaseUrl(appBaseNoFile, url))) {
+ rewrittenUrl = appBaseNoFile + appUrl;
+ } else if (appBaseNoFile === url + '/') {
+ rewrittenUrl = appBaseNoFile;
+ }
+ if (rewrittenUrl) {
+ this.$$parse(rewrittenUrl);
+ }
+ return !!rewrittenUrl;
+ };
+}
+
+
+/**
+ * LocationHashbangUrl represents URL
+ * This object is exposed as $location service when developer doesn't opt into html5 mode.
+ * It also serves as the base class for html5 mode fallback on legacy browsers.
+ *
+ * @constructor
+ * @param {string} appBase application base URL
+ * @param {string} appBaseNoFile application base URL stripped of any filename
+ * @param {string} hashPrefix hashbang prefix
+ */
+function LocationHashbangUrl(appBase, appBaseNoFile, hashPrefix) {
+
+ parseAbsoluteUrl(appBase, this);
+
+
+ /**
+ * Parse given hashbang URL into properties
+ * @param {string} url Hashbang URL
+ * @private
+ */
+ this.$$parse = function(url) {
+ var withoutBaseUrl = stripBaseUrl(appBase, url) || stripBaseUrl(appBaseNoFile, url);
+ var withoutHashUrl;
+
+ if (!isUndefined(withoutBaseUrl) && withoutBaseUrl.charAt(0) === '#') {
+
+ // The rest of the URL starts with a hash so we have
+ // got either a hashbang path or a plain hash fragment
+ withoutHashUrl = stripBaseUrl(hashPrefix, withoutBaseUrl);
+ if (isUndefined(withoutHashUrl)) {
+ // There was no hashbang prefix so we just have a hash fragment
+ withoutHashUrl = withoutBaseUrl;
+ }
+
+ } else {
+ // There was no hashbang path nor hash fragment:
+ // If we are in HTML5 mode we use what is left as the path;
+ // Otherwise we ignore what is left
+ if (this.$$html5) {
+ withoutHashUrl = withoutBaseUrl;
+ } else {
+ withoutHashUrl = '';
+ if (isUndefined(withoutBaseUrl)) {
+ appBase = url;
+ /** @type {?} */ (this).replace();
+ }
+ }
+ }
+
+ parseAppUrl(withoutHashUrl, this, false);
+
+ this.$$path = removeWindowsDriveName(this.$$path, withoutHashUrl, appBase);
+
+ this.$$compose();
+
+ /*
+ * In Windows, on an anchor node on documents loaded from
+ * the filesystem, the browser will return a pathname
+ * prefixed with the drive name ('/C:/path') when a
+ * pathname without a drive is set:
+ * * a.setAttribute('href', '/foo')
+ * * a.pathname === '/C:/foo' //true
+ *
+ * Inside of AngularJS, we're always using pathnames that
+ * do not include drive names for routing.
+ */
+ function removeWindowsDriveName(path, url, base) {
+ /*
+ Matches paths for file protocol on windows,
+ such as /C:/foo/bar, and captures only /foo/bar.
+ */
+ var windowsFilePathExp = /^\/[A-Z]:(\/.*)/;
+
+ var firstPathSegmentMatch;
+
+ //Get the relative path from the input URL.
+ if (startsWith(url, base)) {
+ url = url.replace(base, '');
+ }
+
+ // The input URL intentionally contains a first path segment that ends with a colon.
+ if (windowsFilePathExp.exec(url)) {
+ return path;
+ }
+
+ firstPathSegmentMatch = windowsFilePathExp.exec(path);
+ return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path;
+ }
+ };
+
+ this.$$normalizeUrl = function(url) {
+ return appBase + (url ? hashPrefix + url : '');
+ };
+
+ this.$$parseLinkUrl = function(url, relHref) {
+ if (stripHash(appBase) === stripHash(url)) {
+ this.$$parse(url);
+ return true;
+ }
+ return false;
+ };
+}
+
+
+/**
+ * LocationHashbangUrl represents URL
+ * This object is exposed as $location service when html5 history api is enabled but the browser
+ * does not support it.
+ *
+ * @constructor
+ * @param {string} appBase application base URL
+ * @param {string} appBaseNoFile application base URL stripped of any filename
+ * @param {string} hashPrefix hashbang prefix
+ */
+function LocationHashbangInHtml5Url(appBase, appBaseNoFile, hashPrefix) {
+ this.$$html5 = true;
+ LocationHashbangUrl.apply(this, arguments);
+
+ this.$$parseLinkUrl = function(url, relHref) {
+ if (relHref && relHref[0] === '#') {
+ // special case for links to hash fragments:
+ // keep the old url and only replace the hash fragment
+ this.hash(relHref.slice(1));
+ return true;
+ }
+
+ var rewrittenUrl;
+ var appUrl;
+
+ if (appBase === stripHash(url)) {
+ rewrittenUrl = url;
+ } else if ((appUrl = stripBaseUrl(appBaseNoFile, url))) {
+ rewrittenUrl = appBase + hashPrefix + appUrl;
+ } else if (appBaseNoFile === url + '/') {
+ rewrittenUrl = appBaseNoFile;
+ }
+ if (rewrittenUrl) {
+ this.$$parse(rewrittenUrl);
+ }
+ return !!rewrittenUrl;
+ };
+
+ this.$$normalizeUrl = function(url) {
+ // include hashPrefix in $$absUrl when $$url is empty so IE9 does not reload page because of removal of '#'
+ return appBase + hashPrefix + url;
+ };
+}
+
+
+var locationPrototype = {
+
+ /**
+ * Ensure absolute URL is initialized.
+ * @private
+ */
+ $$absUrl:'',
+
+ /**
+ * Are we in html5 mode?
+ * @private
+ */
+ $$html5: false,
+
+ /**
+ * Has any change been replacing?
+ * @private
+ */
+ $$replace: false,
+
+ /**
+ * Compose url and update `url` and `absUrl` property
+ * @private
+ */
+ $$compose: function() {
+ this.$$url = normalizePath(this.$$path, this.$$search, this.$$hash);
+ this.$$absUrl = this.$$normalizeUrl(this.$$url);
+ this.$$urlUpdatedByLocation = true;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $location#absUrl
+ *
+ * @description
+ * This method is getter only.
+ *
+ * Return full URL representation with all segments encoded according to rules specified in
+ * [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
+ *
+ *
+ * ```js
+ * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+ * var absUrl = $location.absUrl();
+ * // => "http://example.com/#/some/path?foo=bar&baz=xoxo"
+ * ```
+ *
+ * @return {string} full URL
+ */
+ absUrl: locationGetter('$$absUrl'),
+
+ /**
+ * @ngdoc method
+ * @name $location#url
+ *
+ * @description
+ * This method is getter / setter.
+ *
+ * Return URL (e.g. `/path?a=b#hash`) when called without any parameter.
+ *
+ * Change path, search and hash, when called with parameter and return `$location`.
+ *
+ *
+ * ```js
+ * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+ * var url = $location.url();
+ * // => "/some/path?foo=bar&baz=xoxo"
+ * ```
+ *
+ * @param {string=} url New URL without base prefix (e.g. `/path?a=b#hash`)
+ * @return {string} url
+ */
+ url: function(url) {
+ if (isUndefined(url)) {
+ return this.$$url;
+ }
+
+ var match = PATH_MATCH.exec(url);
+ if (match[1] || url === '') this.path(decodeURIComponent(match[1]));
+ if (match[2] || match[1] || url === '') this.search(match[3] || '');
+ this.hash(match[5] || '');
+
+ return this;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $location#protocol
+ *
+ * @description
+ * This method is getter only.
+ *
+ * Return protocol of current URL.
+ *
+ *
+ * ```js
+ * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+ * var protocol = $location.protocol();
+ * // => "http"
+ * ```
+ *
+ * @return {string} protocol of current URL
+ */
+ protocol: locationGetter('$$protocol'),
+
+ /**
+ * @ngdoc method
+ * @name $location#host
+ *
+ * @description
+ * This method is getter only.
+ *
+ * Return host of current URL.
+ *
+ * Note: compared to the non-AngularJS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
+ *
+ *
+ * ```js
+ * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+ * var host = $location.host();
+ * // => "example.com"
+ *
+ * // given URL http://user:password@example.com:8080/#/some/path?foo=bar&baz=xoxo
+ * host = $location.host();
+ * // => "example.com"
+ * host = location.host;
+ * // => "example.com:8080"
+ * ```
+ *
+ * @return {string} host of current URL.
+ */
+ host: locationGetter('$$host'),
+
+ /**
+ * @ngdoc method
+ * @name $location#port
+ *
+ * @description
+ * This method is getter only.
+ *
+ * Return port of current URL.
+ *
+ *
+ * ```js
+ * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+ * var port = $location.port();
+ * // => 80
+ * ```
+ *
+ * @return {Number} port
+ */
+ port: locationGetter('$$port'),
+
+ /**
+ * @ngdoc method
+ * @name $location#path
+ *
+ * @description
+ * This method is getter / setter.
+ *
+ * Return path of current URL when called without any parameter.
+ *
+ * Change path when called with parameter and return `$location`.
+ *
+ * Note: Path should always begin with forward slash (/), this method will add the forward slash
+ * if it is missing.
+ *
+ *
+ * ```js
+ * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+ * var path = $location.path();
+ * // => "/some/path"
+ * ```
+ *
+ * @param {(string|number)=} path New path
+ * @return {(string|object)} path if called with no parameters, or `$location` if called with a parameter
+ */
+ path: locationGetterSetter('$$path', function(path) {
+ path = path !== null ? path.toString() : '';
+ return path.charAt(0) === '/' ? path : '/' + path;
+ }),
+
+ /**
+ * @ngdoc method
+ * @name $location#search
+ *
+ * @description
+ * This method is getter / setter.
+ *
+ * Return search part (as object) of current URL when called without any parameter.
+ *
+ * Change search part when called with parameter and return `$location`.
+ *
+ *
+ * ```js
+ * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+ * var searchObject = $location.search();
+ * // => {foo: 'bar', baz: 'xoxo'}
+ *
+ * // set foo to 'yipee'
+ * $location.search('foo', 'yipee');
+ * // $location.search() => {foo: 'yipee', baz: 'xoxo'}
+ * ```
+ *
+ * @param {string|Object.<string>|Object.<Array.<string>>} search New search params - string or
+ * hash object.
+ *
+ * When called with a single argument the method acts as a setter, setting the `search` component
+ * of `$location` to the specified value.
+ *
+ * If the argument is a hash object containing an array of values, these values will be encoded
+ * as duplicate search parameters in the URL.
+ *
+ * @param {(string|Number|Array<string>|boolean)=} paramValue If `search` is a string or number, then `paramValue`
+ * will override only a single search property.
+ *
+ * If `paramValue` is an array, it will override the property of the `search` component of
+ * `$location` specified via the first argument.
+ *
+ * If `paramValue` is `null`, the property specified via the first argument will be deleted.
+ *
+ * If `paramValue` is `true`, the property specified via the first argument will be added with no
+ * value nor trailing equal sign.
+ *
+ * @return {Object} If called with no arguments returns the parsed `search` object. If called with
+ * one or more arguments returns `$location` object itself.
+ */
+ search: function(search, paramValue) {
+ switch (arguments.length) {
+ case 0:
+ return this.$$search;
+ case 1:
+ if (isString(search) || isNumber(search)) {
+ search = search.toString();
+ this.$$search = parseKeyValue(search);
+ } else if (isObject(search)) {
+ search = copy(search, {});
+ // remove object undefined or null properties
+ forEach(search, function(value, key) {
+ if (value == null) delete search[key];
+ });
+
+ this.$$search = search;
+ } else {
+ throw $locationMinErr('isrcharg',
+ 'The first argument of the `$location#search()` call must be a string or an object.');
+ }
+ break;
+ default:
+ if (isUndefined(paramValue) || paramValue === null) {
+ delete this.$$search[search];
+ } else {
+ this.$$search[search] = paramValue;
+ }
+ }
+
+ this.$$compose();
+ return this;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $location#hash
+ *
+ * @description
+ * This method is getter / setter.
+ *
+ * Returns the hash fragment when called without any parameters.
+ *
+ * Changes the hash fragment when called with a parameter and returns `$location`.
+ *
+ *
+ * ```js
+ * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue
+ * var hash = $location.hash();
+ * // => "hashValue"
+ * ```
+ *
+ * @param {(string|number)=} hash New hash fragment
+ * @return {string} hash
+ */
+ hash: locationGetterSetter('$$hash', function(hash) {
+ return hash !== null ? hash.toString() : '';
+ }),
+
+ /**
+ * @ngdoc method
+ * @name $location#replace
+ *
+ * @description
+ * If called, all changes to $location during the current `$digest` will replace the current history
+ * record, instead of adding a new one.
+ */
+ replace: function() {
+ this.$$replace = true;
+ return this;
+ }
+};
+
+forEach([LocationHashbangInHtml5Url, LocationHashbangUrl, LocationHtml5Url], function(Location) {
+ Location.prototype = Object.create(locationPrototype);
+
+ /**
+ * @ngdoc method
+ * @name $location#state
+ *
+ * @description
+ * This method is getter / setter.
+ *
+ * Return the history state object when called without any parameter.
+ *
+ * Change the history state object when called with one parameter and return `$location`.
+ * The state object is later passed to `pushState` or `replaceState`.
+ *
+ * NOTE: This method is supported only in HTML5 mode and only in browsers supporting
+ * the HTML5 History API (i.e. methods `pushState` and `replaceState`). If you need to support
+ * older browsers (like IE9 or Android < 4.0), don't use this method.
+ *
+ * @param {object=} state State object for pushState or replaceState
+ * @return {object} state
+ */
+ Location.prototype.state = function(state) {
+ if (!arguments.length) {
+ return this.$$state;
+ }
+
+ if (Location !== LocationHtml5Url || !this.$$html5) {
+ throw $locationMinErr('nostate', 'History API state support is available only ' +
+ 'in HTML5 mode and only in browsers supporting HTML5 History API');
+ }
+ // The user might modify `stateObject` after invoking `$location.state(stateObject)`
+ // but we're changing the $$state reference to $browser.state() during the $digest
+ // so the modification window is narrow.
+ this.$$state = isUndefined(state) ? null : state;
+ this.$$urlUpdatedByLocation = true;
+
+ return this;
+ };
+});
+
+
+function locationGetter(property) {
+ return /** @this */ function() {
+ return this[property];
+ };
+}
+
+
+function locationGetterSetter(property, preprocess) {
+ return /** @this */ function(value) {
+ if (isUndefined(value)) {
+ return this[property];
+ }
+
+ this[property] = preprocess(value);
+ this.$$compose();
+
+ return this;
+ };
+}
+
+
+/**
+ * @ngdoc service
+ * @name $location
+ *
+ * @requires $rootElement
+ *
+ * @description
+ * The $location service parses the URL in the browser address bar (based on the
+ * [window.location](https://developer.mozilla.org/en/window.location)) and makes the URL
+ * available to your application. Changes to the URL in the address bar are reflected into
+ * $location service and changes to $location are reflected into the browser address bar.
+ *
+ * **The $location service:**
+ *
+ * - Exposes the current URL in the browser address bar, so you can
+ * - Watch and observe the URL.
+ * - Change the URL.
+ * - Synchronizes the URL with the browser when the user
+ * - Changes the address bar.
+ * - Clicks the back or forward button (or clicks a History link).
+ * - Clicks on a link.
+ * - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
+ *
+ * For more information see {@link guide/$location Developer Guide: Using $location}
+ */
+
+/**
+ * @ngdoc provider
+ * @name $locationProvider
+ * @this
+ *
+ * @description
+ * Use the `$locationProvider` to configure how the application deep linking paths are stored.
+ */
+function $LocationProvider() {
+ var hashPrefix = '!',
+ html5Mode = {
+ enabled: false,
+ requireBase: true,
+ rewriteLinks: true
+ };
+
+ /**
+ * @ngdoc method
+ * @name $locationProvider#hashPrefix
+ * @description
+ * The default value for the prefix is `'!'`.
+ * @param {string=} prefix Prefix for hash part (containing path and search)
+ * @returns {*} current value if used as getter or itself (chaining) if used as setter
+ */
+ this.hashPrefix = function(prefix) {
+ if (isDefined(prefix)) {
+ hashPrefix = prefix;
+ return this;
+ } else {
+ return hashPrefix;
+ }
+ };
+
+ /**
+ * @ngdoc method
+ * @name $locationProvider#html5Mode
+ * @description
+ * @param {(boolean|Object)=} mode If boolean, sets `html5Mode.enabled` to value.
+ * If object, sets `enabled`, `requireBase` and `rewriteLinks` to respective values. Supported
+ * properties:
+ * - **enabled** – `{boolean}` – (default: false) If true, will rely on `history.pushState` to
+ * change urls where supported. Will fall back to hash-prefixed paths in browsers that do not
+ * support `pushState`.
+ * - **requireBase** - `{boolean}` - (default: `true`) When html5Mode is enabled, specifies
+ * whether or not a <base> tag is required to be present. If `enabled` and `requireBase` are
+ * true, and a base tag is not present, an error will be thrown when `$location` is injected.
+ * See the {@link guide/$location $location guide for more information}
+ * - **rewriteLinks** - `{boolean|string}` - (default: `true`) When html5Mode is enabled,
+ * enables/disables URL rewriting for relative links. If set to a string, URL rewriting will
+ * only happen on links with an attribute that matches the given string. For example, if set
+ * to `'internal-link'`, then the URL will only be rewritten for `<a internal-link>` links.
+ * Note that [attribute name normalization](guide/directive#normalization) does not apply
+ * here, so `'internalLink'` will **not** match `'internal-link'`.
+ *
+ * @returns {Object} html5Mode object if used as getter or itself (chaining) if used as setter
+ */
+ this.html5Mode = function(mode) {
+ if (isBoolean(mode)) {
+ html5Mode.enabled = mode;
+ return this;
+ } else if (isObject(mode)) {
+
+ if (isBoolean(mode.enabled)) {
+ html5Mode.enabled = mode.enabled;
+ }
+
+ if (isBoolean(mode.requireBase)) {
+ html5Mode.requireBase = mode.requireBase;
+ }
+
+ if (isBoolean(mode.rewriteLinks) || isString(mode.rewriteLinks)) {
+ html5Mode.rewriteLinks = mode.rewriteLinks;
+ }
+
+ return this;
+ } else {
+ return html5Mode;
+ }
+ };
+
+ /**
+ * @ngdoc event
+ * @name $location#$locationChangeStart
+ * @eventType broadcast on root scope
+ * @description
+ * Broadcasted before a URL will change.
+ *
+ * This change can be prevented by calling
+ * `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
+ * details about event object. Upon successful change
+ * {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
+ *
+ * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
+ * the browser supports the HTML5 History API.
+ *
+ * @param {Object} angularEvent Synthetic event object.
+ * @param {string} newUrl New URL
+ * @param {string=} oldUrl URL that was before it was changed.
+ * @param {string=} newState New history state object
+ * @param {string=} oldState History state object that was before it was changed.
+ */
+
+ /**
+ * @ngdoc event
+ * @name $location#$locationChangeSuccess
+ * @eventType broadcast on root scope
+ * @description
+ * Broadcasted after a URL was changed.
+ *
+ * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
+ * the browser supports the HTML5 History API.
+ *
+ * @param {Object} angularEvent Synthetic event object.
+ * @param {string} newUrl New URL
+ * @param {string=} oldUrl URL that was before it was changed.
+ * @param {string=} newState New history state object
+ * @param {string=} oldState History state object that was before it was changed.
+ */
+
+ this.$get = ['$rootScope', '$browser', '$sniffer', '$rootElement', '$window',
+ function($rootScope, $browser, $sniffer, $rootElement, $window) {
+ var $location,
+ LocationMode,
+ baseHref = $browser.baseHref(), // if base[href] is undefined, it defaults to ''
+ initialUrl = $browser.url(),
+ appBase;
+
+ if (html5Mode.enabled) {
+ if (!baseHref && html5Mode.requireBase) {
+ throw $locationMinErr('nobase',
+ '$location in HTML5 mode requires a <base> tag to be present!');
+ }
+ appBase = serverBase(initialUrl) + (baseHref || '/');
+ LocationMode = $sniffer.history ? LocationHtml5Url : LocationHashbangInHtml5Url;
+ } else {
+ appBase = stripHash(initialUrl);
+ LocationMode = LocationHashbangUrl;
+ }
+ var appBaseNoFile = stripFile(appBase);
+
+ $location = new LocationMode(appBase, appBaseNoFile, '#' + hashPrefix);
+ $location.$$parseLinkUrl(initialUrl, initialUrl);
+
+ $location.$$state = $browser.state();
+
+ var IGNORE_URI_REGEXP = /^\s*(javascript|mailto):/i;
+
+ // Determine if two URLs are equal despite potentially having different encoding/normalizing
+ // such as $location.absUrl() vs $browser.url()
+ // See https://github.com/angular/angular.js/issues/16592
+ function urlsEqual(a, b) {
+ return a === b || urlResolve(a).href === urlResolve(b).href;
+ }
+
+ function setBrowserUrlWithFallback(url, replace, state) {
+ var oldUrl = $location.url();
+ var oldState = $location.$$state;
+ try {
+ $browser.url(url, replace, state);
+
+ // Make sure $location.state() returns referentially identical (not just deeply equal)
+ // state object; this makes possible quick checking if the state changed in the digest
+ // loop. Checking deep equality would be too expensive.
+ $location.$$state = $browser.state();
+ } catch (e) {
+ // Restore old values if pushState fails
+ $location.url(oldUrl);
+ $location.$$state = oldState;
+
+ throw e;
+ }
+ }
+
+ $rootElement.on('click', function(event) {
+ var rewriteLinks = html5Mode.rewriteLinks;
+ // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
+ // currently we open nice url link and redirect then
+
+ if (!rewriteLinks || event.ctrlKey || event.metaKey || event.shiftKey || event.which === 2 || event.button === 2) return;
+
+ var elm = jqLite(event.target);
+
+ // traverse the DOM up to find first A tag
+ while (nodeName_(elm[0]) !== 'a') {
+ // ignore rewriting if no A tag (reached root element, or no parent - removed from document)
+ if (elm[0] === $rootElement[0] || !(elm = elm.parent())[0]) return;
+ }
+
+ if (isString(rewriteLinks) && isUndefined(elm.attr(rewriteLinks))) return;
+
+ var absHref = elm.prop('href');
+ // get the actual href attribute - see
+ // http://msdn.microsoft.com/en-us/library/ie/dd347148(v=vs.85).aspx
+ var relHref = elm.attr('href') || elm.attr('xlink:href');
+
+ if (isObject(absHref) && absHref.toString() === '[object SVGAnimatedString]') {
+ // SVGAnimatedString.animVal should be identical to SVGAnimatedString.baseVal, unless during
+ // an animation.
+ absHref = urlResolve(absHref.animVal).href;
+ }
+
+ // Ignore when url is started with javascript: or mailto:
+ if (IGNORE_URI_REGEXP.test(absHref)) return;
+
+ if (absHref && !elm.attr('target') && !event.isDefaultPrevented()) {
+ if ($location.$$parseLinkUrl(absHref, relHref)) {
+ // We do a preventDefault for all urls that are part of the AngularJS application,
+ // in html5mode and also without, so that we are able to abort navigation without
+ // getting double entries in the location history.
+ event.preventDefault();
+ // update location manually
+ if ($location.absUrl() !== $browser.url()) {
+ $rootScope.$apply();
+ }
+ }
+ }
+ });
+
+
+ // rewrite hashbang url <> html5 url
+ if ($location.absUrl() !== initialUrl) {
+ $browser.url($location.absUrl(), true);
+ }
+
+ var initializing = true;
+
+ // update $location when $browser url changes
+ $browser.onUrlChange(function(newUrl, newState) {
+
+ if (!startsWith(newUrl, appBaseNoFile)) {
+ // If we are navigating outside of the app then force a reload
+ $window.location.href = newUrl;
+ return;
+ }
+
+ $rootScope.$evalAsync(function() {
+ var oldUrl = $location.absUrl();
+ var oldState = $location.$$state;
+ var defaultPrevented;
+ $location.$$parse(newUrl);
+ $location.$$state = newState;
+
+ defaultPrevented = $rootScope.$broadcast('$locationChangeStart', newUrl, oldUrl,
+ newState, oldState).defaultPrevented;
+
+ // if the location was changed by a `$locationChangeStart` handler then stop
+ // processing this location change
+ if ($location.absUrl() !== newUrl) return;
+
+ if (defaultPrevented) {
+ $location.$$parse(oldUrl);
+ $location.$$state = oldState;
+ setBrowserUrlWithFallback(oldUrl, false, oldState);
+ } else {
+ initializing = false;
+ afterLocationChange(oldUrl, oldState);
+ }
+ });
+ if (!$rootScope.$$phase) $rootScope.$digest();
+ });
+
+ // update browser
+ $rootScope.$watch(function $locationWatch() {
+ if (initializing || $location.$$urlUpdatedByLocation) {
+ $location.$$urlUpdatedByLocation = false;
+
+ var oldUrl = $browser.url();
+ var newUrl = $location.absUrl();
+ var oldState = $browser.state();
+ var currentReplace = $location.$$replace;
+ var urlOrStateChanged = !urlsEqual(oldUrl, newUrl) ||
+ ($location.$$html5 && $sniffer.history && oldState !== $location.$$state);
+
+ if (initializing || urlOrStateChanged) {
+ initializing = false;
+
+ $rootScope.$evalAsync(function() {
+ var newUrl = $location.absUrl();
+ var defaultPrevented = $rootScope.$broadcast('$locationChangeStart', newUrl, oldUrl,
+ $location.$$state, oldState).defaultPrevented;
+
+ // if the location was changed by a `$locationChangeStart` handler then stop
+ // processing this location change
+ if ($location.absUrl() !== newUrl) return;
+
+ if (defaultPrevented) {
+ $location.$$parse(oldUrl);
+ $location.$$state = oldState;
+ } else {
+ if (urlOrStateChanged) {
+ setBrowserUrlWithFallback(newUrl, currentReplace,
+ oldState === $location.$$state ? null : $location.$$state);
+ }
+ afterLocationChange(oldUrl, oldState);
+ }
+ });
+ }
+ }
+
+ $location.$$replace = false;
+
+ // we don't need to return anything because $evalAsync will make the digest loop dirty when
+ // there is a change
+ });
+
+ return $location;
+
+ function afterLocationChange(oldUrl, oldState) {
+ $rootScope.$broadcast('$locationChangeSuccess', $location.absUrl(), oldUrl,
+ $location.$$state, oldState);
+ }
+}];
+}
+
+/**
+ * @ngdoc service
+ * @name $log
+ * @requires $window
+ *
+ * @description
+ * Simple service for logging. Default implementation safely writes the message
+ * into the browser's console (if present).
+ *
+ * The main purpose of this service is to simplify debugging and troubleshooting.
+ *
+ * To reveal the location of the calls to `$log` in the JavaScript console,
+ * you can "blackbox" the AngularJS source in your browser:
+ *
+ * [Mozilla description of blackboxing](https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Black_box_a_source).
+ * [Chrome description of blackboxing](https://developer.chrome.com/devtools/docs/blackboxing).
+ *
+ * Note: Not all browsers support blackboxing.
+ *
+ * The default is to log `debug` messages. You can use
+ * {@link ng.$logProvider ng.$logProvider#debugEnabled} to change this.
+ *
+ * @example
+ <example module="logExample" name="log-service">
+ <file name="script.js">
+ angular.module('logExample', [])
+ .controller('LogController', ['$scope', '$log', function($scope, $log) {
+ $scope.$log = $log;
+ $scope.message = 'Hello World!';
+ }]);
+ </file>
+ <file name="index.html">
+ <div ng-controller="LogController">
+ <p>Reload this page with open console, enter text and hit the log button...</p>
+ <label>Message:
+ <input type="text" ng-model="message" /></label>
+ <button ng-click="$log.log(message)">log</button>
+ <button ng-click="$log.warn(message)">warn</button>
+ <button ng-click="$log.info(message)">info</button>
+ <button ng-click="$log.error(message)">error</button>
+ <button ng-click="$log.debug(message)">debug</button>
+ </div>
+ </file>
+ </example>
+ */
+
+/**
+ * @ngdoc provider
+ * @name $logProvider
+ * @this
+ *
+ * @description
+ * Use the `$logProvider` to configure how the application logs messages
+ */
+function $LogProvider() {
+ var debug = true,
+ self = this;
+
+ /**
+ * @ngdoc method
+ * @name $logProvider#debugEnabled
+ * @description
+ * @param {boolean=} flag enable or disable debug level messages
+ * @returns {*} current value if used as getter or itself (chaining) if used as setter
+ */
+ this.debugEnabled = function(flag) {
+ if (isDefined(flag)) {
+ debug = flag;
+ return this;
+ } else {
+ return debug;
+ }
+ };
+
+ this.$get = ['$window', function($window) {
+ // Support: IE 9-11, Edge 12-14+
+ // IE/Edge display errors in such a way that it requires the user to click in 4 places
+ // to see the stack trace. There is no way to feature-detect it so there's a chance
+ // of the user agent sniffing to go wrong but since it's only about logging, this shouldn't
+ // break apps. Other browsers display errors in a sensible way and some of them map stack
+ // traces along source maps if available so it makes sense to let browsers display it
+ // as they want.
+ var formatStackTrace = msie || /\bEdge\//.test($window.navigator && $window.navigator.userAgent);
+
+ return {
+ /**
+ * @ngdoc method
+ * @name $log#log
+ *
+ * @description
+ * Write a log message
+ */
+ log: consoleLog('log'),
+
+ /**
+ * @ngdoc method
+ * @name $log#info
+ *
+ * @description
+ * Write an information message
+ */
+ info: consoleLog('info'),
+
+ /**
+ * @ngdoc method
+ * @name $log#warn
+ *
+ * @description
+ * Write a warning message
+ */
+ warn: consoleLog('warn'),
+
+ /**
+ * @ngdoc method
+ * @name $log#error
+ *
+ * @description
+ * Write an error message
+ */
+ error: consoleLog('error'),
+
+ /**
+ * @ngdoc method
+ * @name $log#debug
+ *
+ * @description
+ * Write a debug message
+ */
+ debug: (function() {
+ var fn = consoleLog('debug');
+
+ return function() {
+ if (debug) {
+ fn.apply(self, arguments);
+ }
+ };
+ })()
+ };
+
+ function formatError(arg) {
+ if (isError(arg)) {
+ if (arg.stack && formatStackTrace) {
+ arg = (arg.message && arg.stack.indexOf(arg.message) === -1)
+ ? 'Error: ' + arg.message + '\n' + arg.stack
+ : arg.stack;
+ } else if (arg.sourceURL) {
+ arg = arg.message + '\n' + arg.sourceURL + ':' + arg.line;
+ }
+ }
+ return arg;
+ }
+
+ function consoleLog(type) {
+ var console = $window.console || {},
+ logFn = console[type] || console.log || noop;
+
+ return function() {
+ var args = [];
+ forEach(arguments, function(arg) {
+ args.push(formatError(arg));
+ });
+ // Support: IE 9 only
+ // console methods don't inherit from Function.prototype in IE 9 so we can't
+ // call `logFn.apply(console, args)` directly.
+ return Function.prototype.apply.call(logFn, console, args);
+ };
+ }
+ }];
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Any commits to this file should be reviewed with security in mind. *
+ * Changes to this file can potentially create security vulnerabilities. *
+ * An approval from 2 Core members with history of modifying *
+ * this file is required. *
+ * *
+ * Does the change somehow allow for arbitrary javascript to be executed? *
+ * Or allows for someone to change the prototype of built-in objects? *
+ * Or gives undesired access to variables likes document or window? *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+var $parseMinErr = minErr('$parse');
+
+var objectValueOf = {}.constructor.prototype.valueOf;
+
+// Sandboxing AngularJS Expressions
+// ------------------------------
+// AngularJS expressions are no longer sandboxed. So it is now even easier to access arbitrary JS code by
+// various means such as obtaining a reference to native JS functions like the Function constructor.
+//
+// As an example, consider the following AngularJS expression:
+//
+// {}.toString.constructor('alert("evil JS code")')
+//
+// It is important to realize that if you create an expression from a string that contains user provided
+// content then it is possible that your application contains a security vulnerability to an XSS style attack.
+//
+// See https://docs.angularjs.org/guide/security
+
+
+function getStringValue(name) {
+ // Property names must be strings. This means that non-string objects cannot be used
+ // as keys in an object. Any non-string object, including a number, is typecasted
+ // into a string via the toString method.
+ // -- MDN, https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Property_accessors#Property_names
+ //
+ // So, to ensure that we are checking the same `name` that JavaScript would use, we cast it
+ // to a string. It's not always possible. If `name` is an object and its `toString` method is
+ // 'broken' (doesn't return a string, isn't a function, etc.), an error will be thrown:
+ //
+ // TypeError: Cannot convert object to primitive value
+ //
+ // For performance reasons, we don't catch this error here and allow it to propagate up the call
+ // stack. Note that you'll get the same error in JavaScript if you try to access a property using
+ // such a 'broken' object as a key.
+ return name + '';
+}
+
+
+var OPERATORS = createMap();
+forEach('+ - * / % === !== == != < > <= >= && || ! = |'.split(' '), function(operator) { OPERATORS[operator] = true; });
+var ESCAPE = {'n':'\n', 'f':'\f', 'r':'\r', 't':'\t', 'v':'\v', '\'':'\'', '"':'"'};
+
+
+/////////////////////////////////////////
+
+
+/**
+ * @constructor
+ */
+var Lexer = function Lexer(options) {
+ this.options = options;
+};
+
+Lexer.prototype = {
+ constructor: Lexer,
+
+ lex: function(text) {
+ this.text = text;
+ this.index = 0;
+ this.tokens = [];
+
+ while (this.index < this.text.length) {
+ var ch = this.text.charAt(this.index);
+ if (ch === '"' || ch === '\'') {
+ this.readString(ch);
+ } else if (this.isNumber(ch) || ch === '.' && this.isNumber(this.peek())) {
+ this.readNumber();
+ } else if (this.isIdentifierStart(this.peekMultichar())) {
+ this.readIdent();
+ } else if (this.is(ch, '(){}[].,;:?')) {
+ this.tokens.push({index: this.index, text: ch});
+ this.index++;
+ } else if (this.isWhitespace(ch)) {
+ this.index++;
+ } else {
+ var ch2 = ch + this.peek();
+ var ch3 = ch2 + this.peek(2);
+ var op1 = OPERATORS[ch];
+ var op2 = OPERATORS[ch2];
+ var op3 = OPERATORS[ch3];
+ if (op1 || op2 || op3) {
+ var token = op3 ? ch3 : (op2 ? ch2 : ch);
+ this.tokens.push({index: this.index, text: token, operator: true});
+ this.index += token.length;
+ } else {
+ this.throwError('Unexpected next character ', this.index, this.index + 1);
+ }
+ }
+ }
+ return this.tokens;
+ },
+
+ is: function(ch, chars) {
+ return chars.indexOf(ch) !== -1;
+ },
+
+ peek: function(i) {
+ var num = i || 1;
+ return (this.index + num < this.text.length) ? this.text.charAt(this.index + num) : false;
+ },
+
+ isNumber: function(ch) {
+ return ('0' <= ch && ch <= '9') && typeof ch === 'string';
+ },
+
+ isWhitespace: function(ch) {
+ // IE treats non-breaking space as \u00A0
+ return (ch === ' ' || ch === '\r' || ch === '\t' ||
+ ch === '\n' || ch === '\v' || ch === '\u00A0');
+ },
+
+ isIdentifierStart: function(ch) {
+ return this.options.isIdentifierStart ?
+ this.options.isIdentifierStart(ch, this.codePointAt(ch)) :
+ this.isValidIdentifierStart(ch);
+ },
+
+ isValidIdentifierStart: function(ch) {
+ return ('a' <= ch && ch <= 'z' ||
+ 'A' <= ch && ch <= 'Z' ||
+ '_' === ch || ch === '$');
+ },
+
+ isIdentifierContinue: function(ch) {
+ return this.options.isIdentifierContinue ?
+ this.options.isIdentifierContinue(ch, this.codePointAt(ch)) :
+ this.isValidIdentifierContinue(ch);
+ },
+
+ isValidIdentifierContinue: function(ch, cp) {
+ return this.isValidIdentifierStart(ch, cp) || this.isNumber(ch);
+ },
+
+ codePointAt: function(ch) {
+ if (ch.length === 1) return ch.charCodeAt(0);
+ // eslint-disable-next-line no-bitwise
+ return (ch.charCodeAt(0) << 10) + ch.charCodeAt(1) - 0x35FDC00;
+ },
+
+ peekMultichar: function() {
+ var ch = this.text.charAt(this.index);
+ var peek = this.peek();
+ if (!peek) {
+ return ch;
+ }
+ var cp1 = ch.charCodeAt(0);
+ var cp2 = peek.charCodeAt(0);
+ if (cp1 >= 0xD800 && cp1 <= 0xDBFF && cp2 >= 0xDC00 && cp2 <= 0xDFFF) {
+ return ch + peek;
+ }
+ return ch;
+ },
+
+ isExpOperator: function(ch) {
+ return (ch === '-' || ch === '+' || this.isNumber(ch));
+ },
+
+ throwError: function(error, start, end) {
+ end = end || this.index;
+ var colStr = (isDefined(start)
+ ? 's ' + start + '-' + this.index + ' [' + this.text.substring(start, end) + ']'
+ : ' ' + end);
+ throw $parseMinErr('lexerr', 'Lexer Error: {0} at column{1} in expression [{2}].',
+ error, colStr, this.text);
+ },
+
+ readNumber: function() {
+ var number = '';
+ var start = this.index;
+ while (this.index < this.text.length) {
+ var ch = lowercase(this.text.charAt(this.index));
+ if (ch === '.' || this.isNumber(ch)) {
+ number += ch;
+ } else {
+ var peekCh = this.peek();
+ if (ch === 'e' && this.isExpOperator(peekCh)) {
+ number += ch;
+ } else if (this.isExpOperator(ch) &&
+ peekCh && this.isNumber(peekCh) &&
+ number.charAt(number.length - 1) === 'e') {
+ number += ch;
+ } else if (this.isExpOperator(ch) &&
+ (!peekCh || !this.isNumber(peekCh)) &&
+ number.charAt(number.length - 1) === 'e') {
+ this.throwError('Invalid exponent');
+ } else {
+ break;
+ }
+ }
+ this.index++;
+ }
+ this.tokens.push({
+ index: start,
+ text: number,
+ constant: true,
+ value: Number(number)
+ });
+ },
+
+ readIdent: function() {
+ var start = this.index;
+ this.index += this.peekMultichar().length;
+ while (this.index < this.text.length) {
+ var ch = this.peekMultichar();
+ if (!this.isIdentifierContinue(ch)) {
+ break;
+ }
+ this.index += ch.length;
+ }
+ this.tokens.push({
+ index: start,
+ text: this.text.slice(start, this.index),
+ identifier: true
+ });
+ },
+
+ readString: function(quote) {
+ var start = this.index;
+ this.index++;
+ var string = '';
+ var rawString = quote;
+ var escape = false;
+ while (this.index < this.text.length) {
+ var ch = this.text.charAt(this.index);
+ rawString += ch;
+ if (escape) {
+ if (ch === 'u') {
+ var hex = this.text.substring(this.index + 1, this.index + 5);
+ if (!hex.match(/[\da-f]{4}/i)) {
+ this.throwError('Invalid unicode escape [\\u' + hex + ']');
+ }
+ this.index += 4;
+ string += String.fromCharCode(parseInt(hex, 16));
+ } else {
+ var rep = ESCAPE[ch];
+ string = string + (rep || ch);
+ }
+ escape = false;
+ } else if (ch === '\\') {
+ escape = true;
+ } else if (ch === quote) {
+ this.index++;
+ this.tokens.push({
+ index: start,
+ text: rawString,
+ constant: true,
+ value: string
+ });
+ return;
+ } else {
+ string += ch;
+ }
+ this.index++;
+ }
+ this.throwError('Unterminated quote', start);
+ }
+};
+
+var AST = function AST(lexer, options) {
+ this.lexer = lexer;
+ this.options = options;
+};
+
+AST.Program = 'Program';
+AST.ExpressionStatement = 'ExpressionStatement';
+AST.AssignmentExpression = 'AssignmentExpression';
+AST.ConditionalExpression = 'ConditionalExpression';
+AST.LogicalExpression = 'LogicalExpression';
+AST.BinaryExpression = 'BinaryExpression';
+AST.UnaryExpression = 'UnaryExpression';
+AST.CallExpression = 'CallExpression';
+AST.MemberExpression = 'MemberExpression';
+AST.Identifier = 'Identifier';
+AST.Literal = 'Literal';
+AST.ArrayExpression = 'ArrayExpression';
+AST.Property = 'Property';
+AST.ObjectExpression = 'ObjectExpression';
+AST.ThisExpression = 'ThisExpression';
+AST.LocalsExpression = 'LocalsExpression';
+
+// Internal use only
+AST.NGValueParameter = 'NGValueParameter';
+
+AST.prototype = {
+ ast: function(text) {
+ this.text = text;
+ this.tokens = this.lexer.lex(text);
+
+ var value = this.program();
+
+ if (this.tokens.length !== 0) {
+ this.throwError('is an unexpected token', this.tokens[0]);
+ }
+
+ return value;
+ },
+
+ program: function() {
+ var body = [];
+ while (true) {
+ if (this.tokens.length > 0 && !this.peek('}', ')', ';', ']'))
+ body.push(this.expressionStatement());
+ if (!this.expect(';')) {
+ return { type: AST.Program, body: body};
+ }
+ }
+ },
+
+ expressionStatement: function() {
+ return { type: AST.ExpressionStatement, expression: this.filterChain() };
+ },
+
+ filterChain: function() {
+ var left = this.expression();
+ while (this.expect('|')) {
+ left = this.filter(left);
+ }
+ return left;
+ },
+
+ expression: function() {
+ return this.assignment();
+ },
+
+ assignment: function() {
+ var result = this.ternary();
+ if (this.expect('=')) {
+ if (!isAssignable(result)) {
+ throw $parseMinErr('lval', 'Trying to assign a value to a non l-value');
+ }
+
+ result = { type: AST.AssignmentExpression, left: result, right: this.assignment(), operator: '='};
+ }
+ return result;
+ },
+
+ ternary: function() {
+ var test = this.logicalOR();
+ var alternate;
+ var consequent;
+ if (this.expect('?')) {
+ alternate = this.expression();
+ if (this.consume(':')) {
+ consequent = this.expression();
+ return { type: AST.ConditionalExpression, test: test, alternate: alternate, consequent: consequent};
+ }
+ }
+ return test;
+ },
+
+ logicalOR: function() {
+ var left = this.logicalAND();
+ while (this.expect('||')) {
+ left = { type: AST.LogicalExpression, operator: '||', left: left, right: this.logicalAND() };
+ }
+ return left;
+ },
+
+ logicalAND: function() {
+ var left = this.equality();
+ while (this.expect('&&')) {
+ left = { type: AST.LogicalExpression, operator: '&&', left: left, right: this.equality()};
+ }
+ return left;
+ },
+
+ equality: function() {
+ var left = this.relational();
+ var token;
+ while ((token = this.expect('==','!=','===','!=='))) {
+ left = { type: AST.BinaryExpression, operator: token.text, left: left, right: this.relational() };
+ }
+ return left;
+ },
+
+ relational: function() {
+ var left = this.additive();
+ var token;
+ while ((token = this.expect('<', '>', '<=', '>='))) {
+ left = { type: AST.BinaryExpression, operator: token.text, left: left, right: this.additive() };
+ }
+ return left;
+ },
+
+ additive: function() {
+ var left = this.multiplicative();
+ var token;
+ while ((token = this.expect('+','-'))) {
+ left = { type: AST.BinaryExpression, operator: token.text, left: left, right: this.multiplicative() };
+ }
+ return left;
+ },
+
+ multiplicative: function() {
+ var left = this.unary();
+ var token;
+ while ((token = this.expect('*','/','%'))) {
+ left = { type: AST.BinaryExpression, operator: token.text, left: left, right: this.unary() };
+ }
+ return left;
+ },
+
+ unary: function() {
+ var token;
+ if ((token = this.expect('+', '-', '!'))) {
+ return { type: AST.UnaryExpression, operator: token.text, prefix: true, argument: this.unary() };
+ } else {
+ return this.primary();
+ }
+ },
+
+ primary: function() {
+ var primary;
+ if (this.expect('(')) {
+ primary = this.filterChain();
+ this.consume(')');
+ } else if (this.expect('[')) {
+ primary = this.arrayDeclaration();
+ } else if (this.expect('{')) {
+ primary = this.object();
+ } else if (this.selfReferential.hasOwnProperty(this.peek().text)) {
+ primary = copy(this.selfReferential[this.consume().text]);
+ } else if (this.options.literals.hasOwnProperty(this.peek().text)) {
+ primary = { type: AST.Literal, value: this.options.literals[this.consume().text]};
+ } else if (this.peek().identifier) {
+ primary = this.identifier();
+ } else if (this.peek().constant) {
+ primary = this.constant();
+ } else {
+ this.throwError('not a primary expression', this.peek());
+ }
+
+ var next;
+ while ((next = this.expect('(', '[', '.'))) {
+ if (next.text === '(') {
+ primary = {type: AST.CallExpression, callee: primary, arguments: this.parseArguments() };
+ this.consume(')');
+ } else if (next.text === '[') {
+ primary = { type: AST.MemberExpression, object: primary, property: this.expression(), computed: true };
+ this.consume(']');
+ } else if (next.text === '.') {
+ primary = { type: AST.MemberExpression, object: primary, property: this.identifier(), computed: false };
+ } else {
+ this.throwError('IMPOSSIBLE');
+ }
+ }
+ return primary;
+ },
+
+ filter: function(baseExpression) {
+ var args = [baseExpression];
+ var result = {type: AST.CallExpression, callee: this.identifier(), arguments: args, filter: true};
+
+ while (this.expect(':')) {
+ args.push(this.expression());
+ }
+
+ return result;
+ },
+
+ parseArguments: function() {
+ var args = [];
+ if (this.peekToken().text !== ')') {
+ do {
+ args.push(this.filterChain());
+ } while (this.expect(','));
+ }
+ return args;
+ },
+
+ identifier: function() {
+ var token = this.consume();
+ if (!token.identifier) {
+ this.throwError('is not a valid identifier', token);
+ }
+ return { type: AST.Identifier, name: token.text };
+ },
+
+ constant: function() {
+ // TODO check that it is a constant
+ return { type: AST.Literal, value: this.consume().value };
+ },
+
+ arrayDeclaration: function() {
+ var elements = [];
+ if (this.peekToken().text !== ']') {
+ do {
+ if (this.peek(']')) {
+ // Support trailing commas per ES5.1.
+ break;
+ }
+ elements.push(this.expression());
+ } while (this.expect(','));
+ }
+ this.consume(']');
+
+ return { type: AST.ArrayExpression, elements: elements };
+ },
+
+ object: function() {
+ var properties = [], property;
+ if (this.peekToken().text !== '}') {
+ do {
+ if (this.peek('}')) {
+ // Support trailing commas per ES5.1.
+ break;
+ }
+ property = {type: AST.Property, kind: 'init'};
+ if (this.peek().constant) {
+ property.key = this.constant();
+ property.computed = false;
+ this.consume(':');
+ property.value = this.expression();
+ } else if (this.peek().identifier) {
+ property.key = this.identifier();
+ property.computed = false;
+ if (this.peek(':')) {
+ this.consume(':');
+ property.value = this.expression();
+ } else {
+ property.value = property.key;
+ }
+ } else if (this.peek('[')) {
+ this.consume('[');
+ property.key = this.expression();
+ this.consume(']');
+ property.computed = true;
+ this.consume(':');
+ property.value = this.expression();
+ } else {
+ this.throwError('invalid key', this.peek());
+ }
+ properties.push(property);
+ } while (this.expect(','));
+ }
+ this.consume('}');
+
+ return {type: AST.ObjectExpression, properties: properties };
+ },
+
+ throwError: function(msg, token) {
+ throw $parseMinErr('syntax',
+ 'Syntax Error: Token \'{0}\' {1} at column {2} of the expression [{3}] starting at [{4}].',
+ token.text, msg, (token.index + 1), this.text, this.text.substring(token.index));
+ },
+
+ consume: function(e1) {
+ if (this.tokens.length === 0) {
+ throw $parseMinErr('ueoe', 'Unexpected end of expression: {0}', this.text);
+ }
+
+ var token = this.expect(e1);
+ if (!token) {
+ this.throwError('is unexpected, expecting [' + e1 + ']', this.peek());
+ }
+ return token;
+ },
+
+ peekToken: function() {
+ if (this.tokens.length === 0) {
+ throw $parseMinErr('ueoe', 'Unexpected end of expression: {0}', this.text);
+ }
+ return this.tokens[0];
+ },
+
+ peek: function(e1, e2, e3, e4) {
+ return this.peekAhead(0, e1, e2, e3, e4);
+ },
+
+ peekAhead: function(i, e1, e2, e3, e4) {
+ if (this.tokens.length > i) {
+ var token = this.tokens[i];
+ var t = token.text;
+ if (t === e1 || t === e2 || t === e3 || t === e4 ||
+ (!e1 && !e2 && !e3 && !e4)) {
+ return token;
+ }
+ }
+ return false;
+ },
+
+ expect: function(e1, e2, e3, e4) {
+ var token = this.peek(e1, e2, e3, e4);
+ if (token) {
+ this.tokens.shift();
+ return token;
+ }
+ return false;
+ },
+
+ selfReferential: {
+ 'this': {type: AST.ThisExpression },
+ '$locals': {type: AST.LocalsExpression }
+ }
+};
+
+function ifDefined(v, d) {
+ return typeof v !== 'undefined' ? v : d;
+}
+
+function plusFn(l, r) {
+ if (typeof l === 'undefined') return r;
+ if (typeof r === 'undefined') return l;
+ return l + r;
+}
+
+function isStateless($filter, filterName) {
+ var fn = $filter(filterName);
+ return !fn.$stateful;
+}
+
+var PURITY_ABSOLUTE = 1;
+var PURITY_RELATIVE = 2;
+
+// Detect nodes which could depend on non-shallow state of objects
+function isPure(node, parentIsPure) {
+ switch (node.type) {
+ // Computed members might invoke a stateful toString()
+ case AST.MemberExpression:
+ if (node.computed) {
+ return false;
+ }
+ break;
+
+ // Unary always convert to primative
+ case AST.UnaryExpression:
+ return PURITY_ABSOLUTE;
+
+ // The binary + operator can invoke a stateful toString().
+ case AST.BinaryExpression:
+ return node.operator !== '+' ? PURITY_ABSOLUTE : false;
+
+ // Functions / filters probably read state from within objects
+ case AST.CallExpression:
+ return false;
+ }
+
+ return (undefined === parentIsPure) ? PURITY_RELATIVE : parentIsPure;
+}
+
+function findConstantAndWatchExpressions(ast, $filter, parentIsPure) {
+ var allConstants;
+ var argsToWatch;
+ var isStatelessFilter;
+
+ var astIsPure = ast.isPure = isPure(ast, parentIsPure);
+
+ switch (ast.type) {
+ case AST.Program:
+ allConstants = true;
+ forEach(ast.body, function(expr) {
+ findConstantAndWatchExpressions(expr.expression, $filter, astIsPure);
+ allConstants = allConstants && expr.expression.constant;
+ });
+ ast.constant = allConstants;
+ break;
+ case AST.Literal:
+ ast.constant = true;
+ ast.toWatch = [];
+ break;
+ case AST.UnaryExpression:
+ findConstantAndWatchExpressions(ast.argument, $filter, astIsPure);
+ ast.constant = ast.argument.constant;
+ ast.toWatch = ast.argument.toWatch;
+ break;
+ case AST.BinaryExpression:
+ findConstantAndWatchExpressions(ast.left, $filter, astIsPure);
+ findConstantAndWatchExpressions(ast.right, $filter, astIsPure);
+ ast.constant = ast.left.constant && ast.right.constant;
+ ast.toWatch = ast.left.toWatch.concat(ast.right.toWatch);
+ break;
+ case AST.LogicalExpression:
+ findConstantAndWatchExpressions(ast.left, $filter, astIsPure);
+ findConstantAndWatchExpressions(ast.right, $filter, astIsPure);
+ ast.constant = ast.left.constant && ast.right.constant;
+ ast.toWatch = ast.constant ? [] : [ast];
+ break;
+ case AST.ConditionalExpression:
+ findConstantAndWatchExpressions(ast.test, $filter, astIsPure);
+ findConstantAndWatchExpressions(ast.alternate, $filter, astIsPure);
+ findConstantAndWatchExpressions(ast.consequent, $filter, astIsPure);
+ ast.constant = ast.test.constant && ast.alternate.constant && ast.consequent.constant;
+ ast.toWatch = ast.constant ? [] : [ast];
+ break;
+ case AST.Identifier:
+ ast.constant = false;
+ ast.toWatch = [ast];
+ break;
+ case AST.MemberExpression:
+ findConstantAndWatchExpressions(ast.object, $filter, astIsPure);
+ if (ast.computed) {
+ findConstantAndWatchExpressions(ast.property, $filter, astIsPure);
+ }
+ ast.constant = ast.object.constant && (!ast.computed || ast.property.constant);
+ ast.toWatch = ast.constant ? [] : [ast];
+ break;
+ case AST.CallExpression:
+ isStatelessFilter = ast.filter ? isStateless($filter, ast.callee.name) : false;
+ allConstants = isStatelessFilter;
+ argsToWatch = [];
+ forEach(ast.arguments, function(expr) {
+ findConstantAndWatchExpressions(expr, $filter, astIsPure);
+ allConstants = allConstants && expr.constant;
+ argsToWatch.push.apply(argsToWatch, expr.toWatch);
+ });
+ ast.constant = allConstants;
+ ast.toWatch = isStatelessFilter ? argsToWatch : [ast];
+ break;
+ case AST.AssignmentExpression:
+ findConstantAndWatchExpressions(ast.left, $filter, astIsPure);
+ findConstantAndWatchExpressions(ast.right, $filter, astIsPure);
+ ast.constant = ast.left.constant && ast.right.constant;
+ ast.toWatch = [ast];
+ break;
+ case AST.ArrayExpression:
+ allConstants = true;
+ argsToWatch = [];
+ forEach(ast.elements, function(expr) {
+ findConstantAndWatchExpressions(expr, $filter, astIsPure);
+ allConstants = allConstants && expr.constant;
+ argsToWatch.push.apply(argsToWatch, expr.toWatch);
+ });
+ ast.constant = allConstants;
+ ast.toWatch = argsToWatch;
+ break;
+ case AST.ObjectExpression:
+ allConstants = true;
+ argsToWatch = [];
+ forEach(ast.properties, function(property) {
+ findConstantAndWatchExpressions(property.value, $filter, astIsPure);
+ allConstants = allConstants && property.value.constant;
+ argsToWatch.push.apply(argsToWatch, property.value.toWatch);
+ if (property.computed) {
+ //`{[key]: value}` implicitly does `key.toString()` which may be non-pure
+ findConstantAndWatchExpressions(property.key, $filter, /*parentIsPure=*/false);
+ allConstants = allConstants && property.key.constant;
+ argsToWatch.push.apply(argsToWatch, property.key.toWatch);
+ }
+ });
+ ast.constant = allConstants;
+ ast.toWatch = argsToWatch;
+ break;
+ case AST.ThisExpression:
+ ast.constant = false;
+ ast.toWatch = [];
+ break;
+ case AST.LocalsExpression:
+ ast.constant = false;
+ ast.toWatch = [];
+ break;
+ }
+}
+
+function getInputs(body) {
+ if (body.length !== 1) return;
+ var lastExpression = body[0].expression;
+ var candidate = lastExpression.toWatch;
+ if (candidate.length !== 1) return candidate;
+ return candidate[0] !== lastExpression ? candidate : undefined;
+}
+
+function isAssignable(ast) {
+ return ast.type === AST.Identifier || ast.type === AST.MemberExpression;
+}
+
+function assignableAST(ast) {
+ if (ast.body.length === 1 && isAssignable(ast.body[0].expression)) {
+ return {type: AST.AssignmentExpression, left: ast.body[0].expression, right: {type: AST.NGValueParameter}, operator: '='};
+ }
+}
+
+function isLiteral(ast) {
+ return ast.body.length === 0 ||
+ ast.body.length === 1 && (
+ ast.body[0].expression.type === AST.Literal ||
+ ast.body[0].expression.type === AST.ArrayExpression ||
+ ast.body[0].expression.type === AST.ObjectExpression);
+}
+
+function isConstant(ast) {
+ return ast.constant;
+}
+
+function ASTCompiler($filter) {
+ this.$filter = $filter;
+}
+
+ASTCompiler.prototype = {
+ compile: function(ast) {
+ var self = this;
+ this.state = {
+ nextId: 0,
+ filters: {},
+ fn: {vars: [], body: [], own: {}},
+ assign: {vars: [], body: [], own: {}},
+ inputs: []
+ };
+ findConstantAndWatchExpressions(ast, self.$filter);
+ var extra = '';
+ var assignable;
+ this.stage = 'assign';
+ if ((assignable = assignableAST(ast))) {
+ this.state.computing = 'assign';
+ var result = this.nextId();
+ this.recurse(assignable, result);
+ this.return_(result);
+ extra = 'fn.assign=' + this.generateFunction('assign', 's,v,l');
+ }
+ var toWatch = getInputs(ast.body);
+ self.stage = 'inputs';
+ forEach(toWatch, function(watch, key) {
+ var fnKey = 'fn' + key;
+ self.state[fnKey] = {vars: [], body: [], own: {}};
+ self.state.computing = fnKey;
+ var intoId = self.nextId();
+ self.recurse(watch, intoId);
+ self.return_(intoId);
+ self.state.inputs.push({name: fnKey, isPure: watch.isPure});
+ watch.watchId = key;
+ });
+ this.state.computing = 'fn';
+ this.stage = 'main';
+ this.recurse(ast);
+ var fnString =
+ // The build and minification steps remove the string "use strict" from the code, but this is done using a regex.
+ // This is a workaround for this until we do a better job at only removing the prefix only when we should.
+ '"' + this.USE + ' ' + this.STRICT + '";\n' +
+ this.filterPrefix() +
+ 'var fn=' + this.generateFunction('fn', 's,l,a,i') +
+ extra +
+ this.watchFns() +
+ 'return fn;';
+
+ // eslint-disable-next-line no-new-func
+ var fn = (new Function('$filter',
+ 'getStringValue',
+ 'ifDefined',
+ 'plus',
+ fnString))(
+ this.$filter,
+ getStringValue,
+ ifDefined,
+ plusFn);
+ this.state = this.stage = undefined;
+ return fn;
+ },
+
+ USE: 'use',
+
+ STRICT: 'strict',
+
+ watchFns: function() {
+ var result = [];
+ var inputs = this.state.inputs;
+ var self = this;
+ forEach(inputs, function(input) {
+ result.push('var ' + input.name + '=' + self.generateFunction(input.name, 's'));
+ if (input.isPure) {
+ result.push(input.name, '.isPure=' + JSON.stringify(input.isPure) + ';');
+ }
+ });
+ if (inputs.length) {
+ result.push('fn.inputs=[' + inputs.map(function(i) { return i.name; }).join(',') + '];');
+ }
+ return result.join('');
+ },
+
+ generateFunction: function(name, params) {
+ return 'function(' + params + '){' +
+ this.varsPrefix(name) +
+ this.body(name) +
+ '};';
+ },
+
+ filterPrefix: function() {
+ var parts = [];
+ var self = this;
+ forEach(this.state.filters, function(id, filter) {
+ parts.push(id + '=$filter(' + self.escape(filter) + ')');
+ });
+ if (parts.length) return 'var ' + parts.join(',') + ';';
+ return '';
+ },
+
+ varsPrefix: function(section) {
+ return this.state[section].vars.length ? 'var ' + this.state[section].vars.join(',') + ';' : '';
+ },
+
+ body: function(section) {
+ return this.state[section].body.join('');
+ },
+
+ recurse: function(ast, intoId, nameId, recursionFn, create, skipWatchIdCheck) {
+ var left, right, self = this, args, expression, computed;
+ recursionFn = recursionFn || noop;
+ if (!skipWatchIdCheck && isDefined(ast.watchId)) {
+ intoId = intoId || this.nextId();
+ this.if_('i',
+ this.lazyAssign(intoId, this.computedMember('i', ast.watchId)),
+ this.lazyRecurse(ast, intoId, nameId, recursionFn, create, true)
+ );
+ return;
+ }
+ switch (ast.type) {
+ case AST.Program:
+ forEach(ast.body, function(expression, pos) {
+ self.recurse(expression.expression, undefined, undefined, function(expr) { right = expr; });
+ if (pos !== ast.body.length - 1) {
+ self.current().body.push(right, ';');
+ } else {
+ self.return_(right);
+ }
+ });
+ break;
+ case AST.Literal:
+ expression = this.escape(ast.value);
+ this.assign(intoId, expression);
+ recursionFn(intoId || expression);
+ break;
+ case AST.UnaryExpression:
+ this.recurse(ast.argument, undefined, undefined, function(expr) { right = expr; });
+ expression = ast.operator + '(' + this.ifDefined(right, 0) + ')';
+ this.assign(intoId, expression);
+ recursionFn(expression);
+ break;
+ case AST.BinaryExpression:
+ this.recurse(ast.left, undefined, undefined, function(expr) { left = expr; });
+ this.recurse(ast.right, undefined, undefined, function(expr) { right = expr; });
+ if (ast.operator === '+') {
+ expression = this.plus(left, right);
+ } else if (ast.operator === '-') {
+ expression = this.ifDefined(left, 0) + ast.operator + this.ifDefined(right, 0);
+ } else {
+ expression = '(' + left + ')' + ast.operator + '(' + right + ')';
+ }
+ this.assign(intoId, expression);
+ recursionFn(expression);
+ break;
+ case AST.LogicalExpression:
+ intoId = intoId || this.nextId();
+ self.recurse(ast.left, intoId);
+ self.if_(ast.operator === '&&' ? intoId : self.not(intoId), self.lazyRecurse(ast.right, intoId));
+ recursionFn(intoId);
+ break;
+ case AST.ConditionalExpression:
+ intoId = intoId || this.nextId();
+ self.recurse(ast.test, intoId);
+ self.if_(intoId, self.lazyRecurse(ast.alternate, intoId), self.lazyRecurse(ast.consequent, intoId));
+ recursionFn(intoId);
+ break;
+ case AST.Identifier:
+ intoId = intoId || this.nextId();
+ if (nameId) {
+ nameId.context = self.stage === 'inputs' ? 's' : this.assign(this.nextId(), this.getHasOwnProperty('l', ast.name) + '?l:s');
+ nameId.computed = false;
+ nameId.name = ast.name;
+ }
+ self.if_(self.stage === 'inputs' || self.not(self.getHasOwnProperty('l', ast.name)),
+ function() {
+ self.if_(self.stage === 'inputs' || 's', function() {
+ if (create && create !== 1) {
+ self.if_(
+ self.isNull(self.nonComputedMember('s', ast.name)),
+ self.lazyAssign(self.nonComputedMember('s', ast.name), '{}'));
+ }
+ self.assign(intoId, self.nonComputedMember('s', ast.name));
+ });
+ }, intoId && self.lazyAssign(intoId, self.nonComputedMember('l', ast.name))
+ );
+ recursionFn(intoId);
+ break;
+ case AST.MemberExpression:
+ left = nameId && (nameId.context = this.nextId()) || this.nextId();
+ intoId = intoId || this.nextId();
+ self.recurse(ast.object, left, undefined, function() {
+ self.if_(self.notNull(left), function() {
+ if (ast.computed) {
+ right = self.nextId();
+ self.recurse(ast.property, right);
+ self.getStringValue(right);
+ if (create && create !== 1) {
+ self.if_(self.not(self.computedMember(left, right)), self.lazyAssign(self.computedMember(left, right), '{}'));
+ }
+ expression = self.computedMember(left, right);
+ self.assign(intoId, expression);
+ if (nameId) {
+ nameId.computed = true;
+ nameId.name = right;
+ }
+ } else {
+ if (create && create !== 1) {
+ self.if_(self.isNull(self.nonComputedMember(left, ast.property.name)), self.lazyAssign(self.nonComputedMember(left, ast.property.name), '{}'));
+ }
+ expression = self.nonComputedMember(left, ast.property.name);
+ self.assign(intoId, expression);
+ if (nameId) {
+ nameId.computed = false;
+ nameId.name = ast.property.name;
+ }
+ }
+ }, function() {
+ self.assign(intoId, 'undefined');
+ });
+ recursionFn(intoId);
+ }, !!create);
+ break;
+ case AST.CallExpression:
+ intoId = intoId || this.nextId();
+ if (ast.filter) {
+ right = self.filter(ast.callee.name);
+ args = [];
+ forEach(ast.arguments, function(expr) {
+ var argument = self.nextId();
+ self.recurse(expr, argument);
+ args.push(argument);
+ });
+ expression = right + '(' + args.join(',') + ')';
+ self.assign(intoId, expression);
+ recursionFn(intoId);
+ } else {
+ right = self.nextId();
+ left = {};
+ args = [];
+ self.recurse(ast.callee, right, left, function() {
+ self.if_(self.notNull(right), function() {
+ forEach(ast.arguments, function(expr) {
+ self.recurse(expr, ast.constant ? undefined : self.nextId(), undefined, function(argument) {
+ args.push(argument);
+ });
+ });
+ if (left.name) {
+ expression = self.member(left.context, left.name, left.computed) + '(' + args.join(',') + ')';
+ } else {
+ expression = right + '(' + args.join(',') + ')';
+ }
+ self.assign(intoId, expression);
+ }, function() {
+ self.assign(intoId, 'undefined');
+ });
+ recursionFn(intoId);
+ });
+ }
+ break;
+ case AST.AssignmentExpression:
+ right = this.nextId();
+ left = {};
+ this.recurse(ast.left, undefined, left, function() {
+ self.if_(self.notNull(left.context), function() {
+ self.recurse(ast.right, right);
+ expression = self.member(left.context, left.name, left.computed) + ast.operator + right;
+ self.assign(intoId, expression);
+ recursionFn(intoId || expression);
+ });
+ }, 1);
+ break;
+ case AST.ArrayExpression:
+ args = [];
+ forEach(ast.elements, function(expr) {
+ self.recurse(expr, ast.constant ? undefined : self.nextId(), undefined, function(argument) {
+ args.push(argument);
+ });
+ });
+ expression = '[' + args.join(',') + ']';
+ this.assign(intoId, expression);
+ recursionFn(intoId || expression);
+ break;
+ case AST.ObjectExpression:
+ args = [];
+ computed = false;
+ forEach(ast.properties, function(property) {
+ if (property.computed) {
+ computed = true;
+ }
+ });
+ if (computed) {
+ intoId = intoId || this.nextId();
+ this.assign(intoId, '{}');
+ forEach(ast.properties, function(property) {
+ if (property.computed) {
+ left = self.nextId();
+ self.recurse(property.key, left);
+ } else {
+ left = property.key.type === AST.Identifier ?
+ property.key.name :
+ ('' + property.key.value);
+ }
+ right = self.nextId();
+ self.recurse(property.value, right);
+ self.assign(self.member(intoId, left, property.computed), right);
+ });
+ } else {
+ forEach(ast.properties, function(property) {
+ self.recurse(property.value, ast.constant ? undefined : self.nextId(), undefined, function(expr) {
+ args.push(self.escape(
+ property.key.type === AST.Identifier ? property.key.name :
+ ('' + property.key.value)) +
+ ':' + expr);
+ });
+ });
+ expression = '{' + args.join(',') + '}';
+ this.assign(intoId, expression);
+ }
+ recursionFn(intoId || expression);
+ break;
+ case AST.ThisExpression:
+ this.assign(intoId, 's');
+ recursionFn(intoId || 's');
+ break;
+ case AST.LocalsExpression:
+ this.assign(intoId, 'l');
+ recursionFn(intoId || 'l');
+ break;
+ case AST.NGValueParameter:
+ this.assign(intoId, 'v');
+ recursionFn(intoId || 'v');
+ break;
+ }
+ },
+
+ getHasOwnProperty: function(element, property) {
+ var key = element + '.' + property;
+ var own = this.current().own;
+ if (!own.hasOwnProperty(key)) {
+ own[key] = this.nextId(false, element + '&&(' + this.escape(property) + ' in ' + element + ')');
+ }
+ return own[key];
+ },
+
+ assign: function(id, value) {
+ if (!id) return;
+ this.current().body.push(id, '=', value, ';');
+ return id;
+ },
+
+ filter: function(filterName) {
+ if (!this.state.filters.hasOwnProperty(filterName)) {
+ this.state.filters[filterName] = this.nextId(true);
+ }
+ return this.state.filters[filterName];
+ },
+
+ ifDefined: function(id, defaultValue) {
+ return 'ifDefined(' + id + ',' + this.escape(defaultValue) + ')';
+ },
+
+ plus: function(left, right) {
+ return 'plus(' + left + ',' + right + ')';
+ },
+
+ return_: function(id) {
+ this.current().body.push('return ', id, ';');
+ },
+
+ if_: function(test, alternate, consequent) {
+ if (test === true) {
+ alternate();
+ } else {
+ var body = this.current().body;
+ body.push('if(', test, '){');
+ alternate();
+ body.push('}');
+ if (consequent) {
+ body.push('else{');
+ consequent();
+ body.push('}');
+ }
+ }
+ },
+
+ not: function(expression) {
+ return '!(' + expression + ')';
+ },
+
+ isNull: function(expression) {
+ return expression + '==null';
+ },
+
+ notNull: function(expression) {
+ return expression + '!=null';
+ },
+
+ nonComputedMember: function(left, right) {
+ var SAFE_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
+ var UNSAFE_CHARACTERS = /[^$_a-zA-Z0-9]/g;
+ if (SAFE_IDENTIFIER.test(right)) {
+ return left + '.' + right;
+ } else {
+ return left + '["' + right.replace(UNSAFE_CHARACTERS, this.stringEscapeFn) + '"]';
+ }
+ },
+
+ computedMember: function(left, right) {
+ return left + '[' + right + ']';
+ },
+
+ member: function(left, right, computed) {
+ if (computed) return this.computedMember(left, right);
+ return this.nonComputedMember(left, right);
+ },
+
+ getStringValue: function(item) {
+ this.assign(item, 'getStringValue(' + item + ')');
+ },
+
+ lazyRecurse: function(ast, intoId, nameId, recursionFn, create, skipWatchIdCheck) {
+ var self = this;
+ return function() {
+ self.recurse(ast, intoId, nameId, recursionFn, create, skipWatchIdCheck);
+ };
+ },
+
+ lazyAssign: function(id, value) {
+ var self = this;
+ return function() {
+ self.assign(id, value);
+ };
+ },
+
+ stringEscapeRegex: /[^ a-zA-Z0-9]/g,
+
+ stringEscapeFn: function(c) {
+ return '\\u' + ('0000' + c.charCodeAt(0).toString(16)).slice(-4);
+ },
+
+ escape: function(value) {
+ if (isString(value)) return '\'' + value.replace(this.stringEscapeRegex, this.stringEscapeFn) + '\'';
+ if (isNumber(value)) return value.toString();
+ if (value === true) return 'true';
+ if (value === false) return 'false';
+ if (value === null) return 'null';
+ if (typeof value === 'undefined') return 'undefined';
+
+ throw $parseMinErr('esc', 'IMPOSSIBLE');
+ },
+
+ nextId: function(skip, init) {
+ var id = 'v' + (this.state.nextId++);
+ if (!skip) {
+ this.current().vars.push(id + (init ? '=' + init : ''));
+ }
+ return id;
+ },
+
+ current: function() {
+ return this.state[this.state.computing];
+ }
+};
+
+
+function ASTInterpreter($filter) {
+ this.$filter = $filter;
+}
+
+ASTInterpreter.prototype = {
+ compile: function(ast) {
+ var self = this;
+ findConstantAndWatchExpressions(ast, self.$filter);
+ var assignable;
+ var assign;
+ if ((assignable = assignableAST(ast))) {
+ assign = this.recurse(assignable);
+ }
+ var toWatch = getInputs(ast.body);
+ var inputs;
+ if (toWatch) {
+ inputs = [];
+ forEach(toWatch, function(watch, key) {
+ var input = self.recurse(watch);
+ input.isPure = watch.isPure;
+ watch.input = input;
+ inputs.push(input);
+ watch.watchId = key;
+ });
+ }
+ var expressions = [];
+ forEach(ast.body, function(expression) {
+ expressions.push(self.recurse(expression.expression));
+ });
+ var fn = ast.body.length === 0 ? noop :
+ ast.body.length === 1 ? expressions[0] :
+ function(scope, locals) {
+ var lastValue;
+ forEach(expressions, function(exp) {
+ lastValue = exp(scope, locals);
+ });
+ return lastValue;
+ };
+ if (assign) {
+ fn.assign = function(scope, value, locals) {
+ return assign(scope, locals, value);
+ };
+ }
+ if (inputs) {
+ fn.inputs = inputs;
+ }
+ return fn;
+ },
+
+ recurse: function(ast, context, create) {
+ var left, right, self = this, args;
+ if (ast.input) {
+ return this.inputs(ast.input, ast.watchId);
+ }
+ switch (ast.type) {
+ case AST.Literal:
+ return this.value(ast.value, context);
+ case AST.UnaryExpression:
+ right = this.recurse(ast.argument);
+ return this['unary' + ast.operator](right, context);
+ case AST.BinaryExpression:
+ left = this.recurse(ast.left);
+ right = this.recurse(ast.right);
+ return this['binary' + ast.operator](left, right, context);
+ case AST.LogicalExpression:
+ left = this.recurse(ast.left);
+ right = this.recurse(ast.right);
+ return this['binary' + ast.operator](left, right, context);
+ case AST.ConditionalExpression:
+ return this['ternary?:'](
+ this.recurse(ast.test),
+ this.recurse(ast.alternate),
+ this.recurse(ast.consequent),
+ context
+ );
+ case AST.Identifier:
+ return self.identifier(ast.name, context, create);
+ case AST.MemberExpression:
+ left = this.recurse(ast.object, false, !!create);
+ if (!ast.computed) {
+ right = ast.property.name;
+ }
+ if (ast.computed) right = this.recurse(ast.property);
+ return ast.computed ?
+ this.computedMember(left, right, context, create) :
+ this.nonComputedMember(left, right, context, create);
+ case AST.CallExpression:
+ args = [];
+ forEach(ast.arguments, function(expr) {
+ args.push(self.recurse(expr));
+ });
+ if (ast.filter) right = this.$filter(ast.callee.name);
+ if (!ast.filter) right = this.recurse(ast.callee, true);
+ return ast.filter ?
+ function(scope, locals, assign, inputs) {
+ var values = [];
+ for (var i = 0; i < args.length; ++i) {
+ values.push(args[i](scope, locals, assign, inputs));
+ }
+ var value = right.apply(undefined, values, inputs);
+ return context ? {context: undefined, name: undefined, value: value} : value;
+ } :
+ function(scope, locals, assign, inputs) {
+ var rhs = right(scope, locals, assign, inputs);
+ var value;
+ if (rhs.value != null) {
+ var values = [];
+ for (var i = 0; i < args.length; ++i) {
+ values.push(args[i](scope, locals, assign, inputs));
+ }
+ value = rhs.value.apply(rhs.context, values);
+ }
+ return context ? {value: value} : value;
+ };
+ case AST.AssignmentExpression:
+ left = this.recurse(ast.left, true, 1);
+ right = this.recurse(ast.right);
+ return function(scope, locals, assign, inputs) {
+ var lhs = left(scope, locals, assign, inputs);
+ var rhs = right(scope, locals, assign, inputs);
+ lhs.context[lhs.name] = rhs;
+ return context ? {value: rhs} : rhs;
+ };
+ case AST.ArrayExpression:
+ args = [];
+ forEach(ast.elements, function(expr) {
+ args.push(self.recurse(expr));
+ });
+ return function(scope, locals, assign, inputs) {
+ var value = [];
+ for (var i = 0; i < args.length; ++i) {
+ value.push(args[i](scope, locals, assign, inputs));
+ }
+ return context ? {value: value} : value;
+ };
+ case AST.ObjectExpression:
+ args = [];
+ forEach(ast.properties, function(property) {
+ if (property.computed) {
+ args.push({key: self.recurse(property.key),
+ computed: true,
+ value: self.recurse(property.value)
+ });
+ } else {
+ args.push({key: property.key.type === AST.Identifier ?
+ property.key.name :
+ ('' + property.key.value),
+ computed: false,
+ value: self.recurse(property.value)
+ });
+ }
+ });
+ return function(scope, locals, assign, inputs) {
+ var value = {};
+ for (var i = 0; i < args.length; ++i) {
+ if (args[i].computed) {
+ value[args[i].key(scope, locals, assign, inputs)] = args[i].value(scope, locals, assign, inputs);
+ } else {
+ value[args[i].key] = args[i].value(scope, locals, assign, inputs);
+ }
+ }
+ return context ? {value: value} : value;
+ };
+ case AST.ThisExpression:
+ return function(scope) {
+ return context ? {value: scope} : scope;
+ };
+ case AST.LocalsExpression:
+ return function(scope, locals) {
+ return context ? {value: locals} : locals;
+ };
+ case AST.NGValueParameter:
+ return function(scope, locals, assign) {
+ return context ? {value: assign} : assign;
+ };
+ }
+ },
+
+ 'unary+': function(argument, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = argument(scope, locals, assign, inputs);
+ if (isDefined(arg)) {
+ arg = +arg;
+ } else {
+ arg = 0;
+ }
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'unary-': function(argument, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = argument(scope, locals, assign, inputs);
+ if (isDefined(arg)) {
+ arg = -arg;
+ } else {
+ arg = -0;
+ }
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'unary!': function(argument, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = !argument(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary+': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var lhs = left(scope, locals, assign, inputs);
+ var rhs = right(scope, locals, assign, inputs);
+ var arg = plusFn(lhs, rhs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary-': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var lhs = left(scope, locals, assign, inputs);
+ var rhs = right(scope, locals, assign, inputs);
+ var arg = (isDefined(lhs) ? lhs : 0) - (isDefined(rhs) ? rhs : 0);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary*': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) * right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary/': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) / right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary%': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) % right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary===': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) === right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary!==': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) !== right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary==': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ // eslint-disable-next-line eqeqeq
+ var arg = left(scope, locals, assign, inputs) == right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary!=': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ // eslint-disable-next-line eqeqeq
+ var arg = left(scope, locals, assign, inputs) != right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary<': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) < right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary>': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) > right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary<=': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) <= right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary>=': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) >= right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary&&': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) && right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'binary||': function(left, right, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = left(scope, locals, assign, inputs) || right(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ 'ternary?:': function(test, alternate, consequent, context) {
+ return function(scope, locals, assign, inputs) {
+ var arg = test(scope, locals, assign, inputs) ? alternate(scope, locals, assign, inputs) : consequent(scope, locals, assign, inputs);
+ return context ? {value: arg} : arg;
+ };
+ },
+ value: function(value, context) {
+ return function() { return context ? {context: undefined, name: undefined, value: value} : value; };
+ },
+ identifier: function(name, context, create) {
+ return function(scope, locals, assign, inputs) {
+ var base = locals && (name in locals) ? locals : scope;
+ if (create && create !== 1 && base && base[name] == null) {
+ base[name] = {};
+ }
+ var value = base ? base[name] : undefined;
+ if (context) {
+ return {context: base, name: name, value: value};
+ } else {
+ return value;
+ }
+ };
+ },
+ computedMember: function(left, right, context, create) {
+ return function(scope, locals, assign, inputs) {
+ var lhs = left(scope, locals, assign, inputs);
+ var rhs;
+ var value;
+ if (lhs != null) {
+ rhs = right(scope, locals, assign, inputs);
+ rhs = getStringValue(rhs);
+ if (create && create !== 1) {
+ if (lhs && !(lhs[rhs])) {
+ lhs[rhs] = {};
+ }
+ }
+ value = lhs[rhs];
+ }
+ if (context) {
+ return {context: lhs, name: rhs, value: value};
+ } else {
+ return value;
+ }
+ };
+ },
+ nonComputedMember: function(left, right, context, create) {
+ return function(scope, locals, assign, inputs) {
+ var lhs = left(scope, locals, assign, inputs);
+ if (create && create !== 1) {
+ if (lhs && lhs[right] == null) {
+ lhs[right] = {};
+ }
+ }
+ var value = lhs != null ? lhs[right] : undefined;
+ if (context) {
+ return {context: lhs, name: right, value: value};
+ } else {
+ return value;
+ }
+ };
+ },
+ inputs: function(input, watchId) {
+ return function(scope, value, locals, inputs) {
+ if (inputs) return inputs[watchId];
+ return input(scope, value, locals);
+ };
+ }
+};
+
+/**
+ * @constructor
+ */
+function Parser(lexer, $filter, options) {
+ this.ast = new AST(lexer, options);
+ this.astCompiler = options.csp ? new ASTInterpreter($filter) :
+ new ASTCompiler($filter);
+}
+
+Parser.prototype = {
+ constructor: Parser,
+
+ parse: function(text) {
+ var ast = this.getAst(text);
+ var fn = this.astCompiler.compile(ast.ast);
+ fn.literal = isLiteral(ast.ast);
+ fn.constant = isConstant(ast.ast);
+ fn.oneTime = ast.oneTime;
+ return fn;
+ },
+
+ getAst: function(exp) {
+ var oneTime = false;
+ exp = exp.trim();
+
+ if (exp.charAt(0) === ':' && exp.charAt(1) === ':') {
+ oneTime = true;
+ exp = exp.substring(2);
+ }
+ return {
+ ast: this.ast.ast(exp),
+ oneTime: oneTime
+ };
+ }
+};
+
+function getValueOf(value) {
+ return isFunction(value.valueOf) ? value.valueOf() : objectValueOf.call(value);
+}
+
+///////////////////////////////////
+
+/**
+ * @ngdoc service
+ * @name $parse
+ * @kind function
+ *
+ * @description
+ *
+ * Converts AngularJS {@link guide/expression expression} into a function.
+ *
+ * ```js
+ * var getter = $parse('user.name');
+ * var setter = getter.assign;
+ * var context = {user:{name:'AngularJS'}};
+ * var locals = {user:{name:'local'}};
+ *
+ * expect(getter(context)).toEqual('AngularJS');
+ * setter(context, 'newValue');
+ * expect(context.user.name).toEqual('newValue');
+ * expect(getter(context, locals)).toEqual('local');
+ * ```
+ *
+ *
+ * @param {string} expression String expression to compile.
+ * @returns {function(context, locals)} a function which represents the compiled expression:
+ *
+ * * `context` – `{object}` – an object against which any expressions embedded in the strings
+ * are evaluated against (typically a scope object).
+ * * `locals` – `{object=}` – local variables context object, useful for overriding values in
+ * `context`.
+ *
+ * The returned function also has the following properties:
+ * * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript
+ * literal.
+ * * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript
+ * constant literals.
+ * * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be
+ * set to a function to change its value on the given context.
+ *
+ */
+
+
+/**
+ * @ngdoc provider
+ * @name $parseProvider
+ * @this
+ *
+ * @description
+ * `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse}
+ * service.
+ */
+function $ParseProvider() {
+ var cache = createMap();
+ var literals = {
+ 'true': true,
+ 'false': false,
+ 'null': null,
+ 'undefined': undefined
+ };
+ var identStart, identContinue;
+
+ /**
+ * @ngdoc method
+ * @name $parseProvider#addLiteral
+ * @description
+ *
+ * Configure $parse service to add literal values that will be present as literal at expressions.
+ *
+ * @param {string} literalName Token for the literal value. The literal name value must be a valid literal name.
+ * @param {*} literalValue Value for this literal. All literal values must be primitives or `undefined`.
+ *
+ **/
+ this.addLiteral = function(literalName, literalValue) {
+ literals[literalName] = literalValue;
+ };
+
+ /**
+ * @ngdoc method
+ * @name $parseProvider#setIdentifierFns
+ *
+ * @description
+ *
+ * Allows defining the set of characters that are allowed in AngularJS expressions. The function
+ * `identifierStart` will get called to know if a given character is a valid character to be the
+ * first character for an identifier. The function `identifierContinue` will get called to know if
+ * a given character is a valid character to be a follow-up identifier character. The functions
+ * `identifierStart` and `identifierContinue` will receive as arguments the single character to be
+ * identifier and the character code point. These arguments will be `string` and `numeric`. Keep in
+ * mind that the `string` parameter can be two characters long depending on the character
+ * representation. It is expected for the function to return `true` or `false`, whether that
+ * character is allowed or not.
+ *
+ * Since this function will be called extensively, keep the implementation of these functions fast,
+ * as the performance of these functions have a direct impact on the expressions parsing speed.
+ *
+ * @param {function=} identifierStart The function that will decide whether the given character is
+ * a valid identifier start character.
+ * @param {function=} identifierContinue The function that will decide whether the given character is
+ * a valid identifier continue character.
+ */
+ this.setIdentifierFns = function(identifierStart, identifierContinue) {
+ identStart = identifierStart;
+ identContinue = identifierContinue;
+ return this;
+ };
+
+ this.$get = ['$filter', function($filter) {
+ var noUnsafeEval = csp().noUnsafeEval;
+ var $parseOptions = {
+ csp: noUnsafeEval,
+ literals: copy(literals),
+ isIdentifierStart: isFunction(identStart) && identStart,
+ isIdentifierContinue: isFunction(identContinue) && identContinue
+ };
+ $parse.$$getAst = $$getAst;
+ return $parse;
+
+ function $parse(exp, interceptorFn) {
+ var parsedExpression, cacheKey;
+
+ switch (typeof exp) {
+ case 'string':
+ exp = exp.trim();
+ cacheKey = exp;
+
+ parsedExpression = cache[cacheKey];
+
+ if (!parsedExpression) {
+ var lexer = new Lexer($parseOptions);
+ var parser = new Parser(lexer, $filter, $parseOptions);
+ parsedExpression = parser.parse(exp);
+
+ cache[cacheKey] = addWatchDelegate(parsedExpression);
+ }
+ return addInterceptor(parsedExpression, interceptorFn);
+
+ case 'function':
+ return addInterceptor(exp, interceptorFn);
+
+ default:
+ return addInterceptor(noop, interceptorFn);
+ }
+ }
+
+ function $$getAst(exp) {
+ var lexer = new Lexer($parseOptions);
+ var parser = new Parser(lexer, $filter, $parseOptions);
+ return parser.getAst(exp).ast;
+ }
+
+ function expressionInputDirtyCheck(newValue, oldValueOfValue, compareObjectIdentity) {
+
+ if (newValue == null || oldValueOfValue == null) { // null/undefined
+ return newValue === oldValueOfValue;
+ }
+
+ if (typeof newValue === 'object') {
+
+ // attempt to convert the value to a primitive type
+ // TODO(docs): add a note to docs that by implementing valueOf even objects and arrays can
+ // be cheaply dirty-checked
+ newValue = getValueOf(newValue);
+
+ if (typeof newValue === 'object' && !compareObjectIdentity) {
+ // objects/arrays are not supported - deep-watching them would be too expensive
+ return false;
+ }
+
+ // fall-through to the primitive equality check
+ }
+
+ //Primitive or NaN
+ // eslint-disable-next-line no-self-compare
+ return newValue === oldValueOfValue || (newValue !== newValue && oldValueOfValue !== oldValueOfValue);
+ }
+
+ function inputsWatchDelegate(scope, listener, objectEquality, parsedExpression, prettyPrintExpression) {
+ var inputExpressions = parsedExpression.inputs;
+ var lastResult;
+
+ if (inputExpressions.length === 1) {
+ var oldInputValueOf = expressionInputDirtyCheck; // init to something unique so that equals check fails
+ inputExpressions = inputExpressions[0];
+ return scope.$watch(function expressionInputWatch(scope) {
+ var newInputValue = inputExpressions(scope);
+ if (!expressionInputDirtyCheck(newInputValue, oldInputValueOf, inputExpressions.isPure)) {
+ lastResult = parsedExpression(scope, undefined, undefined, [newInputValue]);
+ oldInputValueOf = newInputValue && getValueOf(newInputValue);
+ }
+ return lastResult;
+ }, listener, objectEquality, prettyPrintExpression);
+ }
+
+ var oldInputValueOfValues = [];
+ var oldInputValues = [];
+ for (var i = 0, ii = inputExpressions.length; i < ii; i++) {
+ oldInputValueOfValues[i] = expressionInputDirtyCheck; // init to something unique so that equals check fails
+ oldInputValues[i] = null;
+ }
+
+ return scope.$watch(function expressionInputsWatch(scope) {
+ var changed = false;
+
+ for (var i = 0, ii = inputExpressions.length; i < ii; i++) {
+ var newInputValue = inputExpressions[i](scope);
+ if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValueOfValues[i], inputExpressions[i].isPure))) {
+ oldInputValues[i] = newInputValue;
+ oldInputValueOfValues[i] = newInputValue && getValueOf(newInputValue);
+ }
+ }
+
+ if (changed) {
+ lastResult = parsedExpression(scope, undefined, undefined, oldInputValues);
+ }
+
+ return lastResult;
+ }, listener, objectEquality, prettyPrintExpression);
+ }
+
+ function oneTimeWatchDelegate(scope, listener, objectEquality, parsedExpression, prettyPrintExpression) {
+ var isDone = parsedExpression.literal ? isAllDefined : isDefined;
+ var unwatch, lastValue;
+
+ var exp = parsedExpression.$$intercepted || parsedExpression;
+ var post = parsedExpression.$$interceptor || identity;
+
+ var useInputs = parsedExpression.inputs && !exp.inputs;
+
+ // Propogate the literal/inputs/constant attributes
+ // ... but not oneTime since we are handling it
+ oneTimeWatch.literal = parsedExpression.literal;
+ oneTimeWatch.constant = parsedExpression.constant;
+ oneTimeWatch.inputs = parsedExpression.inputs;
+
+ // Allow other delegates to run on this wrapped expression
+ addWatchDelegate(oneTimeWatch);
+
+ unwatch = scope.$watch(oneTimeWatch, listener, objectEquality, prettyPrintExpression);
+
+ return unwatch;
+
+ function unwatchIfDone() {
+ if (isDone(lastValue)) {
+ unwatch();
+ }
+ }
+
+ function oneTimeWatch(scope, locals, assign, inputs) {
+ lastValue = useInputs && inputs ? inputs[0] : exp(scope, locals, assign, inputs);
+ if (isDone(lastValue)) {
+ scope.$$postDigest(unwatchIfDone);
+ }
+ return post(lastValue);
+ }
+ }
+
+ function isAllDefined(value) {
+ var allDefined = true;
+ forEach(value, function(val) {
+ if (!isDefined(val)) allDefined = false;
+ });
+ return allDefined;
+ }
+
+ function constantWatchDelegate(scope, listener, objectEquality, parsedExpression) {
+ var unwatch = scope.$watch(function constantWatch(scope) {
+ unwatch();
+ return parsedExpression(scope);
+ }, listener, objectEquality);
+ return unwatch;
+ }
+
+ function addWatchDelegate(parsedExpression) {
+ if (parsedExpression.constant) {
+ parsedExpression.$$watchDelegate = constantWatchDelegate;
+ } else if (parsedExpression.oneTime) {
+ parsedExpression.$$watchDelegate = oneTimeWatchDelegate;
+ } else if (parsedExpression.inputs) {
+ parsedExpression.$$watchDelegate = inputsWatchDelegate;
+ }
+
+ return parsedExpression;
+ }
+
+ function chainInterceptors(first, second) {
+ function chainedInterceptor(value) {
+ return second(first(value));
+ }
+ chainedInterceptor.$stateful = first.$stateful || second.$stateful;
+ chainedInterceptor.$$pure = first.$$pure && second.$$pure;
+
+ return chainedInterceptor;
+ }
+
+ function addInterceptor(parsedExpression, interceptorFn) {
+ if (!interceptorFn) return parsedExpression;
+
+ // Extract any existing interceptors out of the parsedExpression
+ // to ensure the original parsedExpression is always the $$intercepted
+ if (parsedExpression.$$interceptor) {
+ interceptorFn = chainInterceptors(parsedExpression.$$interceptor, interceptorFn);
+ parsedExpression = parsedExpression.$$intercepted;
+ }
+
+ var useInputs = false;
+
+ var fn = function interceptedExpression(scope, locals, assign, inputs) {
+ var value = useInputs && inputs ? inputs[0] : parsedExpression(scope, locals, assign, inputs);
+ return interceptorFn(value);
+ };
+
+ // Maintain references to the interceptor/intercepted
+ fn.$$intercepted = parsedExpression;
+ fn.$$interceptor = interceptorFn;
+
+ // Propogate the literal/oneTime/constant attributes
+ fn.literal = parsedExpression.literal;
+ fn.oneTime = parsedExpression.oneTime;
+ fn.constant = parsedExpression.constant;
+
+ // Treat the interceptor like filters.
+ // If it is not $stateful then only watch its inputs.
+ // If the expression itself has no inputs then use the full expression as an input.
+ if (!interceptorFn.$stateful) {
+ useInputs = !parsedExpression.inputs;
+ fn.inputs = parsedExpression.inputs ? parsedExpression.inputs : [parsedExpression];
+
+ if (!interceptorFn.$$pure) {
+ fn.inputs = fn.inputs.map(function(e) {
+ // Remove the isPure flag of inputs when it is not absolute because they are now wrapped in a
+ // non-pure interceptor function.
+ if (e.isPure === PURITY_RELATIVE) {
+ return function depurifier(s) { return e(s); };
+ }
+ return e;
+ });
+ }
+ }
+
+ return addWatchDelegate(fn);
+ }
+ }];
+}
+
+/**
+ * @ngdoc service
+ * @name $q
+ * @requires $rootScope
+ *
+ * @description
+ * A service that helps you run functions asynchronously, and use their return values (or exceptions)
+ * when they are done processing.
+ *
+ * This is a [Promises/A+](https://promisesaplus.com/)-compliant implementation of promises/deferred
+ * objects inspired by [Kris Kowal's Q](https://github.com/kriskowal/q).
+ *
+ * $q can be used in two fashions --- one which is more similar to Kris Kowal's Q or jQuery's Deferred
+ * implementations, and the other which resembles ES6 (ES2015) promises to some degree.
+ *
+ * ## $q constructor
+ *
+ * The streamlined ES6 style promise is essentially just using $q as a constructor which takes a `resolver`
+ * function as the first argument. This is similar to the native Promise implementation from ES6,
+ * see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
+ *
+ * While the constructor-style use is supported, not all of the supporting methods from ES6 promises are
+ * available yet.
+ *
+ * It can be used like so:
+ *
+ * ```js
+ * // for the purpose of this example let's assume that variables `$q` and `okToGreet`
+ * // are available in the current lexical scope (they could have been injected or passed in).
+ *
+ * function asyncGreet(name) {
+ * // perform some asynchronous operation, resolve or reject the promise when appropriate.
+ * return $q(function(resolve, reject) {
+ * setTimeout(function() {
+ * if (okToGreet(name)) {
+ * resolve('Hello, ' + name + '!');
+ * } else {
+ * reject('Greeting ' + name + ' is not allowed.');
+ * }
+ * }, 1000);
+ * });
+ * }
+ *
+ * var promise = asyncGreet('Robin Hood');
+ * promise.then(function(greeting) {
+ * alert('Success: ' + greeting);
+ * }, function(reason) {
+ * alert('Failed: ' + reason);
+ * });
+ * ```
+ *
+ * Note: progress/notify callbacks are not currently supported via the ES6-style interface.
+ *
+ * Note: unlike ES6 behavior, an exception thrown in the constructor function will NOT implicitly reject the promise.
+ *
+ * However, the more traditional CommonJS-style usage is still available, and documented below.
+ *
+ * [The CommonJS Promise proposal](http://wiki.commonjs.org/wiki/Promises) describes a promise as an
+ * interface for interacting with an object that represents the result of an action that is
+ * performed asynchronously, and may or may not be finished at any given point in time.
+ *
+ * From the perspective of dealing with error handling, deferred and promise APIs are to
+ * asynchronous programming what `try`, `catch` and `throw` keywords are to synchronous programming.
+ *
+ * ```js
+ * // for the purpose of this example let's assume that variables `$q` and `okToGreet`
+ * // are available in the current lexical scope (they could have been injected or passed in).
+ *
+ * function asyncGreet(name) {
+ * var deferred = $q.defer();
+ *
+ * setTimeout(function() {
+ * deferred.notify('About to greet ' + name + '.');
+ *
+ * if (okToGreet(name)) {
+ * deferred.resolve('Hello, ' + name + '!');
+ * } else {
+ * deferred.reject('Greeting ' + name + ' is not allowed.');
+ * }
+ * }, 1000);
+ *
+ * return deferred.promise;
+ * }
+ *
+ * var promise = asyncGreet('Robin Hood');
+ * promise.then(function(greeting) {
+ * alert('Success: ' + greeting);
+ * }, function(reason) {
+ * alert('Failed: ' + reason);
+ * }, function(update) {
+ * alert('Got notification: ' + update);
+ * });
+ * ```
+ *
+ * At first it might not be obvious why this extra complexity is worth the trouble. The payoff
+ * comes in the way of guarantees that promise and deferred APIs make, see
+ * https://github.com/kriskowal/uncommonjs/blob/master/promises/specification.md.
+ *
+ * Additionally the promise api allows for composition that is very hard to do with the
+ * traditional callback ([CPS](http://en.wikipedia.org/wiki/Continuation-passing_style)) approach.
+ * For more on this please see the [Q documentation](https://github.com/kriskowal/q) especially the
+ * section on serial or parallel joining of promises.
+ *
+ * ## The Deferred API
+ *
+ * A new instance of deferred is constructed by calling `$q.defer()`.
+ *
+ * The purpose of the deferred object is to expose the associated Promise instance as well as APIs
+ * that can be used for signaling the successful or unsuccessful completion, as well as the status
+ * of the task.
+ *
+ * **Methods**
+ *
+ * - `resolve(value)` – resolves the derived promise with the `value`. If the value is a rejection
+ * constructed via `$q.reject`, the promise will be rejected instead.
+ * - `reject(reason)` – rejects the derived promise with the `reason`. This is equivalent to
+ * resolving it with a rejection constructed via `$q.reject`.
+ * - `notify(value)` - provides updates on the status of the promise's execution. This may be called
+ * multiple times before the promise is either resolved or rejected.
+ *
+ * **Properties**
+ *
+ * - promise – `{Promise}` – promise object associated with this deferred.
+ *
+ *
+ * ## The Promise API
+ *
+ * A new promise instance is created when a deferred instance is created and can be retrieved by
+ * calling `deferred.promise`.
+ *
+ * The purpose of the promise object is to allow for interested parties to get access to the result
+ * of the deferred task when it completes.
+ *
+ * **Methods**
+ *
+ * - `then(successCallback, [errorCallback], [notifyCallback])` – regardless of when the promise was or
+ * will be resolved or rejected, `then` calls one of the success or error callbacks asynchronously
+ * as soon as the result is available. The callbacks are called with a single argument: the result
+ * or rejection reason. Additionally, the notify callback may be called zero or more times to
+ * provide a progress indication, before the promise is resolved or rejected.
+ *
+ * This method *returns a new promise* which is resolved or rejected via the return value of the
+ * `successCallback`, `errorCallback` (unless that value is a promise, in which case it is resolved
+ * with the value which is resolved in that promise using
+ * [promise chaining](http://www.html5rocks.com/en/tutorials/es6/promises/#toc-promises-queues)).
+ * It also notifies via the return value of the `notifyCallback` method. The promise cannot be
+ * resolved or rejected from the notifyCallback method. The errorCallback and notifyCallback
+ * arguments are optional.
+ *
+ * - `catch(errorCallback)` – shorthand for `promise.then(null, errorCallback)`
+ *
+ * - `finally(callback, notifyCallback)` – allows you to observe either the fulfillment or rejection of a promise,
+ * but to do so without modifying the final value. This is useful to release resources or do some
+ * clean-up that needs to be done whether the promise was rejected or resolved. See the [full
+ * specification](https://github.com/kriskowal/q/wiki/API-Reference#promisefinallycallback) for
+ * more information.
+ *
+ * ## Chaining promises
+ *
+ * Because calling the `then` method of a promise returns a new derived promise, it is easily
+ * possible to create a chain of promises:
+ *
+ * ```js
+ * promiseB = promiseA.then(function(result) {
+ * return result + 1;
+ * });
+ *
+ * // promiseB will be resolved immediately after promiseA is resolved and its value
+ * // will be the result of promiseA incremented by 1
+ * ```
+ *
+ * It is possible to create chains of any length and since a promise can be resolved with another
+ * promise (which will defer its resolution further), it is possible to pause/defer resolution of
+ * the promises at any point in the chain. This makes it possible to implement powerful APIs like
+ * $http's response interceptors.
+ *
+ *
+ * ## Differences between Kris Kowal's Q and $q
+ *
+ * There are two main differences:
+ *
+ * - $q is integrated with the {@link ng.$rootScope.Scope} Scope model observation
+ * mechanism in AngularJS, which means faster propagation of resolution or rejection into your
+ * models and avoiding unnecessary browser repaints, which would result in flickering UI.
+ * - Q has many more features than $q, but that comes at a cost of bytes. $q is tiny, but contains
+ * all the important functionality needed for common async tasks.
+ *
+ * ## Testing
+ *
+ * ```js
+ * it('should simulate promise', inject(function($q, $rootScope) {
+ * var deferred = $q.defer();
+ * var promise = deferred.promise;
+ * var resolvedValue;
+ *
+ * promise.then(function(value) { resolvedValue = value; });
+ * expect(resolvedValue).toBeUndefined();
+ *
+ * // Simulate resolving of promise
+ * deferred.resolve(123);
+ * // Note that the 'then' function does not get called synchronously.
+ * // This is because we want the promise API to always be async, whether or not
+ * // it got called synchronously or asynchronously.
+ * expect(resolvedValue).toBeUndefined();
+ *
+ * // Propagate promise resolution to 'then' functions using $apply().
+ * $rootScope.$apply();
+ * expect(resolvedValue).toEqual(123);
+ * }));
+ * ```
+ *
+ * @param {function(function, function)} resolver Function which is responsible for resolving or
+ * rejecting the newly created promise. The first parameter is a function which resolves the
+ * promise, the second parameter is a function which rejects the promise.
+ *
+ * @returns {Promise} The newly created promise.
+ */
+/**
+ * @ngdoc provider
+ * @name $qProvider
+ * @this
+ *
+ * @description
+ */
+function $QProvider() {
+ var errorOnUnhandledRejections = true;
+ this.$get = ['$rootScope', '$exceptionHandler', function($rootScope, $exceptionHandler) {
+ return qFactory(function(callback) {
+ $rootScope.$evalAsync(callback);
+ }, $exceptionHandler, errorOnUnhandledRejections);
+ }];
+
+ /**
+ * @ngdoc method
+ * @name $qProvider#errorOnUnhandledRejections
+ * @kind function
+ *
+ * @description
+ * Retrieves or overrides whether to generate an error when a rejected promise is not handled.
+ * This feature is enabled by default.
+ *
+ * @param {boolean=} value Whether to generate an error when a rejected promise is not handled.
+ * @returns {boolean|ng.$qProvider} Current value when called without a new value or self for
+ * chaining otherwise.
+ */
+ this.errorOnUnhandledRejections = function(value) {
+ if (isDefined(value)) {
+ errorOnUnhandledRejections = value;
+ return this;
+ } else {
+ return errorOnUnhandledRejections;
+ }
+ };
+}
+
+/** @this */
+function $$QProvider() {
+ var errorOnUnhandledRejections = true;
+ this.$get = ['$browser', '$exceptionHandler', function($browser, $exceptionHandler) {
+ return qFactory(function(callback) {
+ $browser.defer(callback);
+ }, $exceptionHandler, errorOnUnhandledRejections);
+ }];
+
+ this.errorOnUnhandledRejections = function(value) {
+ if (isDefined(value)) {
+ errorOnUnhandledRejections = value;
+ return this;
+ } else {
+ return errorOnUnhandledRejections;
+ }
+ };
+}
+
+/**
+ * Constructs a promise manager.
+ *
+ * @param {function(function)} nextTick Function for executing functions in the next turn.
+ * @param {function(...*)} exceptionHandler Function into which unexpected exceptions are passed for
+ * debugging purposes.
+ * @param {boolean=} errorOnUnhandledRejections Whether an error should be generated on unhandled
+ * promises rejections.
+ * @returns {object} Promise manager.
+ */
+function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
+ var $qMinErr = minErr('$q', TypeError);
+ var queueSize = 0;
+ var checkQueue = [];
+
+ /**
+ * @ngdoc method
+ * @name ng.$q#defer
+ * @kind function
+ *
+ * @description
+ * Creates a `Deferred` object which represents a task which will finish in the future.
+ *
+ * @returns {Deferred} Returns a new instance of deferred.
+ */
+ function defer() {
+ return new Deferred();
+ }
+
+ function Deferred() {
+ var promise = this.promise = new Promise();
+ //Non prototype methods necessary to support unbound execution :/
+ this.resolve = function(val) { resolvePromise(promise, val); };
+ this.reject = function(reason) { rejectPromise(promise, reason); };
+ this.notify = function(progress) { notifyPromise(promise, progress); };
+ }
+
+
+ function Promise() {
+ this.$$state = { status: 0 };
+ }
+
+ extend(Promise.prototype, {
+ then: function(onFulfilled, onRejected, progressBack) {
+ if (isUndefined(onFulfilled) && isUndefined(onRejected) && isUndefined(progressBack)) {
+ return this;
+ }
+ var result = new Promise();
+
+ this.$$state.pending = this.$$state.pending || [];
+ this.$$state.pending.push([result, onFulfilled, onRejected, progressBack]);
+ if (this.$$state.status > 0) scheduleProcessQueue(this.$$state);
+
+ return result;
+ },
+
+ 'catch': function(callback) {
+ return this.then(null, callback);
+ },
+
+ 'finally': function(callback, progressBack) {
+ return this.then(function(value) {
+ return handleCallback(value, resolve, callback);
+ }, function(error) {
+ return handleCallback(error, reject, callback);
+ }, progressBack);
+ }
+ });
+
+ function processQueue(state) {
+ var fn, promise, pending;
+
+ pending = state.pending;
+ state.processScheduled = false;
+ state.pending = undefined;
+ try {
+ for (var i = 0, ii = pending.length; i < ii; ++i) {
+ markQStateExceptionHandled(state);
+ promise = pending[i][0];
+ fn = pending[i][state.status];
+ try {
+ if (isFunction(fn)) {
+ resolvePromise(promise, fn(state.value));
+ } else if (state.status === 1) {
+ resolvePromise(promise, state.value);
+ } else {
+ rejectPromise(promise, state.value);
+ }
+ } catch (e) {
+ rejectPromise(promise, e);
+ // This error is explicitly marked for being passed to the $exceptionHandler
+ if (e && e.$$passToExceptionHandler === true) {
+ exceptionHandler(e);
+ }
+ }
+ }
+ } finally {
+ --queueSize;
+ if (errorOnUnhandledRejections && queueSize === 0) {
+ nextTick(processChecks);
+ }
+ }
+ }
+
+ function processChecks() {
+ // eslint-disable-next-line no-unmodified-loop-condition
+ while (!queueSize && checkQueue.length) {
+ var toCheck = checkQueue.shift();
+ if (!isStateExceptionHandled(toCheck)) {
+ markQStateExceptionHandled(toCheck);
+ var errorMessage = 'Possibly unhandled rejection: ' + toDebugString(toCheck.value);
+ if (isError(toCheck.value)) {
+ exceptionHandler(toCheck.value, errorMessage);
+ } else {
+ exceptionHandler(errorMessage);
+ }
+ }
+ }
+ }
+
+ function scheduleProcessQueue(state) {
+ if (errorOnUnhandledRejections && !state.pending && state.status === 2 && !isStateExceptionHandled(state)) {
+ if (queueSize === 0 && checkQueue.length === 0) {
+ nextTick(processChecks);
+ }
+ checkQueue.push(state);
+ }
+ if (state.processScheduled || !state.pending) return;
+ state.processScheduled = true;
+ ++queueSize;
+ nextTick(function() { processQueue(state); });
+ }
+
+ function resolvePromise(promise, val) {
+ if (promise.$$state.status) return;
+ if (val === promise) {
+ $$reject(promise, $qMinErr(
+ 'qcycle',
+ 'Expected promise to be resolved with value other than itself \'{0}\'',
+ val));
+ } else {
+ $$resolve(promise, val);
+ }
+
+ }
+
+ function $$resolve(promise, val) {
+ var then;
+ var done = false;
+ try {
+ if (isObject(val) || isFunction(val)) then = val.then;
+ if (isFunction(then)) {
+ promise.$$state.status = -1;
+ then.call(val, doResolve, doReject, doNotify);
+ } else {
+ promise.$$state.value = val;
+ promise.$$state.status = 1;
+ scheduleProcessQueue(promise.$$state);
+ }
+ } catch (e) {
+ doReject(e);
+ }
+
+ function doResolve(val) {
+ if (done) return;
+ done = true;
+ $$resolve(promise, val);
+ }
+ function doReject(val) {
+ if (done) return;
+ done = true;
+ $$reject(promise, val);
+ }
+ function doNotify(progress) {
+ notifyPromise(promise, progress);
+ }
+ }
+
+ function rejectPromise(promise, reason) {
+ if (promise.$$state.status) return;
+ $$reject(promise, reason);
+ }
+
+ function $$reject(promise, reason) {
+ promise.$$state.value = reason;
+ promise.$$state.status = 2;
+ scheduleProcessQueue(promise.$$state);
+ }
+
+ function notifyPromise(promise, progress) {
+ var callbacks = promise.$$state.pending;
+
+ if ((promise.$$state.status <= 0) && callbacks && callbacks.length) {
+ nextTick(function() {
+ var callback, result;
+ for (var i = 0, ii = callbacks.length; i < ii; i++) {
+ result = callbacks[i][0];
+ callback = callbacks[i][3];
+ try {
+ notifyPromise(result, isFunction(callback) ? callback(progress) : progress);
+ } catch (e) {
+ exceptionHandler(e);
+ }
+ }
+ });
+ }
+ }
+
+ /**
+ * @ngdoc method
+ * @name $q#reject
+ * @kind function
+ *
+ * @description
+ * Creates a promise that is resolved as rejected with the specified `reason`. This api should be
+ * used to forward rejection in a chain of promises. If you are dealing with the last promise in
+ * a promise chain, you don't need to worry about it.
+ *
+ * When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of
+ * `reject` as the `throw` keyword in JavaScript. This also means that if you "catch" an error via
+ * a promise error callback and you want to forward the error to the promise derived from the
+ * current promise, you have to "rethrow" the error by returning a rejection constructed via
+ * `reject`.
+ *
+ * ```js
+ * promiseB = promiseA.then(function(result) {
+ * // success: do something and resolve promiseB
+ * // with the old or a new result
+ * return result;
+ * }, function(reason) {
+ * // error: handle the error if possible and
+ * // resolve promiseB with newPromiseOrValue,
+ * // otherwise forward the rejection to promiseB
+ * if (canHandle(reason)) {
+ * // handle the error and recover
+ * return newPromiseOrValue;
+ * }
+ * return $q.reject(reason);
+ * });
+ * ```
+ *
+ * @param {*} reason Constant, message, exception or an object representing the rejection reason.
+ * @returns {Promise} Returns a promise that was already resolved as rejected with the `reason`.
+ */
+ function reject(reason) {
+ var result = new Promise();
+ rejectPromise(result, reason);
+ return result;
+ }
+
+ function handleCallback(value, resolver, callback) {
+ var callbackOutput = null;
+ try {
+ if (isFunction(callback)) callbackOutput = callback();
+ } catch (e) {
+ return reject(e);
+ }
+ if (isPromiseLike(callbackOutput)) {
+ return callbackOutput.then(function() {
+ return resolver(value);
+ }, reject);
+ } else {
+ return resolver(value);
+ }
+ }
+
+ /**
+ * @ngdoc method
+ * @name $q#when
+ * @kind function
+ *
+ * @description
+ * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise.
+ * This is useful when you are dealing with an object that might or might not be a promise, or if
+ * the promise comes from a source that can't be trusted.
+ *
+ * @param {*} value Value or a promise
+ * @param {Function=} successCallback
+ * @param {Function=} errorCallback
+ * @param {Function=} progressCallback
+ * @returns {Promise} Returns a promise of the passed value or promise
+ */
+
+
+ function when(value, callback, errback, progressBack) {
+ var result = new Promise();
+ resolvePromise(result, value);
+ return result.then(callback, errback, progressBack);
+ }
+
+ /**
+ * @ngdoc method
+ * @name $q#resolve
+ * @kind function
+ *
+ * @description
+ * Alias of {@link ng.$q#when when} to maintain naming consistency with ES6.
+ *
+ * @param {*} value Value or a promise
+ * @param {Function=} successCallback
+ * @param {Function=} errorCallback
+ * @param {Function=} progressCallback
+ * @returns {Promise} Returns a promise of the passed value or promise
+ */
+ var resolve = when;
+
+ /**
+ * @ngdoc method
+ * @name $q#all
+ * @kind function
+ *
+ * @description
+ * Combines multiple promises into a single promise that is resolved when all of the input
+ * promises are resolved.
+ *
+ * @param {Array.<Promise>|Object.<Promise>} promises An array or hash of promises.
+ * @returns {Promise} Returns a single promise that will be resolved with an array/hash of values,
+ * each value corresponding to the promise at the same index/key in the `promises` array/hash.
+ * If any of the promises is resolved with a rejection, this resulting promise will be rejected
+ * with the same rejection value.
+ */
+
+ function all(promises) {
+ var result = new Promise(),
+ counter = 0,
+ results = isArray(promises) ? [] : {};
+
+ forEach(promises, function(promise, key) {
+ counter++;
+ when(promise).then(function(value) {
+ results[key] = value;
+ if (!(--counter)) resolvePromise(result, results);
+ }, function(reason) {
+ rejectPromise(result, reason);
+ });
+ });
+
+ if (counter === 0) {
+ resolvePromise(result, results);
+ }
+
+ return result;
+ }
+
+ /**
+ * @ngdoc method
+ * @name $q#race
+ * @kind function
+ *
+ * @description
+ * Returns a promise that resolves or rejects as soon as one of those promises
+ * resolves or rejects, with the value or reason from that promise.
+ *
+ * @param {Array.<Promise>|Object.<Promise>} promises An array or hash of promises.
+ * @returns {Promise} a promise that resolves or rejects as soon as one of the `promises`
+ * resolves or rejects, with the value or reason from that promise.
+ */
+
+ function race(promises) {
+ var deferred = defer();
+
+ forEach(promises, function(promise) {
+ when(promise).then(deferred.resolve, deferred.reject);
+ });
+
+ return deferred.promise;
+ }
+
+ function $Q(resolver) {
+ if (!isFunction(resolver)) {
+ throw $qMinErr('norslvr', 'Expected resolverFn, got \'{0}\'', resolver);
+ }
+
+ var promise = new Promise();
+
+ function resolveFn(value) {
+ resolvePromise(promise, value);
+ }
+
+ function rejectFn(reason) {
+ rejectPromise(promise, reason);
+ }
+
+ resolver(resolveFn, rejectFn);
+
+ return promise;
+ }
+
+ // Let's make the instanceof operator work for promises, so that
+ // `new $q(fn) instanceof $q` would evaluate to true.
+ $Q.prototype = Promise.prototype;
+
+ $Q.defer = defer;
+ $Q.reject = reject;
+ $Q.when = when;
+ $Q.resolve = resolve;
+ $Q.all = all;
+ $Q.race = race;
+
+ return $Q;
+}
+
+function isStateExceptionHandled(state) {
+ return !!state.pur;
+}
+function markQStateExceptionHandled(state) {
+ state.pur = true;
+}
+function markQExceptionHandled(q) {
+ // Built-in `$q` promises will always have a `$$state` property. This check is to allow
+ // overwriting `$q` with a different promise library (e.g. Bluebird + angular-bluebird-promises).
+ // (Currently, this is the only method that might be called with a promise, even if it is not
+ // created by the built-in `$q`.)
+ if (q.$$state) {
+ markQStateExceptionHandled(q.$$state);
+ }
+}
+
+/** @this */
+function $$RAFProvider() { //rAF
+ this.$get = ['$window', '$timeout', function($window, $timeout) {
+ var requestAnimationFrame = $window.requestAnimationFrame ||
+ $window.webkitRequestAnimationFrame;
+
+ var cancelAnimationFrame = $window.cancelAnimationFrame ||
+ $window.webkitCancelAnimationFrame ||
+ $window.webkitCancelRequestAnimationFrame;
+
+ var rafSupported = !!requestAnimationFrame;
+ var raf = rafSupported
+ ? function(fn) {
+ var id = requestAnimationFrame(fn);
+ return function() {
+ cancelAnimationFrame(id);
+ };
+ }
+ : function(fn) {
+ var timer = $timeout(fn, 16.66, false); // 1000 / 60 = 16.666
+ return function() {
+ $timeout.cancel(timer);
+ };
+ };
+
+ raf.supported = rafSupported;
+
+ return raf;
+ }];
+}
+
+/**
+ * DESIGN NOTES
+ *
+ * The design decisions behind the scope are heavily favored for speed and memory consumption.
+ *
+ * The typical use of scope is to watch the expressions, which most of the time return the same
+ * value as last time so we optimize the operation.
+ *
+ * Closures construction is expensive in terms of speed as well as memory:
+ * - No closures, instead use prototypical inheritance for API
+ * - Internal state needs to be stored on scope directly, which means that private state is
+ * exposed as $$____ properties
+ *
+ * Loop operations are optimized by using while(count--) { ... }
+ * - This means that in order to keep the same order of execution as addition we have to add
+ * items to the array at the beginning (unshift) instead of at the end (push)
+ *
+ * Child scopes are created and removed often
+ * - Using an array would be slow since inserts in the middle are expensive; so we use linked lists
+ *
+ * There are fewer watches than observers. This is why you don't want the observer to be implemented
+ * in the same way as watch. Watch requires return of the initialization function which is expensive
+ * to construct.
+ */
+
+
+/**
+ * @ngdoc provider
+ * @name $rootScopeProvider
+ * @description
+ *
+ * Provider for the $rootScope service.
+ */
+
+/**
+ * @ngdoc method
+ * @name $rootScopeProvider#digestTtl
+ * @description
+ *
+ * Sets the number of `$digest` iterations the scope should attempt to execute before giving up and
+ * assuming that the model is unstable.
+ *
+ * The current default is 10 iterations.
+ *
+ * In complex applications it's possible that the dependencies between `$watch`s will result in
+ * several digest iterations. However if an application needs more than the default 10 digest
+ * iterations for its model to stabilize then you should investigate what is causing the model to
+ * continuously change during the digest.
+ *
+ * Increasing the TTL could have performance implications, so you should not change it without
+ * proper justification.
+ *
+ * @param {number} limit The number of digest iterations.
+ */
+
+
+/**
+ * @ngdoc service
+ * @name $rootScope
+ * @this
+ *
+ * @description
+ *
+ * Every application has a single root {@link ng.$rootScope.Scope scope}.
+ * All other scopes are descendant scopes of the root scope. Scopes provide separation
+ * between the model and the view, via a mechanism for watching the model for changes.
+ * They also provide event emission/broadcast and subscription facility. See the
+ * {@link guide/scope developer guide on scopes}.
+ */
+function $RootScopeProvider() {
+ var TTL = 10;
+ var $rootScopeMinErr = minErr('$rootScope');
+ var lastDirtyWatch = null;
+ var applyAsyncId = null;
+
+ this.digestTtl = function(value) {
+ if (arguments.length) {
+ TTL = value;
+ }
+ return TTL;
+ };
+
+ function createChildScopeClass(parent) {
+ function ChildScope() {
+ this.$$watchers = this.$$nextSibling =
+ this.$$childHead = this.$$childTail = null;
+ this.$$listeners = {};
+ this.$$listenerCount = {};
+ this.$$watchersCount = 0;
+ this.$id = nextUid();
+ this.$$ChildScope = null;
+ this.$$suspended = false;
+ }
+ ChildScope.prototype = parent;
+ return ChildScope;
+ }
+
+ this.$get = ['$exceptionHandler', '$parse', '$browser',
+ function($exceptionHandler, $parse, $browser) {
+
+ function destroyChildScope($event) {
+ $event.currentScope.$$destroyed = true;
+ }
+
+ function cleanUpScope($scope) {
+
+ // Support: IE 9 only
+ if (msie === 9) {
+ // There is a memory leak in IE9 if all child scopes are not disconnected
+ // completely when a scope is destroyed. So this code will recurse up through
+ // all this scopes children
+ //
+ // See issue https://github.com/angular/angular.js/issues/10706
+ if ($scope.$$childHead) {
+ cleanUpScope($scope.$$childHead);
+ }
+ if ($scope.$$nextSibling) {
+ cleanUpScope($scope.$$nextSibling);
+ }
+ }
+
+ // The code below works around IE9 and V8's memory leaks
+ //
+ // See:
+ // - https://code.google.com/p/v8/issues/detail?id=2073#c26
+ // - https://github.com/angular/angular.js/issues/6794#issuecomment-38648909
+ // - https://github.com/angular/angular.js/issues/1313#issuecomment-10378451
+
+ $scope.$parent = $scope.$$nextSibling = $scope.$$prevSibling = $scope.$$childHead =
+ $scope.$$childTail = $scope.$root = $scope.$$watchers = null;
+ }
+
+ /**
+ * @ngdoc type
+ * @name $rootScope.Scope
+ *
+ * @description
+ * A root scope can be retrieved using the {@link ng.$rootScope $rootScope} key from the
+ * {@link auto.$injector $injector}. Child scopes are created using the
+ * {@link ng.$rootScope.Scope#$new $new()} method. (Most scopes are created automatically when
+ * compiled HTML template is executed.) See also the {@link guide/scope Scopes guide} for
+ * an in-depth introduction and usage examples.
+ *
+ *
+ * ## Inheritance
+ * A scope can inherit from a parent scope, as in this example:
+ * ```js
+ var parent = $rootScope;
+ var child = parent.$new();
+
+ parent.salutation = "Hello";
+ expect(child.salutation).toEqual('Hello');
+
+ child.salutation = "Welcome";
+ expect(child.salutation).toEqual('Welcome');
+ expect(parent.salutation).toEqual('Hello');
+ * ```
+ *
+ * When interacting with `Scope` in tests, additional helper methods are available on the
+ * instances of `Scope` type. See {@link ngMock.$rootScope.Scope ngMock Scope} for additional
+ * details.
+ *
+ *
+ * @param {Object.<string, function()>=} providers Map of service factory which need to be
+ * provided for the current scope. Defaults to {@link ng}.
+ * @param {Object.<string, *>=} instanceCache Provides pre-instantiated services which should
+ * append/override services provided by `providers`. This is handy
+ * when unit-testing and having the need to override a default
+ * service.
+ * @returns {Object} Newly created scope.
+ *
+ */
+ function Scope() {
+ this.$id = nextUid();
+ this.$$phase = this.$parent = this.$$watchers =
+ this.$$nextSibling = this.$$prevSibling =
+ this.$$childHead = this.$$childTail = null;
+ this.$root = this;
+ this.$$destroyed = false;
+ this.$$suspended = false;
+ this.$$listeners = {};
+ this.$$listenerCount = {};
+ this.$$watchersCount = 0;
+ this.$$isolateBindings = null;
+ }
+
+ /**
+ * @ngdoc property
+ * @name $rootScope.Scope#$id
+ *
+ * @description
+ * Unique scope ID (monotonically increasing) useful for debugging.
+ */
+
+ /**
+ * @ngdoc property
+ * @name $rootScope.Scope#$parent
+ *
+ * @description
+ * Reference to the parent scope.
+ */
+
+ /**
+ * @ngdoc property
+ * @name $rootScope.Scope#$root
+ *
+ * @description
+ * Reference to the root scope.
+ */
+
+ Scope.prototype = {
+ constructor: Scope,
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$new
+ * @kind function
+ *
+ * @description
+ * Creates a new child {@link ng.$rootScope.Scope scope}.
+ *
+ * The parent scope will propagate the {@link ng.$rootScope.Scope#$digest $digest()} event.
+ * The scope can be removed from the scope hierarchy using {@link ng.$rootScope.Scope#$destroy $destroy()}.
+ *
+ * {@link ng.$rootScope.Scope#$destroy $destroy()} must be called on a scope when it is
+ * desired for the scope and its child scopes to be permanently detached from the parent and
+ * thus stop participating in model change detection and listener notification by invoking.
+ *
+ * @param {boolean} isolate If true, then the scope does not prototypically inherit from the
+ * parent scope. The scope is isolated, as it can not see parent scope properties.
+ * When creating widgets, it is useful for the widget to not accidentally read parent
+ * state.
+ *
+ * @param {Scope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
+ * of the newly created scope. Defaults to `this` scope if not provided.
+ * This is used when creating a transclude scope to correctly place it
+ * in the scope hierarchy while maintaining the correct prototypical
+ * inheritance.
+ *
+ * @returns {Object} The newly created child scope.
+ *
+ */
+ $new: function(isolate, parent) {
+ var child;
+
+ parent = parent || this;
+
+ if (isolate) {
+ child = new Scope();
+ child.$root = this.$root;
+ } else {
+ // Only create a child scope class if somebody asks for one,
+ // but cache it to allow the VM to optimize lookups.
+ if (!this.$$ChildScope) {
+ this.$$ChildScope = createChildScopeClass(this);
+ }
+ child = new this.$$ChildScope();
+ }
+ child.$parent = parent;
+ child.$$prevSibling = parent.$$childTail;
+ if (parent.$$childHead) {
+ parent.$$childTail.$$nextSibling = child;
+ parent.$$childTail = child;
+ } else {
+ parent.$$childHead = parent.$$childTail = child;
+ }
+
+ // When the new scope is not isolated or we inherit from `this`, and
+ // the parent scope is destroyed, the property `$$destroyed` is inherited
+ // prototypically. In all other cases, this property needs to be set
+ // when the parent scope is destroyed.
+ // The listener needs to be added after the parent is set
+ if (isolate || parent !== this) child.$on('$destroy', destroyChildScope);
+
+ return child;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$watch
+ * @kind function
+ *
+ * @description
+ * Registers a `listener` callback to be executed whenever the `watchExpression` changes.
+ *
+ * - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#$digest
+ * $digest()} and should return the value that will be watched. (`watchExpression` should not change
+ * its value when executed multiple times with the same input because it may be executed multiple
+ * times by {@link ng.$rootScope.Scope#$digest $digest()}. That is, `watchExpression` should be
+ * [idempotent](http://en.wikipedia.org/wiki/Idempotence).)
+ * - The `listener` is called only when the value from the current `watchExpression` and the
+ * previous call to `watchExpression` are not equal (with the exception of the initial run,
+ * see below). Inequality is determined according to reference inequality,
+ * [strict comparison](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators)
+ * via the `!==` Javascript operator, unless `objectEquality == true`
+ * (see next point)
+ * - When `objectEquality == true`, inequality of the `watchExpression` is determined
+ * according to the {@link angular.equals} function. To save the value of the object for
+ * later comparison, the {@link angular.copy} function is used. This therefore means that
+ * watching complex objects will have adverse memory and performance implications.
+ * - This should not be used to watch for changes in objects that are (or contain)
+ * [File](https://developer.mozilla.org/docs/Web/API/File) objects due to limitations with {@link angular.copy `angular.copy`}.
+ * - The watch `listener` may change the model, which may trigger other `listener`s to fire.
+ * This is achieved by rerunning the watchers until no changes are detected. The rerun
+ * iteration limit is 10 to prevent an infinite loop deadlock.
+ *
+ *
+ * If you want to be notified whenever {@link ng.$rootScope.Scope#$digest $digest} is called,
+ * you can register a `watchExpression` function with no `listener`. (Be prepared for
+ * multiple calls to your `watchExpression` because it will execute multiple times in a
+ * single {@link ng.$rootScope.Scope#$digest $digest} cycle if a change is detected.)
+ *
+ * After a watcher is registered with the scope, the `listener` fn is called asynchronously
+ * (via {@link ng.$rootScope.Scope#$evalAsync $evalAsync}) to initialize the
+ * watcher. In rare cases, this is undesirable because the listener is called when the result
+ * of `watchExpression` didn't change. To detect this scenario within the `listener` fn, you
+ * can compare the `newVal` and `oldVal`. If these two values are identical (`===`) then the
+ * listener was called due to initialization.
+ *
+ *
+ *
+ * @example
+ * ```js
+ // let's assume that scope was dependency injected as the $rootScope
+ var scope = $rootScope;
+ scope.name = 'misko';
+ scope.counter = 0;
+
+ expect(scope.counter).toEqual(0);
+ scope.$watch('name', function(newValue, oldValue) {
+ scope.counter = scope.counter + 1;
+ });
+ expect(scope.counter).toEqual(0);
+
+ scope.$digest();
+ // the listener is always called during the first $digest loop after it was registered
+ expect(scope.counter).toEqual(1);
+
+ scope.$digest();
+ // but now it will not be called unless the value changes
+ expect(scope.counter).toEqual(1);
+
+ scope.name = 'adam';
+ scope.$digest();
+ expect(scope.counter).toEqual(2);
+
+
+
+ // Using a function as a watchExpression
+ var food;
+ scope.foodCounter = 0;
+ expect(scope.foodCounter).toEqual(0);
+ scope.$watch(
+ // This function returns the value being watched. It is called for each turn of the $digest loop
+ function() { return food; },
+ // This is the change listener, called when the value returned from the above function changes
+ function(newValue, oldValue) {
+ if ( newValue !== oldValue ) {
+ // Only increment the counter if the value changed
+ scope.foodCounter = scope.foodCounter + 1;
+ }
+ }
+ );
+ // No digest has been run so the counter will be zero
+ expect(scope.foodCounter).toEqual(0);
+
+ // Run the digest but since food has not changed count will still be zero
+ scope.$digest();
+ expect(scope.foodCounter).toEqual(0);
+
+ // Update food and run digest. Now the counter will increment
+ food = 'cheeseburger';
+ scope.$digest();
+ expect(scope.foodCounter).toEqual(1);
+
+ * ```
+ *
+ *
+ *
+ * @param {(function()|string)} watchExpression Expression that is evaluated on each
+ * {@link ng.$rootScope.Scope#$digest $digest} cycle. A change in the return value triggers
+ * a call to the `listener`.
+ *
+ * - `string`: Evaluated as {@link guide/expression expression}
+ * - `function(scope)`: called with current `scope` as a parameter.
+ * @param {function(newVal, oldVal, scope)} listener Callback called whenever the value
+ * of `watchExpression` changes.
+ *
+ * - `newVal` contains the current value of the `watchExpression`
+ * - `oldVal` contains the previous value of the `watchExpression`
+ * - `scope` refers to the current scope
+ * @param {boolean=} [objectEquality=false] Compare for object equality using {@link angular.equals} instead of
+ * comparing for reference equality.
+ * @returns {function()} Returns a deregistration function for this listener.
+ */
+ $watch: function(watchExp, listener, objectEquality, prettyPrintExpression) {
+ var get = $parse(watchExp);
+ var fn = isFunction(listener) ? listener : noop;
+
+ if (get.$$watchDelegate) {
+ return get.$$watchDelegate(this, fn, objectEquality, get, watchExp);
+ }
+ var scope = this,
+ array = scope.$$watchers,
+ watcher = {
+ fn: fn,
+ last: initWatchVal,
+ get: get,
+ exp: prettyPrintExpression || watchExp,
+ eq: !!objectEquality
+ };
+
+ lastDirtyWatch = null;
+
+ if (!array) {
+ array = scope.$$watchers = [];
+ array.$$digestWatchIndex = -1;
+ }
+ // we use unshift since we use a while loop in $digest for speed.
+ // the while loop reads in reverse order.
+ array.unshift(watcher);
+ array.$$digestWatchIndex++;
+ incrementWatchersCount(this, 1);
+
+ return function deregisterWatch() {
+ var index = arrayRemove(array, watcher);
+ if (index >= 0) {
+ incrementWatchersCount(scope, -1);
+ if (index < array.$$digestWatchIndex) {
+ array.$$digestWatchIndex--;
+ }
+ }
+ lastDirtyWatch = null;
+ };
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$watchGroup
+ * @kind function
+ *
+ * @description
+ * A variant of {@link ng.$rootScope.Scope#$watch $watch()} where it watches an array of `watchExpressions`.
+ * If any one expression in the collection changes the `listener` is executed.
+ *
+ * - The items in the `watchExpressions` array are observed via the standard `$watch` operation. Their return
+ * values are examined for changes on every call to `$digest`.
+ * - The `listener` is called whenever any expression in the `watchExpressions` array changes.
+ *
+ * @param {Array.<string|Function(scope)>} watchExpressions Array of expressions that will be individually
+ * watched using {@link ng.$rootScope.Scope#$watch $watch()}
+ *
+ * @param {function(newValues, oldValues, scope)} listener Callback called whenever the return value of any
+ * expression in `watchExpressions` changes
+ * The `newValues` array contains the current values of the `watchExpressions`, with the indexes matching
+ * those of `watchExpression`
+ * and the `oldValues` array contains the previous values of the `watchExpressions`, with the indexes matching
+ * those of `watchExpression`
+ * The `scope` refers to the current scope.
+ * @returns {function()} Returns a de-registration function for all listeners.
+ */
+ $watchGroup: function(watchExpressions, listener) {
+ var oldValues = new Array(watchExpressions.length);
+ var newValues = new Array(watchExpressions.length);
+ var deregisterFns = [];
+ var self = this;
+ var changeReactionScheduled = false;
+ var firstRun = true;
+
+ if (!watchExpressions.length) {
+ // No expressions means we call the listener ASAP
+ var shouldCall = true;
+ self.$evalAsync(function() {
+ if (shouldCall) listener(newValues, newValues, self);
+ });
+ return function deregisterWatchGroup() {
+ shouldCall = false;
+ };
+ }
+
+ if (watchExpressions.length === 1) {
+ // Special case size of one
+ return this.$watch(watchExpressions[0], function watchGroupAction(value, oldValue, scope) {
+ newValues[0] = value;
+ oldValues[0] = oldValue;
+ listener(newValues, (value === oldValue) ? newValues : oldValues, scope);
+ });
+ }
+
+ forEach(watchExpressions, function(expr, i) {
+ var unwatchFn = self.$watch(expr, function watchGroupSubAction(value) {
+ newValues[i] = value;
+ if (!changeReactionScheduled) {
+ changeReactionScheduled = true;
+ self.$evalAsync(watchGroupAction);
+ }
+ });
+ deregisterFns.push(unwatchFn);
+ });
+
+ function watchGroupAction() {
+ changeReactionScheduled = false;
+
+ try {
+ if (firstRun) {
+ firstRun = false;
+ listener(newValues, newValues, self);
+ } else {
+ listener(newValues, oldValues, self);
+ }
+ } finally {
+ for (var i = 0; i < watchExpressions.length; i++) {
+ oldValues[i] = newValues[i];
+ }
+ }
+ }
+
+ return function deregisterWatchGroup() {
+ while (deregisterFns.length) {
+ deregisterFns.shift()();
+ }
+ };
+ },
+
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$watchCollection
+ * @kind function
+ *
+ * @description
+ * Shallow watches the properties of an object and fires whenever any of the properties change
+ * (for arrays, this implies watching the array items; for object maps, this implies watching
+ * the properties). If a change is detected, the `listener` callback is fired.
+ *
+ * - The `obj` collection is observed via standard $watch operation and is examined on every
+ * call to $digest() to see if any items have been added, removed, or moved.
+ * - The `listener` is called whenever anything within the `obj` has changed. Examples include
+ * adding, removing, and moving items belonging to an object or array.
+ *
+ *
+ * @example
+ * ```js
+ $scope.names = ['igor', 'matias', 'misko', 'james'];
+ $scope.dataCount = 4;
+
+ $scope.$watchCollection('names', function(newNames, oldNames) {
+ $scope.dataCount = newNames.length;
+ });
+
+ expect($scope.dataCount).toEqual(4);
+ $scope.$digest();
+
+ //still at 4 ... no changes
+ expect($scope.dataCount).toEqual(4);
+
+ $scope.names.pop();
+ $scope.$digest();
+
+ //now there's been a change
+ expect($scope.dataCount).toEqual(3);
+ * ```
+ *
+ *
+ * @param {string|function(scope)} obj Evaluated as {@link guide/expression expression}. The
+ * expression value should evaluate to an object or an array which is observed on each
+ * {@link ng.$rootScope.Scope#$digest $digest} cycle. Any shallow change within the
+ * collection will trigger a call to the `listener`.
+ *
+ * @param {function(newCollection, oldCollection, scope)} listener a callback function called
+ * when a change is detected.
+ * - The `newCollection` object is the newly modified data obtained from the `obj` expression
+ * - The `oldCollection` object is a copy of the former collection data.
+ * Due to performance considerations, the`oldCollection` value is computed only if the
+ * `listener` function declares two or more arguments.
+ * - The `scope` argument refers to the current scope.
+ *
+ * @returns {function()} Returns a de-registration function for this listener. When the
+ * de-registration function is executed, the internal watch operation is terminated.
+ */
+ $watchCollection: function(obj, listener) {
+ // Mark the interceptor as
+ // ... $$pure when literal since the instance will change when any input changes
+ $watchCollectionInterceptor.$$pure = $parse(obj).literal;
+ // ... $stateful when non-literal since we must read the state of the collection
+ $watchCollectionInterceptor.$stateful = !$watchCollectionInterceptor.$$pure;
+
+ var self = this;
+ // the current value, updated on each dirty-check run
+ var newValue;
+ // a shallow copy of the newValue from the last dirty-check run,
+ // updated to match newValue during dirty-check run
+ var oldValue;
+ // a shallow copy of the newValue from when the last change happened
+ var veryOldValue;
+ // only track veryOldValue if the listener is asking for it
+ var trackVeryOldValue = (listener.length > 1);
+ var changeDetected = 0;
+ var changeDetector = $parse(obj, $watchCollectionInterceptor);
+ var internalArray = [];
+ var internalObject = {};
+ var initRun = true;
+ var oldLength = 0;
+
+ function $watchCollectionInterceptor(_value) {
+ newValue = _value;
+ var newLength, key, bothNaN, newItem, oldItem;
+
+ // If the new value is undefined, then return undefined as the watch may be a one-time watch
+ if (isUndefined(newValue)) return;
+
+ if (!isObject(newValue)) { // if primitive
+ if (oldValue !== newValue) {
+ oldValue = newValue;
+ changeDetected++;
+ }
+ } else if (isArrayLike(newValue)) {
+ if (oldValue !== internalArray) {
+ // we are transitioning from something which was not an array into array.
+ oldValue = internalArray;
+ oldLength = oldValue.length = 0;
+ changeDetected++;
+ }
+
+ newLength = newValue.length;
+
+ if (oldLength !== newLength) {
+ // if lengths do not match we need to trigger change notification
+ changeDetected++;
+ oldValue.length = oldLength = newLength;
+ }
+ // copy the items to oldValue and look for changes.
+ for (var i = 0; i < newLength; i++) {
+ oldItem = oldValue[i];
+ newItem = newValue[i];
+
+ // eslint-disable-next-line no-self-compare
+ bothNaN = (oldItem !== oldItem) && (newItem !== newItem);
+ if (!bothNaN && (oldItem !== newItem)) {
+ changeDetected++;
+ oldValue[i] = newItem;
+ }
+ }
+ } else {
+ if (oldValue !== internalObject) {
+ // we are transitioning from something which was not an object into object.
+ oldValue = internalObject = {};
+ oldLength = 0;
+ changeDetected++;
+ }
+ // copy the items to oldValue and look for changes.
+ newLength = 0;
+ for (key in newValue) {
+ if (hasOwnProperty.call(newValue, key)) {
+ newLength++;
+ newItem = newValue[key];
+ oldItem = oldValue[key];
+
+ if (key in oldValue) {
+ // eslint-disable-next-line no-self-compare
+ bothNaN = (oldItem !== oldItem) && (newItem !== newItem);
+ if (!bothNaN && (oldItem !== newItem)) {
+ changeDetected++;
+ oldValue[key] = newItem;
+ }
+ } else {
+ oldLength++;
+ oldValue[key] = newItem;
+ changeDetected++;
+ }
+ }
+ }
+ if (oldLength > newLength) {
+ // we used to have more keys, need to find them and destroy them.
+ changeDetected++;
+ for (key in oldValue) {
+ if (!hasOwnProperty.call(newValue, key)) {
+ oldLength--;
+ delete oldValue[key];
+ }
+ }
+ }
+ }
+ return changeDetected;
+ }
+
+ function $watchCollectionAction() {
+ if (initRun) {
+ initRun = false;
+ listener(newValue, newValue, self);
+ } else {
+ listener(newValue, veryOldValue, self);
+ }
+
+ // make a copy for the next time a collection is changed
+ if (trackVeryOldValue) {
+ if (!isObject(newValue)) {
+ //primitive
+ veryOldValue = newValue;
+ } else if (isArrayLike(newValue)) {
+ veryOldValue = new Array(newValue.length);
+ for (var i = 0; i < newValue.length; i++) {
+ veryOldValue[i] = newValue[i];
+ }
+ } else { // if object
+ veryOldValue = {};
+ for (var key in newValue) {
+ if (hasOwnProperty.call(newValue, key)) {
+ veryOldValue[key] = newValue[key];
+ }
+ }
+ }
+ }
+ }
+
+ return this.$watch(changeDetector, $watchCollectionAction);
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$digest
+ * @kind function
+ *
+ * @description
+ * Processes all of the {@link ng.$rootScope.Scope#$watch watchers} of the current scope and
+ * its children. Because a {@link ng.$rootScope.Scope#$watch watcher}'s listener can change
+ * the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#$watch watchers}
+ * until no more listeners are firing. This means that it is possible to get into an infinite
+ * loop. This function will throw `'Maximum iteration limit exceeded.'` if the number of
+ * iterations exceeds 10.
+ *
+ * Usually, you don't call `$digest()` directly in
+ * {@link ng.directive:ngController controllers} or in
+ * {@link ng.$compileProvider#directive directives}.
+ * Instead, you should call {@link ng.$rootScope.Scope#$apply $apply()} (typically from within
+ * a {@link ng.$compileProvider#directive directive}), which will force a `$digest()`.
+ *
+ * If you want to be notified whenever `$digest()` is called,
+ * you can register a `watchExpression` function with
+ * {@link ng.$rootScope.Scope#$watch $watch()} with no `listener`.
+ *
+ * In unit tests, you may need to call `$digest()` to simulate the scope life cycle.
+ *
+ * @example
+ * ```js
+ var scope = ...;
+ scope.name = 'misko';
+ scope.counter = 0;
+
+ expect(scope.counter).toEqual(0);
+ scope.$watch('name', function(newValue, oldValue) {
+ scope.counter = scope.counter + 1;
+ });
+ expect(scope.counter).toEqual(0);
+
+ scope.$digest();
+ // the listener is always called during the first $digest loop after it was registered
+ expect(scope.counter).toEqual(1);
+
+ scope.$digest();
+ // but now it will not be called unless the value changes
+ expect(scope.counter).toEqual(1);
+
+ scope.name = 'adam';
+ scope.$digest();
+ expect(scope.counter).toEqual(2);
+ * ```
+ *
+ */
+ $digest: function() {
+ var watch, value, last, fn, get,
+ watchers,
+ dirty, ttl = TTL,
+ next, current, target = asyncQueue.length ? $rootScope : this,
+ watchLog = [],
+ logIdx, asyncTask;
+
+ beginPhase('$digest');
+ // Check for changes to browser url that happened in sync before the call to $digest
+ $browser.$$checkUrlChange();
+
+ if (this === $rootScope && applyAsyncId !== null) {
+ // If this is the root scope, and $applyAsync has scheduled a deferred $apply(), then
+ // cancel the scheduled $apply and flush the queue of expressions to be evaluated.
+ $browser.defer.cancel(applyAsyncId);
+ flushApplyAsync();
+ }
+
+ lastDirtyWatch = null;
+
+ do { // "while dirty" loop
+ dirty = false;
+ current = target;
+
+ // It's safe for asyncQueuePosition to be a local variable here because this loop can't
+ // be reentered recursively. Calling $digest from a function passed to $evalAsync would
+ // lead to a '$digest already in progress' error.
+ for (var asyncQueuePosition = 0; asyncQueuePosition < asyncQueue.length; asyncQueuePosition++) {
+ try {
+ asyncTask = asyncQueue[asyncQueuePosition];
+ fn = asyncTask.fn;
+ fn(asyncTask.scope, asyncTask.locals);
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ lastDirtyWatch = null;
+ }
+ asyncQueue.length = 0;
+
+ traverseScopesLoop:
+ do { // "traverse the scopes" loop
+ if ((watchers = !current.$$suspended && current.$$watchers)) {
+ // process our watches
+ watchers.$$digestWatchIndex = watchers.length;
+ while (watchers.$$digestWatchIndex--) {
+ try {
+ watch = watchers[watchers.$$digestWatchIndex];
+ // Most common watches are on primitives, in which case we can short
+ // circuit it with === operator, only when === fails do we use .equals
+ if (watch) {
+ get = watch.get;
+ if ((value = get(current)) !== (last = watch.last) &&
+ !(watch.eq
+ ? equals(value, last)
+ : (isNumberNaN(value) && isNumberNaN(last)))) {
+ dirty = true;
+ lastDirtyWatch = watch;
+ watch.last = watch.eq ? copy(value, null) : value;
+ fn = watch.fn;
+ fn(value, ((last === initWatchVal) ? value : last), current);
+ if (ttl < 5) {
+ logIdx = 4 - ttl;
+ if (!watchLog[logIdx]) watchLog[logIdx] = [];
+ watchLog[logIdx].push({
+ msg: isFunction(watch.exp) ? 'fn: ' + (watch.exp.name || watch.exp.toString()) : watch.exp,
+ newVal: value,
+ oldVal: last
+ });
+ }
+ } else if (watch === lastDirtyWatch) {
+ // If the most recently dirty watcher is now clean, short circuit since the remaining watchers
+ // have already been tested.
+ dirty = false;
+ break traverseScopesLoop;
+ }
+ }
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ }
+ }
+
+ // Insanity Warning: scope depth-first traversal
+ // yes, this code is a bit crazy, but it works and we have tests to prove it!
+ // this piece should be kept in sync with the traversal in $broadcast
+ // (though it differs due to having the extra check for $$suspended and does not
+ // check $$listenerCount)
+ if (!(next = ((!current.$$suspended && current.$$watchersCount && current.$$childHead) ||
+ (current !== target && current.$$nextSibling)))) {
+ while (current !== target && !(next = current.$$nextSibling)) {
+ current = current.$parent;
+ }
+ }
+ } while ((current = next));
+
+ // `break traverseScopesLoop;` takes us to here
+
+ if ((dirty || asyncQueue.length) && !(ttl--)) {
+ clearPhase();
+ throw $rootScopeMinErr('infdig',
+ '{0} $digest() iterations reached. Aborting!\n' +
+ 'Watchers fired in the last 5 iterations: {1}',
+ TTL, watchLog);
+ }
+
+ } while (dirty || asyncQueue.length);
+
+ clearPhase();
+
+ // postDigestQueuePosition isn't local here because this loop can be reentered recursively.
+ while (postDigestQueuePosition < postDigestQueue.length) {
+ try {
+ postDigestQueue[postDigestQueuePosition++]();
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ }
+ postDigestQueue.length = postDigestQueuePosition = 0;
+
+ // Check for changes to browser url that happened during the $digest
+ // (for which no event is fired; e.g. via `history.pushState()`)
+ $browser.$$checkUrlChange();
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$suspend
+ * @kind function
+ *
+ * @description
+ * Suspend watchers of this scope subtree so that they will not be invoked during digest.
+ *
+ * This can be used to optimize your application when you know that running those watchers
+ * is redundant.
+ *
+ * **Warning**
+ *
+ * Suspending scopes from the digest cycle can have unwanted and difficult to debug results.
+ * Only use this approach if you are confident that you know what you are doing and have
+ * ample tests to ensure that bindings get updated as you expect.
+ *
+ * Some of the things to consider are:
+ *
+ * * Any external event on a directive/component will not trigger a digest while the hosting
+ * scope is suspended - even if the event handler calls `$apply()` or `$rootScope.$digest()`.
+ * * Transcluded content exists on a scope that inherits from outside a directive but exists
+ * as a child of the directive's containing scope. If the containing scope is suspended the
+ * transcluded scope will also be suspended, even if the scope from which the transcluded
+ * scope inherits is not suspended.
+ * * Multiple directives trying to manage the suspended status of a scope can confuse each other:
+ * * A call to `$suspend()` on an already suspended scope is a no-op.
+ * * A call to `$resume()` on a non-suspended scope is a no-op.
+ * * If two directives suspend a scope, then one of them resumes the scope, the scope will no
+ * longer be suspended. This could result in the other directive believing a scope to be
+ * suspended when it is not.
+ * * If a parent scope is suspended then all its descendants will be also excluded from future
+ * digests whether or not they have been suspended themselves. Note that this also applies to
+ * isolate child scopes.
+ * * Calling `$digest()` directly on a descendant of a suspended scope will still run the watchers
+ * for that scope and its descendants. When digesting we only check whether the current scope is
+ * locally suspended, rather than checking whether it has a suspended ancestor.
+ * * Calling `$resume()` on a scope that has a suspended ancestor will not cause the scope to be
+ * included in future digests until all its ancestors have been resumed.
+ * * Resolved promises, e.g. from explicit `$q` deferreds and `$http` calls, trigger `$apply()`
+ * against the `$rootScope` and so will still trigger a global digest even if the promise was
+ * initiated by a component that lives on a suspended scope.
+ */
+ $suspend: function() {
+ this.$$suspended = true;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$isSuspended
+ * @kind function
+ *
+ * @description
+ * Call this method to determine if this scope has been explicitly suspended. It will not
+ * tell you whether an ancestor has been suspended.
+ * To determine if this scope will be excluded from a digest triggered at the $rootScope,
+ * for example, you must check all its ancestors:
+ *
+ * ```
+ * function isExcludedFromDigest(scope) {
+ * while(scope) {
+ * if (scope.$isSuspended()) return true;
+ * scope = scope.$parent;
+ * }
+ * return false;
+ * ```
+ *
+ * Be aware that a scope may not be included in digests if it has a suspended ancestor,
+ * even if `$isSuspended()` returns false.
+ *
+ * @returns true if the current scope has been suspended.
+ */
+ $isSuspended: function() {
+ return this.$$suspended;
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$resume
+ * @kind function
+ *
+ * @description
+ * Resume watchers of this scope subtree in case it was suspended.
+ *
+ * See {@link $rootScope.Scope#$suspend} for information about the dangers of using this approach.
+ */
+ $resume: function() {
+ this.$$suspended = false;
+ },
+
+ /**
+ * @ngdoc event
+ * @name $rootScope.Scope#$destroy
+ * @eventType broadcast on scope being destroyed
+ *
+ * @description
+ * Broadcasted when a scope and its children are being destroyed.
+ *
+ * Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
+ * clean up DOM bindings before an element is removed from the DOM.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$destroy
+ * @kind function
+ *
+ * @description
+ * Removes the current scope (and all of its children) from the parent scope. Removal implies
+ * that calls to {@link ng.$rootScope.Scope#$digest $digest()} will no longer
+ * propagate to the current scope and its children. Removal also implies that the current
+ * scope is eligible for garbage collection.
+ *
+ * The `$destroy()` is usually used by directives such as
+ * {@link ng.directive:ngRepeat ngRepeat} for managing the
+ * unrolling of the loop.
+ *
+ * Just before a scope is destroyed, a `$destroy` event is broadcasted on this scope.
+ * Application code can register a `$destroy` event handler that will give it a chance to
+ * perform any necessary cleanup.
+ *
+ * Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
+ * clean up DOM bindings before an element is removed from the DOM.
+ */
+ $destroy: function() {
+ // We can't destroy a scope that has been already destroyed.
+ if (this.$$destroyed) return;
+ var parent = this.$parent;
+
+ this.$broadcast('$destroy');
+ this.$$destroyed = true;
+
+ if (this === $rootScope) {
+ //Remove handlers attached to window when $rootScope is removed
+ $browser.$$applicationDestroyed();
+ }
+
+ incrementWatchersCount(this, -this.$$watchersCount);
+ for (var eventName in this.$$listenerCount) {
+ decrementListenerCount(this, this.$$listenerCount[eventName], eventName);
+ }
+
+ // sever all the references to parent scopes (after this cleanup, the current scope should
+ // not be retained by any of our references and should be eligible for garbage collection)
+ if (parent && parent.$$childHead === this) parent.$$childHead = this.$$nextSibling;
+ if (parent && parent.$$childTail === this) parent.$$childTail = this.$$prevSibling;
+ if (this.$$prevSibling) this.$$prevSibling.$$nextSibling = this.$$nextSibling;
+ if (this.$$nextSibling) this.$$nextSibling.$$prevSibling = this.$$prevSibling;
+
+ // Disable listeners, watchers and apply/digest methods
+ this.$destroy = this.$digest = this.$apply = this.$evalAsync = this.$applyAsync = noop;
+ this.$on = this.$watch = this.$watchGroup = function() { return noop; };
+ this.$$listeners = {};
+
+ // Disconnect the next sibling to prevent `cleanUpScope` destroying those too
+ this.$$nextSibling = null;
+ cleanUpScope(this);
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$eval
+ * @kind function
+ *
+ * @description
+ * Executes the `expression` on the current scope and returns the result. Any exceptions in
+ * the expression are propagated (uncaught). This is useful when evaluating AngularJS
+ * expressions.
+ *
+ * @example
+ * ```js
+ var scope = ng.$rootScope.Scope();
+ scope.a = 1;
+ scope.b = 2;
+
+ expect(scope.$eval('a+b')).toEqual(3);
+ expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3);
+ * ```
+ *
+ * @param {(string|function())=} expression An AngularJS expression to be executed.
+ *
+ * - `string`: execute using the rules as defined in {@link guide/expression expression}.
+ * - `function(scope)`: execute the function with the current `scope` parameter.
+ *
+ * @param {(object)=} locals Local variables object, useful for overriding values in scope.
+ * @returns {*} The result of evaluating the expression.
+ */
+ $eval: function(expr, locals) {
+ return $parse(expr)(this, locals);
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$evalAsync
+ * @kind function
+ *
+ * @description
+ * Executes the expression on the current scope at a later point in time.
+ *
+ * The `$evalAsync` makes no guarantees as to when the `expression` will be executed, only
+ * that:
+ *
+ * - it will execute after the function that scheduled the evaluation (preferably before DOM
+ * rendering).
+ * - at least one {@link ng.$rootScope.Scope#$digest $digest cycle} will be performed after
+ * `expression` execution.
+ *
+ * Any exceptions from the execution of the expression are forwarded to the
+ * {@link ng.$exceptionHandler $exceptionHandler} service.
+ *
+ * __Note:__ if this function is called outside of a `$digest` cycle, a new `$digest` cycle
+ * will be scheduled. However, it is encouraged to always call code that changes the model
+ * from within an `$apply` call. That includes code evaluated via `$evalAsync`.
+ *
+ * @param {(string|function())=} expression An AngularJS expression to be executed.
+ *
+ * - `string`: execute using the rules as defined in {@link guide/expression expression}.
+ * - `function(scope)`: execute the function with the current `scope` parameter.
+ *
+ * @param {(object)=} locals Local variables object, useful for overriding values in scope.
+ */
+ $evalAsync: function(expr, locals) {
+ // if we are outside of an $digest loop and this is the first time we are scheduling async
+ // task also schedule async auto-flush
+ if (!$rootScope.$$phase && !asyncQueue.length) {
+ $browser.defer(function() {
+ if (asyncQueue.length) {
+ $rootScope.$digest();
+ }
+ }, null, '$evalAsync');
+ }
+
+ asyncQueue.push({scope: this, fn: $parse(expr), locals: locals});
+ },
+
+ $$postDigest: function(fn) {
+ postDigestQueue.push(fn);
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$apply
+ * @kind function
+ *
+ * @description
+ * `$apply()` is used to execute an expression in AngularJS from outside of the AngularJS
+ * framework. (For example from browser DOM events, setTimeout, XHR or third party libraries).
+ * Because we are calling into the AngularJS framework we need to perform proper scope life
+ * cycle of {@link ng.$exceptionHandler exception handling},
+ * {@link ng.$rootScope.Scope#$digest executing watches}.
+ *
+ * **Life cycle: Pseudo-Code of `$apply()`**
+ *
+ * ```js
+ function $apply(expr) {
+ try {
+ return $eval(expr);
+ } catch (e) {
+ $exceptionHandler(e);
+ } finally {
+ $root.$digest();
+ }
+ }
+ * ```
+ *
+ *
+ * Scope's `$apply()` method transitions through the following stages:
+ *
+ * 1. The {@link guide/expression expression} is executed using the
+ * {@link ng.$rootScope.Scope#$eval $eval()} method.
+ * 2. Any exceptions from the execution of the expression are forwarded to the
+ * {@link ng.$exceptionHandler $exceptionHandler} service.
+ * 3. The {@link ng.$rootScope.Scope#$watch watch} listeners are fired immediately after the
+ * expression was executed using the {@link ng.$rootScope.Scope#$digest $digest()} method.
+ *
+ *
+ * @param {(string|function())=} exp An AngularJS expression to be executed.
+ *
+ * - `string`: execute using the rules as defined in {@link guide/expression expression}.
+ * - `function(scope)`: execute the function with current `scope` parameter.
+ *
+ * @returns {*} The result of evaluating the expression.
+ */
+ $apply: function(expr) {
+ try {
+ beginPhase('$apply');
+ try {
+ return this.$eval(expr);
+ } finally {
+ clearPhase();
+ }
+ } catch (e) {
+ $exceptionHandler(e);
+ } finally {
+ try {
+ $rootScope.$digest();
+ } catch (e) {
+ $exceptionHandler(e);
+ // eslint-disable-next-line no-unsafe-finally
+ throw e;
+ }
+ }
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$applyAsync
+ * @kind function
+ *
+ * @description
+ * Schedule the invocation of $apply to occur at a later time. The actual time difference
+ * varies across browsers, but is typically around ~10 milliseconds.
+ *
+ * This can be used to queue up multiple expressions which need to be evaluated in the same
+ * digest.
+ *
+ * @param {(string|function())=} exp An AngularJS expression to be executed.
+ *
+ * - `string`: execute using the rules as defined in {@link guide/expression expression}.
+ * - `function(scope)`: execute the function with current `scope` parameter.
+ */
+ $applyAsync: function(expr) {
+ var scope = this;
+ if (expr) {
+ applyAsyncQueue.push($applyAsyncExpression);
+ }
+ expr = $parse(expr);
+ scheduleApplyAsync();
+
+ function $applyAsyncExpression() {
+ scope.$eval(expr);
+ }
+ },
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$on
+ * @kind function
+ *
+ * @description
+ * Listens on events of a given type. See {@link ng.$rootScope.Scope#$emit $emit} for
+ * discussion of event life cycle.
+ *
+ * The event listener function format is: `function(event, args...)`. The `event` object
+ * passed into the listener has the following attributes:
+ *
+ * - `targetScope` - `{Scope}`: the scope on which the event was `$emit`-ed or
+ * `$broadcast`-ed.
+ * - `currentScope` - `{Scope}`: the scope that is currently handling the event. Once the
+ * event propagates through the scope hierarchy, this property is set to null.
+ * - `name` - `{string}`: name of the event.
+ * - `stopPropagation` - `{function=}`: calling `stopPropagation` function will cancel
+ * further event propagation (available only for events that were `$emit`-ed).
+ * - `preventDefault` - `{function}`: calling `preventDefault` sets `defaultPrevented` flag
+ * to true.
+ * - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
+ *
+ * @param {string} name Event name to listen on.
+ * @param {function(event, ...args)} listener Function to call when the event is emitted.
+ * @returns {function()} Returns a deregistration function for this listener.
+ */
+ $on: function(name, listener) {
+ var namedListeners = this.$$listeners[name];
+ if (!namedListeners) {
+ this.$$listeners[name] = namedListeners = [];
+ }
+ namedListeners.push(listener);
+
+ var current = this;
+ do {
+ if (!current.$$listenerCount[name]) {
+ current.$$listenerCount[name] = 0;
+ }
+ current.$$listenerCount[name]++;
+ } while ((current = current.$parent));
+
+ var self = this;
+ return function() {
+ var indexOfListener = namedListeners.indexOf(listener);
+ if (indexOfListener !== -1) {
+ // Use delete in the hope of the browser deallocating the memory for the array entry,
+ // while not shifting the array indexes of other listeners.
+ // See issue https://github.com/angular/angular.js/issues/16135
+ delete namedListeners[indexOfListener];
+ decrementListenerCount(self, 1, name);
+ }
+ };
+ },
+
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$emit
+ * @kind function
+ *
+ * @description
+ * Dispatches an event `name` upwards through the scope hierarchy notifying the
+ * registered {@link ng.$rootScope.Scope#$on} listeners.
+ *
+ * The event life cycle starts at the scope on which `$emit` was called. All
+ * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get
+ * notified. Afterwards, the event traverses upwards toward the root scope and calls all
+ * registered listeners along the way. The event will stop propagating if one of the listeners
+ * cancels it.
+ *
+ * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed
+ * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
+ *
+ * @param {string} name Event name to emit.
+ * @param {...*} args Optional one or more arguments which will be passed onto the event listeners.
+ * @return {Object} Event object (see {@link ng.$rootScope.Scope#$on}).
+ */
+ $emit: function(name, args) {
+ var empty = [],
+ namedListeners,
+ scope = this,
+ stopPropagation = false,
+ event = {
+ name: name,
+ targetScope: scope,
+ stopPropagation: function() {stopPropagation = true;},
+ preventDefault: function() {
+ event.defaultPrevented = true;
+ },
+ defaultPrevented: false
+ },
+ listenerArgs = concat([event], arguments, 1),
+ i, length;
+
+ do {
+ namedListeners = scope.$$listeners[name] || empty;
+ event.currentScope = scope;
+ for (i = 0, length = namedListeners.length; i < length; i++) {
+
+ // if listeners were deregistered, defragment the array
+ if (!namedListeners[i]) {
+ namedListeners.splice(i, 1);
+ i--;
+ length--;
+ continue;
+ }
+ try {
+ //allow all listeners attached to the current scope to run
+ namedListeners[i].apply(null, listenerArgs);
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ }
+ //if any listener on the current scope stops propagation, prevent bubbling
+ if (stopPropagation) {
+ break;
+ }
+ //traverse upwards
+ scope = scope.$parent;
+ } while (scope);
+
+ event.currentScope = null;
+
+ return event;
+ },
+
+
+ /**
+ * @ngdoc method
+ * @name $rootScope.Scope#$broadcast
+ * @kind function
+ *
+ * @description
+ * Dispatches an event `name` downwards to all child scopes (and their children) notifying the
+ * registered {@link ng.$rootScope.Scope#$on} listeners.
+ *
+ * The event life cycle starts at the scope on which `$broadcast` was called. All
+ * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get
+ * notified. Afterwards, the event propagates to all direct and indirect scopes of the current
+ * scope and calls all registered listeners along the way. The event cannot be canceled.
+ *
+ * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed
+ * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
+ *
+ * @param {string} name Event name to broadcast.
+ * @param {...*} args Optional one or more arguments which will be passed onto the event listeners.
+ * @return {Object} Event object, see {@link ng.$rootScope.Scope#$on}
+ */
+ $broadcast: function(name, args) {
+ var target = this,
+ current = target,
+ next = target,
+ event = {
+ name: name,
+ targetScope: target,
+ preventDefault: function() {
+ event.defaultPrevented = true;
+ },
+ defaultPrevented: false
+ };
+
+ if (!target.$$listenerCount[name]) return event;
+
+ var listenerArgs = concat([event], arguments, 1),
+ listeners, i, length;
+
+ //down while you can, then up and next sibling or up and next sibling until back at root
+ while ((current = next)) {
+ event.currentScope = current;
+ listeners = current.$$listeners[name] || [];
+ for (i = 0, length = listeners.length; i < length; i++) {
+ // if listeners were deregistered, defragment the array
+ if (!listeners[i]) {
+ listeners.splice(i, 1);
+ i--;
+ length--;
+ continue;
+ }
+
+ try {
+ listeners[i].apply(null, listenerArgs);
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ }
+
+ // Insanity Warning: scope depth-first traversal
+ // yes, this code is a bit crazy, but it works and we have tests to prove it!
+ // this piece should be kept in sync with the traversal in $digest
+ // (though it differs due to having the extra check for $$listenerCount and
+ // does not check $$suspended)
+ if (!(next = ((current.$$listenerCount[name] && current.$$childHead) ||
+ (current !== target && current.$$nextSibling)))) {
+ while (current !== target && !(next = current.$$nextSibling)) {
+ current = current.$parent;
+ }
+ }
+ }
+
+ event.currentScope = null;
+ return event;
+ }
+ };
+
+ var $rootScope = new Scope();
+
+ //The internal queues. Expose them on the $rootScope for debugging/testing purposes.
+ var asyncQueue = $rootScope.$$asyncQueue = [];
+ var postDigestQueue = $rootScope.$$postDigestQueue = [];
+ var applyAsyncQueue = $rootScope.$$applyAsyncQueue = [];
+
+ var postDigestQueuePosition = 0;
+
+ return $rootScope;
+
+
+ function beginPhase(phase) {
+ if ($rootScope.$$phase) {
+ throw $rootScopeMinErr('inprog', '{0} already in progress', $rootScope.$$phase);
+ }
+
+ $rootScope.$$phase = phase;
+ }
+
+ function clearPhase() {
+ $rootScope.$$phase = null;
+ }
+
+ function incrementWatchersCount(current, count) {
+ do {
+ current.$$watchersCount += count;
+ } while ((current = current.$parent));
+ }
+
+ function decrementListenerCount(current, count, name) {
+ do {
+ current.$$listenerCount[name] -= count;
+
+ if (current.$$listenerCount[name] === 0) {
+ delete current.$$listenerCount[name];
+ }
+ } while ((current = current.$parent));
+ }
+
+ /**
+ * function used as an initial value for watchers.
+ * because it's unique we can easily tell it apart from other values
+ */
+ function initWatchVal() {}
+
+ function flushApplyAsync() {
+ while (applyAsyncQueue.length) {
+ try {
+ applyAsyncQueue.shift()();
+ } catch (e) {
+ $exceptionHandler(e);
+ }
+ }
+ applyAsyncId = null;
+ }
+
+ function scheduleApplyAsync() {
+ if (applyAsyncId === null) {
+ applyAsyncId = $browser.defer(function() {
+ $rootScope.$apply(flushApplyAsync);
+ }, null, '$applyAsync');
+ }
+ }
+ }];
+}
+
+/**
+ * @ngdoc service
+ * @name $rootElement
+ *
+ * @description
+ * The root element of AngularJS application. This is either the element where {@link
+ * ng.directive:ngApp ngApp} was declared or the element passed into
+ * {@link angular.bootstrap}. The element represents the root element of application. It is also the
+ * location where the application's {@link auto.$injector $injector} service gets
+ * published, and can be retrieved using `$rootElement.injector()`.
+ */
+
+
+// the implementation is in angular.bootstrap
+
+/**
+ * @this
+ * @description
+ * Private service to sanitize uris for links and images. Used by $compile and $sanitize.
+ */
+function $$SanitizeUriProvider() {
+
+ var aHrefSanitizationTrustedUrlList = /^\s*(https?|s?ftp|mailto|tel|file):/,
+ imgSrcSanitizationTrustedUrlList = /^\s*((https?|ftp|file|blob):|data:image\/)/;
+
+ /**
+ * @description
+ * Retrieves or overrides the default regular expression that is used for determining trusted safe
+ * urls during a[href] sanitization.
+ *
+ * The sanitization is a security measure aimed at prevent XSS attacks via HTML anchor links.
+ *
+ * Any url due to be assigned to an `a[href]` attribute via interpolation is marked as requiring
+ * the $sce.URL security context. When interpolation occurs a call is made to `$sce.trustAsUrl(url)`
+ * which in turn may call `$$sanitizeUri(url, isMedia)` to sanitize the potentially malicious URL.
+ *
+ * If the URL matches the `aHrefSanitizationTrustedUrlList` regular expression, it is returned unchanged.
+ *
+ * If there is no match the URL is returned prefixed with `'unsafe:'` to ensure that when it is written
+ * to the DOM it is inactive and potentially malicious code will not be executed.
+ *
+ * @param {RegExp=} regexp New regexp to trust urls with.
+ * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
+ * chaining otherwise.
+ */
+ this.aHrefSanitizationTrustedUrlList = function(regexp) {
+ if (isDefined(regexp)) {
+ aHrefSanitizationTrustedUrlList = regexp;
+ return this;
+ }
+ return aHrefSanitizationTrustedUrlList;
+ };
+
+
+ /**
+ * @description
+ * Retrieves or overrides the default regular expression that is used for determining trusted safe
+ * urls during img[src] sanitization.
+ *
+ * The sanitization is a security measure aimed at prevent XSS attacks via HTML image src links.
+ *
+ * Any URL due to be assigned to an `img[src]` attribute via interpolation is marked as requiring
+ * the $sce.MEDIA_URL security context. When interpolation occurs a call is made to
+ * `$sce.trustAsMediaUrl(url)` which in turn may call `$$sanitizeUri(url, isMedia)` to sanitize
+ * the potentially malicious URL.
+ *
+ * If the URL matches the `imgSrcSanitizationTrustedUrlList` regular expression, it is returned
+ * unchanged.
+ *
+ * If there is no match the URL is returned prefixed with `'unsafe:'` to ensure that when it is written
+ * to the DOM it is inactive and potentially malicious code will not be executed.
+ *
+ * @param {RegExp=} regexp New regexp to trust urls with.
+ * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
+ * chaining otherwise.
+ */
+ this.imgSrcSanitizationTrustedUrlList = function(regexp) {
+ if (isDefined(regexp)) {
+ imgSrcSanitizationTrustedUrlList = regexp;
+ return this;
+ }
+ return imgSrcSanitizationTrustedUrlList;
+ };
+
+ this.$get = function() {
+ return function sanitizeUri(uri, isMediaUrl) {
+ // if (!uri) return uri;
+ var regex = isMediaUrl ? imgSrcSanitizationTrustedUrlList : aHrefSanitizationTrustedUrlList;
+ var normalizedVal = urlResolve(uri && uri.trim()).href;
+ if (normalizedVal !== '' && !normalizedVal.match(regex)) {
+ return 'unsafe:' + normalizedVal;
+ }
+ return uri;
+ };
+ };
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Any commits to this file should be reviewed with security in mind. *
+ * Changes to this file can potentially create security vulnerabilities. *
+ * An approval from 2 Core members with history of modifying *
+ * this file is required. *
+ * *
+ * Does the change somehow allow for arbitrary javascript to be executed? *
+ * Or allows for someone to change the prototype of built-in objects? *
+ * Or gives undesired access to variables likes document or window? *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* exported $SceProvider, $SceDelegateProvider */
+
+var $sceMinErr = minErr('$sce');
+
+var SCE_CONTEXTS = {
+ // HTML is used when there's HTML rendered (e.g. ng-bind-html, iframe srcdoc binding).
+ HTML: 'html',
+
+ // Style statements or stylesheets. Currently unused in AngularJS.
+ CSS: 'css',
+
+ // An URL used in a context where it refers to the source of media, which are not expected to be run
+ // as scripts, such as an image, audio, video, etc.
+ MEDIA_URL: 'mediaUrl',
+
+ // An URL used in a context where it does not refer to a resource that loads code.
+ // A value that can be trusted as a URL can also trusted as a MEDIA_URL.
+ URL: 'url',
+
+ // RESOURCE_URL is a subtype of URL used where the referred-to resource could be interpreted as
+ // code. (e.g. ng-include, script src binding, templateUrl)
+ // A value that can be trusted as a RESOURCE_URL, can also trusted as a URL and a MEDIA_URL.
+ RESOURCE_URL: 'resourceUrl',
+
+ // Script. Currently unused in AngularJS.
+ JS: 'js'
+};
+
+// Helper functions follow.
+
+var UNDERSCORE_LOWERCASE_REGEXP = /_([a-z])/g;
+
+function snakeToCamel(name) {
+ return name
+ .replace(UNDERSCORE_LOWERCASE_REGEXP, fnCamelCaseReplace);
+}
+
+function adjustMatcher(matcher) {
+ if (matcher === 'self') {
+ return matcher;
+ } else if (isString(matcher)) {
+ // Strings match exactly except for 2 wildcards - '*' and '**'.
+ // '*' matches any character except those from the set ':/.?&'.
+ // '**' matches any character (like .* in a RegExp).
+ // More than 2 *'s raises an error as it's ill defined.
+ if (matcher.indexOf('***') > -1) {
+ throw $sceMinErr('iwcard',
+ 'Illegal sequence *** in string matcher. String: {0}', matcher);
+ }
+ matcher = escapeForRegexp(matcher).
+ replace(/\\\*\\\*/g, '.*').
+ replace(/\\\*/g, '[^:/.?&;]*');
+ return new RegExp('^' + matcher + '$');
+ } else if (isRegExp(matcher)) {
+ // The only other type of matcher allowed is a Regexp.
+ // Match entire URL / disallow partial matches.
+ // Flags are reset (i.e. no global, ignoreCase or multiline)
+ return new RegExp('^' + matcher.source + '$');
+ } else {
+ throw $sceMinErr('imatcher',
+ 'Matchers may only be "self", string patterns or RegExp objects');
+ }
+}
+
+
+function adjustMatchers(matchers) {
+ var adjustedMatchers = [];
+ if (isDefined(matchers)) {
+ forEach(matchers, function(matcher) {
+ adjustedMatchers.push(adjustMatcher(matcher));
+ });
+ }
+ return adjustedMatchers;
+}
+
+
+/**
+ * @ngdoc service
+ * @name $sceDelegate
+ * @kind function
+ *
+ * @description
+ *
+ * `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict
+ * Contextual Escaping (SCE)} services to AngularJS.
+ *
+ * For an overview of this service and the functionnality it provides in AngularJS, see the main
+ * page for {@link ng.$sce SCE}. The current page is targeted for developers who need to alter how
+ * SCE works in their application, which shouldn't be needed in most cases.
+ *
+ * <div class="alert alert-danger">
+ * AngularJS strongly relies on contextual escaping for the security of bindings: disabling or
+ * modifying this might cause cross site scripting (XSS) vulnerabilities. For libraries owners,
+ * changes to this service will also influence users, so be extra careful and document your changes.
+ * </div>
+ *
+ * Typically, you would configure or override the {@link ng.$sceDelegate $sceDelegate} instead of
+ * the `$sce` service to customize the way Strict Contextual Escaping works in AngularJS. This is
+ * because, while the `$sce` provides numerous shorthand methods, etc., you really only need to
+ * override 3 core functions (`trustAs`, `getTrusted` and `valueOf`) to replace the way things
+ * work because `$sce` delegates to `$sceDelegate` for these operations.
+ *
+ * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} to configure this service.
+ *
+ * The default instance of `$sceDelegate` should work out of the box with little pain. While you
+ * can override it completely to change the behavior of `$sce`, the common case would
+ * involve configuring the {@link ng.$sceDelegateProvider $sceDelegateProvider} instead by setting
+ * your own trusted and banned resource lists for trusting URLs used for loading AngularJS resources
+ * such as templates. Refer {@link ng.$sceDelegateProvider#trustedResourceUrlList
+ * $sceDelegateProvider.trustedResourceUrlList} and {@link
+ * ng.$sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider.bannedResourceUrlList}
+ */
+
+/**
+ * @ngdoc provider
+ * @name $sceDelegateProvider
+ * @this
+ *
+ * @description
+ *
+ * The `$sceDelegateProvider` provider allows developers to configure the {@link ng.$sceDelegate
+ * $sceDelegate service}, used as a delegate for {@link ng.$sce Strict Contextual Escaping (SCE)}.
+ *
+ * The `$sceDelegateProvider` allows one to get/set the `trustedResourceUrlList` and
+ * `bannedResourceUrlList` used to ensure that the URLs used for sourcing AngularJS templates and
+ * other script-running URLs are safe (all places that use the `$sce.RESOURCE_URL` context). See
+ * {@link ng.$sceDelegateProvider#trustedResourceUrlList
+ * $sceDelegateProvider.trustedResourceUrlList} and
+ * {@link ng.$sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider.bannedResourceUrlList},
+ *
+ * For the general details about this service in AngularJS, read the main page for {@link ng.$sce
+ * Strict Contextual Escaping (SCE)}.
+ *
+ * **Example**: Consider the following case. <a name="example"></a>
+ *
+ * - your app is hosted at url `http://myapp.example.com/`
+ * - but some of your templates are hosted on other domains you control such as
+ * `http://srv01.assets.example.com/`, `http://srv02.assets.example.com/`, etc.
+ * - and you have an open redirect at `http://myapp.example.com/clickThru?...`.
+ *
+ * Here is what a secure configuration for this scenario might look like:
+ *
+ * ```
+ * angular.module('myApp', []).config(function($sceDelegateProvider) {
+ * $sceDelegateProvider.trustedResourceUrlList([
+ * // Allow same origin resource loads.
+ * 'self',
+ * // Allow loading from our assets domain. Notice the difference between * and **.
+ * 'http://srv*.assets.example.com/**'
+ * ]);
+ *
+ * // The banned resource URL list overrides the trusted resource URL list so the open redirect
+ * // here is blocked.
+ * $sceDelegateProvider.bannedResourceUrlList([
+ * 'http://myapp.example.com/clickThru**'
+ * ]);
+ * });
+ * ```
+ * Note that an empty trusted resource URL list will block every resource URL from being loaded, and will require
+ * you to manually mark each one as trusted with `$sce.trustAsResourceUrl`. However, templates
+ * requested by {@link ng.$templateRequest $templateRequest} that are present in
+ * {@link ng.$templateCache $templateCache} will not go through this check. If you have a mechanism
+ * to populate your templates in that cache at config time, then it is a good idea to remove 'self'
+ * from the trusted resource URL lsit. This helps to mitigate the security impact of certain types
+ * of issues, like for instance attacker-controlled `ng-includes`.
+ */
+
+function $SceDelegateProvider() {
+ this.SCE_CONTEXTS = SCE_CONTEXTS;
+
+ // Resource URLs can also be trusted by policy.
+ var trustedResourceUrlList = ['self'],
+ bannedResourceUrlList = [];
+
+ /**
+ * @ngdoc method
+ * @name $sceDelegateProvider#trustedResourceUrlList
+ * @kind function
+ *
+ * @param {Array=} trustedResourceUrlList When provided, replaces the trustedResourceUrlList with
+ * the value provided. This must be an array or null. A snapshot of this array is used so
+ * further changes to the array are ignored.
+ * Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
+ * allowed in this array.
+ *
+ * @return {Array} The currently set trusted resource URL array.
+ *
+ * @description
+ * Sets/Gets the list trusted of resource URLs.
+ *
+ * The **default value** when no `trustedResourceUrlList` has been explicitly set is `['self']`
+ * allowing only same origin resource requests.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** the default `trustedResourceUrlList` of 'self' is not recommended if your app shares
+ * its origin with other apps! It is a good idea to limit it to only your application's directory.
+ * </div>
+ */
+ this.trustedResourceUrlList = function(value) {
+ if (arguments.length) {
+ trustedResourceUrlList = adjustMatchers(value);
+ }
+ return trustedResourceUrlList;
+ };
+
+ /**
+ * @ngdoc method
+ * @name $sceDelegateProvider#resourceUrlWhitelist
+ * @kind function
+ *
+ * @deprecated
+ * sinceVersion="1.8.1"
+ *
+ * This method is deprecated. Use {@link $sceDelegateProvider#trustedResourceUrlList
+ * trustedResourceUrlList} instead.
+ */
+ Object.defineProperty(this, 'resourceUrlWhitelist', {
+ get: function() {
+ return this.trustedResourceUrlList;
+ },
+ set: function(value) {
+ this.trustedResourceUrlList = value;
+ }
+ });
+
+ /**
+ * @ngdoc method
+ * @name $sceDelegateProvider#bannedResourceUrlList
+ * @kind function
+ *
+ * @param {Array=} bannedResourceUrlList When provided, replaces the `bannedResourceUrlList` with
+ * the value provided. This must be an array or null. A snapshot of this array is used so
+ * further changes to the array are ignored.</p><p>
+ * Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
+ * allowed in this array.</p><p>
+ * The typical usage for the `bannedResourceUrlList` is to **block
+ * [open redirects](http://cwe.mitre.org/data/definitions/601.html)** served by your domain as
+ * these would otherwise be trusted but actually return content from the redirected domain.
+ * </p><p>
+ * Finally, **the banned resource URL list overrides the trusted resource URL list** and has
+ * the final say.
+ *
+ * @return {Array} The currently set `bannedResourceUrlList` array.
+ *
+ * @description
+ * Sets/Gets the `bannedResourceUrlList` of trusted resource URLs.
+ *
+ * The **default value** when no trusted resource URL list has been explicitly set is the empty
+ * array (i.e. there is no `bannedResourceUrlList`.)
+ */
+ this.bannedResourceUrlList = function(value) {
+ if (arguments.length) {
+ bannedResourceUrlList = adjustMatchers(value);
+ }
+ return bannedResourceUrlList;
+ };
+
+ /**
+ * @ngdoc method
+ * @name $sceDelegateProvider#resourceUrlBlacklist
+ * @kind function
+ *
+ * @deprecated
+ * sinceVersion="1.8.1"
+ *
+ * This method is deprecated. Use {@link $sceDelegateProvider#bannedResourceUrlList
+ * bannedResourceUrlList} instead.
+ */
+ Object.defineProperty(this, 'resourceUrlBlacklist', {
+ get: function() {
+ return this.bannedResourceUrlList;
+ },
+ set: function(value) {
+ this.bannedResourceUrlList = value;
+ }
+ });
+
+ this.$get = ['$injector', '$$sanitizeUri', function($injector, $$sanitizeUri) {
+
+ var htmlSanitizer = function htmlSanitizer(html) {
+ throw $sceMinErr('unsafe', 'Attempting to use an unsafe value in a safe context.');
+ };
+
+ if ($injector.has('$sanitize')) {
+ htmlSanitizer = $injector.get('$sanitize');
+ }
+
+
+ function matchUrl(matcher, parsedUrl) {
+ if (matcher === 'self') {
+ return urlIsSameOrigin(parsedUrl) || urlIsSameOriginAsBaseUrl(parsedUrl);
+ } else {
+ // definitely a regex. See adjustMatchers()
+ return !!matcher.exec(parsedUrl.href);
+ }
+ }
+
+ function isResourceUrlAllowedByPolicy(url) {
+ var parsedUrl = urlResolve(url.toString());
+ var i, n, allowed = false;
+ // Ensure that at least one item from the trusted resource URL list allows this url.
+ for (i = 0, n = trustedResourceUrlList.length; i < n; i++) {
+ if (matchUrl(trustedResourceUrlList[i], parsedUrl)) {
+ allowed = true;
+ break;
+ }
+ }
+ if (allowed) {
+ // Ensure that no item from the banned resource URL list has blocked this url.
+ for (i = 0, n = bannedResourceUrlList.length; i < n; i++) {
+ if (matchUrl(bannedResourceUrlList[i], parsedUrl)) {
+ allowed = false;
+ break;
+ }
+ }
+ }
+ return allowed;
+ }
+
+ function generateHolderType(Base) {
+ var holderType = function TrustedValueHolderType(trustedValue) {
+ this.$$unwrapTrustedValue = function() {
+ return trustedValue;
+ };
+ };
+ if (Base) {
+ holderType.prototype = new Base();
+ }
+ holderType.prototype.valueOf = function sceValueOf() {
+ return this.$$unwrapTrustedValue();
+ };
+ holderType.prototype.toString = function sceToString() {
+ return this.$$unwrapTrustedValue().toString();
+ };
+ return holderType;
+ }
+
+ var trustedValueHolderBase = generateHolderType(),
+ byType = {};
+
+ byType[SCE_CONTEXTS.HTML] = generateHolderType(trustedValueHolderBase);
+ byType[SCE_CONTEXTS.CSS] = generateHolderType(trustedValueHolderBase);
+ byType[SCE_CONTEXTS.MEDIA_URL] = generateHolderType(trustedValueHolderBase);
+ byType[SCE_CONTEXTS.URL] = generateHolderType(byType[SCE_CONTEXTS.MEDIA_URL]);
+ byType[SCE_CONTEXTS.JS] = generateHolderType(trustedValueHolderBase);
+ byType[SCE_CONTEXTS.RESOURCE_URL] = generateHolderType(byType[SCE_CONTEXTS.URL]);
+
+ /**
+ * @ngdoc method
+ * @name $sceDelegate#trustAs
+ *
+ * @description
+ * Returns a trusted representation of the parameter for the specified context. This trusted
+ * object will later on be used as-is, without any security check, by bindings or directives
+ * that require this security context.
+ * For instance, marking a string as trusted for the `$sce.HTML` context will entirely bypass
+ * the potential `$sanitize` call in corresponding `$sce.HTML` bindings or directives, such as
+ * `ng-bind-html`. Note that in most cases you won't need to call this function: if you have the
+ * sanitizer loaded, passing the value itself will render all the HTML that does not pose a
+ * security risk.
+ *
+ * See {@link ng.$sceDelegate#getTrusted getTrusted} for the function that will consume those
+ * trusted values, and {@link ng.$sce $sce} for general documentation about strict contextual
+ * escaping.
+ *
+ * @param {string} type The context in which this value is safe for use, e.g. `$sce.URL`,
+ * `$sce.RESOURCE_URL`, `$sce.HTML`, `$sce.JS` or `$sce.CSS`.
+ *
+ * @param {*} value The value that should be considered trusted.
+ * @return {*} A trusted representation of value, that can be used in the given context.
+ */
+ function trustAs(type, trustedValue) {
+ var Constructor = (byType.hasOwnProperty(type) ? byType[type] : null);
+ if (!Constructor) {
+ throw $sceMinErr('icontext',
+ 'Attempted to trust a value in invalid context. Context: {0}; Value: {1}',
+ type, trustedValue);
+ }
+ if (trustedValue === null || isUndefined(trustedValue) || trustedValue === '') {
+ return trustedValue;
+ }
+ // All the current contexts in SCE_CONTEXTS happen to be strings. In order to avoid trusting
+ // mutable objects, we ensure here that the value passed in is actually a string.
+ if (typeof trustedValue !== 'string') {
+ throw $sceMinErr('itype',
+ 'Attempted to trust a non-string value in a content requiring a string: Context: {0}',
+ type);
+ }
+ return new Constructor(trustedValue);
+ }
+
+ /**
+ * @ngdoc method
+ * @name $sceDelegate#valueOf
+ *
+ * @description
+ * If the passed parameter had been returned by a prior call to {@link ng.$sceDelegate#trustAs
+ * `$sceDelegate.trustAs`}, returns the value that had been passed to {@link
+ * ng.$sceDelegate#trustAs `$sceDelegate.trustAs`}.
+ *
+ * If the passed parameter is not a value that had been returned by {@link
+ * ng.$sceDelegate#trustAs `$sceDelegate.trustAs`}, it must be returned as-is.
+ *
+ * @param {*} value The result of a prior {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs`}
+ * call or anything else.
+ * @return {*} The `value` that was originally provided to {@link ng.$sceDelegate#trustAs
+ * `$sceDelegate.trustAs`} if `value` is the result of such a call. Otherwise, returns
+ * `value` unchanged.
+ */
+ function valueOf(maybeTrusted) {
+ if (maybeTrusted instanceof trustedValueHolderBase) {
+ return maybeTrusted.$$unwrapTrustedValue();
+ } else {
+ return maybeTrusted;
+ }
+ }
+
+ /**
+ * @ngdoc method
+ * @name $sceDelegate#getTrusted
+ *
+ * @description
+ * Given an object and a security context in which to assign it, returns a value that's safe to
+ * use in this context, which was represented by the parameter. To do so, this function either
+ * unwraps the safe type it has been given (for instance, a {@link ng.$sceDelegate#trustAs
+ * `$sceDelegate.trustAs`} result), or it might try to sanitize the value given, depending on
+ * the context and sanitizer availablility.
+ *
+ * The contexts that can be sanitized are $sce.MEDIA_URL, $sce.URL and $sce.HTML. The first two are available
+ * by default, and the third one relies on the `$sanitize` service (which may be loaded through
+ * the `ngSanitize` module). Furthermore, for $sce.RESOURCE_URL context, a plain string may be
+ * accepted if the resource url policy defined by {@link ng.$sceDelegateProvider#trustedResourceUrlList
+ * `$sceDelegateProvider.trustedResourceUrlList`} and {@link ng.$sceDelegateProvider#bannedResourceUrlList
+ * `$sceDelegateProvider.bannedResourceUrlList`} accepts that resource.
+ *
+ * This function will throw if the safe type isn't appropriate for this context, or if the
+ * value given cannot be accepted in the context (which might be caused by sanitization not
+ * being available, or the value not being recognized as safe).
+ *
+ * <div class="alert alert-danger">
+ * Disabling auto-escaping is extremely dangerous, it usually creates a Cross Site Scripting
+ * (XSS) vulnerability in your application.
+ * </div>
+ *
+ * @param {string} type The context in which this value is to be used (such as `$sce.HTML`).
+ * @param {*} maybeTrusted The result of a prior {@link ng.$sceDelegate#trustAs
+ * `$sceDelegate.trustAs`} call, or anything else (which will not be considered trusted.)
+ * @return {*} A version of the value that's safe to use in the given context, or throws an
+ * exception if this is impossible.
+ */
+ function getTrusted(type, maybeTrusted) {
+ if (maybeTrusted === null || isUndefined(maybeTrusted) || maybeTrusted === '') {
+ return maybeTrusted;
+ }
+ var constructor = (byType.hasOwnProperty(type) ? byType[type] : null);
+ // If maybeTrusted is a trusted class instance or subclass instance, then unwrap and return
+ // as-is.
+ if (constructor && maybeTrusted instanceof constructor) {
+ return maybeTrusted.$$unwrapTrustedValue();
+ }
+
+ // If maybeTrusted is a trusted class instance but not of the correct trusted type
+ // then unwrap it and allow it to pass through to the rest of the checks
+ if (isFunction(maybeTrusted.$$unwrapTrustedValue)) {
+ maybeTrusted = maybeTrusted.$$unwrapTrustedValue();
+ }
+
+ // If we get here, then we will either sanitize the value or throw an exception.
+ if (type === SCE_CONTEXTS.MEDIA_URL || type === SCE_CONTEXTS.URL) {
+ // we attempt to sanitize non-resource URLs
+ return $$sanitizeUri(maybeTrusted.toString(), type === SCE_CONTEXTS.MEDIA_URL);
+ } else if (type === SCE_CONTEXTS.RESOURCE_URL) {
+ if (isResourceUrlAllowedByPolicy(maybeTrusted)) {
+ return maybeTrusted;
+ } else {
+ throw $sceMinErr('insecurl',
+ 'Blocked loading resource from url not allowed by $sceDelegate policy. URL: {0}',
+ maybeTrusted.toString());
+ }
+ } else if (type === SCE_CONTEXTS.HTML) {
+ // htmlSanitizer throws its own error when no sanitizer is available.
+ return htmlSanitizer(maybeTrusted);
+ }
+ // Default error when the $sce service has no way to make the input safe.
+ throw $sceMinErr('unsafe', 'Attempting to use an unsafe value in a safe context.');
+ }
+
+ return { trustAs: trustAs,
+ getTrusted: getTrusted,
+ valueOf: valueOf };
+ }];
+}
+
+
+/**
+ * @ngdoc provider
+ * @name $sceProvider
+ * @this
+ *
+ * @description
+ *
+ * The $sceProvider provider allows developers to configure the {@link ng.$sce $sce} service.
+ * - enable/disable Strict Contextual Escaping (SCE) in a module
+ * - override the default implementation with a custom delegate
+ *
+ * Read more about {@link ng.$sce Strict Contextual Escaping (SCE)}.
+ */
+
+/**
+ * @ngdoc service
+ * @name $sce
+ * @kind function
+ *
+ * @description
+ *
+ * `$sce` is a service that provides Strict Contextual Escaping services to AngularJS.
+ *
+ * ## Strict Contextual Escaping
+ *
+ * Strict Contextual Escaping (SCE) is a mode in which AngularJS constrains bindings to only render
+ * trusted values. Its goal is to assist in writing code in a way that (a) is secure by default, and
+ * (b) makes auditing for security vulnerabilities such as XSS, clickjacking, etc. a lot easier.
+ *
+ * ### Overview
+ *
+ * To systematically block XSS security bugs, AngularJS treats all values as untrusted by default in
+ * HTML or sensitive URL bindings. When binding untrusted values, AngularJS will automatically
+ * run security checks on them (sanitizations, trusted URL resource, depending on context), or throw
+ * when it cannot guarantee the security of the result. That behavior depends strongly on contexts:
+ * HTML can be sanitized, but template URLs cannot, for instance.
+ *
+ * To illustrate this, consider the `ng-bind-html` directive. It renders its value directly as HTML:
+ * we call that the *context*. When given an untrusted input, AngularJS will attempt to sanitize it
+ * before rendering if a sanitizer is available, and throw otherwise. To bypass sanitization and
+ * render the input as-is, you will need to mark it as trusted for that context before attempting
+ * to bind it.
+ *
+ * As of version 1.2, AngularJS ships with SCE enabled by default.
+ *
+ * ### In practice
+ *
+ * Here's an example of a binding in a privileged context:
+ *
+ * ```
+ * <input ng-model="userHtml" aria-label="User input">
+ * <div ng-bind-html="userHtml"></div>
+ * ```
+ *
+ * Notice that `ng-bind-html` is bound to `userHtml` controlled by the user. With SCE
+ * disabled, this application allows the user to render arbitrary HTML into the DIV, which would
+ * be an XSS security bug. In a more realistic example, one may be rendering user comments, blog
+ * articles, etc. via bindings. (HTML is just one example of a context where rendering user
+ * controlled input creates security vulnerabilities.)
+ *
+ * For the case of HTML, you might use a library, either on the client side, or on the server side,
+ * to sanitize unsafe HTML before binding to the value and rendering it in the document.
+ *
+ * How would you ensure that every place that used these types of bindings was bound to a value that
+ * was sanitized by your library (or returned as safe for rendering by your server?) How can you
+ * ensure that you didn't accidentally delete the line that sanitized the value, or renamed some
+ * properties/fields and forgot to update the binding to the sanitized value?
+ *
+ * To be secure by default, AngularJS makes sure bindings go through that sanitization, or
+ * any similar validation process, unless there's a good reason to trust the given value in this
+ * context. That trust is formalized with a function call. This means that as a developer, you
+ * can assume all untrusted bindings are safe. Then, to audit your code for binding security issues,
+ * you just need to ensure the values you mark as trusted indeed are safe - because they were
+ * received from your server, sanitized by your library, etc. You can organize your codebase to
+ * help with this - perhaps allowing only the files in a specific directory to do this.
+ * Ensuring that the internal API exposed by that code doesn't markup arbitrary values as safe then
+ * becomes a more manageable task.
+ *
+ * In the case of AngularJS' SCE service, one uses {@link ng.$sce#trustAs $sce.trustAs}
+ * (and shorthand methods such as {@link ng.$sce#trustAsHtml $sce.trustAsHtml}, etc.) to
+ * build the trusted versions of your values.
+ *
+ * ### How does it work?
+ *
+ * In privileged contexts, directives and code will bind to the result of {@link ng.$sce#getTrusted
+ * $sce.getTrusted(context, value)} rather than to the value directly. Think of this function as
+ * a way to enforce the required security context in your data sink. Directives use {@link
+ * ng.$sce#parseAs $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs
+ * the {@link ng.$sce#getTrusted $sce.getTrusted} behind the scenes on non-constant literals. Also,
+ * when binding without directives, AngularJS will understand the context of your bindings
+ * automatically.
+ *
+ * As an example, {@link ng.directive:ngBindHtml ngBindHtml} uses {@link
+ * ng.$sce#parseAsHtml $sce.parseAsHtml(binding expression)}. Here's the actual code (slightly
+ * simplified):
+ *
+ * ```
+ * var ngBindHtmlDirective = ['$sce', function($sce) {
+ * return function(scope, element, attr) {
+ * scope.$watch($sce.parseAsHtml(attr.ngBindHtml), function(value) {
+ * element.html(value || '');
+ * });
+ * };
+ * }];
+ * ```
+ *
+ * ### Impact on loading templates
+ *
+ * This applies both to the {@link ng.directive:ngInclude `ng-include`} directive as well as
+ * `templateUrl`'s specified by {@link guide/directive directives}.
+ *
+ * By default, AngularJS only loads templates from the same domain and protocol as the application
+ * document. This is done by calling {@link ng.$sce#getTrustedResourceUrl
+ * $sce.getTrustedResourceUrl} on the template URL. To load templates from other domains and/or
+ * protocols, you may either add them to the {@link ng.$sceDelegateProvider#trustedResourceUrlList
+ * trustedResourceUrlList} or {@link ng.$sce#trustAsResourceUrl wrap them} into trusted values.
+ *
+ * *Please note*:
+ * The browser's
+ * [Same Origin Policy](https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest)
+ * and [Cross-Origin Resource Sharing (CORS)](http://www.w3.org/TR/cors/)
+ * policy apply in addition to this and may further restrict whether the template is successfully
+ * loaded. This means that without the right CORS policy, loading templates from a different domain
+ * won't work on all browsers. Also, loading templates from `file://` URL does not work on some
+ * browsers.
+ *
+ * ### This feels like too much overhead
+ *
+ * It's important to remember that SCE only applies to interpolation expressions.
+ *
+ * If your expressions are constant literals, they're automatically trusted and you don't need to
+ * call `$sce.trustAs` on them (e.g.
+ * `<div ng-bind-html="'<b>implicitly trusted</b>'"></div>`) just works (remember to include the
+ * `ngSanitize` module). The `$sceDelegate` will also use the `$sanitize` service if it is available
+ * when binding untrusted values to `$sce.HTML` context.
+ * AngularJS provides an implementation in `angular-sanitize.js`, and if you
+ * wish to use it, you will also need to depend on the {@link ngSanitize `ngSanitize`} module in
+ * your application.
+ *
+ * The included {@link ng.$sceDelegate $sceDelegate} comes with sane defaults to allow you to load
+ * templates in `ng-include` from your application's domain without having to even know about SCE.
+ * It blocks loading templates from other domains or loading templates over http from an https
+ * served document. You can change these by setting your own custom {@link
+ * ng.$sceDelegateProvider#trustedResourceUrlList trusted resource URL list} and {@link
+ * ng.$sceDelegateProvider#bannedResourceUrlList banned resource URL list} for matching such URLs.
+ *
+ * This significantly reduces the overhead. It is far easier to pay the small overhead and have an
+ * application that's secure and can be audited to verify that with much more ease than bolting
+ * security onto an application later.
+ *
+ * <a name="contexts"></a>
+ * ### What trusted context types are supported?
+ *
+ * | Context | Notes |
+ * |---------------------|----------------|
+ * | `$sce.HTML` | For HTML that's safe to source into the application. The {@link ng.directive:ngBindHtml ngBindHtml} directive uses this context for bindings. If an unsafe value is encountered and the {@link ngSanitize $sanitize} module is present this will sanitize the value instead of throwing an error. |
+ * | `$sce.CSS` | For CSS that's safe to source into the application. Currently unused. Feel free to use it in your own directives. |
+ * | `$sce.MEDIA_URL` | For URLs that are safe to render as media. Is automatically converted from string by sanitizing when needed. |
+ * | `$sce.URL` | For URLs that are safe to follow as links. Is automatically converted from string by sanitizing when needed. Note that `$sce.URL` makes a stronger statement about the URL than `$sce.MEDIA_URL` does and therefore contexts requiring values trusted for `$sce.URL` can be used anywhere that values trusted for `$sce.MEDIA_URL` are required.|
+ * | `$sce.RESOURCE_URL` | For URLs that are not only safe to follow as links, but whose contents are also safe to include in your application. Examples include `ng-include`, `src` / `ngSrc` bindings for tags other than `IMG` (e.g. `IFRAME`, `OBJECT`, etc.) <br><br>Note that `$sce.RESOURCE_URL` makes a stronger statement about the URL than `$sce.URL` or `$sce.MEDIA_URL` do and therefore contexts requiring values trusted for `$sce.RESOURCE_URL` can be used anywhere that values trusted for `$sce.URL` or `$sce.MEDIA_URL` are required. <br><br> The {@link $sceDelegateProvider#trustedResourceUrlList $sceDelegateProvider#trustedResourceUrlList()} and {@link $sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider#bannedResourceUrlList()} can be used to restrict trusted origins for `RESOURCE_URL` |
+ * | `$sce.JS` | For JavaScript that is safe to execute in your application's context. Currently unused. Feel free to use it in your own directives. |
+ *
+ *
+ * <div class="alert alert-warning">
+ * Be aware that, before AngularJS 1.7.0, `a[href]` and `img[src]` used to sanitize their
+ * interpolated values directly rather than rely upon {@link ng.$sce#getTrusted `$sce.getTrusted`}.
+ *
+ * **As of 1.7.0, this is no longer the case.**
+ *
+ * Now such interpolations are marked as requiring `$sce.URL` (for `a[href]`) or `$sce.MEDIA_URL`
+ * (for `img[src]`), so that the sanitization happens (via `$sce.getTrusted...`) when the `$interpolate`
+ * service evaluates the expressions.
+ * </div>
+ *
+ * There are no CSS or JS context bindings in AngularJS currently, so their corresponding `$sce.trustAs`
+ * functions aren't useful yet. This might evolve.
+ *
+ * ### Format of items in {@link ng.$sceDelegateProvider#trustedResourceUrlList trustedResourceUrlList}/{@link ng.$sceDelegateProvider#bannedResourceUrlList bannedResourceUrlList} <a name="resourceUrlPatternItem"></a>
+ *
+ * Each element in these arrays must be one of the following:
+ *
+ * - **'self'**
+ * - The special **string**, `'self'`, can be used to match against all URLs of the **same
+ * domain** as the application document using the **same protocol**.
+ * - **String** (except the special value `'self'`)
+ * - The string is matched against the full *normalized / absolute URL* of the resource
+ * being tested (substring matches are not good enough.)
+ * - There are exactly **two wildcard sequences** - `*` and `**`. All other characters
+ * match themselves.
+ * - `*`: matches zero or more occurrences of any character other than one of the following 6
+ * characters: '`:`', '`/`', '`.`', '`?`', '`&`' and '`;`'. It's a useful wildcard for use
+ * for matching resource URL lists.
+ * - `**`: matches zero or more occurrences of *any* character. As such, it's not
+ * appropriate for use in a scheme, domain, etc. as it would match too much. (e.g.
+ * http://**.example.com/ would match http://evil.com/?ignore=.example.com/ and that might
+ * not have been the intention.) Its usage at the very end of the path is ok. (e.g.
+ * http://foo.example.com/templates/**).
+ * - **RegExp** (*see caveat below*)
+ * - *Caveat*: While regular expressions are powerful and offer great flexibility, their syntax
+ * (and all the inevitable escaping) makes them *harder to maintain*. It's easy to
+ * accidentally introduce a bug when one updates a complex expression (imho, all regexes should
+ * have good test coverage). For instance, the use of `.` in the regex is correct only in a
+ * small number of cases. A `.` character in the regex used when matching the scheme or a
+ * subdomain could be matched against a `:` or literal `.` that was likely not intended. It
+ * is highly recommended to use the string patterns and only fall back to regular expressions
+ * as a last resort.
+ * - The regular expression must be an instance of RegExp (i.e. not a string.) It is
+ * matched against the **entire** *normalized / absolute URL* of the resource being tested
+ * (even when the RegExp did not have the `^` and `$` codes.) In addition, any flags
+ * present on the RegExp (such as multiline, global, ignoreCase) are ignored.
+ * - If you are generating your JavaScript from some other templating engine (not
+ * recommended, e.g. in issue [#4006](https://github.com/angular/angular.js/issues/4006)),
+ * remember to escape your regular expression (and be aware that you might need more than
+ * one level of escaping depending on your templating engine and the way you interpolated
+ * the value.) Do make use of your platform's escaping mechanism as it might be good
+ * enough before coding your own. E.g. Ruby has
+ * [Regexp.escape(str)](http://www.ruby-doc.org/core-2.0.0/Regexp.html#method-c-escape)
+ * and Python has [re.escape](http://docs.python.org/library/re.html#re.escape).
+ * Javascript lacks a similar built in function for escaping. Take a look at Google
+ * Closure library's [goog.string.regExpEscape(s)](
+ * http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962).
+ *
+ * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} for an example.
+ *
+ * ### Show me an example using SCE.
+ *
+ * <example module="mySceApp" deps="angular-sanitize.js" name="sce-service">
+ * <file name="index.html">
+ * <div ng-controller="AppController as myCtrl">
+ * <i ng-bind-html="myCtrl.explicitlyTrustedHtml" id="explicitlyTrustedHtml"></i><br><br>
+ * <b>User comments</b><br>
+ * By default, HTML that isn't explicitly trusted (e.g. Alice's comment) is sanitized when
+ * $sanitize is available. If $sanitize isn't available, this results in an error instead of an
+ * exploit.
+ * <div class="well">
+ * <div ng-repeat="userComment in myCtrl.userComments">
+ * <b>{{userComment.name}}</b>:
+ * <span ng-bind-html="userComment.htmlComment" class="htmlComment"></span>
+ * <br>
+ * </div>
+ * </div>
+ * </div>
+ * </file>
+ *
+ * <file name="script.js">
+ * angular.module('mySceApp', ['ngSanitize'])
+ * .controller('AppController', ['$http', '$templateCache', '$sce',
+ * function AppController($http, $templateCache, $sce) {
+ * var self = this;
+ * $http.get('test_data.json', {cache: $templateCache}).then(function(response) {
+ * self.userComments = response.data;
+ * });
+ * self.explicitlyTrustedHtml = $sce.trustAsHtml(
+ * '<span onmouseover="this.textContent="Explicitly trusted HTML bypasses ' +
+ * 'sanitization."">Hover over this text.</span>');
+ * }]);
+ * </file>
+ *
+ * <file name="test_data.json">
+ * [
+ * { "name": "Alice",
+ * "htmlComment":
+ * "<span onmouseover='this.textContent=\"PWN3D!\"'>Is <i>anyone</i> reading this?</span>"
+ * },
+ * { "name": "Bob",
+ * "htmlComment": "<i>Yes!</i> Am I the only other one?"
+ * }
+ * ]
+ * </file>
+ *
+ * <file name="protractor.js" type="protractor">
+ * describe('SCE doc demo', function() {
+ * it('should sanitize untrusted values', function() {
+ * expect(element.all(by.css('.htmlComment')).first().getAttribute('innerHTML'))
+ * .toBe('<span>Is <i>anyone</i> reading this?</span>');
+ * });
+ *
+ * it('should NOT sanitize explicitly trusted values', function() {
+ * expect(element(by.id('explicitlyTrustedHtml')).getAttribute('innerHTML')).toBe(
+ * '<span onmouseover="this.textContent="Explicitly trusted HTML bypasses ' +
+ * 'sanitization."">Hover over this text.</span>');
+ * });
+ * });
+ * </file>
+ * </example>
+ *
+ *
+ *
+ * ## Can I disable SCE completely?
+ *
+ * Yes, you can. However, this is strongly discouraged. SCE gives you a lot of security benefits
+ * for little coding overhead. It will be much harder to take an SCE disabled application and
+ * either secure it on your own or enable SCE at a later stage. It might make sense to disable SCE
+ * for cases where you have a lot of existing code that was written before SCE was introduced and
+ * you're migrating them a module at a time. Also do note that this is an app-wide setting, so if
+ * you are writing a library, you will cause security bugs applications using it.
+ *
+ * That said, here's how you can completely disable SCE:
+ *
+ * ```
+ * angular.module('myAppWithSceDisabledmyApp', []).config(function($sceProvider) {
+ * // Completely disable SCE. For demonstration purposes only!
+ * // Do not use in new projects or libraries.
+ * $sceProvider.enabled(false);
+ * });
+ * ```
+ *
+ */
+
+function $SceProvider() {
+ var enabled = true;
+
+ /**
+ * @ngdoc method
+ * @name $sceProvider#enabled
+ * @kind function
+ *
+ * @param {boolean=} value If provided, then enables/disables SCE application-wide.
+ * @return {boolean} True if SCE is enabled, false otherwise.
+ *
+ * @description
+ * Enables/disables SCE and returns the current value.
+ */
+ this.enabled = function(value) {
+ if (arguments.length) {
+ enabled = !!value;
+ }
+ return enabled;
+ };
+
+
+ /* Design notes on the default implementation for SCE.
+ *
+ * The API contract for the SCE delegate
+ * -------------------------------------
+ * The SCE delegate object must provide the following 3 methods:
+ *
+ * - trustAs(contextEnum, value)
+ * This method is used to tell the SCE service that the provided value is OK to use in the
+ * contexts specified by contextEnum. It must return an object that will be accepted by
+ * getTrusted() for a compatible contextEnum and return this value.
+ *
+ * - valueOf(value)
+ * For values that were not produced by trustAs(), return them as is. For values that were
+ * produced by trustAs(), return the corresponding input value to trustAs. Basically, if
+ * trustAs is wrapping the given values into some type, this operation unwraps it when given
+ * such a value.
+ *
+ * - getTrusted(contextEnum, value)
+ * This function should return the value that is safe to use in the context specified by
+ * contextEnum or throw and exception otherwise.
+ *
+ * NOTE: This contract deliberately does NOT state that values returned by trustAs() must be
+ * opaque or wrapped in some holder object. That happens to be an implementation detail. For
+ * instance, an implementation could maintain a registry of all trusted objects by context. In
+ * such a case, trustAs() would return the same object that was passed in. getTrusted() would
+ * return the same object passed in if it was found in the registry under a compatible context or
+ * throw an exception otherwise. An implementation might only wrap values some of the time based
+ * on some criteria. getTrusted() might return a value and not throw an exception for special
+ * constants or objects even if not wrapped. All such implementations fulfill this contract.
+ *
+ *
+ * A note on the inheritance model for SCE contexts
+ * ------------------------------------------------
+ * I've used inheritance and made RESOURCE_URL wrapped types a subtype of URL wrapped types. This
+ * is purely an implementation details.
+ *
+ * The contract is simply this:
+ *
+ * getTrusted($sce.RESOURCE_URL, value) succeeding implies that getTrusted($sce.URL, value)
+ * will also succeed.
+ *
+ * Inheritance happens to capture this in a natural way. In some future, we may not use
+ * inheritance anymore. That is OK because no code outside of sce.js and sceSpecs.js would need to
+ * be aware of this detail.
+ */
+
+ this.$get = ['$parse', '$sceDelegate', function(
+ $parse, $sceDelegate) {
+ // Support: IE 9-11 only
+ // Prereq: Ensure that we're not running in IE<11 quirks mode. In that mode, IE < 11 allow
+ // the "expression(javascript expression)" syntax which is insecure.
+ if (enabled && msie < 8) {
+ throw $sceMinErr('iequirks',
+ 'Strict Contextual Escaping does not support Internet Explorer version < 11 in quirks ' +
+ 'mode. You can fix this by adding the text <!doctype html> to the top of your HTML ' +
+ 'document. See http://docs.angularjs.org/api/ng.$sce for more information.');
+ }
+
+ var sce = shallowCopy(SCE_CONTEXTS);
+
+ /**
+ * @ngdoc method
+ * @name $sce#isEnabled
+ * @kind function
+ *
+ * @return {Boolean} True if SCE is enabled, false otherwise. If you want to set the value, you
+ * have to do it at module config time on {@link ng.$sceProvider $sceProvider}.
+ *
+ * @description
+ * Returns a boolean indicating if SCE is enabled.
+ */
+ sce.isEnabled = function() {
+ return enabled;
+ };
+ sce.trustAs = $sceDelegate.trustAs;
+ sce.getTrusted = $sceDelegate.getTrusted;
+ sce.valueOf = $sceDelegate.valueOf;
+
+ if (!enabled) {
+ sce.trustAs = sce.getTrusted = function(type, value) { return value; };
+ sce.valueOf = identity;
+ }
+
+ /**
+ * @ngdoc method
+ * @name $sce#parseAs
+ *
+ * @description
+ * Converts AngularJS {@link guide/expression expression} into a function. This is like {@link
+ * ng.$parse $parse} and is identical when the expression is a literal constant. Otherwise, it
+ * wraps the expression in a call to {@link ng.$sce#getTrusted $sce.getTrusted(*type*,
+ * *result*)}
+ *
+ * @param {string} type The SCE context in which this result will be used.
+ * @param {string} expression String expression to compile.
+ * @return {function(context, locals)} A function which represents the compiled expression:
+ *
+ * * `context` – `{object}` – an object against which any expressions embedded in the
+ * strings are evaluated against (typically a scope object).
+ * * `locals` – `{object=}` – local variables context object, useful for overriding values
+ * in `context`.
+ */
+ sce.parseAs = function sceParseAs(type, expr) {
+ var parsed = $parse(expr);
+ if (parsed.literal && parsed.constant) {
+ return parsed;
+ } else {
+ return $parse(expr, function(value) {
+ return sce.getTrusted(type, value);
+ });
+ }
+ };
+
+ /**
+ * @ngdoc method
+ * @name $sce#trustAs
+ *
+ * @description
+ * Delegates to {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs`}. As such, returns a
+ * wrapped object that represents your value, and the trust you have in its safety for the given
+ * context. AngularJS can then use that value as-is in bindings of the specified secure context.
+ * This is used in bindings for `ng-bind-html`, `ng-include`, and most `src` attribute
+ * interpolations. See {@link ng.$sce $sce} for strict contextual escaping.
+ *
+ * @param {string} type The context in which this value is safe for use, e.g. `$sce.URL`,
+ * `$sce.RESOURCE_URL`, `$sce.HTML`, `$sce.JS` or `$sce.CSS`.
+ *
+ * @param {*} value The value that that should be considered trusted.
+ * @return {*} A wrapped version of value that can be used as a trusted variant of your `value`
+ * in the context you specified.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#trustAsHtml
+ *
+ * @description
+ * Shorthand method. `$sce.trustAsHtml(value)` →
+ * {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs($sce.HTML, value)`}
+ *
+ * @param {*} value The value to mark as trusted for `$sce.HTML` context.
+ * @return {*} A wrapped version of value that can be used as a trusted variant of your `value`
+ * in `$sce.HTML` context (like `ng-bind-html`).
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#trustAsCss
+ *
+ * @description
+ * Shorthand method. `$sce.trustAsCss(value)` →
+ * {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs($sce.CSS, value)`}
+ *
+ * @param {*} value The value to mark as trusted for `$sce.CSS` context.
+ * @return {*} A wrapped version of value that can be used as a trusted variant
+ * of your `value` in `$sce.CSS` context. This context is currently unused, so there are
+ * almost no reasons to use this function so far.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#trustAsUrl
+ *
+ * @description
+ * Shorthand method. `$sce.trustAsUrl(value)` →
+ * {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs($sce.URL, value)`}
+ *
+ * @param {*} value The value to mark as trusted for `$sce.URL` context.
+ * @return {*} A wrapped version of value that can be used as a trusted variant of your `value`
+ * in `$sce.URL` context. That context is currently unused, so there are almost no reasons
+ * to use this function so far.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#trustAsResourceUrl
+ *
+ * @description
+ * Shorthand method. `$sce.trustAsResourceUrl(value)` →
+ * {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs($sce.RESOURCE_URL, value)`}
+ *
+ * @param {*} value The value to mark as trusted for `$sce.RESOURCE_URL` context.
+ * @return {*} A wrapped version of value that can be used as a trusted variant of your `value`
+ * in `$sce.RESOURCE_URL` context (template URLs in `ng-include`, most `src` attribute
+ * bindings, ...)
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#trustAsJs
+ *
+ * @description
+ * Shorthand method. `$sce.trustAsJs(value)` →
+ * {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs($sce.JS, value)`}
+ *
+ * @param {*} value The value to mark as trusted for `$sce.JS` context.
+ * @return {*} A wrapped version of value that can be used as a trusted variant of your `value`
+ * in `$sce.JS` context. That context is currently unused, so there are almost no reasons to
+ * use this function so far.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#getTrusted
+ *
+ * @description
+ * Delegates to {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted`}. As such,
+ * takes any input, and either returns a value that's safe to use in the specified context,
+ * or throws an exception. This function is aware of trusted values created by the `trustAs`
+ * function and its shorthands, and when contexts are appropriate, returns the unwrapped value
+ * as-is. Finally, this function can also throw when there is no way to turn `maybeTrusted` in a
+ * safe value (e.g., no sanitization is available or possible.)
+ *
+ * @param {string} type The context in which this value is to be used.
+ * @param {*} maybeTrusted The result of a prior {@link ng.$sce#trustAs
+ * `$sce.trustAs`} call, or anything else (which will not be considered trusted.)
+ * @return {*} A version of the value that's safe to use in the given context, or throws an
+ * exception if this is impossible.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#getTrustedHtml
+ *
+ * @description
+ * Shorthand method. `$sce.getTrustedHtml(value)` →
+ * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.HTML, value)`}
+ *
+ * @param {*} value The value to pass to `$sce.getTrusted`.
+ * @return {*} The return value of `$sce.getTrusted($sce.HTML, value)`
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#getTrustedCss
+ *
+ * @description
+ * Shorthand method. `$sce.getTrustedCss(value)` →
+ * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.CSS, value)`}
+ *
+ * @param {*} value The value to pass to `$sce.getTrusted`.
+ * @return {*} The return value of `$sce.getTrusted($sce.CSS, value)`
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#getTrustedUrl
+ *
+ * @description
+ * Shorthand method. `$sce.getTrustedUrl(value)` →
+ * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.URL, value)`}
+ *
+ * @param {*} value The value to pass to `$sce.getTrusted`.
+ * @return {*} The return value of `$sce.getTrusted($sce.URL, value)`
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#getTrustedResourceUrl
+ *
+ * @description
+ * Shorthand method. `$sce.getTrustedResourceUrl(value)` →
+ * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.RESOURCE_URL, value)`}
+ *
+ * @param {*} value The value to pass to `$sceDelegate.getTrusted`.
+ * @return {*} The return value of `$sce.getTrusted($sce.RESOURCE_URL, value)`
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#getTrustedJs
+ *
+ * @description
+ * Shorthand method. `$sce.getTrustedJs(value)` →
+ * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.JS, value)`}
+ *
+ * @param {*} value The value to pass to `$sce.getTrusted`.
+ * @return {*} The return value of `$sce.getTrusted($sce.JS, value)`
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#parseAsHtml
+ *
+ * @description
+ * Shorthand method. `$sce.parseAsHtml(expression string)` →
+ * {@link ng.$sce#parseAs `$sce.parseAs($sce.HTML, value)`}
+ *
+ * @param {string} expression String expression to compile.
+ * @return {function(context, locals)} A function which represents the compiled expression:
+ *
+ * * `context` – `{object}` – an object against which any expressions embedded in the
+ * strings are evaluated against (typically a scope object).
+ * * `locals` – `{object=}` – local variables context object, useful for overriding values
+ * in `context`.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#parseAsCss
+ *
+ * @description
+ * Shorthand method. `$sce.parseAsCss(value)` →
+ * {@link ng.$sce#parseAs `$sce.parseAs($sce.CSS, value)`}
+ *
+ * @param {string} expression String expression to compile.
+ * @return {function(context, locals)} A function which represents the compiled expression:
+ *
+ * * `context` – `{object}` – an object against which any expressions embedded in the
+ * strings are evaluated against (typically a scope object).
+ * * `locals` – `{object=}` – local variables context object, useful for overriding values
+ * in `context`.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#parseAsUrl
+ *
+ * @description
+ * Shorthand method. `$sce.parseAsUrl(value)` →
+ * {@link ng.$sce#parseAs `$sce.parseAs($sce.URL, value)`}
+ *
+ * @param {string} expression String expression to compile.
+ * @return {function(context, locals)} A function which represents the compiled expression:
+ *
+ * * `context` – `{object}` – an object against which any expressions embedded in the
+ * strings are evaluated against (typically a scope object).
+ * * `locals` – `{object=}` – local variables context object, useful for overriding values
+ * in `context`.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#parseAsResourceUrl
+ *
+ * @description
+ * Shorthand method. `$sce.parseAsResourceUrl(value)` →
+ * {@link ng.$sce#parseAs `$sce.parseAs($sce.RESOURCE_URL, value)`}
+ *
+ * @param {string} expression String expression to compile.
+ * @return {function(context, locals)} A function which represents the compiled expression:
+ *
+ * * `context` – `{object}` – an object against which any expressions embedded in the
+ * strings are evaluated against (typically a scope object).
+ * * `locals` – `{object=}` – local variables context object, useful for overriding values
+ * in `context`.
+ */
+
+ /**
+ * @ngdoc method
+ * @name $sce#parseAsJs
+ *
+ * @description
+ * Shorthand method. `$sce.parseAsJs(value)` →
+ * {@link ng.$sce#parseAs `$sce.parseAs($sce.JS, value)`}
+ *
+ * @param {string} expression String expression to compile.
+ * @return {function(context, locals)} A function which represents the compiled expression:
+ *
+ * * `context` – `{object}` – an object against which any expressions embedded in the
+ * strings are evaluated against (typically a scope object).
+ * * `locals` – `{object=}` – local variables context object, useful for overriding values
+ * in `context`.
+ */
+
+ // Shorthand delegations.
+ var parse = sce.parseAs,
+ getTrusted = sce.getTrusted,
+ trustAs = sce.trustAs;
+
+ forEach(SCE_CONTEXTS, function(enumValue, name) {
+ var lName = lowercase(name);
+ sce[snakeToCamel('parse_as_' + lName)] = function(expr) {
+ return parse(enumValue, expr);
+ };
+ sce[snakeToCamel('get_trusted_' + lName)] = function(value) {
+ return getTrusted(enumValue, value);
+ };
+ sce[snakeToCamel('trust_as_' + lName)] = function(value) {
+ return trustAs(enumValue, value);
+ };
+ });
+
+ return sce;
+ }];
+}
+
+/* exported $SnifferProvider */
+
+/**
+ * !!! This is an undocumented "private" service !!!
+ *
+ * @name $sniffer
+ * @requires $window
+ * @requires $document
+ * @this
+ *
+ * @property {boolean} history Does the browser support html5 history api ?
+ * @property {boolean} transitions Does the browser support CSS transition events ?
+ * @property {boolean} animations Does the browser support CSS animation events ?
+ *
+ * @description
+ * This is very simple implementation of testing browser's features.
+ */
+function $SnifferProvider() {
+ this.$get = ['$window', '$document', function($window, $document) {
+ var eventSupport = {},
+ // Chrome Packaged Apps are not allowed to access `history.pushState`.
+ // If not sandboxed, they can be detected by the presence of `chrome.app.runtime`
+ // (see https://developer.chrome.com/apps/api_index). If sandboxed, they can be detected by
+ // the presence of an extension runtime ID and the absence of other Chrome runtime APIs
+ // (see https://developer.chrome.com/apps/manifest/sandbox).
+ // (NW.js apps have access to Chrome APIs, but do support `history`.)
+ isNw = $window.nw && $window.nw.process,
+ isChromePackagedApp =
+ !isNw &&
+ $window.chrome &&
+ ($window.chrome.app && $window.chrome.app.runtime ||
+ !$window.chrome.app && $window.chrome.runtime && $window.chrome.runtime.id),
+ hasHistoryPushState = !isChromePackagedApp && $window.history && $window.history.pushState,
+ android =
+ toInt((/android (\d+)/.exec(lowercase(($window.navigator || {}).userAgent)) || [])[1]),
+ boxee = /Boxee/i.test(($window.navigator || {}).userAgent),
+ document = $document[0] || {},
+ bodyStyle = document.body && document.body.style,
+ transitions = false,
+ animations = false;
+
+ if (bodyStyle) {
+ // Support: Android <5, Blackberry Browser 10, default Chrome in Android 4.4.x
+ // Mentioned browsers need a -webkit- prefix for transitions & animations.
+ transitions = !!('transition' in bodyStyle || 'webkitTransition' in bodyStyle);
+ animations = !!('animation' in bodyStyle || 'webkitAnimation' in bodyStyle);
+ }
+
+
+ return {
+ // Android has history.pushState, but it does not update location correctly
+ // so let's not use the history API at all.
+ // http://code.google.com/p/android/issues/detail?id=17471
+ // https://github.com/angular/angular.js/issues/904
+
+ // older webkit browser (533.9) on Boxee box has exactly the same problem as Android has
+ // so let's not use the history API also
+ // We are purposefully using `!(android < 4)` to cover the case when `android` is undefined
+ history: !!(hasHistoryPushState && !(android < 4) && !boxee),
+ hasEvent: function(event) {
+ // Support: IE 9-11 only
+ // IE9 implements 'input' event it's so fubared that we rather pretend that it doesn't have
+ // it. In particular the event is not fired when backspace or delete key are pressed or
+ // when cut operation is performed.
+ // IE10+ implements 'input' event but it erroneously fires under various situations,
+ // e.g. when placeholder changes, or a form is focused.
+ if (event === 'input' && msie) return false;
+
+ if (isUndefined(eventSupport[event])) {
+ var divElm = document.createElement('div');
+ eventSupport[event] = 'on' + event in divElm;
+ }
+
+ return eventSupport[event];
+ },
+ csp: csp(),
+ transitions: transitions,
+ animations: animations,
+ android: android
+ };
+ }];
+}
+
+/**
+ * ! This is a private undocumented service !
+ *
+ * @name $$taskTrackerFactory
+ * @description
+ * A function to create `TaskTracker` instances.
+ *
+ * A `TaskTracker` can keep track of pending tasks (grouped by type) and can notify interested
+ * parties when all pending tasks (or tasks of a specific type) have been completed.
+ *
+ * @param {$log} log - A logger instance (such as `$log`). Used to log error during callback
+ * execution.
+ *
+ * @this
+ */
+function $$TaskTrackerFactoryProvider() {
+ this.$get = valueFn(function(log) { return new TaskTracker(log); });
+}
+
+function TaskTracker(log) {
+ var self = this;
+ var taskCounts = {};
+ var taskCallbacks = [];
+
+ var ALL_TASKS_TYPE = self.ALL_TASKS_TYPE = '$$all$$';
+ var DEFAULT_TASK_TYPE = self.DEFAULT_TASK_TYPE = '$$default$$';
+
+ /**
+ * Execute the specified function and decrement the appropriate `taskCounts` counter.
+ * If the counter reaches 0, all corresponding `taskCallbacks` are executed.
+ *
+ * @param {Function} fn - The function to execute.
+ * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task that is being completed.
+ */
+ self.completeTask = completeTask;
+
+ /**
+ * Increase the task count for the specified task type (or the default task type if non is
+ * specified).
+ *
+ * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
+ */
+ self.incTaskCount = incTaskCount;
+
+ /**
+ * Execute the specified callback when all pending tasks have been completed.
+ *
+ * If there are no pending tasks, the callback is executed immediately. You can optionally limit
+ * the tasks that will be waited for to a specific type, by passing a `taskType`.
+ *
+ * @param {function} callback - The function to call when there are no pending tasks.
+ * @param {string=} [taskType=ALL_TASKS_TYPE] - The type of tasks that will be waited for.
+ */
+ self.notifyWhenNoPendingTasks = notifyWhenNoPendingTasks;
+
+ function completeTask(fn, taskType) {
+ taskType = taskType || DEFAULT_TASK_TYPE;
+
+ try {
+ fn();
+ } finally {
+ decTaskCount(taskType);
+
+ var countForType = taskCounts[taskType];
+ var countForAll = taskCounts[ALL_TASKS_TYPE];
+
+ // If at least one of the queues (`ALL_TASKS_TYPE` or `taskType`) is empty, run callbacks.
+ if (!countForAll || !countForType) {
+ var getNextCallback = !countForAll ? getLastCallback : getLastCallbackForType;
+ var nextCb;
+
+ while ((nextCb = getNextCallback(taskType))) {
+ try {
+ nextCb();
+ } catch (e) {
+ log.error(e);
+ }
+ }
+ }
+ }
+ }
+
+ function decTaskCount(taskType) {
+ taskType = taskType || DEFAULT_TASK_TYPE;
+ if (taskCounts[taskType]) {
+ taskCounts[taskType]--;
+ taskCounts[ALL_TASKS_TYPE]--;
+ }
+ }
+
+ function getLastCallback() {
+ var cbInfo = taskCallbacks.pop();
+ return cbInfo && cbInfo.cb;
+ }
+
+ function getLastCallbackForType(taskType) {
+ for (var i = taskCallbacks.length - 1; i >= 0; --i) {
+ var cbInfo = taskCallbacks[i];
+ if (cbInfo.type === taskType) {
+ taskCallbacks.splice(i, 1);
+ return cbInfo.cb;
+ }
+ }
+ }
+
+ function incTaskCount(taskType) {
+ taskType = taskType || DEFAULT_TASK_TYPE;
+ taskCounts[taskType] = (taskCounts[taskType] || 0) + 1;
+ taskCounts[ALL_TASKS_TYPE] = (taskCounts[ALL_TASKS_TYPE] || 0) + 1;
+ }
+
+ function notifyWhenNoPendingTasks(callback, taskType) {
+ taskType = taskType || ALL_TASKS_TYPE;
+ if (!taskCounts[taskType]) {
+ callback();
+ } else {
+ taskCallbacks.push({type: taskType, cb: callback});
+ }
+ }
+}
+
+var $templateRequestMinErr = minErr('$templateRequest');
+
+/**
+ * @ngdoc provider
+ * @name $templateRequestProvider
+ * @this
+ *
+ * @description
+ * Used to configure the options passed to the {@link $http} service when making a template request.
+ *
+ * For example, it can be used for specifying the "Accept" header that is sent to the server, when
+ * requesting a template.
+ */
+function $TemplateRequestProvider() {
+
+ var httpOptions;
+
+ /**
+ * @ngdoc method
+ * @name $templateRequestProvider#httpOptions
+ * @description
+ * The options to be passed to the {@link $http} service when making the request.
+ * You can use this to override options such as the "Accept" header for template requests.
+ *
+ * The {@link $templateRequest} will set the `cache` and the `transformResponse` properties of the
+ * options if not overridden here.
+ *
+ * @param {string=} value new value for the {@link $http} options.
+ * @returns {string|self} Returns the {@link $http} options when used as getter and self if used as setter.
+ */
+ this.httpOptions = function(val) {
+ if (val) {
+ httpOptions = val;
+ return this;
+ }
+ return httpOptions;
+ };
+
+ /**
+ * @ngdoc service
+ * @name $templateRequest
+ *
+ * @description
+ * The `$templateRequest` service runs security checks then downloads the provided template using
+ * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request
+ * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the
+ * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
+ * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
+ * when `tpl` is of type string and `$templateCache` has the matching entry.
+ *
+ * If you want to pass custom options to the `$http` service, such as setting the Accept header you
+ * can configure this via {@link $templateRequestProvider#httpOptions}.
+ *
+ * `$templateRequest` is used internally by {@link $compile}, {@link ngRoute.$route}, and directives such
+ * as {@link ngInclude} to download and cache templates.
+ *
+ * 3rd party modules should use `$templateRequest` if their services or directives are loading
+ * templates.
+ *
+ * @param {string|TrustedResourceUrl} tpl The HTTP request template URL
+ * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
+ *
+ * @return {Promise} a promise for the HTTP response data of the given URL.
+ *
+ * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
+ */
+ this.$get = ['$exceptionHandler', '$templateCache', '$http', '$q', '$sce',
+ function($exceptionHandler, $templateCache, $http, $q, $sce) {
+
+ function handleRequestFn(tpl, ignoreRequestError) {
+ handleRequestFn.totalPendingRequests++;
+
+ // We consider the template cache holds only trusted templates, so
+ // there's no need to go through adding the template again to the trusted
+ // resources for keys that already are included in there. This also makes
+ // AngularJS accept any script directive, no matter its name. However, we
+ // still need to unwrap trusted types.
+ if (!isString(tpl) || isUndefined($templateCache.get(tpl))) {
+ tpl = $sce.getTrustedResourceUrl(tpl);
+ }
+
+ var transformResponse = $http.defaults && $http.defaults.transformResponse;
+
+ if (isArray(transformResponse)) {
+ transformResponse = transformResponse.filter(function(transformer) {
+ return transformer !== defaultHttpResponseTransform;
+ });
+ } else if (transformResponse === defaultHttpResponseTransform) {
+ transformResponse = null;
+ }
+
+ return $http.get(tpl, extend({
+ cache: $templateCache,
+ transformResponse: transformResponse
+ }, httpOptions))
+ .finally(function() {
+ handleRequestFn.totalPendingRequests--;
+ })
+ .then(function(response) {
+ return $templateCache.put(tpl, response.data);
+ }, handleError);
+
+ function handleError(resp) {
+ if (!ignoreRequestError) {
+ resp = $templateRequestMinErr('tpload',
+ 'Failed to load template: {0} (HTTP status: {1} {2})',
+ tpl, resp.status, resp.statusText);
+
+ $exceptionHandler(resp);
+ }
+
+ return $q.reject(resp);
+ }
+ }
+
+ handleRequestFn.totalPendingRequests = 0;
+
+ return handleRequestFn;
+ }
+ ];
+}
+
+/** @this */
+function $$TestabilityProvider() {
+ this.$get = ['$rootScope', '$browser', '$location',
+ function($rootScope, $browser, $location) {
+
+ /**
+ * @name $testability
+ *
+ * @description
+ * The private $$testability service provides a collection of methods for use when debugging
+ * or by automated test and debugging tools.
+ */
+ var testability = {};
+
+ /**
+ * @name $$testability#findBindings
+ *
+ * @description
+ * Returns an array of elements that are bound (via ng-bind or {{}})
+ * to expressions matching the input.
+ *
+ * @param {Element} element The element root to search from.
+ * @param {string} expression The binding expression to match.
+ * @param {boolean} opt_exactMatch If true, only returns exact matches
+ * for the expression. Filters and whitespace are ignored.
+ */
+ testability.findBindings = function(element, expression, opt_exactMatch) {
+ var bindings = element.getElementsByClassName('ng-binding');
+ var matches = [];
+ forEach(bindings, function(binding) {
+ var dataBinding = angular.element(binding).data('$binding');
+ if (dataBinding) {
+ forEach(dataBinding, function(bindingName) {
+ if (opt_exactMatch) {
+ var matcher = new RegExp('(^|\\s)' + escapeForRegexp(expression) + '(\\s|\\||$)');
+ if (matcher.test(bindingName)) {
+ matches.push(binding);
+ }
+ } else {
+ if (bindingName.indexOf(expression) !== -1) {
+ matches.push(binding);
+ }
+ }
+ });
+ }
+ });
+ return matches;
+ };
+
+ /**
+ * @name $$testability#findModels
+ *
+ * @description
+ * Returns an array of elements that are two-way found via ng-model to
+ * expressions matching the input.
+ *
+ * @param {Element} element The element root to search from.
+ * @param {string} expression The model expression to match.
+ * @param {boolean} opt_exactMatch If true, only returns exact matches
+ * for the expression.
+ */
+ testability.findModels = function(element, expression, opt_exactMatch) {
+ var prefixes = ['ng-', 'data-ng-', 'ng\\:'];
+ for (var p = 0; p < prefixes.length; ++p) {
+ var attributeEquals = opt_exactMatch ? '=' : '*=';
+ var selector = '[' + prefixes[p] + 'model' + attributeEquals + '"' + expression + '"]';
+ var elements = element.querySelectorAll(selector);
+ if (elements.length) {
+ return elements;
+ }
+ }
+ };
+
+ /**
+ * @name $$testability#getLocation
+ *
+ * @description
+ * Shortcut for getting the location in a browser agnostic way. Returns
+ * the path, search, and hash. (e.g. /path?a=b#hash)
+ */
+ testability.getLocation = function() {
+ return $location.url();
+ };
+
+ /**
+ * @name $$testability#setLocation
+ *
+ * @description
+ * Shortcut for navigating to a location without doing a full page reload.
+ *
+ * @param {string} url The location url (path, search and hash,
+ * e.g. /path?a=b#hash) to go to.
+ */
+ testability.setLocation = function(url) {
+ if (url !== $location.url()) {
+ $location.url(url);
+ $rootScope.$digest();
+ }
+ };
+
+ /**
+ * @name $$testability#whenStable
+ *
+ * @description
+ * Calls the callback when all pending tasks are completed.
+ *
+ * Types of tasks waited for include:
+ * - Pending timeouts (via {@link $timeout}).
+ * - Pending HTTP requests (via {@link $http}).
+ * - In-progress route transitions (via {@link $route}).
+ * - Pending tasks scheduled via {@link $rootScope#$applyAsync}.
+ * - Pending tasks scheduled via {@link $rootScope#$evalAsync}.
+ * These include tasks scheduled via `$evalAsync()` indirectly (such as {@link $q} promises).
+ *
+ * @param {function} callback
+ */
+ testability.whenStable = function(callback) {
+ $browser.notifyWhenNoOutstandingRequests(callback);
+ };
+
+ return testability;
+ }];
+}
+
+var $timeoutMinErr = minErr('$timeout');
+
+/** @this */
+function $TimeoutProvider() {
+ this.$get = ['$rootScope', '$browser', '$q', '$$q', '$exceptionHandler',
+ function($rootScope, $browser, $q, $$q, $exceptionHandler) {
+
+ var deferreds = {};
+
+
+ /**
+ * @ngdoc service
+ * @name $timeout
+ *
+ * @description
+ * AngularJS's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
+ * block and delegates any exceptions to
+ * {@link ng.$exceptionHandler $exceptionHandler} service.
+ *
+ * The return value of calling `$timeout` is a promise, which will be resolved when
+ * the delay has passed and the timeout function, if provided, is executed.
+ *
+ * To cancel a timeout request, call `$timeout.cancel(promise)`.
+ *
+ * In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to
+ * synchronously flush the queue of deferred functions.
+ *
+ * If you only want a promise that will be resolved after some specified delay
+ * then you can call `$timeout` without the `fn` function.
+ *
+ * @param {function()=} fn A function, whose execution should be delayed.
+ * @param {number=} [delay=0] Delay in milliseconds.
+ * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
+ * will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
+ * @param {...*=} Pass additional parameters to the executed function.
+ * @returns {Promise} Promise that will be resolved when the timeout is reached. The promise
+ * will be resolved with the return value of the `fn` function.
+ *
+ */
+ function timeout(fn, delay, invokeApply) {
+ if (!isFunction(fn)) {
+ invokeApply = delay;
+ delay = fn;
+ fn = noop;
+ }
+
+ var args = sliceArgs(arguments, 3),
+ skipApply = (isDefined(invokeApply) && !invokeApply),
+ deferred = (skipApply ? $$q : $q).defer(),
+ promise = deferred.promise,
+ timeoutId;
+
+ timeoutId = $browser.defer(function() {
+ try {
+ deferred.resolve(fn.apply(null, args));
+ } catch (e) {
+ deferred.reject(e);
+ $exceptionHandler(e);
+ } finally {
+ delete deferreds[promise.$$timeoutId];
+ }
+
+ if (!skipApply) $rootScope.$apply();
+ }, delay, '$timeout');
+
+ promise.$$timeoutId = timeoutId;
+ deferreds[timeoutId] = deferred;
+
+ return promise;
+ }
+
+
+ /**
+ * @ngdoc method
+ * @name $timeout#cancel
+ *
+ * @description
+ * Cancels a task associated with the `promise`. As a result of this, the promise will be
+ * resolved with a rejection.
+ *
+ * @param {Promise=} promise Promise returned by the `$timeout` function.
+ * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
+ * canceled.
+ */
+ timeout.cancel = function(promise) {
+ if (!promise) return false;
+
+ if (!promise.hasOwnProperty('$$timeoutId')) {
+ throw $timeoutMinErr('badprom',
+ '`$timeout.cancel()` called with a promise that was not generated by `$timeout()`.');
+ }
+
+ if (!deferreds.hasOwnProperty(promise.$$timeoutId)) return false;
+
+ var id = promise.$$timeoutId;
+ var deferred = deferreds[id];
+
+ // Timeout cancels should not report an unhandled promise.
+ markQExceptionHandled(deferred.promise);
+ deferred.reject('canceled');
+ delete deferreds[id];
+
+ return $browser.defer.cancel(id);
+ };
+
+ return timeout;
+ }];
+}
+
+// NOTE: The usage of window and document instead of $window and $document here is
+// deliberate. This service depends on the specific behavior of anchor nodes created by the
+// browser (resolving and parsing URLs) that is unlikely to be provided by mock objects and
+// cause us to break tests. In addition, when the browser resolves a URL for XHR, it
+// doesn't know about mocked locations and resolves URLs to the real document - which is
+// exactly the behavior needed here. There is little value is mocking these out for this
+// service.
+var urlParsingNode = window.document.createElement('a');
+var originUrl = urlResolve(window.location.href);
+var baseUrlParsingNode;
+
+urlParsingNode.href = 'http://[::1]';
+
+// Support: IE 9-11 only, Edge 16-17 only (fixed in 18 Preview)
+// IE/Edge don't wrap IPv6 addresses' hostnames in square brackets
+// when parsed out of an anchor element.
+var ipv6InBrackets = urlParsingNode.hostname === '[::1]';
+
+/**
+ *
+ * Implementation Notes for non-IE browsers
+ * ----------------------------------------
+ * Assigning a URL to the href property of an anchor DOM node, even one attached to the DOM,
+ * results both in the normalizing and parsing of the URL. Normalizing means that a relative
+ * URL will be resolved into an absolute URL in the context of the application document.
+ * Parsing means that the anchor node's host, hostname, protocol, port, pathname and related
+ * properties are all populated to reflect the normalized URL. This approach has wide
+ * compatibility - Safari 1+, Mozilla 1+ etc. See
+ * http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
+ *
+ * Implementation Notes for IE
+ * ---------------------------
+ * IE <= 10 normalizes the URL when assigned to the anchor node similar to the other
+ * browsers. However, the parsed components will not be set if the URL assigned did not specify
+ * them. (e.g. if you assign a.href = "foo", then a.protocol, a.host, etc. will be empty.) We
+ * work around that by performing the parsing in a 2nd step by taking a previously normalized
+ * URL (e.g. by assigning to a.href) and assigning it a.href again. This correctly populates the
+ * properties such as protocol, hostname, port, etc.
+ *
+ * References:
+ * http://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement
+ * http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
+ * http://url.spec.whatwg.org/#urlutils
+ * https://github.com/angular/angular.js/pull/2902
+ * http://james.padolsey.com/javascript/parsing-urls-with-the-dom/
+ *
+ * @kind function
+ * @param {string|object} url The URL to be parsed. If `url` is not a string, it will be returned
+ * unchanged.
+ * @description Normalizes and parses a URL.
+ * @returns {object} Returns the normalized URL as a dictionary.
+ *
+ * | member name | Description |
+ * |---------------|------------------------------------------------------------------------|
+ * | href | A normalized version of the provided URL if it was not an absolute URL |
+ * | protocol | The protocol without the trailing colon |
+ * | host | The host and port (if the port is non-default) of the normalizedUrl |
+ * | search | The search params, minus the question mark |
+ * | hash | The hash string, minus the hash symbol |
+ * | hostname | The hostname |
+ * | port | The port, without ":" |
+ * | pathname | The pathname, beginning with "/" |
+ *
+ */
+function urlResolve(url) {
+ if (!isString(url)) return url;
+
+ var href = url;
+
+ // Support: IE 9-11 only
+ if (msie) {
+ // Normalize before parse. Refer Implementation Notes on why this is
+ // done in two steps on IE.
+ urlParsingNode.setAttribute('href', href);
+ href = urlParsingNode.href;
+ }
+
+ urlParsingNode.setAttribute('href', href);
+
+ var hostname = urlParsingNode.hostname;
+
+ if (!ipv6InBrackets && hostname.indexOf(':') > -1) {
+ hostname = '[' + hostname + ']';
+ }
+
+ return {
+ href: urlParsingNode.href,
+ protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
+ host: urlParsingNode.host,
+ search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
+ hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
+ hostname: hostname,
+ port: urlParsingNode.port,
+ pathname: (urlParsingNode.pathname.charAt(0) === '/')
+ ? urlParsingNode.pathname
+ : '/' + urlParsingNode.pathname
+ };
+}
+
+/**
+ * Parse a request URL and determine whether this is a same-origin request as the application
+ * document.
+ *
+ * @param {string|object} requestUrl The url of the request as a string that will be resolved
+ * or a parsed URL object.
+ * @returns {boolean} Whether the request is for the same origin as the application document.
+ */
+function urlIsSameOrigin(requestUrl) {
+ return urlsAreSameOrigin(requestUrl, originUrl);
+}
+
+/**
+ * Parse a request URL and determine whether it is same-origin as the current document base URL.
+ *
+ * Note: The base URL is usually the same as the document location (`location.href`) but can
+ * be overriden by using the `<base>` tag.
+ *
+ * @param {string|object} requestUrl The url of the request as a string that will be resolved
+ * or a parsed URL object.
+ * @returns {boolean} Whether the URL is same-origin as the document base URL.
+ */
+function urlIsSameOriginAsBaseUrl(requestUrl) {
+ return urlsAreSameOrigin(requestUrl, getBaseUrl());
+}
+
+/**
+ * Create a function that can check a URL's origin against a list of allowed/trusted origins.
+ * The current location's origin is implicitly trusted.
+ *
+ * @param {string[]} trustedOriginUrls - A list of URLs (strings), whose origins are trusted.
+ *
+ * @returns {Function} - A function that receives a URL (string or parsed URL object) and returns
+ * whether it is of an allowed origin.
+ */
+function urlIsAllowedOriginFactory(trustedOriginUrls) {
+ var parsedAllowedOriginUrls = [originUrl].concat(trustedOriginUrls.map(urlResolve));
+
+ /**
+ * Check whether the specified URL (string or parsed URL object) has an origin that is allowed
+ * based on a list of trusted-origin URLs. The current location's origin is implicitly
+ * trusted.
+ *
+ * @param {string|Object} requestUrl - The URL to be checked (provided as a string that will be
+ * resolved or a parsed URL object).
+ *
+ * @returns {boolean} - Whether the specified URL is of an allowed origin.
+ */
+ return function urlIsAllowedOrigin(requestUrl) {
+ var parsedUrl = urlResolve(requestUrl);
+ return parsedAllowedOriginUrls.some(urlsAreSameOrigin.bind(null, parsedUrl));
+ };
+}
+
+/**
+ * Determine if two URLs share the same origin.
+ *
+ * @param {string|Object} url1 - First URL to compare as a string or a normalized URL in the form of
+ * a dictionary object returned by `urlResolve()`.
+ * @param {string|object} url2 - Second URL to compare as a string or a normalized URL in the form
+ * of a dictionary object returned by `urlResolve()`.
+ *
+ * @returns {boolean} - True if both URLs have the same origin, and false otherwise.
+ */
+function urlsAreSameOrigin(url1, url2) {
+ url1 = urlResolve(url1);
+ url2 = urlResolve(url2);
+
+ return (url1.protocol === url2.protocol &&
+ url1.host === url2.host);
+}
+
+/**
+ * Returns the current document base URL.
+ * @returns {string}
+ */
+function getBaseUrl() {
+ if (window.document.baseURI) {
+ return window.document.baseURI;
+ }
+
+ // `document.baseURI` is available everywhere except IE
+ if (!baseUrlParsingNode) {
+ baseUrlParsingNode = window.document.createElement('a');
+ baseUrlParsingNode.href = '.';
+
+ // Work-around for IE bug described in Implementation Notes. The fix in `urlResolve()` is not
+ // suitable here because we need to track changes to the base URL.
+ baseUrlParsingNode = baseUrlParsingNode.cloneNode(false);
+ }
+ return baseUrlParsingNode.href;
+}
+
+/**
+ * @ngdoc service
+ * @name $window
+ * @this
+ *
+ * @description
+ * A reference to the browser's `window` object. While `window`
+ * is globally available in JavaScript, it causes testability problems, because
+ * it is a global variable. In AngularJS we always refer to it through the
+ * `$window` service, so it may be overridden, removed or mocked for testing.
+ *
+ * Expressions, like the one defined for the `ngClick` directive in the example
+ * below, are evaluated with respect to the current scope. Therefore, there is
+ * no risk of inadvertently coding in a dependency on a global value in such an
+ * expression.
+ *
+ * @example
+ <example module="windowExample" name="window-service">
+ <file name="index.html">
+ <script>
+ angular.module('windowExample', [])
+ .controller('ExampleController', ['$scope', '$window', function($scope, $window) {
+ $scope.greeting = 'Hello, World!';
+ $scope.doGreeting = function(greeting) {
+ $window.alert(greeting);
+ };
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <input type="text" ng-model="greeting" aria-label="greeting" />
+ <button ng-click="doGreeting(greeting)">ALERT</button>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should display the greeting in the input box', function() {
+ element(by.model('greeting')).sendKeys('Hello, E2E Tests');
+ // If we click the button it will block the test runner
+ // element(':button').click();
+ });
+ </file>
+ </example>
+ */
+function $WindowProvider() {
+ this.$get = valueFn(window);
+}
+
+/**
+ * @name $$cookieReader
+ * @requires $document
+ *
+ * @description
+ * This is a private service for reading cookies used by $http and ngCookies
+ *
+ * @return {Object} a key/value map of the current cookies
+ */
+function $$CookieReader($document) {
+ var rawDocument = $document[0] || {};
+ var lastCookies = {};
+ var lastCookieString = '';
+
+ function safeGetCookie(rawDocument) {
+ try {
+ return rawDocument.cookie || '';
+ } catch (e) {
+ return '';
+ }
+ }
+
+ function safeDecodeURIComponent(str) {
+ try {
+ return decodeURIComponent(str);
+ } catch (e) {
+ return str;
+ }
+ }
+
+ return function() {
+ var cookieArray, cookie, i, index, name;
+ var currentCookieString = safeGetCookie(rawDocument);
+
+ if (currentCookieString !== lastCookieString) {
+ lastCookieString = currentCookieString;
+ cookieArray = lastCookieString.split('; ');
+ lastCookies = {};
+
+ for (i = 0; i < cookieArray.length; i++) {
+ cookie = cookieArray[i];
+ index = cookie.indexOf('=');
+ if (index > 0) { //ignore nameless cookies
+ name = safeDecodeURIComponent(cookie.substring(0, index));
+ // the first value that is seen for a cookie is the most
+ // specific one. values for the same cookie name that
+ // follow are for less specific paths.
+ if (isUndefined(lastCookies[name])) {
+ lastCookies[name] = safeDecodeURIComponent(cookie.substring(index + 1));
+ }
+ }
+ }
+ }
+ return lastCookies;
+ };
+}
+
+$$CookieReader.$inject = ['$document'];
+
+/** @this */
+function $$CookieReaderProvider() {
+ this.$get = $$CookieReader;
+}
+
+/* global currencyFilter: true,
+ dateFilter: true,
+ filterFilter: true,
+ jsonFilter: true,
+ limitToFilter: true,
+ lowercaseFilter: true,
+ numberFilter: true,
+ orderByFilter: true,
+ uppercaseFilter: true,
+ */
+
+/**
+ * @ngdoc provider
+ * @name $filterProvider
+ * @description
+ *
+ * Filters are just functions which transform input to an output. However filters need to be
+ * Dependency Injected. To achieve this a filter definition consists of a factory function which is
+ * annotated with dependencies and is responsible for creating a filter function.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
+ * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
+ * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
+ * (`myapp_subsection_filterx`).
+ * </div>
+ *
+ * ```js
+ * // Filter registration
+ * function MyModule($provide, $filterProvider) {
+ * // create a service to demonstrate injection (not always needed)
+ * $provide.value('greet', function(name){
+ * return 'Hello ' + name + '!';
+ * });
+ *
+ * // register a filter factory which uses the
+ * // greet service to demonstrate DI.
+ * $filterProvider.register('greet', function(greet){
+ * // return the filter function which uses the greet service
+ * // to generate salutation
+ * return function(text) {
+ * // filters need to be forgiving so check input validity
+ * return text && greet(text) || text;
+ * };
+ * });
+ * }
+ * ```
+ *
+ * The filter function is registered with the `$injector` under the filter name suffix with
+ * `Filter`.
+ *
+ * ```js
+ * it('should be the same instance', inject(
+ * function($filterProvider) {
+ * $filterProvider.register('reverse', function(){
+ * return ...;
+ * });
+ * },
+ * function($filter, reverseFilter) {
+ * expect($filter('reverse')).toBe(reverseFilter);
+ * });
+ * ```
+ *
+ *
+ * For more information about how AngularJS filters work, and how to create your own filters, see
+ * {@link guide/filter Filters} in the AngularJS Developer Guide.
+ */
+
+/**
+ * @ngdoc service
+ * @name $filter
+ * @kind function
+ * @description
+ * Filters are used for formatting data displayed to the user.
+ *
+ * They can be used in view templates, controllers or services. AngularJS comes
+ * with a collection of [built-in filters](api/ng/filter), but it is easy to
+ * define your own as well.
+ *
+ * The general syntax in templates is as follows:
+ *
+ * ```html
+ * {{ expression [| filter_name[:parameter_value] ... ] }}
+ * ```
+ *
+ * @param {String} name Name of the filter function to retrieve
+ * @return {Function} the filter function
+ * @example
+ <example name="$filter" module="filterExample">
+ <file name="index.html">
+ <div ng-controller="MainCtrl">
+ <h3>{{ originalText }}</h3>
+ <h3>{{ filteredText }}</h3>
+ </div>
+ </file>
+
+ <file name="script.js">
+ angular.module('filterExample', [])
+ .controller('MainCtrl', function($scope, $filter) {
+ $scope.originalText = 'hello';
+ $scope.filteredText = $filter('uppercase')($scope.originalText);
+ });
+ </file>
+ </example>
+ */
+$FilterProvider.$inject = ['$provide'];
+/** @this */
+function $FilterProvider($provide) {
+ var suffix = 'Filter';
+
+ /**
+ * @ngdoc method
+ * @name $filterProvider#register
+ * @param {string|Object} name Name of the filter function, or an object map of filters where
+ * the keys are the filter names and the values are the filter factories.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
+ * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
+ * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
+ * (`myapp_subsection_filterx`).
+ * </div>
+ * @param {Function} factory If the first argument was a string, a factory function for the filter to be registered.
+ * @returns {Object} Registered filter instance, or if a map of filters was provided then a map
+ * of the registered filter instances.
+ */
+ function register(name, factory) {
+ if (isObject(name)) {
+ var filters = {};
+ forEach(name, function(filter, key) {
+ filters[key] = register(key, filter);
+ });
+ return filters;
+ } else {
+ return $provide.factory(name + suffix, factory);
+ }
+ }
+ this.register = register;
+
+ this.$get = ['$injector', function($injector) {
+ return function(name) {
+ return $injector.get(name + suffix);
+ };
+ }];
+
+ ////////////////////////////////////////
+
+ /* global
+ currencyFilter: false,
+ dateFilter: false,
+ filterFilter: false,
+ jsonFilter: false,
+ limitToFilter: false,
+ lowercaseFilter: false,
+ numberFilter: false,
+ orderByFilter: false,
+ uppercaseFilter: false
+ */
+
+ register('currency', currencyFilter);
+ register('date', dateFilter);
+ register('filter', filterFilter);
+ register('json', jsonFilter);
+ register('limitTo', limitToFilter);
+ register('lowercase', lowercaseFilter);
+ register('number', numberFilter);
+ register('orderBy', orderByFilter);
+ register('uppercase', uppercaseFilter);
+}
+
+/**
+ * @ngdoc filter
+ * @name filter
+ * @kind function
+ *
+ * @description
+ * Selects a subset of items from `array` and returns it as a new array.
+ *
+ * @param {Array} array The source array.
+ * <div class="alert alert-info">
+ * **Note**: If the array contains objects that reference themselves, filtering is not possible.
+ * </div>
+ * @param {string|Object|function()} expression The predicate to be used for selecting items from
+ * `array`.
+ *
+ * Can be one of:
+ *
+ * - `string`: The string is used for matching against the contents of the `array`. All strings or
+ * objects with string properties in `array` that match this string will be returned. This also
+ * applies to nested object properties.
+ * The predicate can be negated by prefixing the string with `!`.
+ *
+ * - `Object`: A pattern object can be used to filter specific properties on objects contained
+ * by `array`. For example `{name:"M", phone:"1"}` predicate will return an array of items
+ * which have property `name` containing "M" and property `phone` containing "1". A special
+ * property name (`$` by default) can be used (e.g. as in `{$: "text"}`) to accept a match
+ * against any property of the object or its nested object properties. That's equivalent to the
+ * simple substring match with a `string` as described above. The special property name can be
+ * overwritten, using the `anyPropertyKey` parameter.
+ * The predicate can be negated by prefixing the string with `!`.
+ * For example `{name: "!M"}` predicate will return an array of items which have property `name`
+ * not containing "M".
+ *
+ * Note that a named property will match properties on the same level only, while the special
+ * `$` property will match properties on the same level or deeper. E.g. an array item like
+ * `{name: {first: 'John', last: 'Doe'}}` will **not** be matched by `{name: 'John'}`, but
+ * **will** be matched by `{$: 'John'}`.
+ *
+ * - `function(value, index, array)`: A predicate function can be used to write arbitrary filters.
+ * The function is called for each element of the array, with the element, its index, and
+ * the entire array itself as arguments.
+ *
+ * The final result is an array of those elements that the predicate returned true for.
+ *
+ * @param {function(actual, expected)|true|false} [comparator] Comparator which is used in
+ * determining if values retrieved using `expression` (when it is not a function) should be
+ * considered a match based on the expected value (from the filter expression) and actual
+ * value (from the object in the array).
+ *
+ * Can be one of:
+ *
+ * - `function(actual, expected)`:
+ * The function will be given the object value and the predicate value to compare and
+ * should return true if both values should be considered equal.
+ *
+ * - `true`: A shorthand for `function(actual, expected) { return angular.equals(actual, expected)}`.
+ * This is essentially strict comparison of expected and actual.
+ *
+ * - `false`: A short hand for a function which will look for a substring match in a case
+ * insensitive way. Primitive values are converted to strings. Objects are not compared against
+ * primitives, unless they have a custom `toString` method (e.g. `Date` objects).
+ *
+ *
+ * Defaults to `false`.
+ *
+ * @param {string} [anyPropertyKey] The special property name that matches against any property.
+ * By default `$`.
+ *
+ * @example
+ <example name="filter-filter">
+ <file name="index.html">
+ <div ng-init="friends = [{name:'John', phone:'555-1276'},
+ {name:'Mary', phone:'800-BIG-MARY'},
+ {name:'Mike', phone:'555-4321'},
+ {name:'Adam', phone:'555-5678'},
+ {name:'Julie', phone:'555-8765'},
+ {name:'Juliette', phone:'555-5678'}]"></div>
+
+ <label>Search: <input ng-model="searchText"></label>
+ <table id="searchTextResults">
+ <tr><th>Name</th><th>Phone</th></tr>
+ <tr ng-repeat="friend in friends | filter:searchText">
+ <td>{{friend.name}}</td>
+ <td>{{friend.phone}}</td>
+ </tr>
+ </table>
+ <hr>
+ <label>Any: <input ng-model="search.$"></label> <br>
+ <label>Name only <input ng-model="search.name"></label><br>
+ <label>Phone only <input ng-model="search.phone"></label><br>
+ <label>Equality <input type="checkbox" ng-model="strict"></label><br>
+ <table id="searchObjResults">
+ <tr><th>Name</th><th>Phone</th></tr>
+ <tr ng-repeat="friendObj in friends | filter:search:strict">
+ <td>{{friendObj.name}}</td>
+ <td>{{friendObj.phone}}</td>
+ </tr>
+ </table>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var expectFriendNames = function(expectedNames, key) {
+ element.all(by.repeater(key + ' in friends').column(key + '.name')).then(function(arr) {
+ arr.forEach(function(wd, i) {
+ expect(wd.getText()).toMatch(expectedNames[i]);
+ });
+ });
+ };
+
+ it('should search across all fields when filtering with a string', function() {
+ var searchText = element(by.model('searchText'));
+ searchText.clear();
+ searchText.sendKeys('m');
+ expectFriendNames(['Mary', 'Mike', 'Adam'], 'friend');
+
+ searchText.clear();
+ searchText.sendKeys('76');
+ expectFriendNames(['John', 'Julie'], 'friend');
+ });
+
+ it('should search in specific fields when filtering with a predicate object', function() {
+ var searchAny = element(by.model('search.$'));
+ searchAny.clear();
+ searchAny.sendKeys('i');
+ expectFriendNames(['Mary', 'Mike', 'Julie', 'Juliette'], 'friendObj');
+ });
+ it('should use a equal comparison when comparator is true', function() {
+ var searchName = element(by.model('search.name'));
+ var strict = element(by.model('strict'));
+ searchName.clear();
+ searchName.sendKeys('Julie');
+ strict.click();
+ expectFriendNames(['Julie'], 'friendObj');
+ });
+ </file>
+ </example>
+ */
+
+function filterFilter() {
+ return function(array, expression, comparator, anyPropertyKey) {
+ if (!isArrayLike(array)) {
+ if (array == null) {
+ return array;
+ } else {
+ throw minErr('filter')('notarray', 'Expected array but received: {0}', array);
+ }
+ }
+
+ anyPropertyKey = anyPropertyKey || '$';
+ var expressionType = getTypeForFilter(expression);
+ var predicateFn;
+ var matchAgainstAnyProp;
+
+ switch (expressionType) {
+ case 'function':
+ predicateFn = expression;
+ break;
+ case 'boolean':
+ case 'null':
+ case 'number':
+ case 'string':
+ matchAgainstAnyProp = true;
+ // falls through
+ case 'object':
+ predicateFn = createPredicateFn(expression, comparator, anyPropertyKey, matchAgainstAnyProp);
+ break;
+ default:
+ return array;
+ }
+
+ return Array.prototype.filter.call(array, predicateFn);
+ };
+}
+
+// Helper functions for `filterFilter`
+function createPredicateFn(expression, comparator, anyPropertyKey, matchAgainstAnyProp) {
+ var shouldMatchPrimitives = isObject(expression) && (anyPropertyKey in expression);
+ var predicateFn;
+
+ if (comparator === true) {
+ comparator = equals;
+ } else if (!isFunction(comparator)) {
+ comparator = function(actual, expected) {
+ if (isUndefined(actual)) {
+ // No substring matching against `undefined`
+ return false;
+ }
+ if ((actual === null) || (expected === null)) {
+ // No substring matching against `null`; only match against `null`
+ return actual === expected;
+ }
+ if (isObject(expected) || (isObject(actual) && !hasCustomToString(actual))) {
+ // Should not compare primitives against objects, unless they have custom `toString` method
+ return false;
+ }
+
+ actual = lowercase('' + actual);
+ expected = lowercase('' + expected);
+ return actual.indexOf(expected) !== -1;
+ };
+ }
+
+ predicateFn = function(item) {
+ if (shouldMatchPrimitives && !isObject(item)) {
+ return deepCompare(item, expression[anyPropertyKey], comparator, anyPropertyKey, false);
+ }
+ return deepCompare(item, expression, comparator, anyPropertyKey, matchAgainstAnyProp);
+ };
+
+ return predicateFn;
+}
+
+function deepCompare(actual, expected, comparator, anyPropertyKey, matchAgainstAnyProp, dontMatchWholeObject) {
+ var actualType = getTypeForFilter(actual);
+ var expectedType = getTypeForFilter(expected);
+
+ if ((expectedType === 'string') && (expected.charAt(0) === '!')) {
+ return !deepCompare(actual, expected.substring(1), comparator, anyPropertyKey, matchAgainstAnyProp);
+ } else if (isArray(actual)) {
+ // In case `actual` is an array, consider it a match
+ // if ANY of it's items matches `expected`
+ return actual.some(function(item) {
+ return deepCompare(item, expected, comparator, anyPropertyKey, matchAgainstAnyProp);
+ });
+ }
+
+ switch (actualType) {
+ case 'object':
+ var key;
+ if (matchAgainstAnyProp) {
+ for (key in actual) {
+ // Under certain, rare, circumstances, key may not be a string and `charAt` will be undefined
+ // See: https://github.com/angular/angular.js/issues/15644
+ if (key.charAt && (key.charAt(0) !== '$') &&
+ deepCompare(actual[key], expected, comparator, anyPropertyKey, true)) {
+ return true;
+ }
+ }
+ return dontMatchWholeObject ? false : deepCompare(actual, expected, comparator, anyPropertyKey, false);
+ } else if (expectedType === 'object') {
+ for (key in expected) {
+ var expectedVal = expected[key];
+ if (isFunction(expectedVal) || isUndefined(expectedVal)) {
+ continue;
+ }
+
+ var matchAnyProperty = key === anyPropertyKey;
+ var actualVal = matchAnyProperty ? actual : actual[key];
+ if (!deepCompare(actualVal, expectedVal, comparator, anyPropertyKey, matchAnyProperty, matchAnyProperty)) {
+ return false;
+ }
+ }
+ return true;
+ } else {
+ return comparator(actual, expected);
+ }
+ case 'function':
+ return false;
+ default:
+ return comparator(actual, expected);
+ }
+}
+
+// Used for easily differentiating between `null` and actual `object`
+function getTypeForFilter(val) {
+ return (val === null) ? 'null' : typeof val;
+}
+
+var MAX_DIGITS = 22;
+var DECIMAL_SEP = '.';
+var ZERO_CHAR = '0';
+
+/**
+ * @ngdoc filter
+ * @name currency
+ * @kind function
+ *
+ * @description
+ * Formats a number as a currency (ie $1,234.56). When no currency symbol is provided, default
+ * symbol for current locale is used.
+ *
+ * @param {number} amount Input to filter.
+ * @param {string=} symbol Currency symbol or identifier to be displayed.
+ * @param {number=} fractionSize Number of decimal places to round the amount to, defaults to default max fraction size for current locale
+ * @returns {string} Formatted number.
+ *
+ *
+ * @example
+ <example module="currencyExample" name="currency-filter">
+ <file name="index.html">
+ <script>
+ angular.module('currencyExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.amount = 1234.56;
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <input type="number" ng-model="amount" aria-label="amount"> <br>
+ default currency symbol ($): <span id="currency-default">{{amount | currency}}</span><br>
+ custom currency identifier (USD$): <span id="currency-custom">{{amount | currency:"USD$"}}</span><br>
+ no fractions (0): <span id="currency-no-fractions">{{amount | currency:"USD$":0}}</span>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should init with 1234.56', function() {
+ expect(element(by.id('currency-default')).getText()).toBe('$1,234.56');
+ expect(element(by.id('currency-custom')).getText()).toBe('USD$1,234.56');
+ expect(element(by.id('currency-no-fractions')).getText()).toBe('USD$1,235');
+ });
+ it('should update', function() {
+ if (browser.params.browser === 'safari') {
+ // Safari does not understand the minus key. See
+ // https://github.com/angular/protractor/issues/481
+ return;
+ }
+ element(by.model('amount')).clear();
+ element(by.model('amount')).sendKeys('-1234');
+ expect(element(by.id('currency-default')).getText()).toBe('-$1,234.00');
+ expect(element(by.id('currency-custom')).getText()).toBe('-USD$1,234.00');
+ expect(element(by.id('currency-no-fractions')).getText()).toBe('-USD$1,234');
+ });
+ </file>
+ </example>
+ */
+currencyFilter.$inject = ['$locale'];
+function currencyFilter($locale) {
+ var formats = $locale.NUMBER_FORMATS;
+ return function(amount, currencySymbol, fractionSize) {
+ if (isUndefined(currencySymbol)) {
+ currencySymbol = formats.CURRENCY_SYM;
+ }
+
+ if (isUndefined(fractionSize)) {
+ fractionSize = formats.PATTERNS[1].maxFrac;
+ }
+
+ // If the currency symbol is empty, trim whitespace around the symbol
+ var currencySymbolRe = !currencySymbol ? /\s*\u00A4\s*/g : /\u00A4/g;
+
+ // if null or undefined pass it through
+ return (amount == null)
+ ? amount
+ : formatNumber(amount, formats.PATTERNS[1], formats.GROUP_SEP, formats.DECIMAL_SEP, fractionSize).
+ replace(currencySymbolRe, currencySymbol);
+ };
+}
+
+/**
+ * @ngdoc filter
+ * @name number
+ * @kind function
+ *
+ * @description
+ * Formats a number as text.
+ *
+ * If the input is null or undefined, it will just be returned.
+ * If the input is infinite (Infinity or -Infinity), the Infinity symbol '∞' or '-∞' is returned, respectively.
+ * If the input is not a number an empty string is returned.
+ *
+ *
+ * @param {number|string} number Number to format.
+ * @param {(number|string)=} fractionSize Number of decimal places to round the number to.
+ * If this is not provided then the fraction size is computed from the current locale's number
+ * formatting pattern. In the case of the default locale, it will be 3.
+ * @returns {string} Number rounded to `fractionSize` appropriately formatted based on the current
+ * locale (e.g., in the en_US locale it will have "." as the decimal separator and
+ * include "," group separators after each third digit).
+ *
+ * @example
+ <example module="numberFilterExample" name="number-filter">
+ <file name="index.html">
+ <script>
+ angular.module('numberFilterExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.val = 1234.56789;
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <label>Enter number: <input ng-model='val'></label><br>
+ Default formatting: <span id='number-default'>{{val | number}}</span><br>
+ No fractions: <span>{{val | number:0}}</span><br>
+ Negative number: <span>{{-val | number:4}}</span>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should format numbers', function() {
+ expect(element(by.id('number-default')).getText()).toBe('1,234.568');
+ expect(element(by.binding('val | number:0')).getText()).toBe('1,235');
+ expect(element(by.binding('-val | number:4')).getText()).toBe('-1,234.5679');
+ });
+
+ it('should update', function() {
+ element(by.model('val')).clear();
+ element(by.model('val')).sendKeys('3374.333');
+ expect(element(by.id('number-default')).getText()).toBe('3,374.333');
+ expect(element(by.binding('val | number:0')).getText()).toBe('3,374');
+ expect(element(by.binding('-val | number:4')).getText()).toBe('-3,374.3330');
+ });
+ </file>
+ </example>
+ */
+numberFilter.$inject = ['$locale'];
+function numberFilter($locale) {
+ var formats = $locale.NUMBER_FORMATS;
+ return function(number, fractionSize) {
+
+ // if null or undefined pass it through
+ return (number == null)
+ ? number
+ : formatNumber(number, formats.PATTERNS[0], formats.GROUP_SEP, formats.DECIMAL_SEP,
+ fractionSize);
+ };
+}
+
+/**
+ * Parse a number (as a string) into three components that can be used
+ * for formatting the number.
+ *
+ * (Significant bits of this parse algorithm came from https://github.com/MikeMcl/big.js/)
+ *
+ * @param {string} numStr The number to parse
+ * @return {object} An object describing this number, containing the following keys:
+ * - d : an array of digits containing leading zeros as necessary
+ * - i : the number of the digits in `d` that are to the left of the decimal point
+ * - e : the exponent for numbers that would need more than `MAX_DIGITS` digits in `d`
+ *
+ */
+function parse(numStr) {
+ var exponent = 0, digits, numberOfIntegerDigits;
+ var i, j, zeros;
+
+ // Decimal point?
+ if ((numberOfIntegerDigits = numStr.indexOf(DECIMAL_SEP)) > -1) {
+ numStr = numStr.replace(DECIMAL_SEP, '');
+ }
+
+ // Exponential form?
+ if ((i = numStr.search(/e/i)) > 0) {
+ // Work out the exponent.
+ if (numberOfIntegerDigits < 0) numberOfIntegerDigits = i;
+ numberOfIntegerDigits += +numStr.slice(i + 1);
+ numStr = numStr.substring(0, i);
+ } else if (numberOfIntegerDigits < 0) {
+ // There was no decimal point or exponent so it is an integer.
+ numberOfIntegerDigits = numStr.length;
+ }
+
+ // Count the number of leading zeros.
+ for (i = 0; numStr.charAt(i) === ZERO_CHAR; i++) { /* empty */ }
+
+ if (i === (zeros = numStr.length)) {
+ // The digits are all zero.
+ digits = [0];
+ numberOfIntegerDigits = 1;
+ } else {
+ // Count the number of trailing zeros
+ zeros--;
+ while (numStr.charAt(zeros) === ZERO_CHAR) zeros--;
+
+ // Trailing zeros are insignificant so ignore them
+ numberOfIntegerDigits -= i;
+ digits = [];
+ // Convert string to array of digits without leading/trailing zeros.
+ for (j = 0; i <= zeros; i++, j++) {
+ digits[j] = +numStr.charAt(i);
+ }
+ }
+
+ // If the number overflows the maximum allowed digits then use an exponent.
+ if (numberOfIntegerDigits > MAX_DIGITS) {
+ digits = digits.splice(0, MAX_DIGITS - 1);
+ exponent = numberOfIntegerDigits - 1;
+ numberOfIntegerDigits = 1;
+ }
+
+ return { d: digits, e: exponent, i: numberOfIntegerDigits };
+}
+
+/**
+ * Round the parsed number to the specified number of decimal places
+ * This function changed the parsedNumber in-place
+ */
+function roundNumber(parsedNumber, fractionSize, minFrac, maxFrac) {
+ var digits = parsedNumber.d;
+ var fractionLen = digits.length - parsedNumber.i;
+
+ // determine fractionSize if it is not specified; `+fractionSize` converts it to a number
+ fractionSize = (isUndefined(fractionSize)) ? Math.min(Math.max(minFrac, fractionLen), maxFrac) : +fractionSize;
+
+ // The index of the digit to where rounding is to occur
+ var roundAt = fractionSize + parsedNumber.i;
+ var digit = digits[roundAt];
+
+ if (roundAt > 0) {
+ // Drop fractional digits beyond `roundAt`
+ digits.splice(Math.max(parsedNumber.i, roundAt));
+
+ // Set non-fractional digits beyond `roundAt` to 0
+ for (var j = roundAt; j < digits.length; j++) {
+ digits[j] = 0;
+ }
+ } else {
+ // We rounded to zero so reset the parsedNumber
+ fractionLen = Math.max(0, fractionLen);
+ parsedNumber.i = 1;
+ digits.length = Math.max(1, roundAt = fractionSize + 1);
+ digits[0] = 0;
+ for (var i = 1; i < roundAt; i++) digits[i] = 0;
+ }
+
+ if (digit >= 5) {
+ if (roundAt - 1 < 0) {
+ for (var k = 0; k > roundAt; k--) {
+ digits.unshift(0);
+ parsedNumber.i++;
+ }
+ digits.unshift(1);
+ parsedNumber.i++;
+ } else {
+ digits[roundAt - 1]++;
+ }
+ }
+
+ // Pad out with zeros to get the required fraction length
+ for (; fractionLen < Math.max(0, fractionSize); fractionLen++) digits.push(0);
+
+
+ // Do any carrying, e.g. a digit was rounded up to 10
+ var carry = digits.reduceRight(function(carry, d, i, digits) {
+ d = d + carry;
+ digits[i] = d % 10;
+ return Math.floor(d / 10);
+ }, 0);
+ if (carry) {
+ digits.unshift(carry);
+ parsedNumber.i++;
+ }
+}
+
+/**
+ * Format a number into a string
+ * @param {number} number The number to format
+ * @param {{
+ * minFrac, // the minimum number of digits required in the fraction part of the number
+ * maxFrac, // the maximum number of digits required in the fraction part of the number
+ * gSize, // number of digits in each group of separated digits
+ * lgSize, // number of digits in the last group of digits before the decimal separator
+ * negPre, // the string to go in front of a negative number (e.g. `-` or `(`))
+ * posPre, // the string to go in front of a positive number
+ * negSuf, // the string to go after a negative number (e.g. `)`)
+ * posSuf // the string to go after a positive number
+ * }} pattern
+ * @param {string} groupSep The string to separate groups of number (e.g. `,`)
+ * @param {string} decimalSep The string to act as the decimal separator (e.g. `.`)
+ * @param {[type]} fractionSize The size of the fractional part of the number
+ * @return {string} The number formatted as a string
+ */
+function formatNumber(number, pattern, groupSep, decimalSep, fractionSize) {
+
+ if (!(isString(number) || isNumber(number)) || isNaN(number)) return '';
+
+ var isInfinity = !isFinite(number);
+ var isZero = false;
+ var numStr = Math.abs(number) + '',
+ formattedText = '',
+ parsedNumber;
+
+ if (isInfinity) {
+ formattedText = '\u221e';
+ } else {
+ parsedNumber = parse(numStr);
+
+ roundNumber(parsedNumber, fractionSize, pattern.minFrac, pattern.maxFrac);
+
+ var digits = parsedNumber.d;
+ var integerLen = parsedNumber.i;
+ var exponent = parsedNumber.e;
+ var decimals = [];
+ isZero = digits.reduce(function(isZero, d) { return isZero && !d; }, true);
+
+ // pad zeros for small numbers
+ while (integerLen < 0) {
+ digits.unshift(0);
+ integerLen++;
+ }
+
+ // extract decimals digits
+ if (integerLen > 0) {
+ decimals = digits.splice(integerLen, digits.length);
+ } else {
+ decimals = digits;
+ digits = [0];
+ }
+
+ // format the integer digits with grouping separators
+ var groups = [];
+ if (digits.length >= pattern.lgSize) {
+ groups.unshift(digits.splice(-pattern.lgSize, digits.length).join(''));
+ }
+ while (digits.length > pattern.gSize) {
+ groups.unshift(digits.splice(-pattern.gSize, digits.length).join(''));
+ }
+ if (digits.length) {
+ groups.unshift(digits.join(''));
+ }
+ formattedText = groups.join(groupSep);
+
+ // append the decimal digits
+ if (decimals.length) {
+ formattedText += decimalSep + decimals.join('');
+ }
+
+ if (exponent) {
+ formattedText += 'e+' + exponent;
+ }
+ }
+ if (number < 0 && !isZero) {
+ return pattern.negPre + formattedText + pattern.negSuf;
+ } else {
+ return pattern.posPre + formattedText + pattern.posSuf;
+ }
+}
+
+function padNumber(num, digits, trim, negWrap) {
+ var neg = '';
+ if (num < 0 || (negWrap && num <= 0)) {
+ if (negWrap) {
+ num = -num + 1;
+ } else {
+ num = -num;
+ neg = '-';
+ }
+ }
+ num = '' + num;
+ while (num.length < digits) num = ZERO_CHAR + num;
+ if (trim) {
+ num = num.substr(num.length - digits);
+ }
+ return neg + num;
+}
+
+
+function dateGetter(name, size, offset, trim, negWrap) {
+ offset = offset || 0;
+ return function(date) {
+ var value = date['get' + name]();
+ if (offset > 0 || value > -offset) {
+ value += offset;
+ }
+ if (value === 0 && offset === -12) value = 12;
+ return padNumber(value, size, trim, negWrap);
+ };
+}
+
+function dateStrGetter(name, shortForm, standAlone) {
+ return function(date, formats) {
+ var value = date['get' + name]();
+ var propPrefix = (standAlone ? 'STANDALONE' : '') + (shortForm ? 'SHORT' : '');
+ var get = uppercase(propPrefix + name);
+
+ return formats[get][value];
+ };
+}
+
+function timeZoneGetter(date, formats, offset) {
+ var zone = -1 * offset;
+ var paddedZone = (zone >= 0) ? '+' : '';
+
+ paddedZone += padNumber(Math[zone > 0 ? 'floor' : 'ceil'](zone / 60), 2) +
+ padNumber(Math.abs(zone % 60), 2);
+
+ return paddedZone;
+}
+
+function getFirstThursdayOfYear(year) {
+ // 0 = index of January
+ var dayOfWeekOnFirst = (new Date(year, 0, 1)).getDay();
+ // 4 = index of Thursday (+1 to account for 1st = 5)
+ // 11 = index of *next* Thursday (+1 account for 1st = 12)
+ return new Date(year, 0, ((dayOfWeekOnFirst <= 4) ? 5 : 12) - dayOfWeekOnFirst);
+}
+
+function getThursdayThisWeek(datetime) {
+ return new Date(datetime.getFullYear(), datetime.getMonth(),
+ // 4 = index of Thursday
+ datetime.getDate() + (4 - datetime.getDay()));
+}
+
+function weekGetter(size) {
+ return function(date) {
+ var firstThurs = getFirstThursdayOfYear(date.getFullYear()),
+ thisThurs = getThursdayThisWeek(date);
+
+ var diff = +thisThurs - +firstThurs,
+ result = 1 + Math.round(diff / 6.048e8); // 6.048e8 ms per week
+
+ return padNumber(result, size);
+ };
+}
+
+function ampmGetter(date, formats) {
+ return date.getHours() < 12 ? formats.AMPMS[0] : formats.AMPMS[1];
+}
+
+function eraGetter(date, formats) {
+ return date.getFullYear() <= 0 ? formats.ERAS[0] : formats.ERAS[1];
+}
+
+function longEraGetter(date, formats) {
+ return date.getFullYear() <= 0 ? formats.ERANAMES[0] : formats.ERANAMES[1];
+}
+
+var DATE_FORMATS = {
+ yyyy: dateGetter('FullYear', 4, 0, false, true),
+ yy: dateGetter('FullYear', 2, 0, true, true),
+ y: dateGetter('FullYear', 1, 0, false, true),
+ MMMM: dateStrGetter('Month'),
+ MMM: dateStrGetter('Month', true),
+ MM: dateGetter('Month', 2, 1),
+ M: dateGetter('Month', 1, 1),
+ LLLL: dateStrGetter('Month', false, true),
+ dd: dateGetter('Date', 2),
+ d: dateGetter('Date', 1),
+ HH: dateGetter('Hours', 2),
+ H: dateGetter('Hours', 1),
+ hh: dateGetter('Hours', 2, -12),
+ h: dateGetter('Hours', 1, -12),
+ mm: dateGetter('Minutes', 2),
+ m: dateGetter('Minutes', 1),
+ ss: dateGetter('Seconds', 2),
+ s: dateGetter('Seconds', 1),
+ // while ISO 8601 requires fractions to be prefixed with `.` or `,`
+ // we can be just safely rely on using `sss` since we currently don't support single or two digit fractions
+ sss: dateGetter('Milliseconds', 3),
+ EEEE: dateStrGetter('Day'),
+ EEE: dateStrGetter('Day', true),
+ a: ampmGetter,
+ Z: timeZoneGetter,
+ ww: weekGetter(2),
+ w: weekGetter(1),
+ G: eraGetter,
+ GG: eraGetter,
+ GGG: eraGetter,
+ GGGG: longEraGetter
+};
+
+var DATE_FORMATS_SPLIT = /((?:[^yMLdHhmsaZEwG']+)|(?:'(?:[^']|'')*')|(?:E+|y+|M+|L+|d+|H+|h+|m+|s+|a|Z|G+|w+))([\s\S]*)/,
+ NUMBER_STRING = /^-?\d+$/;
+
+/**
+ * @ngdoc filter
+ * @name date
+ * @kind function
+ *
+ * @description
+ * Formats `date` to a string based on the requested `format`.
+ *
+ * `format` string can be composed of the following elements:
+ *
+ * * `'yyyy'`: 4 digit representation of year (e.g. AD 1 => 0001, AD 2010 => 2010)
+ * * `'yy'`: 2 digit representation of year, padded (00-99). (e.g. AD 2001 => 01, AD 2010 => 10)
+ * * `'y'`: 1 digit representation of year, e.g. (AD 1 => 1, AD 199 => 199)
+ * * `'MMMM'`: Month in year (January-December)
+ * * `'MMM'`: Month in year (Jan-Dec)
+ * * `'MM'`: Month in year, padded (01-12)
+ * * `'M'`: Month in year (1-12)
+ * * `'LLLL'`: Stand-alone month in year (January-December)
+ * * `'dd'`: Day in month, padded (01-31)
+ * * `'d'`: Day in month (1-31)
+ * * `'EEEE'`: Day in Week,(Sunday-Saturday)
+ * * `'EEE'`: Day in Week, (Sun-Sat)
+ * * `'HH'`: Hour in day, padded (00-23)
+ * * `'H'`: Hour in day (0-23)
+ * * `'hh'`: Hour in AM/PM, padded (01-12)
+ * * `'h'`: Hour in AM/PM, (1-12)
+ * * `'mm'`: Minute in hour, padded (00-59)
+ * * `'m'`: Minute in hour (0-59)
+ * * `'ss'`: Second in minute, padded (00-59)
+ * * `'s'`: Second in minute (0-59)
+ * * `'sss'`: Millisecond in second, padded (000-999)
+ * * `'a'`: AM/PM marker
+ * * `'Z'`: 4 digit (+sign) representation of the timezone offset (-1200-+1200)
+ * * `'ww'`: Week of year, padded (00-53). Week 01 is the week with the first Thursday of the year
+ * * `'w'`: Week of year (0-53). Week 1 is the week with the first Thursday of the year
+ * * `'G'`, `'GG'`, `'GGG'`: The abbreviated form of the era string (e.g. 'AD')
+ * * `'GGGG'`: The long form of the era string (e.g. 'Anno Domini')
+ *
+ * `format` string can also be one of the following predefined
+ * {@link guide/i18n localizable formats}:
+ *
+ * * `'medium'`: equivalent to `'MMM d, y h:mm:ss a'` for en_US locale
+ * (e.g. Sep 3, 2010 12:05:08 PM)
+ * * `'short'`: equivalent to `'M/d/yy h:mm a'` for en_US locale (e.g. 9/3/10 12:05 PM)
+ * * `'fullDate'`: equivalent to `'EEEE, MMMM d, y'` for en_US locale
+ * (e.g. Friday, September 3, 2010)
+ * * `'longDate'`: equivalent to `'MMMM d, y'` for en_US locale (e.g. September 3, 2010)
+ * * `'mediumDate'`: equivalent to `'MMM d, y'` for en_US locale (e.g. Sep 3, 2010)
+ * * `'shortDate'`: equivalent to `'M/d/yy'` for en_US locale (e.g. 9/3/10)
+ * * `'mediumTime'`: equivalent to `'h:mm:ss a'` for en_US locale (e.g. 12:05:08 PM)
+ * * `'shortTime'`: equivalent to `'h:mm a'` for en_US locale (e.g. 12:05 PM)
+ *
+ * `format` string can contain literal values. These need to be escaped by surrounding with single quotes (e.g.
+ * `"h 'in the morning'"`). In order to output a single quote, escape it - i.e., two single quotes in a sequence
+ * (e.g. `"h 'o''clock'"`).
+ *
+ * Any other characters in the `format` string will be output as-is.
+ *
+ * @param {(Date|number|string)} date Date to format either as Date object, milliseconds (string or
+ * number) or various ISO 8601 datetime string formats (e.g. yyyy-MM-ddTHH:mm:ss.sssZ and its
+ * shorter versions like yyyy-MM-ddTHH:mmZ, yyyy-MM-dd or yyyyMMddTHHmmssZ). If no timezone is
+ * specified in the string input, the time is considered to be in the local timezone.
+ * @param {string=} format Formatting rules (see Description). If not specified,
+ * `mediumDate` is used.
+ * @param {string=} timezone Timezone to be used for formatting. It understands UTC/GMT and the
+ * continental US time zone abbreviations, but for general use, use a time zone offset, for
+ * example, `'+0430'` (4 hours, 30 minutes east of the Greenwich meridian)
+ * If not specified, the timezone of the browser will be used.
+ * @returns {string} Formatted string or the input if input is not recognized as date/millis.
+ *
+ * @example
+ <example name="filter-date">
+ <file name="index.html">
+ <span ng-non-bindable>{{1288323623006 | date:'medium'}}</span>:
+ <span>{{1288323623006 | date:'medium'}}</span><br>
+ <span ng-non-bindable>{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}</span>:
+ <span>{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}</span><br>
+ <span ng-non-bindable>{{1288323623006 | date:'MM/dd/yyyy @ h:mma'}}</span>:
+ <span>{{'1288323623006' | date:'MM/dd/yyyy @ h:mma'}}</span><br>
+ <span ng-non-bindable>{{1288323623006 | date:"MM/dd/yyyy 'at' h:mma"}}</span>:
+ <span>{{'1288323623006' | date:"MM/dd/yyyy 'at' h:mma"}}</span><br>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should format date', function() {
+ expect(element(by.binding("1288323623006 | date:'medium'")).getText()).
+ toMatch(/Oct 2\d, 2010 \d{1,2}:\d{2}:\d{2} (AM|PM)/);
+ expect(element(by.binding("1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'")).getText()).
+ toMatch(/2010-10-2\d \d{2}:\d{2}:\d{2} (-|\+)?\d{4}/);
+ expect(element(by.binding("'1288323623006' | date:'MM/dd/yyyy @ h:mma'")).getText()).
+ toMatch(/10\/2\d\/2010 @ \d{1,2}:\d{2}(AM|PM)/);
+ expect(element(by.binding("'1288323623006' | date:\"MM/dd/yyyy 'at' h:mma\"")).getText()).
+ toMatch(/10\/2\d\/2010 at \d{1,2}:\d{2}(AM|PM)/);
+ });
+ </file>
+ </example>
+ */
+dateFilter.$inject = ['$locale'];
+function dateFilter($locale) {
+
+
+ var R_ISO8601_STR = /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/;
+ // 1 2 3 4 5 6 7 8 9 10 11
+ function jsonStringToDate(string) {
+ var match;
+ if ((match = string.match(R_ISO8601_STR))) {
+ var date = new Date(0),
+ tzHour = 0,
+ tzMin = 0,
+ dateSetter = match[8] ? date.setUTCFullYear : date.setFullYear,
+ timeSetter = match[8] ? date.setUTCHours : date.setHours;
+
+ if (match[9]) {
+ tzHour = toInt(match[9] + match[10]);
+ tzMin = toInt(match[9] + match[11]);
+ }
+ dateSetter.call(date, toInt(match[1]), toInt(match[2]) - 1, toInt(match[3]));
+ var h = toInt(match[4] || 0) - tzHour;
+ var m = toInt(match[5] || 0) - tzMin;
+ var s = toInt(match[6] || 0);
+ var ms = Math.round(parseFloat('0.' + (match[7] || 0)) * 1000);
+ timeSetter.call(date, h, m, s, ms);
+ return date;
+ }
+ return string;
+ }
+
+
+ return function(date, format, timezone) {
+ var text = '',
+ parts = [],
+ fn, match;
+
+ format = format || 'mediumDate';
+ format = $locale.DATETIME_FORMATS[format] || format;
+ if (isString(date)) {
+ date = NUMBER_STRING.test(date) ? toInt(date) : jsonStringToDate(date);
+ }
+
+ if (isNumber(date)) {
+ date = new Date(date);
+ }
+
+ if (!isDate(date) || !isFinite(date.getTime())) {
+ return date;
+ }
+
+ while (format) {
+ match = DATE_FORMATS_SPLIT.exec(format);
+ if (match) {
+ parts = concat(parts, match, 1);
+ format = parts.pop();
+ } else {
+ parts.push(format);
+ format = null;
+ }
+ }
+
+ var dateTimezoneOffset = date.getTimezoneOffset();
+ if (timezone) {
+ dateTimezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
+ date = convertTimezoneToLocal(date, timezone, true);
+ }
+ forEach(parts, function(value) {
+ fn = DATE_FORMATS[value];
+ text += fn ? fn(date, $locale.DATETIME_FORMATS, dateTimezoneOffset)
+ : value === '\'\'' ? '\'' : value.replace(/(^'|'$)/g, '').replace(/''/g, '\'');
+ });
+
+ return text;
+ };
+}
+
+
+/**
+ * @ngdoc filter
+ * @name json
+ * @kind function
+ *
+ * @description
+ * Allows you to convert a JavaScript object into JSON string.
+ *
+ * This filter is mostly useful for debugging. When using the double curly {{value}} notation
+ * the binding is automatically converted to JSON.
+ *
+ * @param {*} object Any JavaScript object (including arrays and primitive types) to filter.
+ * @param {number=} spacing The number of spaces to use per indentation, defaults to 2.
+ * @returns {string} JSON string.
+ *
+ *
+ * @example
+ <example name="filter-json">
+ <file name="index.html">
+ <pre id="default-spacing">{{ {'name':'value'} | json }}</pre>
+ <pre id="custom-spacing">{{ {'name':'value'} | json:4 }}</pre>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should jsonify filtered objects', function() {
+ expect(element(by.id('default-spacing')).getText()).toMatch(/\{\n {2}"name": ?"value"\n}/);
+ expect(element(by.id('custom-spacing')).getText()).toMatch(/\{\n {4}"name": ?"value"\n}/);
+ });
+ </file>
+ </example>
+ *
+ */
+function jsonFilter() {
+ return function(object, spacing) {
+ if (isUndefined(spacing)) {
+ spacing = 2;
+ }
+ return toJson(object, spacing);
+ };
+}
+
+
+/**
+ * @ngdoc filter
+ * @name lowercase
+ * @kind function
+ * @description
+ * Converts string to lowercase.
+ *
+ * See the {@link ng.uppercase uppercase filter documentation} for a functionally identical example.
+ *
+ * @see angular.lowercase
+ */
+var lowercaseFilter = valueFn(lowercase);
+
+
+/**
+ * @ngdoc filter
+ * @name uppercase
+ * @kind function
+ * @description
+ * Converts string to uppercase.
+ * @example
+ <example module="uppercaseFilterExample" name="filter-uppercase">
+ <file name="index.html">
+ <script>
+ angular.module('uppercaseFilterExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.title = 'This is a title';
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <!-- This title should be formatted normally -->
+ <h1>{{title}}</h1>
+ <!-- This title should be capitalized -->
+ <h1>{{title | uppercase}}</h1>
+ </div>
+ </file>
+ </example>
+ */
+var uppercaseFilter = valueFn(uppercase);
+
+/**
+ * @ngdoc filter
+ * @name limitTo
+ * @kind function
+ *
+ * @description
+ * Creates a new array or string containing only a specified number of elements. The elements are
+ * taken from either the beginning or the end of the source array, string or number, as specified by
+ * the value and sign (positive or negative) of `limit`. Other array-like objects are also supported
+ * (e.g. array subclasses, NodeLists, jqLite/jQuery collections etc). If a number is used as input,
+ * it is converted to a string.
+ *
+ * @param {Array|ArrayLike|string|number} input - Array/array-like, string or number to be limited.
+ * @param {string|number} limit - The length of the returned array or string. If the `limit` number
+ * is positive, `limit` number of items from the beginning of the source array/string are copied.
+ * If the number is negative, `limit` number of items from the end of the source array/string
+ * are copied. The `limit` will be trimmed if it exceeds `array.length`. If `limit` is undefined,
+ * the input will be returned unchanged.
+ * @param {(string|number)=} begin - Index at which to begin limitation. As a negative index,
+ * `begin` indicates an offset from the end of `input`. Defaults to `0`.
+ * @returns {Array|string} A new sub-array or substring of length `limit` or less if the input had
+ * less than `limit` elements.
+ *
+ * @example
+ <example module="limitToExample" name="limit-to-filter">
+ <file name="index.html">
+ <script>
+ angular.module('limitToExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.numbers = [1,2,3,4,5,6,7,8,9];
+ $scope.letters = "abcdefghi";
+ $scope.longNumber = 2345432342;
+ $scope.numLimit = 3;
+ $scope.letterLimit = 3;
+ $scope.longNumberLimit = 3;
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <label>
+ Limit {{numbers}} to:
+ <input type="number" step="1" ng-model="numLimit">
+ </label>
+ <p>Output numbers: {{ numbers | limitTo:numLimit }}</p>
+ <label>
+ Limit {{letters}} to:
+ <input type="number" step="1" ng-model="letterLimit">
+ </label>
+ <p>Output letters: {{ letters | limitTo:letterLimit }}</p>
+ <label>
+ Limit {{longNumber}} to:
+ <input type="number" step="1" ng-model="longNumberLimit">
+ </label>
+ <p>Output long number: {{ longNumber | limitTo:longNumberLimit }}</p>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var numLimitInput = element(by.model('numLimit'));
+ var letterLimitInput = element(by.model('letterLimit'));
+ var longNumberLimitInput = element(by.model('longNumberLimit'));
+ var limitedNumbers = element(by.binding('numbers | limitTo:numLimit'));
+ var limitedLetters = element(by.binding('letters | limitTo:letterLimit'));
+ var limitedLongNumber = element(by.binding('longNumber | limitTo:longNumberLimit'));
+
+ it('should limit the number array to first three items', function() {
+ expect(numLimitInput.getAttribute('value')).toBe('3');
+ expect(letterLimitInput.getAttribute('value')).toBe('3');
+ expect(longNumberLimitInput.getAttribute('value')).toBe('3');
+ expect(limitedNumbers.getText()).toEqual('Output numbers: [1,2,3]');
+ expect(limitedLetters.getText()).toEqual('Output letters: abc');
+ expect(limitedLongNumber.getText()).toEqual('Output long number: 234');
+ });
+
+ // There is a bug in safari and protractor that doesn't like the minus key
+ // it('should update the output when -3 is entered', function() {
+ // numLimitInput.clear();
+ // numLimitInput.sendKeys('-3');
+ // letterLimitInput.clear();
+ // letterLimitInput.sendKeys('-3');
+ // longNumberLimitInput.clear();
+ // longNumberLimitInput.sendKeys('-3');
+ // expect(limitedNumbers.getText()).toEqual('Output numbers: [7,8,9]');
+ // expect(limitedLetters.getText()).toEqual('Output letters: ghi');
+ // expect(limitedLongNumber.getText()).toEqual('Output long number: 342');
+ // });
+
+ it('should not exceed the maximum size of input array', function() {
+ numLimitInput.clear();
+ numLimitInput.sendKeys('100');
+ letterLimitInput.clear();
+ letterLimitInput.sendKeys('100');
+ longNumberLimitInput.clear();
+ longNumberLimitInput.sendKeys('100');
+ expect(limitedNumbers.getText()).toEqual('Output numbers: [1,2,3,4,5,6,7,8,9]');
+ expect(limitedLetters.getText()).toEqual('Output letters: abcdefghi');
+ expect(limitedLongNumber.getText()).toEqual('Output long number: 2345432342');
+ });
+ </file>
+ </example>
+*/
+function limitToFilter() {
+ return function(input, limit, begin) {
+ if (Math.abs(Number(limit)) === Infinity) {
+ limit = Number(limit);
+ } else {
+ limit = toInt(limit);
+ }
+ if (isNumberNaN(limit)) return input;
+
+ if (isNumber(input)) input = input.toString();
+ if (!isArrayLike(input)) return input;
+
+ begin = (!begin || isNaN(begin)) ? 0 : toInt(begin);
+ begin = (begin < 0) ? Math.max(0, input.length + begin) : begin;
+
+ if (limit >= 0) {
+ return sliceFn(input, begin, begin + limit);
+ } else {
+ if (begin === 0) {
+ return sliceFn(input, limit, input.length);
+ } else {
+ return sliceFn(input, Math.max(0, begin + limit), begin);
+ }
+ }
+ };
+}
+
+function sliceFn(input, begin, end) {
+ if (isString(input)) return input.slice(begin, end);
+
+ return slice.call(input, begin, end);
+}
+
+/**
+ * @ngdoc filter
+ * @name orderBy
+ * @kind function
+ *
+ * @description
+ * Returns an array containing the items from the specified `collection`, ordered by a `comparator`
+ * function based on the values computed using the `expression` predicate.
+ *
+ * For example, `[{id: 'foo'}, {id: 'bar'}] | orderBy:'id'` would result in
+ * `[{id: 'bar'}, {id: 'foo'}]`.
+ *
+ * The `collection` can be an Array or array-like object (e.g. NodeList, jQuery object, TypedArray,
+ * String, etc).
+ *
+ * The `expression` can be a single predicate, or a list of predicates each serving as a tie-breaker
+ * for the preceding one. The `expression` is evaluated against each item and the output is used
+ * for comparing with other items.
+ *
+ * You can change the sorting order by setting `reverse` to `true`. By default, items are sorted in
+ * ascending order.
+ *
+ * The comparison is done using the `comparator` function. If none is specified, a default, built-in
+ * comparator is used (see below for details - in a nutshell, it compares numbers numerically and
+ * strings alphabetically).
+ *
+ * ### Under the hood
+ *
+ * Ordering the specified `collection` happens in two phases:
+ *
+ * 1. All items are passed through the predicate (or predicates), and the returned values are saved
+ * along with their type (`string`, `number` etc). For example, an item `{label: 'foo'}`, passed
+ * through a predicate that extracts the value of the `label` property, would be transformed to:
+ * ```
+ * {
+ * value: 'foo',
+ * type: 'string',
+ * index: ...
+ * }
+ * ```
+ * **Note:** `null` values use `'null'` as their type.
+ * 2. The comparator function is used to sort the items, based on the derived values, types and
+ * indices.
+ *
+ * If you use a custom comparator, it will be called with pairs of objects of the form
+ * `{value: ..., type: '...', index: ...}` and is expected to return `0` if the objects are equal
+ * (as far as the comparator is concerned), `-1` if the 1st one should be ranked higher than the
+ * second, or `1` otherwise.
+ *
+ * In order to ensure that the sorting will be deterministic across platforms, if none of the
+ * specified predicates can distinguish between two items, `orderBy` will automatically introduce a
+ * dummy predicate that returns the item's index as `value`.
+ * (If you are using a custom comparator, make sure it can handle this predicate as well.)
+ *
+ * If a custom comparator still can't distinguish between two items, then they will be sorted based
+ * on their index using the built-in comparator.
+ *
+ * Finally, in an attempt to simplify things, if a predicate returns an object as the extracted
+ * value for an item, `orderBy` will try to convert that object to a primitive value, before passing
+ * it to the comparator. The following rules govern the conversion:
+ *
+ * 1. If the object has a `valueOf()` method that returns a primitive, its return value will be
+ * used instead.<br />
+ * (If the object has a `valueOf()` method that returns another object, then the returned object
+ * will be used in subsequent steps.)
+ * 2. If the object has a custom `toString()` method (i.e. not the one inherited from `Object`) that
+ * returns a primitive, its return value will be used instead.<br />
+ * (If the object has a `toString()` method that returns another object, then the returned object
+ * will be used in subsequent steps.)
+ * 3. No conversion; the object itself is used.
+ *
+ * ### The default comparator
+ *
+ * The default, built-in comparator should be sufficient for most usecases. In short, it compares
+ * numbers numerically, strings alphabetically (and case-insensitively), for objects falls back to
+ * using their index in the original collection, sorts values of different types by type and puts
+ * `undefined` and `null` values at the end of the sorted list.
+ *
+ * More specifically, it follows these steps to determine the relative order of items:
+ *
+ * 1. If the compared values are of different types:
+ * - If one of the values is undefined, consider it "greater than" the other.
+ * - Else if one of the values is null, consider it "greater than" the other.
+ * - Else compare the types themselves alphabetically.
+ * 2. If both values are of type `string`, compare them alphabetically in a case- and
+ * locale-insensitive way.
+ * 3. If both values are objects, compare their indices instead.
+ * 4. Otherwise, return:
+ * - `0`, if the values are equal (by strict equality comparison, i.e. using `===`).
+ * - `-1`, if the 1st value is "less than" the 2nd value (compared using the `<` operator).
+ * - `1`, otherwise.
+ *
+ * **Note:** If you notice numbers not being sorted as expected, make sure they are actually being
+ * saved as numbers and not strings.
+ * **Note:** For the purpose of sorting, `null` and `undefined` are considered "greater than"
+ * any other value (with undefined "greater than" null). This effectively means that `null`
+ * and `undefined` values end up at the end of a list sorted in ascending order.
+ * **Note:** `null` values use `'null'` as their type to be able to distinguish them from objects.
+ *
+ * @param {Array|ArrayLike} collection - The collection (array or array-like object) to sort.
+ * @param {(Function|string|Array.<Function|string>)=} expression - A predicate (or list of
+ * predicates) to be used by the comparator to determine the order of elements.
+ *
+ * Can be one of:
+ *
+ * - `Function`: A getter function. This function will be called with each item as argument and
+ * the return value will be used for sorting.
+ * - `string`: An AngularJS expression. This expression will be evaluated against each item and the
+ * result will be used for sorting. For example, use `'label'` to sort by a property called
+ * `label` or `'label.substring(0, 3)'` to sort by the first 3 characters of the `label`
+ * property.<br />
+ * (The result of a constant expression is interpreted as a property name to be used for
+ * comparison. For example, use `'"special name"'` (note the extra pair of quotes) to sort by a
+ * property called `special name`.)<br />
+ * An expression can be optionally prefixed with `+` or `-` to control the sorting direction,
+ * ascending or descending. For example, `'+label'` or `'-label'`. If no property is provided,
+ * (e.g. `'+'` or `'-'`), the collection element itself is used in comparisons.
+ * - `Array`: An array of function and/or string predicates. If a predicate cannot determine the
+ * relative order of two items, the next predicate is used as a tie-breaker.
+ *
+ * **Note:** If the predicate is missing or empty then it defaults to `'+'`.
+ *
+ * @param {boolean=} reverse - If `true`, reverse the sorting order.
+ * @param {(Function)=} comparator - The comparator function used to determine the relative order of
+ * value pairs. If omitted, the built-in comparator will be used.
+ *
+ * @returns {Array} - The sorted array.
+ *
+ *
+ * @example
+ * ### Ordering a table with `ngRepeat`
+ *
+ * The example below demonstrates a simple {@link ngRepeat ngRepeat}, where the data is sorted by
+ * age in descending order (expression is set to `'-age'`). The `comparator` is not set, which means
+ * it defaults to the built-in comparator.
+ *
+ <example name="orderBy-static" module="orderByExample1">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <table class="friends">
+ <tr>
+ <th>Name</th>
+ <th>Phone Number</th>
+ <th>Age</th>
+ </tr>
+ <tr ng-repeat="friend in friends | orderBy:'-age'">
+ <td>{{friend.name}}</td>
+ <td>{{friend.phone}}</td>
+ <td>{{friend.age}}</td>
+ </tr>
+ </table>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('orderByExample1', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.friends = [
+ {name: 'John', phone: '555-1212', age: 10},
+ {name: 'Mary', phone: '555-9876', age: 19},
+ {name: 'Mike', phone: '555-4321', age: 21},
+ {name: 'Adam', phone: '555-5678', age: 35},
+ {name: 'Julie', phone: '555-8765', age: 29}
+ ];
+ }]);
+ </file>
+ <file name="style.css">
+ .friends {
+ border-collapse: collapse;
+ }
+
+ .friends th {
+ border-bottom: 1px solid;
+ }
+ .friends td, .friends th {
+ border-left: 1px solid;
+ padding: 5px 10px;
+ }
+ .friends td:first-child, .friends th:first-child {
+ border-left: none;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ // Element locators
+ var names = element.all(by.repeater('friends').column('friend.name'));
+
+ it('should sort friends by age in reverse order', function() {
+ expect(names.get(0).getText()).toBe('Adam');
+ expect(names.get(1).getText()).toBe('Julie');
+ expect(names.get(2).getText()).toBe('Mike');
+ expect(names.get(3).getText()).toBe('Mary');
+ expect(names.get(4).getText()).toBe('John');
+ });
+ </file>
+ </example>
+ * <hr />
+ *
+ * @example
+ * ### Changing parameters dynamically
+ *
+ * All parameters can be changed dynamically. The next example shows how you can make the columns of
+ * a table sortable, by binding the `expression` and `reverse` parameters to scope properties.
+ *
+ <example name="orderBy-dynamic" module="orderByExample2">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <pre>Sort by = {{propertyName}}; reverse = {{reverse}}</pre>
+ <hr/>
+ <button ng-click="propertyName = null; reverse = false">Set to unsorted</button>
+ <hr/>
+ <table class="friends">
+ <tr>
+ <th>
+ <button ng-click="sortBy('name')">Name</button>
+ <span class="sortorder" ng-show="propertyName === 'name'" ng-class="{reverse: reverse}"></span>
+ </th>
+ <th>
+ <button ng-click="sortBy('phone')">Phone Number</button>
+ <span class="sortorder" ng-show="propertyName === 'phone'" ng-class="{reverse: reverse}"></span>
+ </th>
+ <th>
+ <button ng-click="sortBy('age')">Age</button>
+ <span class="sortorder" ng-show="propertyName === 'age'" ng-class="{reverse: reverse}"></span>
+ </th>
+ </tr>
+ <tr ng-repeat="friend in friends | orderBy:propertyName:reverse">
+ <td>{{friend.name}}</td>
+ <td>{{friend.phone}}</td>
+ <td>{{friend.age}}</td>
+ </tr>
+ </table>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('orderByExample2', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ var friends = [
+ {name: 'John', phone: '555-1212', age: 10},
+ {name: 'Mary', phone: '555-9876', age: 19},
+ {name: 'Mike', phone: '555-4321', age: 21},
+ {name: 'Adam', phone: '555-5678', age: 35},
+ {name: 'Julie', phone: '555-8765', age: 29}
+ ];
+
+ $scope.propertyName = 'age';
+ $scope.reverse = true;
+ $scope.friends = friends;
+
+ $scope.sortBy = function(propertyName) {
+ $scope.reverse = ($scope.propertyName === propertyName) ? !$scope.reverse : false;
+ $scope.propertyName = propertyName;
+ };
+ }]);
+ </file>
+ <file name="style.css">
+ .friends {
+ border-collapse: collapse;
+ }
+
+ .friends th {
+ border-bottom: 1px solid;
+ }
+ .friends td, .friends th {
+ border-left: 1px solid;
+ padding: 5px 10px;
+ }
+ .friends td:first-child, .friends th:first-child {
+ border-left: none;
+ }
+
+ .sortorder:after {
+ content: '\25b2'; // BLACK UP-POINTING TRIANGLE
+ }
+ .sortorder.reverse:after {
+ content: '\25bc'; // BLACK DOWN-POINTING TRIANGLE
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ // Element locators
+ var unsortButton = element(by.partialButtonText('unsorted'));
+ var nameHeader = element(by.partialButtonText('Name'));
+ var phoneHeader = element(by.partialButtonText('Phone'));
+ var ageHeader = element(by.partialButtonText('Age'));
+ var firstName = element(by.repeater('friends').column('friend.name').row(0));
+ var lastName = element(by.repeater('friends').column('friend.name').row(4));
+
+ it('should sort friends by some property, when clicking on the column header', function() {
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('John');
+
+ phoneHeader.click();
+ expect(firstName.getText()).toBe('John');
+ expect(lastName.getText()).toBe('Mary');
+
+ nameHeader.click();
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('Mike');
+
+ ageHeader.click();
+ expect(firstName.getText()).toBe('John');
+ expect(lastName.getText()).toBe('Adam');
+ });
+
+ it('should sort friends in reverse order, when clicking on the same column', function() {
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('John');
+
+ ageHeader.click();
+ expect(firstName.getText()).toBe('John');
+ expect(lastName.getText()).toBe('Adam');
+
+ ageHeader.click();
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('John');
+ });
+
+ it('should restore the original order, when clicking "Set to unsorted"', function() {
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('John');
+
+ unsortButton.click();
+ expect(firstName.getText()).toBe('John');
+ expect(lastName.getText()).toBe('Julie');
+ });
+ </file>
+ </example>
+ * <hr />
+ *
+ * @example
+ * ### Using `orderBy` inside a controller
+ *
+ * It is also possible to call the `orderBy` filter manually, by injecting `orderByFilter`, and
+ * calling it with the desired parameters. (Alternatively, you could inject the `$filter` factory
+ * and retrieve the `orderBy` filter with `$filter('orderBy')`.)
+ *
+ <example name="orderBy-call-manually" module="orderByExample3">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <pre>Sort by = {{propertyName}}; reverse = {{reverse}}</pre>
+ <hr/>
+ <button ng-click="sortBy(null)">Set to unsorted</button>
+ <hr/>
+ <table class="friends">
+ <tr>
+ <th>
+ <button ng-click="sortBy('name')">Name</button>
+ <span class="sortorder" ng-show="propertyName === 'name'" ng-class="{reverse: reverse}"></span>
+ </th>
+ <th>
+ <button ng-click="sortBy('phone')">Phone Number</button>
+ <span class="sortorder" ng-show="propertyName === 'phone'" ng-class="{reverse: reverse}"></span>
+ </th>
+ <th>
+ <button ng-click="sortBy('age')">Age</button>
+ <span class="sortorder" ng-show="propertyName === 'age'" ng-class="{reverse: reverse}"></span>
+ </th>
+ </tr>
+ <tr ng-repeat="friend in friends">
+ <td>{{friend.name}}</td>
+ <td>{{friend.phone}}</td>
+ <td>{{friend.age}}</td>
+ </tr>
+ </table>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('orderByExample3', [])
+ .controller('ExampleController', ['$scope', 'orderByFilter', function($scope, orderBy) {
+ var friends = [
+ {name: 'John', phone: '555-1212', age: 10},
+ {name: 'Mary', phone: '555-9876', age: 19},
+ {name: 'Mike', phone: '555-4321', age: 21},
+ {name: 'Adam', phone: '555-5678', age: 35},
+ {name: 'Julie', phone: '555-8765', age: 29}
+ ];
+
+ $scope.propertyName = 'age';
+ $scope.reverse = true;
+ $scope.friends = orderBy(friends, $scope.propertyName, $scope.reverse);
+
+ $scope.sortBy = function(propertyName) {
+ $scope.reverse = (propertyName !== null && $scope.propertyName === propertyName)
+ ? !$scope.reverse : false;
+ $scope.propertyName = propertyName;
+ $scope.friends = orderBy(friends, $scope.propertyName, $scope.reverse);
+ };
+ }]);
+ </file>
+ <file name="style.css">
+ .friends {
+ border-collapse: collapse;
+ }
+
+ .friends th {
+ border-bottom: 1px solid;
+ }
+ .friends td, .friends th {
+ border-left: 1px solid;
+ padding: 5px 10px;
+ }
+ .friends td:first-child, .friends th:first-child {
+ border-left: none;
+ }
+
+ .sortorder:after {
+ content: '\25b2'; // BLACK UP-POINTING TRIANGLE
+ }
+ .sortorder.reverse:after {
+ content: '\25bc'; // BLACK DOWN-POINTING TRIANGLE
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ // Element locators
+ var unsortButton = element(by.partialButtonText('unsorted'));
+ var nameHeader = element(by.partialButtonText('Name'));
+ var phoneHeader = element(by.partialButtonText('Phone'));
+ var ageHeader = element(by.partialButtonText('Age'));
+ var firstName = element(by.repeater('friends').column('friend.name').row(0));
+ var lastName = element(by.repeater('friends').column('friend.name').row(4));
+
+ it('should sort friends by some property, when clicking on the column header', function() {
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('John');
+
+ phoneHeader.click();
+ expect(firstName.getText()).toBe('John');
+ expect(lastName.getText()).toBe('Mary');
+
+ nameHeader.click();
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('Mike');
+
+ ageHeader.click();
+ expect(firstName.getText()).toBe('John');
+ expect(lastName.getText()).toBe('Adam');
+ });
+
+ it('should sort friends in reverse order, when clicking on the same column', function() {
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('John');
+
+ ageHeader.click();
+ expect(firstName.getText()).toBe('John');
+ expect(lastName.getText()).toBe('Adam');
+
+ ageHeader.click();
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('John');
+ });
+
+ it('should restore the original order, when clicking "Set to unsorted"', function() {
+ expect(firstName.getText()).toBe('Adam');
+ expect(lastName.getText()).toBe('John');
+
+ unsortButton.click();
+ expect(firstName.getText()).toBe('John');
+ expect(lastName.getText()).toBe('Julie');
+ });
+ </file>
+ </example>
+ * <hr />
+ *
+ * @example
+ * ### Using a custom comparator
+ *
+ * If you have very specific requirements about the way items are sorted, you can pass your own
+ * comparator function. For example, you might need to compare some strings in a locale-sensitive
+ * way. (When specifying a custom comparator, you also need to pass a value for the `reverse`
+ * argument - passing `false` retains the default sorting order, i.e. ascending.)
+ *
+ <example name="orderBy-custom-comparator" module="orderByExample4">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <div class="friends-container custom-comparator">
+ <h3>Locale-sensitive Comparator</h3>
+ <table class="friends">
+ <tr>
+ <th>Name</th>
+ <th>Favorite Letter</th>
+ </tr>
+ <tr ng-repeat="friend in friends | orderBy:'favoriteLetter':false:localeSensitiveComparator">
+ <td>{{friend.name}}</td>
+ <td>{{friend.favoriteLetter}}</td>
+ </tr>
+ </table>
+ </div>
+ <div class="friends-container default-comparator">
+ <h3>Default Comparator</h3>
+ <table class="friends">
+ <tr>
+ <th>Name</th>
+ <th>Favorite Letter</th>
+ </tr>
+ <tr ng-repeat="friend in friends | orderBy:'favoriteLetter'">
+ <td>{{friend.name}}</td>
+ <td>{{friend.favoriteLetter}}</td>
+ </tr>
+ </table>
+ </div>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('orderByExample4', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.friends = [
+ {name: 'John', favoriteLetter: 'Ä'},
+ {name: 'Mary', favoriteLetter: 'Ü'},
+ {name: 'Mike', favoriteLetter: 'Ö'},
+ {name: 'Adam', favoriteLetter: 'H'},
+ {name: 'Julie', favoriteLetter: 'Z'}
+ ];
+
+ $scope.localeSensitiveComparator = function(v1, v2) {
+ // If we don't get strings, just compare by index
+ if (v1.type !== 'string' || v2.type !== 'string') {
+ return (v1.index < v2.index) ? -1 : 1;
+ }
+
+ // Compare strings alphabetically, taking locale into account
+ return v1.value.localeCompare(v2.value);
+ };
+ }]);
+ </file>
+ <file name="style.css">
+ .friends-container {
+ display: inline-block;
+ margin: 0 30px;
+ }
+
+ .friends {
+ border-collapse: collapse;
+ }
+
+ .friends th {
+ border-bottom: 1px solid;
+ }
+ .friends td, .friends th {
+ border-left: 1px solid;
+ padding: 5px 10px;
+ }
+ .friends td:first-child, .friends th:first-child {
+ border-left: none;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ // Element locators
+ var container = element(by.css('.custom-comparator'));
+ var names = container.all(by.repeater('friends').column('friend.name'));
+
+ it('should sort friends by favorite letter (in correct alphabetical order)', function() {
+ expect(names.get(0).getText()).toBe('John');
+ expect(names.get(1).getText()).toBe('Adam');
+ expect(names.get(2).getText()).toBe('Mike');
+ expect(names.get(3).getText()).toBe('Mary');
+ expect(names.get(4).getText()).toBe('Julie');
+ });
+ </file>
+ </example>
+ *
+ */
+orderByFilter.$inject = ['$parse'];
+function orderByFilter($parse) {
+ return function(array, sortPredicate, reverseOrder, compareFn) {
+
+ if (array == null) return array;
+ if (!isArrayLike(array)) {
+ throw minErr('orderBy')('notarray', 'Expected array but received: {0}', array);
+ }
+
+ if (!isArray(sortPredicate)) { sortPredicate = [sortPredicate]; }
+ if (sortPredicate.length === 0) { sortPredicate = ['+']; }
+
+ var predicates = processPredicates(sortPredicate);
+
+ var descending = reverseOrder ? -1 : 1;
+
+ // Define the `compare()` function. Use a default comparator if none is specified.
+ var compare = isFunction(compareFn) ? compareFn : defaultCompare;
+
+ // The next three lines are a version of a Swartzian Transform idiom from Perl
+ // (sometimes called the Decorate-Sort-Undecorate idiom)
+ // See https://en.wikipedia.org/wiki/Schwartzian_transform
+ var compareValues = Array.prototype.map.call(array, getComparisonObject);
+ compareValues.sort(doComparison);
+ array = compareValues.map(function(item) { return item.value; });
+
+ return array;
+
+ function getComparisonObject(value, index) {
+ // NOTE: We are adding an extra `tieBreaker` value based on the element's index.
+ // This will be used to keep the sort stable when none of the input predicates can
+ // distinguish between two elements.
+ return {
+ value: value,
+ tieBreaker: {value: index, type: 'number', index: index},
+ predicateValues: predicates.map(function(predicate) {
+ return getPredicateValue(predicate.get(value), index);
+ })
+ };
+ }
+
+ function doComparison(v1, v2) {
+ for (var i = 0, ii = predicates.length; i < ii; i++) {
+ var result = compare(v1.predicateValues[i], v2.predicateValues[i]);
+ if (result) {
+ return result * predicates[i].descending * descending;
+ }
+ }
+
+ return (compare(v1.tieBreaker, v2.tieBreaker) || defaultCompare(v1.tieBreaker, v2.tieBreaker)) * descending;
+ }
+ };
+
+ function processPredicates(sortPredicates) {
+ return sortPredicates.map(function(predicate) {
+ var descending = 1, get = identity;
+
+ if (isFunction(predicate)) {
+ get = predicate;
+ } else if (isString(predicate)) {
+ if ((predicate.charAt(0) === '+' || predicate.charAt(0) === '-')) {
+ descending = predicate.charAt(0) === '-' ? -1 : 1;
+ predicate = predicate.substring(1);
+ }
+ if (predicate !== '') {
+ get = $parse(predicate);
+ if (get.constant) {
+ var key = get();
+ get = function(value) { return value[key]; };
+ }
+ }
+ }
+ return {get: get, descending: descending};
+ });
+ }
+
+ function isPrimitive(value) {
+ switch (typeof value) {
+ case 'number': /* falls through */
+ case 'boolean': /* falls through */
+ case 'string':
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ function objectValue(value) {
+ // If `valueOf` is a valid function use that
+ if (isFunction(value.valueOf)) {
+ value = value.valueOf();
+ if (isPrimitive(value)) return value;
+ }
+ // If `toString` is a valid function and not the one from `Object.prototype` use that
+ if (hasCustomToString(value)) {
+ value = value.toString();
+ if (isPrimitive(value)) return value;
+ }
+
+ return value;
+ }
+
+ function getPredicateValue(value, index) {
+ var type = typeof value;
+ if (value === null) {
+ type = 'null';
+ } else if (type === 'object') {
+ value = objectValue(value);
+ }
+ return {value: value, type: type, index: index};
+ }
+
+ function defaultCompare(v1, v2) {
+ var result = 0;
+ var type1 = v1.type;
+ var type2 = v2.type;
+
+ if (type1 === type2) {
+ var value1 = v1.value;
+ var value2 = v2.value;
+
+ if (type1 === 'string') {
+ // Compare strings case-insensitively
+ value1 = value1.toLowerCase();
+ value2 = value2.toLowerCase();
+ } else if (type1 === 'object') {
+ // For basic objects, use the position of the object
+ // in the collection instead of the value
+ if (isObject(value1)) value1 = v1.index;
+ if (isObject(value2)) value2 = v2.index;
+ }
+
+ if (value1 !== value2) {
+ result = value1 < value2 ? -1 : 1;
+ }
+ } else {
+ result = (type1 === 'undefined') ? 1 :
+ (type2 === 'undefined') ? -1 :
+ (type1 === 'null') ? 1 :
+ (type2 === 'null') ? -1 :
+ (type1 < type2) ? -1 : 1;
+ }
+
+ return result;
+ }
+}
+
+function ngDirective(directive) {
+ if (isFunction(directive)) {
+ directive = {
+ link: directive
+ };
+ }
+ directive.restrict = directive.restrict || 'AC';
+ return valueFn(directive);
+}
+
+/**
+ * @ngdoc directive
+ * @name a
+ * @restrict E
+ *
+ * @description
+ * Modifies the default behavior of the html a tag so that the default action is prevented when
+ * the href attribute is empty.
+ *
+ * For dynamically creating `href` attributes for a tags, see the {@link ng.ngHref `ngHref`} directive.
+ */
+var htmlAnchorDirective = valueFn({
+ restrict: 'E',
+ compile: function(element, attr) {
+ if (!attr.href && !attr.xlinkHref) {
+ return function(scope, element) {
+ // If the linked element is not an anchor tag anymore, do nothing
+ if (element[0].nodeName.toLowerCase() !== 'a') return;
+
+ // SVGAElement does not use the href attribute, but rather the 'xlinkHref' attribute.
+ var href = toString.call(element.prop('href')) === '[object SVGAnimatedString]' ?
+ 'xlink:href' : 'href';
+ element.on('click', function(event) {
+ // if we have no href url, then don't navigate anywhere.
+ if (!element.attr(href)) {
+ event.preventDefault();
+ }
+ });
+ };
+ }
+ }
+});
+
+/**
+ * @ngdoc directive
+ * @name ngHref
+ * @restrict A
+ * @priority 99
+ *
+ * @description
+ * Using AngularJS markup like `{{hash}}` in an href attribute will
+ * make the link go to the wrong URL if the user clicks it before
+ * AngularJS has a chance to replace the `{{hash}}` markup with its
+ * value. Until AngularJS replaces the markup the link will be broken
+ * and will most likely return a 404 error. The `ngHref` directive
+ * solves this problem.
+ *
+ * The wrong way to write it:
+ * ```html
+ * <a href="http://www.gravatar.com/avatar/{{hash}}">link1</a>
+ * ```
+ *
+ * The correct way to write it:
+ * ```html
+ * <a ng-href="http://www.gravatar.com/avatar/{{hash}}">link1</a>
+ * ```
+ *
+ * @element A
+ * @param {template} ngHref any string which can contain `{{}}` markup.
+ *
+ * @example
+ * This example shows various combinations of `href`, `ng-href` and `ng-click` attributes
+ * in links and their different behaviors:
+ <example name="ng-href">
+ <file name="index.html">
+ <input ng-model="value" /><br />
+ <a id="link-1" href ng-click="value = 1">link 1</a> (link, don't reload)<br />
+ <a id="link-2" href="" ng-click="value = 2">link 2</a> (link, don't reload)<br />
+ <a id="link-3" ng-href="/{{'123'}}">link 3</a> (link, reload!)<br />
+ <a id="link-4" href="" name="xx" ng-click="value = 4">anchor</a> (link, don't reload)<br />
+ <a id="link-5" name="xxx" ng-click="value = 5">anchor</a> (no link)<br />
+ <a id="link-6" ng-href="{{value}}">link</a> (link, change location)
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should execute ng-click but not reload when href without value', function() {
+ element(by.id('link-1')).click();
+ expect(element(by.model('value')).getAttribute('value')).toEqual('1');
+ expect(element(by.id('link-1')).getAttribute('href')).toBe('');
+ });
+
+ it('should execute ng-click but not reload when href empty string', function() {
+ element(by.id('link-2')).click();
+ expect(element(by.model('value')).getAttribute('value')).toEqual('2');
+ expect(element(by.id('link-2')).getAttribute('href')).toBe('');
+ });
+
+ it('should execute ng-click and change url when ng-href specified', function() {
+ expect(element(by.id('link-3')).getAttribute('href')).toMatch(/\/123$/);
+
+ element(by.id('link-3')).click();
+
+ // At this point, we navigate away from an AngularJS page, so we need
+ // to use browser.driver to get the base webdriver.
+
+ browser.wait(function() {
+ return browser.driver.getCurrentUrl().then(function(url) {
+ return url.match(/\/123$/);
+ });
+ }, 5000, 'page should navigate to /123');
+ });
+
+ it('should execute ng-click but not reload when href empty string and name specified', function() {
+ element(by.id('link-4')).click();
+ expect(element(by.model('value')).getAttribute('value')).toEqual('4');
+ expect(element(by.id('link-4')).getAttribute('href')).toBe('');
+ });
+
+ it('should execute ng-click but not reload when no href but name specified', function() {
+ element(by.id('link-5')).click();
+ expect(element(by.model('value')).getAttribute('value')).toEqual('5');
+ expect(element(by.id('link-5')).getAttribute('href')).toBe(null);
+ });
+
+ it('should only change url when only ng-href', function() {
+ element(by.model('value')).clear();
+ element(by.model('value')).sendKeys('6');
+ expect(element(by.id('link-6')).getAttribute('href')).toMatch(/\/6$/);
+
+ element(by.id('link-6')).click();
+
+ // At this point, we navigate away from an AngularJS page, so we need
+ // to use browser.driver to get the base webdriver.
+ browser.wait(function() {
+ return browser.driver.getCurrentUrl().then(function(url) {
+ return url.match(/\/6$/);
+ });
+ }, 5000, 'page should navigate to /6');
+ });
+ </file>
+ </example>
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngSrc
+ * @restrict A
+ * @priority 99
+ *
+ * @description
+ * Using AngularJS markup like `{{hash}}` in a `src` attribute doesn't
+ * work right: The browser will fetch from the URL with the literal
+ * text `{{hash}}` until AngularJS replaces the expression inside
+ * `{{hash}}`. The `ngSrc` directive solves this problem.
+ *
+ * The buggy way to write it:
+ * ```html
+ * <img src="http://www.gravatar.com/avatar/{{hash}}" alt="Description"/>
+ * ```
+ *
+ * The correct way to write it:
+ * ```html
+ * <img ng-src="http://www.gravatar.com/avatar/{{hash}}" alt="Description" />
+ * ```
+ *
+ * @element IMG
+ * @param {template} ngSrc any string which can contain `{{}}` markup.
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngSrcset
+ * @restrict A
+ * @priority 99
+ *
+ * @description
+ * Using AngularJS markup like `{{hash}}` in a `srcset` attribute doesn't
+ * work right: The browser will fetch from the URL with the literal
+ * text `{{hash}}` until AngularJS replaces the expression inside
+ * `{{hash}}`. The `ngSrcset` directive solves this problem.
+ *
+ * The buggy way to write it:
+ * ```html
+ * <img srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description"/>
+ * ```
+ *
+ * The correct way to write it:
+ * ```html
+ * <img ng-srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description" />
+ * ```
+ *
+ * @element IMG
+ * @param {template} ngSrcset any string which can contain `{{}}` markup.
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngDisabled
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ *
+ * This directive sets the `disabled` attribute on the element (typically a form control,
+ * e.g. `input`, `button`, `select` etc.) if the
+ * {@link guide/expression expression} inside `ngDisabled` evaluates to truthy.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `disabled`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ *
+ * @example
+ <example name="ng-disabled">
+ <file name="index.html">
+ <label>Click me to toggle: <input type="checkbox" ng-model="checked"></label><br/>
+ <button ng-model="button" ng-disabled="checked">Button</button>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should toggle button', function() {
+ expect(element(by.css('button')).getAttribute('disabled')).toBeFalsy();
+ element(by.model('checked')).click();
+ expect(element(by.css('button')).getAttribute('disabled')).toBeTruthy();
+ });
+ </file>
+ </example>
+ *
+ * @param {expression} ngDisabled If the {@link guide/expression expression} is truthy,
+ * then the `disabled` attribute will be set on the element
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngChecked
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ * Sets the `checked` attribute on the element, if the expression inside `ngChecked` is truthy.
+ *
+ * Note that this directive should not be used together with {@link ngModel `ngModel`},
+ * as this can lead to unexpected behavior.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `checked`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ *
+ * @example
+ <example name="ng-checked">
+ <file name="index.html">
+ <label>Check me to check both: <input type="checkbox" ng-model="leader"></label><br/>
+ <input id="checkFollower" type="checkbox" ng-checked="leader" aria-label="Follower input">
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check both checkBoxes', function() {
+ expect(element(by.id('checkFollower')).getAttribute('checked')).toBeFalsy();
+ element(by.model('leader')).click();
+ expect(element(by.id('checkFollower')).getAttribute('checked')).toBeTruthy();
+ });
+ </file>
+ </example>
+ *
+ * @element INPUT
+ * @param {expression} ngChecked If the {@link guide/expression expression} is truthy,
+ * then the `checked` attribute will be set on the element
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngReadonly
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ *
+ * Sets the `readonly` attribute on the element, if the expression inside `ngReadonly` is truthy.
+ * Note that `readonly` applies only to `input` elements with specific types. [See the input docs on
+ * MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly) for more information.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `readonly`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ *
+ * @example
+ <example name="ng-readonly">
+ <file name="index.html">
+ <label>Check me to make text readonly: <input type="checkbox" ng-model="checked"></label><br/>
+ <input type="text" ng-readonly="checked" value="I'm AngularJS" aria-label="Readonly field" />
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should toggle readonly attr', function() {
+ expect(element(by.css('[type="text"]')).getAttribute('readonly')).toBeFalsy();
+ element(by.model('checked')).click();
+ expect(element(by.css('[type="text"]')).getAttribute('readonly')).toBeTruthy();
+ });
+ </file>
+ </example>
+ *
+ * @element INPUT
+ * @param {expression} ngReadonly If the {@link guide/expression expression} is truthy,
+ * then special attribute "readonly" will be set on the element
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngSelected
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ *
+ * Sets the `selected` attribute on the element, if the expression inside `ngSelected` is truthy.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `selected`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** `ngSelected` does not interact with the `select` and `ngModel` directives, it only
+ * sets the `selected` attribute on the element. If you are using `ngModel` on the select, you
+ * should not use `ngSelected` on the options, as `ngModel` will set the select value and
+ * selected options.
+ * </div>
+ *
+ * @example
+ <example name="ng-selected">
+ <file name="index.html">
+ <label>Check me to select: <input type="checkbox" ng-model="selected"></label><br/>
+ <select aria-label="ngSelected demo">
+ <option>Hello!</option>
+ <option id="greet" ng-selected="selected">Greetings!</option>
+ </select>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should select Greetings!', function() {
+ expect(element(by.id('greet')).getAttribute('selected')).toBeFalsy();
+ element(by.model('selected')).click();
+ expect(element(by.id('greet')).getAttribute('selected')).toBeTruthy();
+ });
+ </file>
+ </example>
+ *
+ * @element OPTION
+ * @param {expression} ngSelected If the {@link guide/expression expression} is truthy,
+ * then special attribute "selected" will be set on the element
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngOpen
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ *
+ * Sets the `open` attribute on the element, if the expression inside `ngOpen` is truthy.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `open`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ *
+ * ## A note about browser compatibility
+ *
+ * Internet Explorer and Edge do not support the `details` element, it is
+ * recommended to use {@link ng.ngShow} and {@link ng.ngHide} instead.
+ *
+ * @example
+ <example name="ng-open">
+ <file name="index.html">
+ <label>Toggle details: <input type="checkbox" ng-model="open"></label><br/>
+ <details id="details" ng-open="open">
+ <summary>List</summary>
+ <ul>
+ <li>Apple</li>
+ <li>Orange</li>
+ <li>Durian</li>
+ </ul>
+ </details>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should toggle open', function() {
+ expect(element(by.id('details')).getAttribute('open')).toBeFalsy();
+ element(by.model('open')).click();
+ expect(element(by.id('details')).getAttribute('open')).toBeTruthy();
+ });
+ </file>
+ </example>
+ *
+ * @element DETAILS
+ * @param {expression} ngOpen If the {@link guide/expression expression} is truthy,
+ * then special attribute "open" will be set on the element
+ */
+
+var ngAttributeAliasDirectives = {};
+
+// boolean attrs are evaluated
+forEach(BOOLEAN_ATTR, function(propName, attrName) {
+ // binding to multiple is not supported
+ if (propName === 'multiple') return;
+
+ function defaultLinkFn(scope, element, attr) {
+ scope.$watch(attr[normalized], function ngBooleanAttrWatchAction(value) {
+ attr.$set(attrName, !!value);
+ });
+ }
+
+ var normalized = directiveNormalize('ng-' + attrName);
+ var linkFn = defaultLinkFn;
+
+ if (propName === 'checked') {
+ linkFn = function(scope, element, attr) {
+ // ensuring ngChecked doesn't interfere with ngModel when both are set on the same input
+ if (attr.ngModel !== attr[normalized]) {
+ defaultLinkFn(scope, element, attr);
+ }
+ };
+ }
+
+ ngAttributeAliasDirectives[normalized] = function() {
+ return {
+ restrict: 'A',
+ priority: 100,
+ link: linkFn
+ };
+ };
+});
+
+// aliased input attrs are evaluated
+forEach(ALIASED_ATTR, function(htmlAttr, ngAttr) {
+ ngAttributeAliasDirectives[ngAttr] = function() {
+ return {
+ priority: 100,
+ link: function(scope, element, attr) {
+ //special case ngPattern when a literal regular expression value
+ //is used as the expression (this way we don't have to watch anything).
+ if (ngAttr === 'ngPattern' && attr.ngPattern.charAt(0) === '/') {
+ var match = attr.ngPattern.match(REGEX_STRING_REGEXP);
+ if (match) {
+ attr.$set('ngPattern', new RegExp(match[1], match[2]));
+ return;
+ }
+ }
+
+ scope.$watch(attr[ngAttr], function ngAttrAliasWatchAction(value) {
+ attr.$set(ngAttr, value);
+ });
+ }
+ };
+ };
+});
+
+// ng-src, ng-srcset, ng-href are interpolated
+forEach(['src', 'srcset', 'href'], function(attrName) {
+ var normalized = directiveNormalize('ng-' + attrName);
+ ngAttributeAliasDirectives[normalized] = ['$sce', function($sce) {
+ return {
+ priority: 99, // it needs to run after the attributes are interpolated
+ link: function(scope, element, attr) {
+ var propName = attrName,
+ name = attrName;
+
+ if (attrName === 'href' &&
+ toString.call(element.prop('href')) === '[object SVGAnimatedString]') {
+ name = 'xlinkHref';
+ attr.$attr[name] = 'xlink:href';
+ propName = null;
+ }
+
+ // We need to sanitize the url at least once, in case it is a constant
+ // non-interpolated attribute.
+ attr.$set(normalized, $sce.getTrustedMediaUrl(attr[normalized]));
+
+ attr.$observe(normalized, function(value) {
+ if (!value) {
+ if (attrName === 'href') {
+ attr.$set(name, null);
+ }
+ return;
+ }
+
+ attr.$set(name, value);
+
+ // Support: IE 9-11 only
+ // On IE, if "ng:src" directive declaration is used and "src" attribute doesn't exist
+ // then calling element.setAttribute('src', 'foo') doesn't do anything, so we need
+ // to set the property as well to achieve the desired effect.
+ // We use attr[attrName] value since $set might have sanitized the url.
+ if (msie && propName) element.prop(propName, attr[name]);
+ });
+ }
+ };
+ }];
+});
+
+/* global -nullFormCtrl, -PENDING_CLASS, -SUBMITTED_CLASS
+ */
+var nullFormCtrl = {
+ $addControl: noop,
+ $getControls: valueFn([]),
+ $$renameControl: nullFormRenameControl,
+ $removeControl: noop,
+ $setValidity: noop,
+ $setDirty: noop,
+ $setPristine: noop,
+ $setSubmitted: noop,
+ $$setSubmitted: noop
+},
+PENDING_CLASS = 'ng-pending',
+SUBMITTED_CLASS = 'ng-submitted';
+
+function nullFormRenameControl(control, name) {
+ control.$name = name;
+}
+
+/**
+ * @ngdoc type
+ * @name form.FormController
+ *
+ * @property {boolean} $pristine True if user has not interacted with the form yet.
+ * @property {boolean} $dirty True if user has already interacted with the form.
+ * @property {boolean} $valid True if all of the containing forms and controls are valid.
+ * @property {boolean} $invalid True if at least one containing control or form is invalid.
+ * @property {boolean} $submitted True if user has submitted the form even if its invalid.
+ *
+ * @property {Object} $pending An object hash, containing references to controls or forms with
+ * pending validators, where:
+ *
+ * - keys are validations tokens (error names).
+ * - values are arrays of controls or forms that have a pending validator for the given error name.
+ *
+ * See {@link form.FormController#$error $error} for a list of built-in validation tokens.
+ *
+ * @property {Object} $error An object hash, containing references to controls or forms with failing
+ * validators, where:
+ *
+ * - keys are validation tokens (error names),
+ * - values are arrays of controls or forms that have a failing validator for the given error name.
+ *
+ * Built-in validation tokens:
+ * - `email`
+ * - `max`
+ * - `maxlength`
+ * - `min`
+ * - `minlength`
+ * - `number`
+ * - `pattern`
+ * - `required`
+ * - `url`
+ * - `date`
+ * - `datetimelocal`
+ * - `time`
+ * - `week`
+ * - `month`
+ *
+ * @description
+ * `FormController` keeps track of all its controls and nested forms as well as the state of them,
+ * such as being valid/invalid or dirty/pristine.
+ *
+ * Each {@link ng.directive:form form} directive creates an instance
+ * of `FormController`.
+ *
+ */
+//asks for $scope to fool the BC controller module
+FormController.$inject = ['$element', '$attrs', '$scope', '$animate', '$interpolate'];
+function FormController($element, $attrs, $scope, $animate, $interpolate) {
+ this.$$controls = [];
+
+ // init state
+ this.$error = {};
+ this.$$success = {};
+ this.$pending = undefined;
+ this.$name = $interpolate($attrs.name || $attrs.ngForm || '')($scope);
+ this.$dirty = false;
+ this.$pristine = true;
+ this.$valid = true;
+ this.$invalid = false;
+ this.$submitted = false;
+ this.$$parentForm = nullFormCtrl;
+
+ this.$$element = $element;
+ this.$$animate = $animate;
+
+ setupValidity(this);
+}
+
+FormController.prototype = {
+ /**
+ * @ngdoc method
+ * @name form.FormController#$rollbackViewValue
+ *
+ * @description
+ * Rollback all form controls pending updates to the `$modelValue`.
+ *
+ * Updates may be pending by a debounced event or because the input is waiting for a some future
+ * event defined in `ng-model-options`. This method is typically needed by the reset button of
+ * a form that uses `ng-model-options` to pend updates.
+ */
+ $rollbackViewValue: function() {
+ forEach(this.$$controls, function(control) {
+ control.$rollbackViewValue();
+ });
+ },
+
+ /**
+ * @ngdoc method
+ * @name form.FormController#$commitViewValue
+ *
+ * @description
+ * Commit all form controls pending updates to the `$modelValue`.
+ *
+ * Updates may be pending by a debounced event or because the input is waiting for a some future
+ * event defined in `ng-model-options`. This method is rarely needed as `NgModelController`
+ * usually handles calling this in response to input events.
+ */
+ $commitViewValue: function() {
+ forEach(this.$$controls, function(control) {
+ control.$commitViewValue();
+ });
+ },
+
+ /**
+ * @ngdoc method
+ * @name form.FormController#$addControl
+ * @param {object} control control object, either a {@link form.FormController} or an
+ * {@link ngModel.NgModelController}
+ *
+ * @description
+ * Register a control with the form. Input elements using ngModelController do this automatically
+ * when they are linked.
+ *
+ * Note that the current state of the control will not be reflected on the new parent form. This
+ * is not an issue with normal use, as freshly compiled and linked controls are in a `$pristine`
+ * state.
+ *
+ * However, if the method is used programmatically, for example by adding dynamically created controls,
+ * or controls that have been previously removed without destroying their corresponding DOM element,
+ * it's the developers responsibility to make sure the current state propagates to the parent form.
+ *
+ * For example, if an input control is added that is already `$dirty` and has `$error` properties,
+ * calling `$setDirty()` and `$validate()` afterwards will propagate the state to the parent form.
+ */
+ $addControl: function(control) {
+ // Breaking change - before, inputs whose name was "hasOwnProperty" were quietly ignored
+ // and not added to the scope. Now we throw an error.
+ assertNotHasOwnProperty(control.$name, 'input');
+ this.$$controls.push(control);
+
+ if (control.$name) {
+ this[control.$name] = control;
+ }
+
+ control.$$parentForm = this;
+ },
+
+ /**
+ * @ngdoc method
+ * @name form.FormController#$getControls
+ * @returns {Array} the controls that are currently part of this form
+ *
+ * @description
+ * This method returns a **shallow copy** of the controls that are currently part of this form.
+ * The controls can be instances of {@link form.FormController `FormController`}
+ * ({@link ngForm "child-forms"}) and of {@link ngModel.NgModelController `NgModelController`}.
+ * If you need access to the controls of child-forms, you have to call `$getControls()`
+ * recursively on them.
+ * This can be used for example to iterate over all controls to validate them.
+ *
+ * The controls can be accessed normally, but adding to, or removing controls from the array has
+ * no effect on the form. Instead, use {@link form.FormController#$addControl `$addControl()`} and
+ * {@link form.FormController#$removeControl `$removeControl()`} for this use-case.
+ * Likewise, adding a control to, or removing a control from the form is not reflected
+ * in the shallow copy. That means you should get a fresh copy from `$getControls()` every time
+ * you need access to the controls.
+ */
+ $getControls: function() {
+ return shallowCopy(this.$$controls);
+ },
+
+ // Private API: rename a form control
+ $$renameControl: function(control, newName) {
+ var oldName = control.$name;
+
+ if (this[oldName] === control) {
+ delete this[oldName];
+ }
+ this[newName] = control;
+ control.$name = newName;
+ },
+
+ /**
+ * @ngdoc method
+ * @name form.FormController#$removeControl
+ * @param {object} control control object, either a {@link form.FormController} or an
+ * {@link ngModel.NgModelController}
+ *
+ * @description
+ * Deregister a control from the form.
+ *
+ * Input elements using ngModelController do this automatically when they are destroyed.
+ *
+ * Note that only the removed control's validation state (`$errors`etc.) will be removed from the
+ * form. `$dirty`, `$submitted` states will not be changed, because the expected behavior can be
+ * different from case to case. For example, removing the only `$dirty` control from a form may or
+ * may not mean that the form is still `$dirty`.
+ */
+ $removeControl: function(control) {
+ if (control.$name && this[control.$name] === control) {
+ delete this[control.$name];
+ }
+ forEach(this.$pending, function(value, name) {
+ // eslint-disable-next-line no-invalid-this
+ this.$setValidity(name, null, control);
+ }, this);
+ forEach(this.$error, function(value, name) {
+ // eslint-disable-next-line no-invalid-this
+ this.$setValidity(name, null, control);
+ }, this);
+ forEach(this.$$success, function(value, name) {
+ // eslint-disable-next-line no-invalid-this
+ this.$setValidity(name, null, control);
+ }, this);
+
+ arrayRemove(this.$$controls, control);
+ control.$$parentForm = nullFormCtrl;
+ },
+
+ /**
+ * @ngdoc method
+ * @name form.FormController#$setDirty
+ *
+ * @description
+ * Sets the form to a dirty state.
+ *
+ * This method can be called to add the 'ng-dirty' class and set the form to a dirty
+ * state (ng-dirty class). This method will also propagate to parent forms.
+ */
+ $setDirty: function() {
+ this.$$animate.removeClass(this.$$element, PRISTINE_CLASS);
+ this.$$animate.addClass(this.$$element, DIRTY_CLASS);
+ this.$dirty = true;
+ this.$pristine = false;
+ this.$$parentForm.$setDirty();
+ },
+
+ /**
+ * @ngdoc method
+ * @name form.FormController#$setPristine
+ *
+ * @description
+ * Sets the form to its pristine state.
+ *
+ * This method sets the form's `$pristine` state to true, the `$dirty` state to false, removes
+ * the `ng-dirty` class and adds the `ng-pristine` class. Additionally, it sets the `$submitted`
+ * state to false.
+ *
+ * This method will also propagate to all the controls contained in this form.
+ *
+ * Setting a form back to a pristine state is often useful when we want to 'reuse' a form after
+ * saving or resetting it.
+ */
+ $setPristine: function() {
+ this.$$animate.setClass(this.$$element, PRISTINE_CLASS, DIRTY_CLASS + ' ' + SUBMITTED_CLASS);
+ this.$dirty = false;
+ this.$pristine = true;
+ this.$submitted = false;
+ forEach(this.$$controls, function(control) {
+ control.$setPristine();
+ });
+ },
+
+ /**
+ * @ngdoc method
+ * @name form.FormController#$setUntouched
+ *
+ * @description
+ * Sets the form to its untouched state.
+ *
+ * This method can be called to remove the 'ng-touched' class and set the form controls to their
+ * untouched state (ng-untouched class).
+ *
+ * Setting a form controls back to their untouched state is often useful when setting the form
+ * back to its pristine state.
+ */
+ $setUntouched: function() {
+ forEach(this.$$controls, function(control) {
+ control.$setUntouched();
+ });
+ },
+
+ /**
+ * @ngdoc method
+ * @name form.FormController#$setSubmitted
+ *
+ * @description
+ * Sets the form to its `$submitted` state. This will also set `$submitted` on all child and
+ * parent forms of the form.
+ */
+ $setSubmitted: function() {
+ var rootForm = this;
+ while (rootForm.$$parentForm && (rootForm.$$parentForm !== nullFormCtrl)) {
+ rootForm = rootForm.$$parentForm;
+ }
+ rootForm.$$setSubmitted();
+ },
+
+ $$setSubmitted: function() {
+ this.$$animate.addClass(this.$$element, SUBMITTED_CLASS);
+ this.$submitted = true;
+ forEach(this.$$controls, function(control) {
+ if (control.$$setSubmitted) {
+ control.$$setSubmitted();
+ }
+ });
+ }
+};
+
+/**
+ * @ngdoc method
+ * @name form.FormController#$setValidity
+ *
+ * @description
+ * Change the validity state of the form, and notify the parent form (if any).
+ *
+ * Application developers will rarely need to call this method directly. It is used internally, by
+ * {@link ngModel.NgModelController#$setValidity NgModelController.$setValidity()}, to propagate a
+ * control's validity state to the parent `FormController`.
+ *
+ * @param {string} validationErrorKey Name of the validator. The `validationErrorKey` will be
+ * assigned to either `$error[validationErrorKey]` or `$pending[validationErrorKey]` (for
+ * unfulfilled `$asyncValidators`), so that it is available for data-binding. The
+ * `validationErrorKey` should be in camelCase and will get converted into dash-case for
+ * class name. Example: `myError` will result in `ng-valid-my-error` and
+ * `ng-invalid-my-error` classes and can be bound to as `{{ someForm.$error.myError }}`.
+ * @param {boolean} isValid Whether the current state is valid (true), invalid (false), pending
+ * (undefined), or skipped (null). Pending is used for unfulfilled `$asyncValidators`.
+ * Skipped is used by AngularJS when validators do not run because of parse errors and when
+ * `$asyncValidators` do not run because any of the `$validators` failed.
+ * @param {NgModelController | FormController} controller - The controller whose validity state is
+ * triggering the change.
+ */
+addSetValidityMethod({
+ clazz: FormController,
+ set: function(object, property, controller) {
+ var list = object[property];
+ if (!list) {
+ object[property] = [controller];
+ } else {
+ var index = list.indexOf(controller);
+ if (index === -1) {
+ list.push(controller);
+ }
+ }
+ },
+ unset: function(object, property, controller) {
+ var list = object[property];
+ if (!list) {
+ return;
+ }
+ arrayRemove(list, controller);
+ if (list.length === 0) {
+ delete object[property];
+ }
+ }
+});
+
+/**
+ * @ngdoc directive
+ * @name ngForm
+ * @restrict EAC
+ *
+ * @description
+ * Helper directive that makes it possible to create control groups inside a
+ * {@link ng.directive:form `form`} directive.
+ * These "child forms" can be used, for example, to determine the validity of a sub-group of
+ * controls.
+ *
+ * <div class="alert alert-danger">
+ * **Note**: `ngForm` cannot be used as a replacement for `<form>`, because it lacks its
+ * [built-in HTML functionality](https://html.spec.whatwg.org/#the-form-element).
+ * Specifically, you cannot submit `ngForm` like a `<form>` tag. That means,
+ * you cannot send data to the server with `ngForm`, or integrate it with
+ * {@link ng.directive:ngSubmit `ngSubmit`}.
+ * </div>
+ *
+ * @param {string=} ngForm|name Name of the form. If specified, the form controller will
+ * be published into the related scope, under this name.
+ *
+ */
+
+ /**
+ * @ngdoc directive
+ * @name form
+ * @restrict E
+ *
+ * @description
+ * Directive that instantiates
+ * {@link form.FormController FormController}.
+ *
+ * If the `name` attribute is specified, the form controller is published onto the current scope under
+ * this name.
+ *
+ * ## Alias: {@link ng.directive:ngForm `ngForm`}
+ *
+ * In AngularJS, forms can be nested. This means that the outer form is valid when all of the child
+ * forms are valid as well. However, browsers do not allow nesting of `<form>` elements, so
+ * AngularJS provides the {@link ng.directive:ngForm `ngForm`} directive, which behaves identically to
+ * `form` but can be nested. Nested forms can be useful, for example, if the validity of a sub-group
+ * of controls needs to be determined.
+ *
+ * ## CSS classes
+ * - `ng-valid` is set if the form is valid.
+ * - `ng-invalid` is set if the form is invalid.
+ * - `ng-pending` is set if the form is pending.
+ * - `ng-pristine` is set if the form is pristine.
+ * - `ng-dirty` is set if the form is dirty.
+ * - `ng-submitted` is set if the form was submitted.
+ *
+ * Keep in mind that ngAnimate can detect each of these classes when added and removed.
+ *
+ *
+ * ## Submitting a form and preventing the default action
+ *
+ * Since the role of forms in client-side AngularJS applications is different than in classical
+ * roundtrip apps, it is desirable for the browser not to translate the form submission into a full
+ * page reload that sends the data to the server. Instead some javascript logic should be triggered
+ * to handle the form submission in an application-specific way.
+ *
+ * For this reason, AngularJS prevents the default action (form submission to the server) unless the
+ * `<form>` element has an `action` attribute specified.
+ *
+ * You can use one of the following two ways to specify what javascript method should be called when
+ * a form is submitted:
+ *
+ * - {@link ng.directive:ngSubmit ngSubmit} directive on the form element
+ * - {@link ng.directive:ngClick ngClick} directive on the first
+ * button or input field of type submit (input[type=submit])
+ *
+ * To prevent double execution of the handler, use only one of the {@link ng.directive:ngSubmit ngSubmit}
+ * or {@link ng.directive:ngClick ngClick} directives.
+ * This is because of the following form submission rules in the HTML specification:
+ *
+ * - If a form has only one input field then hitting enter in this field triggers form submit
+ * (`ngSubmit`)
+ * - if a form has 2+ input fields and no buttons or input[type=submit] then hitting enter
+ * doesn't trigger submit
+ * - if a form has one or more input fields and one or more buttons or input[type=submit] then
+ * hitting enter in any of the input fields will trigger the click handler on the *first* button or
+ * input[type=submit] (`ngClick`) *and* a submit handler on the enclosing form (`ngSubmit`)
+ *
+ * Any pending `ngModelOptions` changes will take place immediately when an enclosing form is
+ * submitted. Note that `ngClick` events will occur before the model is updated. Use `ngSubmit`
+ * to have access to the updated model.
+ *
+ * @animations
+ * Animations in ngForm are triggered when any of the associated CSS classes are added and removed.
+ * These classes are: `.ng-pristine`, `.ng-dirty`, `.ng-invalid` and `.ng-valid` as well as any
+ * other validations that are performed within the form. Animations in ngForm are similar to how
+ * they work in ngClass and animations can be hooked into using CSS transitions, keyframes as well
+ * as JS animations.
+ *
+ * The following example shows a simple way to utilize CSS transitions to style a form element
+ * that has been rendered as invalid after it has been validated:
+ *
+ * <pre>
+ * //be sure to include ngAnimate as a module to hook into more
+ * //advanced animations
+ * .my-form {
+ * transition:0.5s linear all;
+ * background: white;
+ * }
+ * .my-form.ng-invalid {
+ * background: red;
+ * color:white;
+ * }
+ * </pre>
+ *
+ * @example
+ <example name="ng-form" deps="angular-animate.js" animations="true" fixBase="true" module="formExample">
+ <file name="index.html">
+ <script>
+ angular.module('formExample', [])
+ .controller('FormController', ['$scope', function($scope) {
+ $scope.userType = 'guest';
+ }]);
+ </script>
+ <style>
+ .my-form {
+ transition:all linear 0.5s;
+ background: transparent;
+ }
+ .my-form.ng-invalid {
+ background: red;
+ }
+ </style>
+ <form name="myForm" ng-controller="FormController" class="my-form">
+ userType: <input name="input" ng-model="userType" required>
+ <span class="error" ng-show="myForm.input.$error.required">Required!</span><br>
+ <code>userType = {{userType}}</code><br>
+ <code>myForm.input.$valid = {{myForm.input.$valid}}</code><br>
+ <code>myForm.input.$error = {{myForm.input.$error}}</code><br>
+ <code>myForm.$valid = {{myForm.$valid}}</code><br>
+ <code>myForm.$error.required = {{!!myForm.$error.required}}</code><br>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should initialize to model', function() {
+ var userType = element(by.binding('userType'));
+ var valid = element(by.binding('myForm.input.$valid'));
+
+ expect(userType.getText()).toContain('guest');
+ expect(valid.getText()).toContain('true');
+ });
+
+ it('should be invalid if empty', function() {
+ var userType = element(by.binding('userType'));
+ var valid = element(by.binding('myForm.input.$valid'));
+ var userInput = element(by.model('userType'));
+
+ userInput.clear();
+ userInput.sendKeys('');
+
+ expect(userType.getText()).toEqual('userType =');
+ expect(valid.getText()).toContain('false');
+ });
+ </file>
+ </example>
+ *
+ * @param {string=} name Name of the form. If specified, the form controller will be published into
+ * related scope, under this name.
+ */
+var formDirectiveFactory = function(isNgForm) {
+ return ['$timeout', '$parse', function($timeout, $parse) {
+ var formDirective = {
+ name: 'form',
+ restrict: isNgForm ? 'EAC' : 'E',
+ require: ['form', '^^?form'], //first is the form's own ctrl, second is an optional parent form
+ controller: FormController,
+ compile: function ngFormCompile(formElement, attr) {
+ // Setup initial state of the control
+ formElement.addClass(PRISTINE_CLASS).addClass(VALID_CLASS);
+
+ var nameAttr = attr.name ? 'name' : (isNgForm && attr.ngForm ? 'ngForm' : false);
+
+ return {
+ pre: function ngFormPreLink(scope, formElement, attr, ctrls) {
+ var controller = ctrls[0];
+
+ // if `action` attr is not present on the form, prevent the default action (submission)
+ if (!('action' in attr)) {
+ // we can't use jq events because if a form is destroyed during submission the default
+ // action is not prevented. see #1238
+ //
+ // IE 9 is not affected because it doesn't fire a submit event and try to do a full
+ // page reload if the form was destroyed by submission of the form via a click handler
+ // on a button in the form. Looks like an IE9 specific bug.
+ var handleFormSubmission = function(event) {
+ scope.$apply(function() {
+ controller.$commitViewValue();
+ controller.$setSubmitted();
+ });
+
+ event.preventDefault();
+ };
+
+ formElement[0].addEventListener('submit', handleFormSubmission);
+
+ // unregister the preventDefault listener so that we don't not leak memory but in a
+ // way that will achieve the prevention of the default action.
+ formElement.on('$destroy', function() {
+ $timeout(function() {
+ formElement[0].removeEventListener('submit', handleFormSubmission);
+ }, 0, false);
+ });
+ }
+
+ var parentFormCtrl = ctrls[1] || controller.$$parentForm;
+ parentFormCtrl.$addControl(controller);
+
+ var setter = nameAttr ? getSetter(controller.$name) : noop;
+
+ if (nameAttr) {
+ setter(scope, controller);
+ attr.$observe(nameAttr, function(newValue) {
+ if (controller.$name === newValue) return;
+ setter(scope, undefined);
+ controller.$$parentForm.$$renameControl(controller, newValue);
+ setter = getSetter(controller.$name);
+ setter(scope, controller);
+ });
+ }
+ formElement.on('$destroy', function() {
+ controller.$$parentForm.$removeControl(controller);
+ setter(scope, undefined);
+ extend(controller, nullFormCtrl); //stop propagating child destruction handlers upwards
+ });
+ }
+ };
+ }
+ };
+
+ return formDirective;
+
+ function getSetter(expression) {
+ if (expression === '') {
+ //create an assignable expression, so forms with an empty name can be renamed later
+ return $parse('this[""]').assign;
+ }
+ return $parse(expression).assign || noop;
+ }
+ }];
+};
+
+var formDirective = formDirectiveFactory();
+var ngFormDirective = formDirectiveFactory(true);
+
+
+
+// helper methods
+function setupValidity(instance) {
+ instance.$$classCache = {};
+ instance.$$classCache[INVALID_CLASS] = !(instance.$$classCache[VALID_CLASS] = instance.$$element.hasClass(VALID_CLASS));
+}
+function addSetValidityMethod(context) {
+ var clazz = context.clazz,
+ set = context.set,
+ unset = context.unset;
+
+ clazz.prototype.$setValidity = function(validationErrorKey, state, controller) {
+ if (isUndefined(state)) {
+ createAndSet(this, '$pending', validationErrorKey, controller);
+ } else {
+ unsetAndCleanup(this, '$pending', validationErrorKey, controller);
+ }
+ if (!isBoolean(state)) {
+ unset(this.$error, validationErrorKey, controller);
+ unset(this.$$success, validationErrorKey, controller);
+ } else {
+ if (state) {
+ unset(this.$error, validationErrorKey, controller);
+ set(this.$$success, validationErrorKey, controller);
+ } else {
+ set(this.$error, validationErrorKey, controller);
+ unset(this.$$success, validationErrorKey, controller);
+ }
+ }
+ if (this.$pending) {
+ cachedToggleClass(this, PENDING_CLASS, true);
+ this.$valid = this.$invalid = undefined;
+ toggleValidationCss(this, '', null);
+ } else {
+ cachedToggleClass(this, PENDING_CLASS, false);
+ this.$valid = isObjectEmpty(this.$error);
+ this.$invalid = !this.$valid;
+ toggleValidationCss(this, '', this.$valid);
+ }
+
+ // re-read the state as the set/unset methods could have
+ // combined state in this.$error[validationError] (used for forms),
+ // where setting/unsetting only increments/decrements the value,
+ // and does not replace it.
+ var combinedState;
+ if (this.$pending && this.$pending[validationErrorKey]) {
+ combinedState = undefined;
+ } else if (this.$error[validationErrorKey]) {
+ combinedState = false;
+ } else if (this.$$success[validationErrorKey]) {
+ combinedState = true;
+ } else {
+ combinedState = null;
+ }
+
+ toggleValidationCss(this, validationErrorKey, combinedState);
+ this.$$parentForm.$setValidity(validationErrorKey, combinedState, this);
+ };
+
+ function createAndSet(ctrl, name, value, controller) {
+ if (!ctrl[name]) {
+ ctrl[name] = {};
+ }
+ set(ctrl[name], value, controller);
+ }
+
+ function unsetAndCleanup(ctrl, name, value, controller) {
+ if (ctrl[name]) {
+ unset(ctrl[name], value, controller);
+ }
+ if (isObjectEmpty(ctrl[name])) {
+ ctrl[name] = undefined;
+ }
+ }
+
+ function cachedToggleClass(ctrl, className, switchValue) {
+ if (switchValue && !ctrl.$$classCache[className]) {
+ ctrl.$$animate.addClass(ctrl.$$element, className);
+ ctrl.$$classCache[className] = true;
+ } else if (!switchValue && ctrl.$$classCache[className]) {
+ ctrl.$$animate.removeClass(ctrl.$$element, className);
+ ctrl.$$classCache[className] = false;
+ }
+ }
+
+ function toggleValidationCss(ctrl, validationErrorKey, isValid) {
+ validationErrorKey = validationErrorKey ? '-' + snake_case(validationErrorKey, '-') : '';
+
+ cachedToggleClass(ctrl, VALID_CLASS + validationErrorKey, isValid === true);
+ cachedToggleClass(ctrl, INVALID_CLASS + validationErrorKey, isValid === false);
+ }
+}
+
+function isObjectEmpty(obj) {
+ if (obj) {
+ for (var prop in obj) {
+ if (obj.hasOwnProperty(prop)) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+/* global
+ VALID_CLASS: false,
+ INVALID_CLASS: false,
+ PRISTINE_CLASS: false,
+ DIRTY_CLASS: false,
+ ngModelMinErr: false
+*/
+
+// Regex code was initially obtained from SO prior to modification: https://stackoverflow.com/questions/3143070/javascript-regex-iso-datetime#answer-3143231
+var ISO_DATE_REGEXP = /^\d{4,}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+(?:[+-][0-2]\d:[0-5]\d|Z)$/;
+// See valid URLs in RFC3987 (http://tools.ietf.org/html/rfc3987)
+// Note: We are being more lenient, because browsers are too.
+// 1. Scheme
+// 2. Slashes
+// 3. Username
+// 4. Password
+// 5. Hostname
+// 6. Port
+// 7. Path
+// 8. Query
+// 9. Fragment
+// 1111111111111111 222 333333 44444 55555555555555555555555 666 77777777 8888888 999
+var URL_REGEXP = /^[a-z][a-z\d.+-]*:\/*(?:[^:@]+(?::[^@]+)?@)?(?:[^\s:/?#]+|\[[a-f\d:]+])(?::\d+)?(?:\/[^?#]*)?(?:\?[^#]*)?(?:#.*)?$/i;
+// eslint-disable-next-line max-len
+var EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+(\.[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+)*@[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/;
+var NUMBER_REGEXP = /^\s*(-|\+)?(\d+|(\d*(\.\d*)))([eE][+-]?\d+)?\s*$/;
+var DATE_REGEXP = /^(\d{4,})-(\d{2})-(\d{2})$/;
+var DATETIMELOCAL_REGEXP = /^(\d{4,})-(\d\d)-(\d\d)T(\d\d):(\d\d)(?::(\d\d)(\.\d{1,3})?)?$/;
+var WEEK_REGEXP = /^(\d{4,})-W(\d\d)$/;
+var MONTH_REGEXP = /^(\d{4,})-(\d\d)$/;
+var TIME_REGEXP = /^(\d\d):(\d\d)(?::(\d\d)(\.\d{1,3})?)?$/;
+
+var PARTIAL_VALIDATION_EVENTS = 'keydown wheel mousedown';
+var PARTIAL_VALIDATION_TYPES = createMap();
+forEach('date,datetime-local,month,time,week'.split(','), function(type) {
+ PARTIAL_VALIDATION_TYPES[type] = true;
+});
+
+var inputType = {
+
+ /**
+ * @ngdoc input
+ * @name input[text]
+ *
+ * @description
+ * Standard HTML text input with AngularJS data binding, inherited by most of the `input` elements.
+ *
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} required Adds `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
+ * minlength.
+ * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
+ * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
+ * any length.
+ * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
+ * that contains the regular expression body that will be converted to a regular expression
+ * as in the ngPattern directive.
+ * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
+ * does not match a RegExp found by evaluating the AngularJS expression given in the attribute value.
+ * If the expression evaluates to a RegExp object, then this is used directly.
+ * If the expression evaluates to a string, then it will be converted to a RegExp
+ * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to
+ * `new RegExp('^abc$')`.<br />
+ * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ * start at the index of the last search's match, thus not taking the whole input value into
+ * account.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ * @param {boolean=} [ngTrim=true] If set to false AngularJS will not automatically trim the input.
+ * This parameter is ignored for input[type=password] controls, which will never trim the
+ * input.
+ *
+ * @example
+ <example name="text-input-directive" module="textInputExample">
+ <file name="index.html">
+ <script>
+ angular.module('textInputExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.example = {
+ text: 'guest',
+ word: /^\s*\w*\s*$/
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="ExampleController">
+ <label>Single word:
+ <input type="text" name="input" ng-model="example.text"
+ ng-pattern="example.word" required ng-trim="false">
+ </label>
+ <div role="alert">
+ <span class="error" ng-show="myForm.input.$error.required">
+ Required!</span>
+ <span class="error" ng-show="myForm.input.$error.pattern">
+ Single word only!</span>
+ </div>
+ <code>text = {{example.text}}</code><br/>
+ <code>myForm.input.$valid = {{myForm.input.$valid}}</code><br/>
+ <code>myForm.input.$error = {{myForm.input.$error}}</code><br/>
+ <code>myForm.$valid = {{myForm.$valid}}</code><br/>
+ <code>myForm.$error.required = {{!!myForm.$error.required}}</code><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var text = element(by.binding('example.text'));
+ var valid = element(by.binding('myForm.input.$valid'));
+ var input = element(by.model('example.text'));
+
+ it('should initialize to model', function() {
+ expect(text.getText()).toContain('guest');
+ expect(valid.getText()).toContain('true');
+ });
+
+ it('should be invalid if empty', function() {
+ input.clear();
+ input.sendKeys('');
+
+ expect(text.getText()).toEqual('text =');
+ expect(valid.getText()).toContain('false');
+ });
+
+ it('should be invalid if multi word', function() {
+ input.clear();
+ input.sendKeys('hello world');
+
+ expect(valid.getText()).toContain('false');
+ });
+ </file>
+ </example>
+ */
+ 'text': textInputType,
+
+ /**
+ * @ngdoc input
+ * @name input[date]
+ *
+ * @description
+ * Input with date validation and transformation. In browsers that do not yet support
+ * the HTML5 date input, a text element will be used. In that case, text must be entered in a valid ISO-8601
+ * date format (yyyy-MM-dd), for example: `2009-01-06`. Since many
+ * modern browsers do not yet support this input type, it is important to provide cues to users on the
+ * expected input format via a placeholder or label.
+ *
+ * The model must always be a Date object, otherwise AngularJS will throw an error.
+ * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
+ *
+ * The timezone to be used to read/write the `Date` instance in the model can be defined using
+ * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser.
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`. This must be a
+ * valid ISO date string (yyyy-MM-dd). You can also use interpolation inside this attribute
+ * (e.g. `min="{{minDate | date:'yyyy-MM-dd'}}"`). Note that `min` will also add native HTML5
+ * constraint validation.
+ * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`. This must be
+ * a valid ISO date string (yyyy-MM-dd). You can also use interpolation inside this attribute
+ * (e.g. `max="{{maxDate | date:'yyyy-MM-dd'}}"`). Note that `max` will also add native HTML5
+ * constraint validation.
+ * @param {(date|string)=} ngMin Sets the `min` validation constraint to the Date / ISO date string
+ * the `ngMin` expression evaluates to. Note that it does not set the `min` attribute.
+ * @param {(date|string)=} ngMax Sets the `max` validation constraint to the Date / ISO date string
+ * the `ngMax` expression evaluates to. Note that it does not set the `max` attribute.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ *
+ * @example
+ <example name="date-input-directive" module="dateInputExample">
+ <file name="index.html">
+ <script>
+ angular.module('dateInputExample', [])
+ .controller('DateController', ['$scope', function($scope) {
+ $scope.example = {
+ value: new Date(2013, 9, 22)
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="DateController as dateCtrl">
+ <label for="exampleInput">Pick a date in 2013:</label>
+ <input type="date" id="exampleInput" name="input" ng-model="example.value"
+ placeholder="yyyy-MM-dd" min="2013-01-01" max="2013-12-31" required />
+ <div role="alert">
+ <span class="error" ng-show="myForm.input.$error.required">
+ Required!</span>
+ <span class="error" ng-show="myForm.input.$error.date">
+ Not a valid date!</span>
+ </div>
+ <tt>value = {{example.value | date: "yyyy-MM-dd"}}</tt><br/>
+ <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
+ <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
+ <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var value = element(by.binding('example.value | date: "yyyy-MM-dd"'));
+ var valid = element(by.binding('myForm.input.$valid'));
+
+ // currently protractor/webdriver does not support
+ // sending keys to all known HTML5 input controls
+ // for various browsers (see https://github.com/angular/protractor/issues/562).
+ function setInput(val) {
+ // set the value of the element and force validation.
+ var scr = "var ipt = document.getElementById('exampleInput'); " +
+ "ipt.value = '" + val + "';" +
+ "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });";
+ browser.executeScript(scr);
+ }
+
+ it('should initialize to model', function() {
+ expect(value.getText()).toContain('2013-10-22');
+ expect(valid.getText()).toContain('myForm.input.$valid = true');
+ });
+
+ it('should be invalid if empty', function() {
+ setInput('');
+ expect(value.getText()).toEqual('value =');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+
+ it('should be invalid if over max', function() {
+ setInput('2015-01-01');
+ expect(value.getText()).toContain('');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+ </file>
+ </example>
+ */
+ 'date': createDateInputType('date', DATE_REGEXP,
+ createDateParser(DATE_REGEXP, ['yyyy', 'MM', 'dd']),
+ 'yyyy-MM-dd'),
+
+ /**
+ * @ngdoc input
+ * @name input[datetime-local]
+ *
+ * @description
+ * Input with datetime validation and transformation. In browsers that do not yet support
+ * the HTML5 date input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
+ * local datetime format (yyyy-MM-ddTHH:mm:ss), for example: `2010-12-28T14:57:00`.
+ *
+ * The model must always be a Date object, otherwise AngularJS will throw an error.
+ * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
+ *
+ * The timezone to be used to read/write the `Date` instance in the model can be defined using
+ * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser.
+ *
+ * The format of the displayed time can be adjusted with the
+ * {@link ng.directive:ngModelOptions#ngModelOptions-arguments ngModelOptions} `timeSecondsFormat`
+ * and `timeStripZeroSeconds`.
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`.
+ * This must be a valid ISO datetime format (yyyy-MM-ddTHH:mm:ss). You can also use interpolation
+ * inside this attribute (e.g. `min="{{minDatetimeLocal | date:'yyyy-MM-ddTHH:mm:ss'}}"`).
+ * Note that `min` will also add native HTML5 constraint validation.
+ * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`.
+ * This must be a valid ISO datetime format (yyyy-MM-ddTHH:mm:ss). You can also use interpolation
+ * inside this attribute (e.g. `max="{{maxDatetimeLocal | date:'yyyy-MM-ddTHH:mm:ss'}}"`).
+ * Note that `max` will also add native HTML5 constraint validation.
+ * @param {(date|string)=} ngMin Sets the `min` validation error key to the Date / ISO datetime string
+ * the `ngMin` expression evaluates to. Note that it does not set the `min` attribute.
+ * @param {(date|string)=} ngMax Sets the `max` validation error key to the Date / ISO datetime string
+ * the `ngMax` expression evaluates to. Note that it does not set the `max` attribute.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ *
+ * @example
+ <example name="datetimelocal-input-directive" module="dateExample">
+ <file name="index.html">
+ <script>
+ angular.module('dateExample', [])
+ .controller('DateController', ['$scope', function($scope) {
+ $scope.example = {
+ value: new Date(2010, 11, 28, 14, 57)
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="DateController as dateCtrl">
+ <label for="exampleInput">Pick a date between in 2013:</label>
+ <input type="datetime-local" id="exampleInput" name="input" ng-model="example.value"
+ placeholder="yyyy-MM-ddTHH:mm:ss" min="2001-01-01T00:00:00" max="2013-12-31T00:00:00" required />
+ <div role="alert">
+ <span class="error" ng-show="myForm.input.$error.required">
+ Required!</span>
+ <span class="error" ng-show="myForm.input.$error.datetimelocal">
+ Not a valid date!</span>
+ </div>
+ <tt>value = {{example.value | date: "yyyy-MM-ddTHH:mm:ss"}}</tt><br/>
+ <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
+ <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
+ <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var value = element(by.binding('example.value | date: "yyyy-MM-ddTHH:mm:ss"'));
+ var valid = element(by.binding('myForm.input.$valid'));
+
+ // currently protractor/webdriver does not support
+ // sending keys to all known HTML5 input controls
+ // for various browsers (https://github.com/angular/protractor/issues/562).
+ function setInput(val) {
+ // set the value of the element and force validation.
+ var scr = "var ipt = document.getElementById('exampleInput'); " +
+ "ipt.value = '" + val + "';" +
+ "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });";
+ browser.executeScript(scr);
+ }
+
+ it('should initialize to model', function() {
+ expect(value.getText()).toContain('2010-12-28T14:57:00');
+ expect(valid.getText()).toContain('myForm.input.$valid = true');
+ });
+
+ it('should be invalid if empty', function() {
+ setInput('');
+ expect(value.getText()).toEqual('value =');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+
+ it('should be invalid if over max', function() {
+ setInput('2015-01-01T23:59:00');
+ expect(value.getText()).toContain('');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+ </file>
+ </example>
+ */
+ 'datetime-local': createDateInputType('datetimelocal', DATETIMELOCAL_REGEXP,
+ createDateParser(DATETIMELOCAL_REGEXP, ['yyyy', 'MM', 'dd', 'HH', 'mm', 'ss', 'sss']),
+ 'yyyy-MM-ddTHH:mm:ss.sss'),
+
+ /**
+ * @ngdoc input
+ * @name input[time]
+ *
+ * @description
+ * Input with time validation and transformation. In browsers that do not yet support
+ * the HTML5 time input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
+ * local time format (HH:mm:ss), for example: `14:57:00`. Model must be a Date object. This binding will always output a
+ * Date object to the model of January 1, 1970, or local date `new Date(1970, 0, 1, HH, mm, ss)`.
+ *
+ * The model must always be a Date object, otherwise AngularJS will throw an error.
+ * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
+ *
+ * The timezone to be used to read/write the `Date` instance in the model can be defined using
+ * {@link ng.directive:ngModelOptions#ngModelOptions-arguments ngModelOptions}. By default,
+ * this is the timezone of the browser.
+ *
+ * The format of the displayed time can be adjusted with the
+ * {@link ng.directive:ngModelOptions#ngModelOptions-arguments ngModelOptions} `timeSecondsFormat`
+ * and `timeStripZeroSeconds`.
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`.
+ * This must be a valid ISO time format (HH:mm:ss). You can also use interpolation inside this
+ * attribute (e.g. `min="{{minTime | date:'HH:mm:ss'}}"`). Note that `min` will also add
+ * native HTML5 constraint validation.
+ * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`.
+ * This must be a valid ISO time format (HH:mm:ss). You can also use interpolation inside this
+ * attribute (e.g. `max="{{maxTime | date:'HH:mm:ss'}}"`). Note that `max` will also add
+ * native HTML5 constraint validation.
+ * @param {(date|string)=} ngMin Sets the `min` validation constraint to the Date / ISO time string the
+ * `ngMin` expression evaluates to. Note that it does not set the `min` attribute.
+ * @param {(date|string)=} ngMax Sets the `max` validation constraint to the Date / ISO time string the
+ * `ngMax` expression evaluates to. Note that it does not set the `max` attribute.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ *
+ * @example
+ <example name="time-input-directive" module="timeExample">
+ <file name="index.html">
+ <script>
+ angular.module('timeExample', [])
+ .controller('DateController', ['$scope', function($scope) {
+ $scope.example = {
+ value: new Date(1970, 0, 1, 14, 57, 0)
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="DateController as dateCtrl">
+ <label for="exampleInput">Pick a time between 8am and 5pm:</label>
+ <input type="time" id="exampleInput" name="input" ng-model="example.value"
+ placeholder="HH:mm:ss" min="08:00:00" max="17:00:00" required />
+ <div role="alert">
+ <span class="error" ng-show="myForm.input.$error.required">
+ Required!</span>
+ <span class="error" ng-show="myForm.input.$error.time">
+ Not a valid date!</span>
+ </div>
+ <tt>value = {{example.value | date: "HH:mm:ss"}}</tt><br/>
+ <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
+ <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
+ <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var value = element(by.binding('example.value | date: "HH:mm:ss"'));
+ var valid = element(by.binding('myForm.input.$valid'));
+
+ // currently protractor/webdriver does not support
+ // sending keys to all known HTML5 input controls
+ // for various browsers (https://github.com/angular/protractor/issues/562).
+ function setInput(val) {
+ // set the value of the element and force validation.
+ var scr = "var ipt = document.getElementById('exampleInput'); " +
+ "ipt.value = '" + val + "';" +
+ "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });";
+ browser.executeScript(scr);
+ }
+
+ it('should initialize to model', function() {
+ expect(value.getText()).toContain('14:57:00');
+ expect(valid.getText()).toContain('myForm.input.$valid = true');
+ });
+
+ it('should be invalid if empty', function() {
+ setInput('');
+ expect(value.getText()).toEqual('value =');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+
+ it('should be invalid if over max', function() {
+ setInput('23:59:00');
+ expect(value.getText()).toContain('');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+ </file>
+ </example>
+ */
+ 'time': createDateInputType('time', TIME_REGEXP,
+ createDateParser(TIME_REGEXP, ['HH', 'mm', 'ss', 'sss']),
+ 'HH:mm:ss.sss'),
+
+ /**
+ * @ngdoc input
+ * @name input[week]
+ *
+ * @description
+ * Input with week-of-the-year validation and transformation to Date. In browsers that do not yet support
+ * the HTML5 week input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
+ * week format (yyyy-W##), for example: `2013-W02`.
+ *
+ * The model must always be a Date object, otherwise AngularJS will throw an error.
+ * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
+ *
+ * The value of the resulting Date object will be set to Thursday at 00:00:00 of the requested week,
+ * due to ISO-8601 week numbering standards. Information on ISO's system for numbering the weeks of the
+ * year can be found at: https://en.wikipedia.org/wiki/ISO_8601#Week_dates
+ *
+ * The timezone to be used to read/write the `Date` instance in the model can be defined using
+ * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser.
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`.
+ * This must be a valid ISO week format (yyyy-W##). You can also use interpolation inside this
+ * attribute (e.g. `min="{{minWeek | date:'yyyy-Www'}}"`). Note that `min` will also add
+ * native HTML5 constraint validation.
+ * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`.
+ * This must be a valid ISO week format (yyyy-W##). You can also use interpolation inside this
+ * attribute (e.g. `max="{{maxWeek | date:'yyyy-Www'}}"`). Note that `max` will also add
+ * native HTML5 constraint validation.
+ * @param {(date|string)=} ngMin Sets the `min` validation constraint to the Date / ISO week string
+ * the `ngMin` expression evaluates to. Note that it does not set the `min` attribute.
+ * @param {(date|string)=} ngMax Sets the `max` validation constraint to the Date / ISO week string
+ * the `ngMax` expression evaluates to. Note that it does not set the `max` attribute.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ *
+ * @example
+ <example name="week-input-directive" module="weekExample">
+ <file name="index.html">
+ <script>
+ angular.module('weekExample', [])
+ .controller('DateController', ['$scope', function($scope) {
+ $scope.example = {
+ value: new Date(2013, 0, 3)
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="DateController as dateCtrl">
+ <label>Pick a date between in 2013:
+ <input id="exampleInput" type="week" name="input" ng-model="example.value"
+ placeholder="YYYY-W##" min="2012-W32"
+ max="2013-W52" required />
+ </label>
+ <div role="alert">
+ <span class="error" ng-show="myForm.input.$error.required">
+ Required!</span>
+ <span class="error" ng-show="myForm.input.$error.week">
+ Not a valid date!</span>
+ </div>
+ <tt>value = {{example.value | date: "yyyy-Www"}}</tt><br/>
+ <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
+ <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
+ <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var value = element(by.binding('example.value | date: "yyyy-Www"'));
+ var valid = element(by.binding('myForm.input.$valid'));
+
+ // currently protractor/webdriver does not support
+ // sending keys to all known HTML5 input controls
+ // for various browsers (https://github.com/angular/protractor/issues/562).
+ function setInput(val) {
+ // set the value of the element and force validation.
+ var scr = "var ipt = document.getElementById('exampleInput'); " +
+ "ipt.value = '" + val + "';" +
+ "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });";
+ browser.executeScript(scr);
+ }
+
+ it('should initialize to model', function() {
+ expect(value.getText()).toContain('2013-W01');
+ expect(valid.getText()).toContain('myForm.input.$valid = true');
+ });
+
+ it('should be invalid if empty', function() {
+ setInput('');
+ expect(value.getText()).toEqual('value =');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+
+ it('should be invalid if over max', function() {
+ setInput('2015-W01');
+ expect(value.getText()).toContain('');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+ </file>
+ </example>
+ */
+ 'week': createDateInputType('week', WEEK_REGEXP, weekParser, 'yyyy-Www'),
+
+ /**
+ * @ngdoc input
+ * @name input[month]
+ *
+ * @description
+ * Input with month validation and transformation. In browsers that do not yet support
+ * the HTML5 month input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
+ * month format (yyyy-MM), for example: `2009-01`.
+ *
+ * The model must always be a Date object, otherwise AngularJS will throw an error.
+ * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
+ * If the model is not set to the first of the month, the next view to model update will set it
+ * to the first of the month.
+ *
+ * The timezone to be used to read/write the `Date` instance in the model can be defined using
+ * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser.
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`.
+ * This must be a valid ISO month format (yyyy-MM). You can also use interpolation inside this
+ * attribute (e.g. `min="{{minMonth | date:'yyyy-MM'}}"`). Note that `min` will also add
+ * native HTML5 constraint validation.
+ * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`.
+ * This must be a valid ISO month format (yyyy-MM). You can also use interpolation inside this
+ * attribute (e.g. `max="{{maxMonth | date:'yyyy-MM'}}"`). Note that `max` will also add
+ * native HTML5 constraint validation.
+ * @param {(date|string)=} ngMin Sets the `min` validation constraint to the Date / ISO week string
+ * the `ngMin` expression evaluates to. Note that it does not set the `min` attribute.
+ * @param {(date|string)=} ngMax Sets the `max` validation constraint to the Date / ISO week string
+ * the `ngMax` expression evaluates to. Note that it does not set the `max` attribute.
+
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ *
+ * @example
+ <example name="month-input-directive" module="monthExample">
+ <file name="index.html">
+ <script>
+ angular.module('monthExample', [])
+ .controller('DateController', ['$scope', function($scope) {
+ $scope.example = {
+ value: new Date(2013, 9, 1)
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="DateController as dateCtrl">
+ <label for="exampleInput">Pick a month in 2013:</label>
+ <input id="exampleInput" type="month" name="input" ng-model="example.value"
+ placeholder="yyyy-MM" min="2013-01" max="2013-12" required />
+ <div role="alert">
+ <span class="error" ng-show="myForm.input.$error.required">
+ Required!</span>
+ <span class="error" ng-show="myForm.input.$error.month">
+ Not a valid month!</span>
+ </div>
+ <tt>value = {{example.value | date: "yyyy-MM"}}</tt><br/>
+ <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
+ <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
+ <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var value = element(by.binding('example.value | date: "yyyy-MM"'));
+ var valid = element(by.binding('myForm.input.$valid'));
+
+ // currently protractor/webdriver does not support
+ // sending keys to all known HTML5 input controls
+ // for various browsers (https://github.com/angular/protractor/issues/562).
+ function setInput(val) {
+ // set the value of the element and force validation.
+ var scr = "var ipt = document.getElementById('exampleInput'); " +
+ "ipt.value = '" + val + "';" +
+ "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });";
+ browser.executeScript(scr);
+ }
+
+ it('should initialize to model', function() {
+ expect(value.getText()).toContain('2013-10');
+ expect(valid.getText()).toContain('myForm.input.$valid = true');
+ });
+
+ it('should be invalid if empty', function() {
+ setInput('');
+ expect(value.getText()).toEqual('value =');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+
+ it('should be invalid if over max', function() {
+ setInput('2015-01');
+ expect(value.getText()).toContain('');
+ expect(valid.getText()).toContain('myForm.input.$valid = false');
+ });
+ </file>
+ </example>
+ */
+ 'month': createDateInputType('month', MONTH_REGEXP,
+ createDateParser(MONTH_REGEXP, ['yyyy', 'MM']),
+ 'yyyy-MM'),
+
+ /**
+ * @ngdoc input
+ * @name input[number]
+ *
+ * @description
+ * Text input with number validation and transformation. Sets the `number` validation
+ * error if not a valid number.
+ *
+ * <div class="alert alert-warning">
+ * The model must always be of type `number` otherwise AngularJS will throw an error.
+ * Be aware that a string containing a number is not enough. See the {@link ngModel:numfmt}
+ * error docs for more information and an example of how to convert your model if necessary.
+ * </div>
+ *
+ *
+ *
+ * @knownIssue
+ *
+ * ### HTML5 constraint validation and `allowInvalid`
+ *
+ * In browsers that follow the
+ * [HTML5 specification](https://html.spec.whatwg.org/multipage/forms.html#number-state-%28type=number%29),
+ * `input[number]` does not work as expected with {@link ngModelOptions `ngModelOptions.allowInvalid`}.
+ * If a non-number is entered in the input, the browser will report the value as an empty string,
+ * which means the view / model values in `ngModel` and subsequently the scope value
+ * will also be an empty string.
+ *
+ * @knownIssue
+ *
+ * ### Large numbers and `step` validation
+ *
+ * The `step` validation will not work correctly for very large numbers (e.g. 9999999999) due to
+ * Javascript's arithmetic limitations. If you need to handle large numbers, purpose-built
+ * libraries (e.g. https://github.com/MikeMcl/big.js/), can be included into AngularJS by
+ * {@link guide/forms#modifying-built-in-validators overwriting the validators}
+ * for `number` and / or `step`, or by {@link guide/forms#custom-validation applying custom validators}
+ * to an `input[text]` element. The source for `input[number]` type can be used as a starting
+ * point for both implementations.
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`.
+ * Can be interpolated.
+ * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`.
+ * Can be interpolated.
+ * @param {string=} ngMin Like `min`, sets the `min` validation error key if the value entered is less than `ngMin`,
+ * but does not trigger HTML5 native validation. Takes an expression.
+ * @param {string=} ngMax Like `max`, sets the `max` validation error key if the value entered is greater than `ngMax`,
+ * but does not trigger HTML5 native validation. Takes an expression.
+ * @param {string=} step Sets the `step` validation error key if the value entered does not fit the `step` constraint.
+ * Can be interpolated.
+ * @param {string=} ngStep Like `step`, sets the `step` validation error key if the value entered does not fit the `ngStep` constraint,
+ * but does not trigger HTML5 native validation. Takes an expression.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
+ * minlength.
+ * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
+ * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
+ * any length.
+ * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
+ * that contains the regular expression body that will be converted to a regular expression
+ * as in the ngPattern directive.
+ * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
+ * does not match a RegExp found by evaluating the AngularJS expression given in the attribute value.
+ * If the expression evaluates to a RegExp object, then this is used directly.
+ * If the expression evaluates to a string, then it will be converted to a RegExp
+ * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to
+ * `new RegExp('^abc$')`.<br />
+ * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ * start at the index of the last search's match, thus not taking the whole input value into
+ * account.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ *
+ * @example
+ <example name="number-input-directive" module="numberExample">
+ <file name="index.html">
+ <script>
+ angular.module('numberExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.example = {
+ value: 12
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="ExampleController">
+ <label>Number:
+ <input type="number" name="input" ng-model="example.value"
+ min="0" max="99" required>
+ </label>
+ <div role="alert">
+ <span class="error" ng-show="myForm.input.$error.required">
+ Required!</span>
+ <span class="error" ng-show="myForm.input.$error.number">
+ Not valid number!</span>
+ </div>
+ <tt>value = {{example.value}}</tt><br/>
+ <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
+ <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
+ <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var value = element(by.binding('example.value'));
+ var valid = element(by.binding('myForm.input.$valid'));
+ var input = element(by.model('example.value'));
+
+ it('should initialize to model', function() {
+ expect(value.getText()).toContain('12');
+ expect(valid.getText()).toContain('true');
+ });
+
+ it('should be invalid if empty', function() {
+ input.clear();
+ input.sendKeys('');
+ expect(value.getText()).toEqual('value =');
+ expect(valid.getText()).toContain('false');
+ });
+
+ it('should be invalid if over max', function() {
+ input.clear();
+ input.sendKeys('123');
+ expect(value.getText()).toEqual('value =');
+ expect(valid.getText()).toContain('false');
+ });
+ </file>
+ </example>
+ */
+ 'number': numberInputType,
+
+
+ /**
+ * @ngdoc input
+ * @name input[url]
+ *
+ * @description
+ * Text input with URL validation. Sets the `url` validation error key if the content is not a
+ * valid URL.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** `input[url]` uses a regex to validate urls that is derived from the regex
+ * used in Chromium. If you need stricter validation, you can use `ng-pattern` or modify
+ * the built-in validators (see the {@link guide/forms Forms guide})
+ * </div>
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
+ * minlength.
+ * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
+ * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
+ * any length.
+ * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
+ * that contains the regular expression body that will be converted to a regular expression
+ * as in the ngPattern directive.
+ * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
+ * does not match a RegExp found by evaluating the AngularJS expression given in the attribute value.
+ * If the expression evaluates to a RegExp object, then this is used directly.
+ * If the expression evaluates to a string, then it will be converted to a RegExp
+ * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to
+ * `new RegExp('^abc$')`.<br />
+ * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ * start at the index of the last search's match, thus not taking the whole input value into
+ * account.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ *
+ * @example
+ <example name="url-input-directive" module="urlExample">
+ <file name="index.html">
+ <script>
+ angular.module('urlExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.url = {
+ text: 'http://google.com'
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="ExampleController">
+ <label>URL:
+ <input type="url" name="input" ng-model="url.text" required>
+ <label>
+ <div role="alert">
+ <span class="error" ng-show="myForm.input.$error.required">
+ Required!</span>
+ <span class="error" ng-show="myForm.input.$error.url">
+ Not valid url!</span>
+ </div>
+ <tt>text = {{url.text}}</tt><br/>
+ <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
+ <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
+ <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ <tt>myForm.$error.url = {{!!myForm.$error.url}}</tt><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var text = element(by.binding('url.text'));
+ var valid = element(by.binding('myForm.input.$valid'));
+ var input = element(by.model('url.text'));
+
+ it('should initialize to model', function() {
+ expect(text.getText()).toContain('http://google.com');
+ expect(valid.getText()).toContain('true');
+ });
+
+ it('should be invalid if empty', function() {
+ input.clear();
+ input.sendKeys('');
+
+ expect(text.getText()).toEqual('text =');
+ expect(valid.getText()).toContain('false');
+ });
+
+ it('should be invalid if not url', function() {
+ input.clear();
+ input.sendKeys('box');
+
+ expect(valid.getText()).toContain('false');
+ });
+ </file>
+ </example>
+ */
+ 'url': urlInputType,
+
+
+ /**
+ * @ngdoc input
+ * @name input[email]
+ *
+ * @description
+ * Text input with email validation. Sets the `email` validation error key if not a valid email
+ * address.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** `input[email]` uses a regex to validate email addresses that is derived from the regex
+ * used in Chromium, which may not fulfill your app's requirements.
+ * If you need stricter (e.g. requiring a top-level domain), or more relaxed validation
+ * (e.g. allowing IPv6 address literals) you can use `ng-pattern` or
+ * modify the built-in validators (see the {@link guide/forms Forms guide}).
+ * </div>
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
+ * minlength.
+ * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
+ * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
+ * any length.
+ * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
+ * that contains the regular expression body that will be converted to a regular expression
+ * as in the ngPattern directive.
+ * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
+ * does not match a RegExp found by evaluating the AngularJS expression given in the attribute value.
+ * If the expression evaluates to a RegExp object, then this is used directly.
+ * If the expression evaluates to a string, then it will be converted to a RegExp
+ * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to
+ * `new RegExp('^abc$')`.<br />
+ * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ * start at the index of the last search's match, thus not taking the whole input value into
+ * account.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ *
+ * @example
+ <example name="email-input-directive" module="emailExample">
+ <file name="index.html">
+ <script>
+ angular.module('emailExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.email = {
+ text: 'me@example.com'
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="ExampleController">
+ <label>Email:
+ <input type="email" name="input" ng-model="email.text" required>
+ </label>
+ <div role="alert">
+ <span class="error" ng-show="myForm.input.$error.required">
+ Required!</span>
+ <span class="error" ng-show="myForm.input.$error.email">
+ Not valid email!</span>
+ </div>
+ <tt>text = {{email.text}}</tt><br/>
+ <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
+ <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
+ <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ <tt>myForm.$error.email = {{!!myForm.$error.email}}</tt><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var text = element(by.binding('email.text'));
+ var valid = element(by.binding('myForm.input.$valid'));
+ var input = element(by.model('email.text'));
+
+ it('should initialize to model', function() {
+ expect(text.getText()).toContain('me@example.com');
+ expect(valid.getText()).toContain('true');
+ });
+
+ it('should be invalid if empty', function() {
+ input.clear();
+ input.sendKeys('');
+ expect(text.getText()).toEqual('text =');
+ expect(valid.getText()).toContain('false');
+ });
+
+ it('should be invalid if not email', function() {
+ input.clear();
+ input.sendKeys('xxx');
+
+ expect(valid.getText()).toContain('false');
+ });
+ </file>
+ </example>
+ */
+ 'email': emailInputType,
+
+
+ /**
+ * @ngdoc input
+ * @name input[radio]
+ *
+ * @description
+ * HTML radio button.
+ *
+ * **Note:**<br>
+ * All inputs controlled by {@link ngModel ngModel} (including those of type `radio`) will use the
+ * value of their `name` attribute to determine the property under which their
+ * {@link ngModel.NgModelController NgModelController} will be published on the parent
+ * {@link form.FormController FormController}. Thus, if you use the same `name` for multiple
+ * inputs of a form (e.g. a group of radio inputs), only _one_ `NgModelController` will be
+ * published on the parent `FormController` under that name. The rest of the controllers will
+ * continue to work as expected, but you won't be able to access them as properties on the parent
+ * `FormController`.
+ *
+ * <div class="alert alert-info">
+ * <p>
+ * In plain HTML forms, the `name` attribute is used to identify groups of radio inputs, so
+ * that the browser can manage their state (checked/unchecked) based on the state of other
+ * inputs in the same group.
+ * </p>
+ * <p>
+ * In AngularJS forms, this is not necessary. The input's state will be updated based on the
+ * value of the underlying model data.
+ * </p>
+ * </div>
+ *
+ * <div class="alert alert-success">
+ * If you omit the `name` attribute on a radio input, `ngModel` will automatically assign it a
+ * unique name.
+ * </div>
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string} value The value to which the `ngModel` expression should be set when selected.
+ * Note that `value` only supports `string` values, i.e. the scope model needs to be a string,
+ * too. Use `ngValue` if you need complex models (`number`, `object`, ...).
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ * @param {string} ngValue AngularJS expression to which `ngModel` will be be set when the radio
+ * is selected. Should be used instead of the `value` attribute if you need
+ * a non-string `ngModel` (`boolean`, `array`, ...).
+ *
+ * @example
+ <example name="radio-input-directive" module="radioExample">
+ <file name="index.html">
+ <script>
+ angular.module('radioExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.color = {
+ name: 'blue'
+ };
+ $scope.specialValue = {
+ "id": "12345",
+ "value": "green"
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="ExampleController">
+ <label>
+ <input type="radio" ng-model="color.name" value="red">
+ Red
+ </label><br/>
+ <label>
+ <input type="radio" ng-model="color.name" ng-value="specialValue">
+ Green
+ </label><br/>
+ <label>
+ <input type="radio" ng-model="color.name" value="blue">
+ Blue
+ </label><br/>
+ <tt>color = {{color.name | json}}</tt><br/>
+ </form>
+ Note that `ng-value="specialValue"` sets radio item's value to be the value of `$scope.specialValue`.
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should change state', function() {
+ var inputs = element.all(by.model('color.name'));
+ var color = element(by.binding('color.name'));
+
+ expect(color.getText()).toContain('blue');
+
+ inputs.get(0).click();
+ expect(color.getText()).toContain('red');
+
+ inputs.get(1).click();
+ expect(color.getText()).toContain('green');
+ });
+ </file>
+ </example>
+ */
+ 'radio': radioInputType,
+
+ /**
+ * @ngdoc input
+ * @name input[range]
+ *
+ * @description
+ * Native range input with validation and transformation.
+ *
+ * The model for the range input must always be a `Number`.
+ *
+ * IE9 and other browsers that do not support the `range` type fall back
+ * to a text input without any default values for `min`, `max` and `step`. Model binding,
+ * validation and number parsing are nevertheless supported.
+ *
+ * Browsers that support range (latest Chrome, Safari, Firefox, Edge) treat `input[range]`
+ * in a way that never allows the input to hold an invalid value. That means:
+ * - any non-numerical value is set to `(max + min) / 2`.
+ * - any numerical value that is less than the current min val, or greater than the current max val
+ * is set to the min / max val respectively.
+ * - additionally, the current `step` is respected, so the nearest value that satisfies a step
+ * is used.
+ *
+ * See the [HTML Spec on input[type=range]](https://www.w3.org/TR/html5/forms.html#range-state-(type=range))
+ * for more info.
+ *
+ * This has the following consequences for AngularJS:
+ *
+ * Since the element value should always reflect the current model value, a range input
+ * will set the bound ngModel expression to the value that the browser has set for the
+ * input element. For example, in the following input `<input type="range" ng-model="model.value">`,
+ * if the application sets `model.value = null`, the browser will set the input to `'50'`.
+ * AngularJS will then set the model to `50`, to prevent input and model value being out of sync.
+ *
+ * That means the model for range will immediately be set to `50` after `ngModel` has been
+ * initialized. It also means a range input can never have the required error.
+ *
+ * This does not only affect changes to the model value, but also to the values of the `min`,
+ * `max`, and `step` attributes. When these change in a way that will cause the browser to modify
+ * the input value, AngularJS will also update the model value.
+ *
+ * Automatic value adjustment also means that a range input element can never have the `required`,
+ * `min`, or `max` errors.
+ *
+ * However, `step` is currently only fully implemented by Firefox. Other browsers have problems
+ * when the step value changes dynamically - they do not adjust the element value correctly, but
+ * instead may set the `stepMismatch` error. If that's the case, the AngularJS will set the `step`
+ * error on the input, and set the model to `undefined`.
+ *
+ * Note that `input[range]` is not compatible with`ngMax`, `ngMin`, and `ngStep`, because they do
+ * not set the `min` and `max` attributes, which means that the browser won't automatically adjust
+ * the input value based on their values, and will always assume min = 0, max = 100, and step = 1.
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} min Sets the `min` validation to ensure that the value entered is greater
+ * than `min`. Can be interpolated.
+ * @param {string=} max Sets the `max` validation to ensure that the value entered is less than `max`.
+ * Can be interpolated.
+ * @param {string=} step Sets the `step` validation to ensure that the value entered matches the `step`
+ * Can be interpolated.
+ * @param {expression=} ngChange AngularJS expression to be executed when the ngModel value changes due
+ * to user interaction with the input element.
+ * @param {expression=} ngChecked If the expression is truthy, then the `checked` attribute will be set on the
+ * element. **Note** : `ngChecked` should not be used alongside `ngModel`.
+ * Checkout {@link ng.directive:ngChecked ngChecked} for usage.
+ *
+ * @example
+ <example name="range-input-directive" module="rangeExample">
+ <file name="index.html">
+ <script>
+ angular.module('rangeExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.value = 75;
+ $scope.min = 10;
+ $scope.max = 90;
+ }]);
+ </script>
+ <form name="myForm" ng-controller="ExampleController">
+
+ Model as range: <input type="range" name="range" ng-model="value" min="{{min}}" max="{{max}}">
+ <hr>
+ Model as number: <input type="number" ng-model="value"><br>
+ Min: <input type="number" ng-model="min"><br>
+ Max: <input type="number" ng-model="max"><br>
+ value = <code>{{value}}</code><br/>
+ myForm.range.$valid = <code>{{myForm.range.$valid}}</code><br/>
+ myForm.range.$error = <code>{{myForm.range.$error}}</code>
+ </form>
+ </file>
+ </example>
+
+ * ## Range Input with ngMin & ngMax attributes
+
+ * @example
+ <example name="range-input-directive-ng" module="rangeExample">
+ <file name="index.html">
+ <script>
+ angular.module('rangeExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.value = 75;
+ $scope.min = 10;
+ $scope.max = 90;
+ }]);
+ </script>
+ <form name="myForm" ng-controller="ExampleController">
+ Model as range: <input type="range" name="range" ng-model="value" ng-min="min" ng-max="max">
+ <hr>
+ Model as number: <input type="number" ng-model="value"><br>
+ Min: <input type="number" ng-model="min"><br>
+ Max: <input type="number" ng-model="max"><br>
+ value = <code>{{value}}</code><br/>
+ myForm.range.$valid = <code>{{myForm.range.$valid}}</code><br/>
+ myForm.range.$error = <code>{{myForm.range.$error}}</code>
+ </form>
+ </file>
+ </example>
+
+ */
+ 'range': rangeInputType,
+
+ /**
+ * @ngdoc input
+ * @name input[checkbox]
+ *
+ * @description
+ * HTML checkbox.
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {expression=} ngTrueValue The value to which the expression should be set when selected.
+ * @param {expression=} ngFalseValue The value to which the expression should be set when not selected.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ *
+ * @example
+ <example name="checkbox-input-directive" module="checkboxExample">
+ <file name="index.html">
+ <script>
+ angular.module('checkboxExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.checkboxModel = {
+ value1 : true,
+ value2 : 'YES'
+ };
+ }]);
+ </script>
+ <form name="myForm" ng-controller="ExampleController">
+ <label>Value1:
+ <input type="checkbox" ng-model="checkboxModel.value1">
+ </label><br/>
+ <label>Value2:
+ <input type="checkbox" ng-model="checkboxModel.value2"
+ ng-true-value="'YES'" ng-false-value="'NO'">
+ </label><br/>
+ <tt>value1 = {{checkboxModel.value1}}</tt><br/>
+ <tt>value2 = {{checkboxModel.value2}}</tt><br/>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should change state', function() {
+ var value1 = element(by.binding('checkboxModel.value1'));
+ var value2 = element(by.binding('checkboxModel.value2'));
+
+ expect(value1.getText()).toContain('true');
+ expect(value2.getText()).toContain('YES');
+
+ element(by.model('checkboxModel.value1')).click();
+ element(by.model('checkboxModel.value2')).click();
+
+ expect(value1.getText()).toContain('false');
+ expect(value2.getText()).toContain('NO');
+ });
+ </file>
+ </example>
+ */
+ 'checkbox': checkboxInputType,
+
+ 'hidden': noop,
+ 'button': noop,
+ 'submit': noop,
+ 'reset': noop,
+ 'file': noop
+};
+
+function stringBasedInputType(ctrl) {
+ ctrl.$formatters.push(function(value) {
+ return ctrl.$isEmpty(value) ? value : value.toString();
+ });
+}
+
+function textInputType(scope, element, attr, ctrl, $sniffer, $browser) {
+ baseInputType(scope, element, attr, ctrl, $sniffer, $browser);
+ stringBasedInputType(ctrl);
+}
+
+function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
+ var type = lowercase(element[0].type);
+
+ // In composition mode, users are still inputting intermediate text buffer,
+ // hold the listener until composition is done.
+ // More about composition events: https://developer.mozilla.org/en-US/docs/Web/API/CompositionEvent
+ if (!$sniffer.android) {
+ var composing = false;
+
+ element.on('compositionstart', function() {
+ composing = true;
+ });
+
+ // Support: IE9+
+ element.on('compositionupdate', function(ev) {
+ // End composition when ev.data is empty string on 'compositionupdate' event.
+ // When the input de-focusses (e.g. by clicking away), IE triggers 'compositionupdate'
+ // instead of 'compositionend'.
+ if (isUndefined(ev.data) || ev.data === '') {
+ composing = false;
+ }
+ });
+
+ element.on('compositionend', function() {
+ composing = false;
+ listener();
+ });
+ }
+
+ var timeout;
+
+ var listener = function(ev) {
+ if (timeout) {
+ $browser.defer.cancel(timeout);
+ timeout = null;
+ }
+ if (composing) return;
+ var value = element.val(),
+ event = ev && ev.type;
+
+ // By default we will trim the value
+ // If the attribute ng-trim exists we will avoid trimming
+ // If input type is 'password', the value is never trimmed
+ if (type !== 'password' && (!attr.ngTrim || attr.ngTrim !== 'false')) {
+ value = trim(value);
+ }
+
+ // If a control is suffering from bad input (due to native validators), browsers discard its
+ // value, so it may be necessary to revalidate (by calling $setViewValue again) even if the
+ // control's value is the same empty value twice in a row.
+ if (ctrl.$viewValue !== value || (value === '' && ctrl.$$hasNativeValidators)) {
+ ctrl.$setViewValue(value, event);
+ }
+ };
+
+ // if the browser does support "input" event, we are fine - except on IE9 which doesn't fire the
+ // input event on backspace, delete or cut
+ if ($sniffer.hasEvent('input')) {
+ element.on('input', listener);
+ } else {
+ var deferListener = function(ev, input, origValue) {
+ if (!timeout) {
+ timeout = $browser.defer(function() {
+ timeout = null;
+ if (!input || input.value !== origValue) {
+ listener(ev);
+ }
+ });
+ }
+ };
+
+ element.on('keydown', /** @this */ function(event) {
+ var key = event.keyCode;
+
+ // ignore
+ // command modifiers arrows
+ if (key === 91 || (15 < key && key < 19) || (37 <= key && key <= 40)) return;
+
+ deferListener(event, this, this.value);
+ });
+
+ // if user modifies input value using context menu in IE, we need "paste", "cut" and "drop" events to catch it
+ if ($sniffer.hasEvent('paste')) {
+ element.on('paste cut drop', deferListener);
+ }
+ }
+
+ // if user paste into input using mouse on older browser
+ // or form autocomplete on newer browser, we need "change" event to catch it
+ element.on('change', listener);
+
+ // Some native input types (date-family) have the ability to change validity without
+ // firing any input/change events.
+ // For these event types, when native validators are present and the browser supports the type,
+ // check for validity changes on various DOM events.
+ if (PARTIAL_VALIDATION_TYPES[type] && ctrl.$$hasNativeValidators && type === attr.type) {
+ element.on(PARTIAL_VALIDATION_EVENTS, /** @this */ function(ev) {
+ if (!timeout) {
+ var validity = this[VALIDITY_STATE_PROPERTY];
+ var origBadInput = validity.badInput;
+ var origTypeMismatch = validity.typeMismatch;
+ timeout = $browser.defer(function() {
+ timeout = null;
+ if (validity.badInput !== origBadInput || validity.typeMismatch !== origTypeMismatch) {
+ listener(ev);
+ }
+ });
+ }
+ });
+ }
+
+ ctrl.$render = function() {
+ // Workaround for Firefox validation #12102.
+ var value = ctrl.$isEmpty(ctrl.$viewValue) ? '' : ctrl.$viewValue;
+ if (element.val() !== value) {
+ element.val(value);
+ }
+ };
+}
+
+function weekParser(isoWeek, existingDate) {
+ if (isDate(isoWeek)) {
+ return isoWeek;
+ }
+
+ if (isString(isoWeek)) {
+ WEEK_REGEXP.lastIndex = 0;
+ var parts = WEEK_REGEXP.exec(isoWeek);
+ if (parts) {
+ var year = +parts[1],
+ week = +parts[2],
+ hours = 0,
+ minutes = 0,
+ seconds = 0,
+ milliseconds = 0,
+ firstThurs = getFirstThursdayOfYear(year),
+ addDays = (week - 1) * 7;
+
+ if (existingDate) {
+ hours = existingDate.getHours();
+ minutes = existingDate.getMinutes();
+ seconds = existingDate.getSeconds();
+ milliseconds = existingDate.getMilliseconds();
+ }
+
+ return new Date(year, 0, firstThurs.getDate() + addDays, hours, minutes, seconds, milliseconds);
+ }
+ }
+
+ return NaN;
+}
+
+function createDateParser(regexp, mapping) {
+ return function(iso, previousDate) {
+ var parts, map;
+
+ if (isDate(iso)) {
+ return iso;
+ }
+
+ if (isString(iso)) {
+ // When a date is JSON'ified to wraps itself inside of an extra
+ // set of double quotes. This makes the date parsing code unable
+ // to match the date string and parse it as a date.
+ if (iso.charAt(0) === '"' && iso.charAt(iso.length - 1) === '"') {
+ iso = iso.substring(1, iso.length - 1);
+ }
+ if (ISO_DATE_REGEXP.test(iso)) {
+ return new Date(iso);
+ }
+ regexp.lastIndex = 0;
+ parts = regexp.exec(iso);
+
+ if (parts) {
+ parts.shift();
+ if (previousDate) {
+ map = {
+ yyyy: previousDate.getFullYear(),
+ MM: previousDate.getMonth() + 1,
+ dd: previousDate.getDate(),
+ HH: previousDate.getHours(),
+ mm: previousDate.getMinutes(),
+ ss: previousDate.getSeconds(),
+ sss: previousDate.getMilliseconds() / 1000
+ };
+ } else {
+ map = { yyyy: 1970, MM: 1, dd: 1, HH: 0, mm: 0, ss: 0, sss: 0 };
+ }
+
+ forEach(parts, function(part, index) {
+ if (index < mapping.length) {
+ map[mapping[index]] = +part;
+ }
+ });
+
+ var date = new Date(map.yyyy, map.MM - 1, map.dd, map.HH, map.mm, map.ss || 0, map.sss * 1000 || 0);
+ if (map.yyyy < 100) {
+ // In the constructor, 2-digit years map to 1900-1999.
+ // Use `setFullYear()` to set the correct year.
+ date.setFullYear(map.yyyy);
+ }
+
+ return date;
+ }
+ }
+
+ return NaN;
+ };
+}
+
+function createDateInputType(type, regexp, parseDate, format) {
+ return function dynamicDateInputType(scope, element, attr, ctrl, $sniffer, $browser, $filter, $parse) {
+ badInputChecker(scope, element, attr, ctrl, type);
+ baseInputType(scope, element, attr, ctrl, $sniffer, $browser);
+
+ var isTimeType = type === 'time' || type === 'datetimelocal';
+ var previousDate;
+ var previousTimezone;
+
+ ctrl.$parsers.push(function(value) {
+ if (ctrl.$isEmpty(value)) return null;
+
+ if (regexp.test(value)) {
+ // Note: We cannot read ctrl.$modelValue, as there might be a different
+ // parser/formatter in the processing chain so that the model
+ // contains some different data format!
+ return parseDateAndConvertTimeZoneToLocal(value, previousDate);
+ }
+ ctrl.$$parserName = type;
+ return undefined;
+ });
+
+ ctrl.$formatters.push(function(value) {
+ if (value && !isDate(value)) {
+ throw ngModelMinErr('datefmt', 'Expected `{0}` to be a date', value);
+ }
+ if (isValidDate(value)) {
+ previousDate = value;
+ var timezone = ctrl.$options.getOption('timezone');
+
+ if (timezone) {
+ previousTimezone = timezone;
+ previousDate = convertTimezoneToLocal(previousDate, timezone, true);
+ }
+
+ return formatter(value, timezone);
+ } else {
+ previousDate = null;
+ previousTimezone = null;
+ return '';
+ }
+ });
+
+ if (isDefined(attr.min) || attr.ngMin) {
+ var minVal = attr.min || $parse(attr.ngMin)(scope);
+ var parsedMinVal = parseObservedDateValue(minVal);
+
+ ctrl.$validators.min = function(value) {
+ return !isValidDate(value) || isUndefined(parsedMinVal) || parseDate(value) >= parsedMinVal;
+ };
+ attr.$observe('min', function(val) {
+ if (val !== minVal) {
+ parsedMinVal = parseObservedDateValue(val);
+ minVal = val;
+ ctrl.$validate();
+ }
+ });
+ }
+
+ if (isDefined(attr.max) || attr.ngMax) {
+ var maxVal = attr.max || $parse(attr.ngMax)(scope);
+ var parsedMaxVal = parseObservedDateValue(maxVal);
+
+ ctrl.$validators.max = function(value) {
+ return !isValidDate(value) || isUndefined(parsedMaxVal) || parseDate(value) <= parsedMaxVal;
+ };
+ attr.$observe('max', function(val) {
+ if (val !== maxVal) {
+ parsedMaxVal = parseObservedDateValue(val);
+ maxVal = val;
+ ctrl.$validate();
+ }
+ });
+ }
+
+ function isValidDate(value) {
+ // Invalid Date: getTime() returns NaN
+ return value && !(value.getTime && value.getTime() !== value.getTime());
+ }
+
+ function parseObservedDateValue(val) {
+ return isDefined(val) && !isDate(val) ? parseDateAndConvertTimeZoneToLocal(val) || undefined : val;
+ }
+
+ function parseDateAndConvertTimeZoneToLocal(value, previousDate) {
+ var timezone = ctrl.$options.getOption('timezone');
+
+ if (previousTimezone && previousTimezone !== timezone) {
+ // If the timezone has changed, adjust the previousDate to the default timezone
+ // so that the new date is converted with the correct timezone offset
+ previousDate = addDateMinutes(previousDate, timezoneToOffset(previousTimezone));
+ }
+
+ var parsedDate = parseDate(value, previousDate);
+
+ if (!isNaN(parsedDate) && timezone) {
+ parsedDate = convertTimezoneToLocal(parsedDate, timezone);
+ }
+ return parsedDate;
+ }
+
+ function formatter(value, timezone) {
+ var targetFormat = format;
+
+ if (isTimeType && isString(ctrl.$options.getOption('timeSecondsFormat'))) {
+ targetFormat = format
+ .replace('ss.sss', ctrl.$options.getOption('timeSecondsFormat'))
+ .replace(/:$/, '');
+ }
+
+ var formatted = $filter('date')(value, targetFormat, timezone);
+
+ if (isTimeType && ctrl.$options.getOption('timeStripZeroSeconds')) {
+ formatted = formatted.replace(/(?::00)?(?:\.000)?$/, '');
+ }
+
+ return formatted;
+ }
+ };
+}
+
+function badInputChecker(scope, element, attr, ctrl, parserName) {
+ var node = element[0];
+ var nativeValidation = ctrl.$$hasNativeValidators = isObject(node.validity);
+ if (nativeValidation) {
+ ctrl.$parsers.push(function(value) {
+ var validity = element.prop(VALIDITY_STATE_PROPERTY) || {};
+ if (validity.badInput || validity.typeMismatch) {
+ ctrl.$$parserName = parserName;
+ return undefined;
+ }
+
+ return value;
+ });
+ }
+}
+
+function numberFormatterParser(ctrl) {
+ ctrl.$parsers.push(function(value) {
+ if (ctrl.$isEmpty(value)) return null;
+ if (NUMBER_REGEXP.test(value)) return parseFloat(value);
+
+ ctrl.$$parserName = 'number';
+ return undefined;
+ });
+
+ ctrl.$formatters.push(function(value) {
+ if (!ctrl.$isEmpty(value)) {
+ if (!isNumber(value)) {
+ throw ngModelMinErr('numfmt', 'Expected `{0}` to be a number', value);
+ }
+ value = value.toString();
+ }
+ return value;
+ });
+}
+
+function parseNumberAttrVal(val) {
+ if (isDefined(val) && !isNumber(val)) {
+ val = parseFloat(val);
+ }
+ return !isNumberNaN(val) ? val : undefined;
+}
+
+function isNumberInteger(num) {
+ // See http://stackoverflow.com/questions/14636536/how-to-check-if-a-variable-is-an-integer-in-javascript#14794066
+ // (minus the assumption that `num` is a number)
+
+ // eslint-disable-next-line no-bitwise
+ return (num | 0) === num;
+}
+
+function countDecimals(num) {
+ var numString = num.toString();
+ var decimalSymbolIndex = numString.indexOf('.');
+
+ if (decimalSymbolIndex === -1) {
+ if (-1 < num && num < 1) {
+ // It may be in the exponential notation format (`1e-X`)
+ var match = /e-(\d+)$/.exec(numString);
+
+ if (match) {
+ return Number(match[1]);
+ }
+ }
+
+ return 0;
+ }
+
+ return numString.length - decimalSymbolIndex - 1;
+}
+
+function isValidForStep(viewValue, stepBase, step) {
+ // At this point `stepBase` and `step` are expected to be non-NaN values
+ // and `viewValue` is expected to be a valid stringified number.
+ var value = Number(viewValue);
+
+ var isNonIntegerValue = !isNumberInteger(value);
+ var isNonIntegerStepBase = !isNumberInteger(stepBase);
+ var isNonIntegerStep = !isNumberInteger(step);
+
+ // Due to limitations in Floating Point Arithmetic (e.g. `0.3 - 0.2 !== 0.1` or
+ // `0.5 % 0.1 !== 0`), we need to convert all numbers to integers.
+ if (isNonIntegerValue || isNonIntegerStepBase || isNonIntegerStep) {
+ var valueDecimals = isNonIntegerValue ? countDecimals(value) : 0;
+ var stepBaseDecimals = isNonIntegerStepBase ? countDecimals(stepBase) : 0;
+ var stepDecimals = isNonIntegerStep ? countDecimals(step) : 0;
+
+ var decimalCount = Math.max(valueDecimals, stepBaseDecimals, stepDecimals);
+ var multiplier = Math.pow(10, decimalCount);
+
+ value = value * multiplier;
+ stepBase = stepBase * multiplier;
+ step = step * multiplier;
+
+ if (isNonIntegerValue) value = Math.round(value);
+ if (isNonIntegerStepBase) stepBase = Math.round(stepBase);
+ if (isNonIntegerStep) step = Math.round(step);
+ }
+
+ return (value - stepBase) % step === 0;
+}
+
+function numberInputType(scope, element, attr, ctrl, $sniffer, $browser, $filter, $parse) {
+ badInputChecker(scope, element, attr, ctrl, 'number');
+ numberFormatterParser(ctrl);
+ baseInputType(scope, element, attr, ctrl, $sniffer, $browser);
+
+ var parsedMinVal;
+
+ if (isDefined(attr.min) || attr.ngMin) {
+ var minVal = attr.min || $parse(attr.ngMin)(scope);
+ parsedMinVal = parseNumberAttrVal(minVal);
+
+ ctrl.$validators.min = function(modelValue, viewValue) {
+ return ctrl.$isEmpty(viewValue) || isUndefined(parsedMinVal) || viewValue >= parsedMinVal;
+ };
+
+ attr.$observe('min', function(val) {
+ if (val !== minVal) {
+ parsedMinVal = parseNumberAttrVal(val);
+ minVal = val;
+ // TODO(matsko): implement validateLater to reduce number of validations
+ ctrl.$validate();
+ }
+ });
+ }
+
+ if (isDefined(attr.max) || attr.ngMax) {
+ var maxVal = attr.max || $parse(attr.ngMax)(scope);
+ var parsedMaxVal = parseNumberAttrVal(maxVal);
+
+ ctrl.$validators.max = function(modelValue, viewValue) {
+ return ctrl.$isEmpty(viewValue) || isUndefined(parsedMaxVal) || viewValue <= parsedMaxVal;
+ };
+
+ attr.$observe('max', function(val) {
+ if (val !== maxVal) {
+ parsedMaxVal = parseNumberAttrVal(val);
+ maxVal = val;
+ // TODO(matsko): implement validateLater to reduce number of validations
+ ctrl.$validate();
+ }
+ });
+ }
+
+ if (isDefined(attr.step) || attr.ngStep) {
+ var stepVal = attr.step || $parse(attr.ngStep)(scope);
+ var parsedStepVal = parseNumberAttrVal(stepVal);
+
+ ctrl.$validators.step = function(modelValue, viewValue) {
+ return ctrl.$isEmpty(viewValue) || isUndefined(parsedStepVal) ||
+ isValidForStep(viewValue, parsedMinVal || 0, parsedStepVal);
+ };
+
+ attr.$observe('step', function(val) {
+ // TODO(matsko): implement validateLater to reduce number of validations
+ if (val !== stepVal) {
+ parsedStepVal = parseNumberAttrVal(val);
+ stepVal = val;
+ ctrl.$validate();
+ }
+
+ });
+
+ }
+}
+
+function rangeInputType(scope, element, attr, ctrl, $sniffer, $browser) {
+ badInputChecker(scope, element, attr, ctrl, 'range');
+ numberFormatterParser(ctrl);
+ baseInputType(scope, element, attr, ctrl, $sniffer, $browser);
+
+ var supportsRange = ctrl.$$hasNativeValidators && element[0].type === 'range',
+ minVal = supportsRange ? 0 : undefined,
+ maxVal = supportsRange ? 100 : undefined,
+ stepVal = supportsRange ? 1 : undefined,
+ validity = element[0].validity,
+ hasMinAttr = isDefined(attr.min),
+ hasMaxAttr = isDefined(attr.max),
+ hasStepAttr = isDefined(attr.step);
+
+ var originalRender = ctrl.$render;
+
+ ctrl.$render = supportsRange && isDefined(validity.rangeUnderflow) && isDefined(validity.rangeOverflow) ?
+ //Browsers that implement range will set these values automatically, but reading the adjusted values after
+ //$render would cause the min / max validators to be applied with the wrong value
+ function rangeRender() {
+ originalRender();
+ ctrl.$setViewValue(element.val());
+ } :
+ originalRender;
+
+ if (hasMinAttr) {
+ minVal = parseNumberAttrVal(attr.min);
+
+ ctrl.$validators.min = supportsRange ?
+ // Since all browsers set the input to a valid value, we don't need to check validity
+ function noopMinValidator() { return true; } :
+ // non-support browsers validate the min val
+ function minValidator(modelValue, viewValue) {
+ return ctrl.$isEmpty(viewValue) || isUndefined(minVal) || viewValue >= minVal;
+ };
+
+ setInitialValueAndObserver('min', minChange);
+ }
+
+ if (hasMaxAttr) {
+ maxVal = parseNumberAttrVal(attr.max);
+
+ ctrl.$validators.max = supportsRange ?
+ // Since all browsers set the input to a valid value, we don't need to check validity
+ function noopMaxValidator() { return true; } :
+ // non-support browsers validate the max val
+ function maxValidator(modelValue, viewValue) {
+ return ctrl.$isEmpty(viewValue) || isUndefined(maxVal) || viewValue <= maxVal;
+ };
+
+ setInitialValueAndObserver('max', maxChange);
+ }
+
+ if (hasStepAttr) {
+ stepVal = parseNumberAttrVal(attr.step);
+
+ ctrl.$validators.step = supportsRange ?
+ function nativeStepValidator() {
+ // Currently, only FF implements the spec on step change correctly (i.e. adjusting the
+ // input element value to a valid value). It's possible that other browsers set the stepMismatch
+ // validity error instead, so we can at least report an error in that case.
+ return !validity.stepMismatch;
+ } :
+ // ngStep doesn't set the setp attr, so the browser doesn't adjust the input value as setting step would
+ function stepValidator(modelValue, viewValue) {
+ return ctrl.$isEmpty(viewValue) || isUndefined(stepVal) ||
+ isValidForStep(viewValue, minVal || 0, stepVal);
+ };
+
+ setInitialValueAndObserver('step', stepChange);
+ }
+
+ function setInitialValueAndObserver(htmlAttrName, changeFn) {
+ // interpolated attributes set the attribute value only after a digest, but we need the
+ // attribute value when the input is first rendered, so that the browser can adjust the
+ // input value based on the min/max value
+ element.attr(htmlAttrName, attr[htmlAttrName]);
+ var oldVal = attr[htmlAttrName];
+ attr.$observe(htmlAttrName, function wrappedObserver(val) {
+ if (val !== oldVal) {
+ oldVal = val;
+ changeFn(val);
+ }
+ });
+ }
+
+ function minChange(val) {
+ minVal = parseNumberAttrVal(val);
+ // ignore changes before model is initialized
+ if (isNumberNaN(ctrl.$modelValue)) {
+ return;
+ }
+
+ if (supportsRange) {
+ var elVal = element.val();
+ // IE11 doesn't set the el val correctly if the minVal is greater than the element value
+ if (minVal > elVal) {
+ elVal = minVal;
+ element.val(elVal);
+ }
+ ctrl.$setViewValue(elVal);
+ } else {
+ // TODO(matsko): implement validateLater to reduce number of validations
+ ctrl.$validate();
+ }
+ }
+
+ function maxChange(val) {
+ maxVal = parseNumberAttrVal(val);
+ // ignore changes before model is initialized
+ if (isNumberNaN(ctrl.$modelValue)) {
+ return;
+ }
+
+ if (supportsRange) {
+ var elVal = element.val();
+ // IE11 doesn't set the el val correctly if the maxVal is less than the element value
+ if (maxVal < elVal) {
+ element.val(maxVal);
+ // IE11 and Chrome don't set the value to the minVal when max < min
+ elVal = maxVal < minVal ? minVal : maxVal;
+ }
+ ctrl.$setViewValue(elVal);
+ } else {
+ // TODO(matsko): implement validateLater to reduce number of validations
+ ctrl.$validate();
+ }
+ }
+
+ function stepChange(val) {
+ stepVal = parseNumberAttrVal(val);
+ // ignore changes before model is initialized
+ if (isNumberNaN(ctrl.$modelValue)) {
+ return;
+ }
+
+ // Some browsers don't adjust the input value correctly, but set the stepMismatch error
+ if (!supportsRange) {
+ // TODO(matsko): implement validateLater to reduce number of validations
+ ctrl.$validate();
+ } else if (ctrl.$viewValue !== element.val()) {
+ ctrl.$setViewValue(element.val());
+ }
+ }
+}
+
+function urlInputType(scope, element, attr, ctrl, $sniffer, $browser) {
+ // Note: no badInputChecker here by purpose as `url` is only a validation
+ // in browsers, i.e. we can always read out input.value even if it is not valid!
+ baseInputType(scope, element, attr, ctrl, $sniffer, $browser);
+ stringBasedInputType(ctrl);
+
+ ctrl.$validators.url = function(modelValue, viewValue) {
+ var value = modelValue || viewValue;
+ return ctrl.$isEmpty(value) || URL_REGEXP.test(value);
+ };
+}
+
+function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) {
+ // Note: no badInputChecker here by purpose as `url` is only a validation
+ // in browsers, i.e. we can always read out input.value even if it is not valid!
+ baseInputType(scope, element, attr, ctrl, $sniffer, $browser);
+ stringBasedInputType(ctrl);
+
+ ctrl.$validators.email = function(modelValue, viewValue) {
+ var value = modelValue || viewValue;
+ return ctrl.$isEmpty(value) || EMAIL_REGEXP.test(value);
+ };
+}
+
+function radioInputType(scope, element, attr, ctrl) {
+ var doTrim = !attr.ngTrim || trim(attr.ngTrim) !== 'false';
+ // make the name unique, if not defined
+ if (isUndefined(attr.name)) {
+ element.attr('name', nextUid());
+ }
+
+ var listener = function(ev) {
+ var value;
+ if (element[0].checked) {
+ value = attr.value;
+ if (doTrim) {
+ value = trim(value);
+ }
+ ctrl.$setViewValue(value, ev && ev.type);
+ }
+ };
+
+ element.on('change', listener);
+
+ ctrl.$render = function() {
+ var value = attr.value;
+ if (doTrim) {
+ value = trim(value);
+ }
+ element[0].checked = (value === ctrl.$viewValue);
+ };
+
+ attr.$observe('value', ctrl.$render);
+}
+
+function parseConstantExpr($parse, context, name, expression, fallback) {
+ var parseFn;
+ if (isDefined(expression)) {
+ parseFn = $parse(expression);
+ if (!parseFn.constant) {
+ throw ngModelMinErr('constexpr', 'Expected constant expression for `{0}`, but saw ' +
+ '`{1}`.', name, expression);
+ }
+ return parseFn(context);
+ }
+ return fallback;
+}
+
+function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browser, $filter, $parse) {
+ var trueValue = parseConstantExpr($parse, scope, 'ngTrueValue', attr.ngTrueValue, true);
+ var falseValue = parseConstantExpr($parse, scope, 'ngFalseValue', attr.ngFalseValue, false);
+
+ var listener = function(ev) {
+ ctrl.$setViewValue(element[0].checked, ev && ev.type);
+ };
+
+ element.on('change', listener);
+
+ ctrl.$render = function() {
+ element[0].checked = ctrl.$viewValue;
+ };
+
+ // Override the standard `$isEmpty` because the $viewValue of an empty checkbox is always set to `false`
+ // This is because of the parser below, which compares the `$modelValue` with `trueValue` to convert
+ // it to a boolean.
+ ctrl.$isEmpty = function(value) {
+ return value === false;
+ };
+
+ ctrl.$formatters.push(function(value) {
+ return equals(value, trueValue);
+ });
+
+ ctrl.$parsers.push(function(value) {
+ return value ? trueValue : falseValue;
+ });
+}
+
+
+/**
+ * @ngdoc directive
+ * @name textarea
+ * @restrict E
+ *
+ * @description
+ * HTML textarea element control with AngularJS data-binding. The data-binding and validation
+ * properties of this element are exactly the same as those of the
+ * {@link ng.directive:input input element}.
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
+ * minlength.
+ * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
+ * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any
+ * length.
+ * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
+ * does not match a RegExp found by evaluating the AngularJS expression given in the attribute value.
+ * If the expression evaluates to a RegExp object, then this is used directly.
+ * If the expression evaluates to a string, then it will be converted to a RegExp
+ * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to
+ * `new RegExp('^abc$')`.<br />
+ * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ * start at the index of the last search's match, thus not taking the whole input value into
+ * account.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ * @param {boolean=} [ngTrim=true] If set to false AngularJS will not automatically trim the input.
+ *
+ * @knownIssue
+ *
+ * When specifying the `placeholder` attribute of `<textarea>`, Internet Explorer will temporarily
+ * insert the placeholder value as the textarea's content. If the placeholder value contains
+ * interpolation (`{{ ... }}`), an error will be logged in the console when AngularJS tries to update
+ * the value of the by-then-removed text node. This doesn't affect the functionality of the
+ * textarea, but can be undesirable.
+ *
+ * You can work around this Internet Explorer issue by using `ng-attr-placeholder` instead of
+ * `placeholder` on textareas, whenever you need interpolation in the placeholder value. You can
+ * find more details on `ngAttr` in the
+ * [Interpolation](guide/interpolation#-ngattr-for-binding-to-arbitrary-attributes) section of the
+ * Developer Guide.
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name input
+ * @restrict E
+ *
+ * @description
+ * HTML input element control. When used together with {@link ngModel `ngModel`}, it provides data-binding,
+ * input state control, and validation.
+ * Input control follows HTML5 input types and polyfills the HTML5 validation behavior for older browsers.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** Not every feature offered is available for all input types.
+ * Specifically, data binding and event handling via `ng-model` is unsupported for `input[file]`.
+ * </div>
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {boolean=} ngRequired Sets `required` attribute if set to true
+ * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
+ * minlength.
+ * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
+ * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any
+ * length.
+ * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
+ * value does not match a RegExp found by evaluating the AngularJS expression given in the attribute value.
+ * If the expression evaluates to a RegExp object, then this is used directly.
+ * If the expression evaluates to a string, then it will be converted to a RegExp
+ * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to
+ * `new RegExp('^abc$')`.<br />
+ * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ * start at the index of the last search's match, thus not taking the whole input value into
+ * account.
+ * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
+ * interaction with the input element.
+ * @param {boolean=} [ngTrim=true] If set to false AngularJS will not automatically trim the input.
+ * This parameter is ignored for input[type=password] controls, which will never trim the
+ * input.
+ *
+ * @example
+ <example name="input-directive" module="inputExample">
+ <file name="index.html">
+ <script>
+ angular.module('inputExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.user = {name: 'guest', last: 'visitor'};
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <form name="myForm">
+ <label>
+ User name:
+ <input type="text" name="userName" ng-model="user.name" required>
+ </label>
+ <div role="alert">
+ <span class="error" ng-show="myForm.userName.$error.required">
+ Required!</span>
+ </div>
+ <label>
+ Last name:
+ <input type="text" name="lastName" ng-model="user.last"
+ ng-minlength="3" ng-maxlength="10">
+ </label>
+ <div role="alert">
+ <span class="error" ng-show="myForm.lastName.$error.minlength">
+ Too short!</span>
+ <span class="error" ng-show="myForm.lastName.$error.maxlength">
+ Too long!</span>
+ </div>
+ </form>
+ <hr>
+ <tt>user = {{user}}</tt><br/>
+ <tt>myForm.userName.$valid = {{myForm.userName.$valid}}</tt><br/>
+ <tt>myForm.userName.$error = {{myForm.userName.$error}}</tt><br/>
+ <tt>myForm.lastName.$valid = {{myForm.lastName.$valid}}</tt><br/>
+ <tt>myForm.lastName.$error = {{myForm.lastName.$error}}</tt><br/>
+ <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ <tt>myForm.$error.minlength = {{!!myForm.$error.minlength}}</tt><br/>
+ <tt>myForm.$error.maxlength = {{!!myForm.$error.maxlength}}</tt><br/>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var user = element(by.exactBinding('user'));
+ var userNameValid = element(by.binding('myForm.userName.$valid'));
+ var lastNameValid = element(by.binding('myForm.lastName.$valid'));
+ var lastNameError = element(by.binding('myForm.lastName.$error'));
+ var formValid = element(by.binding('myForm.$valid'));
+ var userNameInput = element(by.model('user.name'));
+ var userLastInput = element(by.model('user.last'));
+
+ it('should initialize to model', function() {
+ expect(user.getText()).toContain('{"name":"guest","last":"visitor"}');
+ expect(userNameValid.getText()).toContain('true');
+ expect(formValid.getText()).toContain('true');
+ });
+
+ it('should be invalid if empty when required', function() {
+ userNameInput.clear();
+ userNameInput.sendKeys('');
+
+ expect(user.getText()).toContain('{"last":"visitor"}');
+ expect(userNameValid.getText()).toContain('false');
+ expect(formValid.getText()).toContain('false');
+ });
+
+ it('should be valid if empty when min length is set', function() {
+ userLastInput.clear();
+ userLastInput.sendKeys('');
+
+ expect(user.getText()).toContain('{"name":"guest","last":""}');
+ expect(lastNameValid.getText()).toContain('true');
+ expect(formValid.getText()).toContain('true');
+ });
+
+ it('should be invalid if less than required min length', function() {
+ userLastInput.clear();
+ userLastInput.sendKeys('xx');
+
+ expect(user.getText()).toContain('{"name":"guest"}');
+ expect(lastNameValid.getText()).toContain('false');
+ expect(lastNameError.getText()).toContain('minlength');
+ expect(formValid.getText()).toContain('false');
+ });
+
+ it('should be invalid if longer than max length', function() {
+ userLastInput.clear();
+ userLastInput.sendKeys('some ridiculously long name');
+
+ expect(user.getText()).toContain('{"name":"guest"}');
+ expect(lastNameValid.getText()).toContain('false');
+ expect(lastNameError.getText()).toContain('maxlength');
+ expect(formValid.getText()).toContain('false');
+ });
+ </file>
+ </example>
+ */
+var inputDirective = ['$browser', '$sniffer', '$filter', '$parse',
+ function($browser, $sniffer, $filter, $parse) {
+ return {
+ restrict: 'E',
+ require: ['?ngModel'],
+ link: {
+ pre: function(scope, element, attr, ctrls) {
+ if (ctrls[0]) {
+ (inputType[lowercase(attr.type)] || inputType.text)(scope, element, attr, ctrls[0], $sniffer,
+ $browser, $filter, $parse);
+ }
+ }
+ }
+ };
+}];
+
+
+var hiddenInputBrowserCacheDirective = function() {
+ var valueProperty = {
+ configurable: true,
+ enumerable: false,
+ get: function() {
+ return this.getAttribute('value') || '';
+ },
+ set: function(val) {
+ this.setAttribute('value', val);
+ }
+ };
+
+ return {
+ restrict: 'E',
+ priority: 200,
+ compile: function(_, attr) {
+ if (lowercase(attr.type) !== 'hidden') {
+ return;
+ }
+
+ return {
+ pre: function(scope, element, attr, ctrls) {
+ var node = element[0];
+
+ // Support: Edge
+ // Moving the DOM around prevents autofillling
+ if (node.parentNode) {
+ node.parentNode.insertBefore(node, node.nextSibling);
+ }
+
+ // Support: FF, IE
+ // Avoiding direct assignment to .value prevents autofillling
+ if (Object.defineProperty) {
+ Object.defineProperty(node, 'value', valueProperty);
+ }
+ }
+ };
+ }
+ };
+};
+
+
+
+var CONSTANT_VALUE_REGEXP = /^(true|false|\d+)$/;
+/**
+ * @ngdoc directive
+ * @name ngValue
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ * Binds the given expression to the value of the element.
+ *
+ * It is mainly used on {@link input[radio] `input[radio]`} and option elements,
+ * so that when the element is selected, the {@link ngModel `ngModel`} of that element (or its
+ * {@link select `select`} parent element) is set to the bound value. It is especially useful
+ * for dynamically generated lists using {@link ngRepeat `ngRepeat`}, as shown below.
+ *
+ * It can also be used to achieve one-way binding of a given expression to an input element
+ * such as an `input[text]` or a `textarea`, when that element does not use ngModel.
+ *
+ * @element ANY
+ * @param {string=} ngValue AngularJS expression, whose value will be bound to the `value` attribute
+ * and `value` property of the element.
+ *
+ * @example
+ <example name="ngValue-directive" module="valueExample">
+ <file name="index.html">
+ <script>
+ angular.module('valueExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.names = ['pizza', 'unicorns', 'robots'];
+ $scope.my = { favorite: 'unicorns' };
+ }]);
+ </script>
+ <form ng-controller="ExampleController">
+ <h2>Which is your favorite?</h2>
+ <label ng-repeat="name in names" for="{{name}}">
+ {{name}}
+ <input type="radio"
+ ng-model="my.favorite"
+ ng-value="name"
+ id="{{name}}"
+ name="favorite">
+ </label>
+ <div>You chose {{my.favorite}}</div>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ var favorite = element(by.binding('my.favorite'));
+
+ it('should initialize to model', function() {
+ expect(favorite.getText()).toContain('unicorns');
+ });
+ it('should bind the values to the inputs', function() {
+ element.all(by.model('my.favorite')).get(0).click();
+ expect(favorite.getText()).toContain('pizza');
+ });
+ </file>
+ </example>
+ */
+var ngValueDirective = function() {
+ /**
+ * inputs use the value attribute as their default value if the value property is not set.
+ * Once the value property has been set (by adding input), it will not react to changes to
+ * the value attribute anymore. Setting both attribute and property fixes this behavior, and
+ * makes it possible to use ngValue as a sort of one-way bind.
+ */
+ function updateElementValue(element, attr, value) {
+ // Support: IE9 only
+ // In IE9 values are converted to string (e.g. `input.value = null` results in `input.value === 'null'`).
+ var propValue = isDefined(value) ? value : (msie === 9) ? '' : null;
+ element.prop('value', propValue);
+ attr.$set('value', value);
+ }
+
+ return {
+ restrict: 'A',
+ priority: 100,
+ compile: function(tpl, tplAttr) {
+ if (CONSTANT_VALUE_REGEXP.test(tplAttr.ngValue)) {
+ return function ngValueConstantLink(scope, elm, attr) {
+ var value = scope.$eval(attr.ngValue);
+ updateElementValue(elm, attr, value);
+ };
+ } else {
+ return function ngValueLink(scope, elm, attr) {
+ scope.$watch(attr.ngValue, function valueWatchAction(value) {
+ updateElementValue(elm, attr, value);
+ });
+ };
+ }
+ }
+ };
+};
+
+/**
+ * @ngdoc directive
+ * @name ngBind
+ * @restrict AC
+ *
+ * @description
+ * The `ngBind` attribute tells AngularJS to replace the text content of the specified HTML element
+ * with the value of a given expression, and to update the text content when the value of that
+ * expression changes.
+ *
+ * Typically, you don't use `ngBind` directly, but instead you use the double curly markup like
+ * `{{ expression }}` which is similar but less verbose.
+ *
+ * It is preferable to use `ngBind` instead of `{{ expression }}` if a template is momentarily
+ * displayed by the browser in its raw state before AngularJS compiles it. Since `ngBind` is an
+ * element attribute, it makes the bindings invisible to the user while the page is loading.
+ *
+ * An alternative solution to this problem would be using the
+ * {@link ng.directive:ngCloak ngCloak} directive.
+ *
+ *
+ * @element ANY
+ * @param {expression} ngBind {@link guide/expression Expression} to evaluate.
+ *
+ * @example
+ * Enter a name in the Live Preview text box; the greeting below the text box changes instantly.
+ <example module="bindExample" name="ng-bind">
+ <file name="index.html">
+ <script>
+ angular.module('bindExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.name = 'Whirled';
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <label>Enter name: <input type="text" ng-model="name"></label><br>
+ Hello <span ng-bind="name"></span>!
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ng-bind', function() {
+ var nameInput = element(by.model('name'));
+
+ expect(element(by.binding('name')).getText()).toBe('Whirled');
+ nameInput.clear();
+ nameInput.sendKeys('world');
+ expect(element(by.binding('name')).getText()).toBe('world');
+ });
+ </file>
+ </example>
+ */
+var ngBindDirective = ['$compile', function($compile) {
+ return {
+ restrict: 'AC',
+ compile: function ngBindCompile(templateElement) {
+ $compile.$$addBindingClass(templateElement);
+ return function ngBindLink(scope, element, attr) {
+ $compile.$$addBindingInfo(element, attr.ngBind);
+ element = element[0];
+ scope.$watch(attr.ngBind, function ngBindWatchAction(value) {
+ element.textContent = stringify(value);
+ });
+ };
+ }
+ };
+}];
+
+
+/**
+ * @ngdoc directive
+ * @name ngBindTemplate
+ *
+ * @description
+ * The `ngBindTemplate` directive specifies that the element
+ * text content should be replaced with the interpolation of the template
+ * in the `ngBindTemplate` attribute.
+ * Unlike `ngBind`, the `ngBindTemplate` can contain multiple `{{` `}}`
+ * expressions. This directive is needed since some HTML elements
+ * (such as TITLE and OPTION) cannot contain SPAN elements.
+ *
+ * @element ANY
+ * @param {string} ngBindTemplate template of form
+ * <tt>{{</tt> <tt>expression</tt> <tt>}}</tt> to eval.
+ *
+ * @example
+ * Try it here: enter text in text box and watch the greeting change.
+ <example module="bindExample" name="ng-bind-template">
+ <file name="index.html">
+ <script>
+ angular.module('bindExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.salutation = 'Hello';
+ $scope.name = 'World';
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <label>Salutation: <input type="text" ng-model="salutation"></label><br>
+ <label>Name: <input type="text" ng-model="name"></label><br>
+ <pre ng-bind-template="{{salutation}} {{name}}!"></pre>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ng-bind', function() {
+ var salutationElem = element(by.binding('salutation'));
+ var salutationInput = element(by.model('salutation'));
+ var nameInput = element(by.model('name'));
+
+ expect(salutationElem.getText()).toBe('Hello World!');
+
+ salutationInput.clear();
+ salutationInput.sendKeys('Greetings');
+ nameInput.clear();
+ nameInput.sendKeys('user');
+
+ expect(salutationElem.getText()).toBe('Greetings user!');
+ });
+ </file>
+ </example>
+ */
+var ngBindTemplateDirective = ['$interpolate', '$compile', function($interpolate, $compile) {
+ return {
+ compile: function ngBindTemplateCompile(templateElement) {
+ $compile.$$addBindingClass(templateElement);
+ return function ngBindTemplateLink(scope, element, attr) {
+ var interpolateFn = $interpolate(element.attr(attr.$attr.ngBindTemplate));
+ $compile.$$addBindingInfo(element, interpolateFn.expressions);
+ element = element[0];
+ attr.$observe('ngBindTemplate', function(value) {
+ element.textContent = isUndefined(value) ? '' : value;
+ });
+ };
+ }
+ };
+}];
+
+
+/**
+ * @ngdoc directive
+ * @name ngBindHtml
+ *
+ * @description
+ * Evaluates the expression and inserts the resulting HTML into the element in a secure way. By default,
+ * the resulting HTML content will be sanitized using the {@link ngSanitize.$sanitize $sanitize} service.
+ * To utilize this functionality, ensure that `$sanitize` is available, for example, by including {@link
+ * ngSanitize} in your module's dependencies (not in core AngularJS). In order to use {@link ngSanitize}
+ * in your module's dependencies, you need to include "angular-sanitize.js" in your application.
+ *
+ * You may also bypass sanitization for values you know are safe. To do so, bind to
+ * an explicitly trusted value via {@link ng.$sce#trustAsHtml $sce.trustAsHtml}. See the example
+ * under {@link ng.$sce#show-me-an-example-using-sce- Strict Contextual Escaping (SCE)}.
+ *
+ * Note: If a `$sanitize` service is unavailable and the bound value isn't explicitly trusted, you
+ * will have an exception (instead of an exploit.)
+ *
+ * @element ANY
+ * @param {expression} ngBindHtml {@link guide/expression Expression} to evaluate.
+ *
+ * @example
+
+ <example module="bindHtmlExample" deps="angular-sanitize.js" name="ng-bind-html">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <p ng-bind-html="myHTML"></p>
+ </div>
+ </file>
+
+ <file name="script.js">
+ angular.module('bindHtmlExample', ['ngSanitize'])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.myHTML =
+ 'I am an <code>HTML</code>string with ' +
+ '<a href="#">links!</a> and other <em>stuff</em>';
+ }]);
+ </file>
+
+ <file name="protractor.js" type="protractor">
+ it('should check ng-bind-html', function() {
+ expect(element(by.binding('myHTML')).getText()).toBe(
+ 'I am an HTMLstring with links! and other stuff');
+ });
+ </file>
+ </example>
+ */
+var ngBindHtmlDirective = ['$sce', '$parse', '$compile', function($sce, $parse, $compile) {
+ return {
+ restrict: 'A',
+ compile: function ngBindHtmlCompile(tElement, tAttrs) {
+ var ngBindHtmlGetter = $parse(tAttrs.ngBindHtml);
+ var ngBindHtmlWatch = $parse(tAttrs.ngBindHtml, function sceValueOf(val) {
+ // Unwrap the value to compare the actual inner safe value, not the wrapper object.
+ return $sce.valueOf(val);
+ });
+ $compile.$$addBindingClass(tElement);
+
+ return function ngBindHtmlLink(scope, element, attr) {
+ $compile.$$addBindingInfo(element, attr.ngBindHtml);
+
+ scope.$watch(ngBindHtmlWatch, function ngBindHtmlWatchAction() {
+ // The watched value is the unwrapped value. To avoid re-escaping, use the direct getter.
+ var value = ngBindHtmlGetter(scope);
+ element.html($sce.getTrustedHtml(value) || '');
+ });
+ };
+ }
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngChange
+ * @restrict A
+ *
+ * @description
+ * Evaluate the given expression when the user changes the input.
+ * The expression is evaluated immediately, unlike the JavaScript onchange event
+ * which only triggers at the end of a change (usually, when the user leaves the
+ * form element or presses the return key).
+ *
+ * The `ngChange` expression is only evaluated when a change in the input value causes
+ * a new value to be committed to the model.
+ *
+ * It will not be evaluated:
+ * * if the value returned from the `$parsers` transformation pipeline has not changed
+ * * if the input has continued to be invalid since the model will stay `null`
+ * * if the model is changed programmatically and not by a change to the input value
+ *
+ *
+ * Note, this directive requires `ngModel` to be present.
+ *
+ * @element ANY
+ * @param {expression} ngChange {@link guide/expression Expression} to evaluate upon change
+ * in input value.
+ *
+ * @example
+ * <example name="ngChange-directive" module="changeExample">
+ * <file name="index.html">
+ * <script>
+ * angular.module('changeExample', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.counter = 0;
+ * $scope.change = function() {
+ * $scope.counter++;
+ * };
+ * }]);
+ * </script>
+ * <div ng-controller="ExampleController">
+ * <input type="checkbox" ng-model="confirmed" ng-change="change()" id="ng-change-example1" />
+ * <input type="checkbox" ng-model="confirmed" id="ng-change-example2" />
+ * <label for="ng-change-example2">Confirmed</label><br />
+ * <tt>debug = {{confirmed}}</tt><br/>
+ * <tt>counter = {{counter}}</tt><br/>
+ * </div>
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * var counter = element(by.binding('counter'));
+ * var debug = element(by.binding('confirmed'));
+ *
+ * it('should evaluate the expression if changing from view', function() {
+ * expect(counter.getText()).toContain('0');
+ *
+ * element(by.id('ng-change-example1')).click();
+ *
+ * expect(counter.getText()).toContain('1');
+ * expect(debug.getText()).toContain('true');
+ * });
+ *
+ * it('should not evaluate the expression if changing from model', function() {
+ * element(by.id('ng-change-example2')).click();
+
+ * expect(counter.getText()).toContain('0');
+ * expect(debug.getText()).toContain('true');
+ * });
+ * </file>
+ * </example>
+ */
+var ngChangeDirective = valueFn({
+ restrict: 'A',
+ require: 'ngModel',
+ link: function(scope, element, attr, ctrl) {
+ ctrl.$viewChangeListeners.push(function() {
+ scope.$eval(attr.ngChange);
+ });
+ }
+});
+
+/* exported
+ ngClassDirective,
+ ngClassEvenDirective,
+ ngClassOddDirective
+*/
+
+function classDirective(name, selector) {
+ name = 'ngClass' + name;
+ var indexWatchExpression;
+
+ return ['$parse', function($parse) {
+ return {
+ restrict: 'AC',
+ link: function(scope, element, attr) {
+ var classCounts = element.data('$classCounts');
+ var oldModulo = true;
+ var oldClassString;
+
+ if (!classCounts) {
+ // Use createMap() to prevent class assumptions involving property
+ // names in Object.prototype
+ classCounts = createMap();
+ element.data('$classCounts', classCounts);
+ }
+
+ if (name !== 'ngClass') {
+ if (!indexWatchExpression) {
+ indexWatchExpression = $parse('$index', function moduloTwo($index) {
+ // eslint-disable-next-line no-bitwise
+ return $index & 1;
+ });
+ }
+
+ scope.$watch(indexWatchExpression, ngClassIndexWatchAction);
+ }
+
+ scope.$watch($parse(attr[name], toClassString), ngClassWatchAction);
+
+ function addClasses(classString) {
+ classString = digestClassCounts(split(classString), 1);
+ attr.$addClass(classString);
+ }
+
+ function removeClasses(classString) {
+ classString = digestClassCounts(split(classString), -1);
+ attr.$removeClass(classString);
+ }
+
+ function updateClasses(oldClassString, newClassString) {
+ var oldClassArray = split(oldClassString);
+ var newClassArray = split(newClassString);
+
+ var toRemoveArray = arrayDifference(oldClassArray, newClassArray);
+ var toAddArray = arrayDifference(newClassArray, oldClassArray);
+
+ var toRemoveString = digestClassCounts(toRemoveArray, -1);
+ var toAddString = digestClassCounts(toAddArray, 1);
+
+ attr.$addClass(toAddString);
+ attr.$removeClass(toRemoveString);
+ }
+
+ function digestClassCounts(classArray, count) {
+ var classesToUpdate = [];
+
+ forEach(classArray, function(className) {
+ if (count > 0 || classCounts[className]) {
+ classCounts[className] = (classCounts[className] || 0) + count;
+ if (classCounts[className] === +(count > 0)) {
+ classesToUpdate.push(className);
+ }
+ }
+ });
+
+ return classesToUpdate.join(' ');
+ }
+
+ function ngClassIndexWatchAction(newModulo) {
+ // This watch-action should run before the `ngClassWatchAction()`, thus it
+ // adds/removes `oldClassString`. If the `ngClass` expression has changed as well, the
+ // `ngClassWatchAction()` will update the classes.
+ if (newModulo === selector) {
+ addClasses(oldClassString);
+ } else {
+ removeClasses(oldClassString);
+ }
+
+ oldModulo = newModulo;
+ }
+
+ function ngClassWatchAction(newClassString) {
+ if (oldModulo === selector) {
+ updateClasses(oldClassString, newClassString);
+ }
+
+ oldClassString = newClassString;
+ }
+ }
+ };
+ }];
+
+ // Helpers
+ function arrayDifference(tokens1, tokens2) {
+ if (!tokens1 || !tokens1.length) return [];
+ if (!tokens2 || !tokens2.length) return tokens1;
+
+ var values = [];
+
+ outer:
+ for (var i = 0; i < tokens1.length; i++) {
+ var token = tokens1[i];
+ for (var j = 0; j < tokens2.length; j++) {
+ if (token === tokens2[j]) continue outer;
+ }
+ values.push(token);
+ }
+
+ return values;
+ }
+
+ function split(classString) {
+ return classString && classString.split(' ');
+ }
+
+ function toClassString(classValue) {
+ if (!classValue) return classValue;
+
+ var classString = classValue;
+
+ if (isArray(classValue)) {
+ classString = classValue.map(toClassString).join(' ');
+ } else if (isObject(classValue)) {
+ classString = Object.keys(classValue).
+ filter(function(key) { return classValue[key]; }).
+ join(' ');
+ } else if (!isString(classValue)) {
+ classString = classValue + '';
+ }
+
+ return classString;
+ }
+}
+
+/**
+ * @ngdoc directive
+ * @name ngClass
+ * @restrict AC
+ * @element ANY
+ *
+ * @description
+ * The `ngClass` directive allows you to dynamically set CSS classes on an HTML element by databinding
+ * an expression that represents all classes to be added.
+ *
+ * The directive operates in three different ways, depending on which of three types the expression
+ * evaluates to:
+ *
+ * 1. If the expression evaluates to a string, the string should be one or more space-delimited class
+ * names.
+ *
+ * 2. If the expression evaluates to an object, then for each key-value pair of the
+ * object with a truthy value the corresponding key is used as a class name.
+ *
+ * 3. If the expression evaluates to an array, each element of the array should either be a string as in
+ * type 1 or an object as in type 2. This means that you can mix strings and objects together in an array
+ * to give you more control over what CSS classes appear. See the code below for an example of this.
+ *
+ *
+ * The directive won't add duplicate classes if a particular class was already set.
+ *
+ * When the expression changes, the previously added classes are removed and only then are the
+ * new classes added.
+ *
+ * @knownIssue
+ * You should not use {@link guide/interpolation interpolation} in the value of the `class`
+ * attribute, when using the `ngClass` directive on the same element.
+ * See {@link guide/interpolation#known-issues here} for more info.
+ *
+ * @animations
+ * | Animation | Occurs |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#addClass addClass} | just before the class is applied to the element |
+ * | {@link ng.$animate#removeClass removeClass} | just before the class is removed from the element |
+ * | {@link ng.$animate#setClass setClass} | just before classes are added and classes are removed from the element at the same time |
+ *
+ * ### ngClass and pre-existing CSS3 Transitions/Animations
+ The ngClass directive still supports CSS3 Transitions/Animations even if they do not follow the ngAnimate CSS naming structure.
+ Upon animation ngAnimate will apply supplementary CSS classes to track the start and end of an animation, but this will not hinder
+ any pre-existing CSS transitions already on the element. To get an idea of what happens during a class-based animation, be sure
+ to view the step by step details of {@link $animate#addClass $animate.addClass} and
+ {@link $animate#removeClass $animate.removeClass}.
+ *
+ * @param {expression} ngClass {@link guide/expression Expression} to eval. The result
+ * of the evaluation can be a string representing space delimited class
+ * names, an array, or a map of class names to boolean values. In the case of a map, the
+ * names of the properties whose values are truthy will be added as css classes to the
+ * element.
+ *
+ * @example
+ * ### Basic
+ <example name="ng-class">
+ <file name="index.html">
+ <p ng-class="{strike: deleted, bold: important, 'has-error': error}">Map Syntax Example</p>
+ <label>
+ <input type="checkbox" ng-model="deleted">
+ deleted (apply "strike" class)
+ </label><br>
+ <label>
+ <input type="checkbox" ng-model="important">
+ important (apply "bold" class)
+ </label><br>
+ <label>
+ <input type="checkbox" ng-model="error">
+ error (apply "has-error" class)
+ </label>
+ <hr>
+ <p ng-class="style">Using String Syntax</p>
+ <input type="text" ng-model="style"
+ placeholder="Type: bold strike red" aria-label="Type: bold strike red">
+ <hr>
+ <p ng-class="[style1, style2, style3]">Using Array Syntax</p>
+ <input ng-model="style1"
+ placeholder="Type: bold, strike or red" aria-label="Type: bold, strike or red"><br>
+ <input ng-model="style2"
+ placeholder="Type: bold, strike or red" aria-label="Type: bold, strike or red 2"><br>
+ <input ng-model="style3"
+ placeholder="Type: bold, strike or red" aria-label="Type: bold, strike or red 3"><br>
+ <hr>
+ <p ng-class="[style4, {orange: warning}]">Using Array and Map Syntax</p>
+ <input ng-model="style4" placeholder="Type: bold, strike" aria-label="Type: bold, strike"><br>
+ <label><input type="checkbox" ng-model="warning"> warning (apply "orange" class)</label>
+ </file>
+ <file name="style.css">
+ .strike {
+ text-decoration: line-through;
+ }
+ .bold {
+ font-weight: bold;
+ }
+ .red {
+ color: red;
+ }
+ .has-error {
+ color: red;
+ background-color: yellow;
+ }
+ .orange {
+ color: orange;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ var ps = element.all(by.css('p'));
+
+ it('should let you toggle the class', function() {
+
+ expect(ps.first().getAttribute('class')).not.toMatch(/bold/);
+ expect(ps.first().getAttribute('class')).not.toMatch(/has-error/);
+
+ element(by.model('important')).click();
+ expect(ps.first().getAttribute('class')).toMatch(/bold/);
+
+ element(by.model('error')).click();
+ expect(ps.first().getAttribute('class')).toMatch(/has-error/);
+ });
+
+ it('should let you toggle string example', function() {
+ expect(ps.get(1).getAttribute('class')).toBe('');
+ element(by.model('style')).clear();
+ element(by.model('style')).sendKeys('red');
+ expect(ps.get(1).getAttribute('class')).toBe('red');
+ });
+
+ it('array example should have 3 classes', function() {
+ expect(ps.get(2).getAttribute('class')).toBe('');
+ element(by.model('style1')).sendKeys('bold');
+ element(by.model('style2')).sendKeys('strike');
+ element(by.model('style3')).sendKeys('red');
+ expect(ps.get(2).getAttribute('class')).toBe('bold strike red');
+ });
+
+ it('array with map example should have 2 classes', function() {
+ expect(ps.last().getAttribute('class')).toBe('');
+ element(by.model('style4')).sendKeys('bold');
+ element(by.model('warning')).click();
+ expect(ps.last().getAttribute('class')).toBe('bold orange');
+ });
+ </file>
+ </example>
+
+ @example
+ ### Animations
+
+ The example below demonstrates how to perform animations using ngClass.
+
+ <example module="ngAnimate" deps="angular-animate.js" animations="true" name="ng-class">
+ <file name="index.html">
+ <input id="setbtn" type="button" value="set" ng-click="myVar='my-class'">
+ <input id="clearbtn" type="button" value="clear" ng-click="myVar=''">
+ <br>
+ <span class="base-class" ng-class="myVar">Sample Text</span>
+ </file>
+ <file name="style.css">
+ .base-class {
+ transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
+ }
+
+ .base-class.my-class {
+ color: red;
+ font-size:3em;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ng-class', function() {
+ expect(element(by.css('.base-class')).getAttribute('class')).not.
+ toMatch(/my-class/);
+
+ element(by.id('setbtn')).click();
+
+ expect(element(by.css('.base-class')).getAttribute('class')).
+ toMatch(/my-class/);
+
+ element(by.id('clearbtn')).click();
+
+ expect(element(by.css('.base-class')).getAttribute('class')).not.
+ toMatch(/my-class/);
+ });
+ </file>
+ </example>
+ */
+var ngClassDirective = classDirective('', true);
+
+/**
+ * @ngdoc directive
+ * @name ngClassOdd
+ * @restrict AC
+ *
+ * @description
+ * The `ngClassOdd` and `ngClassEven` directives work exactly as
+ * {@link ng.directive:ngClass ngClass}, except they work in
+ * conjunction with `ngRepeat` and take effect only on odd (even) rows.
+ *
+ * This directive can be applied only within the scope of an
+ * {@link ng.directive:ngRepeat ngRepeat}.
+ *
+ * @animations
+ * | Animation | Occurs |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#addClass addClass} | just before the class is applied to the element |
+ * | {@link ng.$animate#removeClass removeClass} | just before the class is removed from the element |
+ *
+ * @element ANY
+ * @param {expression} ngClassOdd {@link guide/expression Expression} to eval. The result
+ * of the evaluation can be a string representing space delimited class names or an array.
+ *
+ * @example
+ <example name="ng-class-odd">
+ <file name="index.html">
+ <ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']">
+ <li ng-repeat="name in names">
+ <span ng-class-odd="'odd'" ng-class-even="'even'">
+ {{name}}
+ </span>
+ </li>
+ </ol>
+ </file>
+ <file name="style.css">
+ .odd {
+ color: red;
+ }
+ .even {
+ color: blue;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ng-class-odd and ng-class-even', function() {
+ expect(element(by.repeater('name in names').row(0).column('name')).getAttribute('class')).
+ toMatch(/odd/);
+ expect(element(by.repeater('name in names').row(1).column('name')).getAttribute('class')).
+ toMatch(/even/);
+ });
+ </file>
+ </example>
+ *
+ * <hr />
+ * @example
+ * An example on how to implement animations using `ngClassOdd`:
+ *
+ <example module="ngAnimate" deps="angular-animate.js" animations="true" name="ng-class-odd-animate">
+ <file name="index.html">
+ <div ng-init="items=['Item 3', 'Item 2', 'Item 1', 'Item 0']">
+ <button ng-click="items.unshift('Item ' + items.length)">Add item</button>
+ <hr />
+ <table>
+ <tr ng-repeat="item in items" ng-class-odd="'odd'">
+ <td>{{ item }}</td>
+ </tr>
+ </table>
+ </div>
+ </file>
+ <file name="style.css">
+ .odd {
+ background: rgba(255, 255, 0, 0.25);
+ }
+
+ .odd-add, .odd-remove {
+ transition: 1.5s;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should add new entries to the beginning of the list', function() {
+ var button = element(by.buttonText('Add item'));
+ var rows = element.all(by.repeater('item in items'));
+
+ expect(rows.count()).toBe(4);
+ expect(rows.get(0).getText()).toBe('Item 3');
+ expect(rows.get(1).getText()).toBe('Item 2');
+
+ button.click();
+
+ expect(rows.count()).toBe(5);
+ expect(rows.get(0).getText()).toBe('Item 4');
+ expect(rows.get(1).getText()).toBe('Item 3');
+ });
+
+ it('should add odd class to odd entries', function() {
+ var button = element(by.buttonText('Add item'));
+ var rows = element.all(by.repeater('item in items'));
+
+ expect(rows.get(0).getAttribute('class')).toMatch(/odd/);
+ expect(rows.get(1).getAttribute('class')).not.toMatch(/odd/);
+
+ button.click();
+
+ expect(rows.get(0).getAttribute('class')).toMatch(/odd/);
+ expect(rows.get(1).getAttribute('class')).not.toMatch(/odd/);
+ });
+ </file>
+ </example>
+ */
+var ngClassOddDirective = classDirective('Odd', 0);
+
+/**
+ * @ngdoc directive
+ * @name ngClassEven
+ * @restrict AC
+ *
+ * @description
+ * The `ngClassOdd` and `ngClassEven` directives work exactly as
+ * {@link ng.directive:ngClass ngClass}, except they work in
+ * conjunction with `ngRepeat` and take effect only on odd (even) rows.
+ *
+ * This directive can be applied only within the scope of an
+ * {@link ng.directive:ngRepeat ngRepeat}.
+ *
+ * @animations
+ * | Animation | Occurs |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#addClass addClass} | just before the class is applied to the element |
+ * | {@link ng.$animate#removeClass removeClass} | just before the class is removed from the element |
+ *
+ * @element ANY
+ * @param {expression} ngClassEven {@link guide/expression Expression} to eval. The
+ * result of the evaluation can be a string representing space delimited class names or an array.
+ *
+ * @example
+ <example name="ng-class-even">
+ <file name="index.html">
+ <ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']">
+ <li ng-repeat="name in names">
+ <span ng-class-odd="'odd'" ng-class-even="'even'">
+ {{name}}
+ </span>
+ </li>
+ </ol>
+ </file>
+ <file name="style.css">
+ .odd {
+ color: red;
+ }
+ .even {
+ color: blue;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ng-class-odd and ng-class-even', function() {
+ expect(element(by.repeater('name in names').row(0).column('name')).getAttribute('class')).
+ toMatch(/odd/);
+ expect(element(by.repeater('name in names').row(1).column('name')).getAttribute('class')).
+ toMatch(/even/);
+ });
+ </file>
+ </example>
+ *
+ * <hr />
+ * @example
+ * An example on how to implement animations using `ngClassEven`:
+ *
+ <example module="ngAnimate" deps="angular-animate.js" animations="true" name="ng-class-even-animate">
+ <file name="index.html">
+ <div ng-init="items=['Item 3', 'Item 2', 'Item 1', 'Item 0']">
+ <button ng-click="items.unshift('Item ' + items.length)">Add item</button>
+ <hr />
+ <table>
+ <tr ng-repeat="item in items" ng-class-even="'even'">
+ <td>{{ item }}</td>
+ </tr>
+ </table>
+ </div>
+ </file>
+ <file name="style.css">
+ .even {
+ background: rgba(255, 255, 0, 0.25);
+ }
+
+ .even-add, .even-remove {
+ transition: 1.5s;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should add new entries to the beginning of the list', function() {
+ var button = element(by.buttonText('Add item'));
+ var rows = element.all(by.repeater('item in items'));
+
+ expect(rows.count()).toBe(4);
+ expect(rows.get(0).getText()).toBe('Item 3');
+ expect(rows.get(1).getText()).toBe('Item 2');
+
+ button.click();
+
+ expect(rows.count()).toBe(5);
+ expect(rows.get(0).getText()).toBe('Item 4');
+ expect(rows.get(1).getText()).toBe('Item 3');
+ });
+
+ it('should add even class to even entries', function() {
+ var button = element(by.buttonText('Add item'));
+ var rows = element.all(by.repeater('item in items'));
+
+ expect(rows.get(0).getAttribute('class')).not.toMatch(/even/);
+ expect(rows.get(1).getAttribute('class')).toMatch(/even/);
+
+ button.click();
+
+ expect(rows.get(0).getAttribute('class')).not.toMatch(/even/);
+ expect(rows.get(1).getAttribute('class')).toMatch(/even/);
+ });
+ </file>
+ </example>
+ */
+var ngClassEvenDirective = classDirective('Even', 1);
+
+/**
+ * @ngdoc directive
+ * @name ngCloak
+ * @restrict AC
+ *
+ * @description
+ * The `ngCloak` directive is used to prevent the AngularJS html template from being briefly
+ * displayed by the browser in its raw (uncompiled) form while your application is loading. Use this
+ * directive to avoid the undesirable flicker effect caused by the html template display.
+ *
+ * The directive can be applied to the `<body>` element, but the preferred usage is to apply
+ * multiple `ngCloak` directives to small portions of the page to permit progressive rendering
+ * of the browser view.
+ *
+ * `ngCloak` works in cooperation with the following css rule embedded within `angular.js` and
+ * `angular.min.js`.
+ * For CSP mode please add `angular-csp.css` to your html file (see {@link ng.directive:ngCsp ngCsp}).
+ *
+ * ```css
+ * [ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak], .ng-cloak, .x-ng-cloak {
+ * display: none !important;
+ * }
+ * ```
+ *
+ * When this css rule is loaded by the browser, all html elements (including their children) that
+ * are tagged with the `ngCloak` directive are hidden. When AngularJS encounters this directive
+ * during the compilation of the template it deletes the `ngCloak` element attribute, making
+ * the compiled element visible.
+ *
+ * For the best result, the `angular.js` script must be loaded in the head section of the html
+ * document; alternatively, the css rule above must be included in the external stylesheet of the
+ * application.
+ *
+ * @element ANY
+ *
+ * @example
+ <example name="ng-cloak">
+ <file name="index.html">
+ <div id="template1" ng-cloak>{{ 'hello' }}</div>
+ <div id="template2" class="ng-cloak">{{ 'world' }}</div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should remove the template directive and css class', function() {
+ expect($('#template1').getAttribute('ng-cloak')).
+ toBeNull();
+ expect($('#template2').getAttribute('ng-cloak')).
+ toBeNull();
+ });
+ </file>
+ </example>
+ *
+ */
+var ngCloakDirective = ngDirective({
+ compile: function(element, attr) {
+ attr.$set('ngCloak', undefined);
+ element.removeClass('ng-cloak');
+ }
+});
+
+/**
+ * @ngdoc directive
+ * @name ngController
+ *
+ * @description
+ * The `ngController` directive attaches a controller class to the view. This is a key aspect of how angular
+ * supports the principles behind the Model-View-Controller design pattern.
+ *
+ * MVC components in angular:
+ *
+ * * Model — Models are the properties of a scope; scopes are attached to the DOM where scope properties
+ * are accessed through bindings.
+ * * View — The template (HTML with data bindings) that is rendered into the View.
+ * * Controller — The `ngController` directive specifies a Controller class; the class contains business
+ * logic behind the application to decorate the scope with functions and values
+ *
+ * Note that you can also attach controllers to the DOM by declaring it in a route definition
+ * via the {@link ngRoute.$route $route} service. A common mistake is to declare the controller
+ * again using `ng-controller` in the template itself. This will cause the controller to be attached
+ * and executed twice.
+ *
+ * @element ANY
+ * @scope
+ * @priority 500
+ * @param {expression} ngController Name of a constructor function registered with the current
+ * {@link ng.$controllerProvider $controllerProvider} or an {@link guide/expression expression}
+ * that on the current scope evaluates to a constructor function.
+ *
+ * The controller instance can be published into a scope property by specifying
+ * `ng-controller="as propertyName"`.
+ *
+ * @example
+ * Here is a simple form for editing user contact information. Adding, removing, clearing, and
+ * greeting are methods declared on the controller (see source tab). These methods can
+ * easily be called from the AngularJS markup. Any changes to the data are automatically reflected
+ * in the View without the need for a manual update.
+ *
+ * Two different declaration styles are included below:
+ *
+ * * one binds methods and properties directly onto the controller using `this`:
+ * `ng-controller="SettingsController1 as settings"`
+ * * one injects `$scope` into the controller:
+ * `ng-controller="SettingsController2"`
+ *
+ * The second option is more common in the AngularJS community, and is generally used in boilerplates
+ * and in this guide. However, there are advantages to binding properties directly to the controller
+ * and avoiding scope.
+ *
+ * * Using `controller as` makes it obvious which controller you are accessing in the template when
+ * multiple controllers apply to an element.
+ * * If you are writing your controllers as classes you have easier access to the properties and
+ * methods, which will appear on the scope, from inside the controller code.
+ * * Since there is always a `.` in the bindings, you don't have to worry about prototypal
+ * inheritance masking primitives.
+ *
+ * This example demonstrates the `controller as` syntax.
+ *
+ * <example name="ngControllerAs" module="controllerAsExample">
+ * <file name="index.html">
+ * <div id="ctrl-as-exmpl" ng-controller="SettingsController1 as settings">
+ * <label>Name: <input type="text" ng-model="settings.name"/></label>
+ * <button ng-click="settings.greet()">greet</button><br/>
+ * Contact:
+ * <ul>
+ * <li ng-repeat="contact in settings.contacts">
+ * <select ng-model="contact.type" aria-label="Contact method" id="select_{{$index}}">
+ * <option>phone</option>
+ * <option>email</option>
+ * </select>
+ * <input type="text" ng-model="contact.value" aria-labelledby="select_{{$index}}" />
+ * <button ng-click="settings.clearContact(contact)">clear</button>
+ * <button ng-click="settings.removeContact(contact)" aria-label="Remove">X</button>
+ * </li>
+ * <li><button ng-click="settings.addContact()">add</button></li>
+ * </ul>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('controllerAsExample', [])
+ * .controller('SettingsController1', SettingsController1);
+ *
+ * function SettingsController1() {
+ * this.name = 'John Smith';
+ * this.contacts = [
+ * {type: 'phone', value: '408 555 1212'},
+ * {type: 'email', value: 'john.smith@example.org'}
+ * ];
+ * }
+ *
+ * SettingsController1.prototype.greet = function() {
+ * alert(this.name);
+ * };
+ *
+ * SettingsController1.prototype.addContact = function() {
+ * this.contacts.push({type: 'email', value: 'yourname@example.org'});
+ * };
+ *
+ * SettingsController1.prototype.removeContact = function(contactToRemove) {
+ * var index = this.contacts.indexOf(contactToRemove);
+ * this.contacts.splice(index, 1);
+ * };
+ *
+ * SettingsController1.prototype.clearContact = function(contact) {
+ * contact.type = 'phone';
+ * contact.value = '';
+ * };
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * it('should check controller as', function() {
+ * var container = element(by.id('ctrl-as-exmpl'));
+ * expect(container.element(by.model('settings.name'))
+ * .getAttribute('value')).toBe('John Smith');
+ *
+ * var firstRepeat =
+ * container.element(by.repeater('contact in settings.contacts').row(0));
+ * var secondRepeat =
+ * container.element(by.repeater('contact in settings.contacts').row(1));
+ *
+ * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value'))
+ * .toBe('408 555 1212');
+ *
+ * expect(secondRepeat.element(by.model('contact.value')).getAttribute('value'))
+ * .toBe('john.smith@example.org');
+ *
+ * firstRepeat.element(by.buttonText('clear')).click();
+ *
+ * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value'))
+ * .toBe('');
+ *
+ * container.element(by.buttonText('add')).click();
+ *
+ * expect(container.element(by.repeater('contact in settings.contacts').row(2))
+ * .element(by.model('contact.value'))
+ * .getAttribute('value'))
+ * .toBe('yourname@example.org');
+ * });
+ * </file>
+ * </example>
+ *
+ * This example demonstrates the "attach to `$scope`" style of controller.
+ *
+ * <example name="ngController" module="controllerExample">
+ * <file name="index.html">
+ * <div id="ctrl-exmpl" ng-controller="SettingsController2">
+ * <label>Name: <input type="text" ng-model="name"/></label>
+ * <button ng-click="greet()">greet</button><br/>
+ * Contact:
+ * <ul>
+ * <li ng-repeat="contact in contacts">
+ * <select ng-model="contact.type" id="select_{{$index}}">
+ * <option>phone</option>
+ * <option>email</option>
+ * </select>
+ * <input type="text" ng-model="contact.value" aria-labelledby="select_{{$index}}" />
+ * <button ng-click="clearContact(contact)">clear</button>
+ * <button ng-click="removeContact(contact)">X</button>
+ * </li>
+ * <li>[ <button ng-click="addContact()">add</button> ]</li>
+ * </ul>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('controllerExample', [])
+ * .controller('SettingsController2', ['$scope', SettingsController2]);
+ *
+ * function SettingsController2($scope) {
+ * $scope.name = 'John Smith';
+ * $scope.contacts = [
+ * {type:'phone', value:'408 555 1212'},
+ * {type:'email', value:'john.smith@example.org'}
+ * ];
+ *
+ * $scope.greet = function() {
+ * alert($scope.name);
+ * };
+ *
+ * $scope.addContact = function() {
+ * $scope.contacts.push({type:'email', value:'yourname@example.org'});
+ * };
+ *
+ * $scope.removeContact = function(contactToRemove) {
+ * var index = $scope.contacts.indexOf(contactToRemove);
+ * $scope.contacts.splice(index, 1);
+ * };
+ *
+ * $scope.clearContact = function(contact) {
+ * contact.type = 'phone';
+ * contact.value = '';
+ * };
+ * }
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * it('should check controller', function() {
+ * var container = element(by.id('ctrl-exmpl'));
+ *
+ * expect(container.element(by.model('name'))
+ * .getAttribute('value')).toBe('John Smith');
+ *
+ * var firstRepeat =
+ * container.element(by.repeater('contact in contacts').row(0));
+ * var secondRepeat =
+ * container.element(by.repeater('contact in contacts').row(1));
+ *
+ * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value'))
+ * .toBe('408 555 1212');
+ * expect(secondRepeat.element(by.model('contact.value')).getAttribute('value'))
+ * .toBe('john.smith@example.org');
+ *
+ * firstRepeat.element(by.buttonText('clear')).click();
+ *
+ * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value'))
+ * .toBe('');
+ *
+ * container.element(by.buttonText('add')).click();
+ *
+ * expect(container.element(by.repeater('contact in contacts').row(2))
+ * .element(by.model('contact.value'))
+ * .getAttribute('value'))
+ * .toBe('yourname@example.org');
+ * });
+ * </file>
+ *</example>
+
+ */
+var ngControllerDirective = [function() {
+ return {
+ restrict: 'A',
+ scope: true,
+ controller: '@',
+ priority: 500
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngCsp
+ *
+ * @restrict A
+ * @element ANY
+ * @description
+ *
+ * AngularJS has some features that can conflict with certain restrictions that are applied when using
+ * [CSP (Content Security Policy)](https://developer.mozilla.org/en/Security/CSP) rules.
+ *
+ * If you intend to implement CSP with these rules then you must tell AngularJS not to use these
+ * features.
+ *
+ * This is necessary when developing things like Google Chrome Extensions or Universal Windows Apps.
+ *
+ *
+ * The following default rules in CSP affect AngularJS:
+ *
+ * * The use of `eval()`, `Function(string)` and similar functions to dynamically create and execute
+ * code from strings is forbidden. AngularJS makes use of this in the {@link $parse} service to
+ * provide a 30% increase in the speed of evaluating AngularJS expressions. (This CSP rule can be
+ * disabled with the CSP keyword `unsafe-eval`, but it is generally not recommended as it would
+ * weaken the protections offered by CSP.)
+ *
+ * * The use of inline resources, such as inline `<script>` and `<style>` elements, are forbidden.
+ * This prevents apps from injecting custom styles directly into the document. AngularJS makes use of
+ * this to include some CSS rules (e.g. {@link ngCloak} and {@link ngHide}). To make these
+ * directives work when a CSP rule is blocking inline styles, you must link to the `angular-csp.css`
+ * in your HTML manually. (This CSP rule can be disabled with the CSP keyword `unsafe-inline`, but
+ * it is generally not recommended as it would weaken the protections offered by CSP.)
+ *
+ * If you do not provide `ngCsp` then AngularJS tries to autodetect if CSP is blocking dynamic code
+ * creation from strings (e.g., `unsafe-eval` not specified in CSP header) and automatically
+ * deactivates this feature in the {@link $parse} service. This autodetection, however, triggers a
+ * CSP error to be logged in the console:
+ *
+ * ```
+ * Refused to evaluate a string as JavaScript because 'unsafe-eval' is not an allowed source of
+ * script in the following Content Security Policy directive: "default-src 'self'". Note that
+ * 'script-src' was not explicitly set, so 'default-src' is used as a fallback.
+ * ```
+ *
+ * This error is harmless but annoying. To prevent the error from showing up, put the `ngCsp`
+ * directive on an element of the HTML document that appears before the `<script>` tag that loads
+ * the `angular.js` file.
+ *
+ * *Note: This directive is only available in the `ng-csp` and `data-ng-csp` attribute form.*
+ *
+ * You can specify which of the CSP related AngularJS features should be deactivated by providing
+ * a value for the `ng-csp` attribute. The options are as follows:
+ *
+ * * no-inline-style: this stops AngularJS from injecting CSS styles into the DOM
+ *
+ * * no-unsafe-eval: this stops AngularJS from optimizing $parse with unsafe eval of strings
+ *
+ * You can use these values in the following combinations:
+ *
+ *
+ * * No declaration means that AngularJS will assume that you can do inline styles, but it will do
+ * a runtime check for unsafe-eval. E.g. `<body>`. This is backwardly compatible with previous
+ * versions of AngularJS.
+ *
+ * * A simple `ng-csp` (or `data-ng-csp`) attribute will tell AngularJS to deactivate both inline
+ * styles and unsafe eval. E.g. `<body ng-csp>`. This is backwardly compatible with previous
+ * versions of AngularJS.
+ *
+ * * Specifying only `no-unsafe-eval` tells AngularJS that we must not use eval, but that we can
+ * inject inline styles. E.g. `<body ng-csp="no-unsafe-eval">`.
+ *
+ * * Specifying only `no-inline-style` tells AngularJS that we must not inject styles, but that we can
+ * run eval - no automatic check for unsafe eval will occur. E.g. `<body ng-csp="no-inline-style">`
+ *
+ * * Specifying both `no-unsafe-eval` and `no-inline-style` tells AngularJS that we must not inject
+ * styles nor use eval, which is the same as an empty: ng-csp.
+ * E.g.`<body ng-csp="no-inline-style;no-unsafe-eval">`
+ *
+ * @example
+ *
+ * This example shows how to apply the `ngCsp` directive to the `html` tag.
+ ```html
+ <!doctype html>
+ <html ng-app ng-csp>
+ ...
+ ...
+ </html>
+ ```
+
+ <!-- Note: the `.csp` suffix in the example name triggers CSP mode in our http server! -->
+ <example name="example.csp" module="cspExample" ng-csp="true">
+ <file name="index.html">
+ <div ng-controller="MainController as ctrl">
+ <div>
+ <button ng-click="ctrl.inc()" id="inc">Increment</button>
+ <span id="counter">
+ {{ctrl.counter}}
+ </span>
+ </div>
+
+ <div>
+ <button ng-click="ctrl.evil()" id="evil">Evil</button>
+ <span id="evilError">
+ {{ctrl.evilError}}
+ </span>
+ </div>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('cspExample', [])
+ .controller('MainController', function MainController() {
+ this.counter = 0;
+ this.inc = function() {
+ this.counter++;
+ };
+ this.evil = function() {
+ try {
+ eval('1+2'); // eslint-disable-line no-eval
+ } catch (e) {
+ this.evilError = e.message;
+ }
+ };
+ });
+ </file>
+ <file name="protractor.js" type="protractor">
+ var util, webdriver;
+
+ var incBtn = element(by.id('inc'));
+ var counter = element(by.id('counter'));
+ var evilBtn = element(by.id('evil'));
+ var evilError = element(by.id('evilError'));
+
+ function getAndClearSevereErrors() {
+ return browser.manage().logs().get('browser').then(function(browserLog) {
+ return browserLog.filter(function(logEntry) {
+ return logEntry.level.value > webdriver.logging.Level.WARNING.value;
+ });
+ });
+ }
+
+ function clearErrors() {
+ getAndClearSevereErrors();
+ }
+
+ function expectNoErrors() {
+ getAndClearSevereErrors().then(function(filteredLog) {
+ expect(filteredLog.length).toEqual(0);
+ if (filteredLog.length) {
+ console.log('browser console errors: ' + util.inspect(filteredLog));
+ }
+ });
+ }
+
+ function expectError(regex) {
+ getAndClearSevereErrors().then(function(filteredLog) {
+ var found = false;
+ filteredLog.forEach(function(log) {
+ if (log.message.match(regex)) {
+ found = true;
+ }
+ });
+ if (!found) {
+ throw new Error('expected an error that matches ' + regex);
+ }
+ });
+ }
+
+ beforeEach(function() {
+ util = require('util');
+ webdriver = require('selenium-webdriver');
+ });
+
+ // For now, we only test on Chrome,
+ // as Safari does not load the page with Protractor's injected scripts,
+ // and Firefox webdriver always disables content security policy (#6358)
+ if (browser.params.browser !== 'chrome') {
+ return;
+ }
+
+ it('should not report errors when the page is loaded', function() {
+ // clear errors so we are not dependent on previous tests
+ clearErrors();
+ // Need to reload the page as the page is already loaded when
+ // we come here
+ browser.driver.getCurrentUrl().then(function(url) {
+ browser.get(url);
+ });
+ expectNoErrors();
+ });
+
+ it('should evaluate expressions', function() {
+ expect(counter.getText()).toEqual('0');
+ incBtn.click();
+ expect(counter.getText()).toEqual('1');
+ expectNoErrors();
+ });
+
+ it('should throw and report an error when using "eval"', function() {
+ evilBtn.click();
+ expect(evilError.getText()).toMatch(/Content Security Policy/);
+ expectError(/Content Security Policy/);
+ });
+ </file>
+ </example>
+ */
+
+// `ngCsp` is not implemented as a proper directive any more, because we need it be processed while
+// we bootstrap the app (before `$parse` is instantiated). For this reason, we just have the `csp()`
+// fn that looks for the `ng-csp` attribute anywhere in the current doc.
+
+/**
+ * @ngdoc directive
+ * @name ngClick
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * The ngClick directive allows you to specify custom behavior when
+ * an element is clicked.
+ *
+ * @param {expression} ngClick {@link guide/expression Expression} to evaluate upon
+ * click. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-click">
+ <file name="index.html">
+ <button ng-click="count = count + 1" ng-init="count=0">
+ Increment
+ </button>
+ <span>
+ count: {{count}}
+ </span>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ng-click', function() {
+ expect(element(by.binding('count')).getText()).toMatch('0');
+ element(by.css('button')).click();
+ expect(element(by.binding('count')).getText()).toMatch('1');
+ });
+ </file>
+ </example>
+ */
+/*
+ * A collection of directives that allows creation of custom event handlers that are defined as
+ * AngularJS expressions and are compiled and executed within the current scope.
+ */
+var ngEventDirectives = {};
+
+// For events that might fire synchronously during DOM manipulation
+// we need to execute their event handlers asynchronously using $evalAsync,
+// so that they are not executed in an inconsistent state.
+var forceAsyncEvents = {
+ 'blur': true,
+ 'focus': true
+};
+forEach(
+ 'click dblclick mousedown mouseup mouseover mouseout mousemove mouseenter mouseleave keydown keyup keypress submit focus blur copy cut paste'.split(' '),
+ function(eventName) {
+ var directiveName = directiveNormalize('ng-' + eventName);
+ ngEventDirectives[directiveName] = ['$parse', '$rootScope', '$exceptionHandler', function($parse, $rootScope, $exceptionHandler) {
+ return createEventDirective($parse, $rootScope, $exceptionHandler, directiveName, eventName, forceAsyncEvents[eventName]);
+ }];
+ }
+);
+
+function createEventDirective($parse, $rootScope, $exceptionHandler, directiveName, eventName, forceAsync) {
+ return {
+ restrict: 'A',
+ compile: function($element, attr) {
+ // NOTE:
+ // We expose the powerful `$event` object on the scope that provides access to the Window,
+ // etc. This is OK, because expressions are not sandboxed any more (and the expression
+ // sandbox was never meant to be a security feature anyway).
+ var fn = $parse(attr[directiveName]);
+ return function ngEventHandler(scope, element) {
+ element.on(eventName, function(event) {
+ var callback = function() {
+ fn(scope, {$event: event});
+ };
+
+ if (!$rootScope.$$phase) {
+ scope.$apply(callback);
+ } else if (forceAsync) {
+ scope.$evalAsync(callback);
+ } else {
+ try {
+ callback();
+ } catch (error) {
+ $exceptionHandler(error);
+ }
+ }
+ });
+ };
+ }
+ };
+}
+
+/**
+ * @ngdoc directive
+ * @name ngDblclick
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * The `ngDblclick` directive allows you to specify custom behavior on a dblclick event.
+ *
+ * @param {expression} ngDblclick {@link guide/expression Expression} to evaluate upon
+ * a dblclick. (The Event object is available as `$event`)
+ *
+ * @example
+ <example name="ng-dblclick">
+ <file name="index.html">
+ <button ng-dblclick="count = count + 1" ng-init="count=0">
+ Increment (on double click)
+ </button>
+ count: {{count}}
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngMousedown
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * The ngMousedown directive allows you to specify custom behavior on mousedown event.
+ *
+ * @param {expression} ngMousedown {@link guide/expression Expression} to evaluate upon
+ * mousedown. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-mousedown">
+ <file name="index.html">
+ <button ng-mousedown="count = count + 1" ng-init="count=0">
+ Increment (on mouse down)
+ </button>
+ count: {{count}}
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngMouseup
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on mouseup event.
+ *
+ * @param {expression} ngMouseup {@link guide/expression Expression} to evaluate upon
+ * mouseup. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-mouseup">
+ <file name="index.html">
+ <button ng-mouseup="count = count + 1" ng-init="count=0">
+ Increment (on mouse up)
+ </button>
+ count: {{count}}
+ </file>
+ </example>
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngMouseover
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on mouseover event.
+ *
+ * @param {expression} ngMouseover {@link guide/expression Expression} to evaluate upon
+ * mouseover. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-mouseover">
+ <file name="index.html">
+ <button ng-mouseover="count = count + 1" ng-init="count=0">
+ Increment (when mouse is over)
+ </button>
+ count: {{count}}
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngMouseenter
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on mouseenter event.
+ *
+ * @param {expression} ngMouseenter {@link guide/expression Expression} to evaluate upon
+ * mouseenter. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-mouseenter">
+ <file name="index.html">
+ <button ng-mouseenter="count = count + 1" ng-init="count=0">
+ Increment (when mouse enters)
+ </button>
+ count: {{count}}
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngMouseleave
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on mouseleave event.
+ *
+ * @param {expression} ngMouseleave {@link guide/expression Expression} to evaluate upon
+ * mouseleave. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-mouseleave">
+ <file name="index.html">
+ <button ng-mouseleave="count = count + 1" ng-init="count=0">
+ Increment (when mouse leaves)
+ </button>
+ count: {{count}}
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngMousemove
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on mousemove event.
+ *
+ * @param {expression} ngMousemove {@link guide/expression Expression} to evaluate upon
+ * mousemove. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-mousemove">
+ <file name="index.html">
+ <button ng-mousemove="count = count + 1" ng-init="count=0">
+ Increment (when mouse moves)
+ </button>
+ count: {{count}}
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngKeydown
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on keydown event.
+ *
+ * @param {expression} ngKeydown {@link guide/expression Expression} to evaluate upon
+ * keydown. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.)
+ *
+ * @example
+ <example name="ng-keydown">
+ <file name="index.html">
+ <input ng-keydown="count = count + 1" ng-init="count=0">
+ key down count: {{count}}
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngKeyup
+ * @restrict A
+ * @element ANY
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on keyup event.
+ *
+ * @param {expression} ngKeyup {@link guide/expression Expression} to evaluate upon
+ * keyup. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.)
+ *
+ * @example
+ <example name="ng-keyup">
+ <file name="index.html">
+ <p>Typing in the input box below updates the key count</p>
+ <input ng-keyup="count = count + 1" ng-init="count=0"> key up count: {{count}}
+
+ <p>Typing in the input box below updates the keycode</p>
+ <input ng-keyup="event=$event">
+ <p>event keyCode: {{ event.keyCode }}</p>
+ <p>event altKey: {{ event.altKey }}</p>
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngKeypress
+ * @restrict A
+ * @element ANY
+ *
+ * @description
+ * Specify custom behavior on keypress event.
+ *
+ * @param {expression} ngKeypress {@link guide/expression Expression} to evaluate upon
+ * keypress. ({@link guide/expression#-event- Event object is available as `$event`}
+ * and can be interrogated for keyCode, altKey, etc.)
+ *
+ * @example
+ <example name="ng-keypress">
+ <file name="index.html">
+ <input ng-keypress="count = count + 1" ng-init="count=0">
+ key press count: {{count}}
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc directive
+ * @name ngSubmit
+ * @restrict A
+ * @element form
+ * @priority 0
+ *
+ * @description
+ * Enables binding AngularJS expressions to onsubmit events.
+ *
+ * Additionally it prevents the default action (which for form means sending the request to the
+ * server and reloading the current page), but only if the form does not contain `action`,
+ * `data-action`, or `x-action` attributes.
+ *
+ * <div class="alert alert-warning">
+ * **Warning:** Be careful not to cause "double-submission" by using both the `ngClick` and
+ * `ngSubmit` handlers together. See the
+ * {@link form#submitting-a-form-and-preventing-the-default-action `form` directive documentation}
+ * for a detailed discussion of when `ngSubmit` may be triggered.
+ * </div>
+ *
+ * @param {expression} ngSubmit {@link guide/expression Expression} to eval.
+ * ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example module="submitExample" name="ng-submit">
+ <file name="index.html">
+ <script>
+ angular.module('submitExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.list = [];
+ $scope.text = 'hello';
+ $scope.submit = function() {
+ if ($scope.text) {
+ $scope.list.push(this.text);
+ $scope.text = '';
+ }
+ };
+ }]);
+ </script>
+ <form ng-submit="submit()" ng-controller="ExampleController">
+ Enter text and hit enter:
+ <input type="text" ng-model="text" name="text" />
+ <input type="submit" id="submit" value="Submit" />
+ <pre>list={{list}}</pre>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ng-submit', function() {
+ expect(element(by.binding('list')).getText()).toBe('list=[]');
+ element(by.css('#submit')).click();
+ expect(element(by.binding('list')).getText()).toContain('hello');
+ expect(element(by.model('text')).getAttribute('value')).toBe('');
+ });
+ it('should ignore empty strings', function() {
+ expect(element(by.binding('list')).getText()).toBe('list=[]');
+ element(by.css('#submit')).click();
+ element(by.css('#submit')).click();
+ expect(element(by.binding('list')).getText()).toContain('hello');
+ });
+ </file>
+ </example>
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngFocus
+ * @restrict A
+ * @element window, input, select, textarea, a
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on focus event.
+ *
+ * Note: As the `focus` event is executed synchronously when calling `input.focus()`
+ * AngularJS executes the expression using `scope.$evalAsync` if the event is fired
+ * during an `$apply` to ensure a consistent state.
+ *
+ * @param {expression} ngFocus {@link guide/expression Expression} to evaluate upon
+ * focus. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ * See {@link ng.directive:ngClick ngClick}
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngBlur
+ * @restrict A
+ * @element window, input, select, textarea, a
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on blur event.
+ *
+ * A [blur event](https://developer.mozilla.org/en-US/docs/Web/Events/blur) fires when
+ * an element has lost focus.
+ *
+ * Note: As the `blur` event is executed synchronously also during DOM manipulations
+ * (e.g. removing a focussed input),
+ * AngularJS executes the expression using `scope.$evalAsync` if the event is fired
+ * during an `$apply` to ensure a consistent state.
+ *
+ * @param {expression} ngBlur {@link guide/expression Expression} to evaluate upon
+ * blur. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ * See {@link ng.directive:ngClick ngClick}
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngCopy
+ * @restrict A
+ * @element window, input, select, textarea, a
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on copy event.
+ *
+ * @param {expression} ngCopy {@link guide/expression Expression} to evaluate upon
+ * copy. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-copy">
+ <file name="index.html">
+ <input ng-copy="copied=true" ng-init="copied=false; value='copy me'" ng-model="value">
+ copied: {{copied}}
+ </file>
+ </example>
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngCut
+ * @restrict A
+ * @element window, input, select, textarea, a
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on cut event.
+ *
+ * @param {expression} ngCut {@link guide/expression Expression} to evaluate upon
+ * cut. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-cut">
+ <file name="index.html">
+ <input ng-cut="cut=true" ng-init="cut=false; value='cut me'" ng-model="value">
+ cut: {{cut}}
+ </file>
+ </example>
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngPaste
+ * @restrict A
+ * @element window, input, select, textarea, a
+ * @priority 0
+ *
+ * @description
+ * Specify custom behavior on paste event.
+ *
+ * @param {expression} ngPaste {@link guide/expression Expression} to evaluate upon
+ * paste. ({@link guide/expression#-event- Event object is available as `$event`})
+ *
+ * @example
+ <example name="ng-paste">
+ <file name="index.html">
+ <input ng-paste="paste=true" ng-init="paste=false" placeholder='paste here'>
+ pasted: {{paste}}
+ </file>
+ </example>
+ */
+
+/**
+ * @ngdoc directive
+ * @name ngIf
+ * @restrict A
+ * @multiElement
+ *
+ * @description
+ * The `ngIf` directive removes or recreates a portion of the DOM tree based on an
+ * {expression}. If the expression assigned to `ngIf` evaluates to a false
+ * value then the element is removed from the DOM, otherwise a clone of the
+ * element is reinserted into the DOM.
+ *
+ * `ngIf` differs from `ngShow` and `ngHide` in that `ngIf` completely removes and recreates the
+ * element in the DOM rather than changing its visibility via the `display` css property. A common
+ * case when this difference is significant is when using css selectors that rely on an element's
+ * position within the DOM, such as the `:first-child` or `:last-child` pseudo-classes.
+ *
+ * Note that when an element is removed using `ngIf` its scope is destroyed and a new scope
+ * is created when the element is restored. The scope created within `ngIf` inherits from
+ * its parent scope using
+ * [prototypal inheritance](https://github.com/angular/angular.js/wiki/Understanding-Scopes#javascript-prototypal-inheritance).
+ * An important implication of this is if `ngModel` is used within `ngIf` to bind to
+ * a javascript primitive defined in the parent scope. In this case any modifications made to the
+ * variable within the child scope will override (hide) the value in the parent scope.
+ *
+ * Also, `ngIf` recreates elements using their compiled state. An example of this behavior
+ * is if an element's class attribute is directly modified after it's compiled, using something like
+ * jQuery's `.addClass()` method, and the element is later removed. When `ngIf` recreates the element
+ * the added class will be lost because the original compiled state is used to regenerate the element.
+ *
+ * Additionally, you can provide animations via the `ngAnimate` module to animate the `enter`
+ * and `leave` effects.
+ *
+ * @animations
+ * | Animation | Occurs |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#enter enter} | just after the `ngIf` contents change and a new DOM element is created and injected into the `ngIf` container |
+ * | {@link ng.$animate#leave leave} | just before the `ngIf` contents are removed from the DOM |
+ *
+ * @element ANY
+ * @scope
+ * @priority 600
+ * @param {expression} ngIf If the {@link guide/expression expression} is falsy then
+ * the element is removed from the DOM tree. If it is truthy a copy of the compiled
+ * element is added to the DOM tree.
+ *
+ * @example
+ <example module="ngAnimate" deps="angular-animate.js" animations="true" name="ng-if">
+ <file name="index.html">
+ <label>Click me: <input type="checkbox" ng-model="checked" ng-init="checked=true" /></label><br/>
+ Show when checked:
+ <span ng-if="checked" class="animate-if">
+ This is removed when the checkbox is unchecked.
+ </span>
+ </file>
+ <file name="animations.css">
+ .animate-if {
+ background:white;
+ border:1px solid black;
+ padding:10px;
+ }
+
+ .animate-if.ng-enter, .animate-if.ng-leave {
+ transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
+ }
+
+ .animate-if.ng-enter,
+ .animate-if.ng-leave.ng-leave-active {
+ opacity:0;
+ }
+
+ .animate-if.ng-leave,
+ .animate-if.ng-enter.ng-enter-active {
+ opacity:1;
+ }
+ </file>
+ </example>
+ */
+var ngIfDirective = ['$animate', '$compile', function($animate, $compile) {
+ return {
+ multiElement: true,
+ transclude: 'element',
+ priority: 600,
+ terminal: true,
+ restrict: 'A',
+ $$tlb: true,
+ link: function($scope, $element, $attr, ctrl, $transclude) {
+ var block, childScope, previousElements;
+ $scope.$watch($attr.ngIf, function ngIfWatchAction(value) {
+
+ if (value) {
+ if (!childScope) {
+ $transclude(function(clone, newScope) {
+ childScope = newScope;
+ clone[clone.length++] = $compile.$$createComment('end ngIf', $attr.ngIf);
+ // Note: We only need the first/last node of the cloned nodes.
+ // However, we need to keep the reference to the jqlite wrapper as it might be changed later
+ // by a directive with templateUrl when its template arrives.
+ block = {
+ clone: clone
+ };
+ $animate.enter(clone, $element.parent(), $element);
+ });
+ }
+ } else {
+ if (previousElements) {
+ previousElements.remove();
+ previousElements = null;
+ }
+ if (childScope) {
+ childScope.$destroy();
+ childScope = null;
+ }
+ if (block) {
+ previousElements = getBlockNodes(block.clone);
+ $animate.leave(previousElements).done(function(response) {
+ if (response !== false) previousElements = null;
+ });
+ block = null;
+ }
+ }
+ });
+ }
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngInclude
+ * @restrict ECA
+ * @scope
+ * @priority -400
+ *
+ * @description
+ * Fetches, compiles and includes an external HTML fragment.
+ *
+ * By default, the template URL is restricted to the same domain and protocol as the
+ * application document. This is done by calling {@link $sce#getTrustedResourceUrl
+ * $sce.getTrustedResourceUrl} on it. To load templates from other domains or protocols
+ * you may either add them to your {@link ng.$sceDelegateProvider#trustedResourceUrlList trusted
+ * resource URL list} or {@link $sce#trustAsResourceUrl wrap them} as trusted values. Refer to
+ * AngularJS's {@link ng.$sce Strict Contextual Escaping}.
+ *
+ * In addition, the browser's
+ * [Same Origin Policy](https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest)
+ * and [Cross-Origin Resource Sharing (CORS)](http://www.w3.org/TR/cors/)
+ * policy may further restrict whether the template is successfully loaded.
+ * For example, `ngInclude` won't work for cross-domain requests on all browsers and for `file://`
+ * access on some browsers.
+ *
+ * @animations
+ * | Animation | Occurs |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#enter enter} | when the expression changes, on the new include |
+ * | {@link ng.$animate#leave leave} | when the expression changes, on the old include |
+ *
+ * The enter and leave animation occur concurrently.
+ *
+ * @param {string} ngInclude|src AngularJS expression evaluating to URL. If the source is a string constant,
+ * make sure you wrap it in **single** quotes, e.g. `src="'myPartialTemplate.html'"`.
+ * @param {string=} onload Expression to evaluate when a new partial is loaded.
+ * <div class="alert alert-warning">
+ * **Note:** When using onload on SVG elements in IE11, the browser will try to call
+ * a function with the name on the window element, which will usually throw a
+ * "function is undefined" error. To fix this, you can instead use `data-onload` or a
+ * different form that {@link guide/directive#normalization matches} `onload`.
+ * </div>
+ *
+ * @param {string=} autoscroll Whether `ngInclude` should call {@link ng.$anchorScroll
+ * $anchorScroll} to scroll the viewport after the content is loaded.
+ *
+ * - If the attribute is not set, disable scrolling.
+ * - If the attribute is set without value, enable scrolling.
+ * - Otherwise enable scrolling only if the expression evaluates to truthy value.
+ *
+ * @example
+ <example module="includeExample" deps="angular-animate.js" animations="true" name="ng-include">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <select ng-model="template" ng-options="t.name for t in templates">
+ <option value="">(blank)</option>
+ </select>
+ url of the template: <code>{{template.url}}</code>
+ <hr/>
+ <div class="slide-animate-container">
+ <div class="slide-animate" ng-include="template.url"></div>
+ </div>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('includeExample', ['ngAnimate'])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.templates =
+ [{ name: 'template1.html', url: 'template1.html'},
+ { name: 'template2.html', url: 'template2.html'}];
+ $scope.template = $scope.templates[0];
+ }]);
+ </file>
+ <file name="template1.html">
+ Content of template1.html
+ </file>
+ <file name="template2.html">
+ Content of template2.html
+ </file>
+ <file name="animations.css">
+ .slide-animate-container {
+ position:relative;
+ background:white;
+ border:1px solid black;
+ height:40px;
+ overflow:hidden;
+ }
+
+ .slide-animate {
+ padding:10px;
+ }
+
+ .slide-animate.ng-enter, .slide-animate.ng-leave {
+ transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
+
+ position:absolute;
+ top:0;
+ left:0;
+ right:0;
+ bottom:0;
+ display:block;
+ padding:10px;
+ }
+
+ .slide-animate.ng-enter {
+ top:-50px;
+ }
+ .slide-animate.ng-enter.ng-enter-active {
+ top:0;
+ }
+
+ .slide-animate.ng-leave {
+ top:0;
+ }
+ .slide-animate.ng-leave.ng-leave-active {
+ top:50px;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ var templateSelect = element(by.model('template'));
+ var includeElem = element(by.css('[ng-include]'));
+
+ it('should load template1.html', function() {
+ expect(includeElem.getText()).toMatch(/Content of template1.html/);
+ });
+
+ it('should load template2.html', function() {
+ if (browser.params.browser === 'firefox') {
+ // Firefox can't handle using selects
+ // See https://github.com/angular/protractor/issues/480
+ return;
+ }
+ templateSelect.click();
+ templateSelect.all(by.css('option')).get(2).click();
+ expect(includeElem.getText()).toMatch(/Content of template2.html/);
+ });
+
+ it('should change to blank', function() {
+ if (browser.params.browser === 'firefox') {
+ // Firefox can't handle using selects
+ return;
+ }
+ templateSelect.click();
+ templateSelect.all(by.css('option')).get(0).click();
+ expect(includeElem.isPresent()).toBe(false);
+ });
+ </file>
+ </example>
+ */
+
+
+/**
+ * @ngdoc event
+ * @name ngInclude#$includeContentRequested
+ * @eventType emit on the scope ngInclude was declared in
+ * @description
+ * Emitted every time the ngInclude content is requested.
+ *
+ * @param {Object} angularEvent Synthetic event object.
+ * @param {String} src URL of content to load.
+ */
+
+
+/**
+ * @ngdoc event
+ * @name ngInclude#$includeContentLoaded
+ * @eventType emit on the current ngInclude scope
+ * @description
+ * Emitted every time the ngInclude content is reloaded.
+ *
+ * @param {Object} angularEvent Synthetic event object.
+ * @param {String} src URL of content to load.
+ */
+
+
+/**
+ * @ngdoc event
+ * @name ngInclude#$includeContentError
+ * @eventType emit on the scope ngInclude was declared in
+ * @description
+ * Emitted when a template HTTP request yields an erroneous response (status < 200 || status > 299)
+ *
+ * @param {Object} angularEvent Synthetic event object.
+ * @param {String} src URL of content to load.
+ */
+var ngIncludeDirective = ['$templateRequest', '$anchorScroll', '$animate',
+ function($templateRequest, $anchorScroll, $animate) {
+ return {
+ restrict: 'ECA',
+ priority: 400,
+ terminal: true,
+ transclude: 'element',
+ controller: angular.noop,
+ compile: function(element, attr) {
+ var srcExp = attr.ngInclude || attr.src,
+ onloadExp = attr.onload || '',
+ autoScrollExp = attr.autoscroll;
+
+ return function(scope, $element, $attr, ctrl, $transclude) {
+ var changeCounter = 0,
+ currentScope,
+ previousElement,
+ currentElement;
+
+ var cleanupLastIncludeContent = function() {
+ if (previousElement) {
+ previousElement.remove();
+ previousElement = null;
+ }
+ if (currentScope) {
+ currentScope.$destroy();
+ currentScope = null;
+ }
+ if (currentElement) {
+ $animate.leave(currentElement).done(function(response) {
+ if (response !== false) previousElement = null;
+ });
+ previousElement = currentElement;
+ currentElement = null;
+ }
+ };
+
+ scope.$watch(srcExp, function ngIncludeWatchAction(src) {
+ var afterAnimation = function(response) {
+ if (response !== false && isDefined(autoScrollExp) &&
+ (!autoScrollExp || scope.$eval(autoScrollExp))) {
+ $anchorScroll();
+ }
+ };
+ var thisChangeId = ++changeCounter;
+
+ if (src) {
+ //set the 2nd param to true to ignore the template request error so that the inner
+ //contents and scope can be cleaned up.
+ $templateRequest(src, true).then(function(response) {
+ if (scope.$$destroyed) return;
+
+ if (thisChangeId !== changeCounter) return;
+ var newScope = scope.$new();
+ ctrl.template = response;
+
+ // Note: This will also link all children of ng-include that were contained in the original
+ // html. If that content contains controllers, ... they could pollute/change the scope.
+ // However, using ng-include on an element with additional content does not make sense...
+ // Note: We can't remove them in the cloneAttchFn of $transclude as that
+ // function is called before linking the content, which would apply child
+ // directives to non existing elements.
+ var clone = $transclude(newScope, function(clone) {
+ cleanupLastIncludeContent();
+ $animate.enter(clone, null, $element).done(afterAnimation);
+ });
+
+ currentScope = newScope;
+ currentElement = clone;
+
+ currentScope.$emit('$includeContentLoaded', src);
+ scope.$eval(onloadExp);
+ }, function() {
+ if (scope.$$destroyed) return;
+
+ if (thisChangeId === changeCounter) {
+ cleanupLastIncludeContent();
+ scope.$emit('$includeContentError', src);
+ }
+ });
+ scope.$emit('$includeContentRequested', src);
+ } else {
+ cleanupLastIncludeContent();
+ ctrl.template = null;
+ }
+ });
+ };
+ }
+ };
+}];
+
+// This directive is called during the $transclude call of the first `ngInclude` directive.
+// It will replace and compile the content of the element with the loaded template.
+// We need this directive so that the element content is already filled when
+// the link function of another directive on the same element as ngInclude
+// is called.
+var ngIncludeFillContentDirective = ['$compile',
+ function($compile) {
+ return {
+ restrict: 'ECA',
+ priority: -400,
+ require: 'ngInclude',
+ link: function(scope, $element, $attr, ctrl) {
+ if (toString.call($element[0]).match(/SVG/)) {
+ // WebKit: https://bugs.webkit.org/show_bug.cgi?id=135698 --- SVG elements do not
+ // support innerHTML, so detect this here and try to generate the contents
+ // specially.
+ $element.empty();
+ $compile(jqLiteBuildFragment(ctrl.template, window.document).childNodes)(scope,
+ function namespaceAdaptedClone(clone) {
+ $element.append(clone);
+ }, {futureParentElement: $element});
+ return;
+ }
+
+ $element.html(ctrl.template);
+ $compile($element.contents())(scope);
+ }
+ };
+ }];
+
+/**
+ * @ngdoc directive
+ * @name ngInit
+ * @restrict AC
+ * @priority 450
+ * @element ANY
+ *
+ * @param {expression} ngInit {@link guide/expression Expression} to eval.
+ *
+ * @description
+ * The `ngInit` directive allows you to evaluate an expression in the
+ * current scope.
+ *
+ * <div class="alert alert-danger">
+ * This directive can be abused to add unnecessary amounts of logic into your templates.
+ * There are only a few appropriate uses of `ngInit`:
+ * <ul>
+ * <li>aliasing special properties of {@link ng.directive:ngRepeat `ngRepeat`},
+ * as seen in the demo below.</li>
+ * <li>initializing data during development, or for examples, as seen throughout these docs.</li>
+ * <li>injecting data via server side scripting.</li>
+ * </ul>
+ *
+ * Besides these few cases, you should use {@link guide/component Components} or
+ * {@link guide/controller Controllers} rather than `ngInit` to initialize values on a scope.
+ * </div>
+ *
+ * <div class="alert alert-warning">
+ * **Note**: If you have assignment in `ngInit` along with a {@link ng.$filter `filter`}, make
+ * sure you have parentheses to ensure correct operator precedence:
+ * <pre class="prettyprint">
+ * `<div ng-init="test1 = ($index | toString)"></div>`
+ * </pre>
+ * </div>
+ *
+ * @example
+ <example module="initExample" name="ng-init">
+ <file name="index.html">
+ <script>
+ angular.module('initExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.list = [['a', 'b'], ['c', 'd']];
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <div ng-repeat="innerList in list" ng-init="outerIndex = $index">
+ <div ng-repeat="value in innerList" ng-init="innerIndex = $index">
+ <span class="example-init">list[ {{outerIndex}} ][ {{innerIndex}} ] = {{value}};</span>
+ </div>
+ </div>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should alias index positions', function() {
+ var elements = element.all(by.css('.example-init'));
+ expect(elements.get(0).getText()).toBe('list[ 0 ][ 0 ] = a;');
+ expect(elements.get(1).getText()).toBe('list[ 0 ][ 1 ] = b;');
+ expect(elements.get(2).getText()).toBe('list[ 1 ][ 0 ] = c;');
+ expect(elements.get(3).getText()).toBe('list[ 1 ][ 1 ] = d;');
+ });
+ </file>
+ </example>
+ */
+var ngInitDirective = ngDirective({
+ priority: 450,
+ compile: function() {
+ return {
+ pre: function(scope, element, attrs) {
+ scope.$eval(attrs.ngInit);
+ }
+ };
+ }
+});
+
+/**
+ * @ngdoc directive
+ * @name ngList
+ * @restrict A
+ * @priority 100
+ *
+ * @param {string=} ngList optional delimiter that should be used to split the value.
+ *
+ * @description
+ * Text input that converts between a delimited string and an array of strings. The default
+ * delimiter is a comma followed by a space - equivalent to `ng-list=", "`. You can specify a custom
+ * delimiter as the value of the `ngList` attribute - for example, `ng-list=" | "`.
+ *
+ * The behaviour of the directive is affected by the use of the `ngTrim` attribute.
+ * * If `ngTrim` is set to `"false"` then whitespace around both the separator and each
+ * list item is respected. This implies that the user of the directive is responsible for
+ * dealing with whitespace but also allows you to use whitespace as a delimiter, such as a
+ * tab or newline character.
+ * * Otherwise whitespace around the delimiter is ignored when splitting (although it is respected
+ * when joining the list items back together) and whitespace around each list item is stripped
+ * before it is added to the model.
+ *
+ * @example
+ * ### Validation
+ *
+ * <example name="ngList-directive" module="listExample">
+ * <file name="app.js">
+ * angular.module('listExample', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.names = ['morpheus', 'neo', 'trinity'];
+ * }]);
+ * </file>
+ * <file name="index.html">
+ * <form name="myForm" ng-controller="ExampleController">
+ * <label>List: <input name="namesInput" ng-model="names" ng-list required></label>
+ * <span role="alert">
+ * <span class="error" ng-show="myForm.namesInput.$error.required">
+ * Required!</span>
+ * </span>
+ * <br>
+ * <tt>names = {{names}}</tt><br/>
+ * <tt>myForm.namesInput.$valid = {{myForm.namesInput.$valid}}</tt><br/>
+ * <tt>myForm.namesInput.$error = {{myForm.namesInput.$error}}</tt><br/>
+ * <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+ * <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+ * </form>
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * var listInput = element(by.model('names'));
+ * var names = element(by.exactBinding('names'));
+ * var valid = element(by.binding('myForm.namesInput.$valid'));
+ * var error = element(by.css('span.error'));
+ *
+ * it('should initialize to model', function() {
+ * expect(names.getText()).toContain('["morpheus","neo","trinity"]');
+ * expect(valid.getText()).toContain('true');
+ * expect(error.getCssValue('display')).toBe('none');
+ * });
+ *
+ * it('should be invalid if empty', function() {
+ * listInput.clear();
+ * listInput.sendKeys('');
+ *
+ * expect(names.getText()).toContain('');
+ * expect(valid.getText()).toContain('false');
+ * expect(error.getCssValue('display')).not.toBe('none');
+ * });
+ * </file>
+ * </example>
+ *
+ * @example
+ * ### Splitting on newline
+ *
+ * <example name="ngList-directive-newlines">
+ * <file name="index.html">
+ * <textarea ng-model="list" ng-list=" " ng-trim="false"></textarea>
+ * <pre>{{ list | json }}</pre>
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * it("should split the text by newlines", function() {
+ * var listInput = element(by.model('list'));
+ * var output = element(by.binding('list | json'));
+ * listInput.sendKeys('abc\ndef\nghi');
+ * expect(output.getText()).toContain('[\n "abc",\n "def",\n "ghi"\n]');
+ * });
+ * </file>
+ * </example>
+ *
+ */
+var ngListDirective = function() {
+ return {
+ restrict: 'A',
+ priority: 100,
+ require: 'ngModel',
+ link: function(scope, element, attr, ctrl) {
+ var ngList = attr.ngList || ', ';
+ var trimValues = attr.ngTrim !== 'false';
+ var separator = trimValues ? trim(ngList) : ngList;
+
+ var parse = function(viewValue) {
+ // If the viewValue is invalid (say required but empty) it will be `undefined`
+ if (isUndefined(viewValue)) return;
+
+ var list = [];
+
+ if (viewValue) {
+ forEach(viewValue.split(separator), function(value) {
+ if (value) list.push(trimValues ? trim(value) : value);
+ });
+ }
+
+ return list;
+ };
+
+ ctrl.$parsers.push(parse);
+ ctrl.$formatters.push(function(value) {
+ if (isArray(value)) {
+ return value.join(ngList);
+ }
+
+ return undefined;
+ });
+
+ // Override the standard $isEmpty because an empty array means the input is empty.
+ ctrl.$isEmpty = function(value) {
+ return !value || !value.length;
+ };
+ }
+ };
+};
+
+/* global VALID_CLASS: true,
+ INVALID_CLASS: true,
+ PRISTINE_CLASS: true,
+ DIRTY_CLASS: true,
+ UNTOUCHED_CLASS: true,
+ TOUCHED_CLASS: true,
+ PENDING_CLASS: true,
+ addSetValidityMethod: true,
+ setupValidity: true,
+ defaultModelOptions: false
+*/
+
+
+var VALID_CLASS = 'ng-valid',
+ INVALID_CLASS = 'ng-invalid',
+ PRISTINE_CLASS = 'ng-pristine',
+ DIRTY_CLASS = 'ng-dirty',
+ UNTOUCHED_CLASS = 'ng-untouched',
+ TOUCHED_CLASS = 'ng-touched',
+ EMPTY_CLASS = 'ng-empty',
+ NOT_EMPTY_CLASS = 'ng-not-empty';
+
+var ngModelMinErr = minErr('ngModel');
+
+/**
+ * @ngdoc type
+ * @name ngModel.NgModelController
+ * @property {*} $viewValue The actual value from the control's view. For `input` elements, this is a
+ * String. See {@link ngModel.NgModelController#$setViewValue} for information about when the $viewValue
+ * is set.
+ *
+ * @property {*} $modelValue The value in the model that the control is bound to.
+ *
+ * @property {Array.<Function>} $parsers Array of functions to execute, as a pipeline, whenever
+ * the control updates the ngModelController with a new {@link ngModel.NgModelController#$viewValue
+ `$viewValue`} from the DOM, usually via user input.
+ See {@link ngModel.NgModelController#$setViewValue `$setViewValue()`} for a detailed lifecycle explanation.
+ Note that the `$parsers` are not called when the bound ngModel expression changes programmatically.
+
+ The functions are called in array order, each passing
+ its return value through to the next. The last return value is forwarded to the
+ {@link ngModel.NgModelController#$validators `$validators`} collection.
+
+ Parsers are used to sanitize / convert the {@link ngModel.NgModelController#$viewValue
+ `$viewValue`}.
+
+ Returning `undefined` from a parser means a parse error occurred. In that case,
+ no {@link ngModel.NgModelController#$validators `$validators`} will run and the `ngModel`
+ will be set to `undefined` unless {@link ngModelOptions `ngModelOptions.allowInvalid`}
+ is set to `true`. The parse error is stored in `ngModel.$error.parse`.
+
+ This simple example shows a parser that would convert text input value to lowercase:
+ * ```js
+ * function parse(value) {
+ * if (value) {
+ * return value.toLowerCase();
+ * }
+ * }
+ * ngModelController.$parsers.push(parse);
+ * ```
+
+ *
+ * @property {Array.<Function>} $formatters Array of functions to execute, as a pipeline, whenever
+ the bound ngModel expression changes programmatically. The `$formatters` are not called when the
+ value of the control is changed by user interaction.
+
+ Formatters are used to format / convert the {@link ngModel.NgModelController#$modelValue
+ `$modelValue`} for display in the control.
+
+ The functions are called in reverse array order, each passing the value through to the
+ next. The last return value is used as the actual DOM value.
+
+ This simple example shows a formatter that would convert the model value to uppercase:
+
+ * ```js
+ * function format(value) {
+ * if (value) {
+ * return value.toUpperCase();
+ * }
+ * }
+ * ngModel.$formatters.push(format);
+ * ```
+ *
+ * @property {Object.<string, function>} $validators A collection of validators that are applied
+ * whenever the model value changes. The key value within the object refers to the name of the
+ * validator while the function refers to the validation operation. The validation operation is
+ * provided with the model value as an argument and must return a true or false value depending
+ * on the response of that validation.
+ *
+ * ```js
+ * ngModel.$validators.validCharacters = function(modelValue, viewValue) {
+ * var value = modelValue || viewValue;
+ * return /[0-9]+/.test(value) &&
+ * /[a-z]+/.test(value) &&
+ * /[A-Z]+/.test(value) &&
+ * /\W+/.test(value);
+ * };
+ * ```
+ *
+ * @property {Object.<string, function>} $asyncValidators A collection of validations that are expected to
+ * perform an asynchronous validation (e.g. a HTTP request). The validation function that is provided
+ * is expected to return a promise when it is run during the model validation process. Once the promise
+ * is delivered then the validation status will be set to true when fulfilled and false when rejected.
+ * When the asynchronous validators are triggered, each of the validators will run in parallel and the model
+ * value will only be updated once all validators have been fulfilled. As long as an asynchronous validator
+ * is unfulfilled, its key will be added to the controllers `$pending` property. Also, all asynchronous validators
+ * will only run once all synchronous validators have passed.
+ *
+ * Please note that if $http is used then it is important that the server returns a success HTTP response code
+ * in order to fulfill the validation and a status level of `4xx` in order to reject the validation.
+ *
+ * ```js
+ * ngModel.$asyncValidators.uniqueUsername = function(modelValue, viewValue) {
+ * var value = modelValue || viewValue;
+ *
+ * // Lookup user by username
+ * return $http.get('/api/users/' + value).
+ * then(function resolved() {
+ * //username exists, this means validation fails
+ * return $q.reject('exists');
+ * }, function rejected() {
+ * //username does not exist, therefore this validation passes
+ * return true;
+ * });
+ * };
+ * ```
+ *
+ * @property {Array.<Function>} $viewChangeListeners Array of functions to execute whenever
+ * a change to {@link ngModel.NgModelController#$viewValue `$viewValue`} has caused a change
+ * to {@link ngModel.NgModelController#$modelValue `$modelValue`}.
+ * It is called with no arguments, and its return value is ignored.
+ * This can be used in place of additional $watches against the model value.
+ *
+ * @property {Object} $error An object hash with all failing validator ids as keys.
+ * @property {Object} $pending An object hash with all pending validator ids as keys.
+ *
+ * @property {boolean} $untouched True if control has not lost focus yet.
+ * @property {boolean} $touched True if control has lost focus.
+ * @property {boolean} $pristine True if user has not interacted with the control yet.
+ * @property {boolean} $dirty True if user has already interacted with the control.
+ * @property {boolean} $valid True if there is no error.
+ * @property {boolean} $invalid True if at least one error on the control.
+ * @property {string} $name The name attribute of the control.
+ *
+ * @description
+ *
+ * `NgModelController` provides API for the {@link ngModel `ngModel`} directive.
+ * The controller contains services for data-binding, validation, CSS updates, and value formatting
+ * and parsing. It purposefully does not contain any logic which deals with DOM rendering or
+ * listening to DOM events.
+ * Such DOM related logic should be provided by other directives which make use of
+ * `NgModelController` for data-binding to control elements.
+ * AngularJS provides this DOM logic for most {@link input `input`} elements.
+ * At the end of this page you can find a {@link ngModel.NgModelController#custom-control-example
+ * custom control example} that uses `ngModelController` to bind to `contenteditable` elements.
+ *
+ * @example
+ * ### Custom Control Example
+ * This example shows how to use `NgModelController` with a custom control to achieve
+ * data-binding. Notice how different directives (`contenteditable`, `ng-model`, and `required`)
+ * collaborate together to achieve the desired result.
+ *
+ * `contenteditable` is an HTML5 attribute, which tells the browser to let the element
+ * contents be edited in place by the user.
+ *
+ * We are using the {@link ng.service:$sce $sce} service here and include the {@link ngSanitize $sanitize}
+ * module to automatically remove "bad" content like inline event listener (e.g. `<span onclick="...">`).
+ * However, as we are using `$sce` the model can still decide to provide unsafe content if it marks
+ * that content using the `$sce` service.
+ *
+ * <example name="NgModelController" module="customControl" deps="angular-sanitize.js">
+ <file name="style.css">
+ [contenteditable] {
+ border: 1px solid black;
+ background-color: white;
+ min-height: 20px;
+ }
+
+ .ng-invalid {
+ border: 1px solid red;
+ }
+
+ </file>
+ <file name="script.js">
+ angular.module('customControl', ['ngSanitize']).
+ directive('contenteditable', ['$sce', function($sce) {
+ return {
+ restrict: 'A', // only activate on element attribute
+ require: '?ngModel', // get a hold of NgModelController
+ link: function(scope, element, attrs, ngModel) {
+ if (!ngModel) return; // do nothing if no ng-model
+
+ // Specify how UI should be updated
+ ngModel.$render = function() {
+ element.html($sce.getTrustedHtml(ngModel.$viewValue || ''));
+ };
+
+ // Listen for change events to enable binding
+ element.on('blur keyup change', function() {
+ scope.$evalAsync(read);
+ });
+ read(); // initialize
+
+ // Write data to the model
+ function read() {
+ var html = element.html();
+ // When we clear the content editable the browser leaves a <br> behind
+ // If strip-br attribute is provided then we strip this out
+ if (attrs.stripBr && html === '<br>') {
+ html = '';
+ }
+ ngModel.$setViewValue(html);
+ }
+ }
+ };
+ }]);
+ </file>
+ <file name="index.html">
+ <form name="myForm">
+ <div contenteditable
+ name="myWidget" ng-model="userContent"
+ strip-br="true"
+ required>Change me!</div>
+ <span ng-show="myForm.myWidget.$error.required">Required!</span>
+ <hr>
+ <textarea ng-model="userContent" aria-label="Dynamic textarea"></textarea>
+ </form>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should data-bind and become invalid', function() {
+ if (browser.params.browser === 'safari' || browser.params.browser === 'firefox') {
+ // SafariDriver can't handle contenteditable
+ // and Firefox driver can't clear contenteditables very well
+ return;
+ }
+ var contentEditable = element(by.css('[contenteditable]'));
+ var content = 'Change me!';
+
+ expect(contentEditable.getText()).toEqual(content);
+
+ contentEditable.clear();
+ contentEditable.sendKeys(protractor.Key.BACK_SPACE);
+ expect(contentEditable.getText()).toEqual('');
+ expect(contentEditable.getAttribute('class')).toMatch(/ng-invalid-required/);
+ });
+ </file>
+ * </example>
+ *
+ *
+ */
+NgModelController.$inject = ['$scope', '$exceptionHandler', '$attrs', '$element', '$parse', '$animate', '$timeout', '$q', '$interpolate'];
+function NgModelController($scope, $exceptionHandler, $attr, $element, $parse, $animate, $timeout, $q, $interpolate) {
+ this.$viewValue = Number.NaN;
+ this.$modelValue = Number.NaN;
+ this.$$rawModelValue = undefined; // stores the parsed modelValue / model set from scope regardless of validity.
+ this.$validators = {};
+ this.$asyncValidators = {};
+ this.$parsers = [];
+ this.$formatters = [];
+ this.$viewChangeListeners = [];
+ this.$untouched = true;
+ this.$touched = false;
+ this.$pristine = true;
+ this.$dirty = false;
+ this.$valid = true;
+ this.$invalid = false;
+ this.$error = {}; // keep invalid keys here
+ this.$$success = {}; // keep valid keys here
+ this.$pending = undefined; // keep pending keys here
+ this.$name = $interpolate($attr.name || '', false)($scope);
+ this.$$parentForm = nullFormCtrl;
+ this.$options = defaultModelOptions;
+ this.$$updateEvents = '';
+ // Attach the correct context to the event handler function for updateOn
+ this.$$updateEventHandler = this.$$updateEventHandler.bind(this);
+
+ this.$$parsedNgModel = $parse($attr.ngModel);
+ this.$$parsedNgModelAssign = this.$$parsedNgModel.assign;
+ this.$$ngModelGet = this.$$parsedNgModel;
+ this.$$ngModelSet = this.$$parsedNgModelAssign;
+ this.$$pendingDebounce = null;
+ this.$$parserValid = undefined;
+ this.$$parserName = 'parse';
+
+ this.$$currentValidationRunId = 0;
+
+ this.$$scope = $scope;
+ this.$$rootScope = $scope.$root;
+ this.$$attr = $attr;
+ this.$$element = $element;
+ this.$$animate = $animate;
+ this.$$timeout = $timeout;
+ this.$$parse = $parse;
+ this.$$q = $q;
+ this.$$exceptionHandler = $exceptionHandler;
+
+ setupValidity(this);
+ setupModelWatcher(this);
+}
+
+NgModelController.prototype = {
+ $$initGetterSetters: function() {
+ if (this.$options.getOption('getterSetter')) {
+ var invokeModelGetter = this.$$parse(this.$$attr.ngModel + '()'),
+ invokeModelSetter = this.$$parse(this.$$attr.ngModel + '($$$p)');
+
+ this.$$ngModelGet = function($scope) {
+ var modelValue = this.$$parsedNgModel($scope);
+ if (isFunction(modelValue)) {
+ modelValue = invokeModelGetter($scope);
+ }
+ return modelValue;
+ };
+ this.$$ngModelSet = function($scope, newValue) {
+ if (isFunction(this.$$parsedNgModel($scope))) {
+ invokeModelSetter($scope, {$$$p: newValue});
+ } else {
+ this.$$parsedNgModelAssign($scope, newValue);
+ }
+ };
+ } else if (!this.$$parsedNgModel.assign) {
+ throw ngModelMinErr('nonassign', 'Expression \'{0}\' is non-assignable. Element: {1}',
+ this.$$attr.ngModel, startingTag(this.$$element));
+ }
+ },
+
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$render
+ *
+ * @description
+ * Called when the view needs to be updated. It is expected that the user of the ng-model
+ * directive will implement this method.
+ *
+ * The `$render()` method is invoked in the following situations:
+ *
+ * * `$rollbackViewValue()` is called. If we are rolling back the view value to the last
+ * committed value then `$render()` is called to update the input control.
+ * * The value referenced by `ng-model` is changed programmatically and both the `$modelValue` and
+ * the `$viewValue` are different from last time.
+ *
+ * Since `ng-model` does not do a deep watch, `$render()` is only invoked if the values of
+ * `$modelValue` and `$viewValue` are actually different from their previous values. If `$modelValue`
+ * or `$viewValue` are objects (rather than a string or number) then `$render()` will not be
+ * invoked if you only change a property on the objects.
+ */
+ $render: noop,
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$isEmpty
+ *
+ * @description
+ * This is called when we need to determine if the value of an input is empty.
+ *
+ * For instance, the required directive does this to work out if the input has data or not.
+ *
+ * The default `$isEmpty` function checks whether the value is `undefined`, `''`, `null` or `NaN`.
+ *
+ * You can override this for input directives whose concept of being empty is different from the
+ * default. The `checkboxInputType` directive does this because in its case a value of `false`
+ * implies empty.
+ *
+ * @param {*} value The value of the input to check for emptiness.
+ * @returns {boolean} True if `value` is "empty".
+ */
+ $isEmpty: function(value) {
+ // eslint-disable-next-line no-self-compare
+ return isUndefined(value) || value === '' || value === null || value !== value;
+ },
+
+ $$updateEmptyClasses: function(value) {
+ if (this.$isEmpty(value)) {
+ this.$$animate.removeClass(this.$$element, NOT_EMPTY_CLASS);
+ this.$$animate.addClass(this.$$element, EMPTY_CLASS);
+ } else {
+ this.$$animate.removeClass(this.$$element, EMPTY_CLASS);
+ this.$$animate.addClass(this.$$element, NOT_EMPTY_CLASS);
+ }
+ },
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$setPristine
+ *
+ * @description
+ * Sets the control to its pristine state.
+ *
+ * This method can be called to remove the `ng-dirty` class and set the control to its pristine
+ * state (`ng-pristine` class). A model is considered to be pristine when the control
+ * has not been changed from when first compiled.
+ */
+ $setPristine: function() {
+ this.$dirty = false;
+ this.$pristine = true;
+ this.$$animate.removeClass(this.$$element, DIRTY_CLASS);
+ this.$$animate.addClass(this.$$element, PRISTINE_CLASS);
+ },
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$setDirty
+ *
+ * @description
+ * Sets the control to its dirty state.
+ *
+ * This method can be called to remove the `ng-pristine` class and set the control to its dirty
+ * state (`ng-dirty` class). A model is considered to be dirty when the control has been changed
+ * from when first compiled.
+ */
+ $setDirty: function() {
+ this.$dirty = true;
+ this.$pristine = false;
+ this.$$animate.removeClass(this.$$element, PRISTINE_CLASS);
+ this.$$animate.addClass(this.$$element, DIRTY_CLASS);
+ this.$$parentForm.$setDirty();
+ },
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$setUntouched
+ *
+ * @description
+ * Sets the control to its untouched state.
+ *
+ * This method can be called to remove the `ng-touched` class and set the control to its
+ * untouched state (`ng-untouched` class). Upon compilation, a model is set as untouched
+ * by default, however this function can be used to restore that state if the model has
+ * already been touched by the user.
+ */
+ $setUntouched: function() {
+ this.$touched = false;
+ this.$untouched = true;
+ this.$$animate.setClass(this.$$element, UNTOUCHED_CLASS, TOUCHED_CLASS);
+ },
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$setTouched
+ *
+ * @description
+ * Sets the control to its touched state.
+ *
+ * This method can be called to remove the `ng-untouched` class and set the control to its
+ * touched state (`ng-touched` class). A model is considered to be touched when the user has
+ * first focused the control element and then shifted focus away from the control (blur event).
+ */
+ $setTouched: function() {
+ this.$touched = true;
+ this.$untouched = false;
+ this.$$animate.setClass(this.$$element, TOUCHED_CLASS, UNTOUCHED_CLASS);
+ },
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$rollbackViewValue
+ *
+ * @description
+ * Cancel an update and reset the input element's value to prevent an update to the `$modelValue`,
+ * which may be caused by a pending debounced event or because the input is waiting for some
+ * future event.
+ *
+ * If you have an input that uses `ng-model-options` to set up debounced updates or updates that
+ * depend on special events such as `blur`, there can be a period when the `$viewValue` is out of
+ * sync with the ngModel's `$modelValue`.
+ *
+ * In this case, you can use `$rollbackViewValue()` to manually cancel the debounced / future update
+ * and reset the input to the last committed view value.
+ *
+ * It is also possible that you run into difficulties if you try to update the ngModel's `$modelValue`
+ * programmatically before these debounced/future events have resolved/occurred, because AngularJS's
+ * dirty checking mechanism is not able to tell whether the model has actually changed or not.
+ *
+ * The `$rollbackViewValue()` method should be called before programmatically changing the model of an
+ * input which may have such events pending. This is important in order to make sure that the
+ * input field will be updated with the new model value and any pending operations are cancelled.
+ *
+ * @example
+ * <example name="ng-model-cancel-update" module="cancel-update-example">
+ * <file name="app.js">
+ * angular.module('cancel-update-example', [])
+ *
+ * .controller('CancelUpdateController', ['$scope', function($scope) {
+ * $scope.model = {value1: '', value2: ''};
+ *
+ * $scope.setEmpty = function(e, value, rollback) {
+ * if (e.keyCode === 27) {
+ * e.preventDefault();
+ * if (rollback) {
+ * $scope.myForm[value].$rollbackViewValue();
+ * }
+ * $scope.model[value] = '';
+ * }
+ * };
+ * }]);
+ * </file>
+ * <file name="index.html">
+ * <div ng-controller="CancelUpdateController">
+ * <p>Both of these inputs are only updated if they are blurred. Hitting escape should
+ * empty them. Follow these steps and observe the difference:</p>
+ * <ol>
+ * <li>Type something in the input. You will see that the model is not yet updated</li>
+ * <li>Press the Escape key.
+ * <ol>
+ * <li> In the first example, nothing happens, because the model is already '', and no
+ * update is detected. If you blur the input, the model will be set to the current view.
+ * </li>
+ * <li> In the second example, the pending update is cancelled, and the input is set back
+ * to the last committed view value (''). Blurring the input does nothing.
+ * </li>
+ * </ol>
+ * </li>
+ * </ol>
+ *
+ * <form name="myForm" ng-model-options="{ updateOn: 'blur' }">
+ * <div>
+ * <p id="inputDescription1">Without $rollbackViewValue():</p>
+ * <input name="value1" aria-describedby="inputDescription1" ng-model="model.value1"
+ * ng-keydown="setEmpty($event, 'value1')">
+ * value1: "{{ model.value1 }}"
+ * </div>
+ *
+ * <div>
+ * <p id="inputDescription2">With $rollbackViewValue():</p>
+ * <input name="value2" aria-describedby="inputDescription2" ng-model="model.value2"
+ * ng-keydown="setEmpty($event, 'value2', true)">
+ * value2: "{{ model.value2 }}"
+ * </div>
+ * </form>
+ * </div>
+ * </file>
+ <file name="style.css">
+ div {
+ display: table-cell;
+ }
+ div:nth-child(1) {
+ padding-right: 30px;
+ }
+
+ </file>
+ * </example>
+ */
+ $rollbackViewValue: function() {
+ this.$$timeout.cancel(this.$$pendingDebounce);
+ this.$viewValue = this.$$lastCommittedViewValue;
+ this.$render();
+ },
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$validate
+ *
+ * @description
+ * Runs each of the registered validators (first synchronous validators and then
+ * asynchronous validators).
+ * If the validity changes to invalid, the model will be set to `undefined`,
+ * unless {@link ngModelOptions `ngModelOptions.allowInvalid`} is `true`.
+ * If the validity changes to valid, it will set the model to the last available valid
+ * `$modelValue`, i.e. either the last parsed value or the last value set from the scope.
+ */
+ $validate: function() {
+
+ // ignore $validate before model is initialized
+ if (isNumberNaN(this.$modelValue)) {
+ return;
+ }
+
+ var viewValue = this.$$lastCommittedViewValue;
+ // Note: we use the $$rawModelValue as $modelValue might have been
+ // set to undefined during a view -> model update that found validation
+ // errors. We can't parse the view here, since that could change
+ // the model although neither viewValue nor the model on the scope changed
+ var modelValue = this.$$rawModelValue;
+
+ var prevValid = this.$valid;
+ var prevModelValue = this.$modelValue;
+
+ var allowInvalid = this.$options.getOption('allowInvalid');
+
+ var that = this;
+ this.$$runValidators(modelValue, viewValue, function(allValid) {
+ // If there was no change in validity, don't update the model
+ // This prevents changing an invalid modelValue to undefined
+ if (!allowInvalid && prevValid !== allValid) {
+ // Note: Don't check this.$valid here, as we could have
+ // external validators (e.g. calculated on the server),
+ // that just call $setValidity and need the model value
+ // to calculate their validity.
+ that.$modelValue = allValid ? modelValue : undefined;
+
+ if (that.$modelValue !== prevModelValue) {
+ that.$$writeModelToScope();
+ }
+ }
+ });
+ },
+
+ $$runValidators: function(modelValue, viewValue, doneCallback) {
+ this.$$currentValidationRunId++;
+ var localValidationRunId = this.$$currentValidationRunId;
+ var that = this;
+
+ // check parser error
+ if (!processParseErrors()) {
+ validationDone(false);
+ return;
+ }
+ if (!processSyncValidators()) {
+ validationDone(false);
+ return;
+ }
+ processAsyncValidators();
+
+ function processParseErrors() {
+ var errorKey = that.$$parserName;
+
+ if (isUndefined(that.$$parserValid)) {
+ setValidity(errorKey, null);
+ } else {
+ if (!that.$$parserValid) {
+ forEach(that.$validators, function(v, name) {
+ setValidity(name, null);
+ });
+ forEach(that.$asyncValidators, function(v, name) {
+ setValidity(name, null);
+ });
+ }
+
+ // Set the parse error last, to prevent unsetting it, should a $validators key == parserName
+ setValidity(errorKey, that.$$parserValid);
+ return that.$$parserValid;
+ }
+ return true;
+ }
+
+ function processSyncValidators() {
+ var syncValidatorsValid = true;
+ forEach(that.$validators, function(validator, name) {
+ var result = Boolean(validator(modelValue, viewValue));
+ syncValidatorsValid = syncValidatorsValid && result;
+ setValidity(name, result);
+ });
+ if (!syncValidatorsValid) {
+ forEach(that.$asyncValidators, function(v, name) {
+ setValidity(name, null);
+ });
+ return false;
+ }
+ return true;
+ }
+
+ function processAsyncValidators() {
+ var validatorPromises = [];
+ var allValid = true;
+ forEach(that.$asyncValidators, function(validator, name) {
+ var promise = validator(modelValue, viewValue);
+ if (!isPromiseLike(promise)) {
+ throw ngModelMinErr('nopromise',
+ 'Expected asynchronous validator to return a promise but got \'{0}\' instead.', promise);
+ }
+ setValidity(name, undefined);
+ validatorPromises.push(promise.then(function() {
+ setValidity(name, true);
+ }, function() {
+ allValid = false;
+ setValidity(name, false);
+ }));
+ });
+ if (!validatorPromises.length) {
+ validationDone(true);
+ } else {
+ that.$$q.all(validatorPromises).then(function() {
+ validationDone(allValid);
+ }, noop);
+ }
+ }
+
+ function setValidity(name, isValid) {
+ if (localValidationRunId === that.$$currentValidationRunId) {
+ that.$setValidity(name, isValid);
+ }
+ }
+
+ function validationDone(allValid) {
+ if (localValidationRunId === that.$$currentValidationRunId) {
+
+ doneCallback(allValid);
+ }
+ }
+ },
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$commitViewValue
+ *
+ * @description
+ * Commit a pending update to the `$modelValue`.
+ *
+ * Updates may be pending by a debounced event or because the input is waiting for a some future
+ * event defined in `ng-model-options`. this method is rarely needed as `NgModelController`
+ * usually handles calling this in response to input events.
+ */
+ $commitViewValue: function() {
+ var viewValue = this.$viewValue;
+
+ this.$$timeout.cancel(this.$$pendingDebounce);
+
+ // If the view value has not changed then we should just exit, except in the case where there is
+ // a native validator on the element. In this case the validation state may have changed even though
+ // the viewValue has stayed empty.
+ if (this.$$lastCommittedViewValue === viewValue && (viewValue !== '' || !this.$$hasNativeValidators)) {
+ return;
+ }
+ this.$$updateEmptyClasses(viewValue);
+ this.$$lastCommittedViewValue = viewValue;
+
+ // change to dirty
+ if (this.$pristine) {
+ this.$setDirty();
+ }
+ this.$$parseAndValidate();
+ },
+
+ $$parseAndValidate: function() {
+ var viewValue = this.$$lastCommittedViewValue;
+ var modelValue = viewValue;
+ var that = this;
+
+ this.$$parserValid = isUndefined(modelValue) ? undefined : true;
+
+ // Reset any previous parse error
+ this.$setValidity(this.$$parserName, null);
+ this.$$parserName = 'parse';
+
+ if (this.$$parserValid) {
+ for (var i = 0; i < this.$parsers.length; i++) {
+ modelValue = this.$parsers[i](modelValue);
+ if (isUndefined(modelValue)) {
+ this.$$parserValid = false;
+ break;
+ }
+ }
+ }
+ if (isNumberNaN(this.$modelValue)) {
+ // this.$modelValue has not been touched yet...
+ this.$modelValue = this.$$ngModelGet(this.$$scope);
+ }
+ var prevModelValue = this.$modelValue;
+ var allowInvalid = this.$options.getOption('allowInvalid');
+ this.$$rawModelValue = modelValue;
+
+ if (allowInvalid) {
+ this.$modelValue = modelValue;
+ writeToModelIfNeeded();
+ }
+
+ // Pass the $$lastCommittedViewValue here, because the cached viewValue might be out of date.
+ // This can happen if e.g. $setViewValue is called from inside a parser
+ this.$$runValidators(modelValue, this.$$lastCommittedViewValue, function(allValid) {
+ if (!allowInvalid) {
+ // Note: Don't check this.$valid here, as we could have
+ // external validators (e.g. calculated on the server),
+ // that just call $setValidity and need the model value
+ // to calculate their validity.
+ that.$modelValue = allValid ? modelValue : undefined;
+ writeToModelIfNeeded();
+ }
+ });
+
+ function writeToModelIfNeeded() {
+ if (that.$modelValue !== prevModelValue) {
+ that.$$writeModelToScope();
+ }
+ }
+ },
+
+ $$writeModelToScope: function() {
+ this.$$ngModelSet(this.$$scope, this.$modelValue);
+ forEach(this.$viewChangeListeners, function(listener) {
+ try {
+ listener();
+ } catch (e) {
+ // eslint-disable-next-line no-invalid-this
+ this.$$exceptionHandler(e);
+ }
+ }, this);
+ },
+
+ /**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$setViewValue
+ *
+ * @description
+ * Update the view value.
+ *
+ * This method should be called when a control wants to change the view value; typically,
+ * this is done from within a DOM event handler. For example, the {@link ng.directive:input input}
+ * directive calls it when the value of the input changes and {@link ng.directive:select select}
+ * calls it when an option is selected.
+ *
+ * When `$setViewValue` is called, the new `value` will be staged for committing through the `$parsers`
+ * and `$validators` pipelines. If there are no special {@link ngModelOptions} specified then the staged
+ * value is sent directly for processing through the `$parsers` pipeline. After this, the `$validators` and
+ * `$asyncValidators` are called and the value is applied to `$modelValue`.
+ * Finally, the value is set to the **expression** specified in the `ng-model` attribute and
+ * all the registered change listeners, in the `$viewChangeListeners` list are called.
+ *
+ * In case the {@link ng.directive:ngModelOptions ngModelOptions} directive is used with `updateOn`
+ * and the `default` trigger is not listed, all those actions will remain pending until one of the
+ * `updateOn` events is triggered on the DOM element.
+ * All these actions will be debounced if the {@link ng.directive:ngModelOptions ngModelOptions}
+ * directive is used with a custom debounce for this particular event.
+ * Note that a `$digest` is only triggered once the `updateOn` events are fired, or if `debounce`
+ * is specified, once the timer runs out.
+ *
+ * When used with standard inputs, the view value will always be a string (which is in some cases
+ * parsed into another type, such as a `Date` object for `input[date]`.)
+ * However, custom controls might also pass objects to this method. In this case, we should make
+ * a copy of the object before passing it to `$setViewValue`. This is because `ngModel` does not
+ * perform a deep watch of objects, it only looks for a change of identity. If you only change
+ * the property of the object then ngModel will not realize that the object has changed and
+ * will not invoke the `$parsers` and `$validators` pipelines. For this reason, you should
+ * not change properties of the copy once it has been passed to `$setViewValue`.
+ * Otherwise you may cause the model value on the scope to change incorrectly.
+ *
+ * <div class="alert alert-info">
+ * In any case, the value passed to the method should always reflect the current value
+ * of the control. For example, if you are calling `$setViewValue` for an input element,
+ * you should pass the input DOM value. Otherwise, the control and the scope model become
+ * out of sync. It's also important to note that `$setViewValue` does not call `$render` or change
+ * the control's DOM value in any way. If we want to change the control's DOM value
+ * programmatically, we should update the `ngModel` scope expression. Its new value will be
+ * picked up by the model controller, which will run it through the `$formatters`, `$render` it
+ * to update the DOM, and finally call `$validate` on it.
+ * </div>
+ *
+ * @param {*} value value from the view.
+ * @param {string} trigger Event that triggered the update.
+ */
+ $setViewValue: function(value, trigger) {
+ this.$viewValue = value;
+ if (this.$options.getOption('updateOnDefault')) {
+ this.$$debounceViewValueCommit(trigger);
+ }
+ },
+
+ $$debounceViewValueCommit: function(trigger) {
+ var debounceDelay = this.$options.getOption('debounce');
+
+ if (isNumber(debounceDelay[trigger])) {
+ debounceDelay = debounceDelay[trigger];
+ } else if (isNumber(debounceDelay['default']) &&
+ this.$options.getOption('updateOn').indexOf(trigger) === -1
+ ) {
+ debounceDelay = debounceDelay['default'];
+ } else if (isNumber(debounceDelay['*'])) {
+ debounceDelay = debounceDelay['*'];
+ }
+
+ this.$$timeout.cancel(this.$$pendingDebounce);
+ var that = this;
+ if (debounceDelay > 0) { // this fails if debounceDelay is an object
+ this.$$pendingDebounce = this.$$timeout(function() {
+ that.$commitViewValue();
+ }, debounceDelay);
+ } else if (this.$$rootScope.$$phase) {
+ this.$commitViewValue();
+ } else {
+ this.$$scope.$apply(function() {
+ that.$commitViewValue();
+ });
+ }
+ },
+
+ /**
+ * @ngdoc method
+ *
+ * @name ngModel.NgModelController#$overrideModelOptions
+ *
+ * @description
+ *
+ * Override the current model options settings programmatically.
+ *
+ * The previous `ModelOptions` value will not be modified. Instead, a
+ * new `ModelOptions` object will inherit from the previous one overriding
+ * or inheriting settings that are defined in the given parameter.
+ *
+ * See {@link ngModelOptions} for information about what options can be specified
+ * and how model option inheritance works.
+ *
+ * <div class="alert alert-warning">
+ * **Note:** this function only affects the options set on the `ngModelController`,
+ * and not the options on the {@link ngModelOptions} directive from which they might have been
+ * obtained initially.
+ * </div>
+ *
+ * <div class="alert alert-danger">
+ * **Note:** it is not possible to override the `getterSetter` option.
+ * </div>
+ *
+ * @param {Object} options a hash of settings to override the previous options
+ *
+ */
+ $overrideModelOptions: function(options) {
+ this.$options = this.$options.createChild(options);
+ this.$$setUpdateOnEvents();
+ },
+
+ /**
+ * @ngdoc method
+ *
+ * @name ngModel.NgModelController#$processModelValue
+
+ * @description
+ *
+ * Runs the model -> view pipeline on the current
+ * {@link ngModel.NgModelController#$modelValue $modelValue}.
+ *
+ * The following actions are performed by this method:
+ *
+ * - the `$modelValue` is run through the {@link ngModel.NgModelController#$formatters $formatters}
+ * and the result is set to the {@link ngModel.NgModelController#$viewValue $viewValue}
+ * - the `ng-empty` or `ng-not-empty` class is set on the element
+ * - if the `$viewValue` has changed:
+ * - {@link ngModel.NgModelController#$render $render} is called on the control
+ * - the {@link ngModel.NgModelController#$validators $validators} are run and
+ * the validation status is set.
+ *
+ * This method is called by ngModel internally when the bound scope value changes.
+ * Application developers usually do not have to call this function themselves.
+ *
+ * This function can be used when the `$viewValue` or the rendered DOM value are not correctly
+ * formatted and the `$modelValue` must be run through the `$formatters` again.
+ *
+ * @example
+ * Consider a text input with an autocomplete list (for fruit), where the items are
+ * objects with a name and an id.
+ * A user enters `ap` and then selects `Apricot` from the list.
+ * Based on this, the autocomplete widget will call `$setViewValue({name: 'Apricot', id: 443})`,
+ * but the rendered value will still be `ap`.
+ * The widget can then call `ctrl.$processModelValue()` to run the model -> view
+ * pipeline again, which formats the object to the string `Apricot`,
+ * then updates the `$viewValue`, and finally renders it in the DOM.
+ *
+ * <example module="inputExample" name="ng-model-process">
+ <file name="index.html">
+ <div ng-controller="inputController" style="display: flex;">
+ <div style="margin-right: 30px;">
+ Search Fruit:
+ <basic-autocomplete items="items" on-select="selectedFruit = item"></basic-autocomplete>
+ </div>
+ <div>
+ Model:<br>
+ <pre>{{selectedFruit | json}}</pre>
+ </div>
+ </div>
+ </file>
+ <file name="app.js">
+ angular.module('inputExample', [])
+ .controller('inputController', function($scope) {
+ $scope.items = [
+ {name: 'Apricot', id: 443},
+ {name: 'Clementine', id: 972},
+ {name: 'Durian', id: 169},
+ {name: 'Jackfruit', id: 982},
+ {name: 'Strawberry', id: 863}
+ ];
+ })
+ .component('basicAutocomplete', {
+ bindings: {
+ items: '<',
+ onSelect: '&'
+ },
+ templateUrl: 'autocomplete.html',
+ controller: function($element, $scope) {
+ var that = this;
+ var ngModel;
+
+ that.$postLink = function() {
+ ngModel = $element.find('input').controller('ngModel');
+
+ ngModel.$formatters.push(function(value) {
+ return (value && value.name) || value;
+ });
+
+ ngModel.$parsers.push(function(value) {
+ var match = value;
+ for (var i = 0; i < that.items.length; i++) {
+ if (that.items[i].name === value) {
+ match = that.items[i];
+ break;
+ }
+ }
+
+ return match;
+ });
+ };
+
+ that.selectItem = function(item) {
+ ngModel.$setViewValue(item);
+ ngModel.$processModelValue();
+ that.onSelect({item: item});
+ };
+ }
+ });
+ </file>
+ <file name="autocomplete.html">
+ <div>
+ <input type="search" ng-model="$ctrl.searchTerm" />
+ <ul>
+ <li ng-repeat="item in $ctrl.items | filter:$ctrl.searchTerm">
+ <button ng-click="$ctrl.selectItem(item)">{{ item.name }}</button>
+ </li>
+ </ul>
+ </div>
+ </file>
+ * </example>
+ *
+ */
+ $processModelValue: function() {
+ var viewValue = this.$$format();
+
+ if (this.$viewValue !== viewValue) {
+ this.$$updateEmptyClasses(viewValue);
+ this.$viewValue = this.$$lastCommittedViewValue = viewValue;
+ this.$render();
+ // It is possible that model and view value have been updated during render
+ this.$$runValidators(this.$modelValue, this.$viewValue, noop);
+ }
+ },
+
+ /**
+ * This method is called internally to run the $formatters on the $modelValue
+ */
+ $$format: function() {
+ var formatters = this.$formatters,
+ idx = formatters.length;
+
+ var viewValue = this.$modelValue;
+ while (idx--) {
+ viewValue = formatters[idx](viewValue);
+ }
+
+ return viewValue;
+ },
+
+ /**
+ * This method is called internally when the bound scope value changes.
+ */
+ $$setModelValue: function(modelValue) {
+ this.$modelValue = this.$$rawModelValue = modelValue;
+ this.$$parserValid = undefined;
+ this.$processModelValue();
+ },
+
+ $$setUpdateOnEvents: function() {
+ if (this.$$updateEvents) {
+ this.$$element.off(this.$$updateEvents, this.$$updateEventHandler);
+ }
+
+ this.$$updateEvents = this.$options.getOption('updateOn');
+ if (this.$$updateEvents) {
+ this.$$element.on(this.$$updateEvents, this.$$updateEventHandler);
+ }
+ },
+
+ $$updateEventHandler: function(ev) {
+ this.$$debounceViewValueCommit(ev && ev.type);
+ }
+};
+
+function setupModelWatcher(ctrl) {
+ // model -> value
+ // Note: we cannot use a normal scope.$watch as we want to detect the following:
+ // 1. scope value is 'a'
+ // 2. user enters 'b'
+ // 3. ng-change kicks in and reverts scope value to 'a'
+ // -> scope value did not change since the last digest as
+ // ng-change executes in apply phase
+ // 4. view should be changed back to 'a'
+ ctrl.$$scope.$watch(function ngModelWatch(scope) {
+ var modelValue = ctrl.$$ngModelGet(scope);
+
+ // if scope model value and ngModel value are out of sync
+ // This cannot be moved to the action function, because it would not catch the
+ // case where the model is changed in the ngChange function or the model setter
+ if (modelValue !== ctrl.$modelValue &&
+ // checks for NaN is needed to allow setting the model to NaN when there's an asyncValidator
+ // eslint-disable-next-line no-self-compare
+ (ctrl.$modelValue === ctrl.$modelValue || modelValue === modelValue)
+ ) {
+ ctrl.$$setModelValue(modelValue);
+ }
+
+ return modelValue;
+ });
+}
+
+/**
+ * @ngdoc method
+ * @name ngModel.NgModelController#$setValidity
+ *
+ * @description
+ * Change the validity state, and notify the form.
+ *
+ * This method can be called within $parsers/$formatters or a custom validation implementation.
+ * However, in most cases it should be sufficient to use the `ngModel.$validators` and
+ * `ngModel.$asyncValidators` collections which will call `$setValidity` automatically.
+ *
+ * @param {string} validationErrorKey Name of the validator. The `validationErrorKey` will be assigned
+ * to either `$error[validationErrorKey]` or `$pending[validationErrorKey]`
+ * (for unfulfilled `$asyncValidators`), so that it is available for data-binding.
+ * The `validationErrorKey` should be in camelCase and will get converted into dash-case
+ * for class name. Example: `myError` will result in `ng-valid-my-error` and `ng-invalid-my-error`
+ * classes and can be bound to as `{{ someForm.someControl.$error.myError }}`.
+ * @param {boolean} isValid Whether the current state is valid (true), invalid (false), pending (undefined),
+ * or skipped (null). Pending is used for unfulfilled `$asyncValidators`.
+ * Skipped is used by AngularJS when validators do not run because of parse errors and
+ * when `$asyncValidators` do not run because any of the `$validators` failed.
+ */
+addSetValidityMethod({
+ clazz: NgModelController,
+ set: function(object, property) {
+ object[property] = true;
+ },
+ unset: function(object, property) {
+ delete object[property];
+ }
+});
+
+
+/**
+ * @ngdoc directive
+ * @name ngModel
+ * @restrict A
+ * @priority 1
+ * @param {expression} ngModel assignable {@link guide/expression Expression} to bind to.
+ *
+ * @description
+ * The `ngModel` directive binds an `input`,`select`, `textarea` (or custom form control) to a
+ * property on the scope using {@link ngModel.NgModelController NgModelController},
+ * which is created and exposed by this directive.
+ *
+ * `ngModel` is responsible for:
+ *
+ * - Binding the view into the model, which other directives such as `input`, `textarea` or `select`
+ * require.
+ * - Providing validation behavior (i.e. required, number, email, url).
+ * - Keeping the state of the control (valid/invalid, dirty/pristine, touched/untouched, validation errors).
+ * - Setting related css classes on the element (`ng-valid`, `ng-invalid`, `ng-dirty`, `ng-pristine`, `ng-touched`,
+ * `ng-untouched`, `ng-empty`, `ng-not-empty`) including animations.
+ * - Registering the control with its parent {@link ng.directive:form form}.
+ *
+ * Note: `ngModel` will try to bind to the property given by evaluating the expression on the
+ * current scope. If the property doesn't already exist on this scope, it will be created
+ * implicitly and added to the scope.
+ *
+ * For best practices on using `ngModel`, see:
+ *
+ * - [Understanding Scopes](https://github.com/angular/angular.js/wiki/Understanding-Scopes)
+ *
+ * For basic examples, how to use `ngModel`, see:
+ *
+ * - {@link ng.directive:input input}
+ * - {@link input[text] text}
+ * - {@link input[checkbox] checkbox}
+ * - {@link input[radio] radio}
+ * - {@link input[number] number}
+ * - {@link input[email] email}
+ * - {@link input[url] url}
+ * - {@link input[date] date}
+ * - {@link input[datetime-local] datetime-local}
+ * - {@link input[time] time}
+ * - {@link input[month] month}
+ * - {@link input[week] week}
+ * - {@link ng.directive:select select}
+ * - {@link ng.directive:textarea textarea}
+ *
+ * ## Complex Models (objects or collections)
+ *
+ * By default, `ngModel` watches the model by reference, not value. This is important to know when
+ * binding inputs to models that are objects (e.g. `Date`) or collections (e.g. arrays). If only properties of the
+ * object or collection change, `ngModel` will not be notified and so the input will not be re-rendered.
+ *
+ * The model must be assigned an entirely new object or collection before a re-rendering will occur.
+ *
+ * Some directives have options that will cause them to use a custom `$watchCollection` on the model expression
+ * - for example, `ngOptions` will do so when a `track by` clause is included in the comprehension expression or
+ * if the select is given the `multiple` attribute.
+ *
+ * The `$watchCollection()` method only does a shallow comparison, meaning that changing properties deeper than the
+ * first level of the object (or only changing the properties of an item in the collection if it's an array) will still
+ * not trigger a re-rendering of the model.
+ *
+ * ## CSS classes
+ * The following CSS classes are added and removed on the associated input/select/textarea element
+ * depending on the validity of the model.
+ *
+ * - `ng-valid`: the model is valid
+ * - `ng-invalid`: the model is invalid
+ * - `ng-valid-[key]`: for each valid key added by `$setValidity`
+ * - `ng-invalid-[key]`: for each invalid key added by `$setValidity`
+ * - `ng-pristine`: the control hasn't been interacted with yet
+ * - `ng-dirty`: the control has been interacted with
+ * - `ng-touched`: the control has been blurred
+ * - `ng-untouched`: the control hasn't been blurred
+ * - `ng-pending`: any `$asyncValidators` are unfulfilled
+ * - `ng-empty`: the view does not contain a value or the value is deemed "empty", as defined
+ * by the {@link ngModel.NgModelController#$isEmpty} method
+ * - `ng-not-empty`: the view contains a non-empty value
+ *
+ * Keep in mind that ngAnimate can detect each of these classes when added and removed.
+ *
+ * @animations
+ * Animations within models are triggered when any of the associated CSS classes are added and removed
+ * on the input element which is attached to the model. These classes include: `.ng-pristine`, `.ng-dirty`,
+ * `.ng-invalid` and `.ng-valid` as well as any other validations that are performed on the model itself.
+ * The animations that are triggered within ngModel are similar to how they work in ngClass and
+ * animations can be hooked into using CSS transitions, keyframes as well as JS animations.
+ *
+ * The following example shows a simple way to utilize CSS transitions to style an input element
+ * that has been rendered as invalid after it has been validated:
+ *
+ * <pre>
+ * //be sure to include ngAnimate as a module to hook into more
+ * //advanced animations
+ * .my-input {
+ * transition:0.5s linear all;
+ * background: white;
+ * }
+ * .my-input.ng-invalid {
+ * background: red;
+ * color:white;
+ * }
+ * </pre>
+ *
+ * @example
+ * ### Basic Usage
+ * <example deps="angular-animate.js" animations="true" fixBase="true" module="inputExample" name="ng-model">
+ <file name="index.html">
+ <script>
+ angular.module('inputExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.val = '1';
+ }]);
+ </script>
+ <style>
+ .my-input {
+ transition:all linear 0.5s;
+ background: transparent;
+ }
+ .my-input.ng-invalid {
+ color:white;
+ background: red;
+ }
+ </style>
+ <p id="inputDescription">
+ Update input to see transitions when valid/invalid.
+ Integer is a valid value.
+ </p>
+ <form name="testForm" ng-controller="ExampleController">
+ <input ng-model="val" ng-pattern="/^\d+$/" name="anim" class="my-input"
+ aria-describedby="inputDescription" />
+ </form>
+ </file>
+ * </example>
+ *
+ * @example
+ * ### Binding to a getter/setter
+ *
+ * Sometimes it's helpful to bind `ngModel` to a getter/setter function. A getter/setter is a
+ * function that returns a representation of the model when called with zero arguments, and sets
+ * the internal state of a model when called with an argument. It's sometimes useful to use this
+ * for models that have an internal representation that's different from what the model exposes
+ * to the view.
+ *
+ * <div class="alert alert-success">
+ * **Best Practice:** It's best to keep getters fast because AngularJS is likely to call them more
+ * frequently than other parts of your code.
+ * </div>
+ *
+ * You use this behavior by adding `ng-model-options="{ getterSetter: true }"` to an element that
+ * has `ng-model` attached to it. You can also add `ng-model-options="{ getterSetter: true }"` to
+ * a `<form>`, which will enable this behavior for all `<input>`s within it. See
+ * {@link ng.directive:ngModelOptions `ngModelOptions`} for more.
+ *
+ * The following example shows how to use `ngModel` with a getter/setter:
+ *
+ * @example
+ * <example name="ngModel-getter-setter" module="getterSetterExample">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <form name="userForm">
+ <label>Name:
+ <input type="text" name="userName"
+ ng-model="user.name"
+ ng-model-options="{ getterSetter: true }" />
+ </label>
+ </form>
+ <pre>user.name = <span ng-bind="user.name()"></span></pre>
+ </div>
+ </file>
+ <file name="app.js">
+ angular.module('getterSetterExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ var _name = 'Brian';
+ $scope.user = {
+ name: function(newName) {
+ // Note that newName can be undefined for two reasons:
+ // 1. Because it is called as a getter and thus called with no arguments
+ // 2. Because the property should actually be set to undefined. This happens e.g. if the
+ // input is invalid
+ return arguments.length ? (_name = newName) : _name;
+ }
+ };
+ }]);
+ </file>
+ * </example>
+ */
+var ngModelDirective = ['$rootScope', function($rootScope) {
+ return {
+ restrict: 'A',
+ require: ['ngModel', '^?form', '^?ngModelOptions'],
+ controller: NgModelController,
+ // Prelink needs to run before any input directive
+ // so that we can set the NgModelOptions in NgModelController
+ // before anyone else uses it.
+ priority: 1,
+ compile: function ngModelCompile(element) {
+ // Setup initial state of the control
+ element.addClass(PRISTINE_CLASS).addClass(UNTOUCHED_CLASS).addClass(VALID_CLASS);
+
+ return {
+ pre: function ngModelPreLink(scope, element, attr, ctrls) {
+ var modelCtrl = ctrls[0],
+ formCtrl = ctrls[1] || modelCtrl.$$parentForm,
+ optionsCtrl = ctrls[2];
+
+ if (optionsCtrl) {
+ modelCtrl.$options = optionsCtrl.$options;
+ }
+
+ modelCtrl.$$initGetterSetters();
+
+ // notify others, especially parent forms
+ formCtrl.$addControl(modelCtrl);
+
+ attr.$observe('name', function(newValue) {
+ if (modelCtrl.$name !== newValue) {
+ modelCtrl.$$parentForm.$$renameControl(modelCtrl, newValue);
+ }
+ });
+
+ scope.$on('$destroy', function() {
+ modelCtrl.$$parentForm.$removeControl(modelCtrl);
+ });
+ },
+ post: function ngModelPostLink(scope, element, attr, ctrls) {
+ var modelCtrl = ctrls[0];
+ modelCtrl.$$setUpdateOnEvents();
+
+ function setTouched() {
+ modelCtrl.$setTouched();
+ }
+
+ element.on('blur', function() {
+ if (modelCtrl.$touched) return;
+
+ if ($rootScope.$$phase) {
+ scope.$evalAsync(setTouched);
+ } else {
+ scope.$apply(setTouched);
+ }
+ });
+ }
+ };
+ }
+ };
+}];
+
+/* exported defaultModelOptions */
+var defaultModelOptions;
+var DEFAULT_REGEXP = /(\s+|^)default(\s+|$)/;
+
+/**
+ * @ngdoc type
+ * @name ModelOptions
+ * @description
+ * A container for the options set by the {@link ngModelOptions} directive
+ */
+function ModelOptions(options) {
+ this.$$options = options;
+}
+
+ModelOptions.prototype = {
+
+ /**
+ * @ngdoc method
+ * @name ModelOptions#getOption
+ * @param {string} name the name of the option to retrieve
+ * @returns {*} the value of the option
+ * @description
+ * Returns the value of the given option
+ */
+ getOption: function(name) {
+ return this.$$options[name];
+ },
+
+ /**
+ * @ngdoc method
+ * @name ModelOptions#createChild
+ * @param {Object} options a hash of options for the new child that will override the parent's options
+ * @return {ModelOptions} a new `ModelOptions` object initialized with the given options.
+ */
+ createChild: function(options) {
+ var inheritAll = false;
+
+ // make a shallow copy
+ options = extend({}, options);
+
+ // Inherit options from the parent if specified by the value `"$inherit"`
+ forEach(options, /** @this */ function(option, key) {
+ if (option === '$inherit') {
+ if (key === '*') {
+ inheritAll = true;
+ } else {
+ options[key] = this.$$options[key];
+ // `updateOn` is special so we must also inherit the `updateOnDefault` option
+ if (key === 'updateOn') {
+ options.updateOnDefault = this.$$options.updateOnDefault;
+ }
+ }
+ } else {
+ if (key === 'updateOn') {
+ // If the `updateOn` property contains the `default` event then we have to remove
+ // it from the event list and set the `updateOnDefault` flag.
+ options.updateOnDefault = false;
+ options[key] = trim(option.replace(DEFAULT_REGEXP, function() {
+ options.updateOnDefault = true;
+ return ' ';
+ }));
+ }
+ }
+ }, this);
+
+ if (inheritAll) {
+ // We have a property of the form: `"*": "$inherit"`
+ delete options['*'];
+ defaults(options, this.$$options);
+ }
+
+ // Finally add in any missing defaults
+ defaults(options, defaultModelOptions.$$options);
+
+ return new ModelOptions(options);
+ }
+};
+
+
+defaultModelOptions = new ModelOptions({
+ updateOn: '',
+ updateOnDefault: true,
+ debounce: 0,
+ getterSetter: false,
+ allowInvalid: false,
+ timezone: null
+});
+
+
+/**
+ * @ngdoc directive
+ * @name ngModelOptions
+ * @restrict A
+ * @priority 10
+ *
+ * @description
+ * This directive allows you to modify the behaviour of {@link ngModel} directives within your
+ * application. You can specify an `ngModelOptions` directive on any element. All {@link ngModel}
+ * directives will use the options of their nearest `ngModelOptions` ancestor.
+ *
+ * The `ngModelOptions` settings are found by evaluating the value of the attribute directive as
+ * an AngularJS expression. This expression should evaluate to an object, whose properties contain
+ * the settings. For example: `<div ng-model-options="{ debounce: 100 }"`.
+ *
+ * ## Inheriting Options
+ *
+ * You can specify that an `ngModelOptions` setting should be inherited from a parent `ngModelOptions`
+ * directive by giving it the value of `"$inherit"`.
+ * Then it will inherit that setting from the first `ngModelOptions` directive found by traversing up the
+ * DOM tree. If there is no ancestor element containing an `ngModelOptions` directive then default settings
+ * will be used.
+ *
+ * For example given the following fragment of HTML
+ *
+ *
+ * ```html
+ * <div ng-model-options="{ allowInvalid: true, debounce: 200 }">
+ * <form ng-model-options="{ updateOn: 'blur', allowInvalid: '$inherit' }">
+ * <input ng-model-options="{ updateOn: 'default', allowInvalid: '$inherit' }" />
+ * </form>
+ * </div>
+ * ```
+ *
+ * the `input` element will have the following settings
+ *
+ * ```js
+ * { allowInvalid: true, updateOn: 'default', debounce: 0 }
+ * ```
+ *
+ * Notice that the `debounce` setting was not inherited and used the default value instead.
+ *
+ * You can specify that all undefined settings are automatically inherited from an ancestor by
+ * including a property with key of `"*"` and value of `"$inherit"`.
+ *
+ * For example given the following fragment of HTML
+ *
+ *
+ * ```html
+ * <div ng-model-options="{ allowInvalid: true, debounce: 200 }">
+ * <form ng-model-options="{ updateOn: 'blur', "*": '$inherit' }">
+ * <input ng-model-options="{ updateOn: 'default', "*": '$inherit' }" />
+ * </form>
+ * </div>
+ * ```
+ *
+ * the `input` element will have the following settings
+ *
+ * ```js
+ * { allowInvalid: true, updateOn: 'default', debounce: 200 }
+ * ```
+ *
+ * Notice that the `debounce` setting now inherits the value from the outer `<div>` element.
+ *
+ * If you are creating a reusable component then you should be careful when using `"*": "$inherit"`
+ * since you may inadvertently inherit a setting in the future that changes the behavior of your component.
+ *
+ *
+ * ## Triggering and debouncing model updates
+ *
+ * The `updateOn` and `debounce` properties allow you to specify a custom list of events that will
+ * trigger a model update and/or a debouncing delay so that the actual update only takes place when
+ * a timer expires; this timer will be reset after another change takes place.
+ *
+ * Given the nature of `ngModelOptions`, the value displayed inside input fields in the view might
+ * be different from the value in the actual model. This means that if you update the model you
+ * should also invoke {@link ngModel.NgModelController#$rollbackViewValue} on the relevant input field in
+ * order to make sure it is synchronized with the model and that any debounced action is canceled.
+ *
+ * The easiest way to reference the control's {@link ngModel.NgModelController#$rollbackViewValue}
+ * method is by making sure the input is placed inside a form that has a `name` attribute. This is
+ * important because `form` controllers are published to the related scope under the name in their
+ * `name` attribute.
+ *
+ * Any pending changes will take place immediately when an enclosing form is submitted via the
+ * `submit` event. Note that `ngClick` events will occur before the model is updated. Use `ngSubmit`
+ * to have access to the updated model.
+ *
+ * ### Overriding immediate updates
+ *
+ * The following example shows how to override immediate updates. Changes on the inputs within the
+ * form will update the model only when the control loses focus (blur event). If `escape` key is
+ * pressed while the input field is focused, the value is reset to the value in the current model.
+ *
+ * <example name="ngModelOptions-directive-blur" module="optionsExample">
+ * <file name="index.html">
+ * <div ng-controller="ExampleController">
+ * <form name="userForm">
+ * <label>
+ * Name:
+ * <input type="text" name="userName"
+ * ng-model="user.name"
+ * ng-model-options="{ updateOn: 'blur' }"
+ * ng-keyup="cancel($event)" />
+ * </label><br />
+ * <label>
+ * Other data:
+ * <input type="text" ng-model="user.data" />
+ * </label><br />
+ * </form>
+ * <pre>user.name = <span ng-bind="user.name"></span></pre>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('optionsExample', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.user = { name: 'say', data: '' };
+ *
+ * $scope.cancel = function(e) {
+ * if (e.keyCode === 27) {
+ * $scope.userForm.userName.$rollbackViewValue();
+ * }
+ * };
+ * }]);
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * var model = element(by.binding('user.name'));
+ * var input = element(by.model('user.name'));
+ * var other = element(by.model('user.data'));
+ *
+ * it('should allow custom events', function() {
+ * input.sendKeys(' hello');
+ * input.click();
+ * expect(model.getText()).toEqual('say');
+ * other.click();
+ * expect(model.getText()).toEqual('say hello');
+ * });
+ *
+ * it('should $rollbackViewValue when model changes', function() {
+ * input.sendKeys(' hello');
+ * expect(input.getAttribute('value')).toEqual('say hello');
+ * input.sendKeys(protractor.Key.ESCAPE);
+ * expect(input.getAttribute('value')).toEqual('say');
+ * other.click();
+ * expect(model.getText()).toEqual('say');
+ * });
+ * </file>
+ * </example>
+ *
+ * ### Debouncing updates
+ *
+ * The next example shows how to debounce model changes. Model will be updated only 1 sec after last change.
+ * If the `Clear` button is pressed, any debounced action is canceled and the value becomes empty.
+ *
+ * <example name="ngModelOptions-directive-debounce" module="optionsExample">
+ * <file name="index.html">
+ * <div ng-controller="ExampleController">
+ * <form name="userForm">
+ * Name:
+ * <input type="text" name="userName"
+ * ng-model="user.name"
+ * ng-model-options="{ debounce: 1000 }" />
+ * <button ng-click="userForm.userName.$rollbackViewValue(); user.name=''">Clear</button><br />
+ * </form>
+ * <pre>user.name = <span ng-bind="user.name"></span></pre>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('optionsExample', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.user = { name: 'say' };
+ * }]);
+ * </file>
+ * </example>
+ *
+ * ### Default events, extra triggers, and catch-all debounce values
+ *
+ * This example shows the relationship between "default" update events and
+ * additional `updateOn` triggers.
+ *
+ * `default` events are those that are bound to the control, and when fired, update the `$viewValue`
+ * via {@link ngModel.NgModelController#$setViewValue $setViewValue}. Every event that is not listed
+ * in `updateOn` is considered a "default" event, since different control types have different
+ * default events.
+ *
+ * The control in this example updates by "default", "click", and "blur", with different `debounce`
+ * values. You can see that "click" doesn't have an individual `debounce` value -
+ * therefore it uses the `*` debounce value.
+ *
+ * There is also a button that calls {@link ngModel.NgModelController#$setViewValue $setViewValue}
+ * directly with a "custom" event. Since "custom" is not defined in the `updateOn` list,
+ * it is considered a "default" event and will update the
+ * control if "default" is defined in `updateOn`, and will receive the "default" debounce value.
+ * Note that this is just to illustrate how custom controls would possibly call `$setViewValue`.
+ *
+ * You can change the `updateOn` and `debounce` configuration to test different scenarios. This
+ * is done with {@link ngModel.NgModelController#$overrideModelOptions $overrideModelOptions}.
+ *
+ <example name="ngModelOptions-advanced" module="optionsExample">
+ <file name="index.html">
+ <model-update-demo></model-update-demo>
+ </file>
+ <file name="app.js">
+ angular.module('optionsExample', [])
+ .component('modelUpdateDemo', {
+ templateUrl: 'template.html',
+ controller: function() {
+ this.name = 'Chinua';
+
+ this.options = {
+ updateOn: 'default blur click',
+ debounce: {
+ default: 2000,
+ blur: 0,
+ '*': 1000
+ }
+ };
+
+ this.updateEvents = function() {
+ var eventList = this.options.updateOn.split(' ');
+ eventList.push('*');
+ var events = {};
+
+ for (var i = 0; i < eventList.length; i++) {
+ events[eventList[i]] = this.options.debounce[eventList[i]];
+ }
+
+ this.events = events;
+ };
+
+ this.updateOptions = function() {
+ var options = angular.extend(this.options, {
+ updateOn: Object.keys(this.events).join(' ').replace('*', ''),
+ debounce: this.events
+ });
+
+ this.form.input.$overrideModelOptions(options);
+ };
+
+ // Initialize the event form
+ this.updateEvents();
+ }
+ });
+ </file>
+ <file name="template.html">
+ <form name="$ctrl.form">
+ Input: <input type="text" name="input" ng-model="$ctrl.name" ng-model-options="$ctrl.options" />
+ </form>
+ Model: <tt>{{$ctrl.name}}</tt>
+ <hr>
+ <button ng-click="$ctrl.form.input.$setViewValue('some value', 'custom')">Trigger setViewValue with 'some value' and 'custom' event</button>
+
+ <hr>
+ <form ng-submit="$ctrl.updateOptions()">
+ <b>updateOn</b><br>
+ <input type="text" ng-model="$ctrl.options.updateOn" ng-change="$ctrl.updateEvents()" ng-model-options="{debounce: 500}">
+
+ <table>
+ <tr>
+ <th>Option</th>
+ <th>Debounce value</th>
+ </tr>
+ <tr ng-repeat="(key, value) in $ctrl.events">
+ <td>{{key}}</td>
+ <td><input type="number" ng-model="$ctrl.events[key]" /></td>
+ </tr>
+ </table>
+
+ <br>
+ <input type="submit" value="Update options">
+ </form>
+ </file>
+ </example>
+ *
+ *
+ * ## Model updates and validation
+ *
+ * The default behaviour in `ngModel` is that the model value is set to `undefined` when the
+ * validation determines that the value is invalid. By setting the `allowInvalid` property to true,
+ * the model will still be updated even if the value is invalid.
+ *
+ *
+ * ## Connecting to the scope
+ *
+ * By setting the `getterSetter` property to true you are telling ngModel that the `ngModel` expression
+ * on the scope refers to a "getter/setter" function rather than the value itself.
+ *
+ * The following example shows how to bind to getter/setters:
+ *
+ * <example name="ngModelOptions-directive-getter-setter" module="getterSetterExample">
+ * <file name="index.html">
+ * <div ng-controller="ExampleController">
+ * <form name="userForm">
+ * <label>
+ * Name:
+ * <input type="text" name="userName"
+ * ng-model="user.name"
+ * ng-model-options="{ getterSetter: true }" />
+ * </label>
+ * </form>
+ * <pre>user.name = <span ng-bind="user.name()"></span></pre>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('getterSetterExample', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * var _name = 'Brian';
+ * $scope.user = {
+ * name: function(newName) {
+ * return angular.isDefined(newName) ? (_name = newName) : _name;
+ * }
+ * };
+ * }]);
+ * </file>
+ * </example>
+ *
+ *
+ * ## Programmatically changing options
+ *
+ * The `ngModelOptions` expression is only evaluated once when the directive is linked; it is not
+ * watched for changes. However, it is possible to override the options on a single
+ * {@link ngModel.NgModelController} instance with
+ * {@link ngModel.NgModelController#$overrideModelOptions `NgModelController#$overrideModelOptions()`}.
+ * See also the example for
+ * {@link ngModelOptions#default-events-extra-triggers-and-catch-all-debounce-values
+ * Default events, extra triggers, and catch-all debounce values}.
+ *
+ *
+ * ## Specifying timezones
+ *
+ * You can specify the timezone that date/time input directives expect by providing its name in the
+ * `timezone` property.
+ *
+ *
+ * ## Formatting the value of `time` and `datetime-local`
+ *
+ * With the options `timeSecondsFormat` and `timeStripZeroSeconds` it is possible to adjust the value
+ * that is displayed in the control. Note that browsers may apply their own formatting
+ * in the user interface.
+ *
+ <example name="ngModelOptions-time-format" module="timeExample">
+ <file name="index.html">
+ <time-example></time-example>
+ </file>
+ <file name="script.js">
+ angular.module('timeExample', [])
+ .component('timeExample', {
+ templateUrl: 'timeExample.html',
+ controller: function() {
+ this.time = new Date(1970, 0, 1, 14, 57, 0);
+
+ this.options = {
+ timeSecondsFormat: 'ss',
+ timeStripZeroSeconds: true
+ };
+
+ this.optionChange = function() {
+ this.timeForm.timeFormatted.$overrideModelOptions(this.options);
+ this.time = new Date(this.time);
+ };
+ }
+ });
+ </file>
+ <file name="timeExample.html">
+ <form name="$ctrl.timeForm">
+ <strong>Default</strong>:
+ <input type="time" ng-model="$ctrl.time" step="any" /><br>
+ <strong>With options</strong>:
+ <input type="time" name="timeFormatted" ng-model="$ctrl.time" step="any" ng-model-options="$ctrl.options" />
+ <br>
+
+ Options:<br>
+ <code>timeSecondsFormat</code>:
+ <input
+ type="text"
+ ng-model="$ctrl.options.timeSecondsFormat"
+ ng-change="$ctrl.optionChange()">
+ <br>
+ <code>timeStripZeroSeconds</code>:
+ <input
+ type="checkbox"
+ ng-model="$ctrl.options.timeStripZeroSeconds"
+ ng-change="$ctrl.optionChange()">
+ </form>
+ </file>
+ * </example>
+ *
+ * @param {Object} ngModelOptions options to apply to {@link ngModel} directives on this element and
+ * and its descendents.
+ *
+ * **General options**:
+ *
+ * - `updateOn`: string specifying which event should the input be bound to. You can set several
+ * events using an space delimited list. There is a special event called `default` that
+ * matches the default events belonging to the control. These are the events that are bound to
+ * the control, and when fired, update the `$viewValue` via `$setViewValue`.
+ *
+ * `ngModelOptions` considers every event that is not listed in `updateOn` a "default" event,
+ * since different control types use different default events.
+ *
+ * See also the section {@link ngModelOptions#triggering-and-debouncing-model-updates
+ * Triggering and debouncing model updates}.
+ *
+ * - `debounce`: integer value which contains the debounce model update value in milliseconds. A
+ * value of 0 triggers an immediate update. If an object is supplied instead, you can specify a
+ * custom value for each event. For example:
+ * ```
+ * ng-model-options="{
+ * updateOn: 'default blur',
+ * debounce: { 'default': 500, 'blur': 0 }
+ * }"
+ * ```
+ * You can use the `*` key to specify a debounce value that applies to all events that are not
+ * specifically listed. In the following example, `mouseup` would have a debounce delay of 1000:
+ * ```
+ * ng-model-options="{
+ * updateOn: 'default blur mouseup',
+ * debounce: { 'default': 500, 'blur': 0, '*': 1000 }
+ * }"
+ * ```
+ * - `allowInvalid`: boolean value which indicates that the model can be set with values that did
+ * not validate correctly instead of the default behavior of setting the model to undefined.
+ * - `getterSetter`: boolean value which determines whether or not to treat functions bound to
+ * `ngModel` as getters/setters.
+ *
+ *
+ * **Input-type specific options**:
+ *
+ * - `timezone`: Defines the timezone to be used to read/write the `Date` instance in the model for
+ * `<input type="date" />`, `<input type="time" />`, ... . It understands UTC/GMT and the
+ * continental US time zone abbreviations, but for general use, use a time zone offset, for
+ * example, `'+0430'` (4 hours, 30 minutes east of the Greenwich meridian)
+ * If not specified, the timezone of the browser will be used.
+ * Note that changing the timezone will have no effect on the current date, and is only applied after
+ * the next input / model change.
+ *
+ * - `timeSecondsFormat`: Defines if the `time` and `datetime-local` types should show seconds and
+ * milliseconds. The option follows the format string of {@link date date filter}.
+ * By default, the options is `undefined` which is equal to `'ss.sss'` (seconds and milliseconds).
+ * The other options are `'ss'` (strips milliseconds), and `''` (empty string), which strips both
+ * seconds and milliseconds.
+ * Note that browsers that support `time` and `datetime-local` require the hour and minutes
+ * part of the time string, and may show the value differently in the user interface.
+ * {@link ngModelOptions#formatting-the-value-of-time-and-datetime-local- See the example}.
+ *
+ * - `timeStripZeroSeconds`: Defines if the `time` and `datetime-local` types should strip the
+ * seconds and milliseconds from the formatted value if they are zero. This option is applied
+ * after `timeSecondsFormat`.
+ * This option can be used to make the formatting consistent over different browsers, as some
+ * browsers with support for `time` will natively hide the milliseconds and
+ * seconds if they are zero, but others won't, and browsers that don't implement these input
+ * types will always show the full string.
+ * {@link ngModelOptions#formatting-the-value-of-time-and-datetime-local- See the example}.
+ *
+ */
+var ngModelOptionsDirective = function() {
+ NgModelOptionsController.$inject = ['$attrs', '$scope'];
+ function NgModelOptionsController($attrs, $scope) {
+ this.$$attrs = $attrs;
+ this.$$scope = $scope;
+ }
+ NgModelOptionsController.prototype = {
+ $onInit: function() {
+ var parentOptions = this.parentCtrl ? this.parentCtrl.$options : defaultModelOptions;
+ var modelOptionsDefinition = this.$$scope.$eval(this.$$attrs.ngModelOptions);
+
+ this.$options = parentOptions.createChild(modelOptionsDefinition);
+ }
+ };
+
+ return {
+ restrict: 'A',
+ // ngModelOptions needs to run before ngModel and input directives
+ priority: 10,
+ require: {parentCtrl: '?^^ngModelOptions'},
+ bindToController: true,
+ controller: NgModelOptionsController
+ };
+};
+
+
+// shallow copy over values from `src` that are not already specified on `dst`
+function defaults(dst, src) {
+ forEach(src, function(value, key) {
+ if (!isDefined(dst[key])) {
+ dst[key] = value;
+ }
+ });
+}
+
+/**
+ * @ngdoc directive
+ * @name ngNonBindable
+ * @restrict AC
+ * @priority 1000
+ * @element ANY
+ *
+ * @description
+ * The `ngNonBindable` directive tells AngularJS not to compile or bind the contents of the current
+ * DOM element, including directives on the element itself that have a lower priority than
+ * `ngNonBindable`. This is useful if the element contains what appears to be AngularJS directives
+ * and bindings but which should be ignored by AngularJS. This could be the case if you have a site
+ * that displays snippets of code, for instance.
+ *
+ * @example
+ * In this example there are two locations where a simple interpolation binding (`{{}}`) is present,
+ * but the one wrapped in `ngNonBindable` is left alone.
+ *
+ <example name="ng-non-bindable">
+ <file name="index.html">
+ <div>Normal: {{1 + 2}}</div>
+ <div ng-non-bindable>Ignored: {{1 + 2}}</div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ng-non-bindable', function() {
+ expect(element(by.binding('1 + 2')).getText()).toContain('3');
+ expect(element.all(by.css('div')).last().getText()).toMatch(/1 \+ 2/);
+ });
+ </file>
+ </example>
+ */
+var ngNonBindableDirective = ngDirective({ terminal: true, priority: 1000 });
+
+/* exported ngOptionsDirective */
+
+/* global jqLiteRemove */
+
+var ngOptionsMinErr = minErr('ngOptions');
+
+/**
+ * @ngdoc directive
+ * @name ngOptions
+ * @restrict A
+ *
+ * @description
+ *
+ * The `ngOptions` attribute can be used to dynamically generate a list of `<option>`
+ * elements for the `<select>` element using the array or object obtained by evaluating the
+ * `ngOptions` comprehension expression.
+ *
+ * In many cases, {@link ng.directive:ngRepeat ngRepeat} can be used on `<option>` elements instead of
+ * `ngOptions` to achieve a similar result. However, `ngOptions` provides some benefits:
+ * - more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the
+ * comprehension expression
+ * - reduced memory consumption by not creating a new scope for each repeated instance
+ * - increased render speed by creating the options in a documentFragment instead of individually
+ *
+ * When an item in the `<select>` menu is selected, the array element or object property
+ * represented by the selected option will be bound to the model identified by the `ngModel`
+ * directive.
+ *
+ * Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
+ * be nested into the `<select>` element. This element will then represent the `null` or "not selected"
+ * option. See example below for demonstration.
+ *
+ * ## Complex Models (objects or collections)
+ *
+ * By default, `ngModel` watches the model by reference, not value. This is important to know when
+ * binding the select to a model that is an object or a collection.
+ *
+ * One issue occurs if you want to preselect an option. For example, if you set
+ * the model to an object that is equal to an object in your collection, `ngOptions` won't be able to set the selection,
+ * because the objects are not identical. So by default, you should always reference the item in your collection
+ * for preselections, e.g.: `$scope.selected = $scope.collection[3]`.
+ *
+ * Another solution is to use a `track by` clause, because then `ngOptions` will track the identity
+ * of the item not by reference, but by the result of the `track by` expression. For example, if your
+ * collection items have an id property, you would `track by item.id`.
+ *
+ * A different issue with objects or collections is that ngModel won't detect if an object property or
+ * a collection item changes. For that reason, `ngOptions` additionally watches the model using
+ * `$watchCollection`, when the expression contains a `track by` clause or the the select has the `multiple` attribute.
+ * This allows ngOptions to trigger a re-rendering of the options even if the actual object/collection
+ * has not changed identity, but only a property on the object or an item in the collection changes.
+ *
+ * Note that `$watchCollection` does a shallow comparison of the properties of the object (or the items in the collection
+ * if the model is an array). This means that changing a property deeper than the first level inside the
+ * object/collection will not trigger a re-rendering.
+ *
+ * ## `select` **`as`**
+ *
+ * Using `select` **`as`** will bind the result of the `select` expression to the model, but
+ * the value of the `<select>` and `<option>` html elements will be either the index (for array data sources)
+ * or property name (for object data sources) of the value within the collection. If a **`track by`** expression
+ * is used, the result of that expression will be set as the value of the `option` and `select` elements.
+ *
+ *
+ * ### `select` **`as`** and **`track by`**
+ *
+ * <div class="alert alert-warning">
+ * Be careful when using `select` **`as`** and **`track by`** in the same expression.
+ * </div>
+ *
+ * Given this array of items on the $scope:
+ *
+ * ```js
+ * $scope.items = [{
+ * id: 1,
+ * label: 'aLabel',
+ * subItem: { name: 'aSubItem' }
+ * }, {
+ * id: 2,
+ * label: 'bLabel',
+ * subItem: { name: 'bSubItem' }
+ * }];
+ * ```
+ *
+ * This will work:
+ *
+ * ```html
+ * <select ng-options="item as item.label for item in items track by item.id" ng-model="selected"></select>
+ * ```
+ * ```js
+ * $scope.selected = $scope.items[0];
+ * ```
+ *
+ * but this will not work:
+ *
+ * ```html
+ * <select ng-options="item.subItem as item.label for item in items track by item.id" ng-model="selected"></select>
+ * ```
+ * ```js
+ * $scope.selected = $scope.items[0].subItem;
+ * ```
+ *
+ * In both examples, the **`track by`** expression is applied successfully to each `item` in the
+ * `items` array. Because the selected option has been set programmatically in the controller, the
+ * **`track by`** expression is also applied to the `ngModel` value. In the first example, the
+ * `ngModel` value is `items[0]` and the **`track by`** expression evaluates to `items[0].id` with
+ * no issue. In the second example, the `ngModel` value is `items[0].subItem` and the **`track by`**
+ * expression evaluates to `items[0].subItem.id` (which is undefined). As a result, the model value
+ * is not matched against any `<option>` and the `<select>` appears as having no selected value.
+ *
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {comprehension_expression} ngOptions in one of the following forms:
+ *
+ * * for array data sources:
+ * * `label` **`for`** `value` **`in`** `array`
+ * * `select` **`as`** `label` **`for`** `value` **`in`** `array`
+ * * `label` **`group by`** `group` **`for`** `value` **`in`** `array`
+ * * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array`
+ * * `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
+ * * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
+ * * `label` **`for`** `value` **`in`** `array` | orderBy:`orderexpr` **`track by`** `trackexpr`
+ * (for including a filter with `track by`)
+ * * for object data sources:
+ * * `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
+ * * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
+ * * `label` **`group by`** `group` **`for (`**`key`**`,`** `value`**`) in`** `object`
+ * * `label` **`disable when`** `disable` **`for (`**`key`**`,`** `value`**`) in`** `object`
+ * * `select` **`as`** `label` **`group by`** `group`
+ * **`for` `(`**`key`**`,`** `value`**`) in`** `object`
+ * * `select` **`as`** `label` **`disable when`** `disable`
+ * **`for` `(`**`key`**`,`** `value`**`) in`** `object`
+ *
+ * Where:
+ *
+ * * `array` / `object`: an expression which evaluates to an array / object to iterate over.
+ * * `value`: local variable which will refer to each item in the `array` or each property value
+ * of `object` during iteration.
+ * * `key`: local variable which will refer to a property name in `object` during iteration.
+ * * `label`: The result of this expression will be the label for `<option>` element. The
+ * `expression` will most likely refer to the `value` variable (e.g. `value.propertyName`).
+ * * `select`: The result of this expression will be bound to the model of the parent `<select>`
+ * element. If not specified, `select` expression will default to `value`.
+ * * `group`: The result of this expression will be used to group options using the `<optgroup>`
+ * DOM element.
+ * * `disable`: The result of this expression will be used to disable the rendered `<option>`
+ * element. Return `true` to disable.
+ * * `trackexpr`: Used when working with an array of objects. The result of this expression will be
+ * used to identify the objects in the array. The `trackexpr` will most likely refer to the
+ * `value` variable (e.g. `value.propertyName`). With this the selection is preserved
+ * even when the options are recreated (e.g. reloaded from the server).
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} required The control is considered valid only if value is entered.
+ * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+ * `required` when you want to data-bind to the `required` attribute.
+ * @param {string=} ngAttrSize sets the size of the select element dynamically. Uses the
+ * {@link guide/interpolation#-ngattr-for-binding-to-arbitrary-attributes ngAttr} directive.
+ *
+ * @example
+ <example module="selectExample" name="select">
+ <file name="index.html">
+ <script>
+ angular.module('selectExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.colors = [
+ {name:'black', shade:'dark'},
+ {name:'white', shade:'light', notAnOption: true},
+ {name:'red', shade:'dark'},
+ {name:'blue', shade:'dark', notAnOption: true},
+ {name:'yellow', shade:'light', notAnOption: false}
+ ];
+ $scope.myColor = $scope.colors[2]; // red
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <ul>
+ <li ng-repeat="color in colors">
+ <label>Name: <input ng-model="color.name"></label>
+ <label><input type="checkbox" ng-model="color.notAnOption"> Disabled?</label>
+ <button ng-click="colors.splice($index, 1)" aria-label="Remove">X</button>
+ </li>
+ <li>
+ <button ng-click="colors.push({})">add</button>
+ </li>
+ </ul>
+ <hr/>
+ <label>Color (null not allowed):
+ <select ng-model="myColor" ng-options="color.name for color in colors"></select>
+ </label><br/>
+ <label>Color (null allowed):
+ <span class="nullable">
+ <select ng-model="myColor" ng-options="color.name for color in colors">
+ <option value="">-- choose color --</option>
+ </select>
+ </span></label><br/>
+
+ <label>Color grouped by shade:
+ <select ng-model="myColor" ng-options="color.name group by color.shade for color in colors">
+ </select>
+ </label><br/>
+
+ <label>Color grouped by shade, with some disabled:
+ <select ng-model="myColor"
+ ng-options="color.name group by color.shade disable when color.notAnOption for color in colors">
+ </select>
+ </label><br/>
+
+
+
+ Select <button ng-click="myColor = { name:'not in list', shade: 'other' }">bogus</button>.
+ <br/>
+ <hr/>
+ Currently selected: {{ {selected_color:myColor} }}
+ <div style="border:solid 1px black; height:20px"
+ ng-style="{'background-color':myColor.name}">
+ </div>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ng-options', function() {
+ expect(element(by.binding('{selected_color:myColor}')).getText()).toMatch('red');
+ element.all(by.model('myColor')).first().click();
+ element.all(by.css('select[ng-model="myColor"] option')).first().click();
+ expect(element(by.binding('{selected_color:myColor}')).getText()).toMatch('black');
+ element(by.css('.nullable select[ng-model="myColor"]')).click();
+ element.all(by.css('.nullable select[ng-model="myColor"] option')).first().click();
+ expect(element(by.binding('{selected_color:myColor}')).getText()).toMatch('null');
+ });
+ </file>
+ </example>
+ */
+
+/* eslint-disable max-len */
+// //00001111111111000000000002222222222000000000000000000000333333333300000000000000000000000004444444444400000000000005555555555555000000000666666666666600000007777777777777000000000000000888888888800000000000000000009999999999
+var NG_OPTIONS_REGEXP = /^\s*([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+group\s+by\s+([\s\S]+?))?(?:\s+disable\s+when\s+([\s\S]+?))?\s+for\s+(?:([$\w][$\w]*)|(?:\(\s*([$\w][$\w]*)\s*,\s*([$\w][$\w]*)\s*\)))\s+in\s+([\s\S]+?)(?:\s+track\s+by\s+([\s\S]+?))?$/;
+ // 1: value expression (valueFn)
+ // 2: label expression (displayFn)
+ // 3: group by expression (groupByFn)
+ // 4: disable when expression (disableWhenFn)
+ // 5: array item variable name
+ // 6: object item key variable name
+ // 7: object item value variable name
+ // 8: collection expression
+ // 9: track by expression
+/* eslint-enable */
+
+
+var ngOptionsDirective = ['$compile', '$document', '$parse', function($compile, $document, $parse) {
+
+ function parseOptionsExpression(optionsExp, selectElement, scope) {
+
+ var match = optionsExp.match(NG_OPTIONS_REGEXP);
+ if (!(match)) {
+ throw ngOptionsMinErr('iexp',
+ 'Expected expression in form of ' +
+ '\'_select_ (as _label_)? for (_key_,)?_value_ in _collection_\'' +
+ ' but got \'{0}\'. Element: {1}',
+ optionsExp, startingTag(selectElement));
+ }
+
+ // Extract the parts from the ngOptions expression
+
+ // The variable name for the value of the item in the collection
+ var valueName = match[5] || match[7];
+ // The variable name for the key of the item in the collection
+ var keyName = match[6];
+
+ // An expression that generates the viewValue for an option if there is a label expression
+ var selectAs = / as /.test(match[0]) && match[1];
+ // An expression that is used to track the id of each object in the options collection
+ var trackBy = match[9];
+ // An expression that generates the viewValue for an option if there is no label expression
+ var valueFn = $parse(match[2] ? match[1] : valueName);
+ var selectAsFn = selectAs && $parse(selectAs);
+ var viewValueFn = selectAsFn || valueFn;
+ var trackByFn = trackBy && $parse(trackBy);
+
+ // Get the value by which we are going to track the option
+ // if we have a trackFn then use that (passing scope and locals)
+ // otherwise just hash the given viewValue
+ var getTrackByValueFn = trackBy ?
+ function(value, locals) { return trackByFn(scope, locals); } :
+ function getHashOfValue(value) { return hashKey(value); };
+ var getTrackByValue = function(value, key) {
+ return getTrackByValueFn(value, getLocals(value, key));
+ };
+
+ var displayFn = $parse(match[2] || match[1]);
+ var groupByFn = $parse(match[3] || '');
+ var disableWhenFn = $parse(match[4] || '');
+ var valuesFn = $parse(match[8]);
+
+ var locals = {};
+ var getLocals = keyName ? function(value, key) {
+ locals[keyName] = key;
+ locals[valueName] = value;
+ return locals;
+ } : function(value) {
+ locals[valueName] = value;
+ return locals;
+ };
+
+
+ function Option(selectValue, viewValue, label, group, disabled) {
+ this.selectValue = selectValue;
+ this.viewValue = viewValue;
+ this.label = label;
+ this.group = group;
+ this.disabled = disabled;
+ }
+
+ function getOptionValuesKeys(optionValues) {
+ var optionValuesKeys;
+
+ if (!keyName && isArrayLike(optionValues)) {
+ optionValuesKeys = optionValues;
+ } else {
+ // if object, extract keys, in enumeration order, unsorted
+ optionValuesKeys = [];
+ for (var itemKey in optionValues) {
+ if (optionValues.hasOwnProperty(itemKey) && itemKey.charAt(0) !== '$') {
+ optionValuesKeys.push(itemKey);
+ }
+ }
+ }
+ return optionValuesKeys;
+ }
+
+ return {
+ trackBy: trackBy,
+ getTrackByValue: getTrackByValue,
+ getWatchables: $parse(valuesFn, function(optionValues) {
+ // Create a collection of things that we would like to watch (watchedArray)
+ // so that they can all be watched using a single $watchCollection
+ // that only runs the handler once if anything changes
+ var watchedArray = [];
+ optionValues = optionValues || [];
+
+ var optionValuesKeys = getOptionValuesKeys(optionValues);
+ var optionValuesLength = optionValuesKeys.length;
+ for (var index = 0; index < optionValuesLength; index++) {
+ var key = (optionValues === optionValuesKeys) ? index : optionValuesKeys[index];
+ var value = optionValues[key];
+
+ var locals = getLocals(value, key);
+ var selectValue = getTrackByValueFn(value, locals);
+ watchedArray.push(selectValue);
+
+ // Only need to watch the displayFn if there is a specific label expression
+ if (match[2] || match[1]) {
+ var label = displayFn(scope, locals);
+ watchedArray.push(label);
+ }
+
+ // Only need to watch the disableWhenFn if there is a specific disable expression
+ if (match[4]) {
+ var disableWhen = disableWhenFn(scope, locals);
+ watchedArray.push(disableWhen);
+ }
+ }
+ return watchedArray;
+ }),
+
+ getOptions: function() {
+
+ var optionItems = [];
+ var selectValueMap = {};
+
+ // The option values were already computed in the `getWatchables` fn,
+ // which must have been called to trigger `getOptions`
+ var optionValues = valuesFn(scope) || [];
+ var optionValuesKeys = getOptionValuesKeys(optionValues);
+ var optionValuesLength = optionValuesKeys.length;
+
+ for (var index = 0; index < optionValuesLength; index++) {
+ var key = (optionValues === optionValuesKeys) ? index : optionValuesKeys[index];
+ var value = optionValues[key];
+ var locals = getLocals(value, key);
+ var viewValue = viewValueFn(scope, locals);
+ var selectValue = getTrackByValueFn(viewValue, locals);
+ var label = displayFn(scope, locals);
+ var group = groupByFn(scope, locals);
+ var disabled = disableWhenFn(scope, locals);
+ var optionItem = new Option(selectValue, viewValue, label, group, disabled);
+
+ optionItems.push(optionItem);
+ selectValueMap[selectValue] = optionItem;
+ }
+
+ return {
+ items: optionItems,
+ selectValueMap: selectValueMap,
+ getOptionFromViewValue: function(value) {
+ return selectValueMap[getTrackByValue(value)];
+ },
+ getViewValueFromOption: function(option) {
+ // If the viewValue could be an object that may be mutated by the application,
+ // we need to make a copy and not return the reference to the value on the option.
+ return trackBy ? copy(option.viewValue) : option.viewValue;
+ }
+ };
+ }
+ };
+ }
+
+
+ // Support: IE 9 only
+ // We can't just jqLite('<option>') since jqLite is not smart enough
+ // to create it in <select> and IE barfs otherwise.
+ var optionTemplate = window.document.createElement('option'),
+ optGroupTemplate = window.document.createElement('optgroup');
+
+ function ngOptionsPostLink(scope, selectElement, attr, ctrls) {
+
+ var selectCtrl = ctrls[0];
+ var ngModelCtrl = ctrls[1];
+ var multiple = attr.multiple;
+
+ // The emptyOption allows the application developer to provide their own custom "empty"
+ // option when the viewValue does not match any of the option values.
+ for (var i = 0, children = selectElement.children(), ii = children.length; i < ii; i++) {
+ if (children[i].value === '') {
+ selectCtrl.hasEmptyOption = true;
+ selectCtrl.emptyOption = children.eq(i);
+ break;
+ }
+ }
+
+ // The empty option will be compiled and rendered before we first generate the options
+ selectElement.empty();
+
+ var providedEmptyOption = !!selectCtrl.emptyOption;
+
+ var unknownOption = jqLite(optionTemplate.cloneNode(false));
+ unknownOption.val('?');
+
+ var options;
+ var ngOptions = parseOptionsExpression(attr.ngOptions, selectElement, scope);
+ // This stores the newly created options before they are appended to the select.
+ // Since the contents are removed from the fragment when it is appended,
+ // we only need to create it once.
+ var listFragment = $document[0].createDocumentFragment();
+
+ // Overwrite the implementation. ngOptions doesn't use hashes
+ selectCtrl.generateUnknownOptionValue = function(val) {
+ return '?';
+ };
+
+ // Update the controller methods for multiple selectable options
+ if (!multiple) {
+
+ selectCtrl.writeValue = function writeNgOptionsValue(value) {
+ // The options might not be defined yet when ngModel tries to render
+ if (!options) return;
+
+ var selectedOption = selectElement[0].options[selectElement[0].selectedIndex];
+ var option = options.getOptionFromViewValue(value);
+
+ // Make sure to remove the selected attribute from the previously selected option
+ // Otherwise, screen readers might get confused
+ if (selectedOption) selectedOption.removeAttribute('selected');
+
+ if (option) {
+ // Don't update the option when it is already selected.
+ // For example, the browser will select the first option by default. In that case,
+ // most properties are set automatically - except the `selected` attribute, which we
+ // set always
+
+ if (selectElement[0].value !== option.selectValue) {
+ selectCtrl.removeUnknownOption();
+
+ selectElement[0].value = option.selectValue;
+ option.element.selected = true;
+ }
+
+ option.element.setAttribute('selected', 'selected');
+ } else {
+ selectCtrl.selectUnknownOrEmptyOption(value);
+ }
+ };
+
+ selectCtrl.readValue = function readNgOptionsValue() {
+
+ var selectedOption = options.selectValueMap[selectElement.val()];
+
+ if (selectedOption && !selectedOption.disabled) {
+ selectCtrl.unselectEmptyOption();
+ selectCtrl.removeUnknownOption();
+ return options.getViewValueFromOption(selectedOption);
+ }
+ return null;
+ };
+
+ // If we are using `track by` then we must watch the tracked value on the model
+ // since ngModel only watches for object identity change
+ // FIXME: When a user selects an option, this watch will fire needlessly
+ if (ngOptions.trackBy) {
+ scope.$watch(
+ function() { return ngOptions.getTrackByValue(ngModelCtrl.$viewValue); },
+ function() { ngModelCtrl.$render(); }
+ );
+ }
+
+ } else {
+
+ selectCtrl.writeValue = function writeNgOptionsMultiple(values) {
+ // The options might not be defined yet when ngModel tries to render
+ if (!options) return;
+
+ // Only set `<option>.selected` if necessary, in order to prevent some browsers from
+ // scrolling to `<option>` elements that are outside the `<select>` element's viewport.
+ var selectedOptions = values && values.map(getAndUpdateSelectedOption) || [];
+
+ options.items.forEach(function(option) {
+ if (option.element.selected && !includes(selectedOptions, option)) {
+ option.element.selected = false;
+ }
+ });
+ };
+
+
+ selectCtrl.readValue = function readNgOptionsMultiple() {
+ var selectedValues = selectElement.val() || [],
+ selections = [];
+
+ forEach(selectedValues, function(value) {
+ var option = options.selectValueMap[value];
+ if (option && !option.disabled) selections.push(options.getViewValueFromOption(option));
+ });
+
+ return selections;
+ };
+
+ // If we are using `track by` then we must watch these tracked values on the model
+ // since ngModel only watches for object identity change
+ if (ngOptions.trackBy) {
+
+ scope.$watchCollection(function() {
+ if (isArray(ngModelCtrl.$viewValue)) {
+ return ngModelCtrl.$viewValue.map(function(value) {
+ return ngOptions.getTrackByValue(value);
+ });
+ }
+ }, function() {
+ ngModelCtrl.$render();
+ });
+
+ }
+ }
+
+ if (providedEmptyOption) {
+
+ // compile the element since there might be bindings in it
+ $compile(selectCtrl.emptyOption)(scope);
+
+ selectElement.prepend(selectCtrl.emptyOption);
+
+ if (selectCtrl.emptyOption[0].nodeType === NODE_TYPE_COMMENT) {
+ // This means the empty option has currently no actual DOM node, probably because
+ // it has been modified by a transclusion directive.
+ selectCtrl.hasEmptyOption = false;
+
+ // Redefine the registerOption function, which will catch
+ // options that are added by ngIf etc. (rendering of the node is async because of
+ // lazy transclusion)
+ selectCtrl.registerOption = function(optionScope, optionEl) {
+ if (optionEl.val() === '') {
+ selectCtrl.hasEmptyOption = true;
+ selectCtrl.emptyOption = optionEl;
+ selectCtrl.emptyOption.removeClass('ng-scope');
+ // This ensures the new empty option is selected if previously no option was selected
+ ngModelCtrl.$render();
+
+ optionEl.on('$destroy', function() {
+ var needsRerender = selectCtrl.$isEmptyOptionSelected();
+
+ selectCtrl.hasEmptyOption = false;
+ selectCtrl.emptyOption = undefined;
+
+ if (needsRerender) ngModelCtrl.$render();
+ });
+ }
+ };
+
+ } else {
+ // remove the class, which is added automatically because we recompile the element and it
+ // becomes the compilation root
+ selectCtrl.emptyOption.removeClass('ng-scope');
+ }
+
+ }
+
+ // We will re-render the option elements if the option values or labels change
+ scope.$watchCollection(ngOptions.getWatchables, updateOptions);
+
+ // ------------------------------------------------------------------ //
+
+ function addOptionElement(option, parent) {
+ var optionElement = optionTemplate.cloneNode(false);
+ parent.appendChild(optionElement);
+ updateOptionElement(option, optionElement);
+ }
+
+ function getAndUpdateSelectedOption(viewValue) {
+ var option = options.getOptionFromViewValue(viewValue);
+ var element = option && option.element;
+
+ if (element && !element.selected) element.selected = true;
+
+ return option;
+ }
+
+ function updateOptionElement(option, element) {
+ option.element = element;
+ element.disabled = option.disabled;
+ // Support: IE 11 only, Edge 12-13 only
+ // NOTE: The label must be set before the value, otherwise IE 11 & Edge create unresponsive
+ // selects in certain circumstances when multiple selects are next to each other and display
+ // the option list in listbox style, i.e. the select is [multiple], or specifies a [size].
+ // See https://github.com/angular/angular.js/issues/11314 for more info.
+ // This is unfortunately untestable with unit / e2e tests
+ if (option.label !== element.label) {
+ element.label = option.label;
+ element.textContent = option.label;
+ }
+ element.value = option.selectValue;
+ }
+
+ function updateOptions() {
+ var previousValue = options && selectCtrl.readValue();
+
+ // We must remove all current options, but cannot simply set innerHTML = null
+ // since the providedEmptyOption might have an ngIf on it that inserts comments which we
+ // must preserve.
+ // Instead, iterate over the current option elements and remove them or their optgroup
+ // parents
+ if (options) {
+
+ for (var i = options.items.length - 1; i >= 0; i--) {
+ var option = options.items[i];
+ if (isDefined(option.group)) {
+ jqLiteRemove(option.element.parentNode);
+ } else {
+ jqLiteRemove(option.element);
+ }
+ }
+ }
+
+ options = ngOptions.getOptions();
+
+ var groupElementMap = {};
+
+ options.items.forEach(function addOption(option) {
+ var groupElement;
+
+ if (isDefined(option.group)) {
+
+ // This option is to live in a group
+ // See if we have already created this group
+ groupElement = groupElementMap[option.group];
+
+ if (!groupElement) {
+
+ groupElement = optGroupTemplate.cloneNode(false);
+ listFragment.appendChild(groupElement);
+
+ // Update the label on the group element
+ // "null" is special cased because of Safari
+ groupElement.label = option.group === null ? 'null' : option.group;
+
+ // Store it for use later
+ groupElementMap[option.group] = groupElement;
+ }
+
+ addOptionElement(option, groupElement);
+
+ } else {
+
+ // This option is not in a group
+ addOptionElement(option, listFragment);
+ }
+ });
+
+ selectElement[0].appendChild(listFragment);
+
+ ngModelCtrl.$render();
+
+ // Check to see if the value has changed due to the update to the options
+ if (!ngModelCtrl.$isEmpty(previousValue)) {
+ var nextValue = selectCtrl.readValue();
+ var isNotPrimitive = ngOptions.trackBy || multiple;
+ if (isNotPrimitive ? !equals(previousValue, nextValue) : previousValue !== nextValue) {
+ ngModelCtrl.$setViewValue(nextValue);
+ ngModelCtrl.$render();
+ }
+ }
+ }
+ }
+
+ return {
+ restrict: 'A',
+ terminal: true,
+ require: ['select', 'ngModel'],
+ link: {
+ pre: function ngOptionsPreLink(scope, selectElement, attr, ctrls) {
+ // Deactivate the SelectController.register method to prevent
+ // option directives from accidentally registering themselves
+ // (and unwanted $destroy handlers etc.)
+ ctrls[0].registerOption = noop;
+ },
+ post: ngOptionsPostLink
+ }
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngPluralize
+ * @restrict EA
+ *
+ * @description
+ * `ngPluralize` is a directive that displays messages according to en-US localization rules.
+ * These rules are bundled with angular.js, but can be overridden
+ * (see {@link guide/i18n AngularJS i18n} dev guide). You configure ngPluralize directive
+ * by specifying the mappings between
+ * [plural categories](http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html)
+ * and the strings to be displayed.
+ *
+ * ## Plural categories and explicit number rules
+ * There are two
+ * [plural categories](http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html)
+ * in AngularJS's default en-US locale: "one" and "other".
+ *
+ * While a plural category may match many numbers (for example, in en-US locale, "other" can match
+ * any number that is not 1), an explicit number rule can only match one number. For example, the
+ * explicit number rule for "3" matches the number 3. There are examples of plural categories
+ * and explicit number rules throughout the rest of this documentation.
+ *
+ * ## Configuring ngPluralize
+ * You configure ngPluralize by providing 2 attributes: `count` and `when`.
+ * You can also provide an optional attribute, `offset`.
+ *
+ * The value of the `count` attribute can be either a string or an {@link guide/expression
+ * AngularJS expression}; these are evaluated on the current scope for its bound value.
+ *
+ * The `when` attribute specifies the mappings between plural categories and the actual
+ * string to be displayed. The value of the attribute should be a JSON object.
+ *
+ * The following example shows how to configure ngPluralize:
+ *
+ * ```html
+ * <ng-pluralize count="personCount"
+ when="{'0': 'Nobody is viewing.',
+ * 'one': '1 person is viewing.',
+ * 'other': '{} people are viewing.'}">
+ * </ng-pluralize>
+ *```
+ *
+ * In the example, `"0: Nobody is viewing."` is an explicit number rule. If you did not
+ * specify this rule, 0 would be matched to the "other" category and "0 people are viewing"
+ * would be shown instead of "Nobody is viewing". You can specify an explicit number rule for
+ * other numbers, for example 12, so that instead of showing "12 people are viewing", you can
+ * show "a dozen people are viewing".
+ *
+ * You can use a set of closed braces (`{}`) as a placeholder for the number that you want substituted
+ * into pluralized strings. In the previous example, AngularJS will replace `{}` with
+ * <span ng-non-bindable>`{{personCount}}`</span>. The closed braces `{}` is a placeholder
+ * for <span ng-non-bindable>{{numberExpression}}</span>.
+ *
+ * If no rule is defined for a category, then an empty string is displayed and a warning is generated.
+ * Note that some locales define more categories than `one` and `other`. For example, fr-fr defines `few` and `many`.
+ *
+ * ## Configuring ngPluralize with offset
+ * The `offset` attribute allows further customization of pluralized text, which can result in
+ * a better user experience. For example, instead of the message "4 people are viewing this document",
+ * you might display "John, Kate and 2 others are viewing this document".
+ * The offset attribute allows you to offset a number by any desired value.
+ * Let's take a look at an example:
+ *
+ * ```html
+ * <ng-pluralize count="personCount" offset=2
+ * when="{'0': 'Nobody is viewing.',
+ * '1': '{{person1}} is viewing.',
+ * '2': '{{person1}} and {{person2}} are viewing.',
+ * 'one': '{{person1}}, {{person2}} and one other person are viewing.',
+ * 'other': '{{person1}}, {{person2}} and {} other people are viewing.'}">
+ * </ng-pluralize>
+ * ```
+ *
+ * Notice that we are still using two plural categories(one, other), but we added
+ * three explicit number rules 0, 1 and 2.
+ * When one person, perhaps John, views the document, "John is viewing" will be shown.
+ * When three people view the document, no explicit number rule is found, so
+ * an offset of 2 is taken off 3, and AngularJS uses 1 to decide the plural category.
+ * In this case, plural category 'one' is matched and "John, Mary and one other person are viewing"
+ * is shown.
+ *
+ * Note that when you specify offsets, you must provide explicit number rules for
+ * numbers from 0 up to and including the offset. If you use an offset of 3, for example,
+ * you must provide explicit number rules for 0, 1, 2 and 3. You must also provide plural strings for
+ * plural categories "one" and "other".
+ *
+ * @param {string|expression} count The variable to be bound to.
+ * @param {string} when The mapping between plural category to its corresponding strings.
+ * @param {number=} offset Offset to deduct from the total number.
+ *
+ * @example
+ <example module="pluralizeExample" name="ng-pluralize">
+ <file name="index.html">
+ <script>
+ angular.module('pluralizeExample', [])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.person1 = 'Igor';
+ $scope.person2 = 'Misko';
+ $scope.personCount = 1;
+ }]);
+ </script>
+ <div ng-controller="ExampleController">
+ <label>Person 1:<input type="text" ng-model="person1" value="Igor" /></label><br/>
+ <label>Person 2:<input type="text" ng-model="person2" value="Misko" /></label><br/>
+ <label>Number of People:<input type="text" ng-model="personCount" value="1" /></label><br/>
+
+ <!--- Example with simple pluralization rules for en locale --->
+ Without Offset:
+ <ng-pluralize count="personCount"
+ when="{'0': 'Nobody is viewing.',
+ 'one': '1 person is viewing.',
+ 'other': '{} people are viewing.'}">
+ </ng-pluralize><br>
+
+ <!--- Example with offset --->
+ With Offset(2):
+ <ng-pluralize count="personCount" offset=2
+ when="{'0': 'Nobody is viewing.',
+ '1': '{{person1}} is viewing.',
+ '2': '{{person1}} and {{person2}} are viewing.',
+ 'one': '{{person1}}, {{person2}} and one other person are viewing.',
+ 'other': '{{person1}}, {{person2}} and {} other people are viewing.'}">
+ </ng-pluralize>
+ </div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should show correct pluralized string', function() {
+ var withoutOffset = element.all(by.css('ng-pluralize')).get(0);
+ var withOffset = element.all(by.css('ng-pluralize')).get(1);
+ var countInput = element(by.model('personCount'));
+
+ expect(withoutOffset.getText()).toEqual('1 person is viewing.');
+ expect(withOffset.getText()).toEqual('Igor is viewing.');
+
+ countInput.clear();
+ countInput.sendKeys('0');
+
+ expect(withoutOffset.getText()).toEqual('Nobody is viewing.');
+ expect(withOffset.getText()).toEqual('Nobody is viewing.');
+
+ countInput.clear();
+ countInput.sendKeys('2');
+
+ expect(withoutOffset.getText()).toEqual('2 people are viewing.');
+ expect(withOffset.getText()).toEqual('Igor and Misko are viewing.');
+
+ countInput.clear();
+ countInput.sendKeys('3');
+
+ expect(withoutOffset.getText()).toEqual('3 people are viewing.');
+ expect(withOffset.getText()).toEqual('Igor, Misko and one other person are viewing.');
+
+ countInput.clear();
+ countInput.sendKeys('4');
+
+ expect(withoutOffset.getText()).toEqual('4 people are viewing.');
+ expect(withOffset.getText()).toEqual('Igor, Misko and 2 other people are viewing.');
+ });
+ it('should show data-bound names', function() {
+ var withOffset = element.all(by.css('ng-pluralize')).get(1);
+ var personCount = element(by.model('personCount'));
+ var person1 = element(by.model('person1'));
+ var person2 = element(by.model('person2'));
+ personCount.clear();
+ personCount.sendKeys('4');
+ person1.clear();
+ person1.sendKeys('Di');
+ person2.clear();
+ person2.sendKeys('Vojta');
+ expect(withOffset.getText()).toEqual('Di, Vojta and 2 other people are viewing.');
+ });
+ </file>
+ </example>
+ */
+var ngPluralizeDirective = ['$locale', '$interpolate', '$log', function($locale, $interpolate, $log) {
+ var BRACE = /{}/g,
+ IS_WHEN = /^when(Minus)?(.+)$/;
+
+ return {
+ link: function(scope, element, attr) {
+ var numberExp = attr.count,
+ whenExp = attr.$attr.when && element.attr(attr.$attr.when), // we have {{}} in attrs
+ offset = attr.offset || 0,
+ whens = scope.$eval(whenExp) || {},
+ whensExpFns = {},
+ startSymbol = $interpolate.startSymbol(),
+ endSymbol = $interpolate.endSymbol(),
+ braceReplacement = startSymbol + numberExp + '-' + offset + endSymbol,
+ watchRemover = angular.noop,
+ lastCount;
+
+ forEach(attr, function(expression, attributeName) {
+ var tmpMatch = IS_WHEN.exec(attributeName);
+ if (tmpMatch) {
+ var whenKey = (tmpMatch[1] ? '-' : '') + lowercase(tmpMatch[2]);
+ whens[whenKey] = element.attr(attr.$attr[attributeName]);
+ }
+ });
+ forEach(whens, function(expression, key) {
+ whensExpFns[key] = $interpolate(expression.replace(BRACE, braceReplacement));
+
+ });
+
+ scope.$watch(numberExp, function ngPluralizeWatchAction(newVal) {
+ var count = parseFloat(newVal);
+ var countIsNaN = isNumberNaN(count);
+
+ if (!countIsNaN && !(count in whens)) {
+ // If an explicit number rule such as 1, 2, 3... is defined, just use it.
+ // Otherwise, check it against pluralization rules in $locale service.
+ count = $locale.pluralCat(count - offset);
+ }
+
+ // If both `count` and `lastCount` are NaN, we don't need to re-register a watch.
+ // In JS `NaN !== NaN`, so we have to explicitly check.
+ if ((count !== lastCount) && !(countIsNaN && isNumberNaN(lastCount))) {
+ watchRemover();
+ var whenExpFn = whensExpFns[count];
+ if (isUndefined(whenExpFn)) {
+ if (newVal != null) {
+ $log.debug('ngPluralize: no rule defined for \'' + count + '\' in ' + whenExp);
+ }
+ watchRemover = noop;
+ updateElementText();
+ } else {
+ watchRemover = scope.$watch(whenExpFn, updateElementText);
+ }
+ lastCount = count;
+ }
+ });
+
+ function updateElementText(newText) {
+ element.text(newText || '');
+ }
+ }
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngRef
+ * @restrict A
+ *
+ * @description
+ * The `ngRef` attribute tells AngularJS to assign the controller of a component (or a directive)
+ * to the given property in the current scope. It is also possible to add the jqlite-wrapped DOM
+ * element to the scope.
+ *
+ * If the element with `ngRef` is destroyed `null` is assigned to the property.
+ *
+ * Note that if you want to assign from a child into the parent scope, you must initialize the
+ * target property on the parent scope, otherwise `ngRef` will assign on the child scope.
+ * This commonly happens when assigning elements or components wrapped in {@link ngIf} or
+ * {@link ngRepeat}. See the second example below.
+ *
+ *
+ * @element ANY
+ * @param {string} ngRef property name - A valid AngularJS expression identifier to which the
+ * controller or jqlite-wrapped DOM element will be bound.
+ * @param {string=} ngRefRead read value - The name of a directive (or component) on this element,
+ * or the special string `$element`. If a name is provided, `ngRef` will
+ * assign the matching controller. If `$element` is provided, the element
+ * itself is assigned (even if a controller is available).
+ *
+ *
+ * @example
+ * ### Simple toggle
+ * This example shows how the controller of the component toggle
+ * is reused in the template through the scope to use its logic.
+ * <example name="ng-ref-component" module="myApp">
+ * <file name="index.html">
+ * <my-toggle ng-ref="myToggle"></my-toggle>
+ * <button ng-click="myToggle.toggle()">Toggle</button>
+ * <div ng-show="myToggle.isOpen()">
+ * You are using a component in the same template to show it.
+ * </div>
+ * </file>
+ * <file name="index.js">
+ * angular.module('myApp', [])
+ * .component('myToggle', {
+ * controller: function ToggleController() {
+ * var opened = false;
+ * this.isOpen = function() { return opened; };
+ * this.toggle = function() { opened = !opened; };
+ * }
+ * });
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * it('should publish the toggle into the scope', function() {
+ * var toggle = element(by.buttonText('Toggle'));
+ * expect(toggle.evaluate('myToggle.isOpen()')).toEqual(false);
+ * toggle.click();
+ * expect(toggle.evaluate('myToggle.isOpen()')).toEqual(true);
+ * });
+ * </file>
+ * </example>
+ *
+ * @example
+ * ### ngRef inside scopes
+ * This example shows how `ngRef` works with child scopes. The `ngRepeat`-ed `myWrapper` components
+ * are assigned to the scope of `myRoot`, because the `toggles` property has been initialized.
+ * The repeated `myToggle` components are published to the child scopes created by `ngRepeat`.
+ * `ngIf` behaves similarly - the assignment of `myToggle` happens in the `ngIf` child scope,
+ * because the target property has not been initialized on the `myRoot` component controller.
+ *
+ * <example name="ng-ref-scopes" module="myApp">
+ * <file name="index.html">
+ * <my-root></my-root>
+ * </file>
+ * <file name="index.js">
+ * angular.module('myApp', [])
+ * .component('myRoot', {
+ * templateUrl: 'root.html',
+ * controller: function() {
+ * this.wrappers = []; // initialize the array so that the wrappers are assigned into the parent scope
+ * }
+ * })
+ * .component('myToggle', {
+ * template: '<strong>myToggle</strong><button ng-click="$ctrl.toggle()" ng-transclude></button>',
+ * transclude: true,
+ * controller: function ToggleController() {
+ * var opened = false;
+ * this.isOpen = function() { return opened; };
+ * this.toggle = function() { opened = !opened; };
+ * }
+ * })
+ * .component('myWrapper', {
+ * transclude: true,
+ * template: '<strong>myWrapper</strong>' +
+ * '<div>ngRepeatToggle.isOpen(): {{$ctrl.ngRepeatToggle.isOpen() | json}}</div>' +
+ * '<my-toggle ng-ref="$ctrl.ngRepeatToggle"><ng-transclude></ng-transclude></my-toggle>'
+ * });
+ * </file>
+ * <file name="root.html">
+ * <strong>myRoot</strong>
+ * <my-toggle ng-ref="$ctrl.outerToggle">Outer Toggle</my-toggle>
+ * <div>outerToggle.isOpen(): {{$ctrl.outerToggle.isOpen() | json}}</div>
+ * <div><em>wrappers assigned to root</em><br>
+ * <div ng-repeat="wrapper in $ctrl.wrappers">
+ * wrapper.ngRepeatToggle.isOpen(): {{wrapper.ngRepeatToggle.isOpen() | json}}
+ * </div>
+ *
+ * <ul>
+ * <li ng-repeat="(index, value) in [1,2,3]">
+ * <strong>ngRepeat</strong>
+ * <div>outerToggle.isOpen(): {{$ctrl.outerToggle.isOpen() | json}}</div>
+ * <my-wrapper ng-ref="$ctrl.wrappers[index]">ngRepeat Toggle {{$index + 1}}</my-wrapper>
+ * </li>
+ * </ul>
+ *
+ * <div>ngIfToggle.isOpen(): {{ngIfToggle.isOpen()}} // This is always undefined because it's
+ * assigned to the child scope created by ngIf.
+ * </div>
+ * <div ng-if="true">
+ <strong>ngIf</strong>
+ * <my-toggle ng-ref="ngIfToggle">ngIf Toggle</my-toggle>
+ * <div>ngIfToggle.isOpen(): {{ngIfToggle.isOpen() | json}}</div>
+ * <div>outerToggle.isOpen(): {{$ctrl.outerToggle.isOpen() | json}}</div>
+ * </div>
+ * </file>
+ * <file name="styles.css">
+ * ul {
+ * list-style: none;
+ * padding-left: 0;
+ * }
+ *
+ * li[ng-repeat] {
+ * background: lightgreen;
+ * padding: 8px;
+ * margin: 8px;
+ * }
+ *
+ * [ng-if] {
+ * background: lightgrey;
+ * padding: 8px;
+ * }
+ *
+ * my-root {
+ * background: lightgoldenrodyellow;
+ * padding: 8px;
+ * display: block;
+ * }
+ *
+ * my-wrapper {
+ * background: lightsalmon;
+ * padding: 8px;
+ * display: block;
+ * }
+ *
+ * my-toggle {
+ * background: lightblue;
+ * padding: 8px;
+ * display: block;
+ * }
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * var OuterToggle = function() {
+ * this.toggle = function() {
+ * element(by.buttonText('Outer Toggle')).click();
+ * };
+ * this.isOpen = function() {
+ * return element.all(by.binding('outerToggle.isOpen()')).first().getText();
+ * };
+ * };
+ * var NgRepeatToggle = function(i) {
+ * var parent = element.all(by.repeater('(index, value) in [1,2,3]')).get(i - 1);
+ * this.toggle = function() {
+ * element(by.buttonText('ngRepeat Toggle ' + i)).click();
+ * };
+ * this.isOpen = function() {
+ * return parent.element(by.binding('ngRepeatToggle.isOpen() | json')).getText();
+ * };
+ * this.isOuterOpen = function() {
+ * return parent.element(by.binding('outerToggle.isOpen() | json')).getText();
+ * };
+ * };
+ * var NgRepeatToggles = function() {
+ * var toggles = [1,2,3].map(function(i) { return new NgRepeatToggle(i); });
+ * this.forEach = function(fn) {
+ * toggles.forEach(fn);
+ * };
+ * this.isOuterOpen = function(i) {
+ * return toggles[i - 1].isOuterOpen();
+ * };
+ * };
+ * var NgIfToggle = function() {
+ * var parent = element(by.css('[ng-if]'));
+ * this.toggle = function() {
+ * element(by.buttonText('ngIf Toggle')).click();
+ * };
+ * this.isOpen = function() {
+ * return by.binding('ngIfToggle.isOpen() | json').getText();
+ * };
+ * this.isOuterOpen = function() {
+ * return parent.element(by.binding('outerToggle.isOpen() | json')).getText();
+ * };
+ * };
+ *
+ * it('should toggle the outer toggle', function() {
+ * var outerToggle = new OuterToggle();
+ * expect(outerToggle.isOpen()).toEqual('outerToggle.isOpen(): false');
+ * outerToggle.toggle();
+ * expect(outerToggle.isOpen()).toEqual('outerToggle.isOpen(): true');
+ * });
+ *
+ * it('should toggle all outer toggles', function() {
+ * var outerToggle = new OuterToggle();
+ * var repeatToggles = new NgRepeatToggles();
+ * var ifToggle = new NgIfToggle();
+ * expect(outerToggle.isOpen()).toEqual('outerToggle.isOpen(): false');
+ * expect(repeatToggles.isOuterOpen(1)).toEqual('outerToggle.isOpen(): false');
+ * expect(repeatToggles.isOuterOpen(2)).toEqual('outerToggle.isOpen(): false');
+ * expect(repeatToggles.isOuterOpen(3)).toEqual('outerToggle.isOpen(): false');
+ * expect(ifToggle.isOuterOpen()).toEqual('outerToggle.isOpen(): false');
+ * outerToggle.toggle();
+ * expect(outerToggle.isOpen()).toEqual('outerToggle.isOpen(): true');
+ * expect(repeatToggles.isOuterOpen(1)).toEqual('outerToggle.isOpen(): true');
+ * expect(repeatToggles.isOuterOpen(2)).toEqual('outerToggle.isOpen(): true');
+ * expect(repeatToggles.isOuterOpen(3)).toEqual('outerToggle.isOpen(): true');
+ * expect(ifToggle.isOuterOpen()).toEqual('outerToggle.isOpen(): true');
+ * });
+ *
+ * it('should toggle each repeat iteration separately', function() {
+ * var repeatToggles = new NgRepeatToggles();
+ *
+ * repeatToggles.forEach(function(repeatToggle) {
+ * expect(repeatToggle.isOpen()).toEqual('ngRepeatToggle.isOpen(): false');
+ * expect(repeatToggle.isOuterOpen()).toEqual('outerToggle.isOpen(): false');
+ * repeatToggle.toggle();
+ * expect(repeatToggle.isOpen()).toEqual('ngRepeatToggle.isOpen(): true');
+ * expect(repeatToggle.isOuterOpen()).toEqual('outerToggle.isOpen(): false');
+ * });
+ * });
+ * </file>
+ * </example>
+ *
+ */
+
+var ngRefMinErr = minErr('ngRef');
+
+var ngRefDirective = ['$parse', function($parse) {
+ return {
+ priority: -1, // Needed for compatibility with element transclusion on the same element
+ restrict: 'A',
+ compile: function(tElement, tAttrs) {
+ // Get the expected controller name, converts <data-some-thing> into "someThing"
+ var controllerName = directiveNormalize(nodeName_(tElement));
+
+ // Get the expression for value binding
+ var getter = $parse(tAttrs.ngRef);
+ var setter = getter.assign || function() {
+ throw ngRefMinErr('nonassign', 'Expression in ngRef="{0}" is non-assignable!', tAttrs.ngRef);
+ };
+
+ return function(scope, element, attrs) {
+ var refValue;
+
+ if (attrs.hasOwnProperty('ngRefRead')) {
+ if (attrs.ngRefRead === '$element') {
+ refValue = element;
+ } else {
+ refValue = element.data('$' + attrs.ngRefRead + 'Controller');
+
+ if (!refValue) {
+ throw ngRefMinErr(
+ 'noctrl',
+ 'The controller for ngRefRead="{0}" could not be found on ngRef="{1}"',
+ attrs.ngRefRead,
+ tAttrs.ngRef
+ );
+ }
+ }
+ } else {
+ refValue = element.data('$' + controllerName + 'Controller');
+ }
+
+ refValue = refValue || element;
+
+ setter(scope, refValue);
+
+ // when the element is removed, remove it (nullify it)
+ element.on('$destroy', function() {
+ // only remove it if value has not changed,
+ // because animations (and other procedures) may duplicate elements
+ if (getter(scope) === refValue) {
+ setter(scope, null);
+ }
+ });
+ };
+ }
+ };
+}];
+
+/* exported ngRepeatDirective */
+
+/**
+ * @ngdoc directive
+ * @name ngRepeat
+ * @multiElement
+ * @restrict A
+ *
+ * @description
+ * The `ngRepeat` directive instantiates a template once per item from a collection. Each template
+ * instance gets its own scope, where the given loop variable is set to the current collection item,
+ * and `$index` is set to the item index or key.
+ *
+ * Special properties are exposed on the local scope of each template instance, including:
+ *
+ * | Variable | Type | Details |
+ * |-----------|-----------------|-----------------------------------------------------------------------------|
+ * | `$index` | {@type number} | iterator offset of the repeated element (0..length-1) |
+ * | `$first` | {@type boolean} | true if the repeated element is first in the iterator. |
+ * | `$middle` | {@type boolean} | true if the repeated element is between the first and last in the iterator. |
+ * | `$last` | {@type boolean} | true if the repeated element is last in the iterator. |
+ * | `$even` | {@type boolean} | true if the iterator position `$index` is even (otherwise false). |
+ * | `$odd` | {@type boolean} | true if the iterator position `$index` is odd (otherwise false). |
+ *
+ * <div class="alert alert-info">
+ * Creating aliases for these properties is possible with {@link ng.directive:ngInit `ngInit`}.
+ * This may be useful when, for instance, nesting ngRepeats.
+ * </div>
+ *
+ *
+ * ## Iterating over object properties
+ *
+ * It is possible to get `ngRepeat` to iterate over the properties of an object using the following
+ * syntax:
+ *
+ * ```js
+ * <div ng-repeat="(key, value) in myObj"> ... </div>
+ * ```
+ *
+ * However, there are a few limitations compared to array iteration:
+ *
+ * - The JavaScript specification does not define the order of keys
+ * returned for an object, so AngularJS relies on the order returned by the browser
+ * when running `for key in myObj`. Browsers generally follow the strategy of providing
+ * keys in the order in which they were defined, although there are exceptions when keys are deleted
+ * and reinstated. See the
+ * [MDN page on `delete` for more info](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete#Cross-browser_notes).
+ *
+ * - `ngRepeat` will silently *ignore* object keys starting with `$`, because
+ * it's a prefix used by AngularJS for public (`$`) and private (`$$`) properties.
+ *
+ * - The built-in filters {@link ng.orderBy orderBy} and {@link ng.filter filter} do not work with
+ * objects, and will throw an error if used with one.
+ *
+ * If you are hitting any of these limitations, the recommended workaround is to convert your object into an array
+ * that is sorted into the order that you prefer before providing it to `ngRepeat`. You could
+ * do this with a filter such as [toArrayFilter](http://ngmodules.org/modules/angular-toArrayFilter)
+ * or implement a `$watch` on the object yourself.
+ *
+ *
+ * ## Tracking and Duplicates
+ *
+ * `ngRepeat` uses {@link $rootScope.Scope#$watchCollection $watchCollection} to detect changes in
+ * the collection. When a change happens, `ngRepeat` then makes the corresponding changes to the DOM:
+ *
+ * * When an item is added, a new instance of the template is added to the DOM.
+ * * When an item is removed, its template instance is removed from the DOM.
+ * * When items are reordered, their respective templates are reordered in the DOM.
+ *
+ * To minimize creation of DOM elements, `ngRepeat` uses a function
+ * to "keep track" of all items in the collection and their corresponding DOM elements.
+ * For example, if an item is added to the collection, `ngRepeat` will know that all other items
+ * already have DOM elements, and will not re-render them.
+ *
+ * All different types of tracking functions, their syntax, and their support for duplicate
+ * items in collections can be found in the
+ * {@link ngRepeat#ngRepeat-arguments ngRepeat expression description}.
+ *
+ * <div class="alert alert-success">
+ * **Best Practice:** If you are working with objects that have a unique identifier property, you
+ * should track by this identifier instead of the object instance,
+ * e.g. `item in items track by item.id`.
+ * Should you reload your data later, `ngRepeat` will not have to rebuild the DOM elements for items
+ * it has already rendered, even if the JavaScript objects in the collection have been substituted
+ * for new ones. For large collections, this significantly improves rendering performance.
+ * </div>
+ *
+ * ### Effects of DOM Element re-use
+ *
+ * When DOM elements are re-used, ngRepeat updates the scope for the element, which will
+ * automatically update any active bindings on the template. However, other
+ * functionality will not be updated, because the element is not re-created:
+ *
+ * - Directives are not re-compiled
+ * - {@link guide/expression#one-time-binding one-time expressions} on the repeated template are not
+ * updated if they have stabilized.
+ *
+ * The above affects all kinds of element re-use due to tracking, but may be especially visible
+ * when tracking by `$index` due to the way ngRepeat re-uses elements.
+ *
+ * The following example shows the effects of different actions with tracking:
+
+ <example module="ngRepeat" name="ngRepeat-tracking" deps="angular-animate.js" animations="true">
+ <file name="script.js">
+ angular.module('ngRepeat', ['ngAnimate']).controller('repeatController', function($scope) {
+ var friends = [
+ {name:'John', age:25},
+ {name:'Mary', age:40},
+ {name:'Peter', age:85}
+ ];
+
+ $scope.removeFirst = function() {
+ $scope.friends.shift();
+ };
+
+ $scope.updateAge = function() {
+ $scope.friends.forEach(function(el) {
+ el.age = el.age + 5;
+ });
+ };
+
+ $scope.copy = function() {
+ $scope.friends = angular.copy($scope.friends);
+ };
+
+ $scope.reset = function() {
+ $scope.friends = angular.copy(friends);
+ };
+
+ $scope.reset();
+ });
+ </file>
+ <file name="index.html">
+ <div ng-controller="repeatController">
+ <ol>
+ <li>When you click "Update Age", only the first list updates the age, because all others have
+ a one-time binding on the age property. If you then click "Copy", the current friend list
+ is copied, and now the second list updates the age, because the identity of the collection items
+ has changed and the list must be re-rendered. The 3rd and 4th list stay the same, because all the
+ items are already known according to their tracking functions.
+ </li>
+ <li>When you click "Remove First", the 4th list has the wrong age on both remaining items. This is
+ due to tracking by $index: when the first collection item is removed, ngRepeat reuses the first
+ DOM element for the new first collection item, and so on. Since the age property is one-time
+ bound, the value remains from the collection item which was previously at this index.
+ </li>
+ </ol>
+
+ <button ng-click="removeFirst()">Remove First</button>
+ <button ng-click="updateAge()">Update Age</button>
+ <button ng-click="copy()">Copy</button>
+ <br><button ng-click="reset()">Reset List</button>
+ <br>
+ <code>track by $id(friend)</code> (default):
+ <ul class="example-animate-container">
+ <li class="animate-repeat" ng-repeat="friend in friends">
+ {{friend.name}} is {{friend.age}} years old.
+ </li>
+ </ul>
+ <code>track by $id(friend)</code> (default), with age one-time binding:
+ <ul class="example-animate-container">
+ <li class="animate-repeat" ng-repeat="friend in friends">
+ {{friend.name}} is {{::friend.age}} years old.
+ </li>
+ </ul>
+ <code>track by friend.name</code>, with age one-time binding:
+ <ul class="example-animate-container">
+ <li class="animate-repeat" ng-repeat="friend in friends track by friend.name">
+ {{friend.name}} is {{::friend.age}} years old.
+ </li>
+ </ul>
+ <code>track by $index</code>, with age one-time binding:
+ <ul class="example-animate-container">
+ <li class="animate-repeat" ng-repeat="friend in friends track by $index">
+ {{friend.name}} is {{::friend.age}} years old.
+ </li>
+ </ul>
+ </div>
+ </file>
+ <file name="animations.css">
+ .example-animate-container {
+ background:white;
+ border:1px solid black;
+ list-style:none;
+ margin:0;
+ padding:0 10px;
+ }
+
+ .animate-repeat {
+ line-height:30px;
+ list-style:none;
+ box-sizing:border-box;
+ }
+
+ .animate-repeat.ng-move,
+ .animate-repeat.ng-enter,
+ .animate-repeat.ng-leave {
+ transition:all linear 0.5s;
+ }
+
+ .animate-repeat.ng-leave.ng-leave-active,
+ .animate-repeat.ng-move,
+ .animate-repeat.ng-enter {
+ opacity:0;
+ max-height:0;
+ }
+
+ .animate-repeat.ng-leave,
+ .animate-repeat.ng-move.ng-move-active,
+ .animate-repeat.ng-enter.ng-enter-active {
+ opacity:1;
+ max-height:30px;
+ }
+ </file>
+ </example>
+
+ *
+ * ## Special repeat start and end points
+ * To repeat a series of elements instead of just one parent element, ngRepeat (as well as other ng directives) supports extending
+ * the range of the repeater by defining explicit start and end points by using **ng-repeat-start** and **ng-repeat-end** respectively.
+ * The **ng-repeat-start** directive works the same as **ng-repeat**, but will repeat all the HTML code (including the tag it's defined on)
+ * up to and including the ending HTML tag where **ng-repeat-end** is placed.
+ *
+ * The example below makes use of this feature:
+ * ```html
+ * <header ng-repeat-start="item in items">
+ * Header {{ item }}
+ * </header>
+ * <div class="body">
+ * Body {{ item }}
+ * </div>
+ * <footer ng-repeat-end>
+ * Footer {{ item }}
+ * </footer>
+ * ```
+ *
+ * And with an input of {@type ['A','B']} for the items variable in the example above, the output will evaluate to:
+ * ```html
+ * <header>
+ * Header A
+ * </header>
+ * <div class="body">
+ * Body A
+ * </div>
+ * <footer>
+ * Footer A
+ * </footer>
+ * <header>
+ * Header B
+ * </header>
+ * <div class="body">
+ * Body B
+ * </div>
+ * <footer>
+ * Footer B
+ * </footer>
+ * ```
+ *
+ * The custom start and end points for ngRepeat also support all other HTML directive syntax flavors provided in AngularJS (such
+ * as **data-ng-repeat-start**, **x-ng-repeat-start** and **ng:repeat-start**).
+ *
+ * @animations
+ * | Animation | Occurs |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#enter enter} | when a new item is added to the list or when an item is revealed after a filter |
+ * | {@link ng.$animate#leave leave} | when an item is removed from the list or when an item is filtered out |
+ * | {@link ng.$animate#move move } | when an adjacent item is filtered out causing a reorder or when the item contents are reordered |
+ *
+ * See the example below for defining CSS animations with ngRepeat.
+ *
+ * @element ANY
+ * @scope
+ * @priority 1000
+ * @param {repeat_expression} ngRepeat The expression indicating how to enumerate a collection. These
+ * formats are currently supported:
+ *
+ * * `variable in expression` – where variable is the user defined loop variable and `expression`
+ * is a scope expression giving the collection to enumerate.
+ *
+ * For example: `album in artist.albums`.
+ *
+ * * `(key, value) in expression` – where `key` and `value` can be any user defined identifiers,
+ * and `expression` is the scope expression giving the collection to enumerate.
+ *
+ * For example: `(name, age) in {'adam':10, 'amalie':12}`.
+ *
+ * * `variable in expression track by tracking_expression` – You can also provide an optional tracking expression
+ * which can be used to associate the objects in the collection with the DOM elements. If no tracking expression
+ * is specified, ng-repeat associates elements by identity. It is an error to have
+ * more than one tracking expression value resolve to the same key. (This would mean that two distinct objects are
+ * mapped to the same DOM element, which is not possible.)
+ *
+ * *Default tracking: $id()*: `item in items` is equivalent to `item in items track by $id(item)`.
+ * This implies that the DOM elements will be associated by item identity in the collection.
+ *
+ * The built-in `$id()` function can be used to assign a unique
+ * `$$hashKey` property to each item in the collection. This property is then used as a key to associated DOM elements
+ * with the corresponding item in the collection by identity. Moving the same object would move
+ * the DOM element in the same way in the DOM.
+ * Note that the default id function does not support duplicate primitive values (`number`, `string`),
+ * but supports duplictae non-primitive values (`object`) that are *equal* in shape.
+ *
+ * *Custom Expression*: It is possible to use any AngularJS expression to compute the tracking
+ * id, for example with a function, or using a property on the collection items.
+ * `item in items track by item.id` is a typical pattern when the items have a unique identifier,
+ * e.g. database id. In this case the object identity does not matter. Two objects are considered
+ * equivalent as long as their `id` property is same.
+ * Tracking by unique identifier is the most performant way and should be used whenever possible.
+ *
+ * *$index*: This special property tracks the collection items by their index, and
+ * re-uses the DOM elements that match that index, e.g. `item in items track by $index`. This can
+ * be used for a performance improvement if no unique identfier is available and the identity of
+ * the collection items cannot be easily computed. It also allows duplicates.
+ *
+ * <div class="alert alert-warning">
+ * <strong>Note:</strong> Re-using DOM elements can have unforeseen effects. Read the
+ * {@link ngRepeat#tracking-and-duplicates section on tracking and duplicates} for
+ * more info.
+ * </div>
+ *
+ * <div class="alert alert-warning">
+ * <strong>Note:</strong> the `track by` expression must come last - after any filters, and the alias expression:
+ * `item in items | filter:searchText as results track by item.id`
+ * </div>
+ *
+ * * `variable in expression as alias_expression` – You can also provide an optional alias expression which will then store the
+ * intermediate results of the repeater after the filters have been applied. Typically this is used to render a special message
+ * when a filter is active on the repeater, but the filtered result set is empty.
+ *
+ * For example: `item in items | filter:x as results` will store the fragment of the repeated items as `results`, but only after
+ * the items have been processed through the filter.
+ *
+ * Please note that `as [variable name]` is not an operator but rather a part of ngRepeat
+ * micro-syntax so it can be used only after all filters (and not as operator, inside an expression).
+ *
+ * For example: `item in items | filter : x | orderBy : order | limitTo : limit as results track by item.id` .
+ *
+ * @example
+ * This example uses `ngRepeat` to display a list of people. A filter is used to restrict the displayed
+ * results by name or by age. New (entering) and removed (leaving) items are animated.
+ <example module="ngRepeat" name="ngRepeat" deps="angular-animate.js" animations="true">
+ <file name="index.html">
+ <div ng-controller="repeatController">
+ I have {{friends.length}} friends. They are:
+ <input type="search" ng-model="q" placeholder="filter friends..." aria-label="filter friends" />
+ <ul class="example-animate-container">
+ <li class="animate-repeat" ng-repeat="friend in friends | filter:q as results track by friend.name">
+ [{{$index + 1}}] {{friend.name}} who is {{friend.age}} years old.
+ </li>
+ <li class="animate-repeat" ng-if="results.length === 0">
+ <strong>No results found...</strong>
+ </li>
+ </ul>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('ngRepeat', ['ngAnimate']).controller('repeatController', function($scope) {
+ $scope.friends = [
+ {name:'John', age:25, gender:'boy'},
+ {name:'Jessie', age:30, gender:'girl'},
+ {name:'Johanna', age:28, gender:'girl'},
+ {name:'Joy', age:15, gender:'girl'},
+ {name:'Mary', age:28, gender:'girl'},
+ {name:'Peter', age:95, gender:'boy'},
+ {name:'Sebastian', age:50, gender:'boy'},
+ {name:'Erika', age:27, gender:'girl'},
+ {name:'Patrick', age:40, gender:'boy'},
+ {name:'Samantha', age:60, gender:'girl'}
+ ];
+ });
+ </file>
+ <file name="animations.css">
+ .example-animate-container {
+ background:white;
+ border:1px solid black;
+ list-style:none;
+ margin:0;
+ padding:0 10px;
+ }
+
+ .animate-repeat {
+ line-height:30px;
+ list-style:none;
+ box-sizing:border-box;
+ }
+
+ .animate-repeat.ng-move,
+ .animate-repeat.ng-enter,
+ .animate-repeat.ng-leave {
+ transition:all linear 0.5s;
+ }
+
+ .animate-repeat.ng-leave.ng-leave-active,
+ .animate-repeat.ng-move,
+ .animate-repeat.ng-enter {
+ opacity:0;
+ max-height:0;
+ }
+
+ .animate-repeat.ng-leave,
+ .animate-repeat.ng-move.ng-move-active,
+ .animate-repeat.ng-enter.ng-enter-active {
+ opacity:1;
+ max-height:30px;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ var friends = element.all(by.repeater('friend in friends'));
+
+ it('should render initial data set', function() {
+ expect(friends.count()).toBe(10);
+ expect(friends.get(0).getText()).toEqual('[1] John who is 25 years old.');
+ expect(friends.get(1).getText()).toEqual('[2] Jessie who is 30 years old.');
+ expect(friends.last().getText()).toEqual('[10] Samantha who is 60 years old.');
+ expect(element(by.binding('friends.length')).getText())
+ .toMatch("I have 10 friends. They are:");
+ });
+
+ it('should update repeater when filter predicate changes', function() {
+ expect(friends.count()).toBe(10);
+
+ element(by.model('q')).sendKeys('ma');
+
+ expect(friends.count()).toBe(2);
+ expect(friends.get(0).getText()).toEqual('[1] Mary who is 28 years old.');
+ expect(friends.last().getText()).toEqual('[2] Samantha who is 60 years old.');
+ });
+ </file>
+ </example>
+ */
+var ngRepeatDirective = ['$parse', '$animate', '$compile', function($parse, $animate, $compile) {
+ var NG_REMOVED = '$$NG_REMOVED';
+ var ngRepeatMinErr = minErr('ngRepeat');
+
+ var updateScope = function(scope, index, valueIdentifier, value, keyIdentifier, key, arrayLength) {
+ // TODO(perf): generate setters to shave off ~40ms or 1-1.5%
+ scope[valueIdentifier] = value;
+ if (keyIdentifier) scope[keyIdentifier] = key;
+ scope.$index = index;
+ scope.$first = (index === 0);
+ scope.$last = (index === (arrayLength - 1));
+ scope.$middle = !(scope.$first || scope.$last);
+ // eslint-disable-next-line no-bitwise
+ scope.$odd = !(scope.$even = (index & 1) === 0);
+ };
+
+ var getBlockStart = function(block) {
+ return block.clone[0];
+ };
+
+ var getBlockEnd = function(block) {
+ return block.clone[block.clone.length - 1];
+ };
+
+ var trackByIdArrayFn = function($scope, key, value) {
+ return hashKey(value);
+ };
+
+ var trackByIdObjFn = function($scope, key) {
+ return key;
+ };
+
+ return {
+ restrict: 'A',
+ multiElement: true,
+ transclude: 'element',
+ priority: 1000,
+ terminal: true,
+ $$tlb: true,
+ compile: function ngRepeatCompile($element, $attr) {
+ var expression = $attr.ngRepeat;
+ var ngRepeatEndComment = $compile.$$createComment('end ngRepeat', expression);
+
+ var match = expression.match(/^\s*([\s\S]+?)\s+in\s+([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+track\s+by\s+([\s\S]+?))?\s*$/);
+
+ if (!match) {
+ throw ngRepeatMinErr('iexp', 'Expected expression in form of \'_item_ in _collection_[ track by _id_]\' but got \'{0}\'.',
+ expression);
+ }
+
+ var lhs = match[1];
+ var rhs = match[2];
+ var aliasAs = match[3];
+ var trackByExp = match[4];
+
+ match = lhs.match(/^(?:(\s*[$\w]+)|\(\s*([$\w]+)\s*,\s*([$\w]+)\s*\))$/);
+
+ if (!match) {
+ throw ngRepeatMinErr('iidexp', '\'_item_\' in \'_item_ in _collection_\' should be an identifier or \'(_key_, _value_)\' expression, but got \'{0}\'.',
+ lhs);
+ }
+ var valueIdentifier = match[3] || match[1];
+ var keyIdentifier = match[2];
+
+ if (aliasAs && (!/^[$a-zA-Z_][$a-zA-Z0-9_]*$/.test(aliasAs) ||
+ /^(null|undefined|this|\$index|\$first|\$middle|\$last|\$even|\$odd|\$parent|\$root|\$id)$/.test(aliasAs))) {
+ throw ngRepeatMinErr('badident', 'alias \'{0}\' is invalid --- must be a valid JS identifier which is not a reserved name.',
+ aliasAs);
+ }
+
+ var trackByIdExpFn;
+
+ if (trackByExp) {
+ var hashFnLocals = {$id: hashKey};
+ var trackByExpGetter = $parse(trackByExp);
+
+ trackByIdExpFn = function($scope, key, value, index) {
+ // assign key, value, and $index to the locals so that they can be used in hash functions
+ if (keyIdentifier) hashFnLocals[keyIdentifier] = key;
+ hashFnLocals[valueIdentifier] = value;
+ hashFnLocals.$index = index;
+ return trackByExpGetter($scope, hashFnLocals);
+ };
+ }
+
+ return function ngRepeatLink($scope, $element, $attr, ctrl, $transclude) {
+
+ // Store a list of elements from previous run. This is a hash where key is the item from the
+ // iterator, and the value is objects with following properties.
+ // - scope: bound scope
+ // - clone: previous element.
+ // - index: position
+ //
+ // We are using no-proto object so that we don't need to guard against inherited props via
+ // hasOwnProperty.
+ var lastBlockMap = createMap();
+
+ //watch props
+ $scope.$watchCollection(rhs, function ngRepeatAction(collection) {
+ var index, length,
+ previousNode = $element[0], // node that cloned nodes should be inserted after
+ // initialized to the comment node anchor
+ nextNode,
+ // Same as lastBlockMap but it has the current state. It will become the
+ // lastBlockMap on the next iteration.
+ nextBlockMap = createMap(),
+ collectionLength,
+ key, value, // key/value of iteration
+ trackById,
+ trackByIdFn,
+ collectionKeys,
+ block, // last object information {scope, element, id}
+ nextBlockOrder,
+ elementsToRemove;
+
+ if (aliasAs) {
+ $scope[aliasAs] = collection;
+ }
+
+ if (isArrayLike(collection)) {
+ collectionKeys = collection;
+ trackByIdFn = trackByIdExpFn || trackByIdArrayFn;
+ } else {
+ trackByIdFn = trackByIdExpFn || trackByIdObjFn;
+ // if object, extract keys, in enumeration order, unsorted
+ collectionKeys = [];
+ for (var itemKey in collection) {
+ if (hasOwnProperty.call(collection, itemKey) && itemKey.charAt(0) !== '$') {
+ collectionKeys.push(itemKey);
+ }
+ }
+ }
+
+ collectionLength = collectionKeys.length;
+ nextBlockOrder = new Array(collectionLength);
+
+ // locate existing items
+ for (index = 0; index < collectionLength; index++) {
+ key = (collection === collectionKeys) ? index : collectionKeys[index];
+ value = collection[key];
+ trackById = trackByIdFn($scope, key, value, index);
+ if (lastBlockMap[trackById]) {
+ // found previously seen block
+ block = lastBlockMap[trackById];
+ delete lastBlockMap[trackById];
+ nextBlockMap[trackById] = block;
+ nextBlockOrder[index] = block;
+ } else if (nextBlockMap[trackById]) {
+ // if collision detected. restore lastBlockMap and throw an error
+ forEach(nextBlockOrder, function(block) {
+ if (block && block.scope) lastBlockMap[block.id] = block;
+ });
+ throw ngRepeatMinErr('dupes',
+ 'Duplicates in a repeater are not allowed. Use \'track by\' expression to specify unique keys. Repeater: {0}, Duplicate key: {1}, Duplicate value: {2}',
+ expression, trackById, value);
+ } else {
+ // new never before seen block
+ nextBlockOrder[index] = {id: trackById, scope: undefined, clone: undefined};
+ nextBlockMap[trackById] = true;
+ }
+ }
+
+ // Clear the value property from the hashFnLocals object to prevent a reference to the last value
+ // being leaked into the ngRepeatCompile function scope
+ if (hashFnLocals) {
+ hashFnLocals[valueIdentifier] = undefined;
+ }
+
+ // remove leftover items
+ for (var blockKey in lastBlockMap) {
+ block = lastBlockMap[blockKey];
+ elementsToRemove = getBlockNodes(block.clone);
+ $animate.leave(elementsToRemove);
+ if (elementsToRemove[0].parentNode) {
+ // if the element was not removed yet because of pending animation, mark it as deleted
+ // so that we can ignore it later
+ for (index = 0, length = elementsToRemove.length; index < length; index++) {
+ elementsToRemove[index][NG_REMOVED] = true;
+ }
+ }
+ block.scope.$destroy();
+ }
+
+ // we are not using forEach for perf reasons (trying to avoid #call)
+ for (index = 0; index < collectionLength; index++) {
+ key = (collection === collectionKeys) ? index : collectionKeys[index];
+ value = collection[key];
+ block = nextBlockOrder[index];
+
+ if (block.scope) {
+ // if we have already seen this object, then we need to reuse the
+ // associated scope/element
+
+ nextNode = previousNode;
+
+ // skip nodes that are already pending removal via leave animation
+ do {
+ nextNode = nextNode.nextSibling;
+ } while (nextNode && nextNode[NG_REMOVED]);
+
+ if (getBlockStart(block) !== nextNode) {
+ // existing item which got moved
+ $animate.move(getBlockNodes(block.clone), null, previousNode);
+ }
+ previousNode = getBlockEnd(block);
+ updateScope(block.scope, index, valueIdentifier, value, keyIdentifier, key, collectionLength);
+ } else {
+ // new item which we don't know about
+ $transclude(function ngRepeatTransclude(clone, scope) {
+ block.scope = scope;
+ // http://jsperf.com/clone-vs-createcomment
+ var endNode = ngRepeatEndComment.cloneNode(false);
+ clone[clone.length++] = endNode;
+
+ $animate.enter(clone, null, previousNode);
+ previousNode = endNode;
+ // Note: We only need the first/last node of the cloned nodes.
+ // However, we need to keep the reference to the jqlite wrapper as it might be changed later
+ // by a directive with templateUrl when its template arrives.
+ block.clone = clone;
+ nextBlockMap[block.id] = block;
+ updateScope(block.scope, index, valueIdentifier, value, keyIdentifier, key, collectionLength);
+ });
+ }
+ }
+ lastBlockMap = nextBlockMap;
+ });
+ };
+ }
+ };
+}];
+
+var NG_HIDE_CLASS = 'ng-hide';
+var NG_HIDE_IN_PROGRESS_CLASS = 'ng-hide-animate';
+/**
+ * @ngdoc directive
+ * @name ngShow
+ * @multiElement
+ *
+ * @description
+ * The `ngShow` directive shows or hides the given HTML element based on the expression provided to
+ * the `ngShow` attribute.
+ *
+ * The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
+ * The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
+ * `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
+ * {@link ng.directive:ngCsp ngCsp}).
+ *
+ * ```html
+ * <!-- when $scope.myValue is truthy (element is visible) -->
+ * <div ng-show="myValue"></div>
+ *
+ * <!-- when $scope.myValue is falsy (element is hidden) -->
+ * <div ng-show="myValue" class="ng-hide"></div>
+ * ```
+ *
+ * When the `ngShow` expression evaluates to a falsy value then the `.ng-hide` CSS class is added
+ * to the class attribute on the element causing it to become hidden. When truthy, the `.ng-hide`
+ * CSS class is removed from the element causing the element not to appear hidden.
+ *
+ * ## Why is `!important` used?
+ *
+ * You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
+ * `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
+ * simple as changing the display style on a HTML list item would make hidden elements appear
+ * visible. This also becomes a bigger issue when dealing with CSS frameworks.
+ *
+ * By using `!important`, the show and hide behavior will work as expected despite any clash between
+ * CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
+ * developer chooses to override the styling to change how to hide an element then it is just a
+ * matter of using `!important` in their own CSS code.
+ *
+ * ### Overriding `.ng-hide`
+ *
+ * By default, the `.ng-hide` class will style the element with `display: none !important`. If you
+ * wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
+ * the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
+ * `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
+ *
+ * ```css
+ * .ng-hide:not(.ng-hide-animate) {
+ * /* These are just alternative ways of hiding an element */
+ * display: block!important;
+ * position: absolute;
+ * top: -9999px;
+ * left: -9999px;
+ * }
+ * ```
+ *
+ * By default you don't need to override anything in CSS and the animations will work around the
+ * display style.
+ *
+ * @animations
+ * | Animation | Occurs |
+ * |-----------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
+ * | {@link $animate#addClass addClass} `.ng-hide` | After the `ngShow` expression evaluates to a non truthy value and just before the contents are set to hidden. |
+ * | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngShow` expression evaluates to a truthy value and just before contents are set to visible. |
+ *
+ * Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
+ * directive expression is true and false. This system works like the animation system present with
+ * `ngClass` except that you must also include the `!important` flag to override the display
+ * property so that the elements are not actually hidden during the animation.
+ *
+ * ```css
+ * /* A working example can be found at the bottom of this page. */
+ * .my-element.ng-hide-add, .my-element.ng-hide-remove {
+ * transition: all 0.5s linear;
+ * }
+ *
+ * .my-element.ng-hide-add { ... }
+ * .my-element.ng-hide-add.ng-hide-add-active { ... }
+ * .my-element.ng-hide-remove { ... }
+ * .my-element.ng-hide-remove.ng-hide-remove-active { ... }
+ * ```
+ *
+ * Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
+ * to block during animation states - ngAnimate will automatically handle the style toggling for you.
+ *
+ * @element ANY
+ * @param {expression} ngShow If the {@link guide/expression expression} is truthy/falsy then the
+ * element is shown/hidden respectively.
+ *
+ * @example
+ * A simple example, animating the element's opacity:
+ *
+ <example module="ngAnimate" deps="angular-animate.js" animations="true" name="ng-show-simple">
+ <file name="index.html">
+ Show: <input type="checkbox" ng-model="checked" aria-label="Toggle ngShow"><br />
+ <div class="check-element animate-show-hide" ng-show="checked">
+ I show up when your checkbox is checked.
+ </div>
+ </file>
+ <file name="animations.css">
+ .animate-show-hide.ng-hide {
+ opacity: 0;
+ }
+
+ .animate-show-hide.ng-hide-add,
+ .animate-show-hide.ng-hide-remove {
+ transition: all linear 0.5s;
+ }
+
+ .check-element {
+ border: 1px solid black;
+ opacity: 1;
+ padding: 10px;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ngShow', function() {
+ var checkbox = element(by.model('checked'));
+ var checkElem = element(by.css('.check-element'));
+
+ expect(checkElem.isDisplayed()).toBe(false);
+ checkbox.click();
+ expect(checkElem.isDisplayed()).toBe(true);
+ });
+ </file>
+ </example>
+ *
+ * <hr />
+ * @example
+ * A more complex example, featuring different show/hide animations:
+ *
+ <example module="ngAnimate" deps="angular-animate.js" animations="true" name="ng-show-complex">
+ <file name="index.html">
+ Show: <input type="checkbox" ng-model="checked" aria-label="Toggle ngShow"><br />
+ <div class="check-element funky-show-hide" ng-show="checked">
+ I show up when your checkbox is checked.
+ </div>
+ </file>
+ <file name="animations.css">
+ body {
+ overflow: hidden;
+ perspective: 1000px;
+ }
+
+ .funky-show-hide.ng-hide-add {
+ transform: rotateZ(0);
+ transform-origin: right;
+ transition: all 0.5s ease-in-out;
+ }
+
+ .funky-show-hide.ng-hide-add.ng-hide-add-active {
+ transform: rotateZ(-135deg);
+ }
+
+ .funky-show-hide.ng-hide-remove {
+ transform: rotateY(90deg);
+ transform-origin: left;
+ transition: all 0.5s ease;
+ }
+
+ .funky-show-hide.ng-hide-remove.ng-hide-remove-active {
+ transform: rotateY(0);
+ }
+
+ .check-element {
+ border: 1px solid black;
+ opacity: 1;
+ padding: 10px;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ngShow', function() {
+ var checkbox = element(by.model('checked'));
+ var checkElem = element(by.css('.check-element'));
+
+ expect(checkElem.isDisplayed()).toBe(false);
+ checkbox.click();
+ expect(checkElem.isDisplayed()).toBe(true);
+ });
+ </file>
+ </example>
+ *
+ * @knownIssue
+ *
+ * ### Flickering when using ngShow to toggle between elements
+ *
+ * When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
+ * happen that both the element to show and the element to hide are visible for a very short time.
+ *
+ * This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
+ * are defined for {@link ngShow} / {@link ngHide}. Internet Explorer is affected more often than
+ * other browsers.
+ *
+ * There are several way to mitigate this problem:
+ *
+ * - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
+ * - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
+ * - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
+ * - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
+ * - Define an animation on the affected elements.
+ */
+var ngShowDirective = ['$animate', function($animate) {
+ return {
+ restrict: 'A',
+ multiElement: true,
+ link: function(scope, element, attr) {
+ scope.$watch(attr.ngShow, function ngShowWatchAction(value) {
+ // we're adding a temporary, animation-specific class for ng-hide since this way
+ // we can control when the element is actually displayed on screen without having
+ // to have a global/greedy CSS selector that breaks when other animations are run.
+ // Read: https://github.com/angular/angular.js/issues/9103#issuecomment-58335845
+ $animate[value ? 'removeClass' : 'addClass'](element, NG_HIDE_CLASS, {
+ tempClasses: NG_HIDE_IN_PROGRESS_CLASS
+ });
+ });
+ }
+ };
+}];
+
+
+/**
+ * @ngdoc directive
+ * @name ngHide
+ * @multiElement
+ *
+ * @description
+ * The `ngHide` directive shows or hides the given HTML element based on the expression provided to
+ * the `ngHide` attribute.
+ *
+ * The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
+ * The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
+ * `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
+ * {@link ng.directive:ngCsp ngCsp}).
+ *
+ * ```html
+ * <!-- when $scope.myValue is truthy (element is hidden) -->
+ * <div ng-hide="myValue" class="ng-hide"></div>
+ *
+ * <!-- when $scope.myValue is falsy (element is visible) -->
+ * <div ng-hide="myValue"></div>
+ * ```
+ *
+ * When the `ngHide` expression evaluates to a truthy value then the `.ng-hide` CSS class is added
+ * to the class attribute on the element causing it to become hidden. When falsy, the `.ng-hide`
+ * CSS class is removed from the element causing the element not to appear hidden.
+ *
+ * ## Why is `!important` used?
+ *
+ * You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
+ * `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
+ * simple as changing the display style on a HTML list item would make hidden elements appear
+ * visible. This also becomes a bigger issue when dealing with CSS frameworks.
+ *
+ * By using `!important`, the show and hide behavior will work as expected despite any clash between
+ * CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
+ * developer chooses to override the styling to change how to hide an element then it is just a
+ * matter of using `!important` in their own CSS code.
+ *
+ * ### Overriding `.ng-hide`
+ *
+ * By default, the `.ng-hide` class will style the element with `display: none !important`. If you
+ * wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
+ * the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
+ * `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
+ *
+ * ```css
+ * .ng-hide:not(.ng-hide-animate) {
+ * /* These are just alternative ways of hiding an element */
+ * display: block!important;
+ * position: absolute;
+ * top: -9999px;
+ * left: -9999px;
+ * }
+ * ```
+ *
+ * By default you don't need to override in CSS anything and the animations will work around the
+ * display style.
+ *
+ * @animations
+ * | Animation | Occurs |
+ * |-----------------------------------------------------|------------------------------------------------------------------------------------------------------------|
+ * | {@link $animate#addClass addClass} `.ng-hide` | After the `ngHide` expression evaluates to a truthy value and just before the contents are set to hidden. |
+ * | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngHide` expression evaluates to a non truthy value and just before contents are set to visible. |
+ *
+ * Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
+ * directive expression is true and false. This system works like the animation system present with
+ * `ngClass` except that you must also include the `!important` flag to override the display
+ * property so that the elements are not actually hidden during the animation.
+ *
+ * ```css
+ * /* A working example can be found at the bottom of this page. */
+ * .my-element.ng-hide-add, .my-element.ng-hide-remove {
+ * transition: all 0.5s linear;
+ * }
+ *
+ * .my-element.ng-hide-add { ... }
+ * .my-element.ng-hide-add.ng-hide-add-active { ... }
+ * .my-element.ng-hide-remove { ... }
+ * .my-element.ng-hide-remove.ng-hide-remove-active { ... }
+ * ```
+ *
+ * Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
+ * to block during animation states - ngAnimate will automatically handle the style toggling for you.
+ *
+ * @element ANY
+ * @param {expression} ngHide If the {@link guide/expression expression} is truthy/falsy then the
+ * element is hidden/shown respectively.
+ *
+ * @example
+ * A simple example, animating the element's opacity:
+ *
+ <example module="ngAnimate" deps="angular-animate.js" animations="true" name="ng-hide-simple">
+ <file name="index.html">
+ Hide: <input type="checkbox" ng-model="checked" aria-label="Toggle ngHide"><br />
+ <div class="check-element animate-show-hide" ng-hide="checked">
+ I hide when your checkbox is checked.
+ </div>
+ </file>
+ <file name="animations.css">
+ .animate-show-hide.ng-hide {
+ opacity: 0;
+ }
+
+ .animate-show-hide.ng-hide-add,
+ .animate-show-hide.ng-hide-remove {
+ transition: all linear 0.5s;
+ }
+
+ .check-element {
+ border: 1px solid black;
+ opacity: 1;
+ padding: 10px;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ngHide', function() {
+ var checkbox = element(by.model('checked'));
+ var checkElem = element(by.css('.check-element'));
+
+ expect(checkElem.isDisplayed()).toBe(true);
+ checkbox.click();
+ expect(checkElem.isDisplayed()).toBe(false);
+ });
+ </file>
+ </example>
+ *
+ * <hr />
+ * @example
+ * A more complex example, featuring different show/hide animations:
+ *
+ <example module="ngAnimate" deps="angular-animate.js" animations="true" name="ng-hide-complex">
+ <file name="index.html">
+ Hide: <input type="checkbox" ng-model="checked" aria-label="Toggle ngHide"><br />
+ <div class="check-element funky-show-hide" ng-hide="checked">
+ I hide when your checkbox is checked.
+ </div>
+ </file>
+ <file name="animations.css">
+ body {
+ overflow: hidden;
+ perspective: 1000px;
+ }
+
+ .funky-show-hide.ng-hide-add {
+ transform: rotateZ(0);
+ transform-origin: right;
+ transition: all 0.5s ease-in-out;
+ }
+
+ .funky-show-hide.ng-hide-add.ng-hide-add-active {
+ transform: rotateZ(-135deg);
+ }
+
+ .funky-show-hide.ng-hide-remove {
+ transform: rotateY(90deg);
+ transform-origin: left;
+ transition: all 0.5s ease;
+ }
+
+ .funky-show-hide.ng-hide-remove.ng-hide-remove-active {
+ transform: rotateY(0);
+ }
+
+ .check-element {
+ border: 1px solid black;
+ opacity: 1;
+ padding: 10px;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should check ngHide', function() {
+ var checkbox = element(by.model('checked'));
+ var checkElem = element(by.css('.check-element'));
+
+ expect(checkElem.isDisplayed()).toBe(true);
+ checkbox.click();
+ expect(checkElem.isDisplayed()).toBe(false);
+ });
+ </file>
+ </example>
+ *
+ * @knownIssue
+ *
+ * ### Flickering when using ngHide to toggle between elements
+ *
+ * When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
+ * happen that both the element to show and the element to hide are visible for a very short time.
+ *
+ * This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
+ * are defined for {@link ngShow} / {@link ngHide}. Internet Explorer is affected more often than
+ * other browsers.
+ *
+ * There are several way to mitigate this problem:
+ *
+ * - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
+ * - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
+ * - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
+ * - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
+ * - Define an animation on the affected elements.
+ */
+var ngHideDirective = ['$animate', function($animate) {
+ return {
+ restrict: 'A',
+ multiElement: true,
+ link: function(scope, element, attr) {
+ scope.$watch(attr.ngHide, function ngHideWatchAction(value) {
+ // The comment inside of the ngShowDirective explains why we add and
+ // remove a temporary class for the show/hide animation
+ $animate[value ? 'addClass' : 'removeClass'](element,NG_HIDE_CLASS, {
+ tempClasses: NG_HIDE_IN_PROGRESS_CLASS
+ });
+ });
+ }
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngStyle
+ * @restrict AC
+ *
+ * @description
+ * The `ngStyle` directive allows you to set CSS style on an HTML element conditionally.
+ *
+ * @knownIssue
+ * You should not use {@link guide/interpolation interpolation} in the value of the `style`
+ * attribute, when using the `ngStyle` directive on the same element.
+ * See {@link guide/interpolation#known-issues here} for more info.
+ *
+ * @element ANY
+ * @param {expression} ngStyle
+ *
+ * {@link guide/expression Expression} which evals to an
+ * object whose keys are CSS style names and values are corresponding values for those CSS
+ * keys.
+ *
+ * Since some CSS style names are not valid keys for an object, they must be quoted.
+ * See the 'background-color' style in the example below.
+ *
+ * @example
+ <example name="ng-style">
+ <file name="index.html">
+ <input type="button" value="set color" ng-click="myStyle={color:'red'}">
+ <input type="button" value="set background" ng-click="myStyle={'background-color':'blue'}">
+ <input type="button" value="clear" ng-click="myStyle={}">
+ <br/>
+ <span ng-style="myStyle">Sample Text</span>
+ <pre>myStyle={{myStyle}}</pre>
+ </file>
+ <file name="style.css">
+ span {
+ color: black;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ var colorSpan = element(by.css('span'));
+
+ it('should check ng-style', function() {
+ expect(colorSpan.getCssValue('color')).toMatch(/rgba\(0, 0, 0, 1\)|rgb\(0, 0, 0\)/);
+ element(by.css('input[value=\'set color\']')).click();
+ expect(colorSpan.getCssValue('color')).toMatch(/rgba\(255, 0, 0, 1\)|rgb\(255, 0, 0\)/);
+ element(by.css('input[value=clear]')).click();
+ expect(colorSpan.getCssValue('color')).toMatch(/rgba\(0, 0, 0, 1\)|rgb\(0, 0, 0\)/);
+ });
+ </file>
+ </example>
+ */
+var ngStyleDirective = ngDirective(function(scope, element, attr) {
+ scope.$watchCollection(attr.ngStyle, function ngStyleWatchAction(newStyles, oldStyles) {
+ if (oldStyles && (newStyles !== oldStyles)) {
+ forEach(oldStyles, function(val, style) { element.css(style, ''); });
+ }
+ if (newStyles) element.css(newStyles);
+ });
+});
+
+/**
+ * @ngdoc directive
+ * @name ngSwitch
+ * @restrict EA
+ *
+ * @description
+ * The `ngSwitch` directive is used to conditionally swap DOM structure on your template based on a scope expression.
+ * Elements within `ngSwitch` but without `ngSwitchWhen` or `ngSwitchDefault` directives will be preserved at the location
+ * as specified in the template.
+ *
+ * The directive itself works similar to ngInclude, however, instead of downloading template code (or loading it
+ * from the template cache), `ngSwitch` simply chooses one of the nested elements and makes it visible based on which element
+ * matches the value obtained from the evaluated expression. In other words, you define a container element
+ * (where you place the directive), place an expression on the **`on="..."` attribute**
+ * (or the **`ng-switch="..."` attribute**), define any inner elements inside of the directive and place
+ * a when attribute per element. The when attribute is used to inform ngSwitch which element to display when the on
+ * expression is evaluated. If a matching expression is not found via a when attribute then an element with the default
+ * attribute is displayed.
+ *
+ * <div class="alert alert-info">
+ * Be aware that the attribute values to match against cannot be expressions. They are interpreted
+ * as literal string values to match against.
+ * For example, **`ng-switch-when="someVal"`** will match against the string `"someVal"` not against the
+ * value of the expression `$scope.someVal`.
+ * </div>
+
+ * @animations
+ * | Animation | Occurs |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#enter enter} | after the ngSwitch contents change and the matched child element is placed inside the container |
+ * | {@link ng.$animate#leave leave} | after the ngSwitch contents change and just before the former contents are removed from the DOM |
+ *
+ * @usage
+ *
+ * ```
+ * <ANY ng-switch="expression">
+ * <ANY ng-switch-when="matchValue1">...</ANY>
+ * <ANY ng-switch-when="matchValue2">...</ANY>
+ * <ANY ng-switch-default>...</ANY>
+ * </ANY>
+ * ```
+ *
+ *
+ * @scope
+ * @priority 1200
+ * @param {*} ngSwitch|on expression to match against <code>ng-switch-when</code>.
+ * On child elements add:
+ *
+ * * `ngSwitchWhen`: the case statement to match against. If match then this
+ * case will be displayed. If the same match appears multiple times, all the
+ * elements will be displayed. It is possible to associate multiple values to
+ * the same `ngSwitchWhen` by defining the optional attribute
+ * `ngSwitchWhenSeparator`. The separator will be used to split the value of
+ * the `ngSwitchWhen` attribute into multiple tokens, and the element will show
+ * if any of the `ngSwitch` evaluates to any of these tokens.
+ * * `ngSwitchDefault`: the default case when no other case match. If there
+ * are multiple default cases, all of them will be displayed when no other
+ * case match.
+ *
+ *
+ * @example
+ <example module="switchExample" deps="angular-animate.js" animations="true" name="ng-switch">
+ <file name="index.html">
+ <div ng-controller="ExampleController">
+ <select ng-model="selection" ng-options="item for item in items">
+ </select>
+ <code>selection={{selection}}</code>
+ <hr/>
+ <div class="animate-switch-container"
+ ng-switch on="selection">
+ <div class="animate-switch" ng-switch-when="settings|options" ng-switch-when-separator="|">Settings Div</div>
+ <div class="animate-switch" ng-switch-when="home">Home Span</div>
+ <div class="animate-switch" ng-switch-default>default</div>
+ </div>
+ </div>
+ </file>
+ <file name="script.js">
+ angular.module('switchExample', ['ngAnimate'])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.items = ['settings', 'home', 'options', 'other'];
+ $scope.selection = $scope.items[0];
+ }]);
+ </file>
+ <file name="animations.css">
+ .animate-switch-container {
+ position:relative;
+ background:white;
+ border:1px solid black;
+ height:40px;
+ overflow:hidden;
+ }
+
+ .animate-switch {
+ padding:10px;
+ }
+
+ .animate-switch.ng-animate {
+ transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
+
+ position:absolute;
+ top:0;
+ left:0;
+ right:0;
+ bottom:0;
+ }
+
+ .animate-switch.ng-leave.ng-leave-active,
+ .animate-switch.ng-enter {
+ top:-50px;
+ }
+ .animate-switch.ng-leave,
+ .animate-switch.ng-enter.ng-enter-active {
+ top:0;
+ }
+ </file>
+ <file name="protractor.js" type="protractor">
+ var switchElem = element(by.css('[ng-switch]'));
+ var select = element(by.model('selection'));
+
+ it('should start in settings', function() {
+ expect(switchElem.getText()).toMatch(/Settings Div/);
+ });
+ it('should change to home', function() {
+ select.all(by.css('option')).get(1).click();
+ expect(switchElem.getText()).toMatch(/Home Span/);
+ });
+ it('should change to settings via "options"', function() {
+ select.all(by.css('option')).get(2).click();
+ expect(switchElem.getText()).toMatch(/Settings Div/);
+ });
+ it('should select default', function() {
+ select.all(by.css('option')).get(3).click();
+ expect(switchElem.getText()).toMatch(/default/);
+ });
+ </file>
+ </example>
+ */
+var ngSwitchDirective = ['$animate', '$compile', function($animate, $compile) {
+ return {
+ require: 'ngSwitch',
+
+ // asks for $scope to fool the BC controller module
+ controller: ['$scope', function NgSwitchController() {
+ this.cases = {};
+ }],
+ link: function(scope, element, attr, ngSwitchController) {
+ var watchExpr = attr.ngSwitch || attr.on,
+ selectedTranscludes = [],
+ selectedElements = [],
+ previousLeaveAnimations = [],
+ selectedScopes = [];
+
+ var spliceFactory = function(array, index) {
+ return function(response) {
+ if (response !== false) array.splice(index, 1);
+ };
+ };
+
+ scope.$watch(watchExpr, function ngSwitchWatchAction(value) {
+ var i, ii;
+
+ // Start with the last, in case the array is modified during the loop
+ while (previousLeaveAnimations.length) {
+ $animate.cancel(previousLeaveAnimations.pop());
+ }
+
+ for (i = 0, ii = selectedScopes.length; i < ii; ++i) {
+ var selected = getBlockNodes(selectedElements[i].clone);
+ selectedScopes[i].$destroy();
+ var runner = previousLeaveAnimations[i] = $animate.leave(selected);
+ runner.done(spliceFactory(previousLeaveAnimations, i));
+ }
+
+ selectedElements.length = 0;
+ selectedScopes.length = 0;
+
+ if ((selectedTranscludes = ngSwitchController.cases['!' + value] || ngSwitchController.cases['?'])) {
+ forEach(selectedTranscludes, function(selectedTransclude) {
+ selectedTransclude.transclude(function(caseElement, selectedScope) {
+ selectedScopes.push(selectedScope);
+ var anchor = selectedTransclude.element;
+ caseElement[caseElement.length++] = $compile.$$createComment('end ngSwitchWhen');
+ var block = { clone: caseElement };
+
+ selectedElements.push(block);
+ $animate.enter(caseElement, anchor.parent(), anchor);
+ });
+ });
+ }
+ });
+ }
+ };
+}];
+
+var ngSwitchWhenDirective = ngDirective({
+ transclude: 'element',
+ priority: 1200,
+ require: '^ngSwitch',
+ multiElement: true,
+ link: function(scope, element, attrs, ctrl, $transclude) {
+
+ var cases = attrs.ngSwitchWhen.split(attrs.ngSwitchWhenSeparator).sort().filter(
+ // Filter duplicate cases
+ function(element, index, array) { return array[index - 1] !== element; }
+ );
+
+ forEach(cases, function(whenCase) {
+ ctrl.cases['!' + whenCase] = (ctrl.cases['!' + whenCase] || []);
+ ctrl.cases['!' + whenCase].push({ transclude: $transclude, element: element });
+ });
+ }
+});
+
+var ngSwitchDefaultDirective = ngDirective({
+ transclude: 'element',
+ priority: 1200,
+ require: '^ngSwitch',
+ multiElement: true,
+ link: function(scope, element, attr, ctrl, $transclude) {
+ ctrl.cases['?'] = (ctrl.cases['?'] || []);
+ ctrl.cases['?'].push({ transclude: $transclude, element: element });
+ }
+});
+
+/**
+ * @ngdoc directive
+ * @name ngTransclude
+ * @restrict EAC
+ *
+ * @description
+ * Directive that marks the insertion point for the transcluded DOM of the nearest parent directive that uses transclusion.
+ *
+ * You can specify that you want to insert a named transclusion slot, instead of the default slot, by providing the slot name
+ * as the value of the `ng-transclude` or `ng-transclude-slot` attribute.
+ *
+ * If the transcluded content is not empty (i.e. contains one or more DOM nodes, including whitespace text nodes), any existing
+ * content of this element will be removed before the transcluded content is inserted.
+ * If the transcluded content is empty (or only whitespace), the existing content is left intact. This lets you provide fallback
+ * content in the case that no transcluded content is provided.
+ *
+ * @element ANY
+ *
+ * @param {string} ngTransclude|ngTranscludeSlot the name of the slot to insert at this point. If this is not provided, is empty
+ * or its value is the same as the name of the attribute then the default slot is used.
+ *
+ * @example
+ * ### Basic transclusion
+ * This example demonstrates basic transclusion of content into a component directive.
+ * <example name="simpleTranscludeExample" module="transcludeExample">
+ * <file name="index.html">
+ * <script>
+ * angular.module('transcludeExample', [])
+ * .directive('pane', function(){
+ * return {
+ * restrict: 'E',
+ * transclude: true,
+ * scope: { title:'@' },
+ * template: '<div style="border: 1px solid black;">' +
+ * '<div style="background-color: gray">{{title}}</div>' +
+ * '<ng-transclude></ng-transclude>' +
+ * '</div>'
+ * };
+ * })
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.title = 'Lorem Ipsum';
+ * $scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...';
+ * }]);
+ * </script>
+ * <div ng-controller="ExampleController">
+ * <input ng-model="title" aria-label="title"> <br/>
+ * <textarea ng-model="text" aria-label="text"></textarea> <br/>
+ * <pane title="{{title}}"><span>{{text}}</span></pane>
+ * </div>
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * it('should have transcluded', function() {
+ * var titleElement = element(by.model('title'));
+ * titleElement.clear();
+ * titleElement.sendKeys('TITLE');
+ * var textElement = element(by.model('text'));
+ * textElement.clear();
+ * textElement.sendKeys('TEXT');
+ * expect(element(by.binding('title')).getText()).toEqual('TITLE');
+ * expect(element(by.binding('text')).getText()).toEqual('TEXT');
+ * });
+ * </file>
+ * </example>
+ *
+ * @example
+ * ### Transclude fallback content
+ * This example shows how to use `NgTransclude` with fallback content, that
+ * is displayed if no transcluded content is provided.
+ *
+ * <example module="transcludeFallbackContentExample" name="ng-transclude">
+ * <file name="index.html">
+ * <script>
+ * angular.module('transcludeFallbackContentExample', [])
+ * .directive('myButton', function(){
+ * return {
+ * restrict: 'E',
+ * transclude: true,
+ * scope: true,
+ * template: '<button style="cursor: pointer;">' +
+ * '<ng-transclude>' +
+ * '<b style="color: red;">Button1</b>' +
+ * '</ng-transclude>' +
+ * '</button>'
+ * };
+ * });
+ * </script>
+ * <!-- fallback button content -->
+ * <my-button id="fallback"></my-button>
+ * <!-- modified button content -->
+ * <my-button id="modified">
+ * <i style="color: green;">Button2</i>
+ * </my-button>
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * it('should have different transclude element content', function() {
+ * expect(element(by.id('fallback')).getText()).toBe('Button1');
+ * expect(element(by.id('modified')).getText()).toBe('Button2');
+ * });
+ * </file>
+ * </example>
+ *
+ * @example
+ * ### Multi-slot transclusion
+ * This example demonstrates using multi-slot transclusion in a component directive.
+ * <example name="multiSlotTranscludeExample" module="multiSlotTranscludeExample">
+ * <file name="index.html">
+ * <style>
+ * .title, .footer {
+ * background-color: gray
+ * }
+ * </style>
+ * <div ng-controller="ExampleController">
+ * <input ng-model="title" aria-label="title"> <br/>
+ * <textarea ng-model="text" aria-label="text"></textarea> <br/>
+ * <pane>
+ * <pane-title><a ng-href="{{link}}">{{title}}</a></pane-title>
+ * <pane-body><p>{{text}}</p></pane-body>
+ * </pane>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('multiSlotTranscludeExample', [])
+ * .directive('pane', function() {
+ * return {
+ * restrict: 'E',
+ * transclude: {
+ * 'title': '?paneTitle',
+ * 'body': 'paneBody',
+ * 'footer': '?paneFooter'
+ * },
+ * template: '<div style="border: 1px solid black;">' +
+ * '<div class="title" ng-transclude="title">Fallback Title</div>' +
+ * '<div ng-transclude="body"></div>' +
+ * '<div class="footer" ng-transclude="footer">Fallback Footer</div>' +
+ * '</div>'
+ * };
+ * })
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.title = 'Lorem Ipsum';
+ * $scope.link = 'https://google.com';
+ * $scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...';
+ * }]);
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * it('should have transcluded the title and the body', function() {
+ * var titleElement = element(by.model('title'));
+ * titleElement.clear();
+ * titleElement.sendKeys('TITLE');
+ * var textElement = element(by.model('text'));
+ * textElement.clear();
+ * textElement.sendKeys('TEXT');
+ * expect(element(by.css('.title')).getText()).toEqual('TITLE');
+ * expect(element(by.binding('text')).getText()).toEqual('TEXT');
+ * expect(element(by.css('.footer')).getText()).toEqual('Fallback Footer');
+ * });
+ * </file>
+ * </example>
+ */
+var ngTranscludeMinErr = minErr('ngTransclude');
+var ngTranscludeDirective = ['$compile', function($compile) {
+ return {
+ restrict: 'EAC',
+ compile: function ngTranscludeCompile(tElement) {
+
+ // Remove and cache any original content to act as a fallback
+ var fallbackLinkFn = $compile(tElement.contents());
+ tElement.empty();
+
+ return function ngTranscludePostLink($scope, $element, $attrs, controller, $transclude) {
+
+ if (!$transclude) {
+ throw ngTranscludeMinErr('orphan',
+ 'Illegal use of ngTransclude directive in the template! ' +
+ 'No parent directive that requires a transclusion found. ' +
+ 'Element: {0}',
+ startingTag($element));
+ }
+
+
+ // If the attribute is of the form: `ng-transclude="ng-transclude"` then treat it like the default
+ if ($attrs.ngTransclude === $attrs.$attr.ngTransclude) {
+ $attrs.ngTransclude = '';
+ }
+ var slotName = $attrs.ngTransclude || $attrs.ngTranscludeSlot;
+
+ // If the slot is required and no transclusion content is provided then this call will throw an error
+ $transclude(ngTranscludeCloneAttachFn, null, slotName);
+
+ // If the slot is optional and no transclusion content is provided then use the fallback content
+ if (slotName && !$transclude.isSlotFilled(slotName)) {
+ useFallbackContent();
+ }
+
+ function ngTranscludeCloneAttachFn(clone, transcludedScope) {
+ if (clone.length && notWhitespace(clone)) {
+ $element.append(clone);
+ } else {
+ useFallbackContent();
+ // There is nothing linked against the transcluded scope since no content was available,
+ // so it should be safe to clean up the generated scope.
+ transcludedScope.$destroy();
+ }
+ }
+
+ function useFallbackContent() {
+ // Since this is the fallback content rather than the transcluded content,
+ // we link against the scope of this directive rather than the transcluded scope
+ fallbackLinkFn($scope, function(clone) {
+ $element.append(clone);
+ });
+ }
+
+ function notWhitespace(nodes) {
+ for (var i = 0, ii = nodes.length; i < ii; i++) {
+ var node = nodes[i];
+ if (node.nodeType !== NODE_TYPE_TEXT || node.nodeValue.trim()) {
+ return true;
+ }
+ }
+ }
+ };
+ }
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name script
+ * @restrict E
+ *
+ * @description
+ * Load the content of a `<script>` element into {@link ng.$templateCache `$templateCache`}, so that the
+ * template can be used by {@link ng.directive:ngInclude `ngInclude`},
+ * {@link ngRoute.directive:ngView `ngView`}, or {@link guide/directive directives}. The type of the
+ * `<script>` element must be specified as `text/ng-template`, and a cache name for the template must be
+ * assigned through the element's `id`, which can then be used as a directive's `templateUrl`.
+ *
+ * @param {string} type Must be set to `'text/ng-template'`.
+ * @param {string} id Cache name of the template.
+ *
+ * @example
+ <example name="script-tag">
+ <file name="index.html">
+ <script type="text/ng-template" id="/tpl.html">
+ Content of the template.
+ </script>
+
+ <a ng-click="currentTpl='/tpl.html'" id="tpl-link">Load inlined template</a>
+ <div id="tpl-content" ng-include src="currentTpl"></div>
+ </file>
+ <file name="protractor.js" type="protractor">
+ it('should load template defined inside script tag', function() {
+ element(by.css('#tpl-link')).click();
+ expect(element(by.css('#tpl-content')).getText()).toMatch(/Content of the template/);
+ });
+ </file>
+ </example>
+ */
+var scriptDirective = ['$templateCache', function($templateCache) {
+ return {
+ restrict: 'E',
+ terminal: true,
+ compile: function(element, attr) {
+ if (attr.type === 'text/ng-template') {
+ var templateUrl = attr.id,
+ text = element[0].text;
+
+ $templateCache.put(templateUrl, text);
+ }
+ }
+ };
+}];
+
+/* exported selectDirective, optionDirective */
+
+var noopNgModelController = { $setViewValue: noop, $render: noop };
+
+function setOptionSelectedStatus(optionEl, value) {
+ optionEl.prop('selected', value);
+ /**
+ * When unselecting an option, setting the property to null / false should be enough
+ * However, screenreaders might react to the selected attribute instead, see
+ * https://github.com/angular/angular.js/issues/14419
+ * Note: "selected" is a boolean attr and will be removed when the "value" arg in attr() is false
+ * or null
+ */
+ optionEl.attr('selected', value);
+}
+
+/**
+ * @ngdoc type
+ * @name select.SelectController
+ *
+ * @description
+ * The controller for the {@link ng.select select} directive. The controller exposes
+ * a few utility methods that can be used to augment the behavior of a regular or an
+ * {@link ng.ngOptions ngOptions} select element.
+ *
+ * @example
+ * ### Set a custom error when the unknown option is selected
+ *
+ * This example sets a custom error "unknownValue" on the ngModelController
+ * when the select element's unknown option is selected, i.e. when the model is set to a value
+ * that is not matched by any option.
+ *
+ * <example name="select-unknown-value-error" module="staticSelect">
+ * <file name="index.html">
+ * <div ng-controller="ExampleController">
+ * <form name="myForm">
+ * <label for="testSelect"> Single select: </label><br>
+ * <select name="testSelect" ng-model="selected" unknown-value-error>
+ * <option value="option-1">Option 1</option>
+ * <option value="option-2">Option 2</option>
+ * </select><br>
+ * <span class="error" ng-if="myForm.testSelect.$error.unknownValue">
+ * Error: The current model doesn't match any option</span><br>
+ *
+ * <button ng-click="forceUnknownOption()">Force unknown option</button><br>
+ * </form>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('staticSelect', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.selected = null;
+ *
+ * $scope.forceUnknownOption = function() {
+ * $scope.selected = 'nonsense';
+ * };
+ * }])
+ * .directive('unknownValueError', function() {
+ * return {
+ * require: ['ngModel', 'select'],
+ * link: function(scope, element, attrs, ctrls) {
+ * var ngModelCtrl = ctrls[0];
+ * var selectCtrl = ctrls[1];
+ *
+ * ngModelCtrl.$validators.unknownValue = function(modelValue, viewValue) {
+ * if (selectCtrl.$isUnknownOptionSelected()) {
+ * return false;
+ * }
+ *
+ * return true;
+ * };
+ * }
+ *
+ * };
+ * });
+ * </file>
+ *</example>
+ *
+ *
+ * @example
+ * ### Set the "required" error when the unknown option is selected.
+ *
+ * By default, the "required" error on the ngModelController is only set on a required select
+ * when the empty option is selected. This example adds a custom directive that also sets the
+ * error when the unknown option is selected.
+ *
+ * <example name="select-unknown-value-required" module="staticSelect">
+ * <file name="index.html">
+ * <div ng-controller="ExampleController">
+ * <form name="myForm">
+ * <label for="testSelect"> Select: </label><br>
+ * <select name="testSelect" ng-model="selected" required unknown-value-required>
+ * <option value="option-1">Option 1</option>
+ * <option value="option-2">Option 2</option>
+ * </select><br>
+ * <span class="error" ng-if="myForm.testSelect.$error.required">Error: Please select a value</span><br>
+ *
+ * <button ng-click="forceUnknownOption()">Force unknown option</button><br>
+ * </form>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('staticSelect', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.selected = null;
+ *
+ * $scope.forceUnknownOption = function() {
+ * $scope.selected = 'nonsense';
+ * };
+ * }])
+ * .directive('unknownValueRequired', function() {
+ * return {
+ * priority: 1, // This directive must run after the required directive has added its validator
+ * require: ['ngModel', 'select'],
+ * link: function(scope, element, attrs, ctrls) {
+ * var ngModelCtrl = ctrls[0];
+ * var selectCtrl = ctrls[1];
+ *
+ * var originalRequiredValidator = ngModelCtrl.$validators.required;
+ *
+ * ngModelCtrl.$validators.required = function() {
+ * if (attrs.required && selectCtrl.$isUnknownOptionSelected()) {
+ * return false;
+ * }
+ *
+ * return originalRequiredValidator.apply(this, arguments);
+ * };
+ * }
+ * };
+ * });
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * it('should show the error message when the unknown option is selected', function() {
+
+ var error = element(by.className('error'));
+
+ expect(error.getText()).toBe('Error: Please select a value');
+
+ element(by.cssContainingText('option', 'Option 1')).click();
+
+ expect(error.isPresent()).toBe(false);
+
+ element(by.tagName('button')).click();
+
+ expect(error.getText()).toBe('Error: Please select a value');
+ });
+ * </file>
+ *</example>
+ *
+ *
+ */
+var SelectController =
+ ['$element', '$scope', /** @this */ function($element, $scope) {
+
+ var self = this,
+ optionsMap = new NgMap();
+
+ self.selectValueMap = {}; // Keys are the hashed values, values the original values
+
+ // If the ngModel doesn't get provided then provide a dummy noop version to prevent errors
+ self.ngModelCtrl = noopNgModelController;
+ self.multiple = false;
+
+ // The "unknown" option is one that is prepended to the list if the viewValue
+ // does not match any of the options. When it is rendered the value of the unknown
+ // option is '? XXX ?' where XXX is the hashKey of the value that is not known.
+ //
+ // Support: IE 9 only
+ // We can't just jqLite('<option>') since jqLite is not smart enough
+ // to create it in <select> and IE barfs otherwise.
+ self.unknownOption = jqLite(window.document.createElement('option'));
+
+ // The empty option is an option with the value '' that the application developer can
+ // provide inside the select. It is always selectable and indicates that a "null" selection has
+ // been made by the user.
+ // If the select has an empty option, and the model of the select is set to "undefined" or "null",
+ // the empty option is selected.
+ // If the model is set to a different unmatched value, the unknown option is rendered and
+ // selected, i.e both are present, because a "null" selection and an unknown value are different.
+ self.hasEmptyOption = false;
+ self.emptyOption = undefined;
+
+ self.renderUnknownOption = function(val) {
+ var unknownVal = self.generateUnknownOptionValue(val);
+ self.unknownOption.val(unknownVal);
+ $element.prepend(self.unknownOption);
+ setOptionSelectedStatus(self.unknownOption, true);
+ $element.val(unknownVal);
+ };
+
+ self.updateUnknownOption = function(val) {
+ var unknownVal = self.generateUnknownOptionValue(val);
+ self.unknownOption.val(unknownVal);
+ setOptionSelectedStatus(self.unknownOption, true);
+ $element.val(unknownVal);
+ };
+
+ self.generateUnknownOptionValue = function(val) {
+ return '? ' + hashKey(val) + ' ?';
+ };
+
+ self.removeUnknownOption = function() {
+ if (self.unknownOption.parent()) self.unknownOption.remove();
+ };
+
+ self.selectEmptyOption = function() {
+ if (self.emptyOption) {
+ $element.val('');
+ setOptionSelectedStatus(self.emptyOption, true);
+ }
+ };
+
+ self.unselectEmptyOption = function() {
+ if (self.hasEmptyOption) {
+ setOptionSelectedStatus(self.emptyOption, false);
+ }
+ };
+
+ $scope.$on('$destroy', function() {
+ // disable unknown option so that we don't do work when the whole select is being destroyed
+ self.renderUnknownOption = noop;
+ });
+
+ // Read the value of the select control, the implementation of this changes depending
+ // upon whether the select can have multiple values and whether ngOptions is at work.
+ self.readValue = function readSingleValue() {
+ var val = $element.val();
+ // ngValue added option values are stored in the selectValueMap, normal interpolations are not
+ var realVal = val in self.selectValueMap ? self.selectValueMap[val] : val;
+
+ if (self.hasOption(realVal)) {
+ return realVal;
+ }
+
+ return null;
+ };
+
+
+ // Write the value to the select control, the implementation of this changes depending
+ // upon whether the select can have multiple values and whether ngOptions is at work.
+ self.writeValue = function writeSingleValue(value) {
+ // Make sure to remove the selected attribute from the previously selected option
+ // Otherwise, screen readers might get confused
+ var currentlySelectedOption = $element[0].options[$element[0].selectedIndex];
+ if (currentlySelectedOption) setOptionSelectedStatus(jqLite(currentlySelectedOption), false);
+
+ if (self.hasOption(value)) {
+ self.removeUnknownOption();
+
+ var hashedVal = hashKey(value);
+ $element.val(hashedVal in self.selectValueMap ? hashedVal : value);
+
+ // Set selected attribute and property on selected option for screen readers
+ var selectedOption = $element[0].options[$element[0].selectedIndex];
+ setOptionSelectedStatus(jqLite(selectedOption), true);
+ } else {
+ self.selectUnknownOrEmptyOption(value);
+ }
+ };
+
+
+ // Tell the select control that an option, with the given value, has been added
+ self.addOption = function(value, element) {
+ // Skip comment nodes, as they only pollute the `optionsMap`
+ if (element[0].nodeType === NODE_TYPE_COMMENT) return;
+
+ assertNotHasOwnProperty(value, '"option value"');
+ if (value === '') {
+ self.hasEmptyOption = true;
+ self.emptyOption = element;
+ }
+ var count = optionsMap.get(value) || 0;
+ optionsMap.set(value, count + 1);
+ // Only render at the end of a digest. This improves render performance when many options
+ // are added during a digest and ensures all relevant options are correctly marked as selected
+ scheduleRender();
+ };
+
+ // Tell the select control that an option, with the given value, has been removed
+ self.removeOption = function(value) {
+ var count = optionsMap.get(value);
+ if (count) {
+ if (count === 1) {
+ optionsMap.delete(value);
+ if (value === '') {
+ self.hasEmptyOption = false;
+ self.emptyOption = undefined;
+ }
+ } else {
+ optionsMap.set(value, count - 1);
+ }
+ }
+ };
+
+ // Check whether the select control has an option matching the given value
+ self.hasOption = function(value) {
+ return !!optionsMap.get(value);
+ };
+
+ /**
+ * @ngdoc method
+ * @name select.SelectController#$hasEmptyOption
+ *
+ * @description
+ *
+ * Returns `true` if the select element currently has an empty option
+ * element, i.e. an option that signifies that the select is empty / the selection is null.
+ *
+ */
+ self.$hasEmptyOption = function() {
+ return self.hasEmptyOption;
+ };
+
+ /**
+ * @ngdoc method
+ * @name select.SelectController#$isUnknownOptionSelected
+ *
+ * @description
+ *
+ * Returns `true` if the select element's unknown option is selected. The unknown option is added
+ * and automatically selected whenever the select model doesn't match any option.
+ *
+ */
+ self.$isUnknownOptionSelected = function() {
+ // Presence of the unknown option means it is selected
+ return $element[0].options[0] === self.unknownOption[0];
+ };
+
+ /**
+ * @ngdoc method
+ * @name select.SelectController#$isEmptyOptionSelected
+ *
+ * @description
+ *
+ * Returns `true` if the select element has an empty option and this empty option is currently
+ * selected. Returns `false` if the select element has no empty option or it is not selected.
+ *
+ */
+ self.$isEmptyOptionSelected = function() {
+ return self.hasEmptyOption && $element[0].options[$element[0].selectedIndex] === self.emptyOption[0];
+ };
+
+ self.selectUnknownOrEmptyOption = function(value) {
+ if (value == null && self.emptyOption) {
+ self.removeUnknownOption();
+ self.selectEmptyOption();
+ } else if (self.unknownOption.parent().length) {
+ self.updateUnknownOption(value);
+ } else {
+ self.renderUnknownOption(value);
+ }
+ };
+
+ var renderScheduled = false;
+ function scheduleRender() {
+ if (renderScheduled) return;
+ renderScheduled = true;
+ $scope.$$postDigest(function() {
+ renderScheduled = false;
+ self.ngModelCtrl.$render();
+ });
+ }
+
+ var updateScheduled = false;
+ function scheduleViewValueUpdate(renderAfter) {
+ if (updateScheduled) return;
+
+ updateScheduled = true;
+
+ $scope.$$postDigest(function() {
+ if ($scope.$$destroyed) return;
+
+ updateScheduled = false;
+ self.ngModelCtrl.$setViewValue(self.readValue());
+ if (renderAfter) self.ngModelCtrl.$render();
+ });
+ }
+
+
+ self.registerOption = function(optionScope, optionElement, optionAttrs, interpolateValueFn, interpolateTextFn) {
+
+ if (optionAttrs.$attr.ngValue) {
+ // The value attribute is set by ngValue
+ var oldVal, hashedVal;
+ optionAttrs.$observe('value', function valueAttributeObserveAction(newVal) {
+
+ var removal;
+ var previouslySelected = optionElement.prop('selected');
+
+ if (isDefined(hashedVal)) {
+ self.removeOption(oldVal);
+ delete self.selectValueMap[hashedVal];
+ removal = true;
+ }
+
+ hashedVal = hashKey(newVal);
+ oldVal = newVal;
+ self.selectValueMap[hashedVal] = newVal;
+ self.addOption(newVal, optionElement);
+ // Set the attribute directly instead of using optionAttrs.$set - this stops the observer
+ // from firing a second time. Other $observers on value will also get the result of the
+ // ngValue expression, not the hashed value
+ optionElement.attr('value', hashedVal);
+
+ if (removal && previouslySelected) {
+ scheduleViewValueUpdate();
+ }
+
+ });
+ } else if (interpolateValueFn) {
+ // The value attribute is interpolated
+ optionAttrs.$observe('value', function valueAttributeObserveAction(newVal) {
+ // This method is overwritten in ngOptions and has side-effects!
+ self.readValue();
+
+ var removal;
+ var previouslySelected = optionElement.prop('selected');
+
+ if (isDefined(oldVal)) {
+ self.removeOption(oldVal);
+ removal = true;
+ }
+ oldVal = newVal;
+ self.addOption(newVal, optionElement);
+
+ if (removal && previouslySelected) {
+ scheduleViewValueUpdate();
+ }
+ });
+ } else if (interpolateTextFn) {
+ // The text content is interpolated
+ optionScope.$watch(interpolateTextFn, function interpolateWatchAction(newVal, oldVal) {
+ optionAttrs.$set('value', newVal);
+ var previouslySelected = optionElement.prop('selected');
+ if (oldVal !== newVal) {
+ self.removeOption(oldVal);
+ }
+ self.addOption(newVal, optionElement);
+
+ if (oldVal && previouslySelected) {
+ scheduleViewValueUpdate();
+ }
+ });
+ } else {
+ // The value attribute is static
+ self.addOption(optionAttrs.value, optionElement);
+ }
+
+
+ optionAttrs.$observe('disabled', function(newVal) {
+
+ // Since model updates will also select disabled options (like ngOptions),
+ // we only have to handle options becoming disabled, not enabled
+
+ if (newVal === 'true' || newVal && optionElement.prop('selected')) {
+ if (self.multiple) {
+ scheduleViewValueUpdate(true);
+ } else {
+ self.ngModelCtrl.$setViewValue(null);
+ self.ngModelCtrl.$render();
+ }
+ }
+ });
+
+ optionElement.on('$destroy', function() {
+ var currentValue = self.readValue();
+ var removeValue = optionAttrs.value;
+
+ self.removeOption(removeValue);
+ scheduleRender();
+
+ if (self.multiple && currentValue && currentValue.indexOf(removeValue) !== -1 ||
+ currentValue === removeValue
+ ) {
+ // When multiple (selected) options are destroyed at the same time, we don't want
+ // to run a model update for each of them. Instead, run a single update in the $$postDigest
+ scheduleViewValueUpdate(true);
+ }
+ });
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name select
+ * @restrict E
+ *
+ * @description
+ * HTML `select` element with AngularJS data-binding.
+ *
+ * The `select` directive is used together with {@link ngModel `ngModel`} to provide data-binding
+ * between the scope and the `<select>` control (including setting default values).
+ * It also handles dynamic `<option>` elements, which can be added using the {@link ngRepeat `ngRepeat}` or
+ * {@link ngOptions `ngOptions`} directives.
+ *
+ * When an item in the `<select>` menu is selected, the value of the selected option will be bound
+ * to the model identified by the `ngModel` directive. With static or repeated options, this is
+ * the content of the `value` attribute or the textContent of the `<option>`, if the value attribute is missing.
+ * Value and textContent can be interpolated.
+ *
+ * The {@link select.SelectController select controller} exposes utility functions that can be used
+ * to manipulate the select's behavior.
+ *
+ * ## Matching model and option values
+ *
+ * In general, the match between the model and an option is evaluated by strictly comparing the model
+ * value against the value of the available options.
+ *
+ * If you are setting the option value with the option's `value` attribute, or textContent, the
+ * value will always be a `string` which means that the model value must also be a string.
+ * Otherwise the `select` directive cannot match them correctly.
+ *
+ * To bind the model to a non-string value, you can use one of the following strategies:
+ * - the {@link ng.ngOptions `ngOptions`} directive
+ * ({@link ng.select#using-select-with-ngoptions-and-setting-a-default-value})
+ * - the {@link ng.ngValue `ngValue`} directive, which allows arbitrary expressions to be
+ * option values ({@link ng.select#using-ngvalue-to-bind-the-model-to-an-array-of-objects Example})
+ * - model $parsers / $formatters to convert the string value
+ * ({@link ng.select#binding-select-to-a-non-string-value-via-ngmodel-parsing-formatting Example})
+ *
+ * If the viewValue of `ngModel` does not match any of the options, then the control
+ * will automatically add an "unknown" option, which it then removes when the mismatch is resolved.
+ *
+ * Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
+ * be nested into the `<select>` element. This element will then represent the `null` or "not selected"
+ * option. See example below for demonstration.
+ *
+ * ## Choosing between `ngRepeat` and `ngOptions`
+ *
+ * In many cases, `ngRepeat` can be used on `<option>` elements instead of {@link ng.directive:ngOptions
+ * ngOptions} to achieve a similar result. However, `ngOptions` provides some benefits:
+ * - more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the
+ * comprehension expression
+ * - reduced memory consumption by not creating a new scope for each repeated instance
+ * - increased render speed by creating the options in a documentFragment instead of individually
+ *
+ * Specifically, select with repeated options slows down significantly starting at 2000 options in
+ * Chrome and Internet Explorer / Edge.
+ *
+ *
+ * @param {string} ngModel Assignable AngularJS expression to data-bind to.
+ * @param {string=} name Property name of the form under which the control is published.
+ * @param {string=} multiple Allows multiple options to be selected. The selected values will be
+ * bound to the model as an array.
+ * @param {string=} required Sets `required` validation error key if the value is not entered.
+ * @param {string=} ngRequired Adds required attribute and required validation constraint to
+ * the element when the ngRequired expression evaluates to true. Use ngRequired instead of required
+ * when you want to data-bind to the required attribute.
+ * @param {string=} ngChange AngularJS expression to be executed when selected option(s) changes due to user
+ * interaction with the select element.
+ * @param {string=} ngOptions sets the options that the select is populated with and defines what is
+ * set on the model on selection. See {@link ngOptions `ngOptions`}.
+ * @param {string=} ngAttrSize sets the size of the select element dynamically. Uses the
+ * {@link guide/interpolation#-ngattr-for-binding-to-arbitrary-attributes ngAttr} directive.
+ *
+ *
+ * @example
+ * ### Simple `select` elements with static options
+ *
+ * <example name="static-select" module="staticSelect">
+ * <file name="index.html">
+ * <div ng-controller="ExampleController">
+ * <form name="myForm">
+ * <label for="singleSelect"> Single select: </label><br>
+ * <select name="singleSelect" ng-model="data.singleSelect">
+ * <option value="option-1">Option 1</option>
+ * <option value="option-2">Option 2</option>
+ * </select><br>
+ *
+ * <label for="singleSelect"> Single select with "not selected" option and dynamic option values: </label><br>
+ * <select name="singleSelect" id="singleSelect" ng-model="data.singleSelect">
+ * <option value="">---Please select---</option> <!-- not selected / blank option -->
+ * <option value="{{data.option1}}">Option 1</option> <!-- interpolation -->
+ * <option value="option-2">Option 2</option>
+ * </select><br>
+ * <button ng-click="forceUnknownOption()">Force unknown option</button><br>
+ * <tt>singleSelect = {{data.singleSelect}}</tt>
+ *
+ * <hr>
+ * <label for="multipleSelect"> Multiple select: </label><br>
+ * <select name="multipleSelect" id="multipleSelect" ng-model="data.multipleSelect" multiple>
+ * <option value="option-1">Option 1</option>
+ * <option value="option-2">Option 2</option>
+ * <option value="option-3">Option 3</option>
+ * </select><br>
+ * <tt>multipleSelect = {{data.multipleSelect}}</tt><br/>
+ * </form>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('staticSelect', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.data = {
+ * singleSelect: null,
+ * multipleSelect: [],
+ * option1: 'option-1'
+ * };
+ *
+ * $scope.forceUnknownOption = function() {
+ * $scope.data.singleSelect = 'nonsense';
+ * };
+ * }]);
+ * </file>
+ *</example>
+ *
+ * @example
+ * ### Using `ngRepeat` to generate `select` options
+ * <example name="select-ngrepeat" module="ngrepeatSelect">
+ * <file name="index.html">
+ * <div ng-controller="ExampleController">
+ * <form name="myForm">
+ * <label for="repeatSelect"> Repeat select: </label>
+ * <select name="repeatSelect" id="repeatSelect" ng-model="data.model">
+ * <option ng-repeat="option in data.availableOptions" value="{{option.id}}">{{option.name}}</option>
+ * </select>
+ * </form>
+ * <hr>
+ * <tt>model = {{data.model}}</tt><br/>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('ngrepeatSelect', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.data = {
+ * model: null,
+ * availableOptions: [
+ * {id: '1', name: 'Option A'},
+ * {id: '2', name: 'Option B'},
+ * {id: '3', name: 'Option C'}
+ * ]
+ * };
+ * }]);
+ * </file>
+ *</example>
+ *
+ * @example
+ * ### Using `ngValue` to bind the model to an array of objects
+ * <example name="select-ngvalue" module="ngvalueSelect">
+ * <file name="index.html">
+ * <div ng-controller="ExampleController">
+ * <form name="myForm">
+ * <label for="ngvalueselect"> ngvalue select: </label>
+ * <select size="6" name="ngvalueselect" ng-model="data.model" multiple>
+ * <option ng-repeat="option in data.availableOptions" ng-value="option.value">{{option.name}}</option>
+ * </select>
+ * </form>
+ * <hr>
+ * <pre>model = {{data.model | json}}</pre><br/>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('ngvalueSelect', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.data = {
+ * model: null,
+ * availableOptions: [
+ {value: 'myString', name: 'string'},
+ {value: 1, name: 'integer'},
+ {value: true, name: 'boolean'},
+ {value: null, name: 'null'},
+ {value: {prop: 'value'}, name: 'object'},
+ {value: ['a'], name: 'array'}
+ * ]
+ * };
+ * }]);
+ * </file>
+ *</example>
+ *
+ * @example
+ * ### Using `select` with `ngOptions` and setting a default value
+ * See the {@link ngOptions ngOptions documentation} for more `ngOptions` usage examples.
+ *
+ * <example name="select-with-default-values" module="defaultValueSelect">
+ * <file name="index.html">
+ * <div ng-controller="ExampleController">
+ * <form name="myForm">
+ * <label for="mySelect">Make a choice:</label>
+ * <select name="mySelect" id="mySelect"
+ * ng-options="option.name for option in data.availableOptions track by option.id"
+ * ng-model="data.selectedOption"></select>
+ * </form>
+ * <hr>
+ * <tt>option = {{data.selectedOption}}</tt><br/>
+ * </div>
+ * </file>
+ * <file name="app.js">
+ * angular.module('defaultValueSelect', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.data = {
+ * availableOptions: [
+ * {id: '1', name: 'Option A'},
+ * {id: '2', name: 'Option B'},
+ * {id: '3', name: 'Option C'}
+ * ],
+ * selectedOption: {id: '3', name: 'Option C'} //This sets the default value of the select in the ui
+ * };
+ * }]);
+ * </file>
+ *</example>
+ *
+ * @example
+ * ### Binding `select` to a non-string value via `ngModel` parsing / formatting
+ *
+ * <example name="select-with-non-string-options" module="nonStringSelect">
+ * <file name="index.html">
+ * <select ng-model="model.id" convert-to-number>
+ * <option value="0">Zero</option>
+ * <option value="1">One</option>
+ * <option value="2">Two</option>
+ * </select>
+ * {{ model }}
+ * </file>
+ * <file name="app.js">
+ * angular.module('nonStringSelect', [])
+ * .run(function($rootScope) {
+ * $rootScope.model = { id: 2 };
+ * })
+ * .directive('convertToNumber', function() {
+ * return {
+ * require: 'ngModel',
+ * link: function(scope, element, attrs, ngModel) {
+ * ngModel.$parsers.push(function(val) {
+ * return parseInt(val, 10);
+ * });
+ * ngModel.$formatters.push(function(val) {
+ * return '' + val;
+ * });
+ * }
+ * };
+ * });
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ * it('should initialize to model', function() {
+ * expect(element(by.model('model.id')).$('option:checked').getText()).toEqual('Two');
+ * });
+ * </file>
+ * </example>
+ *
+ */
+var selectDirective = function() {
+
+ return {
+ restrict: 'E',
+ require: ['select', '?ngModel'],
+ controller: SelectController,
+ priority: 1,
+ link: {
+ pre: selectPreLink,
+ post: selectPostLink
+ }
+ };
+
+ function selectPreLink(scope, element, attr, ctrls) {
+
+ var selectCtrl = ctrls[0];
+ var ngModelCtrl = ctrls[1];
+
+ // if ngModel is not defined, we don't need to do anything but set the registerOption
+ // function to noop, so options don't get added internally
+ if (!ngModelCtrl) {
+ selectCtrl.registerOption = noop;
+ return;
+ }
+
+
+ selectCtrl.ngModelCtrl = ngModelCtrl;
+
+ // When the selected item(s) changes we delegate getting the value of the select control
+ // to the `readValue` method, which can be changed if the select can have multiple
+ // selected values or if the options are being generated by `ngOptions`
+ element.on('change', function() {
+ selectCtrl.removeUnknownOption();
+ scope.$apply(function() {
+ ngModelCtrl.$setViewValue(selectCtrl.readValue());
+ });
+ });
+
+ // If the select allows multiple values then we need to modify how we read and write
+ // values from and to the control; also what it means for the value to be empty and
+ // we have to add an extra watch since ngModel doesn't work well with arrays - it
+ // doesn't trigger rendering if only an item in the array changes.
+ if (attr.multiple) {
+ selectCtrl.multiple = true;
+
+ // Read value now needs to check each option to see if it is selected
+ selectCtrl.readValue = function readMultipleValue() {
+ var array = [];
+ forEach(element.find('option'), function(option) {
+ if (option.selected && !option.disabled) {
+ var val = option.value;
+ array.push(val in selectCtrl.selectValueMap ? selectCtrl.selectValueMap[val] : val);
+ }
+ });
+ return array;
+ };
+
+ // Write value now needs to set the selected property of each matching option
+ selectCtrl.writeValue = function writeMultipleValue(value) {
+ forEach(element.find('option'), function(option) {
+ var shouldBeSelected = !!value && (includes(value, option.value) ||
+ includes(value, selectCtrl.selectValueMap[option.value]));
+ var currentlySelected = option.selected;
+
+ // Support: IE 9-11 only, Edge 12-15+
+ // In IE and Edge adding options to the selection via shift+click/UP/DOWN
+ // will de-select already selected options if "selected" on those options was set
+ // more than once (i.e. when the options were already selected)
+ // So we only modify the selected property if necessary.
+ // Note: this behavior cannot be replicated via unit tests because it only shows in the
+ // actual user interface.
+ if (shouldBeSelected !== currentlySelected) {
+ setOptionSelectedStatus(jqLite(option), shouldBeSelected);
+ }
+
+ });
+ };
+
+ // we have to do it on each watch since ngModel watches reference, but
+ // we need to work of an array, so we need to see if anything was inserted/removed
+ var lastView, lastViewRef = NaN;
+ scope.$watch(function selectMultipleWatch() {
+ if (lastViewRef === ngModelCtrl.$viewValue && !equals(lastView, ngModelCtrl.$viewValue)) {
+ lastView = shallowCopy(ngModelCtrl.$viewValue);
+ ngModelCtrl.$render();
+ }
+ lastViewRef = ngModelCtrl.$viewValue;
+ });
+
+ // If we are a multiple select then value is now a collection
+ // so the meaning of $isEmpty changes
+ ngModelCtrl.$isEmpty = function(value) {
+ return !value || value.length === 0;
+ };
+
+ }
+ }
+
+ function selectPostLink(scope, element, attrs, ctrls) {
+ // if ngModel is not defined, we don't need to do anything
+ var ngModelCtrl = ctrls[1];
+ if (!ngModelCtrl) return;
+
+ var selectCtrl = ctrls[0];
+
+ // We delegate rendering to the `writeValue` method, which can be changed
+ // if the select can have multiple selected values or if the options are being
+ // generated by `ngOptions`.
+ // This must be done in the postLink fn to prevent $render to be called before
+ // all nodes have been linked correctly.
+ ngModelCtrl.$render = function() {
+ selectCtrl.writeValue(ngModelCtrl.$viewValue);
+ };
+ }
+};
+
+
+// The option directive is purely designed to communicate the existence (or lack of)
+// of dynamically created (and destroyed) option elements to their containing select
+// directive via its controller.
+var optionDirective = ['$interpolate', function($interpolate) {
+ return {
+ restrict: 'E',
+ priority: 100,
+ compile: function(element, attr) {
+ var interpolateValueFn, interpolateTextFn;
+
+ if (isDefined(attr.ngValue)) {
+ // Will be handled by registerOption
+ } else if (isDefined(attr.value)) {
+ // If the value attribute is defined, check if it contains an interpolation
+ interpolateValueFn = $interpolate(attr.value, true);
+ } else {
+ // If the value attribute is not defined then we fall back to the
+ // text content of the option element, which may be interpolated
+ interpolateTextFn = $interpolate(element.text(), true);
+ if (!interpolateTextFn) {
+ attr.$set('value', element.text());
+ }
+ }
+
+ return function(scope, element, attr) {
+ // This is an optimization over using ^^ since we don't want to have to search
+ // all the way to the root of the DOM for every single option element
+ var selectCtrlName = '$selectController',
+ parent = element.parent(),
+ selectCtrl = parent.data(selectCtrlName) ||
+ parent.parent().data(selectCtrlName); // in case we are in optgroup
+
+ if (selectCtrl) {
+ selectCtrl.registerOption(scope, element, attr, interpolateValueFn, interpolateTextFn);
+ }
+ };
+ }
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngRequired
+ * @restrict A
+ *
+ * @param {expression} ngRequired AngularJS expression. If it evaluates to `true`, it sets the
+ * `required` attribute to the element and adds the `required`
+ * {@link ngModel.NgModelController#$validators `validator`}.
+ *
+ * @description
+ *
+ * ngRequired adds the required {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
+ * It is most often used for {@link input `input`} and {@link select `select`} controls, but can also be
+ * applied to custom controls.
+ *
+ * The directive sets the `required` attribute on the element if the AngularJS expression inside
+ * `ngRequired` evaluates to true. A special directive for setting `required` is necessary because we
+ * cannot use interpolation inside `required`. See the {@link guide/interpolation interpolation guide}
+ * for more info.
+ *
+ * The validator will set the `required` error key to true if the `required` attribute is set and
+ * calling {@link ngModel.NgModelController#$isEmpty `NgModelController.$isEmpty`} with the
+ * {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`} returns `true`. For example, the
+ * `$isEmpty()` implementation for `input[text]` checks the length of the `$viewValue`. When developing
+ * custom controls, `$isEmpty()` can be overwritten to account for a $viewValue that is not string-based.
+ *
+ * @example
+ * <example name="ngRequiredDirective" module="ngRequiredExample">
+ * <file name="index.html">
+ * <script>
+ * angular.module('ngRequiredExample', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.required = true;
+ * }]);
+ * </script>
+ * <div ng-controller="ExampleController">
+ * <form name="form">
+ * <label for="required">Toggle required: </label>
+ * <input type="checkbox" ng-model="required" id="required" />
+ * <br>
+ * <label for="input">This input must be filled if `required` is true: </label>
+ * <input type="text" ng-model="model" id="input" name="input" ng-required="required" /><br>
+ * <hr>
+ * required error set? = <code>{{form.input.$error.required}}</code><br>
+ * model = <code>{{model}}</code>
+ * </form>
+ * </div>
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ var required = element(by.binding('form.input.$error.required'));
+ var model = element(by.binding('model'));
+ var input = element(by.id('input'));
+
+ it('should set the required error', function() {
+ expect(required.getText()).toContain('true');
+
+ input.sendKeys('123');
+ expect(required.getText()).not.toContain('true');
+ expect(model.getText()).toContain('123');
+ });
+ * </file>
+ * </example>
+ */
+var requiredDirective = ['$parse', function($parse) {
+ return {
+ restrict: 'A',
+ require: '?ngModel',
+ link: function(scope, elm, attr, ctrl) {
+ if (!ctrl) return;
+ // For boolean attributes like required, presence means true
+ var value = attr.hasOwnProperty('required') || $parse(attr.ngRequired)(scope);
+
+ if (!attr.ngRequired) {
+ // force truthy in case we are on non input element
+ // (input elements do this automatically for boolean attributes like required)
+ attr.required = true;
+ }
+
+ ctrl.$validators.required = function(modelValue, viewValue) {
+ return !value || !ctrl.$isEmpty(viewValue);
+ };
+
+ attr.$observe('required', function(newVal) {
+
+ if (value !== newVal) {
+ value = newVal;
+ ctrl.$validate();
+ }
+ });
+ }
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngPattern
+ * @restrict A
+ *
+ * @param {expression|RegExp} ngPattern AngularJS expression that must evaluate to a `RegExp` or a `String`
+ * parsable into a `RegExp`, or a `RegExp` literal. See above for
+ * more details.
+ *
+ * @description
+ *
+ * ngPattern adds the pattern {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
+ * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
+ *
+ * The validator sets the `pattern` error key if the {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`}
+ * does not match a RegExp which is obtained from the `ngPattern` attribute value:
+ * - the value is an AngularJS expression:
+ * - If the expression evaluates to a RegExp object, then this is used directly.
+ * - If the expression evaluates to a string, then it will be converted to a RegExp after wrapping it
+ * in `^` and `$` characters. For instance, `"abc"` will be converted to `new RegExp('^abc$')`.
+ * - If the value is a RegExp literal, e.g. `ngPattern="/^\d+$/"`, it is used directly.
+ *
+ * <div class="alert alert-info">
+ * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ * start at the index of the last search's match, thus not taking the whole input value into
+ * account.
+ * </div>
+ *
+ * <div class="alert alert-info">
+ * **Note:** This directive is also added when the plain `pattern` attribute is used, with two
+ * differences:
+ * <ol>
+ * <li>
+ * `ngPattern` does not set the `pattern` attribute and therefore HTML5 constraint validation is
+ * not available.
+ * </li>
+ * <li>
+ * The `ngPattern` attribute must be an expression, while the `pattern` value must be
+ * interpolated.
+ * </li>
+ * </ol>
+ * </div>
+ *
+ * @example
+ * <example name="ngPatternDirective" module="ngPatternExample">
+ * <file name="index.html">
+ * <script>
+ * angular.module('ngPatternExample', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.regex = '\\d+';
+ * }]);
+ * </script>
+ * <div ng-controller="ExampleController">
+ * <form name="form">
+ * <label for="regex">Set a pattern (regex string): </label>
+ * <input type="text" ng-model="regex" id="regex" />
+ * <br>
+ * <label for="input">This input is restricted by the current pattern: </label>
+ * <input type="text" ng-model="model" id="input" name="input" ng-pattern="regex" /><br>
+ * <hr>
+ * input valid? = <code>{{form.input.$valid}}</code><br>
+ * model = <code>{{model}}</code>
+ * </form>
+ * </div>
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ var model = element(by.binding('model'));
+ var input = element(by.id('input'));
+
+ it('should validate the input with the default pattern', function() {
+ input.sendKeys('aaa');
+ expect(model.getText()).not.toContain('aaa');
+
+ input.clear().then(function() {
+ input.sendKeys('123');
+ expect(model.getText()).toContain('123');
+ });
+ });
+ * </file>
+ * </example>
+ */
+var patternDirective = ['$parse', function($parse) {
+ return {
+ restrict: 'A',
+ require: '?ngModel',
+ compile: function(tElm, tAttr) {
+ var patternExp;
+ var parseFn;
+
+ if (tAttr.ngPattern) {
+ patternExp = tAttr.ngPattern;
+
+ // ngPattern might be a scope expression, or an inlined regex, which is not parsable.
+ // We get value of the attribute here, so we can compare the old and the new value
+ // in the observer to avoid unnecessary validations
+ if (tAttr.ngPattern.charAt(0) === '/' && REGEX_STRING_REGEXP.test(tAttr.ngPattern)) {
+ parseFn = function() { return tAttr.ngPattern; };
+ } else {
+ parseFn = $parse(tAttr.ngPattern);
+ }
+ }
+
+ return function(scope, elm, attr, ctrl) {
+ if (!ctrl) return;
+
+ var attrVal = attr.pattern;
+
+ if (attr.ngPattern) {
+ attrVal = parseFn(scope);
+ } else {
+ patternExp = attr.pattern;
+ }
+
+ var regexp = parsePatternAttr(attrVal, patternExp, elm);
+
+ attr.$observe('pattern', function(newVal) {
+ var oldRegexp = regexp;
+
+ regexp = parsePatternAttr(newVal, patternExp, elm);
+
+ if ((oldRegexp && oldRegexp.toString()) !== (regexp && regexp.toString())) {
+ ctrl.$validate();
+ }
+ });
+
+ ctrl.$validators.pattern = function(modelValue, viewValue) {
+ // HTML5 pattern constraint validates the input value, so we validate the viewValue
+ return ctrl.$isEmpty(viewValue) || isUndefined(regexp) || regexp.test(viewValue);
+ };
+ };
+ }
+
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngMaxlength
+ * @restrict A
+ *
+ * @param {expression} ngMaxlength AngularJS expression that must evaluate to a `Number` or `String`
+ * parsable into a `Number`. Used as value for the `maxlength`
+ * {@link ngModel.NgModelController#$validators validator}.
+ *
+ * @description
+ *
+ * ngMaxlength adds the maxlength {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
+ * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
+ *
+ * The validator sets the `maxlength` error key if the {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`}
+ * is longer than the integer obtained by evaluating the AngularJS expression given in the
+ * `ngMaxlength` attribute value.
+ *
+ * <div class="alert alert-info">
+ * **Note:** This directive is also added when the plain `maxlength` attribute is used, with two
+ * differences:
+ * <ol>
+ * <li>
+ * `ngMaxlength` does not set the `maxlength` attribute and therefore HTML5 constraint
+ * validation is not available.
+ * </li>
+ * <li>
+ * The `ngMaxlength` attribute must be an expression, while the `maxlength` value must be
+ * interpolated.
+ * </li>
+ * </ol>
+ * </div>
+ *
+ * @example
+ * <example name="ngMaxlengthDirective" module="ngMaxlengthExample">
+ * <file name="index.html">
+ * <script>
+ * angular.module('ngMaxlengthExample', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.maxlength = 5;
+ * }]);
+ * </script>
+ * <div ng-controller="ExampleController">
+ * <form name="form">
+ * <label for="maxlength">Set a maxlength: </label>
+ * <input type="number" ng-model="maxlength" id="maxlength" />
+ * <br>
+ * <label for="input">This input is restricted by the current maxlength: </label>
+ * <input type="text" ng-model="model" id="input" name="input" ng-maxlength="maxlength" /><br>
+ * <hr>
+ * input valid? = <code>{{form.input.$valid}}</code><br>
+ * model = <code>{{model}}</code>
+ * </form>
+ * </div>
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ var model = element(by.binding('model'));
+ var input = element(by.id('input'));
+
+ it('should validate the input with the default maxlength', function() {
+ input.sendKeys('abcdef');
+ expect(model.getText()).not.toContain('abcdef');
+
+ input.clear().then(function() {
+ input.sendKeys('abcde');
+ expect(model.getText()).toContain('abcde');
+ });
+ });
+ * </file>
+ * </example>
+ */
+var maxlengthDirective = ['$parse', function($parse) {
+ return {
+ restrict: 'A',
+ require: '?ngModel',
+ link: function(scope, elm, attr, ctrl) {
+ if (!ctrl) return;
+
+ var maxlength = attr.maxlength || $parse(attr.ngMaxlength)(scope);
+ var maxlengthParsed = parseLength(maxlength);
+
+ attr.$observe('maxlength', function(value) {
+ if (maxlength !== value) {
+ maxlengthParsed = parseLength(value);
+ maxlength = value;
+ ctrl.$validate();
+ }
+ });
+ ctrl.$validators.maxlength = function(modelValue, viewValue) {
+ return (maxlengthParsed < 0) || ctrl.$isEmpty(viewValue) || (viewValue.length <= maxlengthParsed);
+ };
+ }
+ };
+}];
+
+/**
+ * @ngdoc directive
+ * @name ngMinlength
+ * @restrict A
+ *
+ * @param {expression} ngMinlength AngularJS expression that must evaluate to a `Number` or `String`
+ * parsable into a `Number`. Used as value for the `minlength`
+ * {@link ngModel.NgModelController#$validators validator}.
+ *
+ * @description
+ *
+ * ngMinlength adds the minlength {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
+ * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
+ *
+ * The validator sets the `minlength` error key if the {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`}
+ * is shorter than the integer obtained by evaluating the AngularJS expression given in the
+ * `ngMinlength` attribute value.
+ *
+ * <div class="alert alert-info">
+ * **Note:** This directive is also added when the plain `minlength` attribute is used, with two
+ * differences:
+ * <ol>
+ * <li>
+ * `ngMinlength` does not set the `minlength` attribute and therefore HTML5 constraint
+ * validation is not available.
+ * </li>
+ * <li>
+ * The `ngMinlength` value must be an expression, while the `minlength` value must be
+ * interpolated.
+ * </li>
+ * </ol>
+ * </div>
+ *
+ * @example
+ * <example name="ngMinlengthDirective" module="ngMinlengthExample">
+ * <file name="index.html">
+ * <script>
+ * angular.module('ngMinlengthExample', [])
+ * .controller('ExampleController', ['$scope', function($scope) {
+ * $scope.minlength = 3;
+ * }]);
+ * </script>
+ * <div ng-controller="ExampleController">
+ * <form name="form">
+ * <label for="minlength">Set a minlength: </label>
+ * <input type="number" ng-model="minlength" id="minlength" />
+ * <br>
+ * <label for="input">This input is restricted by the current minlength: </label>
+ * <input type="text" ng-model="model" id="input" name="input" ng-minlength="minlength" /><br>
+ * <hr>
+ * input valid? = <code>{{form.input.$valid}}</code><br>
+ * model = <code>{{model}}</code>
+ * </form>
+ * </div>
+ * </file>
+ * <file name="protractor.js" type="protractor">
+ var model = element(by.binding('model'));
+ var input = element(by.id('input'));
+
+ it('should validate the input with the default minlength', function() {
+ input.sendKeys('ab');
+ expect(model.getText()).not.toContain('ab');
+
+ input.sendKeys('abc');
+ expect(model.getText()).toContain('abc');
+ });
+ * </file>
+ * </example>
+ */
+var minlengthDirective = ['$parse', function($parse) {
+ return {
+ restrict: 'A',
+ require: '?ngModel',
+ link: function(scope, elm, attr, ctrl) {
+ if (!ctrl) return;
+
+ var minlength = attr.minlength || $parse(attr.ngMinlength)(scope);
+ var minlengthParsed = parseLength(minlength) || -1;
+
+ attr.$observe('minlength', function(value) {
+ if (minlength !== value) {
+ minlengthParsed = parseLength(value) || -1;
+ minlength = value;
+ ctrl.$validate();
+ }
+
+ });
+ ctrl.$validators.minlength = function(modelValue, viewValue) {
+ return ctrl.$isEmpty(viewValue) || viewValue.length >= minlengthParsed;
+ };
+ }
+ };
+}];
+
+
+function parsePatternAttr(regex, patternExp, elm) {
+ if (!regex) return undefined;
+
+ if (isString(regex)) {
+ regex = new RegExp('^' + regex + '$');
+ }
+
+ if (!regex.test) {
+ throw minErr('ngPattern')('noregexp',
+ 'Expected {0} to be a RegExp but was {1}. Element: {2}', patternExp,
+ regex, startingTag(elm));
+ }
+
+ return regex;
+}
+
+function parseLength(val) {
+ var intVal = toInt(val);
+ return isNumberNaN(intVal) ? -1 : intVal;
+}
+
+if (window.angular.bootstrap) {
+ // AngularJS is already loaded, so we can return here...
+ if (window.console) {
+ console.log('WARNING: Tried to load AngularJS more than once.');
+ }
+ return;
+}
+
+// try to bind to jquery now so that one can write jqLite(fn)
+// but we will rebind on bootstrap again.
+bindJQuery();
+
+publishExternalAPI(angular);
+
+angular.module("ngLocale", [], ["$provide", function($provide) {
+var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "many", OTHER: "other"};
+function getDecimals(n) {
+ n = n + '';
+ var i = n.indexOf('.');
+ return (i == -1) ? 0 : n.length - i - 1;
+}
+
+function getVF(n, opt_precision) {
+ var v = opt_precision;
+
+ if (undefined === v) {
+ v = Math.min(getDecimals(n), 3);
+ }
+
+ var base = Math.pow(10, v);
+ var f = ((n * base) | 0) % base;
+ return {v: v, f: f};
+}
+
+$provide.value("$locale", {
+ "DATETIME_FORMATS": {
+ "AMPMS": [
+ "AM",
+ "PM"
+ ],
+ "DAY": [
+ "Sunday",
+ "Monday",
+ "Tuesday",
+ "Wednesday",
+ "Thursday",
+ "Friday",
+ "Saturday"
+ ],
+ "ERANAMES": [
+ "Before Christ",
+ "Anno Domini"
+ ],
+ "ERAS": [
+ "BC",
+ "AD"
+ ],
+ "FIRSTDAYOFWEEK": 6,
+ "MONTH": [
+ "January",
+ "February",
+ "March",
+ "April",
+ "May",
+ "June",
+ "July",
+ "August",
+ "September",
+ "October",
+ "November",
+ "December"
+ ],
+ "SHORTDAY": [
+ "Sun",
+ "Mon",
+ "Tue",
+ "Wed",
+ "Thu",
+ "Fri",
+ "Sat"
+ ],
+ "SHORTMONTH": [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "May",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Oct",
+ "Nov",
+ "Dec"
+ ],
+ "STANDALONEMONTH": [
+ "January",
+ "February",
+ "March",
+ "April",
+ "May",
+ "June",
+ "July",
+ "August",
+ "September",
+ "October",
+ "November",
+ "December"
+ ],
+ "WEEKENDRANGE": [
+ 5,
+ 6
+ ],
+ "fullDate": "EEEE, MMMM d, y",
+ "longDate": "MMMM d, y",
+ "medium": "MMM d, y h:mm:ss a",
+ "mediumDate": "MMM d, y",
+ "mediumTime": "h:mm:ss a",
+ "short": "M/d/yy h:mm a",
+ "shortDate": "M/d/yy",
+ "shortTime": "h:mm a"
+ },
+ "NUMBER_FORMATS": {
+ "CURRENCY_SYM": "$",
+ "DECIMAL_SEP": ".",
+ "GROUP_SEP": ",",
+ "PATTERNS": [
+ {
+ "gSize": 3,
+ "lgSize": 3,
+ "maxFrac": 3,
+ "minFrac": 0,
+ "minInt": 1,
+ "negPre": "-",
+ "negSuf": "",
+ "posPre": "",
+ "posSuf": ""
+ },
+ {
+ "gSize": 3,
+ "lgSize": 3,
+ "maxFrac": 2,
+ "minFrac": 2,
+ "minInt": 1,
+ "negPre": "-\u00a4",
+ "negSuf": "",
+ "posPre": "\u00a4",
+ "posSuf": ""
+ }
+ ]
+ },
+ "id": "en-us",
+ "localeID": "en_US",
+ "pluralCat": function(n, opt_precision) { var i = n | 0; var vf = getVF(n, opt_precision); if (i == 1 && vf.v == 0) { return PLURAL_CATEGORY.ONE; } return PLURAL_CATEGORY.OTHER;}
+});
+}]);
+
+ jqLite(function() {
+ angularInit(window.document, bootstrap);
+ });
+
+})(window);
+
+!window.angular.$$csp().noInlineStyle && window.angular.element(document.head).prepend(window.angular.element('<style>').text('@charset "UTF-8";[ng\\:cloak],[ng-cloak],[data-ng-cloak],[x-ng-cloak],.ng-cloak,.x-ng-cloak,.ng-hide:not(.ng-hide-animate){display:none !important;}ng\\:form{display:block;}.ng-animate-shim{visibility:hidden;}.ng-anchor{position:absolute;}'));
+
+/***/ }),
+
+/***/ "./node_modules/angular/index.js":
+/*!***************************************!*\
+ !*** ./node_modules/angular/index.js ***!
+ \***************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+__webpack_require__(/*! ./angular */ "./node_modules/angular/angular.js");
+module.exports = angular;
+
+
+/***/ }),
+
+/***/ "./src/js/chat/chat.controller.js":
+/*!****************************************!*\
+ !*** ./src/js/chat/chat.controller.js ***!
+ \****************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "ChatController": () => (/* binding */ ChatController)
+/* harmony export */ });
+/* harmony import */ var _uirouter_angularjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @uirouter/angularjs */ "./node_modules/@uirouter/angularjs/lib-esm/index.js");
+/* harmony import */ var lodash_find__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lodash.find */ "./node_modules/lodash.find/index.js");
+/* harmony import */ var lodash_find__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(lodash_find__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var lodash_isnil__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! lodash.isnil */ "./node_modules/lodash.isnil/index.js");
+/* harmony import */ var lodash_isnil__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(lodash_isnil__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var lodash_merge__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! lodash.merge */ "./node_modules/lodash.merge/index.js");
+/* harmony import */ var lodash_merge__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(lodash_merge__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var lodash_values__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! lodash.values */ "./node_modules/lodash.values/index.js");
+/* harmony import */ var lodash_values__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(lodash_values__WEBPACK_IMPORTED_MODULE_4__);
+/* provided dependency */ var $ = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js");
+ChatController.$inject = ["$scope", "$rootScope", "$timeout", "$interval", "$document", "$state", "$http", "api", "RemoteStorageService", "STORAGE_VISITOR", "STORAGE_LAYOUT"];
+
+
+
+
+
+/**
+ * @ngInject
+ * @param {ng.IScope} $scope
+ * @param {ng.IRootScopeService} $rootScope
+ * @param {ng.ITimeoutService} $timeout
+ * @param {ng.IIntervalService} $interval
+ * @param {ng.ITimeoutService} $document
+ * @param {import('@uirouter/angularjs').StateService} $state
+ * @param {ng.IHttpService} $http
+ * @param {ReturnType<typeof import('@js/index.factory').apiService>} api
+ * @param {import('../common/remote-storage.service').RemoteStorageService} RemoteStorageService
+ * @param {'layout'} STORAGE_LAYOUT
+ * @param {'visitor'} STORAGE_VISITOR
+ */
+
+function ChatController($scope, $rootScope, $timeout, $interval, $document, $state, $http, api, RemoteStorageService, STORAGE_VISITOR, STORAGE_LAYOUT) {
+ const vm = this;
+ let emojiArea;
+ let getMessagesInterval;
+ let getInteractionInterval;
+ let lastMessageId; // Data
+
+ vm.errors = {};
+ $rootScope.messages = [];
+ vm.emojiOptions = {
+ watchEmbedData: false,
+ // watch embed data and render on change
+ fontSmiley: false,
+ // convert ascii smileys into font smileys
+ emoji: true,
+ // convert emojis short names into images
+ link: true,
+ // convert links into anchor tags
+ linkTarget: '_blank' // _blank|_self|_parent|_top|framename
+
+ };
+
+ function goToIfTime() {
+ if ($rootScope.settings.online) {
+ $state.go('app.online', null, {
+ location: 'replace'
+ });
+ } else {
+ $state.go('app.offline', null, {
+ location: 'replace'
+ });
+ }
+ }
+
+ function clearStorage() {
+ // visitor storage remove
+ _uirouter_angularjs__WEBPACK_IMPORTED_MODULE_0__.$q.all([RemoteStorageService.removeItem(STORAGE_VISITOR).then(() => console.debug('STORAGE_VISITOR cleared')).catch(RemoteStorageService.onStorageError), RemoteStorageService.removeItem(STORAGE_LAYOUT).then(() => console.debug('STORAGE_LAYOUT cleared')).catch(RemoteStorageService.onStorageError)]).then(() => goToIfTime());
+ }
+ /**
+ * Scroll Chat Content to the bottom
+ * @param speed
+ */
+
+
+ function scrollToBottomOfChat() {
+ $timeout(function () {
+ const element = $document[0].getElementsByClassName('chat-messages')[0];
+
+ if (element) {
+ element.scrollTop = element.scrollHeight;
+ }
+ });
+ } // Functions
+
+
+ function handleError(name) {
+ return function (err) {
+ vm.errors[name] = err.data;
+ scrollToBottomOfChat();
+ };
+ }
+
+ function sendMessage(message) {
+ api.chatWebsite.notify(message).$promise.then(function (data) {
+ delete vm.errors.chatMessageError;
+ let updateRootscope = false;
+
+ if (lodash_isnil__WEBPACK_IMPORTED_MODULE_2___default()($rootScope.visitor.interaction)) {
+ $rootScope.visitor.interaction = {
+ id: data.interaction.id
+ };
+ updateRootscope = true;
+ }
+
+ if (!$rootScope.visitor.interactionStarted) {
+ $rootScope.visitor.interactionStarted = true;
+ updateRootscope = true;
+ } // Update root scope only if one of the above conditions
+
+
+ if (updateRootscope) {
+ RemoteStorageService.updateStorage(STORAGE_VISITOR, $rootScope.visitor).then(value => {
+ $rootScope.visitor = value;
+ }).catch(RemoteStorageService.onStorageError);
+ }
+
+ emojiArea[0].emojioneArea.setText(''); // scroll message list
+
+ scrollToBottomOfChat();
+ }).catch(handleError('chatMessageError'));
+ }
+
+ function fileAdded(data) {
+ const fd = new FormData(); // Take the first selected file
+
+ fd.append('file', data.file);
+ $http.post($rootScope.settings.remote + '/api/chat/interactions/' + $rootScope.visitor.interaction.id + '/attachment_upload?token=' + $rootScope.settings.token, fd, {
+ transformRequest: angular.identity,
+ headers: {
+ 'Content-Type': undefined
+ }
+ }).then(function (data) {
+ data = data.data;
+
+ if (data.id) {
+ delete vm.errors.sendAttachment; // Message Attachment
+
+ sendMessage(lodash_merge__WEBPACK_IMPORTED_MODULE_3___default()({
+ body: '<a href="' + $rootScope.settings.remote + '/api/chat/interactions/' + $rootScope.visitor.interaction.id + '/attachment_download?attachId=' + data.id + '&token=' + $rootScope.settings.token + '" target="_blank">' + data.name + '</a>',
+ AttachmentId: data.id
+ }, $rootScope.visitor));
+ } else {
+ handleError('sendAttachment');
+ }
+ }, handleError('sendAttachment'));
+ }
+
+ function onDestroy() {
+ $interval.cancel(getMessagesInterval);
+ $interval.cancel(getInteractionInterval);
+ getMessagesInterval = null;
+ getInteractionInterval = null;
+ }
+
+ function onDownload(data, callback) {
+ if (callback) {
+ callback(lodash_values__WEBPACK_IMPORTED_MODULE_4___default()($rootScope.messages));
+ }
+ }
+
+ function getInteraction() {
+ if ($rootScope.visitor && $rootScope.visitor.interaction && $rootScope.visitor.interaction.id) {
+ api.chatInteraction.get({
+ id: $rootScope.visitor.interaction.id
+ }).$promise.then(function (data) {
+ delete vm.errors.getInteraction; // IDEA: get only last n messages
+
+ if (data.closed) {
+ $rootScope.visitor.interaction.closed = true;
+ RemoteStorageService.updateStorage(STORAGE_VISITOR, $rootScope.visitor).then(value => {
+ $rootScope.visitor = value;
+ }).catch(RemoteStorageService.onStorageError);
+
+ if (data.disposition === 'unmanaged') {
+ $state.go('app.unmanaged', null, {
+ location: 'replace'
+ });
+ } else {
+ $state.go('app.closing', null, {
+ location: 'replace'
+ });
+ }
+ }
+ }).catch(function (err) {
+ switch (err.status) {
+ case 403:
+ $state.go('app.closing', null, {
+ location: 'replace'
+ });
+ break;
+
+ case 404:
+ clearStorage();
+ break;
+
+ case 405:
+ $state.go('app.unmanaged', null, {
+ location: 'replace'
+ });
+ break;
+
+ default:
+ console.error(err);
+ }
+ });
+ } // scrollToBottomOfChat();
+
+ }
+
+ function reply($event) {
+ const body = emojiArea[0].emojioneArea.getText(); // // If "shift + enter" pressed, grow the reply textarea
+
+ if ($event && $event.keyCode === 13 && $event.shiftKey) {
+ return;
+ } // Prevent the reply() for key presses rather than the"enter" key.
+
+
+ if ($event && $event.keyCode !== 13) {
+ return;
+ } // Check for empty messages
+
+
+ if (body === '') {
+ return;
+ } // Message
+
+
+ sendMessage(lodash_merge__WEBPACK_IMPORTED_MODULE_3___default()({
+ body: body
+ }, $rootScope.visitor));
+ }
+
+ function
+ /* $event */
+ reply_button() {
+ const body = emojiArea[0].emojioneArea.getText(); // Check for empty messages
+
+ if (body === '') {
+ return;
+ } // Message
+
+
+ sendMessage(lodash_merge__WEBPACK_IMPORTED_MODULE_3___default()({
+ body: body
+ }, $rootScope.visitor));
+ emojiArea[0].emojioneArea.setFocus();
+ }
+
+ function updateMessage(id) {
+ return api.chatMessage.update({
+ id: id,
+ read: true
+ }).$promise.catch(function (err) {
+ console.error(err);
+ });
+ }
+
+ function getMessages() {
+ var _$rootScope$visitor, _$rootScope$visitor$i;
+
+ if ($rootScope !== null && $rootScope !== void 0 && (_$rootScope$visitor = $rootScope.visitor) !== null && _$rootScope$visitor !== void 0 && (_$rootScope$visitor$i = _$rootScope$visitor.interaction) !== null && _$rootScope$visitor$i !== void 0 && _$rootScope$visitor$i.id) {
+ api.chatInteraction.getMessages({
+ intid: $rootScope.visitor.interaction.id,
+ includeAgent: true,
+ id: lastMessageId || undefined
+ }).$promise.then(function (data) {
+ delete vm.errors.interaction; // IDEA: get only last n messages
+
+ if (data.count) {
+ let added = false;
+ let i = 0;
+
+ for (i = 0, added = false; i < data.rows.length; i++) {
+ const m = lodash_find__WEBPACK_IMPORTED_MODULE_1___default()($rootScope.messages, {
+ id: data.rows[i].id
+ });
+
+ if (!m) {
+ added = true;
+ $rootScope.messages.push(data.rows[i]);
+ } else if (data.rows[i].read) {
+ m.read = true;
+ } // update last out messages
+
+
+ if (data.rows[i].direction === 'out' && !data.rows[i].read) {
+ updateMessage(data.rows[i].id);
+ }
+ }
+
+ if (added) {
+ // scroll message list
+ scrollToBottomOfChat();
+ }
+
+ if (data.rows[i - 1].read) {
+ lastMessageId = data.rows[i - 1].id;
+ }
+
+ if (lastMessageId && !$rootScope.visitor.interactionStarted) {
+ RemoteStorageService.updateStorage(STORAGE_VISITOR, { ...$rootScope.visitor,
+ interactionStarted: true
+ }).then(value => {
+ $rootScope.visitor = value;
+ });
+ }
+ }
+ }).catch(function (err) {
+ switch (err.status) {
+ case 403:
+ $state.go('app.closing', null, {
+ location: 'replace'
+ });
+ break;
+
+ case 405:
+ $state.go('app.unmanaged', null, {
+ location: 'replace'
+ });
+ break;
+
+ default:
+ console.error(err);
+ }
+ });
+ }
+ }
+
+ function onInit() {
+ console.debug('ChatController::onInit() VISITOR', $rootScope.visitor);
+ $rootScope.status = 'chat';
+ $rootScope.loading = false;
+ $rootScope.settings.showMenu = true;
+ vm.replyMessage = '';
+
+ if ($rootScope.visitor.interaction && $rootScope.visitor.interaction.closed) {
+ // visitor storage remove
+ clearStorage();
+ } else {
+ // first interaction callback
+ getInteraction(); // start polling
+
+ getMessagesInterval = $interval(getMessages, 2000);
+ getInteractionInterval = $interval(getInteraction, 3000);
+ }
+
+ emojiArea = $('#emojionearea').emojioneArea({
+ placeholder: $rootScope.settings.placeholderMessage || 'Type a message',
+ events: {
+ keyup: function (editor, $event) {
+ reply($event);
+ },
+ ready: function () {
+ this.setFocus();
+ }
+ }
+ });
+ } // Methods
+
+
+ vm.$onInit = onInit;
+ vm.reply = reply;
+ vm.reply_button = reply_button;
+ vm.fileAdded = fileAdded; // Events
+
+ $scope.$on('$destroy', onDestroy);
+ $rootScope.$on('$download', onDownload);
+}
+
+
+
+/***/ }),
+
+/***/ "./src/js/closing/closing.controller.js":
+/*!**********************************************!*\
+ !*** ./src/js/closing/closing.controller.js ***!
+ \**********************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "ClosingController": () => (/* binding */ ClosingController)
+/* harmony export */ });
+/* harmony import */ var lodash_merge__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lodash.merge */ "./node_modules/lodash.merge/index.js");
+/* harmony import */ var lodash_merge__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lodash_merge__WEBPACK_IMPORTED_MODULE_0__);
+ClosingController.$inject = ["$rootScope", "$state", "$mdToast", "api", "$q", "RemoteStorageService", "STORAGE_VISITOR", "STORAGE_LAYOUT"];
+
+/**
+ * @ngInject
+ * @param {ng.IRootScopeService} $rootScope
+ * @param {import('@uirouter/angularjs').StateService} $state
+ * @param {import('angular').material.IDialogService} $mdDialog
+ * @param {ReturnType<typeof import('@js/index.factory').apiService>} api
+ * @param {ng.IQService} $q
+ * @param {import('../common/remote-storage.service').RemoteStorageService} RemoteStorageService
+ * @param {'layout'} STORAGE_LAYOUT
+ * @param {'visitor'} STORAGE_VISITOR
+ */
+
+function ClosingController($rootScope, $state, $mdToast, api, $q, RemoteStorageService, STORAGE_VISITOR, STORAGE_LAYOUT) {
+ const vm = this; // Functions
+
+ function handleError(name) {
+ return function (err) {
+ vm.errors[name] = err.data;
+ const toast = $mdToast.simple().textContent($rootScope.settings.formSubmitFailureMessage || 'Form submission error').toastClass('md-failure-toast').position('top');
+ $mdToast.show(toast);
+ };
+ }
+
+ function stopLoading() {
+ $rootScope.loading = false;
+ }
+
+ function onInit() {
+ console.debug('ClosingController::onInit() VISITOR', $rootScope.visitor);
+ $rootScope.status = 'closing'; // localStorageService setup
+
+ $q.all([RemoteStorageService.removeItem(STORAGE_VISITOR).then(() => console.debug('STORAGE_VISITOR cleared')).catch(RemoteStorageService.onStorageError), RemoteStorageService.removeItem(STORAGE_LAYOUT).then(() => console.debug('STORAGE_LAYOUT cleared')).catch(RemoteStorageService.onStorageError)]).then(() => $rootScope.loading = false);
+ }
+
+ function goToIfTime() {
+ if ($rootScope.settings.online) {
+ $state.go('app.online', null, {
+ location: 'replace'
+ });
+ } else {
+ $state.go('app.offline', null, {
+ location: 'replace'
+ });
+ }
+ }
+
+ function reset() {
+ vm.form = {};
+ vm.upColor = null;
+ vm.downColor = null;
+ vm.userForm.$setPristine();
+ vm.userForm.$setUntouched(); // Disable buttons
+
+ delete $rootScope.visitor.interaction; // rootScope setup
+
+ $rootScope.enableDownload = false;
+ }
+
+ function skip() {
+ reset();
+ goToIfTime();
+ }
+
+ function submit() {
+ $rootScope.loading = true;
+
+ if ($rootScope.visitor.interaction && $rootScope.visitor.interaction.id) {
+ api.chatInteraction.close(lodash_merge__WEBPACK_IMPORTED_MODULE_0___default()({
+ id: $rootScope.visitor.interaction.id,
+ ratingType: $rootScope.settings.ratingType,
+ customer: $rootScope.settings.customerAlias || $rootScope.visitor.from
+ }, vm.form)).$promise.then(function () {
+ delete vm.errors.submit;
+ const toast = $mdToast.simple().textContent($rootScope.settings.formSubmitSuccessMessage || 'Form properly submitted').toastClass('md-success-toast').parent(angular.element(document.querySelector('#chat-toolbar')));
+ $mdToast.show(toast);
+ }).then(reset).then(goToIfTime).catch(handleError('submit')).finally(stopLoading);
+ } else {
+ stopLoading();
+ handleError('submit');
+ }
+ } // Methods
+
+
+ vm.$onInit = onInit;
+ vm.submit = submit;
+ vm.skip = skip;
+ vm.form = {};
+ vm.errors = {};
+}
+
+
+
+/***/ }),
+
+/***/ "./src/js/common/remote-storage.service.js":
+/*!*************************************************!*\
+ !*** ./src/js/common/remote-storage.service.js ***!
+ \*************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "RemoteStorageService": () => (/* binding */ RemoteStorageService)
+/* harmony export */ });
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
+var _handleRemoteEvent = /*#__PURE__*/new WeakSet();
+
+var _parseJSON = /*#__PURE__*/new WeakSet();
+
+class RemoteStorageService {
+ /**
+ * @ngInject
+ * @param {angular.IWindowService} $window
+ * @param {angular.IRootScopeService} $rootScope
+ * @param {ng.IQService} $q
+ */
+ constructor($window, $rootScope, $q) {
+ _classPrivateMethodInitSpec(this, _parseJSON);
+
+ _classPrivateMethodInitSpec(this, _handleRemoteEvent);
+
+ this.remoteAddress = new URL($rootScope.settings.address).origin; // exclude path segment
+
+ this.location = $rootScope.settings.location;
+ this.$q = $q;
+ this.$window = $window;
+ }
+ /**
+ * Handle a remote invocation to localstorage
+ * @type {(action: 'setItem'|'getItem'|'removeItem', key: string, callback: (key: string, item?: any)) => (MessageEvent) => void} e
+ */
+
+
+ /**
+ * Send a postMessage event to save data on remote-managed (parent) localStorage
+ * @param {string} key localStorage key
+ * @param {*} value data to be sent
+ */
+ setItem(key, value) {
+ const action = 'setItem';
+ return this.$q(resolve => {
+ _classPrivateMethodGet(this, _handleRemoteEvent, _handleRemoteEvent2).call(this, action, key, () => {
+ resolve();
+ });
+
+ this.$window.parent.postMessage({
+ action,
+ key,
+ value
+ }, this.remoteAddress);
+ });
+ }
+ /**
+ * Send a postMessage event to read data from remote-managed (parent) localStorage
+ * @param {string} key localStorage key
+ */
+
+
+ getItem(key) {
+ const action = 'getItem';
+ return this.$q(resolve => {
+ _classPrivateMethodGet(this, _handleRemoteEvent, _handleRemoteEvent2).call(this, action, key, (k, item) => {
+ resolve(item);
+ });
+
+ this.$window.parent.postMessage({
+ action,
+ key
+ }, this.remoteAddress);
+ });
+ }
+ /**
+ * Send a postMessage event to remove data from remote-managed (parent) localStorage
+ * @param {string} key localStorage key
+ */
+
+
+ removeItem(key) {
+ const action = 'removeItem';
+ return this.$q(resolve => {
+ _classPrivateMethodGet(this, _handleRemoteEvent, _handleRemoteEvent2).call(this, action, key, () => {
+ resolve();
+ });
+
+ this.$window.parent.postMessage({
+ action,
+ key
+ }, this.remoteAddress);
+ });
+ }
+
+ /**
+ * Mimic old index.controller updateStorage method (but async)
+ * @param {string} key
+ * @param {Object} data
+ * @param {boolean} remove [remove=false]
+ */
+ updateStorage(key, data) {
+ let remove = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+ // get item
+ return this.getItem(key).then(item => {
+ const storage = _classPrivateMethodGet(this, _parseJSON, _parseJSON2).call(this, item) || {};
+
+ if (remove) {
+ delete storage[this.location];
+ } else {
+ storage[this.location] = data;
+ }
+
+ return this.setItem(key, storage).then(() => storage[this.location]);
+ });
+ }
+ /**
+ * Use this to log storage error in catch
+ * @param {Error} err
+ */
+
+
+ onStorageError(err) {
+ console.error('Storage Error', err);
+ }
+
+}
+
+RemoteStorageService.$inject = ["$window", "$rootScope", "$q"];
+
+function _handleRemoteEvent2(action, key, callback) {
+ // create a one-time listener which removes itself
+ const listener = e => {
+ const expectedAction = `${action}Result`;
+
+ if (e.origin === this.remoteAddress && key === e.data.key && expectedAction === e.data.action) {
+ const {
+ action,
+ item
+ } = e.data;
+ console.debug(`[Key = ${key}] Action "${action}" event from parent`, e);
+
+ switch (action) {
+ case 'setItemResult':
+ callback(key);
+ break;
+
+ case 'getItemResult':
+ callback(key, item);
+ break;
+
+ case 'removeItemResult':
+ callback(key);
+ break;
+
+ default:
+ console.debug('Unsupported action', action);
+ break;
+ } // Clear listener
+
+
+ this.$window.removeEventListener('message', listener, false);
+ }
+ };
+
+ this.$window.addEventListener('message', listener, false);
+}
+
+function _parseJSON2(stringData) {
+ let parsed = stringData;
+
+ if (typeof parsed === 'string') {
+ try {
+ parsed = JSON.parse(stringData);
+ } catch (error) {
+ console.warn(`Could not parse "${stringData}"`, error);
+ parsed = stringData;
+ }
+ }
+
+ return parsed;
+}
+
+
+
+/***/ }),
+
+/***/ "./src/js/index.controller.js":
+/*!************************************!*\
+ !*** ./src/js/index.controller.js ***!
+ \************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "IndexController": () => (/* binding */ IndexController)
+/* harmony export */ });
+/* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! moment */ "./node_modules/moment/moment.js");
+/* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(moment__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var lodash_map__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lodash.map */ "./node_modules/lodash.map/index.js");
+/* harmony import */ var lodash_map__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(lodash_map__WEBPACK_IMPORTED_MODULE_1__);
+IndexController.$inject = ["$rootScope", "$window", "$state", "$mdDialog", "$q", "RemoteStorageService", "api", "STORAGE_LAYOUT", "STORAGE_VISITOR", "$timeout"];
+
+
+/**
+ * @ngInject
+ * @param {ng.IRootScopeService} $rootScope
+ * @param {ng.IWindowService} $window
+ * @param {import('@uirouter/angularjs').StateService} $state
+ * @param {import('angular').material.IDialogService} $mdDialog
+ * @param {ng.IQService} $q
+ * @param {import('./common/remote-storage.service').RemoteStorageService} RemoteStorageService
+ * @param {ReturnType<typeof import('@js/index.factory').apiService>} api
+ * @param {'layout'} STORAGE_LAYOUT
+ * @param {'visitor'} STORAGE_VISITOR
+ * @param {ng.ITimeoutService} $timeout
+ */
+
+function IndexController($rootScope, $window, $state, $mdDialog, $q, RemoteStorageService, api, STORAGE_LAYOUT, STORAGE_VISITOR, $timeout) {
+ const vm = this; // Data
+ // Functions
+
+ function isOnline() {
+ var _$rootScope$visitor, _$rootScope$visitor$i;
+
+ const online = $rootScope.settings.online;
+ const visitor = $rootScope !== null && $rootScope !== void 0 && (_$rootScope$visitor = $rootScope.visitor) !== null && _$rootScope$visitor !== void 0 && (_$rootScope$visitor$i = _$rootScope$visitor.interaction) !== null && _$rootScope$visitor$i !== void 0 && _$rootScope$visitor$i.id ? true : false;
+ const exceeded = Number($rootScope.settings.maxInteractions) && Number($rootScope.settings.openedInteractions) >= Number($rootScope.settings.maxInteractions);
+
+ if (!(visitor || !exceeded && online)) {
+ return false;
+ }
+
+ return true;
+ }
+
+ function goToIfTime() {
+ $state.go(isOnline() ? 'app.online' : 'app.offline', null, {
+ location: 'replace'
+ });
+ }
+
+ function getHeaderShape() {
+ return $rootScope.settings.header_shape === 'rounded' ? '15px' : '0px';
+ }
+
+ function postMessage(cmd) {
+ $window.parent.postMessage({
+ cmd
+ }, '*');
+ }
+ /**
+ * Toggle expand/collapsed
+ * @param {boolean} [up]
+ */
+
+
+ function toggle(up) {
+ // $rootScope.layout.up = up
+ RemoteStorageService.updateStorage(STORAGE_LAYOUT, {
+ up
+ }).then(value => {
+ $rootScope.layout = value;
+ postMessage(up === true ? 'show' : 'hide');
+ $timeout(() => {
+ $rootScope.$apply();
+ });
+ }).catch(RemoteStorageService.onStorageError);
+ }
+
+ function close() {
+ const interaction = $rootScope.visitor.interaction;
+
+ if (interaction && interaction.id) {
+ // Appending dialog to document.body to cover sidenav in docs app
+ const confirm = $mdDialog.confirm().parent(angular.element(document.querySelector('#chat-app'))).clickOutsideToClose(true).title($rootScope.settings.closingQuestion || 'Do you want to close the interaction?').ok('Ok').cancel('Cancel');
+ $mdDialog.show(confirm).then(function () {
+ return api.chatInteraction.customUpdate({
+ id: interaction.id,
+ closed: true,
+ closeReason: 'contact' // closedAt: moment().format('YYYY-MM-DD HH:mm:ss'),
+
+ }).$promise;
+ }).then(function () {
+ $state.go('app.closing', null, {
+ location: 'replace'
+ });
+ }).catch(function (err) {
+ console.error('keep open', err);
+ });
+ }
+ }
+
+ function
+ /* $event */
+ download() {
+ const deferred = $q.defer();
+ const interaction = $rootScope.visitor.interaction;
+
+ if (interaction && interaction.id) {
+ api.chatInteraction.getMessages({
+ intid: interaction.id,
+ includeAll: true
+ }).$promise.then(function (data) {
+ deferred.resolve(lodash_map__WEBPACK_IMPORTED_MODULE_1___default()(data.rows.slice(1), function (row) {
+ let sender;
+
+ if (row.direction === 'in') {
+ sender = $rootScope.settings.customerAlias || $rootScope.visitor.from || 'Visitor' + row.ContactId;
+ }
+
+ if (row.direction === 'out') {
+ switch ($rootScope.settings.agentIdentifier) {
+ case 'website_alias':
+ sender = row.UserId ? $rootScope.settings.agentAlias + row.UserId : 'System';
+ break;
+
+ case 'agent_alias':
+ sender = row.UserId ? row.User.alias || row.User.fullname : 'System';
+ break;
+
+ case 'agent_fullname':
+ sender = row.UserId ? row.User.fullname : 'System';
+ break;
+
+ default:
+ sender = row.UserId ? $rootScope.settings.agentAlias + row.UserId : 'System';
+ break;
+ }
+ }
+
+ return {
+ sender: sender,
+ message: row.body,
+ createdAt: moment__WEBPACK_IMPORTED_MODULE_0___default()(row.createdAt).format('MM/DD/YYYY HH:mm:ss')
+ };
+ }));
+ }).catch(function (err) {
+ console.error(err);
+ });
+ }
+
+ return deferred.promise;
+ }
+
+ function onInit() {
+ console.debug('IndexController::onInit() VISITOR', $rootScope.visitor);
+ $rootScope.status = 'init';
+ const div_color = $rootScope.settings.color;
+ const text_color = $rootScope.settings.textColor;
+ const text_button_color = $rootScope.settings.textButtonColor || $rootScope.settings.textColor;
+ const button_color = $rootScope.settings.color_button;
+ const background_color = $rootScope.settings.backgroundColor;
+ const client_height = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
+ const client_width = document.documentElement.clientWidth; // Set some css variables for the theme
+
+ document.documentElement.style.setProperty('--xc-ws-div-color', div_color);
+ document.documentElement.style.setProperty('--xc-ws-text-color', text_color);
+ document.documentElement.style.setProperty('--xc-ws-text-button-color', text_button_color);
+ document.documentElement.style.setProperty('--xc-ws-button-color', button_color);
+ document.documentElement.style.setProperty('--xc-ws-background-color', background_color);
+ document.documentElement.style.setProperty('--xc-ws-client-height', client_height);
+ document.documentElement.style.setProperty('--xc-ws-client-width', client_width);
+ let tg = false;
+
+ const getStoredValueWithLocation = value => {
+ return value !== null && value[$rootScope.location] || {};
+ };
+
+ const visitorStoragePromise = RemoteStorageService.getItem(STORAGE_VISITOR).then(getStoredValueWithLocation);
+ const layoutStoragePromise = RemoteStorageService.getItem(STORAGE_LAYOUT).then(getStoredValueWithLocation);
+ $q.all([visitorStoragePromise, layoutStoragePromise]).then(_ref => {
+ let [visitorValue, layoutValue] = _ref;
+ $rootScope.visitor = visitorValue;
+ $rootScope.layout = layoutValue;
+
+ if ($rootScope.visitor.interaction && $rootScope.layout.up) {
+ tg = true;
+ } else {
+ $rootScope.layout.up = true;
+ }
+
+ if ($rootScope.settings.alignment === 'bottom_right') {
+ toggle(tg);
+ }
+
+ goToIfTime(); // checks whether to show or hide chat tab if hide when offline
+
+ let cmd = '';
+
+ if ($rootScope.settings.online || !$rootScope.settings.hideWhenOffline) {
+ cmd = 'init';
+ } else {
+ cmd = 'offline';
+ }
+
+ $window.parent.postMessage({
+ cmd,
+ div_color,
+ text_color,
+ client_height,
+ client_width
+ }, '*');
+ const style = document.createElement('style');
+ document.head.appendChild(style);
+ style.sheet.insertRule('.mdi-send:before {color:' + $rootScope.settings.color + '!important}');
+ }).catch(RemoteStorageService.onStorageError);
+ } // Methods
+
+
+ vm.$onInit = onInit;
+ vm.close = close;
+ vm.toggle = toggle;
+ vm.download = download;
+ vm.getHeaderShape = getHeaderShape;
+ const CHAT_STATUSES = {
+ online: ['online', 'chat', 'waiting', 'closing', 'unmanaged'],
+ offline: ['offline']
+ }; // Define a getter property on the $rootScope property -> $rootScope.actualTitle
+ // that changes according to $rootScope.settings.defaultTitle, $rootScope.status and
+ // takes values from $rootScope.status.header_online and $rootScope.status.header_offline
+
+ Object.defineProperty($rootScope, 'actualTitle', {
+ get() {
+ let result = $rootScope.settings.defaultTitle;
+
+ if (CHAT_STATUSES.online.includes($rootScope.status)) {
+ result = $rootScope.settings.header_online;
+ } else if (CHAT_STATUSES.offline.includes($rootScope.status)) {
+ result = $rootScope.settings.header_offline;
+ }
+
+ return result;
+ }
+
+ });
+ window.addEventListener('message', function (evt) {
+ if (evt.data.evt === 'show') {
+ toggle(true);
+ } else if (evt.data.evt === 'hide') {
+ toggle(false);
+ }
+ }, false);
+}
+
+
+
+/***/ }),
+
+/***/ "./src/js/index.factory.js":
+/*!*********************************!*\
+ !*** ./src/js/index.factory.js ***!
+ \*********************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "apiService": () => (/* binding */ apiService)
+/* harmony export */ });
+apiService.$inject = ["$rootScope", "$resource"];
+
+/**
+ * @ngInject
+ * @param {ng.IRootScopeService} $rootScope
+ * @param {ng.resource.IResourceService} $resource
+ */
+function apiService($rootScope, $resource) {
+ const paramDefaults = {
+ id: '@id',
+ token: $rootScope.settings.token
+ };
+ const api = {};
+ api.baseUrl = $rootScope.settings.remote + '/api/';
+ api.chatWebsite = $resource(api.baseUrl + 'chat/websites/:id', paramDefaults, {
+ notify: {
+ method: 'POST',
+ url: api.baseUrl + 'chat/websites/:id/notify'
+ },
+ offline: {
+ method: 'POST',
+ url: api.baseUrl + 'chat/websites/:id/offline'
+ },
+ getFields: {
+ method: 'GET',
+ url: api.baseUrl + 'chat/websites/:id/fields'
+ }
+ });
+ api.chatInteraction = $resource(api.baseUrl + 'chat/interactions/:id', paramDefaults, {
+ update: {
+ method: 'PUT',
+ url: api.baseUrl + 'chat/interactions/:id'
+ },
+ customUpdate: {
+ method: 'PUT',
+ url: api.baseUrl + 'chat/interactions/:id/custom_update'
+ },
+ close: {
+ method: 'PUT',
+ url: api.baseUrl + 'chat/interactions/:id/close'
+ },
+ getMessages: {
+ method: 'GET',
+ url: api.baseUrl + 'chat/interactions/:intid/my_messages'
+ },
+ uploadAttachment: {
+ method: 'POST',
+ url: api.baseUrl + 'chat/interactions/:id/attachment_upload',
+ headers: {
+ 'Content-Type': undefined
+ },
+ transformRequest: angular.identity
+ },
+ downloadAttachment: {
+ method: 'GET',
+ url: api.baseUrl + 'chat/interactions/:id/attachment_download'
+ },
+ abandon: {
+ method: 'PUT',
+ url: api.baseUrl + 'chat/interactions/:id/abandon'
+ }
+ });
+ api.chatMessage = $resource(api.baseUrl + 'chat/messages/:id', paramDefaults, {
+ update: {
+ method: 'PUT',
+ url: api.baseUrl + 'chat/messages/:id'
+ }
+ });
+ return api;
+}
+
+
+
+/***/ }),
+
+/***/ "./src/js/index.module.js":
+/*!********************************!*\
+ !*** ./src/js/index.module.js ***!
+ \********************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var angular_animate__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! angular-animate */ "./node_modules/angular-animate/index.js");
+/* harmony import */ var angular_animate__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(angular_animate__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var angular_aria__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! angular-aria */ "./node_modules/angular-aria/index.js");
+/* harmony import */ var angular_aria__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(angular_aria__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var angular_messages__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! angular-messages */ "./node_modules/angular-messages/index.js");
+/* harmony import */ var angular_messages__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(angular_messages__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var angular_material__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! angular-material */ "./node_modules/angular-material/index.js");
+/* harmony import */ var angular_material__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(angular_material__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var angular_resource__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! angular-resource */ "./node_modules/angular-resource/index.js");
+/* harmony import */ var angular_resource__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(angular_resource__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var angular_sanitize__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! angular-sanitize */ "./node_modules/angular-sanitize/index.js");
+/* harmony import */ var angular_sanitize__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(angular_sanitize__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var ng_csv__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ng-csv */ "./node_modules/ng-csv/build/ng-csv.min.js");
+/* harmony import */ var ng_csv__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(ng_csv__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var ng_embed__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ng-embed */ "./node_modules/ng-embed/src/ng-embed.js");
+/* harmony import */ var ng_embed__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(ng_embed__WEBPACK_IMPORTED_MODULE_7__);
+/* harmony import */ var _uirouter_angularjs__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @uirouter/angularjs */ "./node_modules/@uirouter/angularjs/lib-esm/index.js");
+/* harmony import */ var angular_local_storage__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! angular-local-storage */ "./node_modules/angular-local-storage/index.js");
+/* harmony import */ var angular_local_storage__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(angular_local_storage__WEBPACK_IMPORTED_MODULE_9__);
+/* harmony import */ var angular_rateit__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! angular-rateit */ "./node_modules/angular-rateit/dist/ng-rateit.js");
+/* harmony import */ var angular_rateit__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(angular_rateit__WEBPACK_IMPORTED_MODULE_10__);
+/* harmony import */ var _flowjs_ng_flow__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! @flowjs/ng-flow */ "./node_modules/@flowjs/ng-flow/dist/ng-flow.js");
+/* harmony import */ var _flowjs_ng_flow__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(_flowjs_ng_flow__WEBPACK_IMPORTED_MODULE_11__);
+/* harmony import */ var emojionearea__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! emojionearea */ "./node_modules/emojionearea/dist/emojionearea.js");
+/* harmony import */ var emojionearea__WEBPACK_IMPORTED_MODULE_12___default = /*#__PURE__*/__webpack_require__.n(emojionearea__WEBPACK_IMPORTED_MODULE_12__);
+/* harmony import */ var jquery_textcomplete__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! jquery-textcomplete */ "./node_modules/jquery-textcomplete/dist/jquery.textcomplete.js");
+/* harmony import */ var jquery_textcomplete__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(jquery_textcomplete__WEBPACK_IMPORTED_MODULE_13__);
+/* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! moment */ "./node_modules/moment/moment.js");
+/* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(moment__WEBPACK_IMPORTED_MODULE_14__);
+/* harmony import */ var _index_controller__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./index.controller */ "./src/js/index.controller.js");
+/* harmony import */ var _index_route__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./index.route */ "./src/js/index.route.js");
+/* harmony import */ var _closing_closing_controller__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./closing/closing.controller */ "./src/js/closing/closing.controller.js");
+/* harmony import */ var _index_factory__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./index.factory */ "./src/js/index.factory.js");
+/* harmony import */ var _chat_chat_controller__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./chat/chat.controller */ "./src/js/chat/chat.controller.js");
+/* harmony import */ var _offline_offline_controller__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./offline/offline.controller */ "./src/js/offline/offline.controller.js");
+/* harmony import */ var _online_online_controller__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./online/online.controller */ "./src/js/online/online.controller.js");
+/* harmony import */ var _unmanaged_unmanaged_controller__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./unmanaged/unmanaged.controller */ "./src/js/unmanaged/unmanaged.controller.js");
+/* harmony import */ var _waiting_waiting_controller__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./waiting/waiting.controller */ "./src/js/waiting/waiting.controller.js");
+/* harmony import */ var _common_remote_storage_service__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./common/remote-storage.service */ "./src/js/common/remote-storage.service.js");
+toTrustedFilter.$inject = ["$sce"];
+// JavaScript code
+
+
+
+
+
+
+
+
+
+
+
+
+ // TODO check IF/WHERE used, and upgrade to https://github.com/yuku/textcomplete
+// see https://www.npmjs.com/package/jquery-textcomplete
+
+
+
+
+
+
+
+
+
+
+
+
+
+/** @ngInject */
+
+function toTrustedFilter($sce) {
+ return function (value) {
+ return $sce.trustAsHtml(value);
+ };
+}
+/** @ngInject */
+
+
+function printDirective() {
+ function printElement(elem, scope) {
+ // clones the element you want to print
+ const div = document.createElement('div');
+ const visitor = scope.visitor;
+ const settings = scope.settings;
+ let startTime;
+
+ for (let i = 0; i < scope.messages.length; i++) {
+ const message = scope.messages[i];
+ let sender = 'Sender: ';
+ const body = 'Message: ' + message.body;
+ const sentAt = 'Sent At: ' + moment__WEBPACK_IMPORTED_MODULE_14___default()(message.createdAt).format('YYYY-MM-DD HH:mm:ss');
+
+ if (i === 0) {
+ startTime = message.createdAt;
+ continue;
+ }
+
+ switch (scope.settings.agentIdentifier) {
+ case 'website_alias':
+ sender += message.direction === 'out' ? message.UserId ? settings.agentAlias + message.UserId : 'System' : settings.customerAlias || visitor.from || 'Visitor' + message.ContactId;
+ break;
+
+ case 'agent_alias':
+ sender += message.direction === 'out' ? message.UserId ? message.User.alias || message.User.fullname : 'System' : settings.customerAlias || visitor.from || 'Visitor' + message.ContactId;
+ break;
+
+ case 'agent_fullname':
+ sender += message.direction === 'out' ? message.UserId ? message.User.fullname : 'System' : settings.customerAlias || visitor.from || 'Visitor' + message.ContactId;
+ break;
+
+ default:
+ sender += message.direction === 'out' ? message.UserId ? (settings.agentAlias || 'Agent') + message.UserId : 'System' : settings.customerAlias || visitor.from || 'Visitor' + message.ContactId;
+ }
+
+ div.appendChild(document.createTextNode(sender));
+ div.appendChild(document.createElement('br'));
+ div.appendChild(document.createTextNode(body));
+ div.appendChild(document.createElement('br'));
+ div.appendChild(document.createTextNode(sentAt));
+ div.appendChild(document.createElement('br'));
+ div.appendChild(document.createElement('br'));
+ }
+
+ const myWindow = window.open();
+ myWindow.document.write('<html><head><title>' + document.title + '</title>');
+ myWindow.document.write('</head><body >');
+ myWindow.document.write('<h3> Website: ' + settings.referer + '</h3>');
+ myWindow.document.write('<h3> Start Time: ' + moment__WEBPACK_IMPORTED_MODULE_14___default()(startTime).format('YYYY-MM-DD HH:mm:ss') + '</h3>');
+ myWindow.document.write('<h3> Print Time: ' + moment__WEBPACK_IMPORTED_MODULE_14___default()().format('YYYY-MM-DD HH:mm:ss') + '</h3>');
+ myWindow.document.write(div.innerHTML);
+ myWindow.document.write('</body></html>');
+ myWindow.document.close(); // necessary for IE >= 10
+
+ myWindow.focus(); // necessary for IE >= 10*/
+
+ myWindow.print();
+ myWindow.close();
+ }
+
+ function link(scope, element
+ /* , attrs */
+ ) {
+ element.on('click', function () {
+ const elemToPrint = document.getElementById('chatContent1');
+
+ if (elemToPrint) {
+ printElement(elemToPrint, scope);
+ }
+ });
+ }
+
+ return {
+ link: link,
+ restrict: 'A'
+ };
+}
+/** @ngInject */
+
+
+function ngEnter() {
+ return function (scope, element, attrs) {
+ element.bind('keydown keypress', function (event) {
+ if (event.which === 13) {
+ scope.$apply(function () {
+ scope.$eval(attrs.ngEnter);
+ });
+ event.preventDefault();
+ }
+ });
+ };
+} // const APP_NAME = 'motion-chat'
+
+
+const MODULE_NAME = 'motion-chat';
+angular.module(MODULE_NAME, ['ngAnimate', 'ngAria', 'ngMessages', 'ngMaterial', 'ngResource', 'ngSanitize', 'ngCsv', 'ngEmbed', 'ui.router', 'LocalStorageModule', 'ngRateIt', 'flow']).filter('toTrusted', toTrustedFilter).constant('STORAGE_PREFIX', 'motion_chat').constant('STORAGE_VISITOR', 'visitor').constant('STORAGE_LAYOUT', 'layout').service('RemoteStorageService', _common_remote_storage_service__WEBPACK_IMPORTED_MODULE_24__.RemoteStorageService).directive('ngEnter', ngEnter).directive('ngPrint', printDirective) // from chat/index.controller
+.controller('ChatController', _chat_chat_controller__WEBPACK_IMPORTED_MODULE_19__.ChatController) // from closing/index.controller
+.controller('ClosingController', _closing_closing_controller__WEBPACK_IMPORTED_MODULE_17__.ClosingController) // from old index.controller.js
+.config(["$mdGestureProvider", function ($mdGestureProvider) {
+ $mdGestureProvider.skipClickHijack();
+}]).controller('IndexController', _index_controller__WEBPACK_IMPORTED_MODULE_15__.IndexController) // from index.factory.js
+.factory('api', _index_factory__WEBPACK_IMPORTED_MODULE_18__.apiService) // from index.route.js
+.config(_index_route__WEBPACK_IMPORTED_MODULE_16__.routeConfig).run(_index_route__WEBPACK_IMPORTED_MODULE_16__.routeRun) // from offline/index.controller
+.controller('OfflineController', _offline_offline_controller__WEBPACK_IMPORTED_MODULE_20__.OfflineController) // from online/index.controller
+.config(["$mdGestureProvider", function ($mdGestureProvider) {
+ $mdGestureProvider.skipClickHijack();
+}]).controller('OnlineController', _online_online_controller__WEBPACK_IMPORTED_MODULE_21__.OnlineController) // from unmanaged/index.controller
+.controller('UnmanagedController', _unmanaged_unmanaged_controller__WEBPACK_IMPORTED_MODULE_22__.UnmanagedController) // from waiting/index.controller
+.controller('WaitingController', _waiting_waiting_controller__WEBPACK_IMPORTED_MODULE_23__.WaitingController); // // Start app
+// angular.element(() => {
+// angular.bootstrap(document, APP_NAME, { strictDi: true })
+// })
+
+/***/ }),
+
+/***/ "./src/js/index.route.js":
+/*!*******************************!*\
+ !*** ./src/js/index.route.js ***!
+ \*******************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "routeRun": () => (/* binding */ routeRun),
+/* harmony export */ "routeConfig": () => (/* binding */ routeConfig)
+/* harmony export */ });
+/* harmony import */ var lodash_forin__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lodash.forin */ "./node_modules/lodash.forin/index.js");
+/* harmony import */ var lodash_forin__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lodash_forin__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var lodash_isnil__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lodash.isnil */ "./node_modules/lodash.isnil/index.js");
+/* harmony import */ var lodash_isnil__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(lodash_isnil__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _chat_chat_tpl_html__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./chat/chat.tpl.html */ "./src/js/chat/chat.tpl.html");
+/* harmony import */ var _closing_closing_tpl_html__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./closing/closing.tpl.html */ "./src/js/closing/closing.tpl.html");
+/* harmony import */ var _offline_offline_tpl_html__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./offline/offline.tpl.html */ "./src/js/offline/offline.tpl.html");
+/* harmony import */ var _online_online_tpl_html__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./online/online.tpl.html */ "./src/js/online/online.tpl.html");
+/* harmony import */ var _unmanaged_unmanaged_tpl_html__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./unmanaged/unmanaged.tpl.html */ "./src/js/unmanaged/unmanaged.tpl.html");
+/* harmony import */ var _waiting_waiting_tpl_html__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./waiting/waiting.tpl.html */ "./src/js/waiting/waiting.tpl.html");
+routeConfig.$inject = ["$stateProvider", "$locationProvider", "$httpProvider", "localStorageServiceProvider", "STORAGE_PREFIX"];
+routeRun.$inject = ["$rootScope", "$location"];
+
+
+
+
+
+
+
+
+/** @ngInject */
+
+function routeRun($rootScope, $location) {
+ // Get query params
+ const params = $location.search(); // Setup settings object
+
+ $rootScope.settings = {
+ cursor: 'pointer',
+ hide: true
+ };
+
+ lodash_forin__WEBPACK_IMPORTED_MODULE_0___default()(params, function (value, key) {
+ if (value !== '' && !lodash_isnil__WEBPACK_IMPORTED_MODULE_1___default()(value)) {
+ if (value === 'true') {
+ value = true;
+ }
+
+ if (value === 'false') {
+ value = false;
+ }
+
+ $rootScope.settings[key] = value;
+ }
+ });
+
+ $rootScope.location = $rootScope.settings.location;
+ $rootScope.layout = {
+ up: false
+ };
+ $rootScope.visitor = {};
+}
+/** @ngInject
+ *
+ * @param {StateProvider} $stateProvider
+ * @param {*} $locationProvider
+ * @param {*} $httpProvider
+ * @param {*} localStorageServiceProvider
+ * @param {*} STORAGE_PREFIX
+ */
+
+
+function routeConfig($stateProvider, $locationProvider, $httpProvider, localStorageServiceProvider, STORAGE_PREFIX) {
+ $locationProvider.html5Mode(true); // initialize get if not there
+
+ if (!$httpProvider.defaults.headers.get) {
+ $httpProvider.defaults.headers.get = {};
+ } // disable IE ajax request caching
+
+
+ $httpProvider.defaults.headers.get['If-Modified-Since'] = 'Mon, 26 Jul 1997 05:00:00 GMT'; // extra
+
+ $httpProvider.defaults.headers.get['Cache-Control'] = 'no-cache';
+ $httpProvider.defaults.headers.get.Pragma = 'no-cache'; // Local Storage Provider
+
+ localStorageServiceProvider.setPrefix(STORAGE_PREFIX); // State definitions
+
+ $stateProvider.state('app', {
+ abstract: true
+ }).state('app.waiting', {
+ url: '/waiting',
+ templateUrl: _waiting_waiting_tpl_html__WEBPACK_IMPORTED_MODULE_7__,
+ // '/waiting/index.tpl.html',
+ controller: 'WaitingController as vm'
+ }).state('app.online', {
+ url: '/online',
+ templateUrl: _online_online_tpl_html__WEBPACK_IMPORTED_MODULE_5__,
+ controller: 'OnlineController as vm'
+ }).state('app.offline', {
+ url: '/offline',
+ templateUrl: _offline_offline_tpl_html__WEBPACK_IMPORTED_MODULE_4__,
+ controller: 'OfflineController as vm'
+ }).state('app.chat', {
+ url: '/chat',
+ templateUrl: _chat_chat_tpl_html__WEBPACK_IMPORTED_MODULE_2__,
+ controller: 'ChatController as vm'
+ }).state('app.unmanaged', {
+ url: '/unmanaged',
+ templateUrl: _unmanaged_unmanaged_tpl_html__WEBPACK_IMPORTED_MODULE_6__,
+ controller: 'UnmanagedController as vm'
+ }).state('app.closing', {
+ url: '/closing',
+ templateUrl: _closing_closing_tpl_html__WEBPACK_IMPORTED_MODULE_3__,
+ controller: 'ClosingController as vm'
+ });
+}
+
+
+
+/***/ }),
+
+/***/ "./src/js/offline/offline.controller.js":
+/*!**********************************************!*\
+ !*** ./src/js/offline/offline.controller.js ***!
+ \**********************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "OfflineController": () => (/* binding */ OfflineController)
+/* harmony export */ });
+/* harmony import */ var lodash_isnil__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lodash.isnil */ "./node_modules/lodash.isnil/index.js");
+/* harmony import */ var lodash_isnil__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lodash_isnil__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var lodash_merge__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lodash.merge */ "./node_modules/lodash.merge/index.js");
+/* harmony import */ var lodash_merge__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(lodash_merge__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var lodash_random__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! lodash.random */ "./node_modules/lodash.random/index.js");
+/* harmony import */ var lodash_random__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(lodash_random__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! lodash.clonedeep */ "./node_modules/lodash.clonedeep/index.js");
+/* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var json_form_data__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! json-form-data */ "./node_modules/json-form-data/src/jsonToFormData.js");
+/* harmony import */ var json_form_data__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(json_form_data__WEBPACK_IMPORTED_MODULE_4__);
+OfflineController.$inject = ["$scope", "$rootScope", "$sce", "api", "$mdToast", "$element", "$http"];
+
+
+
+
+
+const MB = 1024 * 1024;
+/**
+ * @ngInject
+ * @param {ng.IScope} $scope
+ * @param {ng.IRootScopeService} $rootScope
+ * @param {ReturnType<typeof import('@js/index.factory').apiService>} api
+ * @param {import('angular').material.IToastService} $mdToast
+ * @param {JQLite} $element
+ * @param {ng.IHttpService} $http
+ */
+
+function OfflineController($scope, $rootScope, $sce, api, $mdToast, $element, $http) {
+ const vm = this;
+ let fromKey = null;
+ let initialFields = null;
+ $rootScope.typeField = '';
+ const optJsonFormData = {
+ showLeafArrayIndexes: true,
+ includeNullValues: false,
+ mapping: function (value) {
+ if (typeof value === 'boolean') {
+ return +value ? '1' : '0';
+ }
+
+ return value;
+ }
+ };
+
+ vm.trustAsHtml = function (string) {
+ return $sce.trustAsHtml(string);
+ };
+
+ function getAnonymous() {
+ return 'Anonymous' + lodash_random__WEBPACK_IMPORTED_MODULE_2___default()(1, 1000000);
+ } // Stop loader
+
+
+ function stopLoading() {
+ $rootScope.loading = false;
+ }
+
+ function onInit() {
+ console.debug('OfflineController::onInit() VISITOR', $rootScope.visitor);
+ $rootScope.status = 'offline'; // NOTE: init visitor form
+
+ vm.visitor = {
+ id: $rootScope.settings.id,
+ mapKeyOffline: 'firstName',
+ from: getAnonymous()
+ };
+ $rootScope.settings.showMenu = false;
+ $rootScope.loading = false;
+ api.chatWebsite.getFields({
+ id: $rootScope.settings.id,
+ online: false
+ }).$promise.then(function (data) {
+ if (data.count) {
+ fromKey = data.fromKey;
+ initialFields = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3___default()(data.rows);
+ vm.fields = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3___default()(initialFields);
+ }
+ }).then(function () {
+ for (let i = 0; i < vm.fields.length; i++) {
+ const field = vm.fields[i];
+ $rootScope.typeField += field.type;
+
+ if (typeof field.props !== 'undefined') {
+ if (field.props.helpText) {
+ const isHTML = RegExp.prototype.test.bind(/(<([^>]+)>)/i);
+ vm.checkHTML[i] = isHTML(field.props.helpText);
+ }
+ }
+ }
+ }).catch(function (err) {
+ console.error(err);
+ });
+ } // Functions
+
+
+ function handleError(name) {
+ if (name === 'INVALID_FORM') {
+ return function () {
+ vm.form['invalid'] = true;
+ const toast = $mdToast.simple().textContent($rootScope.settings.formSubmitErrorMessage || 'Form invalid!').toastClass('md-error-toast').parent(angular.element(document.querySelector('#chat-toolbar')));
+ $mdToast.show(toast);
+ };
+ } else {
+ return function (err) {
+ const toast = $mdToast.simple().textContent($rootScope.settings.formSubmitFailureMessage || 'Form submission error').toastClass('md-failure-toast').parent(angular.element(document.querySelector('#chat-toolbar')));
+ $mdToast.show(toast);
+ vm.errors[name] = err.data;
+ };
+ }
+ }
+ /**
+ * Upload using form data
+ * @param {Object} payload a JS object with the contents to be sent
+ */
+
+
+ function upload(payload) {
+ return $http({
+ url: `${api.baseUrl}chat/websites/${payload.id}/offline`,
+ headers: {
+ 'Content-Type': undefined
+ },
+ data: json_form_data__WEBPACK_IMPORTED_MODULE_4___default()(payload, { ...optJsonFormData,
+ initialFormData: new FormData()
+ }),
+ method: 'POST'
+ });
+ }
+
+ function onSubmitSuccess() {
+ delete vm.errors.submit;
+ $rootScope.$emit('hide'); // Reset stuff
+ // Clear upload fields
+
+ vm.fields = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3___default()(initialFields); // Clear rest
+
+ vm.form = {};
+ vm.userForm.$setPristine();
+ vm.userForm.$setUntouched();
+ const toast = $mdToast.simple().textContent($rootScope.settings.formSubmitSuccessMessage || 'Form properly submitted').toastClass('md-success-toast').parent(angular.element(document.querySelector('#chat-toolbar')));
+ $mdToast.show(toast);
+ }
+ /**
+ * Submit JSON
+ */
+
+
+ function submit() {
+ // set loading
+ $rootScope.loading = true; // Let's make a copy of the data
+
+ const data = { ...vm.form
+ };
+
+ for (let i = 0; i < vm.fields.length; i++) {
+ const field = vm.fields[i];
+
+ if (field.props && typeof data[field.props.title] !== 'undefined') {
+ // set cmField
+ if (!lodash_isnil__WEBPACK_IMPORTED_MODULE_0___default()(field.cmField)) {
+ vm.visitor[field.cmField] = Array.isArray(data[field.props.title]) ? data[field.props.title].join() : data[field.props.title];
+ }
+
+ if (i === fromKey) {
+ if (!lodash_isnil__WEBPACK_IMPORTED_MODULE_0___default()($rootScope.settings.mapKeyOffline)) {
+ vm.visitor.mapKeyOffline = $rootScope.settings.mapKeyOffline;
+ vm.visitor.from = Array.isArray(data[field.props.title]) ? data[field.props.title].join() : data[field.props.title];
+ }
+ }
+
+ if (field.type === 'upload') {
+ data[field.props.title] = data[field.props.title].map(prop => prop.file);
+ }
+ }
+ }
+
+ const uploadFields = Array.isArray(vm.fields) ? vm.fields.filter(field => field.type === 'upload') : [];
+
+ const payLoad = lodash_merge__WEBPACK_IMPORTED_MODULE_1___default()({
+ body: data
+ }, vm.visitor);
+
+ const isFormDataPayload = data != null && uploadFields.length > 0;
+ const isJsonPayload = data !== null && JSON.stringify(data) !== '{}';
+ const submitPromise = isFormDataPayload ? upload(payLoad) : isJsonPayload ? api.chatWebsite.offline(payLoad).$promise : Promise.reject('INVALID_FORM');
+ submitPromise.then(onSubmitSuccess).catch(handleError('submit')).finally(() => {
+ if (!vm.form.invalid) {
+ vm.form = {};
+ }
+
+ stopLoading();
+ });
+ }
+
+ function toggle(name, item) {
+ if (!vm.form[name]) {
+ vm.form[name] = [];
+ }
+
+ const idx = vm.form[name].indexOf(item);
+
+ if (idx > -1) {
+ vm.form[name].splice(idx, 1);
+ } else {
+ vm.form[name].push(item);
+ }
+ }
+
+ function exists(name, item) {
+ if (!vm.form[name]) {
+ vm.form[name] = [];
+ }
+
+ return vm.form[name].indexOf(item) > -1;
+ }
+ /**
+ *
+ * @param {number} index
+ */
+
+
+ function initUploadButton(index) {
+ // vm.fields contains the configuration
+ const formItem = vm.fields[index];
+ const uploadItem = $element.find('.upload-item');
+
+ if (uploadItem.length) {
+ const button = angular.element(uploadItem[0].querySelector('.upload-button'));
+ const input = angular.element(uploadItem[0].querySelector('input[type=file]'));
+ const label = button.find('label');
+
+ if (label.length) {
+ label.css('display', 'none');
+ }
+
+ button.on('click', () => {
+ label.css('display', 'none');
+ typeof input.trigger === 'function' ? input.trigger('click') : input[0].click();
+ });
+ input.on('change', e => {
+ $scope.$apply(function () {
+ if (typeof formItem.props.error === 'string') {
+ formItem.props.error = null;
+ }
+ /**
+ * @type {File[]}
+ */
+
+
+ const files = Array.from(e.target.files); // Max allowed size in MB
+
+ const maxSizeMB = formItem.config.size * MB;
+ const exceedsSize = files.some(file => file.size >= maxSizeMB);
+
+ if (exceedsSize) {
+ // const label = button.find('label')
+ // label.css('display', 'block')
+ // label.text(formItem.config.sizeErrMessage)
+ formItem.options = [];
+ formItem.props.error = formItem.config.sizeErrMessage;
+ } else {
+ formItem.options = files.map(file => {
+ const {
+ name,
+ size,
+ type
+ } = file;
+ return {
+ name,
+ size,
+ type,
+ file
+ };
+ });
+ }
+
+ vm.form[formItem.props.title] = formItem.options;
+ });
+ });
+ }
+ }
+
+ vm.initUploadButton = initUploadButton;
+ /**
+ *
+ * @param {{options: Array<any>, config: Array<any>}} formItem
+ * @param {number} index
+ */
+
+ function removeFileItem(formItem, index) {
+ // vm.fields contains the configuration
+ // const formItem = vm.fields[index]
+ formItem.options.splice(index, 1);
+ vm.form[formItem.props.title] = formItem.options;
+ }
+
+ vm.removeFileItem = removeFileItem;
+ /**
+ *
+ * @param {{options: Array<any>, config: Array<any>}} formItem
+ */
+
+ function setupFileInput(formItem) {
+ console.log('form item setup', formItem);
+ const uploadItem = $element.find('.upload-item');
+ const input = angular.element(uploadItem[0].querySelector('input[type=file]'));
+ const {
+ multipleUpload,
+ accept
+ } = formItem.config;
+
+ if (multipleUpload) {
+ input.attr('multiple', 'multiple');
+ }
+
+ if (accept) {
+ input[0].setAttribute('accept', accept);
+ }
+ }
+
+ vm.setupFileInput = setupFileInput;
+
+ function makeFileOptionsVisible() {
+ const fileOpts = Array.from($element.find('.filename-label'));
+ const lastOpt = fileOpts[fileOpts.length - 1];
+
+ if (lastOpt && lastOpt.scrollIntoView) {
+ lastOpt.scrollIntoView();
+ }
+ }
+
+ vm.makeFileOptionsVisible = makeFileOptionsVisible; // Methods
+
+ vm.$onInit = onInit;
+ vm.submit = submit;
+ vm.toggle = toggle;
+ vm.exists = exists;
+ vm.checkHTML = [];
+ vm.form = {};
+ vm.errors = {};
+ vm.userForm = {};
+}
+
+
+
+/***/ }),
+
+/***/ "./src/js/online/online.controller.js":
+/*!********************************************!*\
+ !*** ./src/js/online/online.controller.js ***!
+ \********************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "OnlineController": () => (/* binding */ OnlineController)
+/* harmony export */ });
+/* harmony import */ var lodash_isnil__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lodash.isnil */ "./node_modules/lodash.isnil/index.js");
+/* harmony import */ var lodash_isnil__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lodash_isnil__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var lodash_merge__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lodash.merge */ "./node_modules/lodash.merge/index.js");
+/* harmony import */ var lodash_merge__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(lodash_merge__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var lodash_random__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! lodash.random */ "./node_modules/lodash.random/index.js");
+/* harmony import */ var lodash_random__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(lodash_random__WEBPACK_IMPORTED_MODULE_2__);
+OnlineController.$inject = ["$rootScope", "$state", "$sce", "api", "RemoteStorageService", "STORAGE_VISITOR"];
+
+
+ // import moment from 'moment'
+
+/**
+ * @ngInject
+ * @param {ng.IRootScopeService} $rootScope
+ * @param {import('@uirouter/angularjs').StateService} $state
+ * @param {ng.ISCEService} $sce
+ * @param {ReturnType<typeof import('@js/index.factory').apiService>} api
+ * @param {import('../common/remote-storage.service').RemoteStorageService} RemoteStorageService
+ * @param {'motion_chat'} STORAGE_VISITOR
+ */
+
+function OnlineController($rootScope, $state, $sce, api, RemoteStorageService, STORAGE_VISITOR) {
+ const vm = this;
+ let fromKey = null;
+ vm.checkHTML = []; // Data
+
+ vm.form = {};
+ vm.errors = {};
+ vm.userForm = {};
+ vm.disableItem = false;
+
+ vm.trustAsHtml = function (string) {
+ return $sce.trustAsHtml(string);
+ }; // Functions
+
+
+ function goToIf() {
+ if (!$rootScope.settings.enableCustomerWriting) {
+ // Go To Waiting
+ $state.go('app.waiting', null, {
+ location: 'replace'
+ });
+ } else {
+ // Go To Chat
+ $state.go('app.chat', null, {
+ location: 'replace'
+ });
+ }
+ }
+
+ function sendMessage(message) {
+ vm.disableItem = true;
+ api.chatWebsite.notify(message).$promise.then(function (data) {
+ delete vm.errors.chatMessageError;
+ $rootScope.visitor.message = {
+ id: data.message.id
+ };
+ $rootScope.visitor.interaction = {
+ id: data.interaction.id
+ }; // Set visitor storage
+
+ RemoteStorageService.updateStorage(STORAGE_VISITOR, $rootScope.visitor).then(value => {
+ $rootScope.visitor = value;
+ }).catch(RemoteStorageService.onStorageError); // Enable button
+
+ vm.disableItem = false; // Goto If
+
+ goToIf();
+ }).catch(function (err) {
+ // Enable button
+ vm.disableItem = false;
+ console.error(err);
+ });
+ }
+
+ function submit() {
+ let body = 'New chat request \n';
+
+ for (let i = 0; i < vm.fields.length; i++) {
+ const field = vm.fields[i];
+
+ if (field.props && typeof vm.form[field.props.title] !== 'undefined') {
+ // set variable
+ if (!lodash_isnil__WEBPACK_IMPORTED_MODULE_0___default()(field.variable)) {
+ $rootScope.visitor[field.variable] = Array.isArray(vm.form[field.props.title]) ? vm.form[field.props.title].join() : vm.form[field.props.title];
+ } // set cmField
+
+
+ if (!lodash_isnil__WEBPACK_IMPORTED_MODULE_0___default()(field.cmField)) {
+ $rootScope.visitor[field.cmField] = Array.isArray(vm.form[field.props.title]) ? vm.form[field.props.title].join() : vm.form[field.props.title];
+ }
+
+ if (i === fromKey) {
+ if (!lodash_isnil__WEBPACK_IMPORTED_MODULE_0___default()($rootScope.settings.mapKey)) {
+ $rootScope.visitor.mapKey = $rootScope.settings.mapKey;
+ $rootScope.visitor.from = Array.isArray(vm.form[field.props.title]) ? vm.form[field.props.title].join() : vm.form[field.props.title];
+ }
+ }
+
+ if (vm.form[field.props.title]) {
+ body += field.props.title + ': ' + vm.form[field.props.title] + '\n';
+ }
+ }
+ } // First Message
+
+
+ sendMessage(lodash_merge__WEBPACK_IMPORTED_MODULE_1___default()({
+ body: body,
+ referer: $rootScope.settings.referer,
+ customerIp: $rootScope.settings.customerIp
+ }, $rootScope.visitor));
+ }
+
+ function getAnonymous() {
+ return 'Anonymous' + lodash_random__WEBPACK_IMPORTED_MODULE_2___default()(1, 1000000);
+ }
+
+ function toggle(name, item) {
+ if (!vm.form[name]) {
+ vm.form[name] = [];
+ }
+
+ const idx = vm.form[name].indexOf(item);
+
+ if (idx > -1) {
+ vm.form[name].splice(idx, 1);
+ } else {
+ vm.form[name].push(item);
+ }
+ }
+
+ function exists(name, item) {
+ if (!vm.form[name]) {
+ vm.form[name] = [];
+ }
+
+ return vm.form[name].indexOf(item) > -1;
+ }
+ /**
+ * NOTE: init visitor form
+ * @returns
+ */
+
+
+ function initVisitorForm() {
+ $rootScope.visitor = {
+ id: $rootScope.settings.id,
+ mapKey: 'firstName',
+ from: getAnonymous()
+ };
+ $rootScope.settings.showMenu = false; // Set visitor locastorage
+
+ return RemoteStorageService.updateStorage(STORAGE_VISITOR, $rootScope.visitor).then(value => {
+ $rootScope.visitor = value;
+ return api.chatWebsite.getFields({
+ id: $rootScope.settings.id,
+ online: true
+ }).$promise.then(function (data) {
+ if (data.count) {
+ fromKey = data.fromKey;
+ vm.fields = data.rows;
+ }
+ }).then(function () {
+ for (let i = 0; i < vm.fields.length; i++) {
+ const field = vm.fields[i];
+
+ if (field.props.helpText) {
+ const isHTML = RegExp.prototype.test.bind(/(<([^>]+)>)/i);
+ vm.checkHTML[i] = isHTML(field.props.helpText);
+ }
+ }
+ }).catch(function (err) {
+ console.error(err);
+ });
+ }).catch(RemoteStorageService.onStorageError);
+ }
+
+ function onInit() {
+ console.debug('OnlineController::onInit() VISITOR', $rootScope.visitor);
+ $rootScope.status = 'online';
+
+ if ($rootScope.visitor && $rootScope.visitor.interaction) {
+ if ($rootScope.visitor.interaction.id) {
+ if ($rootScope.visitor.interactionStarted === true) {
+ // Go To Chat
+ $state.go('app.chat', null, {
+ location: 'replace'
+ });
+ } else {
+ var _$rootScope$visitor, _$rootScope$visitor$m;
+
+ const chatInteractionId = $rootScope.visitor.interaction.id;
+ const messageId = $rootScope === null || $rootScope === void 0 ? void 0 : (_$rootScope$visitor = $rootScope.visitor) === null || _$rootScope$visitor === void 0 ? void 0 : (_$rootScope$visitor$m = _$rootScope$visitor.message) === null || _$rootScope$visitor$m === void 0 ? void 0 : _$rootScope$visitor$m.id;
+
+ if (messageId) {
+ const data = {
+ id: chatInteractionId,
+ channel: 'chat',
+ interaction: {
+ id: chatInteractionId
+ },
+ message: {
+ id: messageId
+ },
+ disposition: 'abandoned',
+ closed: true,
+ closeReason: 'contact' // closedAt: moment().format('YYYY-MM-DD HH:mm:ss'),
+
+ };
+ api.chatInteraction.abandon(data).$promise.finally(() => {
+ return initVisitorForm();
+ });
+ }
+ }
+ } else {
+ // Go To Waiting
+ $state.go('app.waiting', null, {
+ location: 'replace'
+ });
+ }
+ } else {
+ initVisitorForm();
+ }
+ } // Methods
+
+
+ vm.$onInit = onInit;
+ vm.submit = submit;
+ vm.toggle = toggle;
+ vm.exists = exists;
+}
+
+
+
+/***/ }),
+
+/***/ "./src/js/unmanaged/unmanaged.controller.js":
+/*!**************************************************!*\
+ !*** ./src/js/unmanaged/unmanaged.controller.js ***!
+ \**************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "UnmanagedController": () => (/* binding */ UnmanagedController)
+/* harmony export */ });
+UnmanagedController.$inject = ["$rootScope", "$state", "$mdToast", "api", "$q", "RemoteStorageService", "STORAGE_VISITOR", "STORAGE_LAYOUT"];
+
+/**
+ * @ngInject
+ * @param {ng.IRootScopeService} $rootScope
+ * @param {import('@uirouter/angularjs').StateService} $state
+ * @param {import('angular').material.IToastService} $mdToast
+ * @param {ReturnType<typeof import('@js/index.factory').apiService>} api
+ * @param {ng.IQService} $q
+ * @param {import('../common/remote-storage.service').RemoteStorageService} RemoteStorageService
+ * @param {'layout'} STORAGE_LAYOUT
+ * @param {'visitor'} STORAGE_VISITOR
+ */
+function UnmanagedController($rootScope, $state, $mdToast, api, $q, RemoteStorageService, STORAGE_VISITOR, STORAGE_LAYOUT) {
+ const vm = this; // Data
+
+ vm.form = {};
+ vm.errors = {}; // Functions
+
+ function goToIfTime() {
+ if ($rootScope.settings.online) {
+ $state.go('app.online', null, {
+ location: 'replace'
+ });
+ } else {
+ $state.go('app.offline', null, {
+ location: 'replace'
+ });
+ }
+ }
+
+ function reset() {
+ vm.form = {};
+ vm.upColor = null;
+ vm.downColor = null;
+ vm.userForm.$setPristine();
+ vm.userForm.$setUntouched(); // localStorageService setup
+
+ $rootScope.visitor = {}; // rootScope setup
+
+ $rootScope.enableDownload = false;
+ $rootScope.$emit('hide');
+ }
+
+ function skip() {
+ reset();
+ goToIfTime();
+ }
+
+ function handleError(name) {
+ return function (err) {
+ vm.errors[name] = err.data;
+ const toast = $mdToast.simple().textContent($rootScope.settings.formSubmitFailureMessage || 'Form submission error').toastClass('md-failure-toast').parent(angular.element(document.querySelector('#chat-toolbar')));
+ $mdToast.show(toast);
+ };
+ }
+
+ function stopLoading() {
+ $rootScope.loading = false;
+ }
+
+ function submit() {
+ $rootScope.loading = true;
+
+ if ($rootScope.visitor.interaction && $rootScope.visitor.interaction.id) {
+ api.chatInteraction.customUpdate({
+ id: $rootScope.visitor.interaction.id,
+ note: vm.form.note
+ }).$promise.then(function () {
+ delete vm.errors.submit;
+ const toast = $mdToast.simple().textContent($rootScope.settings.formSubmitSuccessMessage || 'Form properly submitted').toastClass('md-success-toast').parent(angular.element(document.querySelector('#chat-toolbar')));
+ $mdToast.show(toast);
+ }).then(reset).then(goToIfTime).catch(handleError('submit')).finally(stopLoading);
+ } else {
+ stopLoading();
+ handleError('submit');
+ }
+ }
+
+ function onInit() {
+ console.debug('UnmanagedController::onInit() VISITOR', $rootScope.visitor);
+ $rootScope.status = 'unmanaged'; // NOTE: init visitor form
+
+ $q.all([RemoteStorageService.removeItem(STORAGE_VISITOR).then(() => console.debug('STORAGE_VISITOR cleared')).catch(RemoteStorageService.onStorageError), RemoteStorageService.removeItem(STORAGE_LAYOUT).then(() => console.debug('STORAGE_LAYOUT cleared')).catch(RemoteStorageService.onStorageError)]).then(() => $rootScope.loading = false);
+ } // Methods
+
+
+ vm.$onInit = onInit;
+ vm.submit = submit;
+ vm.skip = skip;
+}
+
+
+
+/***/ }),
+
+/***/ "./src/js/waiting/waiting.controller.js":
+/*!**********************************************!*\
+ !*** ./src/js/waiting/waiting.controller.js ***!
+ \**********************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ "WaitingController": () => (/* binding */ WaitingController)
+/* harmony export */ });
+WaitingController.$inject = ["$rootScope", "$scope", "$interval", "$state", "api", "RemoteStorageService", "STORAGE_VISITOR"];
+
+// import moment from 'moment'
+
+/**
+ * @ngInject
+ * @param {ng.IRootScopeService} $rootScope
+ * @param {ng.IScope} $scope
+ * @param {ng.IIntervalService} $interval
+ * @param {import('@uirouter/angularjs').StateService} $state
+ * @param {ReturnType<typeof import('@js/index.factory').apiService>} api
+ * @param {import('../common/remote-storage.service').RemoteStorageService} RemoteStorageService
+ * @param {'visitor'} STORAGE_VISITOR
+ */
+function WaitingController($rootScope, $scope, $interval, $state, api, RemoteStorageService, STORAGE_VISITOR) {
+ const vm = this;
+ let getInteractionIntervalHandle = null; // Functions
+
+ function getInteraction() {
+ let interaction = {};
+ let open = false;
+ api.chatInteraction.get({
+ id: $rootScope.visitor.interaction.id
+ }).$promise.then(function (data) {
+ interaction = data;
+ return api.chatInteraction.getMessages({
+ intid: $rootScope.visitor.interaction.id
+ }).$promise;
+ }).then(function (data) {
+ open = data.rows.length > 1;
+
+ if (interaction.closed) {
+ $rootScope.visitor.interaction.closed = true;
+ RemoteStorageService.updateStorage(STORAGE_VISITOR, $rootScope.visitor).then(value => {
+ $rootScope.visitor = value;
+
+ if (interaction.disposition === 'unmanaged') {
+ $state.go('app.unmanaged', null, {
+ location: 'replace'
+ });
+ }
+ }).catch(RemoteStorageService.onStorageError);
+ } else if (interaction.UserId || open) {
+ // Save UserId interaction
+ if (interaction.UserId) {
+ $rootScope.visitor.interaction.UserId = interaction.UserId;
+ }
+
+ RemoteStorageService.updateStorage(STORAGE_VISITOR, { ...$rootScope.visitor,
+ interactionStarted: true
+ }).then(value => {
+ $rootScope.visitor = value;
+ $state.go('app.chat', null, {
+ location: 'replace'
+ });
+ }).catch(RemoteStorageService.onStorageError);
+ }
+ /* else if (open) {
+ $state.go('app.chat', null, { location: 'replace' })
+ } */
+
+ }).catch(function (err) {
+ switch (err.status) {
+ case 403:
+ $state.go('app.closing', null, {
+ location: 'replace'
+ });
+ break;
+
+ case 405:
+ $state.go('app.unmanaged', null, {
+ location: 'replace'
+ });
+ break;
+
+ default:
+ console.error(err);
+ }
+ });
+ }
+
+ function onDestroy() {
+ $interval.cancel(getInteractionIntervalHandle);
+ }
+
+ function onInit() {
+ console.debug('WaitingController::onInit() VISITOR', $rootScope.visitor);
+ $rootScope.status = 'waiting';
+
+ if ($rootScope.visitor && $rootScope.visitor.interaction && $rootScope.visitor.interaction.id) {
+ // first interaction callback
+ getInteractionIntervalHandle = $interval(getInteraction, 3000);
+ }
+ } // Methods
+
+
+ vm.$onInit = onInit; // var verticalAlignment = 0
+ // Events
+
+ $scope.$on('$destroy', onDestroy);
+}
+
+
+
+/***/ }),
+
+/***/ "./node_modules/emojione/lib/js/emojione.js":
+/*!**************************************************!*\
+ !*** ./node_modules/emojione/lib/js/emojione.js ***!
+ \**************************************************/
+/***/ (function(module) {
+
+/* jshint maxerr: 10000 */
+/* jslint unused: true */
+/* jshint shadow: true */
+/* jshint -W075 */
+(function(ns){
+ // this list must be ordered from largest length of the value array, index 0, to the shortest
+ ns.emojioneList = {":kiss_mm:":{"uc_base":"1f468-2764-1f48b-1f468","uc_output":"1f468-200d-2764-fe0f-200d-1f48b-200d-1f468","uc_match":"1f468-2764-fe0f-1f48b-1f468","uc_greedy":"1f468-2764-1f48b-1f468","shortnames":[":couplekiss_mm:"],"category":"people"},":kiss_woman_man:":{"uc_base":"1f469-2764-1f48b-1f468","uc_output":"1f469-200d-2764-fe0f-200d-1f48b-200d-1f468","uc_match":"1f469-2764-fe0f-1f48b-1f468","uc_greedy":"1f469-2764-1f48b-1f468","shortnames":[],"category":"people"},":kiss_ww:":{"uc_base":"1f469-2764-1f48b-1f469","uc_output":"1f469-200d-2764-fe0f-200d-1f48b-200d-1f469","uc_match":"1f469-2764-fe0f-1f48b-1f469","uc_greedy":"1f469-2764-1f48b-1f469","shortnames":[":couplekiss_ww:"],"category":"people"},":england:":{"uc_base":"1f3f4-e0067-e0062-e0065-e006e-e0067-e007f","uc_output":"1f3f4-e0067-e0062-e0065-e006e-e0067-e007f","uc_match":"1f3f4-e0067-e0062-e0065-e006e-e0067-e007f","uc_greedy":"1f3f4-e0067-e0062-e0065-e006e-e0067-e007f","shortnames":[],"category":"flags"},":scotland:":{"uc_base":"1f3f4-e0067-e0062-e0073-e0063-e0074-e007f","uc_output":"1f3f4-e0067-e0062-e0073-e0063-e0074-e007f","uc_match":"1f3f4-e0067-e0062-e0073-e0063-e0074-e007f","uc_greedy":"1f3f4-e0067-e0062-e0073-e0063-e0074-e007f","shortnames":[],"category":"flags"},":wales:":{"uc_base":"1f3f4-e0067-e0062-e0077-e006c-e0073-e007f","uc_output":"1f3f4-e0067-e0062-e0077-e006c-e0073-e007f","uc_match":"1f3f4-e0067-e0062-e0077-e006c-e0073-e007f","uc_greedy":"1f3f4-e0067-e0062-e0077-e006c-e0073-e007f","shortnames":[],"category":"flags"},":family_mmbb:":{"uc_base":"1f468-1f468-1f466-1f466","uc_output":"1f468-200d-1f468-200d-1f466-200d-1f466","uc_match":"1f468-1f468-1f466-1f466","uc_greedy":"1f468-1f468-1f466-1f466","shortnames":[],"category":"people"},":family_mmgb:":{"uc_base":"1f468-1f468-1f467-1f466","uc_output":"1f468-200d-1f468-200d-1f467-200d-1f466","uc_match":"1f468-1f468-1f467-1f466","uc_greedy":"1f468-1f468-1f467-1f466","shortnames":[],"category":"people"},":family_mmgg:":{"uc_base":"1f468-1f468-1f467-1f467","uc_output":"1f468-200d-1f468-200d-1f467-200d-1f467","uc_match":"1f468-1f468-1f467-1f467","uc_greedy":"1f468-1f468-1f467-1f467","shortnames":[],"category":"people"},":family_mwbb:":{"uc_base":"1f468-1f469-1f466-1f466","uc_output":"1f468-200d-1f469-200d-1f466-200d-1f466","uc_match":"1f468-1f469-1f466-1f466","uc_greedy":"1f468-1f469-1f466-1f466","shortnames":[],"category":"people"},":family_mwgb:":{"uc_base":"1f468-1f469-1f467-1f466","uc_output":"1f468-200d-1f469-200d-1f467-200d-1f466","uc_match":"1f468-1f469-1f467-1f466","uc_greedy":"1f468-1f469-1f467-1f466","shortnames":[],"category":"people"},":family_mwgg:":{"uc_base":"1f468-1f469-1f467-1f467","uc_output":"1f468-200d-1f469-200d-1f467-200d-1f467","uc_match":"1f468-1f469-1f467-1f467","uc_greedy":"1f468-1f469-1f467-1f467","shortnames":[],"category":"people"},":family_wwbb:":{"uc_base":"1f469-1f469-1f466-1f466","uc_output":"1f469-200d-1f469-200d-1f466-200d-1f466","uc_match":"1f469-1f469-1f466-1f466","uc_greedy":"1f469-1f469-1f466-1f466","shortnames":[],"category":"people"},":family_wwgb:":{"uc_base":"1f469-1f469-1f467-1f466","uc_output":"1f469-200d-1f469-200d-1f467-200d-1f466","uc_match":"1f469-1f469-1f467-1f466","uc_greedy":"1f469-1f469-1f467-1f466","shortnames":[],"category":"people"},":family_wwgg:":{"uc_base":"1f469-1f469-1f467-1f467","uc_output":"1f469-200d-1f469-200d-1f467-200d-1f467","uc_match":"1f469-1f469-1f467-1f467","uc_greedy":"1f469-1f469-1f467-1f467","shortnames":[],"category":"people"},":couple_mm:":{"uc_base":"1f468-2764-1f468","uc_output":"1f468-200d-2764-fe0f-200d-1f468","uc_match":"1f468-2764-fe0f-1f468","uc_greedy":"1f468-2764-1f468","shortnames":[":couple_with_heart_mm:"],"category":"people"},":couple_with_heart_woman_man:":{"uc_base":"1f469-2764-1f468","uc_output":"1f469-200d-2764-fe0f-200d-1f468","uc_match":"1f469-2764-fe0f-1f468","uc_greedy":"1f469-2764-1f468","shortnames":[],"category":"people"},":couple_ww:":{"uc_base":"1f469-2764-1f469","uc_output":"1f469-200d-2764-fe0f-200d-1f469","uc_match":"1f469-2764-fe0f-1f469","uc_greedy":"1f469-2764-1f469","shortnames":[":couple_with_heart_ww:"],"category":"people"},":family_man_boy_boy:":{"uc_base":"1f468-1f466-1f466","uc_output":"1f468-200d-1f466-200d-1f466","uc_match":"1f468-1f466-1f466","uc_greedy":"1f468-1f466-1f466","shortnames":[],"category":"people"},":family_man_girl_boy:":{"uc_base":"1f468-1f467-1f466","uc_output":"1f468-200d-1f467-200d-1f466","uc_match":"1f468-1f467-1f466","uc_greedy":"1f468-1f467-1f466","shortnames":[],"category":"people"},":family_man_girl_girl:":{"uc_base":"1f468-1f467-1f467","uc_output":"1f468-200d-1f467-200d-1f467","uc_match":"1f468-1f467-1f467","uc_greedy":"1f468-1f467-1f467","shortnames":[],"category":"people"},":family_man_woman_boy:":{"uc_base":"1f468-1f469-1f466","uc_output":"1f468-200d-1f469-200d-1f466","uc_match":"1f468-1f469-1f466","uc_greedy":"1f468-1f469-1f466","shortnames":[],"category":"people"},":family_mmb:":{"uc_base":"1f468-1f468-1f466","uc_output":"1f468-200d-1f468-200d-1f466","uc_match":"1f468-1f468-1f466","uc_greedy":"1f468-1f468-1f466","shortnames":[],"category":"people"},":family_mmg:":{"uc_base":"1f468-1f468-1f467","uc_output":"1f468-200d-1f468-200d-1f467","uc_match":"1f468-1f468-1f467","uc_greedy":"1f468-1f468-1f467","shortnames":[],"category":"people"},":family_mwg:":{"uc_base":"1f468-1f469-1f467","uc_output":"1f468-200d-1f469-200d-1f467","uc_match":"1f468-1f469-1f467","uc_greedy":"1f468-1f469-1f467","shortnames":[],"category":"people"},":family_woman_boy_boy:":{"uc_base":"1f469-1f466-1f466","uc_output":"1f469-200d-1f466-200d-1f466","uc_match":"1f469-1f466-1f466","uc_greedy":"1f469-1f466-1f466","shortnames":[],"category":"people"},":family_woman_girl_boy:":{"uc_base":"1f469-1f467-1f466","uc_output":"1f469-200d-1f467-200d-1f466","uc_match":"1f469-1f467-1f466","uc_greedy":"1f469-1f467-1f466","shortnames":[],"category":"people"},":family_woman_girl_girl:":{"uc_base":"1f469-1f467-1f467","uc_output":"1f469-200d-1f467-200d-1f467","uc_match":"1f469-1f467-1f467","uc_greedy":"1f469-1f467-1f467","shortnames":[],"category":"people"},":family_wwb:":{"uc_base":"1f469-1f469-1f466","uc_output":"1f469-200d-1f469-200d-1f466","uc_match":"1f469-1f469-1f466","uc_greedy":"1f469-1f469-1f466","shortnames":[],"category":"people"},":family_wwg:":{"uc_base":"1f469-1f469-1f467","uc_output":"1f469-200d-1f469-200d-1f467","uc_match":"1f469-1f469-1f467","uc_greedy":"1f469-1f469-1f467","shortnames":[],"category":"people"},":blond-haired_man_tone1:":{"uc_base":"1f471-1f3fb-2642","uc_output":"1f471-1f3fb-200d-2642-fe0f","uc_match":"1f471-1f3fb-2642-fe0f","uc_greedy":"1f471-1f3fb-2642","shortnames":[":blond-haired_man_light_skin_tone:"],"category":"people"},":blond-haired_man_tone2:":{"uc_base":"1f471-1f3fc-2642","uc_output":"1f471-1f3fc-200d-2642-fe0f","uc_match":"1f471-1f3fc-2642-fe0f","uc_greedy":"1f471-1f3fc-2642","shortnames":[":blond-haired_man_medium_light_skin_tone:"],"category":"people"},":blond-haired_man_tone3:":{"uc_base":"1f471-1f3fd-2642","uc_output":"1f471-1f3fd-200d-2642-fe0f","uc_match":"1f471-1f3fd-2642-fe0f","uc_greedy":"1f471-1f3fd-2642","shortnames":[":blond-haired_man_medium_skin_tone:"],"category":"people"},":blond-haired_man_tone4:":{"uc_base":"1f471-1f3fe-2642","uc_output":"1f471-1f3fe-200d-2642-fe0f","uc_match":"1f471-1f3fe-2642-fe0f","uc_greedy":"1f471-1f3fe-2642","shortnames":[":blond-haired_man_medium_dark_skin_tone:"],"category":"people"},":blond-haired_man_tone5:":{"uc_base":"1f471-1f3ff-2642","uc_output":"1f471-1f3ff-200d-2642-fe0f","uc_match":"1f471-1f3ff-2642-fe0f","uc_greedy":"1f471-1f3ff-2642","shortnames":[":blond-haired_man_dark_skin_tone:"],"category":"people"},":blond-haired_woman_tone1:":{"uc_base":"1f471-1f3fb-2640","uc_output":"1f471-1f3fb-200d-2640-fe0f","uc_match":"1f471-1f3fb-2640-fe0f","uc_greedy":"1f471-1f3fb-2640","shortnames":[":blond-haired_woman_light_skin_tone:"],"category":"people"},":blond-haired_woman_tone2:":{"uc_base":"1f471-1f3fc-2640","uc_output":"1f471-1f3fc-200d-2640-fe0f","uc_match":"1f471-1f3fc-2640-fe0f","uc_greedy":"1f471-1f3fc-2640","shortnames":[":blond-haired_woman_medium_light_skin_tone:"],"category":"people"},":blond-haired_woman_tone3:":{"uc_base":"1f471-1f3fd-2640","uc_output":"1f471-1f3fd-200d-2640-fe0f","uc_match":"1f471-1f3fd-2640-fe0f","uc_greedy":"1f471-1f3fd-2640","shortnames":[":blond-haired_woman_medium_skin_tone:"],"category":"people"},":blond-haired_woman_tone4:":{"uc_base":"1f471-1f3fe-2640","uc_output":"1f471-1f3fe-200d-2640-fe0f","uc_match":"1f471-1f3fe-2640-fe0f","uc_greedy":"1f471-1f3fe-2640","shortnames":[":blond-haired_woman_medium_dark_skin_tone:"],"category":"people"},":blond-haired_woman_tone5:":{"uc_base":"1f471-1f3ff-2640","uc_output":"1f471-1f3ff-200d-2640-fe0f","uc_match":"1f471-1f3ff-2640-fe0f","uc_greedy":"1f471-1f3ff-2640","shortnames":[":blond-haired_woman_dark_skin_tone:"],"category":"people"},":eye_in_speech_bubble:":{"uc_base":"1f441-1f5e8","uc_output":"1f441-fe0f-200d-1f5e8-fe0f","uc_match":"1f441-fe0f-200d-1f5e8","uc_greedy":"1f441-1f5e8","shortnames":[],"category":"symbols"},":man_biking_tone1:":{"uc_base":"1f6b4-1f3fb-2642","uc_output":"1f6b4-1f3fb-200d-2642-fe0f","uc_match":"1f6b4-1f3fb-2642-fe0f","uc_greedy":"1f6b4-1f3fb-2642","shortnames":[":man_biking_light_skin_tone:"],"category":"activity"},":man_biking_tone2:":{"uc_base":"1f6b4-1f3fc-2642","uc_output":"1f6b4-1f3fc-200d-2642-fe0f","uc_match":"1f6b4-1f3fc-2642-fe0f","uc_greedy":"1f6b4-1f3fc-2642","shortnames":[":man_biking_medium_light_skin_tone:"],"category":"activity"},":man_biking_tone3:":{"uc_base":"1f6b4-1f3fd-2642","uc_output":"1f6b4-1f3fd-200d-2642-fe0f","uc_match":"1f6b4-1f3fd-2642-fe0f","uc_greedy":"1f6b4-1f3fd-2642","shortnames":[":man_biking_medium_skin_tone:"],"category":"activity"},":man_biking_tone4:":{"uc_base":"1f6b4-1f3fe-2642","uc_output":"1f6b4-1f3fe-200d-2642-fe0f","uc_match":"1f6b4-1f3fe-2642-fe0f","uc_greedy":"1f6b4-1f3fe-2642","shortnames":[":man_biking_medium_dark_skin_tone:"],"category":"activity"},":man_biking_tone5:":{"uc_base":"1f6b4-1f3ff-2642","uc_output":"1f6b4-1f3ff-200d-2642-fe0f","uc_match":"1f6b4-1f3ff-2642-fe0f","uc_greedy":"1f6b4-1f3ff-2642","shortnames":[":man_biking_dark_skin_tone:"],"category":"activity"},":man_bowing_tone1:":{"uc_base":"1f647-1f3fb-2642","uc_output":"1f647-1f3fb-200d-2642-fe0f","uc_match":"1f647-1f3fb-2642-fe0f","uc_greedy":"1f647-1f3fb-2642","shortnames":[":man_bowing_light_skin_tone:"],"category":"people"},":man_bowing_tone2:":{"uc_base":"1f647-1f3fc-2642","uc_output":"1f647-1f3fc-200d-2642-fe0f","uc_match":"1f647-1f3fc-2642-fe0f","uc_greedy":"1f647-1f3fc-2642","shortnames":[":man_bowing_medium_light_skin_tone:"],"category":"people"},":man_bowing_tone3:":{"uc_base":"1f647-1f3fd-2642","uc_output":"1f647-1f3fd-200d-2642-fe0f","uc_match":"1f647-1f3fd-2642-fe0f","uc_greedy":"1f647-1f3fd-2642","shortnames":[":man_bowing_medium_skin_tone:"],"category":"people"},":man_bowing_tone4:":{"uc_base":"1f647-1f3fe-2642","uc_output":"1f647-1f3fe-200d-2642-fe0f","uc_match":"1f647-1f3fe-2642-fe0f","uc_greedy":"1f647-1f3fe-2642","shortnames":[":man_bowing_medium_dark_skin_tone:"],"category":"people"},":man_bowing_tone5:":{"uc_base":"1f647-1f3ff-2642","uc_output":"1f647-1f3ff-200d-2642-fe0f","uc_match":"1f647-1f3ff-2642-fe0f","uc_greedy":"1f647-1f3ff-2642","shortnames":[":man_bowing_dark_skin_tone:"],"category":"people"},":man_cartwheeling_tone1:":{"uc_base":"1f938-1f3fb-2642","uc_output":"1f938-1f3fb-200d-2642-fe0f","uc_match":"1f938-1f3fb-2642-fe0f","uc_greedy":"1f938-1f3fb-2642","shortnames":[":man_cartwheeling_light_skin_tone:"],"category":"activity"},":man_cartwheeling_tone2:":{"uc_base":"1f938-1f3fc-2642","uc_output":"1f938-1f3fc-200d-2642-fe0f","uc_match":"1f938-1f3fc-2642-fe0f","uc_greedy":"1f938-1f3fc-2642","shortnames":[":man_cartwheeling_medium_light_skin_tone:"],"category":"activity"},":man_cartwheeling_tone3:":{"uc_base":"1f938-1f3fd-2642","uc_output":"1f938-1f3fd-200d-2642-fe0f","uc_match":"1f938-1f3fd-2642-fe0f","uc_greedy":"1f938-1f3fd-2642","shortnames":[":man_cartwheeling_medium_skin_tone:"],"category":"activity"},":man_cartwheeling_tone4:":{"uc_base":"1f938-1f3fe-2642","uc_output":"1f938-1f3fe-200d-2642-fe0f","uc_match":"1f938-1f3fe-2642-fe0f","uc_greedy":"1f938-1f3fe-2642","shortnames":[":man_cartwheeling_medium_dark_skin_tone:"],"category":"activity"},":man_cartwheeling_tone5:":{"uc_base":"1f938-1f3ff-2642","uc_output":"1f938-1f3ff-200d-2642-fe0f","uc_match":"1f938-1f3ff-2642-fe0f","uc_greedy":"1f938-1f3ff-2642","shortnames":[":man_cartwheeling_dark_skin_tone:"],"category":"activity"},":man_climbing_tone1:":{"uc_base":"1f9d7-1f3fb-2642","uc_output":"1f9d7-1f3fb-200d-2642-fe0f","uc_match":"1f9d7-1f3fb-2642-fe0f","uc_greedy":"1f9d7-1f3fb-2642","shortnames":[":man_climbing_light_skin_tone:"],"category":"activity"},":man_climbing_tone2:":{"uc_base":"1f9d7-1f3fc-2642","uc_output":"1f9d7-1f3fc-200d-2642-fe0f","uc_match":"1f9d7-1f3fc-2642-fe0f","uc_greedy":"1f9d7-1f3fc-2642","shortnames":[":man_climbing_medium_light_skin_tone:"],"category":"activity"},":man_climbing_tone3:":{"uc_base":"1f9d7-1f3fd-2642","uc_output":"1f9d7-1f3fd-200d-2642-fe0f","uc_match":"1f9d7-1f3fd-2642-fe0f","uc_greedy":"1f9d7-1f3fd-2642","shortnames":[":man_climbing_medium_skin_tone:"],"category":"activity"},":man_climbing_tone4:":{"uc_base":"1f9d7-1f3fe-2642","uc_output":"1f9d7-1f3fe-200d-2642-fe0f","uc_match":"1f9d7-1f3fe-2642-fe0f","uc_greedy":"1f9d7-1f3fe-2642","shortnames":[":man_climbing_medium_dark_skin_tone:"],"category":"activity"},":man_climbing_tone5:":{"uc_base":"1f9d7-1f3ff-2642","uc_output":"1f9d7-1f3ff-200d-2642-fe0f","uc_match":"1f9d7-1f3ff-2642-fe0f","uc_greedy":"1f9d7-1f3ff-2642","shortnames":[":man_climbing_dark_skin_tone:"],"category":"activity"},":man_construction_worker_tone1:":{"uc_base":"1f477-1f3fb-2642","uc_output":"1f477-1f3fb-200d-2642-fe0f","uc_match":"1f477-1f3fb-2642-fe0f","uc_greedy":"1f477-1f3fb-2642","shortnames":[":man_construction_worker_light_skin_tone:"],"category":"people"},":man_construction_worker_tone2:":{"uc_base":"1f477-1f3fc-2642","uc_output":"1f477-1f3fc-200d-2642-fe0f","uc_match":"1f477-1f3fc-2642-fe0f","uc_greedy":"1f477-1f3fc-2642","shortnames":[":man_construction_worker_medium_light_skin_tone:"],"category":"people"},":man_construction_worker_tone3:":{"uc_base":"1f477-1f3fd-2642","uc_output":"1f477-1f3fd-200d-2642-fe0f","uc_match":"1f477-1f3fd-2642-fe0f","uc_greedy":"1f477-1f3fd-2642","shortnames":[":man_construction_worker_medium_skin_tone:"],"category":"people"},":man_construction_worker_tone4:":{"uc_base":"1f477-1f3fe-2642","uc_output":"1f477-1f3fe-200d-2642-fe0f","uc_match":"1f477-1f3fe-2642-fe0f","uc_greedy":"1f477-1f3fe-2642","shortnames":[":man_construction_worker_medium_dark_skin_tone:"],"category":"people"},":man_construction_worker_tone5:":{"uc_base":"1f477-1f3ff-2642","uc_output":"1f477-1f3ff-200d-2642-fe0f","uc_match":"1f477-1f3ff-2642-fe0f","uc_greedy":"1f477-1f3ff-2642","shortnames":[":man_construction_worker_dark_skin_tone:"],"category":"people"},":man_detective_tone1:":{"uc_base":"1f575-1f3fb-2642","uc_output":"1f575-1f3fb-200d-2642-fe0f","uc_match":"1f575-fe0f-1f3fb-2642-fe0f","uc_greedy":"1f575-1f3fb-2642","shortnames":[":man_detective_light_skin_tone:"],"category":"people"},":man_detective_tone2:":{"uc_base":"1f575-1f3fc-2642","uc_output":"1f575-1f3fc-200d-2642-fe0f","uc_match":"1f575-fe0f-1f3fc-2642-fe0f","uc_greedy":"1f575-1f3fc-2642","shortnames":[":man_detective_medium_light_skin_tone:"],"category":"people"},":man_detective_tone3:":{"uc_base":"1f575-1f3fd-2642","uc_output":"1f575-1f3fd-200d-2642-fe0f","uc_match":"1f575-fe0f-1f3fd-2642-fe0f","uc_greedy":"1f575-1f3fd-2642","shortnames":[":man_detective_medium_skin_tone:"],"category":"people"},":man_detective_tone4:":{"uc_base":"1f575-1f3fe-2642","uc_output":"1f575-1f3fe-200d-2642-fe0f","uc_match":"1f575-fe0f-1f3fe-2642-fe0f","uc_greedy":"1f575-1f3fe-2642","shortnames":[":man_detective_medium_dark_skin_tone:"],"category":"people"},":man_detective_tone5:":{"uc_base":"1f575-1f3ff-2642","uc_output":"1f575-1f3ff-200d-2642-fe0f","uc_match":"1f575-fe0f-1f3ff-2642-fe0f","uc_greedy":"1f575-1f3ff-2642","shortnames":[":man_detective_dark_skin_tone:"],"category":"people"},":man_elf_tone1:":{"uc_base":"1f9dd-1f3fb-2642","uc_output":"1f9dd-1f3fb-200d-2642-fe0f","uc_match":"1f9dd-1f3fb-2642-fe0f","uc_greedy":"1f9dd-1f3fb-2642","shortnames":[":man_elf_light_skin_tone:"],"category":"people"},":man_elf_tone2:":{"uc_base":"1f9dd-1f3fc-2642","uc_output":"1f9dd-1f3fc-200d-2642-fe0f","uc_match":"1f9dd-1f3fc-2642-fe0f","uc_greedy":"1f9dd-1f3fc-2642","shortnames":[":man_elf_medium_light_skin_tone:"],"category":"people"},":man_elf_tone3:":{"uc_base":"1f9dd-1f3fd-2642","uc_output":"1f9dd-1f3fd-200d-2642-fe0f","uc_match":"1f9dd-1f3fd-2642-fe0f","uc_greedy":"1f9dd-1f3fd-2642","shortnames":[":man_elf_medium_skin_tone:"],"category":"people"},":man_elf_tone4:":{"uc_base":"1f9dd-1f3fe-2642","uc_output":"1f9dd-1f3fe-200d-2642-fe0f","uc_match":"1f9dd-1f3fe-2642-fe0f","uc_greedy":"1f9dd-1f3fe-2642","shortnames":[":man_elf_medium_dark_skin_tone:"],"category":"people"},":man_elf_tone5:":{"uc_base":"1f9dd-1f3ff-2642","uc_output":"1f9dd-1f3ff-200d-2642-fe0f","uc_match":"1f9dd-1f3ff-2642-fe0f","uc_greedy":"1f9dd-1f3ff-2642","shortnames":[":man_elf_dark_skin_tone:"],"category":"people"},":man_facepalming_tone1:":{"uc_base":"1f926-1f3fb-2642","uc_output":"1f926-1f3fb-200d-2642-fe0f","uc_match":"1f926-1f3fb-2642-fe0f","uc_greedy":"1f926-1f3fb-2642","shortnames":[":man_facepalming_light_skin_tone:"],"category":"people"},":man_facepalming_tone2:":{"uc_base":"1f926-1f3fc-2642","uc_output":"1f926-1f3fc-200d-2642-fe0f","uc_match":"1f926-1f3fc-2642-fe0f","uc_greedy":"1f926-1f3fc-2642","shortnames":[":man_facepalming_medium_light_skin_tone:"],"category":"people"},":man_facepalming_tone3:":{"uc_base":"1f926-1f3fd-2642","uc_output":"1f926-1f3fd-200d-2642-fe0f","uc_match":"1f926-1f3fd-2642-fe0f","uc_greedy":"1f926-1f3fd-2642","shortnames":[":man_facepalming_medium_skin_tone:"],"category":"people"},":man_facepalming_tone4:":{"uc_base":"1f926-1f3fe-2642","uc_output":"1f926-1f3fe-200d-2642-fe0f","uc_match":"1f926-1f3fe-2642-fe0f","uc_greedy":"1f926-1f3fe-2642","shortnames":[":man_facepalming_medium_dark_skin_tone:"],"category":"people"},":man_facepalming_tone5:":{"uc_base":"1f926-1f3ff-2642","uc_output":"1f926-1f3ff-200d-2642-fe0f","uc_match":"1f926-1f3ff-2642-fe0f","uc_greedy":"1f926-1f3ff-2642","shortnames":[":man_facepalming_dark_skin_tone:"],"category":"people"},":man_fairy_tone1:":{"uc_base":"1f9da-1f3fb-2642","uc_output":"1f9da-1f3fb-200d-2642-fe0f","uc_match":"1f9da-1f3fb-2642-fe0f","uc_greedy":"1f9da-1f3fb-2642","shortnames":[":man_fairy_light_skin_tone:"],"category":"people"},":man_fairy_tone2:":{"uc_base":"1f9da-1f3fc-2642","uc_output":"1f9da-1f3fc-200d-2642-fe0f","uc_match":"1f9da-1f3fc-2642-fe0f","uc_greedy":"1f9da-1f3fc-2642","shortnames":[":man_fairy_medium_light_skin_tone:"],"category":"people"},":man_fairy_tone3:":{"uc_base":"1f9da-1f3fd-2642","uc_output":"1f9da-1f3fd-200d-2642-fe0f","uc_match":"1f9da-1f3fd-2642-fe0f","uc_greedy":"1f9da-1f3fd-2642","shortnames":[":man_fairy_medium_skin_tone:"],"category":"people"},":man_fairy_tone4:":{"uc_base":"1f9da-1f3fe-2642","uc_output":"1f9da-1f3fe-200d-2642-fe0f","uc_match":"1f9da-1f3fe-2642-fe0f","uc_greedy":"1f9da-1f3fe-2642","shortnames":[":man_fairy_medium_dark_skin_tone:"],"category":"people"},":man_fairy_tone5:":{"uc_base":"1f9da-1f3ff-2642","uc_output":"1f9da-1f3ff-200d-2642-fe0f","uc_match":"1f9da-1f3ff-2642-fe0f","uc_greedy":"1f9da-1f3ff-2642","shortnames":[":man_fairy_dark_skin_tone:"],"category":"people"},":man_frowning_tone1:":{"uc_base":"1f64d-1f3fb-2642","uc_output":"1f64d-1f3fb-200d-2642-fe0f","uc_match":"1f64d-1f3fb-2642-fe0f","uc_greedy":"1f64d-1f3fb-2642","shortnames":[":man_frowning_light_skin_tone:"],"category":"people"},":man_frowning_tone2:":{"uc_base":"1f64d-1f3fc-2642","uc_output":"1f64d-1f3fc-200d-2642-fe0f","uc_match":"1f64d-1f3fc-2642-fe0f","uc_greedy":"1f64d-1f3fc-2642","shortnames":[":man_frowning_medium_light_skin_tone:"],"category":"people"},":man_frowning_tone3:":{"uc_base":"1f64d-1f3fd-2642","uc_output":"1f64d-1f3fd-200d-2642-fe0f","uc_match":"1f64d-1f3fd-2642-fe0f","uc_greedy":"1f64d-1f3fd-2642","shortnames":[":man_frowning_medium_skin_tone:"],"category":"people"},":man_frowning_tone4:":{"uc_base":"1f64d-1f3fe-2642","uc_output":"1f64d-1f3fe-200d-2642-fe0f","uc_match":"1f64d-1f3fe-2642-fe0f","uc_greedy":"1f64d-1f3fe-2642","shortnames":[":man_frowning_medium_dark_skin_tone:"],"category":"people"},":man_frowning_tone5:":{"uc_base":"1f64d-1f3ff-2642","uc_output":"1f64d-1f3ff-200d-2642-fe0f","uc_match":"1f64d-1f3ff-2642-fe0f","uc_greedy":"1f64d-1f3ff-2642","shortnames":[":man_frowning_dark_skin_tone:"],"category":"people"},":man_gesturing_no_tone1:":{"uc_base":"1f645-1f3fb-2642","uc_output":"1f645-1f3fb-200d-2642-fe0f","uc_match":"1f645-1f3fb-2642-fe0f","uc_greedy":"1f645-1f3fb-2642","shortnames":[":man_gesturing_no_light_skin_tone:"],"category":"people"},":man_gesturing_no_tone2:":{"uc_base":"1f645-1f3fc-2642","uc_output":"1f645-1f3fc-200d-2642-fe0f","uc_match":"1f645-1f3fc-2642-fe0f","uc_greedy":"1f645-1f3fc-2642","shortnames":[":man_gesturing_no_medium_light_skin_tone:"],"category":"people"},":man_gesturing_no_tone3:":{"uc_base":"1f645-1f3fd-2642","uc_output":"1f645-1f3fd-200d-2642-fe0f","uc_match":"1f645-1f3fd-2642-fe0f","uc_greedy":"1f645-1f3fd-2642","shortnames":[":man_gesturing_no_medium_skin_tone:"],"category":"people"},":man_gesturing_no_tone4:":{"uc_base":"1f645-1f3fe-2642","uc_output":"1f645-1f3fe-200d-2642-fe0f","uc_match":"1f645-1f3fe-2642-fe0f","uc_greedy":"1f645-1f3fe-2642","shortnames":[":man_gesturing_no_medium_dark_skin_tone:"],"category":"people"},":man_gesturing_no_tone5:":{"uc_base":"1f645-1f3ff-2642","uc_output":"1f645-1f3ff-200d-2642-fe0f","uc_match":"1f645-1f3ff-2642-fe0f","uc_greedy":"1f645-1f3ff-2642","shortnames":[":man_gesturing_no_dark_skin_tone:"],"category":"people"},":man_gesturing_ok_tone1:":{"uc_base":"1f646-1f3fb-2642","uc_output":"1f646-1f3fb-200d-2642-fe0f","uc_match":"1f646-1f3fb-2642-fe0f","uc_greedy":"1f646-1f3fb-2642","shortnames":[":man_gesturing_ok_light_skin_tone:"],"category":"people"},":man_gesturing_ok_tone2:":{"uc_base":"1f646-1f3fc-2642","uc_output":"1f646-1f3fc-200d-2642-fe0f","uc_match":"1f646-1f3fc-2642-fe0f","uc_greedy":"1f646-1f3fc-2642","shortnames":[":man_gesturing_ok_medium_light_skin_tone:"],"category":"people"},":man_gesturing_ok_tone3:":{"uc_base":"1f646-1f3fd-2642","uc_output":"1f646-1f3fd-200d-2642-fe0f","uc_match":"1f646-1f3fd-2642-fe0f","uc_greedy":"1f646-1f3fd-2642","shortnames":[":man_gesturing_ok_medium_skin_tone:"],"category":"people"},":man_gesturing_ok_tone4:":{"uc_base":"1f646-1f3fe-2642","uc_output":"1f646-1f3fe-200d-2642-fe0f","uc_match":"1f646-1f3fe-2642-fe0f","uc_greedy":"1f646-1f3fe-2642","shortnames":[":man_gesturing_ok_medium_dark_skin_tone:"],"category":"people"},":man_gesturing_ok_tone5:":{"uc_base":"1f646-1f3ff-2642","uc_output":"1f646-1f3ff-200d-2642-fe0f","uc_match":"1f646-1f3ff-2642-fe0f","uc_greedy":"1f646-1f3ff-2642","shortnames":[":man_gesturing_ok_dark_skin_tone:"],"category":"people"},":man_getting_face_massage_tone1:":{"uc_base":"1f486-1f3fb-2642","uc_output":"1f486-1f3fb-200d-2642-fe0f","uc_match":"1f486-1f3fb-2642-fe0f","uc_greedy":"1f486-1f3fb-2642","shortnames":[":man_getting_face_massage_light_skin_tone:"],"category":"people"},":man_getting_face_massage_tone2:":{"uc_base":"1f486-1f3fc-2642","uc_output":"1f486-1f3fc-200d-2642-fe0f","uc_match":"1f486-1f3fc-2642-fe0f","uc_greedy":"1f486-1f3fc-2642","shortnames":[":man_getting_face_massage_medium_light_skin_tone:"],"category":"people"},":man_getting_face_massage_tone3:":{"uc_base":"1f486-1f3fd-2642","uc_output":"1f486-1f3fd-200d-2642-fe0f","uc_match":"1f486-1f3fd-2642-fe0f","uc_greedy":"1f486-1f3fd-2642","shortnames":[":man_getting_face_massage_medium_skin_tone:"],"category":"people"},":man_getting_face_massage_tone4:":{"uc_base":"1f486-1f3fe-2642","uc_output":"1f486-1f3fe-200d-2642-fe0f","uc_match":"1f486-1f3fe-2642-fe0f","uc_greedy":"1f486-1f3fe-2642","shortnames":[":man_getting_face_massage_medium_dark_skin_tone:"],"category":"people"},":man_getting_face_massage_tone5:":{"uc_base":"1f486-1f3ff-2642","uc_output":"1f486-1f3ff-200d-2642-fe0f","uc_match":"1f486-1f3ff-2642-fe0f","uc_greedy":"1f486-1f3ff-2642","shortnames":[":man_getting_face_massage_dark_skin_tone:"],"category":"people"},":man_getting_haircut_tone1:":{"uc_base":"1f487-1f3fb-2642","uc_output":"1f487-1f3fb-200d-2642-fe0f","uc_match":"1f487-1f3fb-2642-fe0f","uc_greedy":"1f487-1f3fb-2642","shortnames":[":man_getting_haircut_light_skin_tone:"],"category":"people"},":man_getting_haircut_tone2:":{"uc_base":"1f487-1f3fc-2642","uc_output":"1f487-1f3fc-200d-2642-fe0f","uc_match":"1f487-1f3fc-2642-fe0f","uc_greedy":"1f487-1f3fc-2642","shortnames":[":man_getting_haircut_medium_light_skin_tone:"],"category":"people"},":man_getting_haircut_tone3:":{"uc_base":"1f487-1f3fd-2642","uc_output":"1f487-1f3fd-200d-2642-fe0f","uc_match":"1f487-1f3fd-2642-fe0f","uc_greedy":"1f487-1f3fd-2642","shortnames":[":man_getting_haircut_medium_skin_tone:"],"category":"people"},":man_getting_haircut_tone4:":{"uc_base":"1f487-1f3fe-2642","uc_output":"1f487-1f3fe-200d-2642-fe0f","uc_match":"1f487-1f3fe-2642-fe0f","uc_greedy":"1f487-1f3fe-2642","shortnames":[":man_getting_haircut_medium_dark_skin_tone:"],"category":"people"},":man_getting_haircut_tone5:":{"uc_base":"1f487-1f3ff-2642","uc_output":"1f487-1f3ff-200d-2642-fe0f","uc_match":"1f487-1f3ff-2642-fe0f","uc_greedy":"1f487-1f3ff-2642","shortnames":[":man_getting_haircut_dark_skin_tone:"],"category":"people"},":man_golfing_tone1:":{"uc_base":"1f3cc-1f3fb-2642","uc_output":"1f3cc-1f3fb-200d-2642-fe0f","uc_match":"1f3cc-fe0f-1f3fb-2642-fe0f","uc_greedy":"1f3cc-1f3fb-2642","shortnames":[":man_golfing_light_skin_tone:"],"category":"activity"},":man_golfing_tone2:":{"uc_base":"1f3cc-1f3fc-2642","uc_output":"1f3cc-1f3fc-200d-2642-fe0f","uc_match":"1f3cc-fe0f-1f3fc-2642-fe0f","uc_greedy":"1f3cc-1f3fc-2642","shortnames":[":man_golfing_medium_light_skin_tone:"],"category":"activity"},":man_golfing_tone3:":{"uc_base":"1f3cc-1f3fd-2642","uc_output":"1f3cc-1f3fd-200d-2642-fe0f","uc_match":"1f3cc-fe0f-1f3fd-2642-fe0f","uc_greedy":"1f3cc-1f3fd-2642","shortnames":[":man_golfing_medium_skin_tone:"],"category":"activity"},":man_golfing_tone4:":{"uc_base":"1f3cc-1f3fe-2642","uc_output":"1f3cc-1f3fe-200d-2642-fe0f","uc_match":"1f3cc-fe0f-1f3fe-2642-fe0f","uc_greedy":"1f3cc-1f3fe-2642","shortnames":[":man_golfing_medium_dark_skin_tone:"],"category":"activity"},":man_golfing_tone5:":{"uc_base":"1f3cc-1f3ff-2642","uc_output":"1f3cc-1f3ff-200d-2642-fe0f","uc_match":"1f3cc-fe0f-1f3ff-2642-fe0f","uc_greedy":"1f3cc-1f3ff-2642","shortnames":[":man_golfing_dark_skin_tone:"],"category":"activity"},":man_guard_tone1:":{"uc_base":"1f482-1f3fb-2642","uc_output":"1f482-1f3fb-200d-2642-fe0f","uc_match":"1f482-1f3fb-2642-fe0f","uc_greedy":"1f482-1f3fb-2642","shortnames":[":man_guard_light_skin_tone:"],"category":"people"},":man_guard_tone2:":{"uc_base":"1f482-1f3fc-2642","uc_output":"1f482-1f3fc-200d-2642-fe0f","uc_match":"1f482-1f3fc-2642-fe0f","uc_greedy":"1f482-1f3fc-2642","shortnames":[":man_guard_medium_light_skin_tone:"],"category":"people"},":man_guard_tone3:":{"uc_base":"1f482-1f3fd-2642","uc_output":"1f482-1f3fd-200d-2642-fe0f","uc_match":"1f482-1f3fd-2642-fe0f","uc_greedy":"1f482-1f3fd-2642","shortnames":[":man_guard_medium_skin_tone:"],"category":"people"},":man_guard_tone4:":{"uc_base":"1f482-1f3fe-2642","uc_output":"1f482-1f3fe-200d-2642-fe0f","uc_match":"1f482-1f3fe-2642-fe0f","uc_greedy":"1f482-1f3fe-2642","shortnames":[":man_guard_medium_dark_skin_tone:"],"category":"people"},":man_guard_tone5:":{"uc_base":"1f482-1f3ff-2642","uc_output":"1f482-1f3ff-200d-2642-fe0f","uc_match":"1f482-1f3ff-2642-fe0f","uc_greedy":"1f482-1f3ff-2642","shortnames":[":man_guard_dark_skin_tone:"],"category":"people"},":man_health_worker_tone1:":{"uc_base":"1f468-1f3fb-2695","uc_output":"1f468-1f3fb-200d-2695-fe0f","uc_match":"1f468-1f3fb-2695-fe0f","uc_greedy":"1f468-1f3fb-2695","shortnames":[":man_health_worker_light_skin_tone:"],"category":"people"},":man_health_worker_tone2:":{"uc_base":"1f468-1f3fc-2695","uc_output":"1f468-1f3fc-200d-2695-fe0f","uc_match":"1f468-1f3fc-2695-fe0f","uc_greedy":"1f468-1f3fc-2695","shortnames":[":man_health_worker_medium_light_skin_tone:"],"category":"people"},":man_health_worker_tone3:":{"uc_base":"1f468-1f3fd-2695","uc_output":"1f468-1f3fd-200d-2695-fe0f","uc_match":"1f468-1f3fd-2695-fe0f","uc_greedy":"1f468-1f3fd-2695","shortnames":[":man_health_worker_medium_skin_tone:"],"category":"people"},":man_health_worker_tone4:":{"uc_base":"1f468-1f3fe-2695","uc_output":"1f468-1f3fe-200d-2695-fe0f","uc_match":"1f468-1f3fe-2695-fe0f","uc_greedy":"1f468-1f3fe-2695","shortnames":[":man_health_worker_medium_dark_skin_tone:"],"category":"people"},":man_health_worker_tone5:":{"uc_base":"1f468-1f3ff-2695","uc_output":"1f468-1f3ff-200d-2695-fe0f","uc_match":"1f468-1f3ff-2695-fe0f","uc_greedy":"1f468-1f3ff-2695","shortnames":[":man_health_worker_dark_skin_tone:"],"category":"people"},":man_in_lotus_position_tone1:":{"uc_base":"1f9d8-1f3fb-2642","uc_output":"1f9d8-1f3fb-200d-2642-fe0f","uc_match":"1f9d8-1f3fb-2642-fe0f","uc_greedy":"1f9d8-1f3fb-2642","shortnames":[":man_in_lotus_position_light_skin_tone:"],"category":"activity"},":man_in_lotus_position_tone2:":{"uc_base":"1f9d8-1f3fc-2642","uc_output":"1f9d8-1f3fc-200d-2642-fe0f","uc_match":"1f9d8-1f3fc-2642-fe0f","uc_greedy":"1f9d8-1f3fc-2642","shortnames":[":man_in_lotus_position_medium_light_skin_tone:"],"category":"activity"},":man_in_lotus_position_tone3:":{"uc_base":"1f9d8-1f3fd-2642","uc_output":"1f9d8-1f3fd-200d-2642-fe0f","uc_match":"1f9d8-1f3fd-2642-fe0f","uc_greedy":"1f9d8-1f3fd-2642","shortnames":[":man_in_lotus_position_medium_skin_tone:"],"category":"activity"},":man_in_lotus_position_tone4:":{"uc_base":"1f9d8-1f3fe-2642","uc_output":"1f9d8-1f3fe-200d-2642-fe0f","uc_match":"1f9d8-1f3fe-2642-fe0f","uc_greedy":"1f9d8-1f3fe-2642","shortnames":[":man_in_lotus_position_medium_dark_skin_tone:"],"category":"activity"},":man_in_lotus_position_tone5:":{"uc_base":"1f9d8-1f3ff-2642","uc_output":"1f9d8-1f3ff-200d-2642-fe0f","uc_match":"1f9d8-1f3ff-2642-fe0f","uc_greedy":"1f9d8-1f3ff-2642","shortnames":[":man_in_lotus_position_dark_skin_tone:"],"category":"activity"},":man_in_steamy_room_tone1:":{"uc_base":"1f9d6-1f3fb-2642","uc_output":"1f9d6-1f3fb-200d-2642-fe0f","uc_match":"1f9d6-1f3fb-2642-fe0f","uc_greedy":"1f9d6-1f3fb-2642","shortnames":[":man_in_steamy_room_light_skin_tone:"],"category":"people"},":man_in_steamy_room_tone2:":{"uc_base":"1f9d6-1f3fc-2642","uc_output":"1f9d6-1f3fc-200d-2642-fe0f","uc_match":"1f9d6-1f3fc-2642-fe0f","uc_greedy":"1f9d6-1f3fc-2642","shortnames":[":man_in_steamy_room_medium_light_skin_tone:"],"category":"people"},":man_in_steamy_room_tone3:":{"uc_base":"1f9d6-1f3fd-2642","uc_output":"1f9d6-1f3fd-200d-2642-fe0f","uc_match":"1f9d6-1f3fd-2642-fe0f","uc_greedy":"1f9d6-1f3fd-2642","shortnames":[":man_in_steamy_room_medium_skin_tone:"],"category":"people"},":man_in_steamy_room_tone4:":{"uc_base":"1f9d6-1f3fe-2642","uc_output":"1f9d6-1f3fe-200d-2642-fe0f","uc_match":"1f9d6-1f3fe-2642-fe0f","uc_greedy":"1f9d6-1f3fe-2642","shortnames":[":man_in_steamy_room_medium_dark_skin_tone:"],"category":"people"},":man_in_steamy_room_tone5:":{"uc_base":"1f9d6-1f3ff-2642","uc_output":"1f9d6-1f3ff-200d-2642-fe0f","uc_match":"1f9d6-1f3ff-2642-fe0f","uc_greedy":"1f9d6-1f3ff-2642","shortnames":[":man_in_steamy_room_dark_skin_tone:"],"category":"people"},":man_judge_tone1:":{"uc_base":"1f468-1f3fb-2696","uc_output":"1f468-1f3fb-200d-2696-fe0f","uc_match":"1f468-1f3fb-2696-fe0f","uc_greedy":"1f468-1f3fb-2696","shortnames":[":man_judge_light_skin_tone:"],"category":"people"},":man_judge_tone2:":{"uc_base":"1f468-1f3fc-2696","uc_output":"1f468-1f3fc-200d-2696-fe0f","uc_match":"1f468-1f3fc-2696-fe0f","uc_greedy":"1f468-1f3fc-2696","shortnames":[":man_judge_medium_light_skin_tone:"],"category":"people"},":man_judge_tone3:":{"uc_base":"1f468-1f3fd-2696","uc_output":"1f468-1f3fd-200d-2696-fe0f","uc_match":"1f468-1f3fd-2696-fe0f","uc_greedy":"1f468-1f3fd-2696","shortnames":[":man_judge_medium_skin_tone:"],"category":"people"},":man_judge_tone4:":{"uc_base":"1f468-1f3fe-2696","uc_output":"1f468-1f3fe-200d-2696-fe0f","uc_match":"1f468-1f3fe-2696-fe0f","uc_greedy":"1f468-1f3fe-2696","shortnames":[":man_judge_medium_dark_skin_tone:"],"category":"people"},":man_judge_tone5:":{"uc_base":"1f468-1f3ff-2696","uc_output":"1f468-1f3ff-200d-2696-fe0f","uc_match":"1f468-1f3ff-2696-fe0f","uc_greedy":"1f468-1f3ff-2696","shortnames":[":man_judge_dark_skin_tone:"],"category":"people"},":man_juggling_tone1:":{"uc_base":"1f939-1f3fb-2642","uc_output":"1f939-1f3fb-200d-2642-fe0f","uc_match":"1f939-1f3fb-2642-fe0f","uc_greedy":"1f939-1f3fb-2642","shortnames":[":man_juggling_light_skin_tone:"],"category":"activity"},":man_juggling_tone2:":{"uc_base":"1f939-1f3fc-2642","uc_output":"1f939-1f3fc-200d-2642-fe0f","uc_match":"1f939-1f3fc-2642-fe0f","uc_greedy":"1f939-1f3fc-2642","shortnames":[":man_juggling_medium_light_skin_tone:"],"category":"activity"},":man_juggling_tone3:":{"uc_base":"1f939-1f3fd-2642","uc_output":"1f939-1f3fd-200d-2642-fe0f","uc_match":"1f939-1f3fd-2642-fe0f","uc_greedy":"1f939-1f3fd-2642","shortnames":[":man_juggling_medium_skin_tone:"],"category":"activity"},":man_juggling_tone4:":{"uc_base":"1f939-1f3fe-2642","uc_output":"1f939-1f3fe-200d-2642-fe0f","uc_match":"1f939-1f3fe-2642-fe0f","uc_greedy":"1f939-1f3fe-2642","shortnames":[":man_juggling_medium_dark_skin_tone:"],"category":"activity"},":man_juggling_tone5:":{"uc_base":"1f939-1f3ff-2642","uc_output":"1f939-1f3ff-200d-2642-fe0f","uc_match":"1f939-1f3ff-2642-fe0f","uc_greedy":"1f939-1f3ff-2642","shortnames":[":man_juggling_dark_skin_tone:"],"category":"activity"},":man_lifting_weights_tone1:":{"uc_base":"1f3cb-1f3fb-2642","uc_output":"1f3cb-1f3fb-200d-2642-fe0f","uc_match":"1f3cb-fe0f-1f3fb-2642-fe0f","uc_greedy":"1f3cb-1f3fb-2642","shortnames":[":man_lifting_weights_light_skin_tone:"],"category":"activity"},":man_lifting_weights_tone2:":{"uc_base":"1f3cb-1f3fc-2642","uc_output":"1f3cb-1f3fc-200d-2642-fe0f","uc_match":"1f3cb-fe0f-1f3fc-2642-fe0f","uc_greedy":"1f3cb-1f3fc-2642","shortnames":[":man_lifting_weights_medium_light_skin_tone:"],"category":"activity"},":man_lifting_weights_tone3:":{"uc_base":"1f3cb-1f3fd-2642","uc_output":"1f3cb-1f3fd-200d-2642-fe0f","uc_match":"1f3cb-fe0f-1f3fd-2642-fe0f","uc_greedy":"1f3cb-1f3fd-2642","shortnames":[":man_lifting_weights_medium_skin_tone:"],"category":"activity"},":man_lifting_weights_tone4:":{"uc_base":"1f3cb-1f3fe-2642","uc_output":"1f3cb-1f3fe-200d-2642-fe0f","uc_match":"1f3cb-fe0f-1f3fe-2642-fe0f","uc_greedy":"1f3cb-1f3fe-2642","shortnames":[":man_lifting_weights_medium_dark_skin_tone:"],"category":"activity"},":man_lifting_weights_tone5:":{"uc_base":"1f3cb-1f3ff-2642","uc_output":"1f3cb-1f3ff-200d-2642-fe0f","uc_match":"1f3cb-fe0f-1f3ff-2642-fe0f","uc_greedy":"1f3cb-1f3ff-2642","shortnames":[":man_lifting_weights_dark_skin_tone:"],"category":"activity"},":man_mage_tone1:":{"uc_base":"1f9d9-1f3fb-2642","uc_output":"1f9d9-1f3fb-200d-2642-fe0f","uc_match":"1f9d9-1f3fb-2642-fe0f","uc_greedy":"1f9d9-1f3fb-2642","shortnames":[":man_mage_light_skin_tone:"],"category":"people"},":man_mage_tone2:":{"uc_base":"1f9d9-1f3fc-2642","uc_output":"1f9d9-1f3fc-200d-2642-fe0f","uc_match":"1f9d9-1f3fc-2642-fe0f","uc_greedy":"1f9d9-1f3fc-2642","shortnames":[":man_mage_medium_light_skin_tone:"],"category":"people"},":man_mage_tone3:":{"uc_base":"1f9d9-1f3fd-2642","uc_output":"1f9d9-1f3fd-200d-2642-fe0f","uc_match":"1f9d9-1f3fd-2642-fe0f","uc_greedy":"1f9d9-1f3fd-2642","shortnames":[":man_mage_medium_skin_tone:"],"category":"people"},":man_mage_tone4:":{"uc_base":"1f9d9-1f3fe-2642","uc_output":"1f9d9-1f3fe-200d-2642-fe0f","uc_match":"1f9d9-1f3fe-2642-fe0f","uc_greedy":"1f9d9-1f3fe-2642","shortnames":[":man_mage_medium_dark_skin_tone:"],"category":"people"},":man_mage_tone5:":{"uc_base":"1f9d9-1f3ff-2642","uc_output":"1f9d9-1f3ff-200d-2642-fe0f","uc_match":"1f9d9-1f3ff-2642-fe0f","uc_greedy":"1f9d9-1f3ff-2642","shortnames":[":man_mage_dark_skin_tone:"],"category":"people"},":man_mountain_biking_tone1:":{"uc_base":"1f6b5-1f3fb-2642","uc_output":"1f6b5-1f3fb-200d-2642-fe0f","uc_match":"1f6b5-1f3fb-2642-fe0f","uc_greedy":"1f6b5-1f3fb-2642","shortnames":[":man_mountain_biking_light_skin_tone:"],"category":"activity"},":man_mountain_biking_tone2:":{"uc_base":"1f6b5-1f3fc-2642","uc_output":"1f6b5-1f3fc-200d-2642-fe0f","uc_match":"1f6b5-1f3fc-2642-fe0f","uc_greedy":"1f6b5-1f3fc-2642","shortnames":[":man_mountain_biking_medium_light_skin_tone:"],"category":"activity"},":man_mountain_biking_tone3:":{"uc_base":"1f6b5-1f3fd-2642","uc_output":"1f6b5-1f3fd-200d-2642-fe0f","uc_match":"1f6b5-1f3fd-2642-fe0f","uc_greedy":"1f6b5-1f3fd-2642","shortnames":[":man_mountain_biking_medium_skin_tone:"],"category":"activity"},":man_mountain_biking_tone4:":{"uc_base":"1f6b5-1f3fe-2642","uc_output":"1f6b5-1f3fe-200d-2642-fe0f","uc_match":"1f6b5-1f3fe-2642-fe0f","uc_greedy":"1f6b5-1f3fe-2642","shortnames":[":man_mountain_biking_medium_dark_skin_tone:"],"category":"activity"},":man_mountain_biking_tone5:":{"uc_base":"1f6b5-1f3ff-2642","uc_output":"1f6b5-1f3ff-200d-2642-fe0f","uc_match":"1f6b5-1f3ff-2642-fe0f","uc_greedy":"1f6b5-1f3ff-2642","shortnames":[":man_mountain_biking_dark_skin_tone:"],"category":"activity"},":man_pilot_tone1:":{"uc_base":"1f468-1f3fb-2708","uc_output":"1f468-1f3fb-200d-2708-fe0f","uc_match":"1f468-1f3fb-2708-fe0f","uc_greedy":"1f468-1f3fb-2708","shortnames":[":man_pilot_light_skin_tone:"],"category":"people"},":man_pilot_tone2:":{"uc_base":"1f468-1f3fc-2708","uc_output":"1f468-1f3fc-200d-2708-fe0f","uc_match":"1f468-1f3fc-2708-fe0f","uc_greedy":"1f468-1f3fc-2708","shortnames":[":man_pilot_medium_light_skin_tone:"],"category":"people"},":man_pilot_tone3:":{"uc_base":"1f468-1f3fd-2708","uc_output":"1f468-1f3fd-200d-2708-fe0f","uc_match":"1f468-1f3fd-2708-fe0f","uc_greedy":"1f468-1f3fd-2708","shortnames":[":man_pilot_medium_skin_tone:"],"category":"people"},":man_pilot_tone4:":{"uc_base":"1f468-1f3fe-2708","uc_output":"1f468-1f3fe-200d-2708-fe0f","uc_match":"1f468-1f3fe-2708-fe0f","uc_greedy":"1f468-1f3fe-2708","shortnames":[":man_pilot_medium_dark_skin_tone:"],"category":"people"},":man_pilot_tone5:":{"uc_base":"1f468-1f3ff-2708","uc_output":"1f468-1f3ff-200d-2708-fe0f","uc_match":"1f468-1f3ff-2708-fe0f","uc_greedy":"1f468-1f3ff-2708","shortnames":[":man_pilot_dark_skin_tone:"],"category":"people"},":man_playing_handball_tone1:":{"uc_base":"1f93e-1f3fb-2642","uc_output":"1f93e-1f3fb-200d-2642-fe0f","uc_match":"1f93e-1f3fb-2642-fe0f","uc_greedy":"1f93e-1f3fb-2642","shortnames":[":man_playing_handball_light_skin_tone:"],"category":"activity"},":man_playing_handball_tone2:":{"uc_base":"1f93e-1f3fc-2642","uc_output":"1f93e-1f3fc-200d-2642-fe0f","uc_match":"1f93e-1f3fc-2642-fe0f","uc_greedy":"1f93e-1f3fc-2642","shortnames":[":man_playing_handball_medium_light_skin_tone:"],"category":"activity"},":man_playing_handball_tone3:":{"uc_base":"1f93e-1f3fd-2642","uc_output":"1f93e-1f3fd-200d-2642-fe0f","uc_match":"1f93e-1f3fd-2642-fe0f","uc_greedy":"1f93e-1f3fd-2642","shortnames":[":man_playing_handball_medium_skin_tone:"],"category":"activity"},":man_playing_handball_tone4:":{"uc_base":"1f93e-1f3fe-2642","uc_output":"1f93e-1f3fe-200d-2642-fe0f","uc_match":"1f93e-1f3fe-2642-fe0f","uc_greedy":"1f93e-1f3fe-2642","shortnames":[":man_playing_handball_medium_dark_skin_tone:"],"category":"activity"},":man_playing_handball_tone5:":{"uc_base":"1f93e-1f3ff-2642","uc_output":"1f93e-1f3ff-200d-2642-fe0f","uc_match":"1f93e-1f3ff-2642-fe0f","uc_greedy":"1f93e-1f3ff-2642","shortnames":[":man_playing_handball_dark_skin_tone:"],"category":"activity"},":man_playing_water_polo_tone1:":{"uc_base":"1f93d-1f3fb-2642","uc_output":"1f93d-1f3fb-200d-2642-fe0f","uc_match":"1f93d-1f3fb-2642-fe0f","uc_greedy":"1f93d-1f3fb-2642","shortnames":[":man_playing_water_polo_light_skin_tone:"],"category":"activity"},":man_playing_water_polo_tone2:":{"uc_base":"1f93d-1f3fc-2642","uc_output":"1f93d-1f3fc-200d-2642-fe0f","uc_match":"1f93d-1f3fc-2642-fe0f","uc_greedy":"1f93d-1f3fc-2642","shortnames":[":man_playing_water_polo_medium_light_skin_tone:"],"category":"activity"},":man_playing_water_polo_tone3:":{"uc_base":"1f93d-1f3fd-2642","uc_output":"1f93d-1f3fd-200d-2642-fe0f","uc_match":"1f93d-1f3fd-2642-fe0f","uc_greedy":"1f93d-1f3fd-2642","shortnames":[":man_playing_water_polo_medium_skin_tone:"],"category":"activity"},":man_playing_water_polo_tone4:":{"uc_base":"1f93d-1f3fe-2642","uc_output":"1f93d-1f3fe-200d-2642-fe0f","uc_match":"1f93d-1f3fe-2642-fe0f","uc_greedy":"1f93d-1f3fe-2642","shortnames":[":man_playing_water_polo_medium_dark_skin_tone:"],"category":"activity"},":man_playing_water_polo_tone5:":{"uc_base":"1f93d-1f3ff-2642","uc_output":"1f93d-1f3ff-200d-2642-fe0f","uc_match":"1f93d-1f3ff-2642-fe0f","uc_greedy":"1f93d-1f3ff-2642","shortnames":[":man_playing_water_polo_dark_skin_tone:"],"category":"activity"},":man_police_officer_tone1:":{"uc_base":"1f46e-1f3fb-2642","uc_output":"1f46e-1f3fb-200d-2642-fe0f","uc_match":"1f46e-1f3fb-2642-fe0f","uc_greedy":"1f46e-1f3fb-2642","shortnames":[":man_police_officer_light_skin_tone:"],"category":"people"},":man_police_officer_tone2:":{"uc_base":"1f46e-1f3fc-2642","uc_output":"1f46e-1f3fc-200d-2642-fe0f","uc_match":"1f46e-1f3fc-2642-fe0f","uc_greedy":"1f46e-1f3fc-2642","shortnames":[":man_police_officer_medium_light_skin_tone:"],"category":"people"},":man_police_officer_tone3:":{"uc_base":"1f46e-1f3fd-2642","uc_output":"1f46e-1f3fd-200d-2642-fe0f","uc_match":"1f46e-1f3fd-2642-fe0f","uc_greedy":"1f46e-1f3fd-2642","shortnames":[":man_police_officer_medium_skin_tone:"],"category":"people"},":man_police_officer_tone4:":{"uc_base":"1f46e-1f3fe-2642","uc_output":"1f46e-1f3fe-200d-2642-fe0f","uc_match":"1f46e-1f3fe-2642-fe0f","uc_greedy":"1f46e-1f3fe-2642","shortnames":[":man_police_officer_medium_dark_skin_tone:"],"category":"people"},":man_police_officer_tone5:":{"uc_base":"1f46e-1f3ff-2642","uc_output":"1f46e-1f3ff-200d-2642-fe0f","uc_match":"1f46e-1f3ff-2642-fe0f","uc_greedy":"1f46e-1f3ff-2642","shortnames":[":man_police_officer_dark_skin_tone:"],"category":"people"},":man_pouting_tone1:":{"uc_base":"1f64e-1f3fb-2642","uc_output":"1f64e-1f3fb-200d-2642-fe0f","uc_match":"1f64e-1f3fb-2642-fe0f","uc_greedy":"1f64e-1f3fb-2642","shortnames":[":man_pouting_light_skin_tone:"],"category":"people"},":man_pouting_tone2:":{"uc_base":"1f64e-1f3fc-2642","uc_output":"1f64e-1f3fc-200d-2642-fe0f","uc_match":"1f64e-1f3fc-2642-fe0f","uc_greedy":"1f64e-1f3fc-2642","shortnames":[":man_pouting_medium_light_skin_tone:"],"category":"people"},":man_pouting_tone3:":{"uc_base":"1f64e-1f3fd-2642","uc_output":"1f64e-1f3fd-200d-2642-fe0f","uc_match":"1f64e-1f3fd-2642-fe0f","uc_greedy":"1f64e-1f3fd-2642","shortnames":[":man_pouting_medium_skin_tone:"],"category":"people"},":man_pouting_tone4:":{"uc_base":"1f64e-1f3fe-2642","uc_output":"1f64e-1f3fe-200d-2642-fe0f","uc_match":"1f64e-1f3fe-2642-fe0f","uc_greedy":"1f64e-1f3fe-2642","shortnames":[":man_pouting_medium_dark_skin_tone:"],"category":"people"},":man_pouting_tone5:":{"uc_base":"1f64e-1f3ff-2642","uc_output":"1f64e-1f3ff-200d-2642-fe0f","uc_match":"1f64e-1f3ff-2642-fe0f","uc_greedy":"1f64e-1f3ff-2642","shortnames":[":man_pouting_dark_skin_tone:"],"category":"people"},":man_raising_hand_tone1:":{"uc_base":"1f64b-1f3fb-2642","uc_output":"1f64b-1f3fb-200d-2642-fe0f","uc_match":"1f64b-1f3fb-2642-fe0f","uc_greedy":"1f64b-1f3fb-2642","shortnames":[":man_raising_hand_light_skin_tone:"],"category":"people"},":man_raising_hand_tone2:":{"uc_base":"1f64b-1f3fc-2642","uc_output":"1f64b-1f3fc-200d-2642-fe0f","uc_match":"1f64b-1f3fc-2642-fe0f","uc_greedy":"1f64b-1f3fc-2642","shortnames":[":man_raising_hand_medium_light_skin_tone:"],"category":"people"},":man_raising_hand_tone3:":{"uc_base":"1f64b-1f3fd-2642","uc_output":"1f64b-1f3fd-200d-2642-fe0f","uc_match":"1f64b-1f3fd-2642-fe0f","uc_greedy":"1f64b-1f3fd-2642","shortnames":[":man_raising_hand_medium_skin_tone:"],"category":"people"},":man_raising_hand_tone4:":{"uc_base":"1f64b-1f3fe-2642","uc_output":"1f64b-1f3fe-200d-2642-fe0f","uc_match":"1f64b-1f3fe-2642-fe0f","uc_greedy":"1f64b-1f3fe-2642","shortnames":[":man_raising_hand_medium_dark_skin_tone:"],"category":"people"},":man_raising_hand_tone5:":{"uc_base":"1f64b-1f3ff-2642","uc_output":"1f64b-1f3ff-200d-2642-fe0f","uc_match":"1f64b-1f3ff-2642-fe0f","uc_greedy":"1f64b-1f3ff-2642","shortnames":[":man_raising_hand_dark_skin_tone:"],"category":"people"},":man_rowing_boat_tone1:":{"uc_base":"1f6a3-1f3fb-2642","uc_output":"1f6a3-1f3fb-200d-2642-fe0f","uc_match":"1f6a3-1f3fb-2642-fe0f","uc_greedy":"1f6a3-1f3fb-2642","shortnames":[":man_rowing_boat_light_skin_tone:"],"category":"activity"},":man_rowing_boat_tone2:":{"uc_base":"1f6a3-1f3fc-2642","uc_output":"1f6a3-1f3fc-200d-2642-fe0f","uc_match":"1f6a3-1f3fc-2642-fe0f","uc_greedy":"1f6a3-1f3fc-2642","shortnames":[":man_rowing_boat_medium_light_skin_tone:"],"category":"activity"},":man_rowing_boat_tone3:":{"uc_base":"1f6a3-1f3fd-2642","uc_output":"1f6a3-1f3fd-200d-2642-fe0f","uc_match":"1f6a3-1f3fd-2642-fe0f","uc_greedy":"1f6a3-1f3fd-2642","shortnames":[":man_rowing_boat_medium_skin_tone:"],"category":"activity"},":man_rowing_boat_tone4:":{"uc_base":"1f6a3-1f3fe-2642","uc_output":"1f6a3-1f3fe-200d-2642-fe0f","uc_match":"1f6a3-1f3fe-2642-fe0f","uc_greedy":"1f6a3-1f3fe-2642","shortnames":[":man_rowing_boat_medium_dark_skin_tone:"],"category":"activity"},":man_rowing_boat_tone5:":{"uc_base":"1f6a3-1f3ff-2642","uc_output":"1f6a3-1f3ff-200d-2642-fe0f","uc_match":"1f6a3-1f3ff-2642-fe0f","uc_greedy":"1f6a3-1f3ff-2642","shortnames":[":man_rowing_boat_dark_skin_tone:"],"category":"activity"},":man_running_tone1:":{"uc_base":"1f3c3-1f3fb-2642","uc_output":"1f3c3-1f3fb-200d-2642-fe0f","uc_match":"1f3c3-1f3fb-2642-fe0f","uc_greedy":"1f3c3-1f3fb-2642","shortnames":[":man_running_light_skin_tone:"],"category":"people"},":man_running_tone2:":{"uc_base":"1f3c3-1f3fc-2642","uc_output":"1f3c3-1f3fc-200d-2642-fe0f","uc_match":"1f3c3-1f3fc-2642-fe0f","uc_greedy":"1f3c3-1f3fc-2642","shortnames":[":man_running_medium_light_skin_tone:"],"category":"people"},":man_running_tone3:":{"uc_base":"1f3c3-1f3fd-2642","uc_output":"1f3c3-1f3fd-200d-2642-fe0f","uc_match":"1f3c3-1f3fd-2642-fe0f","uc_greedy":"1f3c3-1f3fd-2642","shortnames":[":man_running_medium_skin_tone:"],"category":"people"},":man_running_tone4:":{"uc_base":"1f3c3-1f3fe-2642","uc_output":"1f3c3-1f3fe-200d-2642-fe0f","uc_match":"1f3c3-1f3fe-2642-fe0f","uc_greedy":"1f3c3-1f3fe-2642","shortnames":[":man_running_medium_dark_skin_tone:"],"category":"people"},":man_running_tone5:":{"uc_base":"1f3c3-1f3ff-2642","uc_output":"1f3c3-1f3ff-200d-2642-fe0f","uc_match":"1f3c3-1f3ff-2642-fe0f","uc_greedy":"1f3c3-1f3ff-2642","shortnames":[":man_running_dark_skin_tone:"],"category":"people"},":man_shrugging_tone1:":{"uc_base":"1f937-1f3fb-2642","uc_output":"1f937-1f3fb-200d-2642-fe0f","uc_match":"1f937-1f3fb-2642-fe0f","uc_greedy":"1f937-1f3fb-2642","shortnames":[":man_shrugging_light_skin_tone:"],"category":"people"},":man_shrugging_tone2:":{"uc_base":"1f937-1f3fc-2642","uc_output":"1f937-1f3fc-200d-2642-fe0f","uc_match":"1f937-1f3fc-2642-fe0f","uc_greedy":"1f937-1f3fc-2642","shortnames":[":man_shrugging_medium_light_skin_tone:"],"category":"people"},":man_shrugging_tone3:":{"uc_base":"1f937-1f3fd-2642","uc_output":"1f937-1f3fd-200d-2642-fe0f","uc_match":"1f937-1f3fd-2642-fe0f","uc_greedy":"1f937-1f3fd-2642","shortnames":[":man_shrugging_medium_skin_tone:"],"category":"people"},":man_shrugging_tone4:":{"uc_base":"1f937-1f3fe-2642","uc_output":"1f937-1f3fe-200d-2642-fe0f","uc_match":"1f937-1f3fe-2642-fe0f","uc_greedy":"1f937-1f3fe-2642","shortnames":[":man_shrugging_medium_dark_skin_tone:"],"category":"people"},":man_shrugging_tone5:":{"uc_base":"1f937-1f3ff-2642","uc_output":"1f937-1f3ff-200d-2642-fe0f","uc_match":"1f937-1f3ff-2642-fe0f","uc_greedy":"1f937-1f3ff-2642","shortnames":[":man_shrugging_dark_skin_tone:"],"category":"people"},":man_surfing_tone1:":{"uc_base":"1f3c4-1f3fb-2642","uc_output":"1f3c4-1f3fb-200d-2642-fe0f","uc_match":"1f3c4-1f3fb-2642-fe0f","uc_greedy":"1f3c4-1f3fb-2642","shortnames":[":man_surfing_light_skin_tone:"],"category":"activity"},":man_surfing_tone2:":{"uc_base":"1f3c4-1f3fc-2642","uc_output":"1f3c4-1f3fc-200d-2642-fe0f","uc_match":"1f3c4-1f3fc-2642-fe0f","uc_greedy":"1f3c4-1f3fc-2642","shortnames":[":man_surfing_medium_light_skin_tone:"],"category":"activity"},":man_surfing_tone3:":{"uc_base":"1f3c4-1f3fd-2642","uc_output":"1f3c4-1f3fd-200d-2642-fe0f","uc_match":"1f3c4-1f3fd-2642-fe0f","uc_greedy":"1f3c4-1f3fd-2642","shortnames":[":man_surfing_medium_skin_tone:"],"category":"activity"},":man_surfing_tone4:":{"uc_base":"1f3c4-1f3fe-2642","uc_output":"1f3c4-1f3fe-200d-2642-fe0f","uc_match":"1f3c4-1f3fe-2642-fe0f","uc_greedy":"1f3c4-1f3fe-2642","shortnames":[":man_surfing_medium_dark_skin_tone:"],"category":"activity"},":man_surfing_tone5:":{"uc_base":"1f3c4-1f3ff-2642","uc_output":"1f3c4-1f3ff-200d-2642-fe0f","uc_match":"1f3c4-1f3ff-2642-fe0f","uc_greedy":"1f3c4-1f3ff-2642","shortnames":[":man_surfing_dark_skin_tone:"],"category":"activity"},":man_swimming_tone1:":{"uc_base":"1f3ca-1f3fb-2642","uc_output":"1f3ca-1f3fb-200d-2642-fe0f","uc_match":"1f3ca-1f3fb-2642-fe0f","uc_greedy":"1f3ca-1f3fb-2642","shortnames":[":man_swimming_light_skin_tone:"],"category":"activity"},":man_swimming_tone2:":{"uc_base":"1f3ca-1f3fc-2642","uc_output":"1f3ca-1f3fc-200d-2642-fe0f","uc_match":"1f3ca-1f3fc-2642-fe0f","uc_greedy":"1f3ca-1f3fc-2642","shortnames":[":man_swimming_medium_light_skin_tone:"],"category":"activity"},":man_swimming_tone3:":{"uc_base":"1f3ca-1f3fd-2642","uc_output":"1f3ca-1f3fd-200d-2642-fe0f","uc_match":"1f3ca-1f3fd-2642-fe0f","uc_greedy":"1f3ca-1f3fd-2642","shortnames":[":man_swimming_medium_skin_tone:"],"category":"activity"},":man_swimming_tone4:":{"uc_base":"1f3ca-1f3fe-2642","uc_output":"1f3ca-1f3fe-200d-2642-fe0f","uc_match":"1f3ca-1f3fe-2642-fe0f","uc_greedy":"1f3ca-1f3fe-2642","shortnames":[":man_swimming_medium_dark_skin_tone:"],"category":"activity"},":man_swimming_tone5:":{"uc_base":"1f3ca-1f3ff-2642","uc_output":"1f3ca-1f3ff-200d-2642-fe0f","uc_match":"1f3ca-1f3ff-2642-fe0f","uc_greedy":"1f3ca-1f3ff-2642","shortnames":[":man_swimming_dark_skin_tone:"],"category":"activity"},":man_tipping_hand_tone1:":{"uc_base":"1f481-1f3fb-2642","uc_output":"1f481-1f3fb-200d-2642-fe0f","uc_match":"1f481-1f3fb-2642-fe0f","uc_greedy":"1f481-1f3fb-2642","shortnames":[":man_tipping_hand_light_skin_tone:"],"category":"people"},":man_tipping_hand_tone2:":{"uc_base":"1f481-1f3fc-2642","uc_output":"1f481-1f3fc-200d-2642-fe0f","uc_match":"1f481-1f3fc-2642-fe0f","uc_greedy":"1f481-1f3fc-2642","shortnames":[":man_tipping_hand_medium_light_skin_tone:"],"category":"people"},":man_tipping_hand_tone3:":{"uc_base":"1f481-1f3fd-2642","uc_output":"1f481-1f3fd-200d-2642-fe0f","uc_match":"1f481-1f3fd-2642-fe0f","uc_greedy":"1f481-1f3fd-2642","shortnames":[":man_tipping_hand_medium_skin_tone:"],"category":"people"},":man_tipping_hand_tone4:":{"uc_base":"1f481-1f3fe-2642","uc_output":"1f481-1f3fe-200d-2642-fe0f","uc_match":"1f481-1f3fe-2642-fe0f","uc_greedy":"1f481-1f3fe-2642","shortnames":[":man_tipping_hand_medium_dark_skin_tone:"],"category":"people"},":man_tipping_hand_tone5:":{"uc_base":"1f481-1f3ff-2642","uc_output":"1f481-1f3ff-200d-2642-fe0f","uc_match":"1f481-1f3ff-2642-fe0f","uc_greedy":"1f481-1f3ff-2642","shortnames":[":man_tipping_hand_dark_skin_tone:"],"category":"people"},":man_vampire_tone1:":{"uc_base":"1f9db-1f3fb-2642","uc_output":"1f9db-1f3fb-200d-2642-fe0f","uc_match":"1f9db-1f3fb-2642-fe0f","uc_greedy":"1f9db-1f3fb-2642","shortnames":[":man_vampire_light_skin_tone:"],"category":"people"},":man_vampire_tone2:":{"uc_base":"1f9db-1f3fc-2642","uc_output":"1f9db-1f3fc-200d-2642-fe0f","uc_match":"1f9db-1f3fc-2642-fe0f","uc_greedy":"1f9db-1f3fc-2642","shortnames":[":man_vampire_medium_light_skin_tone:"],"category":"people"},":man_vampire_tone3:":{"uc_base":"1f9db-1f3fd-2642","uc_output":"1f9db-1f3fd-200d-2642-fe0f","uc_match":"1f9db-1f3fd-2642-fe0f","uc_greedy":"1f9db-1f3fd-2642","shortnames":[":man_vampire_medium_skin_tone:"],"category":"people"},":man_vampire_tone4:":{"uc_base":"1f9db-1f3fe-2642","uc_output":"1f9db-1f3fe-200d-2642-fe0f","uc_match":"1f9db-1f3fe-2642-fe0f","uc_greedy":"1f9db-1f3fe-2642","shortnames":[":man_vampire_medium_dark_skin_tone:"],"category":"people"},":man_vampire_tone5:":{"uc_base":"1f9db-1f3ff-2642","uc_output":"1f9db-1f3ff-200d-2642-fe0f","uc_match":"1f9db-1f3ff-2642-fe0f","uc_greedy":"1f9db-1f3ff-2642","shortnames":[":man_vampire_dark_skin_tone:"],"category":"people"},":man_walking_tone1:":{"uc_base":"1f6b6-1f3fb-2642","uc_output":"1f6b6-1f3fb-200d-2642-fe0f","uc_match":"1f6b6-1f3fb-2642-fe0f","uc_greedy":"1f6b6-1f3fb-2642","shortnames":[":man_walking_light_skin_tone:"],"category":"people"},":man_walking_tone2:":{"uc_base":"1f6b6-1f3fc-2642","uc_output":"1f6b6-1f3fc-200d-2642-fe0f","uc_match":"1f6b6-1f3fc-2642-fe0f","uc_greedy":"1f6b6-1f3fc-2642","shortnames":[":man_walking_medium_light_skin_tone:"],"category":"people"},":man_walking_tone3:":{"uc_base":"1f6b6-1f3fd-2642","uc_output":"1f6b6-1f3fd-200d-2642-fe0f","uc_match":"1f6b6-1f3fd-2642-fe0f","uc_greedy":"1f6b6-1f3fd-2642","shortnames":[":man_walking_medium_skin_tone:"],"category":"people"},":man_walking_tone4:":{"uc_base":"1f6b6-1f3fe-2642","uc_output":"1f6b6-1f3fe-200d-2642-fe0f","uc_match":"1f6b6-1f3fe-2642-fe0f","uc_greedy":"1f6b6-1f3fe-2642","shortnames":[":man_walking_medium_dark_skin_tone:"],"category":"people"},":man_walking_tone5:":{"uc_base":"1f6b6-1f3ff-2642","uc_output":"1f6b6-1f3ff-200d-2642-fe0f","uc_match":"1f6b6-1f3ff-2642-fe0f","uc_greedy":"1f6b6-1f3ff-2642","shortnames":[":man_walking_dark_skin_tone:"],"category":"people"},":man_wearing_turban_tone1:":{"uc_base":"1f473-1f3fb-2642","uc_output":"1f473-1f3fb-200d-2642-fe0f","uc_match":"1f473-1f3fb-2642-fe0f","uc_greedy":"1f473-1f3fb-2642","shortnames":[":man_wearing_turban_light_skin_tone:"],"category":"people"},":man_wearing_turban_tone2:":{"uc_base":"1f473-1f3fc-2642","uc_output":"1f473-1f3fc-200d-2642-fe0f","uc_match":"1f473-1f3fc-2642-fe0f","uc_greedy":"1f473-1f3fc-2642","shortnames":[":man_wearing_turban_medium_light_skin_tone:"],"category":"people"},":man_wearing_turban_tone3:":{"uc_base":"1f473-1f3fd-2642","uc_output":"1f473-1f3fd-200d-2642-fe0f","uc_match":"1f473-1f3fd-2642-fe0f","uc_greedy":"1f473-1f3fd-2642","shortnames":[":man_wearing_turban_medium_skin_tone:"],"category":"people"},":man_wearing_turban_tone4:":{"uc_base":"1f473-1f3fe-2642","uc_output":"1f473-1f3fe-200d-2642-fe0f","uc_match":"1f473-1f3fe-2642-fe0f","uc_greedy":"1f473-1f3fe-2642","shortnames":[":man_wearing_turban_medium_dark_skin_tone:"],"category":"people"},":man_wearing_turban_tone5:":{"uc_base":"1f473-1f3ff-2642","uc_output":"1f473-1f3ff-200d-2642-fe0f","uc_match":"1f473-1f3ff-2642-fe0f","uc_greedy":"1f473-1f3ff-2642","shortnames":[":man_wearing_turban_dark_skin_tone:"],"category":"people"},":mermaid_tone1:":{"uc_base":"1f9dc-1f3fb-2640","uc_output":"1f9dc-1f3fb-200d-2640-fe0f","uc_match":"1f9dc-1f3fb-2640-fe0f","uc_greedy":"1f9dc-1f3fb-2640","shortnames":[":mermaid_light_skin_tone:"],"category":"people"},":mermaid_tone2:":{"uc_base":"1f9dc-1f3fc-2640","uc_output":"1f9dc-1f3fc-200d-2640-fe0f","uc_match":"1f9dc-1f3fc-2640-fe0f","uc_greedy":"1f9dc-1f3fc-2640","shortnames":[":mermaid_medium_light_skin_tone:"],"category":"people"},":mermaid_tone3:":{"uc_base":"1f9dc-1f3fd-2640","uc_output":"1f9dc-1f3fd-200d-2640-fe0f","uc_match":"1f9dc-1f3fd-2640-fe0f","uc_greedy":"1f9dc-1f3fd-2640","shortnames":[":mermaid_medium_skin_tone:"],"category":"people"},":mermaid_tone4:":{"uc_base":"1f9dc-1f3fe-2640","uc_output":"1f9dc-1f3fe-200d-2640-fe0f","uc_match":"1f9dc-1f3fe-2640-fe0f","uc_greedy":"1f9dc-1f3fe-2640","shortnames":[":mermaid_medium_dark_skin_tone:"],"category":"people"},":mermaid_tone5:":{"uc_base":"1f9dc-1f3ff-2640","uc_output":"1f9dc-1f3ff-200d-2640-fe0f","uc_match":"1f9dc-1f3ff-2640-fe0f","uc_greedy":"1f9dc-1f3ff-2640","shortnames":[":mermaid_dark_skin_tone:"],"category":"people"},":merman_tone1:":{"uc_base":"1f9dc-1f3fb-2642","uc_output":"1f9dc-1f3fb-200d-2642-fe0f","uc_match":"1f9dc-1f3fb-2642-fe0f","uc_greedy":"1f9dc-1f3fb-2642","shortnames":[":merman_light_skin_tone:"],"category":"people"},":merman_tone2:":{"uc_base":"1f9dc-1f3fc-2642","uc_output":"1f9dc-1f3fc-200d-2642-fe0f","uc_match":"1f9dc-1f3fc-2642-fe0f","uc_greedy":"1f9dc-1f3fc-2642","shortnames":[":merman_medium_light_skin_tone:"],"category":"people"},":merman_tone3:":{"uc_base":"1f9dc-1f3fd-2642","uc_output":"1f9dc-1f3fd-200d-2642-fe0f","uc_match":"1f9dc-1f3fd-2642-fe0f","uc_greedy":"1f9dc-1f3fd-2642","shortnames":[":merman_medium_skin_tone:"],"category":"people"},":merman_tone4:":{"uc_base":"1f9dc-1f3fe-2642","uc_output":"1f9dc-1f3fe-200d-2642-fe0f","uc_match":"1f9dc-1f3fe-2642-fe0f","uc_greedy":"1f9dc-1f3fe-2642","shortnames":[":merman_medium_dark_skin_tone:"],"category":"people"},":merman_tone5:":{"uc_base":"1f9dc-1f3ff-2642","uc_output":"1f9dc-1f3ff-200d-2642-fe0f","uc_match":"1f9dc-1f3ff-2642-fe0f","uc_greedy":"1f9dc-1f3ff-2642","shortnames":[":merman_dark_skin_tone:"],"category":"people"},":woman_biking_tone1:":{"uc_base":"1f6b4-1f3fb-2640","uc_output":"1f6b4-1f3fb-200d-2640-fe0f","uc_match":"1f6b4-1f3fb-2640-fe0f","uc_greedy":"1f6b4-1f3fb-2640","shortnames":[":woman_biking_light_skin_tone:"],"category":"activity"},":woman_biking_tone2:":{"uc_base":"1f6b4-1f3fc-2640","uc_output":"1f6b4-1f3fc-200d-2640-fe0f","uc_match":"1f6b4-1f3fc-2640-fe0f","uc_greedy":"1f6b4-1f3fc-2640","shortnames":[":woman_biking_medium_light_skin_tone:"],"category":"activity"},":woman_biking_tone3:":{"uc_base":"1f6b4-1f3fd-2640","uc_output":"1f6b4-1f3fd-200d-2640-fe0f","uc_match":"1f6b4-1f3fd-2640-fe0f","uc_greedy":"1f6b4-1f3fd-2640","shortnames":[":woman_biking_medium_skin_tone:"],"category":"activity"},":woman_biking_tone4:":{"uc_base":"1f6b4-1f3fe-2640","uc_output":"1f6b4-1f3fe-200d-2640-fe0f","uc_match":"1f6b4-1f3fe-2640-fe0f","uc_greedy":"1f6b4-1f3fe-2640","shortnames":[":woman_biking_medium_dark_skin_tone:"],"category":"activity"},":woman_biking_tone5:":{"uc_base":"1f6b4-1f3ff-2640","uc_output":"1f6b4-1f3ff-200d-2640-fe0f","uc_match":"1f6b4-1f3ff-2640-fe0f","uc_greedy":"1f6b4-1f3ff-2640","shortnames":[":woman_biking_dark_skin_tone:"],"category":"activity"},":woman_bowing_tone1:":{"uc_base":"1f647-1f3fb-2640","uc_output":"1f647-1f3fb-200d-2640-fe0f","uc_match":"1f647-1f3fb-2640-fe0f","uc_greedy":"1f647-1f3fb-2640","shortnames":[":woman_bowing_light_skin_tone:"],"category":"people"},":woman_bowing_tone2:":{"uc_base":"1f647-1f3fc-2640","uc_output":"1f647-1f3fc-200d-2640-fe0f","uc_match":"1f647-1f3fc-2640-fe0f","uc_greedy":"1f647-1f3fc-2640","shortnames":[":woman_bowing_medium_light_skin_tone:"],"category":"people"},":woman_bowing_tone3:":{"uc_base":"1f647-1f3fd-2640","uc_output":"1f647-1f3fd-200d-2640-fe0f","uc_match":"1f647-1f3fd-2640-fe0f","uc_greedy":"1f647-1f3fd-2640","shortnames":[":woman_bowing_medium_skin_tone:"],"category":"people"},":woman_bowing_tone4:":{"uc_base":"1f647-1f3fe-2640","uc_output":"1f647-1f3fe-200d-2640-fe0f","uc_match":"1f647-1f3fe-2640-fe0f","uc_greedy":"1f647-1f3fe-2640","shortnames":[":woman_bowing_medium_dark_skin_tone:"],"category":"people"},":woman_bowing_tone5:":{"uc_base":"1f647-1f3ff-2640","uc_output":"1f647-1f3ff-200d-2640-fe0f","uc_match":"1f647-1f3ff-2640-fe0f","uc_greedy":"1f647-1f3ff-2640","shortnames":[":woman_bowing_dark_skin_tone:"],"category":"people"},":woman_cartwheeling_tone1:":{"uc_base":"1f938-1f3fb-2640","uc_output":"1f938-1f3fb-200d-2640-fe0f","uc_match":"1f938-1f3fb-2640-fe0f","uc_greedy":"1f938-1f3fb-2640","shortnames":[":woman_cartwheeling_light_skin_tone:"],"category":"activity"},":woman_cartwheeling_tone2:":{"uc_base":"1f938-1f3fc-2640","uc_output":"1f938-1f3fc-200d-2640-fe0f","uc_match":"1f938-1f3fc-2640-fe0f","uc_greedy":"1f938-1f3fc-2640","shortnames":[":woman_cartwheeling_medium_light_skin_tone:"],"category":"activity"},":woman_cartwheeling_tone3:":{"uc_base":"1f938-1f3fd-2640","uc_output":"1f938-1f3fd-200d-2640-fe0f","uc_match":"1f938-1f3fd-2640-fe0f","uc_greedy":"1f938-1f3fd-2640","shortnames":[":woman_cartwheeling_medium_skin_tone:"],"category":"activity"},":woman_cartwheeling_tone4:":{"uc_base":"1f938-1f3fe-2640","uc_output":"1f938-1f3fe-200d-2640-fe0f","uc_match":"1f938-1f3fe-2640-fe0f","uc_greedy":"1f938-1f3fe-2640","shortnames":[":woman_cartwheeling_medium_dark_skin_tone:"],"category":"activity"},":woman_cartwheeling_tone5:":{"uc_base":"1f938-1f3ff-2640","uc_output":"1f938-1f3ff-200d-2640-fe0f","uc_match":"1f938-1f3ff-2640-fe0f","uc_greedy":"1f938-1f3ff-2640","shortnames":[":woman_cartwheeling_dark_skin_tone:"],"category":"activity"},":woman_climbing_tone1:":{"uc_base":"1f9d7-1f3fb-2640","uc_output":"1f9d7-1f3fb-200d-2640-fe0f","uc_match":"1f9d7-1f3fb-2640-fe0f","uc_greedy":"1f9d7-1f3fb-2640","shortnames":[":woman_climbing_light_skin_tone:"],"category":"activity"},":woman_climbing_tone2:":{"uc_base":"1f9d7-1f3fc-2640","uc_output":"1f9d7-1f3fc-200d-2640-fe0f","uc_match":"1f9d7-1f3fc-2640-fe0f","uc_greedy":"1f9d7-1f3fc-2640","shortnames":[":woman_climbing_medium_light_skin_tone:"],"category":"activity"},":woman_climbing_tone3:":{"uc_base":"1f9d7-1f3fd-2640","uc_output":"1f9d7-1f3fd-200d-2640-fe0f","uc_match":"1f9d7-1f3fd-2640-fe0f","uc_greedy":"1f9d7-1f3fd-2640","shortnames":[":woman_climbing_medium_skin_tone:"],"category":"activity"},":woman_climbing_tone4:":{"uc_base":"1f9d7-1f3fe-2640","uc_output":"1f9d7-1f3fe-200d-2640-fe0f","uc_match":"1f9d7-1f3fe-2640-fe0f","uc_greedy":"1f9d7-1f3fe-2640","shortnames":[":woman_climbing_medium_dark_skin_tone:"],"category":"activity"},":woman_climbing_tone5:":{"uc_base":"1f9d7-1f3ff-2640","uc_output":"1f9d7-1f3ff-200d-2640-fe0f","uc_match":"1f9d7-1f3ff-2640-fe0f","uc_greedy":"1f9d7-1f3ff-2640","shortnames":[":woman_climbing_dark_skin_tone:"],"category":"activity"},":woman_construction_worker_tone1:":{"uc_base":"1f477-1f3fb-2640","uc_output":"1f477-1f3fb-200d-2640-fe0f","uc_match":"1f477-1f3fb-2640-fe0f","uc_greedy":"1f477-1f3fb-2640","shortnames":[":woman_construction_worker_light_skin_tone:"],"category":"people"},":woman_construction_worker_tone2:":{"uc_base":"1f477-1f3fc-2640","uc_output":"1f477-1f3fc-200d-2640-fe0f","uc_match":"1f477-1f3fc-2640-fe0f","uc_greedy":"1f477-1f3fc-2640","shortnames":[":woman_construction_worker_medium_light_skin_tone:"],"category":"people"},":woman_construction_worker_tone3:":{"uc_base":"1f477-1f3fd-2640","uc_output":"1f477-1f3fd-200d-2640-fe0f","uc_match":"1f477-1f3fd-2640-fe0f","uc_greedy":"1f477-1f3fd-2640","shortnames":[":woman_construction_worker_medium_skin_tone:"],"category":"people"},":woman_construction_worker_tone4:":{"uc_base":"1f477-1f3fe-2640","uc_output":"1f477-1f3fe-200d-2640-fe0f","uc_match":"1f477-1f3fe-2640-fe0f","uc_greedy":"1f477-1f3fe-2640","shortnames":[":woman_construction_worker_medium_dark_skin_tone:"],"category":"people"},":woman_construction_worker_tone5:":{"uc_base":"1f477-1f3ff-2640","uc_output":"1f477-1f3ff-200d-2640-fe0f","uc_match":"1f477-1f3ff-2640-fe0f","uc_greedy":"1f477-1f3ff-2640","shortnames":[":woman_construction_worker_dark_skin_tone:"],"category":"people"},":woman_detective_tone1:":{"uc_base":"1f575-1f3fb-2640","uc_output":"1f575-1f3fb-200d-2640-fe0f","uc_match":"1f575-fe0f-1f3fb-2640-fe0f","uc_greedy":"1f575-1f3fb-2640","shortnames":[":woman_detective_light_skin_tone:"],"category":"people"},":woman_detective_tone2:":{"uc_base":"1f575-1f3fc-2640","uc_output":"1f575-1f3fc-200d-2640-fe0f","uc_match":"1f575-fe0f-1f3fc-2640-fe0f","uc_greedy":"1f575-1f3fc-2640","shortnames":[":woman_detective_medium_light_skin_tone:"],"category":"people"},":woman_detective_tone3:":{"uc_base":"1f575-1f3fd-2640","uc_output":"1f575-1f3fd-200d-2640-fe0f","uc_match":"1f575-fe0f-1f3fd-2640-fe0f","uc_greedy":"1f575-1f3fd-2640","shortnames":[":woman_detective_medium_skin_tone:"],"category":"people"},":woman_detective_tone4:":{"uc_base":"1f575-1f3fe-2640","uc_output":"1f575-1f3fe-200d-2640-fe0f","uc_match":"1f575-fe0f-1f3fe-2640-fe0f","uc_greedy":"1f575-1f3fe-2640","shortnames":[":woman_detective_medium_dark_skin_tone:"],"category":"people"},":woman_detective_tone5:":{"uc_base":"1f575-1f3ff-2640","uc_output":"1f575-1f3ff-200d-2640-fe0f","uc_match":"1f575-fe0f-1f3ff-2640-fe0f","uc_greedy":"1f575-1f3ff-2640","shortnames":[":woman_detective_dark_skin_tone:"],"category":"people"},":woman_elf_tone1:":{"uc_base":"1f9dd-1f3fb-2640","uc_output":"1f9dd-1f3fb-200d-2640-fe0f","uc_match":"1f9dd-1f3fb-2640-fe0f","uc_greedy":"1f9dd-1f3fb-2640","shortnames":[":woman_elf_light_skin_tone:"],"category":"people"},":woman_elf_tone2:":{"uc_base":"1f9dd-1f3fc-2640","uc_output":"1f9dd-1f3fc-200d-2640-fe0f","uc_match":"1f9dd-1f3fc-2640-fe0f","uc_greedy":"1f9dd-1f3fc-2640","shortnames":[":woman_elf_medium_light_skin_tone:"],"category":"people"},":woman_elf_tone3:":{"uc_base":"1f9dd-1f3fd-2640","uc_output":"1f9dd-1f3fd-200d-2640-fe0f","uc_match":"1f9dd-1f3fd-2640-fe0f","uc_greedy":"1f9dd-1f3fd-2640","shortnames":[":woman_elf_medium_skin_tone:"],"category":"people"},":woman_elf_tone4:":{"uc_base":"1f9dd-1f3fe-2640","uc_output":"1f9dd-1f3fe-200d-2640-fe0f","uc_match":"1f9dd-1f3fe-2640-fe0f","uc_greedy":"1f9dd-1f3fe-2640","shortnames":[":woman_elf_medium_dark_skin_tone:"],"category":"people"},":woman_elf_tone5:":{"uc_base":"1f9dd-1f3ff-2640","uc_output":"1f9dd-1f3ff-200d-2640-fe0f","uc_match":"1f9dd-1f3ff-2640-fe0f","uc_greedy":"1f9dd-1f3ff-2640","shortnames":[":woman_elf_dark_skin_tone:"],"category":"people"},":woman_facepalming_tone1:":{"uc_base":"1f926-1f3fb-2640","uc_output":"1f926-1f3fb-200d-2640-fe0f","uc_match":"1f926-1f3fb-2640-fe0f","uc_greedy":"1f926-1f3fb-2640","shortnames":[":woman_facepalming_light_skin_tone:"],"category":"people"},":woman_facepalming_tone2:":{"uc_base":"1f926-1f3fc-2640","uc_output":"1f926-1f3fc-200d-2640-fe0f","uc_match":"1f926-1f3fc-2640-fe0f","uc_greedy":"1f926-1f3fc-2640","shortnames":[":woman_facepalming_medium_light_skin_tone:"],"category":"people"},":woman_facepalming_tone3:":{"uc_base":"1f926-1f3fd-2640","uc_output":"1f926-1f3fd-200d-2640-fe0f","uc_match":"1f926-1f3fd-2640-fe0f","uc_greedy":"1f926-1f3fd-2640","shortnames":[":woman_facepalming_medium_skin_tone:"],"category":"people"},":woman_facepalming_tone4:":{"uc_base":"1f926-1f3fe-2640","uc_output":"1f926-1f3fe-200d-2640-fe0f","uc_match":"1f926-1f3fe-2640-fe0f","uc_greedy":"1f926-1f3fe-2640","shortnames":[":woman_facepalming_medium_dark_skin_tone:"],"category":"people"},":woman_facepalming_tone5:":{"uc_base":"1f926-1f3ff-2640","uc_output":"1f926-1f3ff-200d-2640-fe0f","uc_match":"1f926-1f3ff-2640-fe0f","uc_greedy":"1f926-1f3ff-2640","shortnames":[":woman_facepalming_dark_skin_tone:"],"category":"people"},":woman_fairy_tone1:":{"uc_base":"1f9da-1f3fb-2640","uc_output":"1f9da-1f3fb-200d-2640-fe0f","uc_match":"1f9da-1f3fb-2640-fe0f","uc_greedy":"1f9da-1f3fb-2640","shortnames":[":woman_fairy_light_skin_tone:"],"category":"people"},":woman_fairy_tone2:":{"uc_base":"1f9da-1f3fc-2640","uc_output":"1f9da-1f3fc-200d-2640-fe0f","uc_match":"1f9da-1f3fc-2640-fe0f","uc_greedy":"1f9da-1f3fc-2640","shortnames":[":woman_fairy_medium_light_skin_tone:"],"category":"people"},":woman_fairy_tone3:":{"uc_base":"1f9da-1f3fd-2640","uc_output":"1f9da-1f3fd-200d-2640-fe0f","uc_match":"1f9da-1f3fd-2640-fe0f","uc_greedy":"1f9da-1f3fd-2640","shortnames":[":woman_fairy_medium_skin_tone:"],"category":"people"},":woman_fairy_tone4:":{"uc_base":"1f9da-1f3fe-2640","uc_output":"1f9da-1f3fe-200d-2640-fe0f","uc_match":"1f9da-1f3fe-2640-fe0f","uc_greedy":"1f9da-1f3fe-2640","shortnames":[":woman_fairy_medium_dark_skin_tone:"],"category":"people"},":woman_fairy_tone5:":{"uc_base":"1f9da-1f3ff-2640","uc_output":"1f9da-1f3ff-200d-2640-fe0f","uc_match":"1f9da-1f3ff-2640-fe0f","uc_greedy":"1f9da-1f3ff-2640","shortnames":[":woman_fairy_dark_skin_tone:"],"category":"people"},":woman_frowning_tone1:":{"uc_base":"1f64d-1f3fb-2640","uc_output":"1f64d-1f3fb-200d-2640-fe0f","uc_match":"1f64d-1f3fb-2640-fe0f","uc_greedy":"1f64d-1f3fb-2640","shortnames":[":woman_frowning_light_skin_tone:"],"category":"people"},":woman_frowning_tone2:":{"uc_base":"1f64d-1f3fc-2640","uc_output":"1f64d-1f3fc-200d-2640-fe0f","uc_match":"1f64d-1f3fc-2640-fe0f","uc_greedy":"1f64d-1f3fc-2640","shortnames":[":woman_frowning_medium_light_skin_tone:"],"category":"people"},":woman_frowning_tone3:":{"uc_base":"1f64d-1f3fd-2640","uc_output":"1f64d-1f3fd-200d-2640-fe0f","uc_match":"1f64d-1f3fd-2640-fe0f","uc_greedy":"1f64d-1f3fd-2640","shortnames":[":woman_frowning_medium_skin_tone:"],"category":"people"},":woman_frowning_tone4:":{"uc_base":"1f64d-1f3fe-2640","uc_output":"1f64d-1f3fe-200d-2640-fe0f","uc_match":"1f64d-1f3fe-2640-fe0f","uc_greedy":"1f64d-1f3fe-2640","shortnames":[":woman_frowning_medium_dark_skin_tone:"],"category":"people"},":woman_frowning_tone5:":{"uc_base":"1f64d-1f3ff-2640","uc_output":"1f64d-1f3ff-200d-2640-fe0f","uc_match":"1f64d-1f3ff-2640-fe0f","uc_greedy":"1f64d-1f3ff-2640","shortnames":[":woman_frowning_dark_skin_tone:"],"category":"people"},":woman_gesturing_no_tone1:":{"uc_base":"1f645-1f3fb-2640","uc_output":"1f645-1f3fb-200d-2640-fe0f","uc_match":"1f645-1f3fb-2640-fe0f","uc_greedy":"1f645-1f3fb-2640","shortnames":[":woman_gesturing_no_light_skin_tone:"],"category":"people"},":woman_gesturing_no_tone2:":{"uc_base":"1f645-1f3fc-2640","uc_output":"1f645-1f3fc-200d-2640-fe0f","uc_match":"1f645-1f3fc-2640-fe0f","uc_greedy":"1f645-1f3fc-2640","shortnames":[":woman_gesturing_no_medium_light_skin_tone:"],"category":"people"},":woman_gesturing_no_tone3:":{"uc_base":"1f645-1f3fd-2640","uc_output":"1f645-1f3fd-200d-2640-fe0f","uc_match":"1f645-1f3fd-2640-fe0f","uc_greedy":"1f645-1f3fd-2640","shortnames":[":woman_gesturing_no_medium_skin_tone:"],"category":"people"},":woman_gesturing_no_tone4:":{"uc_base":"1f645-1f3fe-2640","uc_output":"1f645-1f3fe-200d-2640-fe0f","uc_match":"1f645-1f3fe-2640-fe0f","uc_greedy":"1f645-1f3fe-2640","shortnames":[":woman_gesturing_no_medium_dark_skin_tone:"],"category":"people"},":woman_gesturing_no_tone5:":{"uc_base":"1f645-1f3ff-2640","uc_output":"1f645-1f3ff-200d-2640-fe0f","uc_match":"1f645-1f3ff-2640-fe0f","uc_greedy":"1f645-1f3ff-2640","shortnames":[":woman_gesturing_no_dark_skin_tone:"],"category":"people"},":woman_gesturing_ok_tone1:":{"uc_base":"1f646-1f3fb-2640","uc_output":"1f646-1f3fb-200d-2640-fe0f","uc_match":"1f646-1f3fb-2640-fe0f","uc_greedy":"1f646-1f3fb-2640","shortnames":[":woman_gesturing_ok_light_skin_tone:"],"category":"people"},":woman_gesturing_ok_tone2:":{"uc_base":"1f646-1f3fc-2640","uc_output":"1f646-1f3fc-200d-2640-fe0f","uc_match":"1f646-1f3fc-2640-fe0f","uc_greedy":"1f646-1f3fc-2640","shortnames":[":woman_gesturing_ok_medium_light_skin_tone:"],"category":"people"},":woman_gesturing_ok_tone3:":{"uc_base":"1f646-1f3fd-2640","uc_output":"1f646-1f3fd-200d-2640-fe0f","uc_match":"1f646-1f3fd-2640-fe0f","uc_greedy":"1f646-1f3fd-2640","shortnames":[":woman_gesturing_ok_medium_skin_tone:"],"category":"people"},":woman_gesturing_ok_tone4:":{"uc_base":"1f646-1f3fe-2640","uc_output":"1f646-1f3fe-200d-2640-fe0f","uc_match":"1f646-1f3fe-2640-fe0f","uc_greedy":"1f646-1f3fe-2640","shortnames":[":woman_gesturing_ok_medium_dark_skin_tone:"],"category":"people"},":woman_gesturing_ok_tone5:":{"uc_base":"1f646-1f3ff-2640","uc_output":"1f646-1f3ff-200d-2640-fe0f","uc_match":"1f646-1f3ff-2640-fe0f","uc_greedy":"1f646-1f3ff-2640","shortnames":[":woman_gesturing_ok_dark_skin_tone:"],"category":"people"},":woman_getting_face_massage_tone1:":{"uc_base":"1f486-1f3fb-2640","uc_output":"1f486-1f3fb-200d-2640-fe0f","uc_match":"1f486-1f3fb-2640-fe0f","uc_greedy":"1f486-1f3fb-2640","shortnames":[":woman_getting_face_massage_light_skin_tone:"],"category":"people"},":woman_getting_face_massage_tone2:":{"uc_base":"1f486-1f3fc-2640","uc_output":"1f486-1f3fc-200d-2640-fe0f","uc_match":"1f486-1f3fc-2640-fe0f","uc_greedy":"1f486-1f3fc-2640","shortnames":[":woman_getting_face_massage_medium_light_skin_tone:"],"category":"people"},":woman_getting_face_massage_tone3:":{"uc_base":"1f486-1f3fd-2640","uc_output":"1f486-1f3fd-200d-2640-fe0f","uc_match":"1f486-1f3fd-2640-fe0f","uc_greedy":"1f486-1f3fd-2640","shortnames":[":woman_getting_face_massage_medium_skin_tone:"],"category":"people"},":woman_getting_face_massage_tone4:":{"uc_base":"1f486-1f3fe-2640","uc_output":"1f486-1f3fe-200d-2640-fe0f","uc_match":"1f486-1f3fe-2640-fe0f","uc_greedy":"1f486-1f3fe-2640","shortnames":[":woman_getting_face_massage_medium_dark_skin_tone:"],"category":"people"},":woman_getting_face_massage_tone5:":{"uc_base":"1f486-1f3ff-2640","uc_output":"1f486-1f3ff-200d-2640-fe0f","uc_match":"1f486-1f3ff-2640-fe0f","uc_greedy":"1f486-1f3ff-2640","shortnames":[":woman_getting_face_massage_dark_skin_tone:"],"category":"people"},":woman_getting_haircut_tone1:":{"uc_base":"1f487-1f3fb-2640","uc_output":"1f487-1f3fb-200d-2640-fe0f","uc_match":"1f487-1f3fb-2640-fe0f","uc_greedy":"1f487-1f3fb-2640","shortnames":[":woman_getting_haircut_light_skin_tone:"],"category":"people"},":woman_getting_haircut_tone2:":{"uc_base":"1f487-1f3fc-2640","uc_output":"1f487-1f3fc-200d-2640-fe0f","uc_match":"1f487-1f3fc-2640-fe0f","uc_greedy":"1f487-1f3fc-2640","shortnames":[":woman_getting_haircut_medium_light_skin_tone:"],"category":"people"},":woman_getting_haircut_tone3:":{"uc_base":"1f487-1f3fd-2640","uc_output":"1f487-1f3fd-200d-2640-fe0f","uc_match":"1f487-1f3fd-2640-fe0f","uc_greedy":"1f487-1f3fd-2640","shortnames":[":woman_getting_haircut_medium_skin_tone:"],"category":"people"},":woman_getting_haircut_tone4:":{"uc_base":"1f487-1f3fe-2640","uc_output":"1f487-1f3fe-200d-2640-fe0f","uc_match":"1f487-1f3fe-2640-fe0f","uc_greedy":"1f487-1f3fe-2640","shortnames":[":woman_getting_haircut_medium_dark_skin_tone:"],"category":"people"},":woman_getting_haircut_tone5:":{"uc_base":"1f487-1f3ff-2640","uc_output":"1f487-1f3ff-200d-2640-fe0f","uc_match":"1f487-1f3ff-2640-fe0f","uc_greedy":"1f487-1f3ff-2640","shortnames":[":woman_getting_haircut_dark_skin_tone:"],"category":"people"},":woman_golfing_tone1:":{"uc_base":"1f3cc-1f3fb-2640","uc_output":"1f3cc-1f3fb-200d-2640-fe0f","uc_match":"1f3cc-fe0f-1f3fb-2640-fe0f","uc_greedy":"1f3cc-1f3fb-2640","shortnames":[":woman_golfing_light_skin_tone:"],"category":"activity"},":woman_golfing_tone2:":{"uc_base":"1f3cc-1f3fc-2640","uc_output":"1f3cc-1f3fc-200d-2640-fe0f","uc_match":"1f3cc-fe0f-1f3fc-2640-fe0f","uc_greedy":"1f3cc-1f3fc-2640","shortnames":[":woman_golfing_medium_light_skin_tone:"],"category":"activity"},":woman_golfing_tone3:":{"uc_base":"1f3cc-1f3fd-2640","uc_output":"1f3cc-1f3fd-200d-2640-fe0f","uc_match":"1f3cc-fe0f-1f3fd-2640-fe0f","uc_greedy":"1f3cc-1f3fd-2640","shortnames":[":woman_golfing_medium_skin_tone:"],"category":"activity"},":woman_golfing_tone4:":{"uc_base":"1f3cc-1f3fe-2640","uc_output":"1f3cc-1f3fe-200d-2640-fe0f","uc_match":"1f3cc-fe0f-1f3fe-2640-fe0f","uc_greedy":"1f3cc-1f3fe-2640","shortnames":[":woman_golfing_medium_dark_skin_tone:"],"category":"activity"},":woman_golfing_tone5:":{"uc_base":"1f3cc-1f3ff-2640","uc_output":"1f3cc-1f3ff-200d-2640-fe0f","uc_match":"1f3cc-fe0f-1f3ff-2640-fe0f","uc_greedy":"1f3cc-1f3ff-2640","shortnames":[":woman_golfing_dark_skin_tone:"],"category":"activity"},":woman_guard_tone1:":{"uc_base":"1f482-1f3fb-2640","uc_output":"1f482-1f3fb-200d-2640-fe0f","uc_match":"1f482-1f3fb-2640-fe0f","uc_greedy":"1f482-1f3fb-2640","shortnames":[":woman_guard_light_skin_tone:"],"category":"people"},":woman_guard_tone2:":{"uc_base":"1f482-1f3fc-2640","uc_output":"1f482-1f3fc-200d-2640-fe0f","uc_match":"1f482-1f3fc-2640-fe0f","uc_greedy":"1f482-1f3fc-2640","shortnames":[":woman_guard_medium_light_skin_tone:"],"category":"people"},":woman_guard_tone3:":{"uc_base":"1f482-1f3fd-2640","uc_output":"1f482-1f3fd-200d-2640-fe0f","uc_match":"1f482-1f3fd-2640-fe0f","uc_greedy":"1f482-1f3fd-2640","shortnames":[":woman_guard_medium_skin_tone:"],"category":"people"},":woman_guard_tone4:":{"uc_base":"1f482-1f3fe-2640","uc_output":"1f482-1f3fe-200d-2640-fe0f","uc_match":"1f482-1f3fe-2640-fe0f","uc_greedy":"1f482-1f3fe-2640","shortnames":[":woman_guard_medium_dark_skin_tone:"],"category":"people"},":woman_guard_tone5:":{"uc_base":"1f482-1f3ff-2640","uc_output":"1f482-1f3ff-200d-2640-fe0f","uc_match":"1f482-1f3ff-2640-fe0f","uc_greedy":"1f482-1f3ff-2640","shortnames":[":woman_guard_dark_skin_tone:"],"category":"people"},":woman_health_worker_tone1:":{"uc_base":"1f469-1f3fb-2695","uc_output":"1f469-1f3fb-200d-2695-fe0f","uc_match":"1f469-1f3fb-2695-fe0f","uc_greedy":"1f469-1f3fb-2695","shortnames":[":woman_health_worker_light_skin_tone:"],"category":"people"},":woman_health_worker_tone2:":{"uc_base":"1f469-1f3fc-2695","uc_output":"1f469-1f3fc-200d-2695-fe0f","uc_match":"1f469-1f3fc-2695-fe0f","uc_greedy":"1f469-1f3fc-2695","shortnames":[":woman_health_worker_medium_light_skin_tone:"],"category":"people"},":woman_health_worker_tone3:":{"uc_base":"1f469-1f3fd-2695","uc_output":"1f469-1f3fd-200d-2695-fe0f","uc_match":"1f469-1f3fd-2695-fe0f","uc_greedy":"1f469-1f3fd-2695","shortnames":[":woman_health_worker_medium_skin_tone:"],"category":"people"},":woman_health_worker_tone4:":{"uc_base":"1f469-1f3fe-2695","uc_output":"1f469-1f3fe-200d-2695-fe0f","uc_match":"1f469-1f3fe-2695-fe0f","uc_greedy":"1f469-1f3fe-2695","shortnames":[":woman_health_worker_medium_dark_skin_tone:"],"category":"people"},":woman_health_worker_tone5:":{"uc_base":"1f469-1f3ff-2695","uc_output":"1f469-1f3ff-200d-2695-fe0f","uc_match":"1f469-1f3ff-2695-fe0f","uc_greedy":"1f469-1f3ff-2695","shortnames":[":woman_health_worker_dark_skin_tone:"],"category":"people"},":woman_in_lotus_position_tone1:":{"uc_base":"1f9d8-1f3fb-2640","uc_output":"1f9d8-1f3fb-200d-2640-fe0f","uc_match":"1f9d8-1f3fb-2640-fe0f","uc_greedy":"1f9d8-1f3fb-2640","shortnames":[":woman_in_lotus_position_light_skin_tone:"],"category":"activity"},":woman_in_lotus_position_tone2:":{"uc_base":"1f9d8-1f3fc-2640","uc_output":"1f9d8-1f3fc-200d-2640-fe0f","uc_match":"1f9d8-1f3fc-2640-fe0f","uc_greedy":"1f9d8-1f3fc-2640","shortnames":[":woman_in_lotus_position_medium_light_skin_tone:"],"category":"activity"},":woman_in_lotus_position_tone3:":{"uc_base":"1f9d8-1f3fd-2640","uc_output":"1f9d8-1f3fd-200d-2640-fe0f","uc_match":"1f9d8-1f3fd-2640-fe0f","uc_greedy":"1f9d8-1f3fd-2640","shortnames":[":woman_in_lotus_position_medium_skin_tone:"],"category":"activity"},":woman_in_lotus_position_tone4:":{"uc_base":"1f9d8-1f3fe-2640","uc_output":"1f9d8-1f3fe-200d-2640-fe0f","uc_match":"1f9d8-1f3fe-2640-fe0f","uc_greedy":"1f9d8-1f3fe-2640","shortnames":[":woman_in_lotus_position_medium_dark_skin_tone:"],"category":"activity"},":woman_in_lotus_position_tone5:":{"uc_base":"1f9d8-1f3ff-2640","uc_output":"1f9d8-1f3ff-200d-2640-fe0f","uc_match":"1f9d8-1f3ff-2640-fe0f","uc_greedy":"1f9d8-1f3ff-2640","shortnames":[":woman_in_lotus_position_dark_skin_tone:"],"category":"activity"},":woman_in_steamy_room_tone1:":{"uc_base":"1f9d6-1f3fb-2640","uc_output":"1f9d6-1f3fb-200d-2640-fe0f","uc_match":"1f9d6-1f3fb-2640-fe0f","uc_greedy":"1f9d6-1f3fb-2640","shortnames":[":woman_in_steamy_room_light_skin_tone:"],"category":"people"},":woman_in_steamy_room_tone2:":{"uc_base":"1f9d6-1f3fc-2640","uc_output":"1f9d6-1f3fc-200d-2640-fe0f","uc_match":"1f9d6-1f3fc-2640-fe0f","uc_greedy":"1f9d6-1f3fc-2640","shortnames":[":woman_in_steamy_room_medium_light_skin_tone:"],"category":"people"},":woman_in_steamy_room_tone3:":{"uc_base":"1f9d6-1f3fd-2640","uc_output":"1f9d6-1f3fd-200d-2640-fe0f","uc_match":"1f9d6-1f3fd-2640-fe0f","uc_greedy":"1f9d6-1f3fd-2640","shortnames":[":woman_in_steamy_room_medium_skin_tone:"],"category":"people"},":woman_in_steamy_room_tone4:":{"uc_base":"1f9d6-1f3fe-2640","uc_output":"1f9d6-1f3fe-200d-2640-fe0f","uc_match":"1f9d6-1f3fe-2640-fe0f","uc_greedy":"1f9d6-1f3fe-2640","shortnames":[":woman_in_steamy_room_medium_dark_skin_tone:"],"category":"people"},":woman_in_steamy_room_tone5:":{"uc_base":"1f9d6-1f3ff-2640","uc_output":"1f9d6-1f3ff-200d-2640-fe0f","uc_match":"1f9d6-1f3ff-2640-fe0f","uc_greedy":"1f9d6-1f3ff-2640","shortnames":[":woman_in_steamy_room_dark_skin_tone:"],"category":"people"},":woman_judge_tone1:":{"uc_base":"1f469-1f3fb-2696","uc_output":"1f469-1f3fb-200d-2696-fe0f","uc_match":"1f469-1f3fb-2696-fe0f","uc_greedy":"1f469-1f3fb-2696","shortnames":[":woman_judge_light_skin_tone:"],"category":"people"},":woman_judge_tone2:":{"uc_base":"1f469-1f3fc-2696","uc_output":"1f469-1f3fc-200d-2696-fe0f","uc_match":"1f469-1f3fc-2696-fe0f","uc_greedy":"1f469-1f3fc-2696","shortnames":[":woman_judge_medium_light_skin_tone:"],"category":"people"},":woman_judge_tone3:":{"uc_base":"1f469-1f3fd-2696","uc_output":"1f469-1f3fd-200d-2696-fe0f","uc_match":"1f469-1f3fd-2696-fe0f","uc_greedy":"1f469-1f3fd-2696","shortnames":[":woman_judge_medium_skin_tone:"],"category":"people"},":woman_judge_tone4:":{"uc_base":"1f469-1f3fe-2696","uc_output":"1f469-1f3fe-200d-2696-fe0f","uc_match":"1f469-1f3fe-2696-fe0f","uc_greedy":"1f469-1f3fe-2696","shortnames":[":woman_judge_medium_dark_skin_tone:"],"category":"people"},":woman_judge_tone5:":{"uc_base":"1f469-1f3ff-2696","uc_output":"1f469-1f3ff-200d-2696-fe0f","uc_match":"1f469-1f3ff-2696-fe0f","uc_greedy":"1f469-1f3ff-2696","shortnames":[":woman_judge_dark_skin_tone:"],"category":"people"},":woman_juggling_tone1:":{"uc_base":"1f939-1f3fb-2640","uc_output":"1f939-1f3fb-200d-2640-fe0f","uc_match":"1f939-1f3fb-2640-fe0f","uc_greedy":"1f939-1f3fb-2640","shortnames":[":woman_juggling_light_skin_tone:"],"category":"activity"},":woman_juggling_tone2:":{"uc_base":"1f939-1f3fc-2640","uc_output":"1f939-1f3fc-200d-2640-fe0f","uc_match":"1f939-1f3fc-2640-fe0f","uc_greedy":"1f939-1f3fc-2640","shortnames":[":woman_juggling_medium_light_skin_tone:"],"category":"activity"},":woman_juggling_tone3:":{"uc_base":"1f939-1f3fd-2640","uc_output":"1f939-1f3fd-200d-2640-fe0f","uc_match":"1f939-1f3fd-2640-fe0f","uc_greedy":"1f939-1f3fd-2640","shortnames":[":woman_juggling_medium_skin_tone:"],"category":"activity"},":woman_juggling_tone4:":{"uc_base":"1f939-1f3fe-2640","uc_output":"1f939-1f3fe-200d-2640-fe0f","uc_match":"1f939-1f3fe-2640-fe0f","uc_greedy":"1f939-1f3fe-2640","shortnames":[":woman_juggling_medium_dark_skin_tone:"],"category":"activity"},":woman_juggling_tone5:":{"uc_base":"1f939-1f3ff-2640","uc_output":"1f939-1f3ff-200d-2640-fe0f","uc_match":"1f939-1f3ff-2640-fe0f","uc_greedy":"1f939-1f3ff-2640","shortnames":[":woman_juggling_dark_skin_tone:"],"category":"activity"},":woman_lifting_weights_tone1:":{"uc_base":"1f3cb-1f3fb-2640","uc_output":"1f3cb-1f3fb-200d-2640-fe0f","uc_match":"1f3cb-fe0f-1f3fb-2640-fe0f","uc_greedy":"1f3cb-1f3fb-2640","shortnames":[":woman_lifting_weights_light_skin_tone:"],"category":"activity"},":woman_lifting_weights_tone2:":{"uc_base":"1f3cb-1f3fc-2640","uc_output":"1f3cb-1f3fc-200d-2640-fe0f","uc_match":"1f3cb-fe0f-1f3fc-2640-fe0f","uc_greedy":"1f3cb-1f3fc-2640","shortnames":[":woman_lifting_weights_medium_light_skin_tone:"],"category":"activity"},":woman_lifting_weights_tone3:":{"uc_base":"1f3cb-1f3fd-2640","uc_output":"1f3cb-1f3fd-200d-2640-fe0f","uc_match":"1f3cb-fe0f-1f3fd-2640-fe0f","uc_greedy":"1f3cb-1f3fd-2640","shortnames":[":woman_lifting_weights_medium_skin_tone:"],"category":"activity"},":woman_lifting_weights_tone4:":{"uc_base":"1f3cb-1f3fe-2640","uc_output":"1f3cb-1f3fe-200d-2640-fe0f","uc_match":"1f3cb-fe0f-1f3fe-2640-fe0f","uc_greedy":"1f3cb-1f3fe-2640","shortnames":[":woman_lifting_weights_medium_dark_skin_tone:"],"category":"activity"},":woman_lifting_weights_tone5:":{"uc_base":"1f3cb-1f3ff-2640","uc_output":"1f3cb-1f3ff-200d-2640-fe0f","uc_match":"1f3cb-fe0f-1f3ff-2640-fe0f","uc_greedy":"1f3cb-1f3ff-2640","shortnames":[":woman_lifting_weights_dark_skin_tone:"],"category":"activity"},":woman_mage_tone1:":{"uc_base":"1f9d9-1f3fb-2640","uc_output":"1f9d9-1f3fb-200d-2640-fe0f","uc_match":"1f9d9-1f3fb-2640-fe0f","uc_greedy":"1f9d9-1f3fb-2640","shortnames":[":woman_mage_light_skin_tone:"],"category":"people"},":woman_mage_tone2:":{"uc_base":"1f9d9-1f3fc-2640","uc_output":"1f9d9-1f3fc-200d-2640-fe0f","uc_match":"1f9d9-1f3fc-2640-fe0f","uc_greedy":"1f9d9-1f3fc-2640","shortnames":[":woman_mage_medium_light_skin_tone:"],"category":"people"},":woman_mage_tone3:":{"uc_base":"1f9d9-1f3fd-2640","uc_output":"1f9d9-1f3fd-200d-2640-fe0f","uc_match":"1f9d9-1f3fd-2640-fe0f","uc_greedy":"1f9d9-1f3fd-2640","shortnames":[":woman_mage_medium_skin_tone:"],"category":"people"},":woman_mage_tone4:":{"uc_base":"1f9d9-1f3fe-2640","uc_output":"1f9d9-1f3fe-200d-2640-fe0f","uc_match":"1f9d9-1f3fe-2640-fe0f","uc_greedy":"1f9d9-1f3fe-2640","shortnames":[":woman_mage_medium_dark_skin_tone:"],"category":"people"},":woman_mage_tone5:":{"uc_base":"1f9d9-1f3ff-2640","uc_output":"1f9d9-1f3ff-200d-2640-fe0f","uc_match":"1f9d9-1f3ff-2640-fe0f","uc_greedy":"1f9d9-1f3ff-2640","shortnames":[":woman_mage_dark_skin_tone:"],"category":"people"},":woman_mountain_biking_tone1:":{"uc_base":"1f6b5-1f3fb-2640","uc_output":"1f6b5-1f3fb-200d-2640-fe0f","uc_match":"1f6b5-1f3fb-2640-fe0f","uc_greedy":"1f6b5-1f3fb-2640","shortnames":[":woman_mountain_biking_light_skin_tone:"],"category":"activity"},":woman_mountain_biking_tone2:":{"uc_base":"1f6b5-1f3fc-2640","uc_output":"1f6b5-1f3fc-200d-2640-fe0f","uc_match":"1f6b5-1f3fc-2640-fe0f","uc_greedy":"1f6b5-1f3fc-2640","shortnames":[":woman_mountain_biking_medium_light_skin_tone:"],"category":"activity"},":woman_mountain_biking_tone3:":{"uc_base":"1f6b5-1f3fd-2640","uc_output":"1f6b5-1f3fd-200d-2640-fe0f","uc_match":"1f6b5-1f3fd-2640-fe0f","uc_greedy":"1f6b5-1f3fd-2640","shortnames":[":woman_mountain_biking_medium_skin_tone:"],"category":"activity"},":woman_mountain_biking_tone4:":{"uc_base":"1f6b5-1f3fe-2640","uc_output":"1f6b5-1f3fe-200d-2640-fe0f","uc_match":"1f6b5-1f3fe-2640-fe0f","uc_greedy":"1f6b5-1f3fe-2640","shortnames":[":woman_mountain_biking_medium_dark_skin_tone:"],"category":"activity"},":woman_mountain_biking_tone5:":{"uc_base":"1f6b5-1f3ff-2640","uc_output":"1f6b5-1f3ff-200d-2640-fe0f","uc_match":"1f6b5-1f3ff-2640-fe0f","uc_greedy":"1f6b5-1f3ff-2640","shortnames":[":woman_mountain_biking_dark_skin_tone:"],"category":"activity"},":woman_pilot_tone1:":{"uc_base":"1f469-1f3fb-2708","uc_output":"1f469-1f3fb-200d-2708-fe0f","uc_match":"1f469-1f3fb-2708-fe0f","uc_greedy":"1f469-1f3fb-2708","shortnames":[":woman_pilot_light_skin_tone:"],"category":"people"},":woman_pilot_tone2:":{"uc_base":"1f469-1f3fc-2708","uc_output":"1f469-1f3fc-200d-2708-fe0f","uc_match":"1f469-1f3fc-2708-fe0f","uc_greedy":"1f469-1f3fc-2708","shortnames":[":woman_pilot_medium_light_skin_tone:"],"category":"people"},":woman_pilot_tone3:":{"uc_base":"1f469-1f3fd-2708","uc_output":"1f469-1f3fd-200d-2708-fe0f","uc_match":"1f469-1f3fd-2708-fe0f","uc_greedy":"1f469-1f3fd-2708","shortnames":[":woman_pilot_medium_skin_tone:"],"category":"people"},":woman_pilot_tone4:":{"uc_base":"1f469-1f3fe-2708","uc_output":"1f469-1f3fe-200d-2708-fe0f","uc_match":"1f469-1f3fe-2708-fe0f","uc_greedy":"1f469-1f3fe-2708","shortnames":[":woman_pilot_medium_dark_skin_tone:"],"category":"people"},":woman_pilot_tone5:":{"uc_base":"1f469-1f3ff-2708","uc_output":"1f469-1f3ff-200d-2708-fe0f","uc_match":"1f469-1f3ff-2708-fe0f","uc_greedy":"1f469-1f3ff-2708","shortnames":[":woman_pilot_dark_skin_tone:"],"category":"people"},":woman_playing_handball_tone1:":{"uc_base":"1f93e-1f3fb-2640","uc_output":"1f93e-1f3fb-200d-2640-fe0f","uc_match":"1f93e-1f3fb-2640-fe0f","uc_greedy":"1f93e-1f3fb-2640","shortnames":[":woman_playing_handball_light_skin_tone:"],"category":"activity"},":woman_playing_handball_tone2:":{"uc_base":"1f93e-1f3fc-2640","uc_output":"1f93e-1f3fc-200d-2640-fe0f","uc_match":"1f93e-1f3fc-2640-fe0f","uc_greedy":"1f93e-1f3fc-2640","shortnames":[":woman_playing_handball_medium_light_skin_tone:"],"category":"activity"},":woman_playing_handball_tone3:":{"uc_base":"1f93e-1f3fd-2640","uc_output":"1f93e-1f3fd-200d-2640-fe0f","uc_match":"1f93e-1f3fd-2640-fe0f","uc_greedy":"1f93e-1f3fd-2640","shortnames":[":woman_playing_handball_medium_skin_tone:"],"category":"activity"},":woman_playing_handball_tone4:":{"uc_base":"1f93e-1f3fe-2640","uc_output":"1f93e-1f3fe-200d-2640-fe0f","uc_match":"1f93e-1f3fe-2640-fe0f","uc_greedy":"1f93e-1f3fe-2640","shortnames":[":woman_playing_handball_medium_dark_skin_tone:"],"category":"activity"},":woman_playing_handball_tone5:":{"uc_base":"1f93e-1f3ff-2640","uc_output":"1f93e-1f3ff-200d-2640-fe0f","uc_match":"1f93e-1f3ff-2640-fe0f","uc_greedy":"1f93e-1f3ff-2640","shortnames":[":woman_playing_handball_dark_skin_tone:"],"category":"activity"},":woman_playing_water_polo_tone1:":{"uc_base":"1f93d-1f3fb-2640","uc_output":"1f93d-1f3fb-200d-2640-fe0f","uc_match":"1f93d-1f3fb-2640-fe0f","uc_greedy":"1f93d-1f3fb-2640","shortnames":[":woman_playing_water_polo_light_skin_tone:"],"category":"activity"},":woman_playing_water_polo_tone2:":{"uc_base":"1f93d-1f3fc-2640","uc_output":"1f93d-1f3fc-200d-2640-fe0f","uc_match":"1f93d-1f3fc-2640-fe0f","uc_greedy":"1f93d-1f3fc-2640","shortnames":[":woman_playing_water_polo_medium_light_skin_tone:"],"category":"activity"},":woman_playing_water_polo_tone3:":{"uc_base":"1f93d-1f3fd-2640","uc_output":"1f93d-1f3fd-200d-2640-fe0f","uc_match":"1f93d-1f3fd-2640-fe0f","uc_greedy":"1f93d-1f3fd-2640","shortnames":[":woman_playing_water_polo_medium_skin_tone:"],"category":"activity"},":woman_playing_water_polo_tone4:":{"uc_base":"1f93d-1f3fe-2640","uc_output":"1f93d-1f3fe-200d-2640-fe0f","uc_match":"1f93d-1f3fe-2640-fe0f","uc_greedy":"1f93d-1f3fe-2640","shortnames":[":woman_playing_water_polo_medium_dark_skin_tone:"],"category":"activity"},":woman_playing_water_polo_tone5:":{"uc_base":"1f93d-1f3ff-2640","uc_output":"1f93d-1f3ff-200d-2640-fe0f","uc_match":"1f93d-1f3ff-2640-fe0f","uc_greedy":"1f93d-1f3ff-2640","shortnames":[":woman_playing_water_polo_dark_skin_tone:"],"category":"activity"},":woman_police_officer_tone1:":{"uc_base":"1f46e-1f3fb-2640","uc_output":"1f46e-1f3fb-200d-2640-fe0f","uc_match":"1f46e-1f3fb-2640-fe0f","uc_greedy":"1f46e-1f3fb-2640","shortnames":[":woman_police_officer_light_skin_tone:"],"category":"people"},":woman_police_officer_tone2:":{"uc_base":"1f46e-1f3fc-2640","uc_output":"1f46e-1f3fc-200d-2640-fe0f","uc_match":"1f46e-1f3fc-2640-fe0f","uc_greedy":"1f46e-1f3fc-2640","shortnames":[":woman_police_officer_medium_light_skin_tone:"],"category":"people"},":woman_police_officer_tone3:":{"uc_base":"1f46e-1f3fd-2640","uc_output":"1f46e-1f3fd-200d-2640-fe0f","uc_match":"1f46e-1f3fd-2640-fe0f","uc_greedy":"1f46e-1f3fd-2640","shortnames":[":woman_police_officer_medium_skin_tone:"],"category":"people"},":woman_police_officer_tone4:":{"uc_base":"1f46e-1f3fe-2640","uc_output":"1f46e-1f3fe-200d-2640-fe0f","uc_match":"1f46e-1f3fe-2640-fe0f","uc_greedy":"1f46e-1f3fe-2640","shortnames":[":woman_police_officer_medium_dark_skin_tone:"],"category":"people"},":woman_police_officer_tone5:":{"uc_base":"1f46e-1f3ff-2640","uc_output":"1f46e-1f3ff-200d-2640-fe0f","uc_match":"1f46e-1f3ff-2640-fe0f","uc_greedy":"1f46e-1f3ff-2640","shortnames":[":woman_police_officer_dark_skin_tone:"],"category":"people"},":woman_pouting_tone1:":{"uc_base":"1f64e-1f3fb-2640","uc_output":"1f64e-1f3fb-200d-2640-fe0f","uc_match":"1f64e-1f3fb-2640-fe0f","uc_greedy":"1f64e-1f3fb-2640","shortnames":[":woman_pouting_light_skin_tone:"],"category":"people"},":woman_pouting_tone2:":{"uc_base":"1f64e-1f3fc-2640","uc_output":"1f64e-1f3fc-200d-2640-fe0f","uc_match":"1f64e-1f3fc-2640-fe0f","uc_greedy":"1f64e-1f3fc-2640","shortnames":[":woman_pouting_medium_light_skin_tone:"],"category":"people"},":woman_pouting_tone3:":{"uc_base":"1f64e-1f3fd-2640","uc_output":"1f64e-1f3fd-200d-2640-fe0f","uc_match":"1f64e-1f3fd-2640-fe0f","uc_greedy":"1f64e-1f3fd-2640","shortnames":[":woman_pouting_medium_skin_tone:"],"category":"people"},":woman_pouting_tone4:":{"uc_base":"1f64e-1f3fe-2640","uc_output":"1f64e-1f3fe-200d-2640-fe0f","uc_match":"1f64e-1f3fe-2640-fe0f","uc_greedy":"1f64e-1f3fe-2640","shortnames":[":woman_pouting_medium_dark_skin_tone:"],"category":"people"},":woman_pouting_tone5:":{"uc_base":"1f64e-1f3ff-2640","uc_output":"1f64e-1f3ff-200d-2640-fe0f","uc_match":"1f64e-1f3ff-2640-fe0f","uc_greedy":"1f64e-1f3ff-2640","shortnames":[":woman_pouting_dark_skin_tone:"],"category":"people"},":woman_raising_hand_tone1:":{"uc_base":"1f64b-1f3fb-2640","uc_output":"1f64b-1f3fb-200d-2640-fe0f","uc_match":"1f64b-1f3fb-2640-fe0f","uc_greedy":"1f64b-1f3fb-2640","shortnames":[":woman_raising_hand_light_skin_tone:"],"category":"people"},":woman_raising_hand_tone2:":{"uc_base":"1f64b-1f3fc-2640","uc_output":"1f64b-1f3fc-200d-2640-fe0f","uc_match":"1f64b-1f3fc-2640-fe0f","uc_greedy":"1f64b-1f3fc-2640","shortnames":[":woman_raising_hand_medium_light_skin_tone:"],"category":"people"},":woman_raising_hand_tone3:":{"uc_base":"1f64b-1f3fd-2640","uc_output":"1f64b-1f3fd-200d-2640-fe0f","uc_match":"1f64b-1f3fd-2640-fe0f","uc_greedy":"1f64b-1f3fd-2640","shortnames":[":woman_raising_hand_medium_skin_tone:"],"category":"people"},":woman_raising_hand_tone4:":{"uc_base":"1f64b-1f3fe-2640","uc_output":"1f64b-1f3fe-200d-2640-fe0f","uc_match":"1f64b-1f3fe-2640-fe0f","uc_greedy":"1f64b-1f3fe-2640","shortnames":[":woman_raising_hand_medium_dark_skin_tone:"],"category":"people"},":woman_raising_hand_tone5:":{"uc_base":"1f64b-1f3ff-2640","uc_output":"1f64b-1f3ff-200d-2640-fe0f","uc_match":"1f64b-1f3ff-2640-fe0f","uc_greedy":"1f64b-1f3ff-2640","shortnames":[":woman_raising_hand_dark_skin_tone:"],"category":"people"},":woman_rowing_boat_tone1:":{"uc_base":"1f6a3-1f3fb-2640","uc_output":"1f6a3-1f3fb-200d-2640-fe0f","uc_match":"1f6a3-1f3fb-2640-fe0f","uc_greedy":"1f6a3-1f3fb-2640","shortnames":[":woman_rowing_boat_light_skin_tone:"],"category":"activity"},":woman_rowing_boat_tone2:":{"uc_base":"1f6a3-1f3fc-2640","uc_output":"1f6a3-1f3fc-200d-2640-fe0f","uc_match":"1f6a3-1f3fc-2640-fe0f","uc_greedy":"1f6a3-1f3fc-2640","shortnames":[":woman_rowing_boat_medium_light_skin_tone:"],"category":"activity"},":woman_rowing_boat_tone3:":{"uc_base":"1f6a3-1f3fd-2640","uc_output":"1f6a3-1f3fd-200d-2640-fe0f","uc_match":"1f6a3-1f3fd-2640-fe0f","uc_greedy":"1f6a3-1f3fd-2640","shortnames":[":woman_rowing_boat_medium_skin_tone:"],"category":"activity"},":woman_rowing_boat_tone4:":{"uc_base":"1f6a3-1f3fe-2640","uc_output":"1f6a3-1f3fe-200d-2640-fe0f","uc_match":"1f6a3-1f3fe-2640-fe0f","uc_greedy":"1f6a3-1f3fe-2640","shortnames":[":woman_rowing_boat_medium_dark_skin_tone:"],"category":"activity"},":woman_rowing_boat_tone5:":{"uc_base":"1f6a3-1f3ff-2640","uc_output":"1f6a3-1f3ff-200d-2640-fe0f","uc_match":"1f6a3-1f3ff-2640-fe0f","uc_greedy":"1f6a3-1f3ff-2640","shortnames":[":woman_rowing_boat_dark_skin_tone:"],"category":"activity"},":woman_running_tone1:":{"uc_base":"1f3c3-1f3fb-2640","uc_output":"1f3c3-1f3fb-200d-2640-fe0f","uc_match":"1f3c3-1f3fb-2640-fe0f","uc_greedy":"1f3c3-1f3fb-2640","shortnames":[":woman_running_light_skin_tone:"],"category":"people"},":woman_running_tone2:":{"uc_base":"1f3c3-1f3fc-2640","uc_output":"1f3c3-1f3fc-200d-2640-fe0f","uc_match":"1f3c3-1f3fc-2640-fe0f","uc_greedy":"1f3c3-1f3fc-2640","shortnames":[":woman_running_medium_light_skin_tone:"],"category":"people"},":woman_running_tone3:":{"uc_base":"1f3c3-1f3fd-2640","uc_output":"1f3c3-1f3fd-200d-2640-fe0f","uc_match":"1f3c3-1f3fd-2640-fe0f","uc_greedy":"1f3c3-1f3fd-2640","shortnames":[":woman_running_medium_skin_tone:"],"category":"people"},":woman_running_tone4:":{"uc_base":"1f3c3-1f3fe-2640","uc_output":"1f3c3-1f3fe-200d-2640-fe0f","uc_match":"1f3c3-1f3fe-2640-fe0f","uc_greedy":"1f3c3-1f3fe-2640","shortnames":[":woman_running_medium_dark_skin_tone:"],"category":"people"},":woman_running_tone5:":{"uc_base":"1f3c3-1f3ff-2640","uc_output":"1f3c3-1f3ff-200d-2640-fe0f","uc_match":"1f3c3-1f3ff-2640-fe0f","uc_greedy":"1f3c3-1f3ff-2640","shortnames":[":woman_running_dark_skin_tone:"],"category":"people"},":woman_shrugging_tone1:":{"uc_base":"1f937-1f3fb-2640","uc_output":"1f937-1f3fb-200d-2640-fe0f","uc_match":"1f937-1f3fb-2640-fe0f","uc_greedy":"1f937-1f3fb-2640","shortnames":[":woman_shrugging_light_skin_tone:"],"category":"people"},":woman_shrugging_tone2:":{"uc_base":"1f937-1f3fc-2640","uc_output":"1f937-1f3fc-200d-2640-fe0f","uc_match":"1f937-1f3fc-2640-fe0f","uc_greedy":"1f937-1f3fc-2640","shortnames":[":woman_shrugging_medium_light_skin_tone:"],"category":"people"},":woman_shrugging_tone3:":{"uc_base":"1f937-1f3fd-2640","uc_output":"1f937-1f3fd-200d-2640-fe0f","uc_match":"1f937-1f3fd-2640-fe0f","uc_greedy":"1f937-1f3fd-2640","shortnames":[":woman_shrugging_medium_skin_tone:"],"category":"people"},":woman_shrugging_tone4:":{"uc_base":"1f937-1f3fe-2640","uc_output":"1f937-1f3fe-200d-2640-fe0f","uc_match":"1f937-1f3fe-2640-fe0f","uc_greedy":"1f937-1f3fe-2640","shortnames":[":woman_shrugging_medium_dark_skin_tone:"],"category":"people"},":woman_shrugging_tone5:":{"uc_base":"1f937-1f3ff-2640","uc_output":"1f937-1f3ff-200d-2640-fe0f","uc_match":"1f937-1f3ff-2640-fe0f","uc_greedy":"1f937-1f3ff-2640","shortnames":[":woman_shrugging_dark_skin_tone:"],"category":"people"},":woman_surfing_tone1:":{"uc_base":"1f3c4-1f3fb-2640","uc_output":"1f3c4-1f3fb-200d-2640-fe0f","uc_match":"1f3c4-1f3fb-2640-fe0f","uc_greedy":"1f3c4-1f3fb-2640","shortnames":[":woman_surfing_light_skin_tone:"],"category":"activity"},":woman_surfing_tone2:":{"uc_base":"1f3c4-1f3fc-2640","uc_output":"1f3c4-1f3fc-200d-2640-fe0f","uc_match":"1f3c4-1f3fc-2640-fe0f","uc_greedy":"1f3c4-1f3fc-2640","shortnames":[":woman_surfing_medium_light_skin_tone:"],"category":"activity"},":woman_surfing_tone3:":{"uc_base":"1f3c4-1f3fd-2640","uc_output":"1f3c4-1f3fd-200d-2640-fe0f","uc_match":"1f3c4-1f3fd-2640-fe0f","uc_greedy":"1f3c4-1f3fd-2640","shortnames":[":woman_surfing_medium_skin_tone:"],"category":"activity"},":woman_surfing_tone4:":{"uc_base":"1f3c4-1f3fe-2640","uc_output":"1f3c4-1f3fe-200d-2640-fe0f","uc_match":"1f3c4-1f3fe-2640-fe0f","uc_greedy":"1f3c4-1f3fe-2640","shortnames":[":woman_surfing_medium_dark_skin_tone:"],"category":"activity"},":woman_surfing_tone5:":{"uc_base":"1f3c4-1f3ff-2640","uc_output":"1f3c4-1f3ff-200d-2640-fe0f","uc_match":"1f3c4-1f3ff-2640-fe0f","uc_greedy":"1f3c4-1f3ff-2640","shortnames":[":woman_surfing_dark_skin_tone:"],"category":"activity"},":woman_swimming_tone1:":{"uc_base":"1f3ca-1f3fb-2640","uc_output":"1f3ca-1f3fb-200d-2640-fe0f","uc_match":"1f3ca-1f3fb-2640-fe0f","uc_greedy":"1f3ca-1f3fb-2640","shortnames":[":woman_swimming_light_skin_tone:"],"category":"activity"},":woman_swimming_tone2:":{"uc_base":"1f3ca-1f3fc-2640","uc_output":"1f3ca-1f3fc-200d-2640-fe0f","uc_match":"1f3ca-1f3fc-2640-fe0f","uc_greedy":"1f3ca-1f3fc-2640","shortnames":[":woman_swimming_medium_light_skin_tone:"],"category":"activity"},":woman_swimming_tone3:":{"uc_base":"1f3ca-1f3fd-2640","uc_output":"1f3ca-1f3fd-200d-2640-fe0f","uc_match":"1f3ca-1f3fd-2640-fe0f","uc_greedy":"1f3ca-1f3fd-2640","shortnames":[":woman_swimming_medium_skin_tone:"],"category":"activity"},":woman_swimming_tone4:":{"uc_base":"1f3ca-1f3fe-2640","uc_output":"1f3ca-1f3fe-200d-2640-fe0f","uc_match":"1f3ca-1f3fe-2640-fe0f","uc_greedy":"1f3ca-1f3fe-2640","shortnames":[":woman_swimming_medium_dark_skin_tone:"],"category":"activity"},":woman_swimming_tone5:":{"uc_base":"1f3ca-1f3ff-2640","uc_output":"1f3ca-1f3ff-200d-2640-fe0f","uc_match":"1f3ca-1f3ff-2640-fe0f","uc_greedy":"1f3ca-1f3ff-2640","shortnames":[":woman_swimming_dark_skin_tone:"],"category":"activity"},":woman_tipping_hand_tone1:":{"uc_base":"1f481-1f3fb-2640","uc_output":"1f481-1f3fb-200d-2640-fe0f","uc_match":"1f481-1f3fb-2640-fe0f","uc_greedy":"1f481-1f3fb-2640","shortnames":[":woman_tipping_hand_light_skin_tone:"],"category":"people"},":woman_tipping_hand_tone2:":{"uc_base":"1f481-1f3fc-2640","uc_output":"1f481-1f3fc-200d-2640-fe0f","uc_match":"1f481-1f3fc-2640-fe0f","uc_greedy":"1f481-1f3fc-2640","shortnames":[":woman_tipping_hand_medium_light_skin_tone:"],"category":"people"},":woman_tipping_hand_tone3:":{"uc_base":"1f481-1f3fd-2640","uc_output":"1f481-1f3fd-200d-2640-fe0f","uc_match":"1f481-1f3fd-2640-fe0f","uc_greedy":"1f481-1f3fd-2640","shortnames":[":woman_tipping_hand_medium_skin_tone:"],"category":"people"},":woman_tipping_hand_tone4:":{"uc_base":"1f481-1f3fe-2640","uc_output":"1f481-1f3fe-200d-2640-fe0f","uc_match":"1f481-1f3fe-2640-fe0f","uc_greedy":"1f481-1f3fe-2640","shortnames":[":woman_tipping_hand_medium_dark_skin_tone:"],"category":"people"},":woman_tipping_hand_tone5:":{"uc_base":"1f481-1f3ff-2640","uc_output":"1f481-1f3ff-200d-2640-fe0f","uc_match":"1f481-1f3ff-2640-fe0f","uc_greedy":"1f481-1f3ff-2640","shortnames":[":woman_tipping_hand_dark_skin_tone:"],"category":"people"},":woman_vampire_tone1:":{"uc_base":"1f9db-1f3fb-2640","uc_output":"1f9db-1f3fb-200d-2640-fe0f","uc_match":"1f9db-1f3fb-2640-fe0f","uc_greedy":"1f9db-1f3fb-2640","shortnames":[":woman_vampire_light_skin_tone:"],"category":"people"},":woman_vampire_tone2:":{"uc_base":"1f9db-1f3fc-2640","uc_output":"1f9db-1f3fc-200d-2640-fe0f","uc_match":"1f9db-1f3fc-2640-fe0f","uc_greedy":"1f9db-1f3fc-2640","shortnames":[":woman_vampire_medium_light_skin_tone:"],"category":"people"},":woman_vampire_tone3:":{"uc_base":"1f9db-1f3fd-2640","uc_output":"1f9db-1f3fd-200d-2640-fe0f","uc_match":"1f9db-1f3fd-2640-fe0f","uc_greedy":"1f9db-1f3fd-2640","shortnames":[":woman_vampire_medium_skin_tone:"],"category":"people"},":woman_vampire_tone4:":{"uc_base":"1f9db-1f3fe-2640","uc_output":"1f9db-1f3fe-200d-2640-fe0f","uc_match":"1f9db-1f3fe-2640-fe0f","uc_greedy":"1f9db-1f3fe-2640","shortnames":[":woman_vampire_medium_dark_skin_tone:"],"category":"people"},":woman_vampire_tone5:":{"uc_base":"1f9db-1f3ff-2640","uc_output":"1f9db-1f3ff-200d-2640-fe0f","uc_match":"1f9db-1f3ff-2640-fe0f","uc_greedy":"1f9db-1f3ff-2640","shortnames":[":woman_vampire_dark_skin_tone:"],"category":"people"},":woman_walking_tone1:":{"uc_base":"1f6b6-1f3fb-2640","uc_output":"1f6b6-1f3fb-200d-2640-fe0f","uc_match":"1f6b6-1f3fb-2640-fe0f","uc_greedy":"1f6b6-1f3fb-2640","shortnames":[":woman_walking_light_skin_tone:"],"category":"people"},":woman_walking_tone2:":{"uc_base":"1f6b6-1f3fc-2640","uc_output":"1f6b6-1f3fc-200d-2640-fe0f","uc_match":"1f6b6-1f3fc-2640-fe0f","uc_greedy":"1f6b6-1f3fc-2640","shortnames":[":woman_walking_medium_light_skin_tone:"],"category":"people"},":woman_walking_tone3:":{"uc_base":"1f6b6-1f3fd-2640","uc_output":"1f6b6-1f3fd-200d-2640-fe0f","uc_match":"1f6b6-1f3fd-2640-fe0f","uc_greedy":"1f6b6-1f3fd-2640","shortnames":[":woman_walking_medium_skin_tone:"],"category":"people"},":woman_walking_tone4:":{"uc_base":"1f6b6-1f3fe-2640","uc_output":"1f6b6-1f3fe-200d-2640-fe0f","uc_match":"1f6b6-1f3fe-2640-fe0f","uc_greedy":"1f6b6-1f3fe-2640","shortnames":[":woman_walking_medium_dark_skin_tone:"],"category":"people"},":woman_walking_tone5:":{"uc_base":"1f6b6-1f3ff-2640","uc_output":"1f6b6-1f3ff-200d-2640-fe0f","uc_match":"1f6b6-1f3ff-2640-fe0f","uc_greedy":"1f6b6-1f3ff-2640","shortnames":[":woman_walking_dark_skin_tone:"],"category":"people"},":woman_wearing_turban_tone1:":{"uc_base":"1f473-1f3fb-2640","uc_output":"1f473-1f3fb-200d-2640-fe0f","uc_match":"1f473-1f3fb-2640-fe0f","uc_greedy":"1f473-1f3fb-2640","shortnames":[":woman_wearing_turban_light_skin_tone:"],"category":"people"},":woman_wearing_turban_tone2:":{"uc_base":"1f473-1f3fc-2640","uc_output":"1f473-1f3fc-200d-2640-fe0f","uc_match":"1f473-1f3fc-2640-fe0f","uc_greedy":"1f473-1f3fc-2640","shortnames":[":woman_wearing_turban_medium_light_skin_tone:"],"category":"people"},":woman_wearing_turban_tone3:":{"uc_base":"1f473-1f3fd-2640","uc_output":"1f473-1f3fd-200d-2640-fe0f","uc_match":"1f473-1f3fd-2640-fe0f","uc_greedy":"1f473-1f3fd-2640","shortnames":[":woman_wearing_turban_medium_skin_tone:"],"category":"people"},":woman_wearing_turban_tone4:":{"uc_base":"1f473-1f3fe-2640","uc_output":"1f473-1f3fe-200d-2640-fe0f","uc_match":"1f473-1f3fe-2640-fe0f","uc_greedy":"1f473-1f3fe-2640","shortnames":[":woman_wearing_turban_medium_dark_skin_tone:"],"category":"people"},":woman_wearing_turban_tone5:":{"uc_base":"1f473-1f3ff-2640","uc_output":"1f473-1f3ff-200d-2640-fe0f","uc_match":"1f473-1f3ff-2640-fe0f","uc_greedy":"1f473-1f3ff-2640","shortnames":[":woman_wearing_turban_dark_skin_tone:"],"category":"people"},":man_bouncing_ball_tone1:":{"uc_base":"26f9-1f3fb-2642","uc_output":"26f9-1f3fb-200d-2642-fe0f","uc_match":"26f9-fe0f-1f3fb-2642-fe0f","uc_greedy":"26f9-1f3fb-2642","shortnames":[":man_bouncing_ball_light_skin_tone:"],"category":"activity"},":man_bouncing_ball_tone2:":{"uc_base":"26f9-1f3fc-2642","uc_output":"26f9-1f3fc-200d-2642-fe0f","uc_match":"26f9-fe0f-1f3fc-2642-fe0f","uc_greedy":"26f9-1f3fc-2642","shortnames":[":man_bouncing_ball_medium_light_skin_tone:"],"category":"activity"},":man_bouncing_ball_tone3:":{"uc_base":"26f9-1f3fd-2642","uc_output":"26f9-1f3fd-200d-2642-fe0f","uc_match":"26f9-fe0f-1f3fd-2642-fe0f","uc_greedy":"26f9-1f3fd-2642","shortnames":[":man_bouncing_ball_medium_skin_tone:"],"category":"activity"},":man_bouncing_ball_tone4:":{"uc_base":"26f9-1f3fe-2642","uc_output":"26f9-1f3fe-200d-2642-fe0f","uc_match":"26f9-fe0f-1f3fe-2642-fe0f","uc_greedy":"26f9-1f3fe-2642","shortnames":[":man_bouncing_ball_medium_dark_skin_tone:"],"category":"activity"},":man_bouncing_ball_tone5:":{"uc_base":"26f9-1f3ff-2642","uc_output":"26f9-1f3ff-200d-2642-fe0f","uc_match":"26f9-fe0f-1f3ff-2642-fe0f","uc_greedy":"26f9-1f3ff-2642","shortnames":[":man_bouncing_ball_dark_skin_tone:"],"category":"activity"},":man_detective:":{"uc_base":"1f575-2642","uc_output":"1f575-fe0f-200d-2642-fe0f","uc_match":"1f575-fe0f-200d-2642","uc_greedy":"1f575-2642","shortnames":[],"category":"people"},":man_golfing:":{"uc_base":"1f3cc-2642","uc_output":"1f3cc-fe0f-200d-2642-fe0f","uc_match":"1f3cc-fe0f-200d-2642","uc_greedy":"1f3cc-2642","shortnames":[],"category":"activity"},":man_lifting_weights:":{"uc_base":"1f3cb-2642","uc_output":"1f3cb-fe0f-200d-2642-fe0f","uc_match":"1f3cb-fe0f-200d-2642","uc_greedy":"1f3cb-2642","shortnames":[],"category":"activity"},":woman_bouncing_ball_tone1:":{"uc_base":"26f9-1f3fb-2640","uc_output":"26f9-1f3fb-200d-2640-fe0f","uc_match":"26f9-fe0f-1f3fb-2640-fe0f","uc_greedy":"26f9-1f3fb-2640","shortnames":[":woman_bouncing_ball_light_skin_tone:"],"category":"activity"},":woman_bouncing_ball_tone2:":{"uc_base":"26f9-1f3fc-2640","uc_output":"26f9-1f3fc-200d-2640-fe0f","uc_match":"26f9-fe0f-1f3fc-2640-fe0f","uc_greedy":"26f9-1f3fc-2640","shortnames":[":woman_bouncing_ball_medium_light_skin_tone:"],"category":"activity"},":woman_bouncing_ball_tone3:":{"uc_base":"26f9-1f3fd-2640","uc_output":"26f9-1f3fd-200d-2640-fe0f","uc_match":"26f9-fe0f-1f3fd-2640-fe0f","uc_greedy":"26f9-1f3fd-2640","shortnames":[":woman_bouncing_ball_medium_skin_tone:"],"category":"activity"},":woman_bouncing_ball_tone4:":{"uc_base":"26f9-1f3fe-2640","uc_output":"26f9-1f3fe-200d-2640-fe0f","uc_match":"26f9-fe0f-1f3fe-2640-fe0f","uc_greedy":"26f9-1f3fe-2640","shortnames":[":woman_bouncing_ball_medium_dark_skin_tone:"],"category":"activity"},":woman_bouncing_ball_tone5:":{"uc_base":"26f9-1f3ff-2640","uc_output":"26f9-1f3ff-200d-2640-fe0f","uc_match":"26f9-fe0f-1f3ff-2640-fe0f","uc_greedy":"26f9-1f3ff-2640","shortnames":[":woman_bouncing_ball_dark_skin_tone:"],"category":"activity"},":woman_detective:":{"uc_base":"1f575-2640","uc_output":"1f575-fe0f-200d-2640-fe0f","uc_match":"1f575-fe0f-200d-2640","uc_greedy":"1f575-2640","shortnames":[],"category":"people"},":woman_golfing:":{"uc_base":"1f3cc-2640","uc_output":"1f3cc-fe0f-200d-2640-fe0f","uc_match":"1f3cc-fe0f-200d-2640","uc_greedy":"1f3cc-2640","shortnames":[],"category":"activity"},":woman_lifting_weights:":{"uc_base":"1f3cb-2640","uc_output":"1f3cb-fe0f-200d-2640-fe0f","uc_match":"1f3cb-fe0f-200d-2640","uc_greedy":"1f3cb-2640","shortnames":[],"category":"activity"},":man_bouncing_ball:":{"uc_base":"26f9-2642","uc_output":"26f9-fe0f-200d-2642-fe0f","uc_match":"26f9-fe0f-200d-2642","uc_greedy":"26f9-2642","shortnames":[],"category":"activity"},":woman_bouncing_ball:":{"uc_base":"26f9-2640","uc_output":"26f9-fe0f-200d-2640-fe0f","uc_match":"26f9-fe0f-200d-2640","uc_greedy":"26f9-2640","shortnames":[],"category":"activity"},":man_artist_tone1:":{"uc_base":"1f468-1f3fb-1f3a8","uc_output":"1f468-1f3fb-200d-1f3a8","uc_match":"1f468-1f3fb-1f3a8","uc_greedy":"1f468-1f3fb-1f3a8","shortnames":[":man_artist_light_skin_tone:"],"category":"people"},":man_artist_tone2:":{"uc_base":"1f468-1f3fc-1f3a8","uc_output":"1f468-1f3fc-200d-1f3a8","uc_match":"1f468-1f3fc-1f3a8","uc_greedy":"1f468-1f3fc-1f3a8","shortnames":[":man_artist_medium_light_skin_tone:"],"category":"people"},":man_artist_tone3:":{"uc_base":"1f468-1f3fd-1f3a8","uc_output":"1f468-1f3fd-200d-1f3a8","uc_match":"1f468-1f3fd-1f3a8","uc_greedy":"1f468-1f3fd-1f3a8","shortnames":[":man_artist_medium_skin_tone:"],"category":"people"},":man_artist_tone4:":{"uc_base":"1f468-1f3fe-1f3a8","uc_output":"1f468-1f3fe-200d-1f3a8","uc_match":"1f468-1f3fe-1f3a8","uc_greedy":"1f468-1f3fe-1f3a8","shortnames":[":man_artist_medium_dark_skin_tone:"],"category":"people"},":man_artist_tone5:":{"uc_base":"1f468-1f3ff-1f3a8","uc_output":"1f468-1f3ff-200d-1f3a8","uc_match":"1f468-1f3ff-1f3a8","uc_greedy":"1f468-1f3ff-1f3a8","shortnames":[":man_artist_dark_skin_tone:"],"category":"people"},":man_astronaut_tone1:":{"uc_base":"1f468-1f3fb-1f680","uc_output":"1f468-1f3fb-200d-1f680","uc_match":"1f468-1f3fb-1f680","uc_greedy":"1f468-1f3fb-1f680","shortnames":[":man_astronaut_light_skin_tone:"],"category":"people"},":man_astronaut_tone2:":{"uc_base":"1f468-1f3fc-1f680","uc_output":"1f468-1f3fc-200d-1f680","uc_match":"1f468-1f3fc-1f680","uc_greedy":"1f468-1f3fc-1f680","shortnames":[":man_astronaut_medium_light_skin_tone:"],"category":"people"},":man_astronaut_tone3:":{"uc_base":"1f468-1f3fd-1f680","uc_output":"1f468-1f3fd-200d-1f680","uc_match":"1f468-1f3fd-1f680","uc_greedy":"1f468-1f3fd-1f680","shortnames":[":man_astronaut_medium_skin_tone:"],"category":"people"},":man_astronaut_tone4:":{"uc_base":"1f468-1f3fe-1f680","uc_output":"1f468-1f3fe-200d-1f680","uc_match":"1f468-1f3fe-1f680","uc_greedy":"1f468-1f3fe-1f680","shortnames":[":man_astronaut_medium_dark_skin_tone:"],"category":"people"},":man_astronaut_tone5:":{"uc_base":"1f468-1f3ff-1f680","uc_output":"1f468-1f3ff-200d-1f680","uc_match":"1f468-1f3ff-1f680","uc_greedy":"1f468-1f3ff-1f680","shortnames":[":man_astronaut_dark_skin_tone:"],"category":"people"},":man_cook_tone1:":{"uc_base":"1f468-1f3fb-1f373","uc_output":"1f468-1f3fb-200d-1f373","uc_match":"1f468-1f3fb-1f373","uc_greedy":"1f468-1f3fb-1f373","shortnames":[":man_cook_light_skin_tone:"],"category":"people"},":man_cook_tone2:":{"uc_base":"1f468-1f3fc-1f373","uc_output":"1f468-1f3fc-200d-1f373","uc_match":"1f468-1f3fc-1f373","uc_greedy":"1f468-1f3fc-1f373","shortnames":[":man_cook_medium_light_skin_tone:"],"category":"people"},":man_cook_tone3:":{"uc_base":"1f468-1f3fd-1f373","uc_output":"1f468-1f3fd-200d-1f373","uc_match":"1f468-1f3fd-1f373","uc_greedy":"1f468-1f3fd-1f373","shortnames":[":man_cook_medium_skin_tone:"],"category":"people"},":man_cook_tone4:":{"uc_base":"1f468-1f3fe-1f373","uc_output":"1f468-1f3fe-200d-1f373","uc_match":"1f468-1f3fe-1f373","uc_greedy":"1f468-1f3fe-1f373","shortnames":[":man_cook_medium_dark_skin_tone:"],"category":"people"},":man_cook_tone5:":{"uc_base":"1f468-1f3ff-1f373","uc_output":"1f468-1f3ff-200d-1f373","uc_match":"1f468-1f3ff-1f373","uc_greedy":"1f468-1f3ff-1f373","shortnames":[":man_cook_dark_skin_tone:"],"category":"people"},":man_factory_worker_tone1:":{"uc_base":"1f468-1f3fb-1f3ed","uc_output":"1f468-1f3fb-200d-1f3ed","uc_match":"1f468-1f3fb-1f3ed","uc_greedy":"1f468-1f3fb-1f3ed","shortnames":[":man_factory_worker_light_skin_tone:"],"category":"people"},":man_factory_worker_tone2:":{"uc_base":"1f468-1f3fc-1f3ed","uc_output":"1f468-1f3fc-200d-1f3ed","uc_match":"1f468-1f3fc-1f3ed","uc_greedy":"1f468-1f3fc-1f3ed","shortnames":[":man_factory_worker_medium_light_skin_tone:"],"category":"people"},":man_factory_worker_tone3:":{"uc_base":"1f468-1f3fd-1f3ed","uc_output":"1f468-1f3fd-200d-1f3ed","uc_match":"1f468-1f3fd-1f3ed","uc_greedy":"1f468-1f3fd-1f3ed","shortnames":[":man_factory_worker_medium_skin_tone:"],"category":"people"},":man_factory_worker_tone4:":{"uc_base":"1f468-1f3fe-1f3ed","uc_output":"1f468-1f3fe-200d-1f3ed","uc_match":"1f468-1f3fe-1f3ed","uc_greedy":"1f468-1f3fe-1f3ed","shortnames":[":man_factory_worker_medium_dark_skin_tone:"],"category":"people"},":man_factory_worker_tone5:":{"uc_base":"1f468-1f3ff-1f3ed","uc_output":"1f468-1f3ff-200d-1f3ed","uc_match":"1f468-1f3ff-1f3ed","uc_greedy":"1f468-1f3ff-1f3ed","shortnames":[":man_factory_worker_dark_skin_tone:"],"category":"people"},":man_farmer_tone1:":{"uc_base":"1f468-1f3fb-1f33e","uc_output":"1f468-1f3fb-200d-1f33e","uc_match":"1f468-1f3fb-1f33e","uc_greedy":"1f468-1f3fb-1f33e","shortnames":[":man_farmer_light_skin_tone:"],"category":"people"},":man_farmer_tone2:":{"uc_base":"1f468-1f3fc-1f33e","uc_output":"1f468-1f3fc-200d-1f33e","uc_match":"1f468-1f3fc-1f33e","uc_greedy":"1f468-1f3fc-1f33e","shortnames":[":man_farmer_medium_light_skin_tone:"],"category":"people"},":man_farmer_tone3:":{"uc_base":"1f468-1f3fd-1f33e","uc_output":"1f468-1f3fd-200d-1f33e","uc_match":"1f468-1f3fd-1f33e","uc_greedy":"1f468-1f3fd-1f33e","shortnames":[":man_farmer_medium_skin_tone:"],"category":"people"},":man_farmer_tone4:":{"uc_base":"1f468-1f3fe-1f33e","uc_output":"1f468-1f3fe-200d-1f33e","uc_match":"1f468-1f3fe-1f33e","uc_greedy":"1f468-1f3fe-1f33e","shortnames":[":man_farmer_medium_dark_skin_tone:"],"category":"people"},":man_farmer_tone5:":{"uc_base":"1f468-1f3ff-1f33e","uc_output":"1f468-1f3ff-200d-1f33e","uc_match":"1f468-1f3ff-1f33e","uc_greedy":"1f468-1f3ff-1f33e","shortnames":[":man_farmer_dark_skin_tone:"],"category":"people"},":man_firefighter_tone1:":{"uc_base":"1f468-1f3fb-1f692","uc_output":"1f468-1f3fb-200d-1f692","uc_match":"1f468-1f3fb-1f692","uc_greedy":"1f468-1f3fb-1f692","shortnames":[":man_firefighter_light_skin_tone:"],"category":"people"},":man_firefighter_tone2:":{"uc_base":"1f468-1f3fc-1f692","uc_output":"1f468-1f3fc-200d-1f692","uc_match":"1f468-1f3fc-1f692","uc_greedy":"1f468-1f3fc-1f692","shortnames":[":man_firefighter_medium_light_skin_tone:"],"category":"people"},":man_firefighter_tone3:":{"uc_base":"1f468-1f3fd-1f692","uc_output":"1f468-1f3fd-200d-1f692","uc_match":"1f468-1f3fd-1f692","uc_greedy":"1f468-1f3fd-1f692","shortnames":[":man_firefighter_medium_skin_tone:"],"category":"people"},":man_firefighter_tone4:":{"uc_base":"1f468-1f3fe-1f692","uc_output":"1f468-1f3fe-200d-1f692","uc_match":"1f468-1f3fe-1f692","uc_greedy":"1f468-1f3fe-1f692","shortnames":[":man_firefighter_medium_dark_skin_tone:"],"category":"people"},":man_firefighter_tone5:":{"uc_base":"1f468-1f3ff-1f692","uc_output":"1f468-1f3ff-200d-1f692","uc_match":"1f468-1f3ff-1f692","uc_greedy":"1f468-1f3ff-1f692","shortnames":[":man_firefighter_dark_skin_tone:"],"category":"people"},":man_mechanic_tone1:":{"uc_base":"1f468-1f3fb-1f527","uc_output":"1f468-1f3fb-200d-1f527","uc_match":"1f468-1f3fb-1f527","uc_greedy":"1f468-1f3fb-1f527","shortnames":[":man_mechanic_light_skin_tone:"],"category":"people"},":man_mechanic_tone2:":{"uc_base":"1f468-1f3fc-1f527","uc_output":"1f468-1f3fc-200d-1f527","uc_match":"1f468-1f3fc-1f527","uc_greedy":"1f468-1f3fc-1f527","shortnames":[":man_mechanic_medium_light_skin_tone:"],"category":"people"},":man_mechanic_tone3:":{"uc_base":"1f468-1f3fd-1f527","uc_output":"1f468-1f3fd-200d-1f527","uc_match":"1f468-1f3fd-1f527","uc_greedy":"1f468-1f3fd-1f527","shortnames":[":man_mechanic_medium_skin_tone:"],"category":"people"},":man_mechanic_tone4:":{"uc_base":"1f468-1f3fe-1f527","uc_output":"1f468-1f3fe-200d-1f527","uc_match":"1f468-1f3fe-1f527","uc_greedy":"1f468-1f3fe-1f527","shortnames":[":man_mechanic_medium_dark_skin_tone:"],"category":"people"},":man_mechanic_tone5:":{"uc_base":"1f468-1f3ff-1f527","uc_output":"1f468-1f3ff-200d-1f527","uc_match":"1f468-1f3ff-1f527","uc_greedy":"1f468-1f3ff-1f527","shortnames":[":man_mechanic_dark_skin_tone:"],"category":"people"},":man_office_worker_tone1:":{"uc_base":"1f468-1f3fb-1f4bc","uc_output":"1f468-1f3fb-200d-1f4bc","uc_match":"1f468-1f3fb-1f4bc","uc_greedy":"1f468-1f3fb-1f4bc","shortnames":[":man_office_worker_light_skin_tone:"],"category":"people"},":man_office_worker_tone2:":{"uc_base":"1f468-1f3fc-1f4bc","uc_output":"1f468-1f3fc-200d-1f4bc","uc_match":"1f468-1f3fc-1f4bc","uc_greedy":"1f468-1f3fc-1f4bc","shortnames":[":man_office_worker_medium_light_skin_tone:"],"category":"people"},":man_office_worker_tone3:":{"uc_base":"1f468-1f3fd-1f4bc","uc_output":"1f468-1f3fd-200d-1f4bc","uc_match":"1f468-1f3fd-1f4bc","uc_greedy":"1f468-1f3fd-1f4bc","shortnames":[":man_office_worker_medium_skin_tone:"],"category":"people"},":man_office_worker_tone4:":{"uc_base":"1f468-1f3fe-1f4bc","uc_output":"1f468-1f3fe-200d-1f4bc","uc_match":"1f468-1f3fe-1f4bc","uc_greedy":"1f468-1f3fe-1f4bc","shortnames":[":man_office_worker_medium_dark_skin_tone:"],"category":"people"},":man_office_worker_tone5:":{"uc_base":"1f468-1f3ff-1f4bc","uc_output":"1f468-1f3ff-200d-1f4bc","uc_match":"1f468-1f3ff-1f4bc","uc_greedy":"1f468-1f3ff-1f4bc","shortnames":[":man_office_worker_dark_skin_tone:"],"category":"people"},":man_scientist_tone1:":{"uc_base":"1f468-1f3fb-1f52c","uc_output":"1f468-1f3fb-200d-1f52c","uc_match":"1f468-1f3fb-1f52c","uc_greedy":"1f468-1f3fb-1f52c","shortnames":[":man_scientist_light_skin_tone:"],"category":"people"},":man_scientist_tone2:":{"uc_base":"1f468-1f3fc-1f52c","uc_output":"1f468-1f3fc-200d-1f52c","uc_match":"1f468-1f3fc-1f52c","uc_greedy":"1f468-1f3fc-1f52c","shortnames":[":man_scientist_medium_light_skin_tone:"],"category":"people"},":man_scientist_tone3:":{"uc_base":"1f468-1f3fd-1f52c","uc_output":"1f468-1f3fd-200d-1f52c","uc_match":"1f468-1f3fd-1f52c","uc_greedy":"1f468-1f3fd-1f52c","shortnames":[":man_scientist_medium_skin_tone:"],"category":"people"},":man_scientist_tone4:":{"uc_base":"1f468-1f3fe-1f52c","uc_output":"1f468-1f3fe-200d-1f52c","uc_match":"1f468-1f3fe-1f52c","uc_greedy":"1f468-1f3fe-1f52c","shortnames":[":man_scientist_medium_dark_skin_tone:"],"category":"people"},":man_scientist_tone5:":{"uc_base":"1f468-1f3ff-1f52c","uc_output":"1f468-1f3ff-200d-1f52c","uc_match":"1f468-1f3ff-1f52c","uc_greedy":"1f468-1f3ff-1f52c","shortnames":[":man_scientist_dark_skin_tone:"],"category":"people"},":man_singer_tone1:":{"uc_base":"1f468-1f3fb-1f3a4","uc_output":"1f468-1f3fb-200d-1f3a4","uc_match":"1f468-1f3fb-1f3a4","uc_greedy":"1f468-1f3fb-1f3a4","shortnames":[":man_singer_light_skin_tone:"],"category":"people"},":man_singer_tone2:":{"uc_base":"1f468-1f3fc-1f3a4","uc_output":"1f468-1f3fc-200d-1f3a4","uc_match":"1f468-1f3fc-1f3a4","uc_greedy":"1f468-1f3fc-1f3a4","shortnames":[":man_singer_medium_light_skin_tone:"],"category":"people"},":man_singer_tone3:":{"uc_base":"1f468-1f3fd-1f3a4","uc_output":"1f468-1f3fd-200d-1f3a4","uc_match":"1f468-1f3fd-1f3a4","uc_greedy":"1f468-1f3fd-1f3a4","shortnames":[":man_singer_medium_skin_tone:"],"category":"people"},":man_singer_tone4:":{"uc_base":"1f468-1f3fe-1f3a4","uc_output":"1f468-1f3fe-200d-1f3a4","uc_match":"1f468-1f3fe-1f3a4","uc_greedy":"1f468-1f3fe-1f3a4","shortnames":[":man_singer_medium_dark_skin_tone:"],"category":"people"},":man_singer_tone5:":{"uc_base":"1f468-1f3ff-1f3a4","uc_output":"1f468-1f3ff-200d-1f3a4","uc_match":"1f468-1f3ff-1f3a4","uc_greedy":"1f468-1f3ff-1f3a4","shortnames":[":man_singer_dark_skin_tone:"],"category":"people"},":man_student_tone1:":{"uc_base":"1f468-1f3fb-1f393","uc_output":"1f468-1f3fb-200d-1f393","uc_match":"1f468-1f3fb-1f393","uc_greedy":"1f468-1f3fb-1f393","shortnames":[":man_student_light_skin_tone:"],"category":"people"},":man_student_tone2:":{"uc_base":"1f468-1f3fc-1f393","uc_output":"1f468-1f3fc-200d-1f393","uc_match":"1f468-1f3fc-1f393","uc_greedy":"1f468-1f3fc-1f393","shortnames":[":man_student_medium_light_skin_tone:"],"category":"people"},":man_student_tone3:":{"uc_base":"1f468-1f3fd-1f393","uc_output":"1f468-1f3fd-200d-1f393","uc_match":"1f468-1f3fd-1f393","uc_greedy":"1f468-1f3fd-1f393","shortnames":[":man_student_medium_skin_tone:"],"category":"people"},":man_student_tone4:":{"uc_base":"1f468-1f3fe-1f393","uc_output":"1f468-1f3fe-200d-1f393","uc_match":"1f468-1f3fe-1f393","uc_greedy":"1f468-1f3fe-1f393","shortnames":[":man_student_medium_dark_skin_tone:"],"category":"people"},":man_student_tone5:":{"uc_base":"1f468-1f3ff-1f393","uc_output":"1f468-1f3ff-200d-1f393","uc_match":"1f468-1f3ff-1f393","uc_greedy":"1f468-1f3ff-1f393","shortnames":[":man_student_dark_skin_tone:"],"category":"people"},":man_teacher_tone1:":{"uc_base":"1f468-1f3fb-1f3eb","uc_output":"1f468-1f3fb-200d-1f3eb","uc_match":"1f468-1f3fb-1f3eb","uc_greedy":"1f468-1f3fb-1f3eb","shortnames":[":man_teacher_light_skin_tone:"],"category":"people"},":man_teacher_tone2:":{"uc_base":"1f468-1f3fc-1f3eb","uc_output":"1f468-1f3fc-200d-1f3eb","uc_match":"1f468-1f3fc-1f3eb","uc_greedy":"1f468-1f3fc-1f3eb","shortnames":[":man_teacher_medium_light_skin_tone:"],"category":"people"},":man_teacher_tone3:":{"uc_base":"1f468-1f3fd-1f3eb","uc_output":"1f468-1f3fd-200d-1f3eb","uc_match":"1f468-1f3fd-1f3eb","uc_greedy":"1f468-1f3fd-1f3eb","shortnames":[":man_teacher_medium_skin_tone:"],"category":"people"},":man_teacher_tone4:":{"uc_base":"1f468-1f3fe-1f3eb","uc_output":"1f468-1f3fe-200d-1f3eb","uc_match":"1f468-1f3fe-1f3eb","uc_greedy":"1f468-1f3fe-1f3eb","shortnames":[":man_teacher_medium_dark_skin_tone:"],"category":"people"},":man_teacher_tone5:":{"uc_base":"1f468-1f3ff-1f3eb","uc_output":"1f468-1f3ff-200d-1f3eb","uc_match":"1f468-1f3ff-1f3eb","uc_greedy":"1f468-1f3ff-1f3eb","shortnames":[":man_teacher_dark_skin_tone:"],"category":"people"},":man_technologist_tone1:":{"uc_base":"1f468-1f3fb-1f4bb","uc_output":"1f468-1f3fb-200d-1f4bb","uc_match":"1f468-1f3fb-1f4bb","uc_greedy":"1f468-1f3fb-1f4bb","shortnames":[":man_technologist_light_skin_tone:"],"category":"people"},":man_technologist_tone2:":{"uc_base":"1f468-1f3fc-1f4bb","uc_output":"1f468-1f3fc-200d-1f4bb","uc_match":"1f468-1f3fc-1f4bb","uc_greedy":"1f468-1f3fc-1f4bb","shortnames":[":man_technologist_medium_light_skin_tone:"],"category":"people"},":man_technologist_tone3:":{"uc_base":"1f468-1f3fd-1f4bb","uc_output":"1f468-1f3fd-200d-1f4bb","uc_match":"1f468-1f3fd-1f4bb","uc_greedy":"1f468-1f3fd-1f4bb","shortnames":[":man_technologist_medium_skin_tone:"],"category":"people"},":man_technologist_tone4:":{"uc_base":"1f468-1f3fe-1f4bb","uc_output":"1f468-1f3fe-200d-1f4bb","uc_match":"1f468-1f3fe-1f4bb","uc_greedy":"1f468-1f3fe-1f4bb","shortnames":[":man_technologist_medium_dark_skin_tone:"],"category":"people"},":man_technologist_tone5:":{"uc_base":"1f468-1f3ff-1f4bb","uc_output":"1f468-1f3ff-200d-1f4bb","uc_match":"1f468-1f3ff-1f4bb","uc_greedy":"1f468-1f3ff-1f4bb","shortnames":[":man_technologist_dark_skin_tone:"],"category":"people"},":woman_artist_tone1:":{"uc_base":"1f469-1f3fb-1f3a8","uc_output":"1f469-1f3fb-200d-1f3a8","uc_match":"1f469-1f3fb-1f3a8","uc_greedy":"1f469-1f3fb-1f3a8","shortnames":[":woman_artist_light_skin_tone:"],"category":"people"},":woman_artist_tone2:":{"uc_base":"1f469-1f3fc-1f3a8","uc_output":"1f469-1f3fc-200d-1f3a8","uc_match":"1f469-1f3fc-1f3a8","uc_greedy":"1f469-1f3fc-1f3a8","shortnames":[":woman_artist_medium_light_skin_tone:"],"category":"people"},":woman_artist_tone3:":{"uc_base":"1f469-1f3fd-1f3a8","uc_output":"1f469-1f3fd-200d-1f3a8","uc_match":"1f469-1f3fd-1f3a8","uc_greedy":"1f469-1f3fd-1f3a8","shortnames":[":woman_artist_medium_skin_tone:"],"category":"people"},":woman_artist_tone4:":{"uc_base":"1f469-1f3fe-1f3a8","uc_output":"1f469-1f3fe-200d-1f3a8","uc_match":"1f469-1f3fe-1f3a8","uc_greedy":"1f469-1f3fe-1f3a8","shortnames":[":woman_artist_medium_dark_skin_tone:"],"category":"people"},":woman_artist_tone5:":{"uc_base":"1f469-1f3ff-1f3a8","uc_output":"1f469-1f3ff-200d-1f3a8","uc_match":"1f469-1f3ff-1f3a8","uc_greedy":"1f469-1f3ff-1f3a8","shortnames":[":woman_artist_dark_skin_tone:"],"category":"people"},":woman_astronaut_tone1:":{"uc_base":"1f469-1f3fb-1f680","uc_output":"1f469-1f3fb-200d-1f680","uc_match":"1f469-1f3fb-1f680","uc_greedy":"1f469-1f3fb-1f680","shortnames":[":woman_astronaut_light_skin_tone:"],"category":"people"},":woman_astronaut_tone2:":{"uc_base":"1f469-1f3fc-1f680","uc_output":"1f469-1f3fc-200d-1f680","uc_match":"1f469-1f3fc-1f680","uc_greedy":"1f469-1f3fc-1f680","shortnames":[":woman_astronaut_medium_light_skin_tone:"],"category":"people"},":woman_astronaut_tone3:":{"uc_base":"1f469-1f3fd-1f680","uc_output":"1f469-1f3fd-200d-1f680","uc_match":"1f469-1f3fd-1f680","uc_greedy":"1f469-1f3fd-1f680","shortnames":[":woman_astronaut_medium_skin_tone:"],"category":"people"},":woman_astronaut_tone4:":{"uc_base":"1f469-1f3fe-1f680","uc_output":"1f469-1f3fe-200d-1f680","uc_match":"1f469-1f3fe-1f680","uc_greedy":"1f469-1f3fe-1f680","shortnames":[":woman_astronaut_medium_dark_skin_tone:"],"category":"people"},":woman_astronaut_tone5:":{"uc_base":"1f469-1f3ff-1f680","uc_output":"1f469-1f3ff-200d-1f680","uc_match":"1f469-1f3ff-1f680","uc_greedy":"1f469-1f3ff-1f680","shortnames":[":woman_astronaut_dark_skin_tone:"],"category":"people"},":woman_cook_tone1:":{"uc_base":"1f469-1f3fb-1f373","uc_output":"1f469-1f3fb-200d-1f373","uc_match":"1f469-1f3fb-1f373","uc_greedy":"1f469-1f3fb-1f373","shortnames":[":woman_cook_light_skin_tone:"],"category":"people"},":woman_cook_tone2:":{"uc_base":"1f469-1f3fc-1f373","uc_output":"1f469-1f3fc-200d-1f373","uc_match":"1f469-1f3fc-1f373","uc_greedy":"1f469-1f3fc-1f373","shortnames":[":woman_cook_medium_light_skin_tone:"],"category":"people"},":woman_cook_tone3:":{"uc_base":"1f469-1f3fd-1f373","uc_output":"1f469-1f3fd-200d-1f373","uc_match":"1f469-1f3fd-1f373","uc_greedy":"1f469-1f3fd-1f373","shortnames":[":woman_cook_medium_skin_tone:"],"category":"people"},":woman_cook_tone4:":{"uc_base":"1f469-1f3fe-1f373","uc_output":"1f469-1f3fe-200d-1f373","uc_match":"1f469-1f3fe-1f373","uc_greedy":"1f469-1f3fe-1f373","shortnames":[":woman_cook_medium_dark_skin_tone:"],"category":"people"},":woman_cook_tone5:":{"uc_base":"1f469-1f3ff-1f373","uc_output":"1f469-1f3ff-200d-1f373","uc_match":"1f469-1f3ff-1f373","uc_greedy":"1f469-1f3ff-1f373","shortnames":[":woman_cook_dark_skin_tone:"],"category":"people"},":woman_factory_worker_tone1:":{"uc_base":"1f469-1f3fb-1f3ed","uc_output":"1f469-1f3fb-200d-1f3ed","uc_match":"1f469-1f3fb-1f3ed","uc_greedy":"1f469-1f3fb-1f3ed","shortnames":[":woman_factory_worker_light_skin_tone:"],"category":"people"},":woman_factory_worker_tone2:":{"uc_base":"1f469-1f3fc-1f3ed","uc_output":"1f469-1f3fc-200d-1f3ed","uc_match":"1f469-1f3fc-1f3ed","uc_greedy":"1f469-1f3fc-1f3ed","shortnames":[":woman_factory_worker_medium_light_skin_tone:"],"category":"people"},":woman_factory_worker_tone3:":{"uc_base":"1f469-1f3fd-1f3ed","uc_output":"1f469-1f3fd-200d-1f3ed","uc_match":"1f469-1f3fd-1f3ed","uc_greedy":"1f469-1f3fd-1f3ed","shortnames":[":woman_factory_worker_medium_skin_tone:"],"category":"people"},":woman_factory_worker_tone4:":{"uc_base":"1f469-1f3fe-1f3ed","uc_output":"1f469-1f3fe-200d-1f3ed","uc_match":"1f469-1f3fe-1f3ed","uc_greedy":"1f469-1f3fe-1f3ed","shortnames":[":woman_factory_worker_medium_dark_skin_tone:"],"category":"people"},":woman_factory_worker_tone5:":{"uc_base":"1f469-1f3ff-1f3ed","uc_output":"1f469-1f3ff-200d-1f3ed","uc_match":"1f469-1f3ff-1f3ed","uc_greedy":"1f469-1f3ff-1f3ed","shortnames":[":woman_factory_worker_dark_skin_tone:"],"category":"people"},":woman_farmer_tone1:":{"uc_base":"1f469-1f3fb-1f33e","uc_output":"1f469-1f3fb-200d-1f33e","uc_match":"1f469-1f3fb-1f33e","uc_greedy":"1f469-1f3fb-1f33e","shortnames":[":woman_farmer_light_skin_tone:"],"category":"people"},":woman_farmer_tone2:":{"uc_base":"1f469-1f3fc-1f33e","uc_output":"1f469-1f3fc-200d-1f33e","uc_match":"1f469-1f3fc-1f33e","uc_greedy":"1f469-1f3fc-1f33e","shortnames":[":woman_farmer_medium_light_skin_tone:"],"category":"people"},":woman_farmer_tone3:":{"uc_base":"1f469-1f3fd-1f33e","uc_output":"1f469-1f3fd-200d-1f33e","uc_match":"1f469-1f3fd-1f33e","uc_greedy":"1f469-1f3fd-1f33e","shortnames":[":woman_farmer_medium_skin_tone:"],"category":"people"},":woman_farmer_tone4:":{"uc_base":"1f469-1f3fe-1f33e","uc_output":"1f469-1f3fe-200d-1f33e","uc_match":"1f469-1f3fe-1f33e","uc_greedy":"1f469-1f3fe-1f33e","shortnames":[":woman_farmer_medium_dark_skin_tone:"],"category":"people"},":woman_farmer_tone5:":{"uc_base":"1f469-1f3ff-1f33e","uc_output":"1f469-1f3ff-200d-1f33e","uc_match":"1f469-1f3ff-1f33e","uc_greedy":"1f469-1f3ff-1f33e","shortnames":[":woman_farmer_dark_skin_tone:"],"category":"people"},":woman_firefighter_tone1:":{"uc_base":"1f469-1f3fb-1f692","uc_output":"1f469-1f3fb-200d-1f692","uc_match":"1f469-1f3fb-1f692","uc_greedy":"1f469-1f3fb-1f692","shortnames":[":woman_firefighter_light_skin_tone:"],"category":"people"},":woman_firefighter_tone2:":{"uc_base":"1f469-1f3fc-1f692","uc_output":"1f469-1f3fc-200d-1f692","uc_match":"1f469-1f3fc-1f692","uc_greedy":"1f469-1f3fc-1f692","shortnames":[":woman_firefighter_medium_light_skin_tone:"],"category":"people"},":woman_firefighter_tone3:":{"uc_base":"1f469-1f3fd-1f692","uc_output":"1f469-1f3fd-200d-1f692","uc_match":"1f469-1f3fd-1f692","uc_greedy":"1f469-1f3fd-1f692","shortnames":[":woman_firefighter_medium_skin_tone:"],"category":"people"},":woman_firefighter_tone4:":{"uc_base":"1f469-1f3fe-1f692","uc_output":"1f469-1f3fe-200d-1f692","uc_match":"1f469-1f3fe-1f692","uc_greedy":"1f469-1f3fe-1f692","shortnames":[":woman_firefighter_medium_dark_skin_tone:"],"category":"people"},":woman_firefighter_tone5:":{"uc_base":"1f469-1f3ff-1f692","uc_output":"1f469-1f3ff-200d-1f692","uc_match":"1f469-1f3ff-1f692","uc_greedy":"1f469-1f3ff-1f692","shortnames":[":woman_firefighter_dark_skin_tone:"],"category":"people"},":woman_mechanic_tone1:":{"uc_base":"1f469-1f3fb-1f527","uc_output":"1f469-1f3fb-200d-1f527","uc_match":"1f469-1f3fb-1f527","uc_greedy":"1f469-1f3fb-1f527","shortnames":[":woman_mechanic_light_skin_tone:"],"category":"people"},":woman_mechanic_tone2:":{"uc_base":"1f469-1f3fc-1f527","uc_output":"1f469-1f3fc-200d-1f527","uc_match":"1f469-1f3fc-1f527","uc_greedy":"1f469-1f3fc-1f527","shortnames":[":woman_mechanic_medium_light_skin_tone:"],"category":"people"},":woman_mechanic_tone3:":{"uc_base":"1f469-1f3fd-1f527","uc_output":"1f469-1f3fd-200d-1f527","uc_match":"1f469-1f3fd-1f527","uc_greedy":"1f469-1f3fd-1f527","shortnames":[":woman_mechanic_medium_skin_tone:"],"category":"people"},":woman_mechanic_tone4:":{"uc_base":"1f469-1f3fe-1f527","uc_output":"1f469-1f3fe-200d-1f527","uc_match":"1f469-1f3fe-1f527","uc_greedy":"1f469-1f3fe-1f527","shortnames":[":woman_mechanic_medium_dark_skin_tone:"],"category":"people"},":woman_mechanic_tone5:":{"uc_base":"1f469-1f3ff-1f527","uc_output":"1f469-1f3ff-200d-1f527","uc_match":"1f469-1f3ff-1f527","uc_greedy":"1f469-1f3ff-1f527","shortnames":[":woman_mechanic_dark_skin_tone:"],"category":"people"},":woman_office_worker_tone1:":{"uc_base":"1f469-1f3fb-1f4bc","uc_output":"1f469-1f3fb-200d-1f4bc","uc_match":"1f469-1f3fb-1f4bc","uc_greedy":"1f469-1f3fb-1f4bc","shortnames":[":woman_office_worker_light_skin_tone:"],"category":"people"},":woman_office_worker_tone2:":{"uc_base":"1f469-1f3fc-1f4bc","uc_output":"1f469-1f3fc-200d-1f4bc","uc_match":"1f469-1f3fc-1f4bc","uc_greedy":"1f469-1f3fc-1f4bc","shortnames":[":woman_office_worker_medium_light_skin_tone:"],"category":"people"},":woman_office_worker_tone3:":{"uc_base":"1f469-1f3fd-1f4bc","uc_output":"1f469-1f3fd-200d-1f4bc","uc_match":"1f469-1f3fd-1f4bc","uc_greedy":"1f469-1f3fd-1f4bc","shortnames":[":woman_office_worker_medium_skin_tone:"],"category":"people"},":woman_office_worker_tone4:":{"uc_base":"1f469-1f3fe-1f4bc","uc_output":"1f469-1f3fe-200d-1f4bc","uc_match":"1f469-1f3fe-1f4bc","uc_greedy":"1f469-1f3fe-1f4bc","shortnames":[":woman_office_worker_medium_dark_skin_tone:"],"category":"people"},":woman_office_worker_tone5:":{"uc_base":"1f469-1f3ff-1f4bc","uc_output":"1f469-1f3ff-200d-1f4bc","uc_match":"1f469-1f3ff-1f4bc","uc_greedy":"1f469-1f3ff-1f4bc","shortnames":[":woman_office_worker_dark_skin_tone:"],"category":"people"},":woman_scientist_tone1:":{"uc_base":"1f469-1f3fb-1f52c","uc_output":"1f469-1f3fb-200d-1f52c","uc_match":"1f469-1f3fb-1f52c","uc_greedy":"1f469-1f3fb-1f52c","shortnames":[":woman_scientist_light_skin_tone:"],"category":"people"},":woman_scientist_tone2:":{"uc_base":"1f469-1f3fc-1f52c","uc_output":"1f469-1f3fc-200d-1f52c","uc_match":"1f469-1f3fc-1f52c","uc_greedy":"1f469-1f3fc-1f52c","shortnames":[":woman_scientist_medium_light_skin_tone:"],"category":"people"},":woman_scientist_tone3:":{"uc_base":"1f469-1f3fd-1f52c","uc_output":"1f469-1f3fd-200d-1f52c","uc_match":"1f469-1f3fd-1f52c","uc_greedy":"1f469-1f3fd-1f52c","shortnames":[":woman_scientist_medium_skin_tone:"],"category":"people"},":woman_scientist_tone4:":{"uc_base":"1f469-1f3fe-1f52c","uc_output":"1f469-1f3fe-200d-1f52c","uc_match":"1f469-1f3fe-1f52c","uc_greedy":"1f469-1f3fe-1f52c","shortnames":[":woman_scientist_medium_dark_skin_tone:"],"category":"people"},":woman_scientist_tone5:":{"uc_base":"1f469-1f3ff-1f52c","uc_output":"1f469-1f3ff-200d-1f52c","uc_match":"1f469-1f3ff-1f52c","uc_greedy":"1f469-1f3ff-1f52c","shortnames":[":woman_scientist_dark_skin_tone:"],"category":"people"},":woman_singer_tone1:":{"uc_base":"1f469-1f3fb-1f3a4","uc_output":"1f469-1f3fb-200d-1f3a4","uc_match":"1f469-1f3fb-1f3a4","uc_greedy":"1f469-1f3fb-1f3a4","shortnames":[":woman_singer_light_skin_tone:"],"category":"people"},":woman_singer_tone2:":{"uc_base":"1f469-1f3fc-1f3a4","uc_output":"1f469-1f3fc-200d-1f3a4","uc_match":"1f469-1f3fc-1f3a4","uc_greedy":"1f469-1f3fc-1f3a4","shortnames":[":woman_singer_medium_light_skin_tone:"],"category":"people"},":woman_singer_tone3:":{"uc_base":"1f469-1f3fd-1f3a4","uc_output":"1f469-1f3fd-200d-1f3a4","uc_match":"1f469-1f3fd-1f3a4","uc_greedy":"1f469-1f3fd-1f3a4","shortnames":[":woman_singer_medium_skin_tone:"],"category":"people"},":woman_singer_tone4:":{"uc_base":"1f469-1f3fe-1f3a4","uc_output":"1f469-1f3fe-200d-1f3a4","uc_match":"1f469-1f3fe-1f3a4","uc_greedy":"1f469-1f3fe-1f3a4","shortnames":[":woman_singer_medium_dark_skin_tone:"],"category":"people"},":woman_singer_tone5:":{"uc_base":"1f469-1f3ff-1f3a4","uc_output":"1f469-1f3ff-200d-1f3a4","uc_match":"1f469-1f3ff-1f3a4","uc_greedy":"1f469-1f3ff-1f3a4","shortnames":[":woman_singer_dark_skin_tone:"],"category":"people"},":woman_student_tone1:":{"uc_base":"1f469-1f3fb-1f393","uc_output":"1f469-1f3fb-200d-1f393","uc_match":"1f469-1f3fb-1f393","uc_greedy":"1f469-1f3fb-1f393","shortnames":[":woman_student_light_skin_tone:"],"category":"people"},":woman_student_tone2:":{"uc_base":"1f469-1f3fc-1f393","uc_output":"1f469-1f3fc-200d-1f393","uc_match":"1f469-1f3fc-1f393","uc_greedy":"1f469-1f3fc-1f393","shortnames":[":woman_student_medium_light_skin_tone:"],"category":"people"},":woman_student_tone3:":{"uc_base":"1f469-1f3fd-1f393","uc_output":"1f469-1f3fd-200d-1f393","uc_match":"1f469-1f3fd-1f393","uc_greedy":"1f469-1f3fd-1f393","shortnames":[":woman_student_medium_skin_tone:"],"category":"people"},":woman_student_tone4:":{"uc_base":"1f469-1f3fe-1f393","uc_output":"1f469-1f3fe-200d-1f393","uc_match":"1f469-1f3fe-1f393","uc_greedy":"1f469-1f3fe-1f393","shortnames":[":woman_student_medium_dark_skin_tone:"],"category":"people"},":woman_student_tone5:":{"uc_base":"1f469-1f3ff-1f393","uc_output":"1f469-1f3ff-200d-1f393","uc_match":"1f469-1f3ff-1f393","uc_greedy":"1f469-1f3ff-1f393","shortnames":[":woman_student_dark_skin_tone:"],"category":"people"},":woman_teacher_tone1:":{"uc_base":"1f469-1f3fb-1f3eb","uc_output":"1f469-1f3fb-200d-1f3eb","uc_match":"1f469-1f3fb-1f3eb","uc_greedy":"1f469-1f3fb-1f3eb","shortnames":[":woman_teacher_light_skin_tone:"],"category":"people"},":woman_teacher_tone2:":{"uc_base":"1f469-1f3fc-1f3eb","uc_output":"1f469-1f3fc-200d-1f3eb","uc_match":"1f469-1f3fc-1f3eb","uc_greedy":"1f469-1f3fc-1f3eb","shortnames":[":woman_teacher_medium_light_skin_tone:"],"category":"people"},":woman_teacher_tone3:":{"uc_base":"1f469-1f3fd-1f3eb","uc_output":"1f469-1f3fd-200d-1f3eb","uc_match":"1f469-1f3fd-1f3eb","uc_greedy":"1f469-1f3fd-1f3eb","shortnames":[":woman_teacher_medium_skin_tone:"],"category":"people"},":woman_teacher_tone4:":{"uc_base":"1f469-1f3fe-1f3eb","uc_output":"1f469-1f3fe-200d-1f3eb","uc_match":"1f469-1f3fe-1f3eb","uc_greedy":"1f469-1f3fe-1f3eb","shortnames":[":woman_teacher_medium_dark_skin_tone:"],"category":"people"},":woman_teacher_tone5:":{"uc_base":"1f469-1f3ff-1f3eb","uc_output":"1f469-1f3ff-200d-1f3eb","uc_match":"1f469-1f3ff-1f3eb","uc_greedy":"1f469-1f3ff-1f3eb","shortnames":[":woman_teacher_dark_skin_tone:"],"category":"people"},":woman_technologist_tone1:":{"uc_base":"1f469-1f3fb-1f4bb","uc_output":"1f469-1f3fb-200d-1f4bb","uc_match":"1f469-1f3fb-1f4bb","uc_greedy":"1f469-1f3fb-1f4bb","shortnames":[":woman_technologist_light_skin_tone:"],"category":"people"},":woman_technologist_tone2:":{"uc_base":"1f469-1f3fc-1f4bb","uc_output":"1f469-1f3fc-200d-1f4bb","uc_match":"1f469-1f3fc-1f4bb","uc_greedy":"1f469-1f3fc-1f4bb","shortnames":[":woman_technologist_medium_light_skin_tone:"],"category":"people"},":woman_technologist_tone3:":{"uc_base":"1f469-1f3fd-1f4bb","uc_output":"1f469-1f3fd-200d-1f4bb","uc_match":"1f469-1f3fd-1f4bb","uc_greedy":"1f469-1f3fd-1f4bb","shortnames":[":woman_technologist_medium_skin_tone:"],"category":"people"},":woman_technologist_tone4:":{"uc_base":"1f469-1f3fe-1f4bb","uc_output":"1f469-1f3fe-200d-1f4bb","uc_match":"1f469-1f3fe-1f4bb","uc_greedy":"1f469-1f3fe-1f4bb","shortnames":[":woman_technologist_medium_dark_skin_tone:"],"category":"people"},":woman_technologist_tone5:":{"uc_base":"1f469-1f3ff-1f4bb","uc_output":"1f469-1f3ff-200d-1f4bb","uc_match":"1f469-1f3ff-1f4bb","uc_greedy":"1f469-1f3ff-1f4bb","shortnames":[":woman_technologist_dark_skin_tone:"],"category":"people"},":rainbow_flag:":{"uc_base":"1f3f3-1f308","uc_output":"1f3f3-fe0f-200d-1f308","uc_match":"1f3f3-fe0f-1f308","uc_greedy":"1f3f3-1f308","shortnames":[":gay_pride_flag:"],"category":"flags"},":blond-haired_man:":{"uc_base":"1f471-2642","uc_output":"1f471-200d-2642-fe0f","uc_match":"1f471-2642-fe0f","uc_greedy":"1f471-2642","shortnames":[],"category":"people"},":blond-haired_woman:":{"uc_base":"1f471-2640","uc_output":"1f471-200d-2640-fe0f","uc_match":"1f471-2640-fe0f","uc_greedy":"1f471-2640","shortnames":[],"category":"people"},":man_biking:":{"uc_base":"1f6b4-2642","uc_output":"1f6b4-200d-2642-fe0f","uc_match":"1f6b4-2642-fe0f","uc_greedy":"1f6b4-2642","shortnames":[],"category":"activity"},":man_bowing:":{"uc_base":"1f647-2642","uc_output":"1f647-200d-2642-fe0f","uc_match":"1f647-2642-fe0f","uc_greedy":"1f647-2642","shortnames":[],"category":"people"},":man_cartwheeling:":{"uc_base":"1f938-2642","uc_output":"1f938-200d-2642-fe0f","uc_match":"1f938-2642-fe0f","uc_greedy":"1f938-2642","shortnames":[],"category":"activity"},":man_climbing:":{"uc_base":"1f9d7-2642","uc_output":"1f9d7-200d-2642-fe0f","uc_match":"1f9d7-2642-fe0f","uc_greedy":"1f9d7-2642","shortnames":[],"category":"activity"},":man_construction_worker:":{"uc_base":"1f477-2642","uc_output":"1f477-200d-2642-fe0f","uc_match":"1f477-2642-fe0f","uc_greedy":"1f477-2642","shortnames":[],"category":"people"},":man_elf:":{"uc_base":"1f9dd-2642","uc_output":"1f9dd-200d-2642-fe0f","uc_match":"1f9dd-2642-fe0f","uc_greedy":"1f9dd-2642","shortnames":[],"category":"people"},":man_facepalming:":{"uc_base":"1f926-2642","uc_output":"1f926-200d-2642-fe0f","uc_match":"1f926-2642-fe0f","uc_greedy":"1f926-2642","shortnames":[],"category":"people"},":man_fairy:":{"uc_base":"1f9da-2642","uc_output":"1f9da-200d-2642-fe0f","uc_match":"1f9da-2642-fe0f","uc_greedy":"1f9da-2642","shortnames":[],"category":"people"},":man_frowning:":{"uc_base":"1f64d-2642","uc_output":"1f64d-200d-2642-fe0f","uc_match":"1f64d-2642-fe0f","uc_greedy":"1f64d-2642","shortnames":[],"category":"people"},":man_genie:":{"uc_base":"1f9de-2642","uc_output":"1f9de-200d-2642-fe0f","uc_match":"1f9de-2642-fe0f","uc_greedy":"1f9de-2642","shortnames":[],"category":"people"},":man_gesturing_no:":{"uc_base":"1f645-2642","uc_output":"1f645-200d-2642-fe0f","uc_match":"1f645-2642-fe0f","uc_greedy":"1f645-2642","shortnames":[],"category":"people"},":man_gesturing_ok:":{"uc_base":"1f646-2642","uc_output":"1f646-200d-2642-fe0f","uc_match":"1f646-2642-fe0f","uc_greedy":"1f646-2642","shortnames":[],"category":"people"},":man_getting_face_massage:":{"uc_base":"1f486-2642","uc_output":"1f486-200d-2642-fe0f","uc_match":"1f486-2642-fe0f","uc_greedy":"1f486-2642","shortnames":[],"category":"people"},":man_getting_haircut:":{"uc_base":"1f487-2642","uc_output":"1f487-200d-2642-fe0f","uc_match":"1f487-2642-fe0f","uc_greedy":"1f487-2642","shortnames":[],"category":"people"},":man_guard:":{"uc_base":"1f482-2642","uc_output":"1f482-200d-2642-fe0f","uc_match":"1f482-2642-fe0f","uc_greedy":"1f482-2642","shortnames":[],"category":"people"},":man_health_worker:":{"uc_base":"1f468-2695","uc_output":"1f468-200d-2695-fe0f","uc_match":"1f468-2695-fe0f","uc_greedy":"1f468-2695","shortnames":[],"category":"people"},":man_in_lotus_position:":{"uc_base":"1f9d8-2642","uc_output":"1f9d8-200d-2642-fe0f","uc_match":"1f9d8-2642-fe0f","uc_greedy":"1f9d8-2642","shortnames":[],"category":"activity"},":man_in_steamy_room:":{"uc_base":"1f9d6-2642","uc_output":"1f9d6-200d-2642-fe0f","uc_match":"1f9d6-2642-fe0f","uc_greedy":"1f9d6-2642","shortnames":[],"category":"people"},":man_judge:":{"uc_base":"1f468-2696","uc_output":"1f468-200d-2696-fe0f","uc_match":"1f468-2696-fe0f","uc_greedy":"1f468-2696","shortnames":[],"category":"people"},":man_juggling:":{"uc_base":"1f939-2642","uc_output":"1f939-200d-2642-fe0f","uc_match":"1f939-2642-fe0f","uc_greedy":"1f939-2642","shortnames":[],"category":"activity"},":man_mage:":{"uc_base":"1f9d9-2642","uc_output":"1f9d9-200d-2642-fe0f","uc_match":"1f9d9-2642-fe0f","uc_greedy":"1f9d9-2642","shortnames":[],"category":"people"},":man_mountain_biking:":{"uc_base":"1f6b5-2642","uc_output":"1f6b5-200d-2642-fe0f","uc_match":"1f6b5-2642-fe0f","uc_greedy":"1f6b5-2642","shortnames":[],"category":"activity"},":man_pilot:":{"uc_base":"1f468-2708","uc_output":"1f468-200d-2708-fe0f","uc_match":"1f468-2708-fe0f","uc_greedy":"1f468-2708","shortnames":[],"category":"people"},":man_playing_handball:":{"uc_base":"1f93e-2642","uc_output":"1f93e-200d-2642-fe0f","uc_match":"1f93e-2642-fe0f","uc_greedy":"1f93e-2642","shortnames":[],"category":"activity"},":man_playing_water_polo:":{"uc_base":"1f93d-2642","uc_output":"1f93d-200d-2642-fe0f","uc_match":"1f93d-2642-fe0f","uc_greedy":"1f93d-2642","shortnames":[],"category":"activity"},":man_police_officer:":{"uc_base":"1f46e-2642","uc_output":"1f46e-200d-2642-fe0f","uc_match":"1f46e-2642-fe0f","uc_greedy":"1f46e-2642","shortnames":[],"category":"people"},":man_pouting:":{"uc_base":"1f64e-2642","uc_output":"1f64e-200d-2642-fe0f","uc_match":"1f64e-2642-fe0f","uc_greedy":"1f64e-2642","shortnames":[],"category":"people"},":man_raising_hand:":{"uc_base":"1f64b-2642","uc_output":"1f64b-200d-2642-fe0f","uc_match":"1f64b-2642-fe0f","uc_greedy":"1f64b-2642","shortnames":[],"category":"people"},":man_rowing_boat:":{"uc_base":"1f6a3-2642","uc_output":"1f6a3-200d-2642-fe0f","uc_match":"1f6a3-2642-fe0f","uc_greedy":"1f6a3-2642","shortnames":[],"category":"activity"},":man_running:":{"uc_base":"1f3c3-2642","uc_output":"1f3c3-200d-2642-fe0f","uc_match":"1f3c3-2642-fe0f","uc_greedy":"1f3c3-2642","shortnames":[],"category":"people"},":man_shrugging:":{"uc_base":"1f937-2642","uc_output":"1f937-200d-2642-fe0f","uc_match":"1f937-2642-fe0f","uc_greedy":"1f937-2642","shortnames":[],"category":"people"},":man_surfing:":{"uc_base":"1f3c4-2642","uc_output":"1f3c4-200d-2642-fe0f","uc_match":"1f3c4-2642-fe0f","uc_greedy":"1f3c4-2642","shortnames":[],"category":"activity"},":man_swimming:":{"uc_base":"1f3ca-2642","uc_output":"1f3ca-200d-2642-fe0f","uc_match":"1f3ca-2642-fe0f","uc_greedy":"1f3ca-2642","shortnames":[],"category":"activity"},":man_tipping_hand:":{"uc_base":"1f481-2642","uc_output":"1f481-200d-2642-fe0f","uc_match":"1f481-2642-fe0f","uc_greedy":"1f481-2642","shortnames":[],"category":"people"},":man_vampire:":{"uc_base":"1f9db-2642","uc_output":"1f9db-200d-2642-fe0f","uc_match":"1f9db-2642-fe0f","uc_greedy":"1f9db-2642","shortnames":[],"category":"people"},":man_walking:":{"uc_base":"1f6b6-2642","uc_output":"1f6b6-200d-2642-fe0f","uc_match":"1f6b6-2642-fe0f","uc_greedy":"1f6b6-2642","shortnames":[],"category":"people"},":man_wearing_turban:":{"uc_base":"1f473-2642","uc_output":"1f473-200d-2642-fe0f","uc_match":"1f473-2642-fe0f","uc_greedy":"1f473-2642","shortnames":[],"category":"people"},":man_zombie:":{"uc_base":"1f9df-2642","uc_output":"1f9df-200d-2642-fe0f","uc_match":"1f9df-2642-fe0f","uc_greedy":"1f9df-2642","shortnames":[],"category":"people"},":men_with_bunny_ears_partying:":{"uc_base":"1f46f-2642","uc_output":"1f46f-200d-2642-fe0f","uc_match":"1f46f-2642-fe0f","uc_greedy":"1f46f-2642","shortnames":[],"category":"people"},":men_wrestling:":{"uc_base":"1f93c-2642","uc_output":"1f93c-200d-2642-fe0f","uc_match":"1f93c-2642-fe0f","uc_greedy":"1f93c-2642","shortnames":[],"category":"activity"},":mermaid:":{"uc_base":"1f9dc-2640","uc_output":"1f9dc-200d-2640-fe0f","uc_match":"1f9dc-2640-fe0f","uc_greedy":"1f9dc-2640","shortnames":[],"category":"people"},":merman:":{"uc_base":"1f9dc-2642","uc_output":"1f9dc-200d-2642-fe0f","uc_match":"1f9dc-2642-fe0f","uc_greedy":"1f9dc-2642","shortnames":[],"category":"people"},":woman_biking:":{"uc_base":"1f6b4-2640","uc_output":"1f6b4-200d-2640-fe0f","uc_match":"1f6b4-2640-fe0f","uc_greedy":"1f6b4-2640","shortnames":[],"category":"activity"},":woman_bowing:":{"uc_base":"1f647-2640","uc_output":"1f647-200d-2640-fe0f","uc_match":"1f647-2640-fe0f","uc_greedy":"1f647-2640","shortnames":[],"category":"people"},":woman_cartwheeling:":{"uc_base":"1f938-2640","uc_output":"1f938-200d-2640-fe0f","uc_match":"1f938-2640-fe0f","uc_greedy":"1f938-2640","shortnames":[],"category":"activity"},":woman_climbing:":{"uc_base":"1f9d7-2640","uc_output":"1f9d7-200d-2640-fe0f","uc_match":"1f9d7-2640-fe0f","uc_greedy":"1f9d7-2640","shortnames":[],"category":"activity"},":woman_construction_worker:":{"uc_base":"1f477-2640","uc_output":"1f477-200d-2640-fe0f","uc_match":"1f477-2640-fe0f","uc_greedy":"1f477-2640","shortnames":[],"category":"people"},":woman_elf:":{"uc_base":"1f9dd-2640","uc_output":"1f9dd-200d-2640-fe0f","uc_match":"1f9dd-2640-fe0f","uc_greedy":"1f9dd-2640","shortnames":[],"category":"people"},":woman_facepalming:":{"uc_base":"1f926-2640","uc_output":"1f926-200d-2640-fe0f","uc_match":"1f926-2640-fe0f","uc_greedy":"1f926-2640","shortnames":[],"category":"people"},":woman_fairy:":{"uc_base":"1f9da-2640","uc_output":"1f9da-200d-2640-fe0f","uc_match":"1f9da-2640-fe0f","uc_greedy":"1f9da-2640","shortnames":[],"category":"people"},":woman_frowning:":{"uc_base":"1f64d-2640","uc_output":"1f64d-200d-2640-fe0f","uc_match":"1f64d-2640-fe0f","uc_greedy":"1f64d-2640","shortnames":[],"category":"people"},":woman_genie:":{"uc_base":"1f9de-2640","uc_output":"1f9de-200d-2640-fe0f","uc_match":"1f9de-2640-fe0f","uc_greedy":"1f9de-2640","shortnames":[],"category":"people"},":woman_gesturing_no:":{"uc_base":"1f645-2640","uc_output":"1f645-200d-2640-fe0f","uc_match":"1f645-2640-fe0f","uc_greedy":"1f645-2640","shortnames":[],"category":"people"},":woman_gesturing_ok:":{"uc_base":"1f646-2640","uc_output":"1f646-200d-2640-fe0f","uc_match":"1f646-2640-fe0f","uc_greedy":"1f646-2640","shortnames":[],"category":"people"},":woman_getting_face_massage:":{"uc_base":"1f486-2640","uc_output":"1f486-200d-2640-fe0f","uc_match":"1f486-2640-fe0f","uc_greedy":"1f486-2640","shortnames":[],"category":"people"},":woman_getting_haircut:":{"uc_base":"1f487-2640","uc_output":"1f487-200d-2640-fe0f","uc_match":"1f487-2640-fe0f","uc_greedy":"1f487-2640","shortnames":[],"category":"people"},":woman_guard:":{"uc_base":"1f482-2640","uc_output":"1f482-200d-2640-fe0f","uc_match":"1f482-2640-fe0f","uc_greedy":"1f482-2640","shortnames":[],"category":"people"},":woman_health_worker:":{"uc_base":"1f469-2695","uc_output":"1f469-200d-2695-fe0f","uc_match":"1f469-2695-fe0f","uc_greedy":"1f469-2695","shortnames":[],"category":"people"},":woman_in_lotus_position:":{"uc_base":"1f9d8-2640","uc_output":"1f9d8-200d-2640-fe0f","uc_match":"1f9d8-2640-fe0f","uc_greedy":"1f9d8-2640","shortnames":[],"category":"activity"},":woman_in_steamy_room:":{"uc_base":"1f9d6-2640","uc_output":"1f9d6-200d-2640-fe0f","uc_match":"1f9d6-2640-fe0f","uc_greedy":"1f9d6-2640","shortnames":[],"category":"people"},":woman_judge:":{"uc_base":"1f469-2696","uc_output":"1f469-200d-2696-fe0f","uc_match":"1f469-2696-fe0f","uc_greedy":"1f469-2696","shortnames":[],"category":"people"},":woman_juggling:":{"uc_base":"1f939-2640","uc_output":"1f939-200d-2640-fe0f","uc_match":"1f939-2640-fe0f","uc_greedy":"1f939-2640","shortnames":[],"category":"activity"},":woman_mage:":{"uc_base":"1f9d9-2640","uc_output":"1f9d9-200d-2640-fe0f","uc_match":"1f9d9-2640-fe0f","uc_greedy":"1f9d9-2640","shortnames":[],"category":"people"},":woman_mountain_biking:":{"uc_base":"1f6b5-2640","uc_output":"1f6b5-200d-2640-fe0f","uc_match":"1f6b5-2640-fe0f","uc_greedy":"1f6b5-2640","shortnames":[],"category":"activity"},":woman_pilot:":{"uc_base":"1f469-2708","uc_output":"1f469-200d-2708-fe0f","uc_match":"1f469-2708-fe0f","uc_greedy":"1f469-2708","shortnames":[],"category":"people"},":woman_playing_handball:":{"uc_base":"1f93e-2640","uc_output":"1f93e-200d-2640-fe0f","uc_match":"1f93e-2640-fe0f","uc_greedy":"1f93e-2640","shortnames":[],"category":"activity"},":woman_playing_water_polo:":{"uc_base":"1f93d-2640","uc_output":"1f93d-200d-2640-fe0f","uc_match":"1f93d-2640-fe0f","uc_greedy":"1f93d-2640","shortnames":[],"category":"activity"},":woman_police_officer:":{"uc_base":"1f46e-2640","uc_output":"1f46e-200d-2640-fe0f","uc_match":"1f46e-2640-fe0f","uc_greedy":"1f46e-2640","shortnames":[],"category":"people"},":woman_pouting:":{"uc_base":"1f64e-2640","uc_output":"1f64e-200d-2640-fe0f","uc_match":"1f64e-2640-fe0f","uc_greedy":"1f64e-2640","shortnames":[],"category":"people"},":woman_raising_hand:":{"uc_base":"1f64b-2640","uc_output":"1f64b-200d-2640-fe0f","uc_match":"1f64b-2640-fe0f","uc_greedy":"1f64b-2640","shortnames":[],"category":"people"},":woman_rowing_boat:":{"uc_base":"1f6a3-2640","uc_output":"1f6a3-200d-2640-fe0f","uc_match":"1f6a3-2640-fe0f","uc_greedy":"1f6a3-2640","shortnames":[],"category":"activity"},":woman_running:":{"uc_base":"1f3c3-2640","uc_output":"1f3c3-200d-2640-fe0f","uc_match":"1f3c3-2640-fe0f","uc_greedy":"1f3c3-2640","shortnames":[],"category":"people"},":woman_shrugging:":{"uc_base":"1f937-2640","uc_output":"1f937-200d-2640-fe0f","uc_match":"1f937-2640-fe0f","uc_greedy":"1f937-2640","shortnames":[],"category":"people"},":woman_surfing:":{"uc_base":"1f3c4-2640","uc_output":"1f3c4-200d-2640-fe0f","uc_match":"1f3c4-2640-fe0f","uc_greedy":"1f3c4-2640","shortnames":[],"category":"activity"},":woman_swimming:":{"uc_base":"1f3ca-2640","uc_output":"1f3ca-200d-2640-fe0f","uc_match":"1f3ca-2640-fe0f","uc_greedy":"1f3ca-2640","shortnames":[],"category":"activity"},":woman_tipping_hand:":{"uc_base":"1f481-2640","uc_output":"1f481-200d-2640-fe0f","uc_match":"1f481-2640-fe0f","uc_greedy":"1f481-2640","shortnames":[],"category":"people"},":woman_vampire:":{"uc_base":"1f9db-2640","uc_output":"1f9db-200d-2640-fe0f","uc_match":"1f9db-2640-fe0f","uc_greedy":"1f9db-2640","shortnames":[],"category":"people"},":woman_walking:":{"uc_base":"1f6b6-2640","uc_output":"1f6b6-200d-2640-fe0f","uc_match":"1f6b6-2640-fe0f","uc_greedy":"1f6b6-2640","shortnames":[],"category":"people"},":woman_wearing_turban:":{"uc_base":"1f473-2640","uc_output":"1f473-200d-2640-fe0f","uc_match":"1f473-2640-fe0f","uc_greedy":"1f473-2640","shortnames":[],"category":"people"},":woman_zombie:":{"uc_base":"1f9df-2640","uc_output":"1f9df-200d-2640-fe0f","uc_match":"1f9df-2640-fe0f","uc_greedy":"1f9df-2640","shortnames":[],"category":"people"},":women_with_bunny_ears_partying:":{"uc_base":"1f46f-2640","uc_output":"1f46f-200d-2640-fe0f","uc_match":"1f46f-2640-fe0f","uc_greedy":"1f46f-2640","shortnames":[],"category":"people"},":women_wrestling:":{"uc_base":"1f93c-2640","uc_output":"1f93c-200d-2640-fe0f","uc_match":"1f93c-2640-fe0f","uc_greedy":"1f93c-2640","shortnames":[],"category":"activity"},":family_man_boy:":{"uc_base":"1f468-1f466","uc_output":"1f468-200d-1f466","uc_match":"1f468-1f466","uc_greedy":"1f468-1f466","shortnames":[],"category":"people"},":family_man_girl:":{"uc_base":"1f468-1f467","uc_output":"1f468-200d-1f467","uc_match":"1f468-1f467","uc_greedy":"1f468-1f467","shortnames":[],"category":"people"},":family_woman_boy:":{"uc_base":"1f469-1f466","uc_output":"1f469-200d-1f466","uc_match":"1f469-1f466","uc_greedy":"1f469-1f466","shortnames":[],"category":"people"},":family_woman_girl:":{"uc_base":"1f469-1f467","uc_output":"1f469-200d-1f467","uc_match":"1f469-1f467","uc_greedy":"1f469-1f467","shortnames":[],"category":"people"},":man_artist:":{"uc_base":"1f468-1f3a8","uc_output":"1f468-200d-1f3a8","uc_match":"1f468-1f3a8","uc_greedy":"1f468-1f3a8","shortnames":[],"category":"people"},":man_astronaut:":{"uc_base":"1f468-1f680","uc_output":"1f468-200d-1f680","uc_match":"1f468-1f680","uc_greedy":"1f468-1f680","shortnames":[],"category":"people"},":man_cook:":{"uc_base":"1f468-1f373","uc_output":"1f468-200d-1f373","uc_match":"1f468-1f373","uc_greedy":"1f468-1f373","shortnames":[],"category":"people"},":man_factory_worker:":{"uc_base":"1f468-1f3ed","uc_output":"1f468-200d-1f3ed","uc_match":"1f468-1f3ed","uc_greedy":"1f468-1f3ed","shortnames":[],"category":"people"},":man_farmer:":{"uc_base":"1f468-1f33e","uc_output":"1f468-200d-1f33e","uc_match":"1f468-1f33e","uc_greedy":"1f468-1f33e","shortnames":[],"category":"people"},":man_firefighter:":{"uc_base":"1f468-1f692","uc_output":"1f468-200d-1f692","uc_match":"1f468-1f692","uc_greedy":"1f468-1f692","shortnames":[],"category":"people"},":man_mechanic:":{"uc_base":"1f468-1f527","uc_output":"1f468-200d-1f527","uc_match":"1f468-1f527","uc_greedy":"1f468-1f527","shortnames":[],"category":"people"},":man_office_worker:":{"uc_base":"1f468-1f4bc","uc_output":"1f468-200d-1f4bc","uc_match":"1f468-1f4bc","uc_greedy":"1f468-1f4bc","shortnames":[],"category":"people"},":man_scientist:":{"uc_base":"1f468-1f52c","uc_output":"1f468-200d-1f52c","uc_match":"1f468-1f52c","uc_greedy":"1f468-1f52c","shortnames":[],"category":"people"},":man_singer:":{"uc_base":"1f468-1f3a4","uc_output":"1f468-200d-1f3a4","uc_match":"1f468-1f3a4","uc_greedy":"1f468-1f3a4","shortnames":[],"category":"people"},":man_student:":{"uc_base":"1f468-1f393","uc_output":"1f468-200d-1f393","uc_match":"1f468-1f393","uc_greedy":"1f468-1f393","shortnames":[],"category":"people"},":man_teacher:":{"uc_base":"1f468-1f3eb","uc_output":"1f468-200d-1f3eb","uc_match":"1f468-1f3eb","uc_greedy":"1f468-1f3eb","shortnames":[],"category":"people"},":man_technologist:":{"uc_base":"1f468-1f4bb","uc_output":"1f468-200d-1f4bb","uc_match":"1f468-1f4bb","uc_greedy":"1f468-1f4bb","shortnames":[],"category":"people"},":woman_artist:":{"uc_base":"1f469-1f3a8","uc_output":"1f469-200d-1f3a8","uc_match":"1f469-1f3a8","uc_greedy":"1f469-1f3a8","shortnames":[],"category":"people"},":woman_astronaut:":{"uc_base":"1f469-1f680","uc_output":"1f469-200d-1f680","uc_match":"1f469-1f680","uc_greedy":"1f469-1f680","shortnames":[],"category":"people"},":woman_cook:":{"uc_base":"1f469-1f373","uc_output":"1f469-200d-1f373","uc_match":"1f469-1f373","uc_greedy":"1f469-1f373","shortnames":[],"category":"people"},":woman_factory_worker:":{"uc_base":"1f469-1f3ed","uc_output":"1f469-200d-1f3ed","uc_match":"1f469-1f3ed","uc_greedy":"1f469-1f3ed","shortnames":[],"category":"people"},":woman_farmer:":{"uc_base":"1f469-1f33e","uc_output":"1f469-200d-1f33e","uc_match":"1f469-1f33e","uc_greedy":"1f469-1f33e","shortnames":[],"category":"people"},":woman_firefighter:":{"uc_base":"1f469-1f692","uc_output":"1f469-200d-1f692","uc_match":"1f469-1f692","uc_greedy":"1f469-1f692","shortnames":[],"category":"people"},":woman_mechanic:":{"uc_base":"1f469-1f527","uc_output":"1f469-200d-1f527","uc_match":"1f469-1f527","uc_greedy":"1f469-1f527","shortnames":[],"category":"people"},":woman_office_worker:":{"uc_base":"1f469-1f4bc","uc_output":"1f469-200d-1f4bc","uc_match":"1f469-1f4bc","uc_greedy":"1f469-1f4bc","shortnames":[],"category":"people"},":woman_scientist:":{"uc_base":"1f469-1f52c","uc_output":"1f469-200d-1f52c","uc_match":"1f469-1f52c","uc_greedy":"1f469-1f52c","shortnames":[],"category":"people"},":woman_singer:":{"uc_base":"1f469-1f3a4","uc_output":"1f469-200d-1f3a4","uc_match":"1f469-1f3a4","uc_greedy":"1f469-1f3a4","shortnames":[],"category":"people"},":woman_student:":{"uc_base":"1f469-1f393","uc_output":"1f469-200d-1f393","uc_match":"1f469-1f393","uc_greedy":"1f469-1f393","shortnames":[],"category":"people"},":woman_teacher:":{"uc_base":"1f469-1f3eb","uc_output":"1f469-200d-1f3eb","uc_match":"1f469-1f3eb","uc_greedy":"1f469-1f3eb","shortnames":[],"category":"people"},":woman_technologist:":{"uc_base":"1f469-1f4bb","uc_output":"1f469-200d-1f4bb","uc_match":"1f469-1f4bb","uc_greedy":"1f469-1f4bb","shortnames":[],"category":"people"},":asterisk:":{"uc_base":"002a-20e3","uc_output":"002a-fe0f-20e3","uc_match":"002a-20e3","uc_greedy":"002a-20e3","shortnames":[":keycap_asterisk:"],"category":"symbols"},":eight:":{"uc_base":"0038-20e3","uc_output":"0038-fe0f-20e3","uc_match":"0038-20e3","uc_greedy":"0038-20e3","shortnames":[],"category":"symbols"},":five:":{"uc_base":"0035-20e3","uc_output":"0035-fe0f-20e3","uc_match":"0035-20e3","uc_greedy":"0035-20e3","shortnames":[],"category":"symbols"},":four:":{"uc_base":"0034-20e3","uc_output":"0034-fe0f-20e3","uc_match":"0034-20e3","uc_greedy":"0034-20e3","shortnames":[],"category":"symbols"},":hash:":{"uc_base":"0023-20e3","uc_output":"0023-fe0f-20e3","uc_match":"0023-20e3","uc_greedy":"0023-20e3","shortnames":[],"category":"symbols"},":nine:":{"uc_base":"0039-20e3","uc_output":"0039-fe0f-20e3","uc_match":"0039-20e3","uc_greedy":"0039-20e3","shortnames":[],"category":"symbols"},":one:":{"uc_base":"0031-20e3","uc_output":"0031-fe0f-20e3","uc_match":"0031-20e3","uc_greedy":"0031-20e3","shortnames":[],"category":"symbols"},":seven:":{"uc_base":"0037-20e3","uc_output":"0037-fe0f-20e3","uc_match":"0037-20e3","uc_greedy":"0037-20e3","shortnames":[],"category":"symbols"},":six:":{"uc_base":"0036-20e3","uc_output":"0036-fe0f-20e3","uc_match":"0036-20e3","uc_greedy":"0036-20e3","shortnames":[],"category":"symbols"},":three:":{"uc_base":"0033-20e3","uc_output":"0033-fe0f-20e3","uc_match":"0033-20e3","uc_greedy":"0033-20e3","shortnames":[],"category":"symbols"},":two:":{"uc_base":"0032-20e3","uc_output":"0032-fe0f-20e3","uc_match":"0032-20e3","uc_greedy":"0032-20e3","shortnames":[],"category":"symbols"},":zero:":{"uc_base":"0030-20e3","uc_output":"0030-fe0f-20e3","uc_match":"0030-20e3","uc_greedy":"0030-20e3","shortnames":[],"category":"symbols"},":adult_tone1:":{"uc_base":"1f9d1-1f3fb","uc_output":"1f9d1-1f3fb","uc_match":"1f9d1-1f3fb","uc_greedy":"1f9d1-1f3fb","shortnames":[":adult_light_skin_tone:"],"category":"people"},":adult_tone2:":{"uc_base":"1f9d1-1f3fc","uc_output":"1f9d1-1f3fc","uc_match":"1f9d1-1f3fc","uc_greedy":"1f9d1-1f3fc","shortnames":[":adult_medium_light_skin_tone:"],"category":"people"},":adult_tone3:":{"uc_base":"1f9d1-1f3fd","uc_output":"1f9d1-1f3fd","uc_match":"1f9d1-1f3fd","uc_greedy":"1f9d1-1f3fd","shortnames":[":adult_medium_skin_tone:"],"category":"people"},":adult_tone4:":{"uc_base":"1f9d1-1f3fe","uc_output":"1f9d1-1f3fe","uc_match":"1f9d1-1f3fe","uc_greedy":"1f9d1-1f3fe","shortnames":[":adult_medium_dark_skin_tone:"],"category":"people"},":adult_tone5:":{"uc_base":"1f9d1-1f3ff","uc_output":"1f9d1-1f3ff","uc_match":"1f9d1-1f3ff","uc_greedy":"1f9d1-1f3ff","shortnames":[":adult_dark_skin_tone:"],"category":"people"},":angel_tone1:":{"uc_base":"1f47c-1f3fb","uc_output":"1f47c-1f3fb","uc_match":"1f47c-1f3fb","uc_greedy":"1f47c-1f3fb","shortnames":[],"category":"people"},":angel_tone2:":{"uc_base":"1f47c-1f3fc","uc_output":"1f47c-1f3fc","uc_match":"1f47c-1f3fc","uc_greedy":"1f47c-1f3fc","shortnames":[],"category":"people"},":angel_tone3:":{"uc_base":"1f47c-1f3fd","uc_output":"1f47c-1f3fd","uc_match":"1f47c-1f3fd","uc_greedy":"1f47c-1f3fd","shortnames":[],"category":"people"},":angel_tone4:":{"uc_base":"1f47c-1f3fe","uc_output":"1f47c-1f3fe","uc_match":"1f47c-1f3fe","uc_greedy":"1f47c-1f3fe","shortnames":[],"category":"people"},":angel_tone5:":{"uc_base":"1f47c-1f3ff","uc_output":"1f47c-1f3ff","uc_match":"1f47c-1f3ff","uc_greedy":"1f47c-1f3ff","shortnames":[],"category":"people"},":baby_tone1:":{"uc_base":"1f476-1f3fb","uc_output":"1f476-1f3fb","uc_match":"1f476-1f3fb","uc_greedy":"1f476-1f3fb","shortnames":[],"category":"people"},":baby_tone2:":{"uc_base":"1f476-1f3fc","uc_output":"1f476-1f3fc","uc_match":"1f476-1f3fc","uc_greedy":"1f476-1f3fc","shortnames":[],"category":"people"},":baby_tone3:":{"uc_base":"1f476-1f3fd","uc_output":"1f476-1f3fd","uc_match":"1f476-1f3fd","uc_greedy":"1f476-1f3fd","shortnames":[],"category":"people"},":baby_tone4:":{"uc_base":"1f476-1f3fe","uc_output":"1f476-1f3fe","uc_match":"1f476-1f3fe","uc_greedy":"1f476-1f3fe","shortnames":[],"category":"people"},":baby_tone5:":{"uc_base":"1f476-1f3ff","uc_output":"1f476-1f3ff","uc_match":"1f476-1f3ff","uc_greedy":"1f476-1f3ff","shortnames":[],"category":"people"},":bath_tone1:":{"uc_base":"1f6c0-1f3fb","uc_output":"1f6c0-1f3fb","uc_match":"1f6c0-1f3fb","uc_greedy":"1f6c0-1f3fb","shortnames":[],"category":"objects"},":bath_tone2:":{"uc_base":"1f6c0-1f3fc","uc_output":"1f6c0-1f3fc","uc_match":"1f6c0-1f3fc","uc_greedy":"1f6c0-1f3fc","shortnames":[],"category":"objects"},":bath_tone3:":{"uc_base":"1f6c0-1f3fd","uc_output":"1f6c0-1f3fd","uc_match":"1f6c0-1f3fd","uc_greedy":"1f6c0-1f3fd","shortnames":[],"category":"objects"},":bath_tone4:":{"uc_base":"1f6c0-1f3fe","uc_output":"1f6c0-1f3fe","uc_match":"1f6c0-1f3fe","uc_greedy":"1f6c0-1f3fe","shortnames":[],"category":"objects"},":bath_tone5:":{"uc_base":"1f6c0-1f3ff","uc_output":"1f6c0-1f3ff","uc_match":"1f6c0-1f3ff","uc_greedy":"1f6c0-1f3ff","shortnames":[],"category":"objects"},":bearded_person_tone1:":{"uc_base":"1f9d4-1f3fb","uc_output":"1f9d4-1f3fb","uc_match":"1f9d4-1f3fb","uc_greedy":"1f9d4-1f3fb","shortnames":[":bearded_person_light_skin_tone:"],"category":"people"},":bearded_person_tone2:":{"uc_base":"1f9d4-1f3fc","uc_output":"1f9d4-1f3fc","uc_match":"1f9d4-1f3fc","uc_greedy":"1f9d4-1f3fc","shortnames":[":bearded_person_medium_light_skin_tone:"],"category":"people"},":bearded_person_tone3:":{"uc_base":"1f9d4-1f3fd","uc_output":"1f9d4-1f3fd","uc_match":"1f9d4-1f3fd","uc_greedy":"1f9d4-1f3fd","shortnames":[":bearded_person_medium_skin_tone:"],"category":"people"},":bearded_person_tone4:":{"uc_base":"1f9d4-1f3fe","uc_output":"1f9d4-1f3fe","uc_match":"1f9d4-1f3fe","uc_greedy":"1f9d4-1f3fe","shortnames":[":bearded_person_medium_dark_skin_tone:"],"category":"people"},":bearded_person_tone5:":{"uc_base":"1f9d4-1f3ff","uc_output":"1f9d4-1f3ff","uc_match":"1f9d4-1f3ff","uc_greedy":"1f9d4-1f3ff","shortnames":[":bearded_person_dark_skin_tone:"],"category":"people"},":blond_haired_person_tone1:":{"uc_base":"1f471-1f3fb","uc_output":"1f471-1f3fb","uc_match":"1f471-1f3fb","uc_greedy":"1f471-1f3fb","shortnames":[":person_with_blond_hair_tone1:"],"category":"people"},":blond_haired_person_tone2:":{"uc_base":"1f471-1f3fc","uc_output":"1f471-1f3fc","uc_match":"1f471-1f3fc","uc_greedy":"1f471-1f3fc","shortnames":[":person_with_blond_hair_tone2:"],"category":"people"},":blond_haired_person_tone3:":{"uc_base":"1f471-1f3fd","uc_output":"1f471-1f3fd","uc_match":"1f471-1f3fd","uc_greedy":"1f471-1f3fd","shortnames":[":person_with_blond_hair_tone3:"],"category":"people"},":blond_haired_person_tone4:":{"uc_base":"1f471-1f3fe","uc_output":"1f471-1f3fe","uc_match":"1f471-1f3fe","uc_greedy":"1f471-1f3fe","shortnames":[":person_with_blond_hair_tone4:"],"category":"people"},":blond_haired_person_tone5:":{"uc_base":"1f471-1f3ff","uc_output":"1f471-1f3ff","uc_match":"1f471-1f3ff","uc_greedy":"1f471-1f3ff","shortnames":[":person_with_blond_hair_tone5:"],"category":"people"},":boy_tone1:":{"uc_base":"1f466-1f3fb","uc_output":"1f466-1f3fb","uc_match":"1f466-1f3fb","uc_greedy":"1f466-1f3fb","shortnames":[],"category":"people"},":boy_tone2:":{"uc_base":"1f466-1f3fc","uc_output":"1f466-1f3fc","uc_match":"1f466-1f3fc","uc_greedy":"1f466-1f3fc","shortnames":[],"category":"people"},":boy_tone3:":{"uc_base":"1f466-1f3fd","uc_output":"1f466-1f3fd","uc_match":"1f466-1f3fd","uc_greedy":"1f466-1f3fd","shortnames":[],"category":"people"},":boy_tone4:":{"uc_base":"1f466-1f3fe","uc_output":"1f466-1f3fe","uc_match":"1f466-1f3fe","uc_greedy":"1f466-1f3fe","shortnames":[],"category":"people"},":boy_tone5:":{"uc_base":"1f466-1f3ff","uc_output":"1f466-1f3ff","uc_match":"1f466-1f3ff","uc_greedy":"1f466-1f3ff","shortnames":[],"category":"people"},":breast_feeding_tone1:":{"uc_base":"1f931-1f3fb","uc_output":"1f931-1f3fb","uc_match":"1f931-1f3fb","uc_greedy":"1f931-1f3fb","shortnames":[":breast_feeding_light_skin_tone:"],"category":"people"},":breast_feeding_tone2:":{"uc_base":"1f931-1f3fc","uc_output":"1f931-1f3fc","uc_match":"1f931-1f3fc","uc_greedy":"1f931-1f3fc","shortnames":[":breast_feeding_medium_light_skin_tone:"],"category":"people"},":breast_feeding_tone3:":{"uc_base":"1f931-1f3fd","uc_output":"1f931-1f3fd","uc_match":"1f931-1f3fd","uc_greedy":"1f931-1f3fd","shortnames":[":breast_feeding_medium_skin_tone:"],"category":"people"},":breast_feeding_tone4:":{"uc_base":"1f931-1f3fe","uc_output":"1f931-1f3fe","uc_match":"1f931-1f3fe","uc_greedy":"1f931-1f3fe","shortnames":[":breast_feeding_medium_dark_skin_tone:"],"category":"people"},":breast_feeding_tone5:":{"uc_base":"1f931-1f3ff","uc_output":"1f931-1f3ff","uc_match":"1f931-1f3ff","uc_greedy":"1f931-1f3ff","shortnames":[":breast_feeding_dark_skin_tone:"],"category":"people"},":bride_with_veil_tone1:":{"uc_base":"1f470-1f3fb","uc_output":"1f470-1f3fb","uc_match":"1f470-1f3fb","uc_greedy":"1f470-1f3fb","shortnames":[],"category":"people"},":bride_with_veil_tone2:":{"uc_base":"1f470-1f3fc","uc_output":"1f470-1f3fc","uc_match":"1f470-1f3fc","uc_greedy":"1f470-1f3fc","shortnames":[],"category":"people"},":bride_with_veil_tone3:":{"uc_base":"1f470-1f3fd","uc_output":"1f470-1f3fd","uc_match":"1f470-1f3fd","uc_greedy":"1f470-1f3fd","shortnames":[],"category":"people"},":bride_with_veil_tone4:":{"uc_base":"1f470-1f3fe","uc_output":"1f470-1f3fe","uc_match":"1f470-1f3fe","uc_greedy":"1f470-1f3fe","shortnames":[],"category":"people"},":bride_with_veil_tone5:":{"uc_base":"1f470-1f3ff","uc_output":"1f470-1f3ff","uc_match":"1f470-1f3ff","uc_greedy":"1f470-1f3ff","shortnames":[],"category":"people"},":call_me_tone1:":{"uc_base":"1f919-1f3fb","uc_output":"1f919-1f3fb","uc_match":"1f919-1f3fb","uc_greedy":"1f919-1f3fb","shortnames":[":call_me_hand_tone1:"],"category":"people"},":call_me_tone2:":{"uc_base":"1f919-1f3fc","uc_output":"1f919-1f3fc","uc_match":"1f919-1f3fc","uc_greedy":"1f919-1f3fc","shortnames":[":call_me_hand_tone2:"],"category":"people"},":call_me_tone3:":{"uc_base":"1f919-1f3fd","uc_output":"1f919-1f3fd","uc_match":"1f919-1f3fd","uc_greedy":"1f919-1f3fd","shortnames":[":call_me_hand_tone3:"],"category":"people"},":call_me_tone4:":{"uc_base":"1f919-1f3fe","uc_output":"1f919-1f3fe","uc_match":"1f919-1f3fe","uc_greedy":"1f919-1f3fe","shortnames":[":call_me_hand_tone4:"],"category":"people"},":call_me_tone5:":{"uc_base":"1f919-1f3ff","uc_output":"1f919-1f3ff","uc_match":"1f919-1f3ff","uc_greedy":"1f919-1f3ff","shortnames":[":call_me_hand_tone5:"],"category":"people"},":child_tone1:":{"uc_base":"1f9d2-1f3fb","uc_output":"1f9d2-1f3fb","uc_match":"1f9d2-1f3fb","uc_greedy":"1f9d2-1f3fb","shortnames":[":child_light_skin_tone:"],"category":"people"},":child_tone2:":{"uc_base":"1f9d2-1f3fc","uc_output":"1f9d2-1f3fc","uc_match":"1f9d2-1f3fc","uc_greedy":"1f9d2-1f3fc","shortnames":[":child_medium_light_skin_tone:"],"category":"people"},":child_tone3:":{"uc_base":"1f9d2-1f3fd","uc_output":"1f9d2-1f3fd","uc_match":"1f9d2-1f3fd","uc_greedy":"1f9d2-1f3fd","shortnames":[":child_medium_skin_tone:"],"category":"people"},":child_tone4:":{"uc_base":"1f9d2-1f3fe","uc_output":"1f9d2-1f3fe","uc_match":"1f9d2-1f3fe","uc_greedy":"1f9d2-1f3fe","shortnames":[":child_medium_dark_skin_tone:"],"category":"people"},":child_tone5:":{"uc_base":"1f9d2-1f3ff","uc_output":"1f9d2-1f3ff","uc_match":"1f9d2-1f3ff","uc_greedy":"1f9d2-1f3ff","shortnames":[":child_dark_skin_tone:"],"category":"people"},":clap_tone1:":{"uc_base":"1f44f-1f3fb","uc_output":"1f44f-1f3fb","uc_match":"1f44f-1f3fb","uc_greedy":"1f44f-1f3fb","shortnames":[],"category":"people"},":clap_tone2:":{"uc_base":"1f44f-1f3fc","uc_output":"1f44f-1f3fc","uc_match":"1f44f-1f3fc","uc_greedy":"1f44f-1f3fc","shortnames":[],"category":"people"},":clap_tone3:":{"uc_base":"1f44f-1f3fd","uc_output":"1f44f-1f3fd","uc_match":"1f44f-1f3fd","uc_greedy":"1f44f-1f3fd","shortnames":[],"category":"people"},":clap_tone4:":{"uc_base":"1f44f-1f3fe","uc_output":"1f44f-1f3fe","uc_match":"1f44f-1f3fe","uc_greedy":"1f44f-1f3fe","shortnames":[],"category":"people"},":clap_tone5:":{"uc_base":"1f44f-1f3ff","uc_output":"1f44f-1f3ff","uc_match":"1f44f-1f3ff","uc_greedy":"1f44f-1f3ff","shortnames":[],"category":"people"},":construction_worker_tone1:":{"uc_base":"1f477-1f3fb","uc_output":"1f477-1f3fb","uc_match":"1f477-1f3fb","uc_greedy":"1f477-1f3fb","shortnames":[],"category":"people"},":construction_worker_tone2:":{"uc_base":"1f477-1f3fc","uc_output":"1f477-1f3fc","uc_match":"1f477-1f3fc","uc_greedy":"1f477-1f3fc","shortnames":[],"category":"people"},":construction_worker_tone3:":{"uc_base":"1f477-1f3fd","uc_output":"1f477-1f3fd","uc_match":"1f477-1f3fd","uc_greedy":"1f477-1f3fd","shortnames":[],"category":"people"},":construction_worker_tone4:":{"uc_base":"1f477-1f3fe","uc_output":"1f477-1f3fe","uc_match":"1f477-1f3fe","uc_greedy":"1f477-1f3fe","shortnames":[],"category":"people"},":construction_worker_tone5:":{"uc_base":"1f477-1f3ff","uc_output":"1f477-1f3ff","uc_match":"1f477-1f3ff","uc_greedy":"1f477-1f3ff","shortnames":[],"category":"people"},":dancer_tone1:":{"uc_base":"1f483-1f3fb","uc_output":"1f483-1f3fb","uc_match":"1f483-1f3fb","uc_greedy":"1f483-1f3fb","shortnames":[],"category":"people"},":dancer_tone2:":{"uc_base":"1f483-1f3fc","uc_output":"1f483-1f3fc","uc_match":"1f483-1f3fc","uc_greedy":"1f483-1f3fc","shortnames":[],"category":"people"},":dancer_tone3:":{"uc_base":"1f483-1f3fd","uc_output":"1f483-1f3fd","uc_match":"1f483-1f3fd","uc_greedy":"1f483-1f3fd","shortnames":[],"category":"people"},":dancer_tone4:":{"uc_base":"1f483-1f3fe","uc_output":"1f483-1f3fe","uc_match":"1f483-1f3fe","uc_greedy":"1f483-1f3fe","shortnames":[],"category":"people"},":dancer_tone5:":{"uc_base":"1f483-1f3ff","uc_output":"1f483-1f3ff","uc_match":"1f483-1f3ff","uc_greedy":"1f483-1f3ff","shortnames":[],"category":"people"},":detective_tone1:":{"uc_base":"1f575-1f3fb","uc_output":"1f575-1f3fb","uc_match":"1f575-fe0f-1f3fb","uc_greedy":"1f575-fe0f-1f3fb","shortnames":[":spy_tone1:",":sleuth_or_spy_tone1:"],"category":"people"},":detective_tone2:":{"uc_base":"1f575-1f3fc","uc_output":"1f575-1f3fc","uc_match":"1f575-fe0f-1f3fc","uc_greedy":"1f575-fe0f-1f3fc","shortnames":[":spy_tone2:",":sleuth_or_spy_tone2:"],"category":"people"},":detective_tone3:":{"uc_base":"1f575-1f3fd","uc_output":"1f575-1f3fd","uc_match":"1f575-fe0f-1f3fd","uc_greedy":"1f575-fe0f-1f3fd","shortnames":[":spy_tone3:",":sleuth_or_spy_tone3:"],"category":"people"},":detective_tone4:":{"uc_base":"1f575-1f3fe","uc_output":"1f575-1f3fe","uc_match":"1f575-fe0f-1f3fe","uc_greedy":"1f575-fe0f-1f3fe","shortnames":[":spy_tone4:",":sleuth_or_spy_tone4:"],"category":"people"},":detective_tone5:":{"uc_base":"1f575-1f3ff","uc_output":"1f575-1f3ff","uc_match":"1f575-fe0f-1f3ff","uc_greedy":"1f575-fe0f-1f3ff","shortnames":[":spy_tone5:",":sleuth_or_spy_tone5:"],"category":"people"},":ear_tone1:":{"uc_base":"1f442-1f3fb","uc_output":"1f442-1f3fb","uc_match":"1f442-1f3fb","uc_greedy":"1f442-1f3fb","shortnames":[],"category":"people"},":ear_tone2:":{"uc_base":"1f442-1f3fc","uc_output":"1f442-1f3fc","uc_match":"1f442-1f3fc","uc_greedy":"1f442-1f3fc","shortnames":[],"category":"people"},":ear_tone3:":{"uc_base":"1f442-1f3fd","uc_output":"1f442-1f3fd","uc_match":"1f442-1f3fd","uc_greedy":"1f442-1f3fd","shortnames":[],"category":"people"},":ear_tone4:":{"uc_base":"1f442-1f3fe","uc_output":"1f442-1f3fe","uc_match":"1f442-1f3fe","uc_greedy":"1f442-1f3fe","shortnames":[],"category":"people"},":ear_tone5:":{"uc_base":"1f442-1f3ff","uc_output":"1f442-1f3ff","uc_match":"1f442-1f3ff","uc_greedy":"1f442-1f3ff","shortnames":[],"category":"people"},":elf_tone1:":{"uc_base":"1f9dd-1f3fb","uc_output":"1f9dd-1f3fb","uc_match":"1f9dd-1f3fb","uc_greedy":"1f9dd-1f3fb","shortnames":[":elf_light_skin_tone:"],"category":"people"},":elf_tone2:":{"uc_base":"1f9dd-1f3fc","uc_output":"1f9dd-1f3fc","uc_match":"1f9dd-1f3fc","uc_greedy":"1f9dd-1f3fc","shortnames":[":elf_medium_light_skin_tone:"],"category":"people"},":elf_tone3:":{"uc_base":"1f9dd-1f3fd","uc_output":"1f9dd-1f3fd","uc_match":"1f9dd-1f3fd","uc_greedy":"1f9dd-1f3fd","shortnames":[":elf_medium_skin_tone:"],"category":"people"},":elf_tone4:":{"uc_base":"1f9dd-1f3fe","uc_output":"1f9dd-1f3fe","uc_match":"1f9dd-1f3fe","uc_greedy":"1f9dd-1f3fe","shortnames":[":elf_medium_dark_skin_tone:"],"category":"people"},":elf_tone5:":{"uc_base":"1f9dd-1f3ff","uc_output":"1f9dd-1f3ff","uc_match":"1f9dd-1f3ff","uc_greedy":"1f9dd-1f3ff","shortnames":[":elf_dark_skin_tone:"],"category":"people"},":fairy_tone1:":{"uc_base":"1f9da-1f3fb","uc_output":"1f9da-1f3fb","uc_match":"1f9da-1f3fb","uc_greedy":"1f9da-1f3fb","shortnames":[":fairy_light_skin_tone:"],"category":"people"},":fairy_tone2:":{"uc_base":"1f9da-1f3fc","uc_output":"1f9da-1f3fc","uc_match":"1f9da-1f3fc","uc_greedy":"1f9da-1f3fc","shortnames":[":fairy_medium_light_skin_tone:"],"category":"people"},":fairy_tone3:":{"uc_base":"1f9da-1f3fd","uc_output":"1f9da-1f3fd","uc_match":"1f9da-1f3fd","uc_greedy":"1f9da-1f3fd","shortnames":[":fairy_medium_skin_tone:"],"category":"people"},":fairy_tone4:":{"uc_base":"1f9da-1f3fe","uc_output":"1f9da-1f3fe","uc_match":"1f9da-1f3fe","uc_greedy":"1f9da-1f3fe","shortnames":[":fairy_medium_dark_skin_tone:"],"category":"people"},":fairy_tone5:":{"uc_base":"1f9da-1f3ff","uc_output":"1f9da-1f3ff","uc_match":"1f9da-1f3ff","uc_greedy":"1f9da-1f3ff","shortnames":[":fairy_dark_skin_tone:"],"category":"people"},":fingers_crossed_tone1:":{"uc_base":"1f91e-1f3fb","uc_output":"1f91e-1f3fb","uc_match":"1f91e-1f3fb","uc_greedy":"1f91e-1f3fb","shortnames":[":hand_with_index_and_middle_fingers_crossed_tone1:"],"category":"people"},":fingers_crossed_tone2:":{"uc_base":"1f91e-1f3fc","uc_output":"1f91e-1f3fc","uc_match":"1f91e-1f3fc","uc_greedy":"1f91e-1f3fc","shortnames":[":hand_with_index_and_middle_fingers_crossed_tone2:"],"category":"people"},":fingers_crossed_tone3:":{"uc_base":"1f91e-1f3fd","uc_output":"1f91e-1f3fd","uc_match":"1f91e-1f3fd","uc_greedy":"1f91e-1f3fd","shortnames":[":hand_with_index_and_middle_fingers_crossed_tone3:"],"category":"people"},":fingers_crossed_tone4:":{"uc_base":"1f91e-1f3fe","uc_output":"1f91e-1f3fe","uc_match":"1f91e-1f3fe","uc_greedy":"1f91e-1f3fe","shortnames":[":hand_with_index_and_middle_fingers_crossed_tone4:"],"category":"people"},":fingers_crossed_tone5:":{"uc_base":"1f91e-1f3ff","uc_output":"1f91e-1f3ff","uc_match":"1f91e-1f3ff","uc_greedy":"1f91e-1f3ff","shortnames":[":hand_with_index_and_middle_fingers_crossed_tone5:"],"category":"people"},":flag_ac:":{"uc_base":"1f1e6-1f1e8","uc_output":"1f1e6-1f1e8","uc_match":"1f1e6-1f1e8","uc_greedy":"1f1e6-1f1e8","shortnames":[":ac:"],"category":"flags"},":flag_ad:":{"uc_base":"1f1e6-1f1e9","uc_output":"1f1e6-1f1e9","uc_match":"1f1e6-1f1e9","uc_greedy":"1f1e6-1f1e9","shortnames":[":ad:"],"category":"flags"},":flag_ae:":{"uc_base":"1f1e6-1f1ea","uc_output":"1f1e6-1f1ea","uc_match":"1f1e6-1f1ea","uc_greedy":"1f1e6-1f1ea","shortnames":[":ae:"],"category":"flags"},":flag_af:":{"uc_base":"1f1e6-1f1eb","uc_output":"1f1e6-1f1eb","uc_match":"1f1e6-1f1eb","uc_greedy":"1f1e6-1f1eb","shortnames":[":af:"],"category":"flags"},":flag_ag:":{"uc_base":"1f1e6-1f1ec","uc_output":"1f1e6-1f1ec","uc_match":"1f1e6-1f1ec","uc_greedy":"1f1e6-1f1ec","shortnames":[":ag:"],"category":"flags"},":flag_ai:":{"uc_base":"1f1e6-1f1ee","uc_output":"1f1e6-1f1ee","uc_match":"1f1e6-1f1ee","uc_greedy":"1f1e6-1f1ee","shortnames":[":ai:"],"category":"flags"},":flag_al:":{"uc_base":"1f1e6-1f1f1","uc_output":"1f1e6-1f1f1","uc_match":"1f1e6-1f1f1","uc_greedy":"1f1e6-1f1f1","shortnames":[":al:"],"category":"flags"},":flag_am:":{"uc_base":"1f1e6-1f1f2","uc_output":"1f1e6-1f1f2","uc_match":"1f1e6-1f1f2","uc_greedy":"1f1e6-1f1f2","shortnames":[":am:"],"category":"flags"},":flag_ao:":{"uc_base":"1f1e6-1f1f4","uc_output":"1f1e6-1f1f4","uc_match":"1f1e6-1f1f4","uc_greedy":"1f1e6-1f1f4","shortnames":[":ao:"],"category":"flags"},":flag_aq:":{"uc_base":"1f1e6-1f1f6","uc_output":"1f1e6-1f1f6","uc_match":"1f1e6-1f1f6","uc_greedy":"1f1e6-1f1f6","shortnames":[":aq:"],"category":"flags"},":flag_ar:":{"uc_base":"1f1e6-1f1f7","uc_output":"1f1e6-1f1f7","uc_match":"1f1e6-1f1f7","uc_greedy":"1f1e6-1f1f7","shortnames":[":ar:"],"category":"flags"},":flag_as:":{"uc_base":"1f1e6-1f1f8","uc_output":"1f1e6-1f1f8","uc_match":"1f1e6-1f1f8","uc_greedy":"1f1e6-1f1f8","shortnames":[":as:"],"category":"flags"},":flag_at:":{"uc_base":"1f1e6-1f1f9","uc_output":"1f1e6-1f1f9","uc_match":"1f1e6-1f1f9","uc_greedy":"1f1e6-1f1f9","shortnames":[":at:"],"category":"flags"},":flag_au:":{"uc_base":"1f1e6-1f1fa","uc_output":"1f1e6-1f1fa","uc_match":"1f1e6-1f1fa","uc_greedy":"1f1e6-1f1fa","shortnames":[":au:"],"category":"flags"},":flag_aw:":{"uc_base":"1f1e6-1f1fc","uc_output":"1f1e6-1f1fc","uc_match":"1f1e6-1f1fc","uc_greedy":"1f1e6-1f1fc","shortnames":[":aw:"],"category":"flags"},":flag_ax:":{"uc_base":"1f1e6-1f1fd","uc_output":"1f1e6-1f1fd","uc_match":"1f1e6-1f1fd","uc_greedy":"1f1e6-1f1fd","shortnames":[":ax:"],"category":"flags"},":flag_az:":{"uc_base":"1f1e6-1f1ff","uc_output":"1f1e6-1f1ff","uc_match":"1f1e6-1f1ff","uc_greedy":"1f1e6-1f1ff","shortnames":[":az:"],"category":"flags"},":flag_ba:":{"uc_base":"1f1e7-1f1e6","uc_output":"1f1e7-1f1e6","uc_match":"1f1e7-1f1e6","uc_greedy":"1f1e7-1f1e6","shortnames":[":ba:"],"category":"flags"},":flag_bb:":{"uc_base":"1f1e7-1f1e7","uc_output":"1f1e7-1f1e7","uc_match":"1f1e7-1f1e7","uc_greedy":"1f1e7-1f1e7","shortnames":[":bb:"],"category":"flags"},":flag_bd:":{"uc_base":"1f1e7-1f1e9","uc_output":"1f1e7-1f1e9","uc_match":"1f1e7-1f1e9","uc_greedy":"1f1e7-1f1e9","shortnames":[":bd:"],"category":"flags"},":flag_be:":{"uc_base":"1f1e7-1f1ea","uc_output":"1f1e7-1f1ea","uc_match":"1f1e7-1f1ea","uc_greedy":"1f1e7-1f1ea","shortnames":[":be:"],"category":"flags"},":flag_bf:":{"uc_base":"1f1e7-1f1eb","uc_output":"1f1e7-1f1eb","uc_match":"1f1e7-1f1eb","uc_greedy":"1f1e7-1f1eb","shortnames":[":bf:"],"category":"flags"},":flag_bg:":{"uc_base":"1f1e7-1f1ec","uc_output":"1f1e7-1f1ec","uc_match":"1f1e7-1f1ec","uc_greedy":"1f1e7-1f1ec","shortnames":[":bg:"],"category":"flags"},":flag_bh:":{"uc_base":"1f1e7-1f1ed","uc_output":"1f1e7-1f1ed","uc_match":"1f1e7-1f1ed","uc_greedy":"1f1e7-1f1ed","shortnames":[":bh:"],"category":"flags"},":flag_bi:":{"uc_base":"1f1e7-1f1ee","uc_output":"1f1e7-1f1ee","uc_match":"1f1e7-1f1ee","uc_greedy":"1f1e7-1f1ee","shortnames":[":bi:"],"category":"flags"},":flag_bj:":{"uc_base":"1f1e7-1f1ef","uc_output":"1f1e7-1f1ef","uc_match":"1f1e7-1f1ef","uc_greedy":"1f1e7-1f1ef","shortnames":[":bj:"],"category":"flags"},":flag_bl:":{"uc_base":"1f1e7-1f1f1","uc_output":"1f1e7-1f1f1","uc_match":"1f1e7-1f1f1","uc_greedy":"1f1e7-1f1f1","shortnames":[":bl:"],"category":"flags"},":flag_bm:":{"uc_base":"1f1e7-1f1f2","uc_output":"1f1e7-1f1f2","uc_match":"1f1e7-1f1f2","uc_greedy":"1f1e7-1f1f2","shortnames":[":bm:"],"category":"flags"},":flag_bn:":{"uc_base":"1f1e7-1f1f3","uc_output":"1f1e7-1f1f3","uc_match":"1f1e7-1f1f3","uc_greedy":"1f1e7-1f1f3","shortnames":[":bn:"],"category":"flags"},":flag_bo:":{"uc_base":"1f1e7-1f1f4","uc_output":"1f1e7-1f1f4","uc_match":"1f1e7-1f1f4","uc_greedy":"1f1e7-1f1f4","shortnames":[":bo:"],"category":"flags"},":flag_bq:":{"uc_base":"1f1e7-1f1f6","uc_output":"1f1e7-1f1f6","uc_match":"1f1e7-1f1f6","uc_greedy":"1f1e7-1f1f6","shortnames":[":bq:"],"category":"flags"},":flag_br:":{"uc_base":"1f1e7-1f1f7","uc_output":"1f1e7-1f1f7","uc_match":"1f1e7-1f1f7","uc_greedy":"1f1e7-1f1f7","shortnames":[":br:"],"category":"flags"},":flag_bs:":{"uc_base":"1f1e7-1f1f8","uc_output":"1f1e7-1f1f8","uc_match":"1f1e7-1f1f8","uc_greedy":"1f1e7-1f1f8","shortnames":[":bs:"],"category":"flags"},":flag_bt:":{"uc_base":"1f1e7-1f1f9","uc_output":"1f1e7-1f1f9","uc_match":"1f1e7-1f1f9","uc_greedy":"1f1e7-1f1f9","shortnames":[":bt:"],"category":"flags"},":flag_bv:":{"uc_base":"1f1e7-1f1fb","uc_output":"1f1e7-1f1fb","uc_match":"1f1e7-1f1fb","uc_greedy":"1f1e7-1f1fb","shortnames":[":bv:"],"category":"flags"},":flag_bw:":{"uc_base":"1f1e7-1f1fc","uc_output":"1f1e7-1f1fc","uc_match":"1f1e7-1f1fc","uc_greedy":"1f1e7-1f1fc","shortnames":[":bw:"],"category":"flags"},":flag_by:":{"uc_base":"1f1e7-1f1fe","uc_output":"1f1e7-1f1fe","uc_match":"1f1e7-1f1fe","uc_greedy":"1f1e7-1f1fe","shortnames":[":by:"],"category":"flags"},":flag_bz:":{"uc_base":"1f1e7-1f1ff","uc_output":"1f1e7-1f1ff","uc_match":"1f1e7-1f1ff","uc_greedy":"1f1e7-1f1ff","shortnames":[":bz:"],"category":"flags"},":flag_ca:":{"uc_base":"1f1e8-1f1e6","uc_output":"1f1e8-1f1e6","uc_match":"1f1e8-1f1e6","uc_greedy":"1f1e8-1f1e6","shortnames":[":ca:"],"category":"flags"},":flag_cc:":{"uc_base":"1f1e8-1f1e8","uc_output":"1f1e8-1f1e8","uc_match":"1f1e8-1f1e8","uc_greedy":"1f1e8-1f1e8","shortnames":[":cc:"],"category":"flags"},":flag_cd:":{"uc_base":"1f1e8-1f1e9","uc_output":"1f1e8-1f1e9","uc_match":"1f1e8-1f1e9","uc_greedy":"1f1e8-1f1e9","shortnames":[":congo:"],"category":"flags"},":flag_cf:":{"uc_base":"1f1e8-1f1eb","uc_output":"1f1e8-1f1eb","uc_match":"1f1e8-1f1eb","uc_greedy":"1f1e8-1f1eb","shortnames":[":cf:"],"category":"flags"},":flag_cg:":{"uc_base":"1f1e8-1f1ec","uc_output":"1f1e8-1f1ec","uc_match":"1f1e8-1f1ec","uc_greedy":"1f1e8-1f1ec","shortnames":[":cg:"],"category":"flags"},":flag_ch:":{"uc_base":"1f1e8-1f1ed","uc_output":"1f1e8-1f1ed","uc_match":"1f1e8-1f1ed","uc_greedy":"1f1e8-1f1ed","shortnames":[":ch:"],"category":"flags"},":flag_ci:":{"uc_base":"1f1e8-1f1ee","uc_output":"1f1e8-1f1ee","uc_match":"1f1e8-1f1ee","uc_greedy":"1f1e8-1f1ee","shortnames":[":ci:"],"category":"flags"},":flag_ck:":{"uc_base":"1f1e8-1f1f0","uc_output":"1f1e8-1f1f0","uc_match":"1f1e8-1f1f0","uc_greedy":"1f1e8-1f1f0","shortnames":[":ck:"],"category":"flags"},":flag_cl:":{"uc_base":"1f1e8-1f1f1","uc_output":"1f1e8-1f1f1","uc_match":"1f1e8-1f1f1","uc_greedy":"1f1e8-1f1f1","shortnames":[":chile:"],"category":"flags"},":flag_cm:":{"uc_base":"1f1e8-1f1f2","uc_output":"1f1e8-1f1f2","uc_match":"1f1e8-1f1f2","uc_greedy":"1f1e8-1f1f2","shortnames":[":cm:"],"category":"flags"},":flag_cn:":{"uc_base":"1f1e8-1f1f3","uc_output":"1f1e8-1f1f3","uc_match":"1f1e8-1f1f3","uc_greedy":"1f1e8-1f1f3","shortnames":[":cn:"],"category":"flags"},":flag_co:":{"uc_base":"1f1e8-1f1f4","uc_output":"1f1e8-1f1f4","uc_match":"1f1e8-1f1f4","uc_greedy":"1f1e8-1f1f4","shortnames":[":co:"],"category":"flags"},":flag_cp:":{"uc_base":"1f1e8-1f1f5","uc_output":"1f1e8-1f1f5","uc_match":"1f1e8-1f1f5","uc_greedy":"1f1e8-1f1f5","shortnames":[":cp:"],"category":"flags"},":flag_cr:":{"uc_base":"1f1e8-1f1f7","uc_output":"1f1e8-1f1f7","uc_match":"1f1e8-1f1f7","uc_greedy":"1f1e8-1f1f7","shortnames":[":cr:"],"category":"flags"},":flag_cu:":{"uc_base":"1f1e8-1f1fa","uc_output":"1f1e8-1f1fa","uc_match":"1f1e8-1f1fa","uc_greedy":"1f1e8-1f1fa","shortnames":[":cu:"],"category":"flags"},":flag_cv:":{"uc_base":"1f1e8-1f1fb","uc_output":"1f1e8-1f1fb","uc_match":"1f1e8-1f1fb","uc_greedy":"1f1e8-1f1fb","shortnames":[":cv:"],"category":"flags"},":flag_cw:":{"uc_base":"1f1e8-1f1fc","uc_output":"1f1e8-1f1fc","uc_match":"1f1e8-1f1fc","uc_greedy":"1f1e8-1f1fc","shortnames":[":cw:"],"category":"flags"},":flag_cx:":{"uc_base":"1f1e8-1f1fd","uc_output":"1f1e8-1f1fd","uc_match":"1f1e8-1f1fd","uc_greedy":"1f1e8-1f1fd","shortnames":[":cx:"],"category":"flags"},":flag_cy:":{"uc_base":"1f1e8-1f1fe","uc_output":"1f1e8-1f1fe","uc_match":"1f1e8-1f1fe","uc_greedy":"1f1e8-1f1fe","shortnames":[":cy:"],"category":"flags"},":flag_cz:":{"uc_base":"1f1e8-1f1ff","uc_output":"1f1e8-1f1ff","uc_match":"1f1e8-1f1ff","uc_greedy":"1f1e8-1f1ff","shortnames":[":cz:"],"category":"flags"},":flag_de:":{"uc_base":"1f1e9-1f1ea","uc_output":"1f1e9-1f1ea","uc_match":"1f1e9-1f1ea","uc_greedy":"1f1e9-1f1ea","shortnames":[":de:"],"category":"flags"},":flag_dg:":{"uc_base":"1f1e9-1f1ec","uc_output":"1f1e9-1f1ec","uc_match":"1f1e9-1f1ec","uc_greedy":"1f1e9-1f1ec","shortnames":[":dg:"],"category":"flags"},":flag_dj:":{"uc_base":"1f1e9-1f1ef","uc_output":"1f1e9-1f1ef","uc_match":"1f1e9-1f1ef","uc_greedy":"1f1e9-1f1ef","shortnames":[":dj:"],"category":"flags"},":flag_dk:":{"uc_base":"1f1e9-1f1f0","uc_output":"1f1e9-1f1f0","uc_match":"1f1e9-1f1f0","uc_greedy":"1f1e9-1f1f0","shortnames":[":dk:"],"category":"flags"},":flag_dm:":{"uc_base":"1f1e9-1f1f2","uc_output":"1f1e9-1f1f2","uc_match":"1f1e9-1f1f2","uc_greedy":"1f1e9-1f1f2","shortnames":[":dm:"],"category":"flags"},":flag_do:":{"uc_base":"1f1e9-1f1f4","uc_output":"1f1e9-1f1f4","uc_match":"1f1e9-1f1f4","uc_greedy":"1f1e9-1f1f4","shortnames":[":do:"],"category":"flags"},":flag_dz:":{"uc_base":"1f1e9-1f1ff","uc_output":"1f1e9-1f1ff","uc_match":"1f1e9-1f1ff","uc_greedy":"1f1e9-1f1ff","shortnames":[":dz:"],"category":"flags"},":flag_ea:":{"uc_base":"1f1ea-1f1e6","uc_output":"1f1ea-1f1e6","uc_match":"1f1ea-1f1e6","uc_greedy":"1f1ea-1f1e6","shortnames":[":ea:"],"category":"flags"},":flag_ec:":{"uc_base":"1f1ea-1f1e8","uc_output":"1f1ea-1f1e8","uc_match":"1f1ea-1f1e8","uc_greedy":"1f1ea-1f1e8","shortnames":[":ec:"],"category":"flags"},":flag_ee:":{"uc_base":"1f1ea-1f1ea","uc_output":"1f1ea-1f1ea","uc_match":"1f1ea-1f1ea","uc_greedy":"1f1ea-1f1ea","shortnames":[":ee:"],"category":"flags"},":flag_eg:":{"uc_base":"1f1ea-1f1ec","uc_output":"1f1ea-1f1ec","uc_match":"1f1ea-1f1ec","uc_greedy":"1f1ea-1f1ec","shortnames":[":eg:"],"category":"flags"},":flag_eh:":{"uc_base":"1f1ea-1f1ed","uc_output":"1f1ea-1f1ed","uc_match":"1f1ea-1f1ed","uc_greedy":"1f1ea-1f1ed","shortnames":[":eh:"],"category":"flags"},":flag_er:":{"uc_base":"1f1ea-1f1f7","uc_output":"1f1ea-1f1f7","uc_match":"1f1ea-1f1f7","uc_greedy":"1f1ea-1f1f7","shortnames":[":er:"],"category":"flags"},":flag_es:":{"uc_base":"1f1ea-1f1f8","uc_output":"1f1ea-1f1f8","uc_match":"1f1ea-1f1f8","uc_greedy":"1f1ea-1f1f8","shortnames":[":es:"],"category":"flags"},":flag_et:":{"uc_base":"1f1ea-1f1f9","uc_output":"1f1ea-1f1f9","uc_match":"1f1ea-1f1f9","uc_greedy":"1f1ea-1f1f9","shortnames":[":et:"],"category":"flags"},":flag_eu:":{"uc_base":"1f1ea-1f1fa","uc_output":"1f1ea-1f1fa","uc_match":"1f1ea-1f1fa","uc_greedy":"1f1ea-1f1fa","shortnames":[":eu:"],"category":"flags"},":flag_fi:":{"uc_base":"1f1eb-1f1ee","uc_output":"1f1eb-1f1ee","uc_match":"1f1eb-1f1ee","uc_greedy":"1f1eb-1f1ee","shortnames":[":fi:"],"category":"flags"},":flag_fj:":{"uc_base":"1f1eb-1f1ef","uc_output":"1f1eb-1f1ef","uc_match":"1f1eb-1f1ef","uc_greedy":"1f1eb-1f1ef","shortnames":[":fj:"],"category":"flags"},":flag_fk:":{"uc_base":"1f1eb-1f1f0","uc_output":"1f1eb-1f1f0","uc_match":"1f1eb-1f1f0","uc_greedy":"1f1eb-1f1f0","shortnames":[":fk:"],"category":"flags"},":flag_fm:":{"uc_base":"1f1eb-1f1f2","uc_output":"1f1eb-1f1f2","uc_match":"1f1eb-1f1f2","uc_greedy":"1f1eb-1f1f2","shortnames":[":fm:"],"category":"flags"},":flag_fo:":{"uc_base":"1f1eb-1f1f4","uc_output":"1f1eb-1f1f4","uc_match":"1f1eb-1f1f4","uc_greedy":"1f1eb-1f1f4","shortnames":[":fo:"],"category":"flags"},":flag_fr:":{"uc_base":"1f1eb-1f1f7","uc_output":"1f1eb-1f1f7","uc_match":"1f1eb-1f1f7","uc_greedy":"1f1eb-1f1f7","shortnames":[":fr:"],"category":"flags"},":flag_ga:":{"uc_base":"1f1ec-1f1e6","uc_output":"1f1ec-1f1e6","uc_match":"1f1ec-1f1e6","uc_greedy":"1f1ec-1f1e6","shortnames":[":ga:"],"category":"flags"},":flag_gb:":{"uc_base":"1f1ec-1f1e7","uc_output":"1f1ec-1f1e7","uc_match":"1f1ec-1f1e7","uc_greedy":"1f1ec-1f1e7","shortnames":[":gb:"],"category":"flags"},":flag_gd:":{"uc_base":"1f1ec-1f1e9","uc_output":"1f1ec-1f1e9","uc_match":"1f1ec-1f1e9","uc_greedy":"1f1ec-1f1e9","shortnames":[":gd:"],"category":"flags"},":flag_ge:":{"uc_base":"1f1ec-1f1ea","uc_output":"1f1ec-1f1ea","uc_match":"1f1ec-1f1ea","uc_greedy":"1f1ec-1f1ea","shortnames":[":ge:"],"category":"flags"},":flag_gf:":{"uc_base":"1f1ec-1f1eb","uc_output":"1f1ec-1f1eb","uc_match":"1f1ec-1f1eb","uc_greedy":"1f1ec-1f1eb","shortnames":[":gf:"],"category":"flags"},":flag_gg:":{"uc_base":"1f1ec-1f1ec","uc_output":"1f1ec-1f1ec","uc_match":"1f1ec-1f1ec","uc_greedy":"1f1ec-1f1ec","shortnames":[":gg:"],"category":"flags"},":flag_gh:":{"uc_base":"1f1ec-1f1ed","uc_output":"1f1ec-1f1ed","uc_match":"1f1ec-1f1ed","uc_greedy":"1f1ec-1f1ed","shortnames":[":gh:"],"category":"flags"},":flag_gi:":{"uc_base":"1f1ec-1f1ee","uc_output":"1f1ec-1f1ee","uc_match":"1f1ec-1f1ee","uc_greedy":"1f1ec-1f1ee","shortnames":[":gi:"],"category":"flags"},":flag_gl:":{"uc_base":"1f1ec-1f1f1","uc_output":"1f1ec-1f1f1","uc_match":"1f1ec-1f1f1","uc_greedy":"1f1ec-1f1f1","shortnames":[":gl:"],"category":"flags"},":flag_gm:":{"uc_base":"1f1ec-1f1f2","uc_output":"1f1ec-1f1f2","uc_match":"1f1ec-1f1f2","uc_greedy":"1f1ec-1f1f2","shortnames":[":gm:"],"category":"flags"},":flag_gn:":{"uc_base":"1f1ec-1f1f3","uc_output":"1f1ec-1f1f3","uc_match":"1f1ec-1f1f3","uc_greedy":"1f1ec-1f1f3","shortnames":[":gn:"],"category":"flags"},":flag_gp:":{"uc_base":"1f1ec-1f1f5","uc_output":"1f1ec-1f1f5","uc_match":"1f1ec-1f1f5","uc_greedy":"1f1ec-1f1f5","shortnames":[":gp:"],"category":"flags"},":flag_gq:":{"uc_base":"1f1ec-1f1f6","uc_output":"1f1ec-1f1f6","uc_match":"1f1ec-1f1f6","uc_greedy":"1f1ec-1f1f6","shortnames":[":gq:"],"category":"flags"},":flag_gr:":{"uc_base":"1f1ec-1f1f7","uc_output":"1f1ec-1f1f7","uc_match":"1f1ec-1f1f7","uc_greedy":"1f1ec-1f1f7","shortnames":[":gr:"],"category":"flags"},":flag_gs:":{"uc_base":"1f1ec-1f1f8","uc_output":"1f1ec-1f1f8","uc_match":"1f1ec-1f1f8","uc_greedy":"1f1ec-1f1f8","shortnames":[":gs:"],"category":"flags"},":flag_gt:":{"uc_base":"1f1ec-1f1f9","uc_output":"1f1ec-1f1f9","uc_match":"1f1ec-1f1f9","uc_greedy":"1f1ec-1f1f9","shortnames":[":gt:"],"category":"flags"},":flag_gu:":{"uc_base":"1f1ec-1f1fa","uc_output":"1f1ec-1f1fa","uc_match":"1f1ec-1f1fa","uc_greedy":"1f1ec-1f1fa","shortnames":[":gu:"],"category":"flags"},":flag_gw:":{"uc_base":"1f1ec-1f1fc","uc_output":"1f1ec-1f1fc","uc_match":"1f1ec-1f1fc","uc_greedy":"1f1ec-1f1fc","shortnames":[":gw:"],"category":"flags"},":flag_gy:":{"uc_base":"1f1ec-1f1fe","uc_output":"1f1ec-1f1fe","uc_match":"1f1ec-1f1fe","uc_greedy":"1f1ec-1f1fe","shortnames":[":gy:"],"category":"flags"},":flag_hk:":{"uc_base":"1f1ed-1f1f0","uc_output":"1f1ed-1f1f0","uc_match":"1f1ed-1f1f0","uc_greedy":"1f1ed-1f1f0","shortnames":[":hk:"],"category":"flags"},":flag_hm:":{"uc_base":"1f1ed-1f1f2","uc_output":"1f1ed-1f1f2","uc_match":"1f1ed-1f1f2","uc_greedy":"1f1ed-1f1f2","shortnames":[":hm:"],"category":"flags"},":flag_hn:":{"uc_base":"1f1ed-1f1f3","uc_output":"1f1ed-1f1f3","uc_match":"1f1ed-1f1f3","uc_greedy":"1f1ed-1f1f3","shortnames":[":hn:"],"category":"flags"},":flag_hr:":{"uc_base":"1f1ed-1f1f7","uc_output":"1f1ed-1f1f7","uc_match":"1f1ed-1f1f7","uc_greedy":"1f1ed-1f1f7","shortnames":[":hr:"],"category":"flags"},":flag_ht:":{"uc_base":"1f1ed-1f1f9","uc_output":"1f1ed-1f1f9","uc_match":"1f1ed-1f1f9","uc_greedy":"1f1ed-1f1f9","shortnames":[":ht:"],"category":"flags"},":flag_hu:":{"uc_base":"1f1ed-1f1fa","uc_output":"1f1ed-1f1fa","uc_match":"1f1ed-1f1fa","uc_greedy":"1f1ed-1f1fa","shortnames":[":hu:"],"category":"flags"},":flag_ic:":{"uc_base":"1f1ee-1f1e8","uc_output":"1f1ee-1f1e8","uc_match":"1f1ee-1f1e8","uc_greedy":"1f1ee-1f1e8","shortnames":[":ic:"],"category":"flags"},":flag_id:":{"uc_base":"1f1ee-1f1e9","uc_output":"1f1ee-1f1e9","uc_match":"1f1ee-1f1e9","uc_greedy":"1f1ee-1f1e9","shortnames":[":indonesia:"],"category":"flags"},":flag_ie:":{"uc_base":"1f1ee-1f1ea","uc_output":"1f1ee-1f1ea","uc_match":"1f1ee-1f1ea","uc_greedy":"1f1ee-1f1ea","shortnames":[":ie:"],"category":"flags"},":flag_il:":{"uc_base":"1f1ee-1f1f1","uc_output":"1f1ee-1f1f1","uc_match":"1f1ee-1f1f1","uc_greedy":"1f1ee-1f1f1","shortnames":[":il:"],"category":"flags"},":flag_im:":{"uc_base":"1f1ee-1f1f2","uc_output":"1f1ee-1f1f2","uc_match":"1f1ee-1f1f2","uc_greedy":"1f1ee-1f1f2","shortnames":[":im:"],"category":"flags"},":flag_in:":{"uc_base":"1f1ee-1f1f3","uc_output":"1f1ee-1f1f3","uc_match":"1f1ee-1f1f3","uc_greedy":"1f1ee-1f1f3","shortnames":[":in:"],"category":"flags"},":flag_io:":{"uc_base":"1f1ee-1f1f4","uc_output":"1f1ee-1f1f4","uc_match":"1f1ee-1f1f4","uc_greedy":"1f1ee-1f1f4","shortnames":[":io:"],"category":"flags"},":flag_iq:":{"uc_base":"1f1ee-1f1f6","uc_output":"1f1ee-1f1f6","uc_match":"1f1ee-1f1f6","uc_greedy":"1f1ee-1f1f6","shortnames":[":iq:"],"category":"flags"},":flag_ir:":{"uc_base":"1f1ee-1f1f7","uc_output":"1f1ee-1f1f7","uc_match":"1f1ee-1f1f7","uc_greedy":"1f1ee-1f1f7","shortnames":[":ir:"],"category":"flags"},":flag_is:":{"uc_base":"1f1ee-1f1f8","uc_output":"1f1ee-1f1f8","uc_match":"1f1ee-1f1f8","uc_greedy":"1f1ee-1f1f8","shortnames":[":is:"],"category":"flags"},":flag_it:":{"uc_base":"1f1ee-1f1f9","uc_output":"1f1ee-1f1f9","uc_match":"1f1ee-1f1f9","uc_greedy":"1f1ee-1f1f9","shortnames":[":it:"],"category":"flags"},":flag_je:":{"uc_base":"1f1ef-1f1ea","uc_output":"1f1ef-1f1ea","uc_match":"1f1ef-1f1ea","uc_greedy":"1f1ef-1f1ea","shortnames":[":je:"],"category":"flags"},":flag_jm:":{"uc_base":"1f1ef-1f1f2","uc_output":"1f1ef-1f1f2","uc_match":"1f1ef-1f1f2","uc_greedy":"1f1ef-1f1f2","shortnames":[":jm:"],"category":"flags"},":flag_jo:":{"uc_base":"1f1ef-1f1f4","uc_output":"1f1ef-1f1f4","uc_match":"1f1ef-1f1f4","uc_greedy":"1f1ef-1f1f4","shortnames":[":jo:"],"category":"flags"},":flag_jp:":{"uc_base":"1f1ef-1f1f5","uc_output":"1f1ef-1f1f5","uc_match":"1f1ef-1f1f5","uc_greedy":"1f1ef-1f1f5","shortnames":[":jp:"],"category":"flags"},":flag_ke:":{"uc_base":"1f1f0-1f1ea","uc_output":"1f1f0-1f1ea","uc_match":"1f1f0-1f1ea","uc_greedy":"1f1f0-1f1ea","shortnames":[":ke:"],"category":"flags"},":flag_kg:":{"uc_base":"1f1f0-1f1ec","uc_output":"1f1f0-1f1ec","uc_match":"1f1f0-1f1ec","uc_greedy":"1f1f0-1f1ec","shortnames":[":kg:"],"category":"flags"},":flag_kh:":{"uc_base":"1f1f0-1f1ed","uc_output":"1f1f0-1f1ed","uc_match":"1f1f0-1f1ed","uc_greedy":"1f1f0-1f1ed","shortnames":[":kh:"],"category":"flags"},":flag_ki:":{"uc_base":"1f1f0-1f1ee","uc_output":"1f1f0-1f1ee","uc_match":"1f1f0-1f1ee","uc_greedy":"1f1f0-1f1ee","shortnames":[":ki:"],"category":"flags"},":flag_km:":{"uc_base":"1f1f0-1f1f2","uc_output":"1f1f0-1f1f2","uc_match":"1f1f0-1f1f2","uc_greedy":"1f1f0-1f1f2","shortnames":[":km:"],"category":"flags"},":flag_kn:":{"uc_base":"1f1f0-1f1f3","uc_output":"1f1f0-1f1f3","uc_match":"1f1f0-1f1f3","uc_greedy":"1f1f0-1f1f3","shortnames":[":kn:"],"category":"flags"},":flag_kp:":{"uc_base":"1f1f0-1f1f5","uc_output":"1f1f0-1f1f5","uc_match":"1f1f0-1f1f5","uc_greedy":"1f1f0-1f1f5","shortnames":[":kp:"],"category":"flags"},":flag_kr:":{"uc_base":"1f1f0-1f1f7","uc_output":"1f1f0-1f1f7","uc_match":"1f1f0-1f1f7","uc_greedy":"1f1f0-1f1f7","shortnames":[":kr:"],"category":"flags"},":flag_kw:":{"uc_base":"1f1f0-1f1fc","uc_output":"1f1f0-1f1fc","uc_match":"1f1f0-1f1fc","uc_greedy":"1f1f0-1f1fc","shortnames":[":kw:"],"category":"flags"},":flag_ky:":{"uc_base":"1f1f0-1f1fe","uc_output":"1f1f0-1f1fe","uc_match":"1f1f0-1f1fe","uc_greedy":"1f1f0-1f1fe","shortnames":[":ky:"],"category":"flags"},":flag_kz:":{"uc_base":"1f1f0-1f1ff","uc_output":"1f1f0-1f1ff","uc_match":"1f1f0-1f1ff","uc_greedy":"1f1f0-1f1ff","shortnames":[":kz:"],"category":"flags"},":flag_la:":{"uc_base":"1f1f1-1f1e6","uc_output":"1f1f1-1f1e6","uc_match":"1f1f1-1f1e6","uc_greedy":"1f1f1-1f1e6","shortnames":[":la:"],"category":"flags"},":flag_lb:":{"uc_base":"1f1f1-1f1e7","uc_output":"1f1f1-1f1e7","uc_match":"1f1f1-1f1e7","uc_greedy":"1f1f1-1f1e7","shortnames":[":lb:"],"category":"flags"},":flag_lc:":{"uc_base":"1f1f1-1f1e8","uc_output":"1f1f1-1f1e8","uc_match":"1f1f1-1f1e8","uc_greedy":"1f1f1-1f1e8","shortnames":[":lc:"],"category":"flags"},":flag_li:":{"uc_base":"1f1f1-1f1ee","uc_output":"1f1f1-1f1ee","uc_match":"1f1f1-1f1ee","uc_greedy":"1f1f1-1f1ee","shortnames":[":li:"],"category":"flags"},":flag_lk:":{"uc_base":"1f1f1-1f1f0","uc_output":"1f1f1-1f1f0","uc_match":"1f1f1-1f1f0","uc_greedy":"1f1f1-1f1f0","shortnames":[":lk:"],"category":"flags"},":flag_lr:":{"uc_base":"1f1f1-1f1f7","uc_output":"1f1f1-1f1f7","uc_match":"1f1f1-1f1f7","uc_greedy":"1f1f1-1f1f7","shortnames":[":lr:"],"category":"flags"},":flag_ls:":{"uc_base":"1f1f1-1f1f8","uc_output":"1f1f1-1f1f8","uc_match":"1f1f1-1f1f8","uc_greedy":"1f1f1-1f1f8","shortnames":[":ls:"],"category":"flags"},":flag_lt:":{"uc_base":"1f1f1-1f1f9","uc_output":"1f1f1-1f1f9","uc_match":"1f1f1-1f1f9","uc_greedy":"1f1f1-1f1f9","shortnames":[":lt:"],"category":"flags"},":flag_lu:":{"uc_base":"1f1f1-1f1fa","uc_output":"1f1f1-1f1fa","uc_match":"1f1f1-1f1fa","uc_greedy":"1f1f1-1f1fa","shortnames":[":lu:"],"category":"flags"},":flag_lv:":{"uc_base":"1f1f1-1f1fb","uc_output":"1f1f1-1f1fb","uc_match":"1f1f1-1f1fb","uc_greedy":"1f1f1-1f1fb","shortnames":[":lv:"],"category":"flags"},":flag_ly:":{"uc_base":"1f1f1-1f1fe","uc_output":"1f1f1-1f1fe","uc_match":"1f1f1-1f1fe","uc_greedy":"1f1f1-1f1fe","shortnames":[":ly:"],"category":"flags"},":flag_ma:":{"uc_base":"1f1f2-1f1e6","uc_output":"1f1f2-1f1e6","uc_match":"1f1f2-1f1e6","uc_greedy":"1f1f2-1f1e6","shortnames":[":ma:"],"category":"flags"},":flag_mc:":{"uc_base":"1f1f2-1f1e8","uc_output":"1f1f2-1f1e8","uc_match":"1f1f2-1f1e8","uc_greedy":"1f1f2-1f1e8","shortnames":[":mc:"],"category":"flags"},":flag_md:":{"uc_base":"1f1f2-1f1e9","uc_output":"1f1f2-1f1e9","uc_match":"1f1f2-1f1e9","uc_greedy":"1f1f2-1f1e9","shortnames":[":md:"],"category":"flags"},":flag_me:":{"uc_base":"1f1f2-1f1ea","uc_output":"1f1f2-1f1ea","uc_match":"1f1f2-1f1ea","uc_greedy":"1f1f2-1f1ea","shortnames":[":me:"],"category":"flags"},":flag_mf:":{"uc_base":"1f1f2-1f1eb","uc_output":"1f1f2-1f1eb","uc_match":"1f1f2-1f1eb","uc_greedy":"1f1f2-1f1eb","shortnames":[":mf:"],"category":"flags"},":flag_mg:":{"uc_base":"1f1f2-1f1ec","uc_output":"1f1f2-1f1ec","uc_match":"1f1f2-1f1ec","uc_greedy":"1f1f2-1f1ec","shortnames":[":mg:"],"category":"flags"},":flag_mh:":{"uc_base":"1f1f2-1f1ed","uc_output":"1f1f2-1f1ed","uc_match":"1f1f2-1f1ed","uc_greedy":"1f1f2-1f1ed","shortnames":[":mh:"],"category":"flags"},":flag_mk:":{"uc_base":"1f1f2-1f1f0","uc_output":"1f1f2-1f1f0","uc_match":"1f1f2-1f1f0","uc_greedy":"1f1f2-1f1f0","shortnames":[":mk:"],"category":"flags"},":flag_ml:":{"uc_base":"1f1f2-1f1f1","uc_output":"1f1f2-1f1f1","uc_match":"1f1f2-1f1f1","uc_greedy":"1f1f2-1f1f1","shortnames":[":ml:"],"category":"flags"},":flag_mm:":{"uc_base":"1f1f2-1f1f2","uc_output":"1f1f2-1f1f2","uc_match":"1f1f2-1f1f2","uc_greedy":"1f1f2-1f1f2","shortnames":[":mm:"],"category":"flags"},":flag_mn:":{"uc_base":"1f1f2-1f1f3","uc_output":"1f1f2-1f1f3","uc_match":"1f1f2-1f1f3","uc_greedy":"1f1f2-1f1f3","shortnames":[":mn:"],"category":"flags"},":flag_mo:":{"uc_base":"1f1f2-1f1f4","uc_output":"1f1f2-1f1f4","uc_match":"1f1f2-1f1f4","uc_greedy":"1f1f2-1f1f4","shortnames":[":mo:"],"category":"flags"},":flag_mp:":{"uc_base":"1f1f2-1f1f5","uc_output":"1f1f2-1f1f5","uc_match":"1f1f2-1f1f5","uc_greedy":"1f1f2-1f1f5","shortnames":[":mp:"],"category":"flags"},":flag_mq:":{"uc_base":"1f1f2-1f1f6","uc_output":"1f1f2-1f1f6","uc_match":"1f1f2-1f1f6","uc_greedy":"1f1f2-1f1f6","shortnames":[":mq:"],"category":"flags"},":flag_mr:":{"uc_base":"1f1f2-1f1f7","uc_output":"1f1f2-1f1f7","uc_match":"1f1f2-1f1f7","uc_greedy":"1f1f2-1f1f7","shortnames":[":mr:"],"category":"flags"},":flag_ms:":{"uc_base":"1f1f2-1f1f8","uc_output":"1f1f2-1f1f8","uc_match":"1f1f2-1f1f8","uc_greedy":"1f1f2-1f1f8","shortnames":[":ms:"],"category":"flags"},":flag_mt:":{"uc_base":"1f1f2-1f1f9","uc_output":"1f1f2-1f1f9","uc_match":"1f1f2-1f1f9","uc_greedy":"1f1f2-1f1f9","shortnames":[":mt:"],"category":"flags"},":flag_mu:":{"uc_base":"1f1f2-1f1fa","uc_output":"1f1f2-1f1fa","uc_match":"1f1f2-1f1fa","uc_greedy":"1f1f2-1f1fa","shortnames":[":mu:"],"category":"flags"},":flag_mv:":{"uc_base":"1f1f2-1f1fb","uc_output":"1f1f2-1f1fb","uc_match":"1f1f2-1f1fb","uc_greedy":"1f1f2-1f1fb","shortnames":[":mv:"],"category":"flags"},":flag_mw:":{"uc_base":"1f1f2-1f1fc","uc_output":"1f1f2-1f1fc","uc_match":"1f1f2-1f1fc","uc_greedy":"1f1f2-1f1fc","shortnames":[":mw:"],"category":"flags"},":flag_mx:":{"uc_base":"1f1f2-1f1fd","uc_output":"1f1f2-1f1fd","uc_match":"1f1f2-1f1fd","uc_greedy":"1f1f2-1f1fd","shortnames":[":mx:"],"category":"flags"},":flag_my:":{"uc_base":"1f1f2-1f1fe","uc_output":"1f1f2-1f1fe","uc_match":"1f1f2-1f1fe","uc_greedy":"1f1f2-1f1fe","shortnames":[":my:"],"category":"flags"},":flag_mz:":{"uc_base":"1f1f2-1f1ff","uc_output":"1f1f2-1f1ff","uc_match":"1f1f2-1f1ff","uc_greedy":"1f1f2-1f1ff","shortnames":[":mz:"],"category":"flags"},":flag_na:":{"uc_base":"1f1f3-1f1e6","uc_output":"1f1f3-1f1e6","uc_match":"1f1f3-1f1e6","uc_greedy":"1f1f3-1f1e6","shortnames":[":na:"],"category":"flags"},":flag_nc:":{"uc_base":"1f1f3-1f1e8","uc_output":"1f1f3-1f1e8","uc_match":"1f1f3-1f1e8","uc_greedy":"1f1f3-1f1e8","shortnames":[":nc:"],"category":"flags"},":flag_ne:":{"uc_base":"1f1f3-1f1ea","uc_output":"1f1f3-1f1ea","uc_match":"1f1f3-1f1ea","uc_greedy":"1f1f3-1f1ea","shortnames":[":ne:"],"category":"flags"},":flag_nf:":{"uc_base":"1f1f3-1f1eb","uc_output":"1f1f3-1f1eb","uc_match":"1f1f3-1f1eb","uc_greedy":"1f1f3-1f1eb","shortnames":[":nf:"],"category":"flags"},":flag_ng:":{"uc_base":"1f1f3-1f1ec","uc_output":"1f1f3-1f1ec","uc_match":"1f1f3-1f1ec","uc_greedy":"1f1f3-1f1ec","shortnames":[":nigeria:"],"category":"flags"},":flag_ni:":{"uc_base":"1f1f3-1f1ee","uc_output":"1f1f3-1f1ee","uc_match":"1f1f3-1f1ee","uc_greedy":"1f1f3-1f1ee","shortnames":[":ni:"],"category":"flags"},":flag_nl:":{"uc_base":"1f1f3-1f1f1","uc_output":"1f1f3-1f1f1","uc_match":"1f1f3-1f1f1","uc_greedy":"1f1f3-1f1f1","shortnames":[":nl:"],"category":"flags"},":flag_no:":{"uc_base":"1f1f3-1f1f4","uc_output":"1f1f3-1f1f4","uc_match":"1f1f3-1f1f4","uc_greedy":"1f1f3-1f1f4","shortnames":[":no:"],"category":"flags"},":flag_np:":{"uc_base":"1f1f3-1f1f5","uc_output":"1f1f3-1f1f5","uc_match":"1f1f3-1f1f5","uc_greedy":"1f1f3-1f1f5","shortnames":[":np:"],"category":"flags"},":flag_nr:":{"uc_base":"1f1f3-1f1f7","uc_output":"1f1f3-1f1f7","uc_match":"1f1f3-1f1f7","uc_greedy":"1f1f3-1f1f7","shortnames":[":nr:"],"category":"flags"},":flag_nu:":{"uc_base":"1f1f3-1f1fa","uc_output":"1f1f3-1f1fa","uc_match":"1f1f3-1f1fa","uc_greedy":"1f1f3-1f1fa","shortnames":[":nu:"],"category":"flags"},":flag_nz:":{"uc_base":"1f1f3-1f1ff","uc_output":"1f1f3-1f1ff","uc_match":"1f1f3-1f1ff","uc_greedy":"1f1f3-1f1ff","shortnames":[":nz:"],"category":"flags"},":flag_om:":{"uc_base":"1f1f4-1f1f2","uc_output":"1f1f4-1f1f2","uc_match":"1f1f4-1f1f2","uc_greedy":"1f1f4-1f1f2","shortnames":[":om:"],"category":"flags"},":flag_pa:":{"uc_base":"1f1f5-1f1e6","uc_output":"1f1f5-1f1e6","uc_match":"1f1f5-1f1e6","uc_greedy":"1f1f5-1f1e6","shortnames":[":pa:"],"category":"flags"},":flag_pe:":{"uc_base":"1f1f5-1f1ea","uc_output":"1f1f5-1f1ea","uc_match":"1f1f5-1f1ea","uc_greedy":"1f1f5-1f1ea","shortnames":[":pe:"],"category":"flags"},":flag_pf:":{"uc_base":"1f1f5-1f1eb","uc_output":"1f1f5-1f1eb","uc_match":"1f1f5-1f1eb","uc_greedy":"1f1f5-1f1eb","shortnames":[":pf:"],"category":"flags"},":flag_pg:":{"uc_base":"1f1f5-1f1ec","uc_output":"1f1f5-1f1ec","uc_match":"1f1f5-1f1ec","uc_greedy":"1f1f5-1f1ec","shortnames":[":pg:"],"category":"flags"},":flag_ph:":{"uc_base":"1f1f5-1f1ed","uc_output":"1f1f5-1f1ed","uc_match":"1f1f5-1f1ed","uc_greedy":"1f1f5-1f1ed","shortnames":[":ph:"],"category":"flags"},":flag_pk:":{"uc_base":"1f1f5-1f1f0","uc_output":"1f1f5-1f1f0","uc_match":"1f1f5-1f1f0","uc_greedy":"1f1f5-1f1f0","shortnames":[":pk:"],"category":"flags"},":flag_pl:":{"uc_base":"1f1f5-1f1f1","uc_output":"1f1f5-1f1f1","uc_match":"1f1f5-1f1f1","uc_greedy":"1f1f5-1f1f1","shortnames":[":pl:"],"category":"flags"},":flag_pm:":{"uc_base":"1f1f5-1f1f2","uc_output":"1f1f5-1f1f2","uc_match":"1f1f5-1f1f2","uc_greedy":"1f1f5-1f1f2","shortnames":[":pm:"],"category":"flags"},":flag_pn:":{"uc_base":"1f1f5-1f1f3","uc_output":"1f1f5-1f1f3","uc_match":"1f1f5-1f1f3","uc_greedy":"1f1f5-1f1f3","shortnames":[":pn:"],"category":"flags"},":flag_pr:":{"uc_base":"1f1f5-1f1f7","uc_output":"1f1f5-1f1f7","uc_match":"1f1f5-1f1f7","uc_greedy":"1f1f5-1f1f7","shortnames":[":pr:"],"category":"flags"},":flag_ps:":{"uc_base":"1f1f5-1f1f8","uc_output":"1f1f5-1f1f8","uc_match":"1f1f5-1f1f8","uc_greedy":"1f1f5-1f1f8","shortnames":[":ps:"],"category":"flags"},":flag_pt:":{"uc_base":"1f1f5-1f1f9","uc_output":"1f1f5-1f1f9","uc_match":"1f1f5-1f1f9","uc_greedy":"1f1f5-1f1f9","shortnames":[":pt:"],"category":"flags"},":flag_pw:":{"uc_base":"1f1f5-1f1fc","uc_output":"1f1f5-1f1fc","uc_match":"1f1f5-1f1fc","uc_greedy":"1f1f5-1f1fc","shortnames":[":pw:"],"category":"flags"},":flag_py:":{"uc_base":"1f1f5-1f1fe","uc_output":"1f1f5-1f1fe","uc_match":"1f1f5-1f1fe","uc_greedy":"1f1f5-1f1fe","shortnames":[":py:"],"category":"flags"},":flag_qa:":{"uc_base":"1f1f6-1f1e6","uc_output":"1f1f6-1f1e6","uc_match":"1f1f6-1f1e6","uc_greedy":"1f1f6-1f1e6","shortnames":[":qa:"],"category":"flags"},":flag_re:":{"uc_base":"1f1f7-1f1ea","uc_output":"1f1f7-1f1ea","uc_match":"1f1f7-1f1ea","uc_greedy":"1f1f7-1f1ea","shortnames":[":re:"],"category":"flags"},":flag_ro:":{"uc_base":"1f1f7-1f1f4","uc_output":"1f1f7-1f1f4","uc_match":"1f1f7-1f1f4","uc_greedy":"1f1f7-1f1f4","shortnames":[":ro:"],"category":"flags"},":flag_rs:":{"uc_base":"1f1f7-1f1f8","uc_output":"1f1f7-1f1f8","uc_match":"1f1f7-1f1f8","uc_greedy":"1f1f7-1f1f8","shortnames":[":rs:"],"category":"flags"},":flag_ru:":{"uc_base":"1f1f7-1f1fa","uc_output":"1f1f7-1f1fa","uc_match":"1f1f7-1f1fa","uc_greedy":"1f1f7-1f1fa","shortnames":[":ru:"],"category":"flags"},":flag_rw:":{"uc_base":"1f1f7-1f1fc","uc_output":"1f1f7-1f1fc","uc_match":"1f1f7-1f1fc","uc_greedy":"1f1f7-1f1fc","shortnames":[":rw:"],"category":"flags"},":flag_sa:":{"uc_base":"1f1f8-1f1e6","uc_output":"1f1f8-1f1e6","uc_match":"1f1f8-1f1e6","uc_greedy":"1f1f8-1f1e6","shortnames":[":saudiarabia:",":saudi:"],"category":"flags"},":flag_sb:":{"uc_base":"1f1f8-1f1e7","uc_output":"1f1f8-1f1e7","uc_match":"1f1f8-1f1e7","uc_greedy":"1f1f8-1f1e7","shortnames":[":sb:"],"category":"flags"},":flag_sc:":{"uc_base":"1f1f8-1f1e8","uc_output":"1f1f8-1f1e8","uc_match":"1f1f8-1f1e8","uc_greedy":"1f1f8-1f1e8","shortnames":[":sc:"],"category":"flags"},":flag_sd:":{"uc_base":"1f1f8-1f1e9","uc_output":"1f1f8-1f1e9","uc_match":"1f1f8-1f1e9","uc_greedy":"1f1f8-1f1e9","shortnames":[":sd:"],"category":"flags"},":flag_se:":{"uc_base":"1f1f8-1f1ea","uc_output":"1f1f8-1f1ea","uc_match":"1f1f8-1f1ea","uc_greedy":"1f1f8-1f1ea","shortnames":[":se:"],"category":"flags"},":flag_sg:":{"uc_base":"1f1f8-1f1ec","uc_output":"1f1f8-1f1ec","uc_match":"1f1f8-1f1ec","uc_greedy":"1f1f8-1f1ec","shortnames":[":sg:"],"category":"flags"},":flag_sh:":{"uc_base":"1f1f8-1f1ed","uc_output":"1f1f8-1f1ed","uc_match":"1f1f8-1f1ed","uc_greedy":"1f1f8-1f1ed","shortnames":[":sh:"],"category":"flags"},":flag_si:":{"uc_base":"1f1f8-1f1ee","uc_output":"1f1f8-1f1ee","uc_match":"1f1f8-1f1ee","uc_greedy":"1f1f8-1f1ee","shortnames":[":si:"],"category":"flags"},":flag_sj:":{"uc_base":"1f1f8-1f1ef","uc_output":"1f1f8-1f1ef","uc_match":"1f1f8-1f1ef","uc_greedy":"1f1f8-1f1ef","shortnames":[":sj:"],"category":"flags"},":flag_sk:":{"uc_base":"1f1f8-1f1f0","uc_output":"1f1f8-1f1f0","uc_match":"1f1f8-1f1f0","uc_greedy":"1f1f8-1f1f0","shortnames":[":sk:"],"category":"flags"},":flag_sl:":{"uc_base":"1f1f8-1f1f1","uc_output":"1f1f8-1f1f1","uc_match":"1f1f8-1f1f1","uc_greedy":"1f1f8-1f1f1","shortnames":[":sl:"],"category":"flags"},":flag_sm:":{"uc_base":"1f1f8-1f1f2","uc_output":"1f1f8-1f1f2","uc_match":"1f1f8-1f1f2","uc_greedy":"1f1f8-1f1f2","shortnames":[":sm:"],"category":"flags"},":flag_sn:":{"uc_base":"1f1f8-1f1f3","uc_output":"1f1f8-1f1f3","uc_match":"1f1f8-1f1f3","uc_greedy":"1f1f8-1f1f3","shortnames":[":sn:"],"category":"flags"},":flag_so:":{"uc_base":"1f1f8-1f1f4","uc_output":"1f1f8-1f1f4","uc_match":"1f1f8-1f1f4","uc_greedy":"1f1f8-1f1f4","shortnames":[":so:"],"category":"flags"},":flag_sr:":{"uc_base":"1f1f8-1f1f7","uc_output":"1f1f8-1f1f7","uc_match":"1f1f8-1f1f7","uc_greedy":"1f1f8-1f1f7","shortnames":[":sr:"],"category":"flags"},":flag_ss:":{"uc_base":"1f1f8-1f1f8","uc_output":"1f1f8-1f1f8","uc_match":"1f1f8-1f1f8","uc_greedy":"1f1f8-1f1f8","shortnames":[":ss:"],"category":"flags"},":flag_st:":{"uc_base":"1f1f8-1f1f9","uc_output":"1f1f8-1f1f9","uc_match":"1f1f8-1f1f9","uc_greedy":"1f1f8-1f1f9","shortnames":[":st:"],"category":"flags"},":flag_sv:":{"uc_base":"1f1f8-1f1fb","uc_output":"1f1f8-1f1fb","uc_match":"1f1f8-1f1fb","uc_greedy":"1f1f8-1f1fb","shortnames":[":sv:"],"category":"flags"},":flag_sx:":{"uc_base":"1f1f8-1f1fd","uc_output":"1f1f8-1f1fd","uc_match":"1f1f8-1f1fd","uc_greedy":"1f1f8-1f1fd","shortnames":[":sx:"],"category":"flags"},":flag_sy:":{"uc_base":"1f1f8-1f1fe","uc_output":"1f1f8-1f1fe","uc_match":"1f1f8-1f1fe","uc_greedy":"1f1f8-1f1fe","shortnames":[":sy:"],"category":"flags"},":flag_sz:":{"uc_base":"1f1f8-1f1ff","uc_output":"1f1f8-1f1ff","uc_match":"1f1f8-1f1ff","uc_greedy":"1f1f8-1f1ff","shortnames":[":sz:"],"category":"flags"},":flag_ta:":{"uc_base":"1f1f9-1f1e6","uc_output":"1f1f9-1f1e6","uc_match":"1f1f9-1f1e6","uc_greedy":"1f1f9-1f1e6","shortnames":[":ta:"],"category":"flags"},":flag_tc:":{"uc_base":"1f1f9-1f1e8","uc_output":"1f1f9-1f1e8","uc_match":"1f1f9-1f1e8","uc_greedy":"1f1f9-1f1e8","shortnames":[":tc:"],"category":"flags"},":flag_td:":{"uc_base":"1f1f9-1f1e9","uc_output":"1f1f9-1f1e9","uc_match":"1f1f9-1f1e9","uc_greedy":"1f1f9-1f1e9","shortnames":[":td:"],"category":"flags"},":flag_tf:":{"uc_base":"1f1f9-1f1eb","uc_output":"1f1f9-1f1eb","uc_match":"1f1f9-1f1eb","uc_greedy":"1f1f9-1f1eb","shortnames":[":tf:"],"category":"flags"},":flag_tg:":{"uc_base":"1f1f9-1f1ec","uc_output":"1f1f9-1f1ec","uc_match":"1f1f9-1f1ec","uc_greedy":"1f1f9-1f1ec","shortnames":[":tg:"],"category":"flags"},":flag_th:":{"uc_base":"1f1f9-1f1ed","uc_output":"1f1f9-1f1ed","uc_match":"1f1f9-1f1ed","uc_greedy":"1f1f9-1f1ed","shortnames":[":th:"],"category":"flags"},":flag_tj:":{"uc_base":"1f1f9-1f1ef","uc_output":"1f1f9-1f1ef","uc_match":"1f1f9-1f1ef","uc_greedy":"1f1f9-1f1ef","shortnames":[":tj:"],"category":"flags"},":flag_tk:":{"uc_base":"1f1f9-1f1f0","uc_output":"1f1f9-1f1f0","uc_match":"1f1f9-1f1f0","uc_greedy":"1f1f9-1f1f0","shortnames":[":tk:"],"category":"flags"},":flag_tl:":{"uc_base":"1f1f9-1f1f1","uc_output":"1f1f9-1f1f1","uc_match":"1f1f9-1f1f1","uc_greedy":"1f1f9-1f1f1","shortnames":[":tl:"],"category":"flags"},":flag_tm:":{"uc_base":"1f1f9-1f1f2","uc_output":"1f1f9-1f1f2","uc_match":"1f1f9-1f1f2","uc_greedy":"1f1f9-1f1f2","shortnames":[":turkmenistan:"],"category":"flags"},":flag_tn:":{"uc_base":"1f1f9-1f1f3","uc_output":"1f1f9-1f1f3","uc_match":"1f1f9-1f1f3","uc_greedy":"1f1f9-1f1f3","shortnames":[":tn:"],"category":"flags"},":flag_to:":{"uc_base":"1f1f9-1f1f4","uc_output":"1f1f9-1f1f4","uc_match":"1f1f9-1f1f4","uc_greedy":"1f1f9-1f1f4","shortnames":[":to:"],"category":"flags"},":flag_tr:":{"uc_base":"1f1f9-1f1f7","uc_output":"1f1f9-1f1f7","uc_match":"1f1f9-1f1f7","uc_greedy":"1f1f9-1f1f7","shortnames":[":tr:"],"category":"flags"},":flag_tt:":{"uc_base":"1f1f9-1f1f9","uc_output":"1f1f9-1f1f9","uc_match":"1f1f9-1f1f9","uc_greedy":"1f1f9-1f1f9","shortnames":[":tt:"],"category":"flags"},":flag_tv:":{"uc_base":"1f1f9-1f1fb","uc_output":"1f1f9-1f1fb","uc_match":"1f1f9-1f1fb","uc_greedy":"1f1f9-1f1fb","shortnames":[":tuvalu:"],"category":"flags"},":flag_tw:":{"uc_base":"1f1f9-1f1fc","uc_output":"1f1f9-1f1fc","uc_match":"1f1f9-1f1fc","uc_greedy":"1f1f9-1f1fc","shortnames":[":tw:"],"category":"flags"},":flag_tz:":{"uc_base":"1f1f9-1f1ff","uc_output":"1f1f9-1f1ff","uc_match":"1f1f9-1f1ff","uc_greedy":"1f1f9-1f1ff","shortnames":[":tz:"],"category":"flags"},":flag_ua:":{"uc_base":"1f1fa-1f1e6","uc_output":"1f1fa-1f1e6","uc_match":"1f1fa-1f1e6","uc_greedy":"1f1fa-1f1e6","shortnames":[":ua:"],"category":"flags"},":flag_ug:":{"uc_base":"1f1fa-1f1ec","uc_output":"1f1fa-1f1ec","uc_match":"1f1fa-1f1ec","uc_greedy":"1f1fa-1f1ec","shortnames":[":ug:"],"category":"flags"},":flag_um:":{"uc_base":"1f1fa-1f1f2","uc_output":"1f1fa-1f1f2","uc_match":"1f1fa-1f1f2","uc_greedy":"1f1fa-1f1f2","shortnames":[":um:"],"category":"flags"},":flag_us:":{"uc_base":"1f1fa-1f1f8","uc_output":"1f1fa-1f1f8","uc_match":"1f1fa-1f1f8","uc_greedy":"1f1fa-1f1f8","shortnames":[":us:"],"category":"flags"},":flag_uy:":{"uc_base":"1f1fa-1f1fe","uc_output":"1f1fa-1f1fe","uc_match":"1f1fa-1f1fe","uc_greedy":"1f1fa-1f1fe","shortnames":[":uy:"],"category":"flags"},":flag_uz:":{"uc_base":"1f1fa-1f1ff","uc_output":"1f1fa-1f1ff","uc_match":"1f1fa-1f1ff","uc_greedy":"1f1fa-1f1ff","shortnames":[":uz:"],"category":"flags"},":flag_va:":{"uc_base":"1f1fb-1f1e6","uc_output":"1f1fb-1f1e6","uc_match":"1f1fb-1f1e6","uc_greedy":"1f1fb-1f1e6","shortnames":[":va:"],"category":"flags"},":flag_vc:":{"uc_base":"1f1fb-1f1e8","uc_output":"1f1fb-1f1e8","uc_match":"1f1fb-1f1e8","uc_greedy":"1f1fb-1f1e8","shortnames":[":vc:"],"category":"flags"},":flag_ve:":{"uc_base":"1f1fb-1f1ea","uc_output":"1f1fb-1f1ea","uc_match":"1f1fb-1f1ea","uc_greedy":"1f1fb-1f1ea","shortnames":[":ve:"],"category":"flags"},":flag_vg:":{"uc_base":"1f1fb-1f1ec","uc_output":"1f1fb-1f1ec","uc_match":"1f1fb-1f1ec","uc_greedy":"1f1fb-1f1ec","shortnames":[":vg:"],"category":"flags"},":flag_vi:":{"uc_base":"1f1fb-1f1ee","uc_output":"1f1fb-1f1ee","uc_match":"1f1fb-1f1ee","uc_greedy":"1f1fb-1f1ee","shortnames":[":vi:"],"category":"flags"},":flag_vn:":{"uc_base":"1f1fb-1f1f3","uc_output":"1f1fb-1f1f3","uc_match":"1f1fb-1f1f3","uc_greedy":"1f1fb-1f1f3","shortnames":[":vn:"],"category":"flags"},":flag_vu:":{"uc_base":"1f1fb-1f1fa","uc_output":"1f1fb-1f1fa","uc_match":"1f1fb-1f1fa","uc_greedy":"1f1fb-1f1fa","shortnames":[":vu:"],"category":"flags"},":flag_wf:":{"uc_base":"1f1fc-1f1eb","uc_output":"1f1fc-1f1eb","uc_match":"1f1fc-1f1eb","uc_greedy":"1f1fc-1f1eb","shortnames":[":wf:"],"category":"flags"},":flag_ws:":{"uc_base":"1f1fc-1f1f8","uc_output":"1f1fc-1f1f8","uc_match":"1f1fc-1f1f8","uc_greedy":"1f1fc-1f1f8","shortnames":[":ws:"],"category":"flags"},":flag_xk:":{"uc_base":"1f1fd-1f1f0","uc_output":"1f1fd-1f1f0","uc_match":"1f1fd-1f1f0","uc_greedy":"1f1fd-1f1f0","shortnames":[":xk:"],"category":"flags"},":flag_ye:":{"uc_base":"1f1fe-1f1ea","uc_output":"1f1fe-1f1ea","uc_match":"1f1fe-1f1ea","uc_greedy":"1f1fe-1f1ea","shortnames":[":ye:"],"category":"flags"},":flag_yt:":{"uc_base":"1f1fe-1f1f9","uc_output":"1f1fe-1f1f9","uc_match":"1f1fe-1f1f9","uc_greedy":"1f1fe-1f1f9","shortnames":[":yt:"],"category":"flags"},":flag_za:":{"uc_base":"1f1ff-1f1e6","uc_output":"1f1ff-1f1e6","uc_match":"1f1ff-1f1e6","uc_greedy":"1f1ff-1f1e6","shortnames":[":za:"],"category":"flags"},":flag_zm:":{"uc_base":"1f1ff-1f1f2","uc_output":"1f1ff-1f1f2","uc_match":"1f1ff-1f1f2","uc_greedy":"1f1ff-1f1f2","shortnames":[":zm:"],"category":"flags"},":flag_zw:":{"uc_base":"1f1ff-1f1fc","uc_output":"1f1ff-1f1fc","uc_match":"1f1ff-1f1fc","uc_greedy":"1f1ff-1f1fc","shortnames":[":zw:"],"category":"flags"},":girl_tone1:":{"uc_base":"1f467-1f3fb","uc_output":"1f467-1f3fb","uc_match":"1f467-1f3fb","uc_greedy":"1f467-1f3fb","shortnames":[],"category":"people"},":girl_tone2:":{"uc_base":"1f467-1f3fc","uc_output":"1f467-1f3fc","uc_match":"1f467-1f3fc","uc_greedy":"1f467-1f3fc","shortnames":[],"category":"people"},":girl_tone3:":{"uc_base":"1f467-1f3fd","uc_output":"1f467-1f3fd","uc_match":"1f467-1f3fd","uc_greedy":"1f467-1f3fd","shortnames":[],"category":"people"},":girl_tone4:":{"uc_base":"1f467-1f3fe","uc_output":"1f467-1f3fe","uc_match":"1f467-1f3fe","uc_greedy":"1f467-1f3fe","shortnames":[],"category":"people"},":girl_tone5:":{"uc_base":"1f467-1f3ff","uc_output":"1f467-1f3ff","uc_match":"1f467-1f3ff","uc_greedy":"1f467-1f3ff","shortnames":[],"category":"people"},":guard_tone1:":{"uc_base":"1f482-1f3fb","uc_output":"1f482-1f3fb","uc_match":"1f482-1f3fb","uc_greedy":"1f482-1f3fb","shortnames":[":guardsman_tone1:"],"category":"people"},":guard_tone2:":{"uc_base":"1f482-1f3fc","uc_output":"1f482-1f3fc","uc_match":"1f482-1f3fc","uc_greedy":"1f482-1f3fc","shortnames":[":guardsman_tone2:"],"category":"people"},":guard_tone3:":{"uc_base":"1f482-1f3fd","uc_output":"1f482-1f3fd","uc_match":"1f482-1f3fd","uc_greedy":"1f482-1f3fd","shortnames":[":guardsman_tone3:"],"category":"people"},":guard_tone4:":{"uc_base":"1f482-1f3fe","uc_output":"1f482-1f3fe","uc_match":"1f482-1f3fe","uc_greedy":"1f482-1f3fe","shortnames":[":guardsman_tone4:"],"category":"people"},":guard_tone5:":{"uc_base":"1f482-1f3ff","uc_output":"1f482-1f3ff","uc_match":"1f482-1f3ff","uc_greedy":"1f482-1f3ff","shortnames":[":guardsman_tone5:"],"category":"people"},":hand_splayed_tone1:":{"uc_base":"1f590-1f3fb","uc_output":"1f590-1f3fb","uc_match":"1f590-fe0f-1f3fb","uc_greedy":"1f590-fe0f-1f3fb","shortnames":[":raised_hand_with_fingers_splayed_tone1:"],"category":"people"},":hand_splayed_tone2:":{"uc_base":"1f590-1f3fc","uc_output":"1f590-1f3fc","uc_match":"1f590-fe0f-1f3fc","uc_greedy":"1f590-fe0f-1f3fc","shortnames":[":raised_hand_with_fingers_splayed_tone2:"],"category":"people"},":hand_splayed_tone3:":{"uc_base":"1f590-1f3fd","uc_output":"1f590-1f3fd","uc_match":"1f590-fe0f-1f3fd","uc_greedy":"1f590-fe0f-1f3fd","shortnames":[":raised_hand_with_fingers_splayed_tone3:"],"category":"people"},":hand_splayed_tone4:":{"uc_base":"1f590-1f3fe","uc_output":"1f590-1f3fe","uc_match":"1f590-fe0f-1f3fe","uc_greedy":"1f590-fe0f-1f3fe","shortnames":[":raised_hand_with_fingers_splayed_tone4:"],"category":"people"},":hand_splayed_tone5:":{"uc_base":"1f590-1f3ff","uc_output":"1f590-1f3ff","uc_match":"1f590-fe0f-1f3ff","uc_greedy":"1f590-fe0f-1f3ff","shortnames":[":raised_hand_with_fingers_splayed_tone5:"],"category":"people"},":horse_racing_tone1:":{"uc_base":"1f3c7-1f3fb","uc_output":"1f3c7-1f3fb","uc_match":"1f3c7-1f3fb","uc_greedy":"1f3c7-1f3fb","shortnames":[],"category":"activity"},":horse_racing_tone2:":{"uc_base":"1f3c7-1f3fc","uc_output":"1f3c7-1f3fc","uc_match":"1f3c7-1f3fc","uc_greedy":"1f3c7-1f3fc","shortnames":[],"category":"activity"},":horse_racing_tone3:":{"uc_base":"1f3c7-1f3fd","uc_output":"1f3c7-1f3fd","uc_match":"1f3c7-1f3fd","uc_greedy":"1f3c7-1f3fd","shortnames":[],"category":"activity"},":horse_racing_tone4:":{"uc_base":"1f3c7-1f3fe","uc_output":"1f3c7-1f3fe","uc_match":"1f3c7-1f3fe","uc_greedy":"1f3c7-1f3fe","shortnames":[],"category":"activity"},":horse_racing_tone5:":{"uc_base":"1f3c7-1f3ff","uc_output":"1f3c7-1f3ff","uc_match":"1f3c7-1f3ff","uc_greedy":"1f3c7-1f3ff","shortnames":[],"category":"activity"},":left_facing_fist_tone1:":{"uc_base":"1f91b-1f3fb","uc_output":"1f91b-1f3fb","uc_match":"1f91b-1f3fb","uc_greedy":"1f91b-1f3fb","shortnames":[":left_fist_tone1:"],"category":"people"},":left_facing_fist_tone2:":{"uc_base":"1f91b-1f3fc","uc_output":"1f91b-1f3fc","uc_match":"1f91b-1f3fc","uc_greedy":"1f91b-1f3fc","shortnames":[":left_fist_tone2:"],"category":"people"},":left_facing_fist_tone3:":{"uc_base":"1f91b-1f3fd","uc_output":"1f91b-1f3fd","uc_match":"1f91b-1f3fd","uc_greedy":"1f91b-1f3fd","shortnames":[":left_fist_tone3:"],"category":"people"},":left_facing_fist_tone4:":{"uc_base":"1f91b-1f3fe","uc_output":"1f91b-1f3fe","uc_match":"1f91b-1f3fe","uc_greedy":"1f91b-1f3fe","shortnames":[":left_fist_tone4:"],"category":"people"},":left_facing_fist_tone5:":{"uc_base":"1f91b-1f3ff","uc_output":"1f91b-1f3ff","uc_match":"1f91b-1f3ff","uc_greedy":"1f91b-1f3ff","shortnames":[":left_fist_tone5:"],"category":"people"},":levitate_tone1:":{"uc_base":"1f574-1f3fb","uc_output":"1f574-1f3fb","uc_match":"1f574-fe0f-1f3fb","uc_greedy":"1f574-fe0f-1f3fb","shortnames":[":man_in_business_suit_levitating_tone1:",":man_in_business_suit_levitating_light_skin_tone:"],"category":"people"},":levitate_tone2:":{"uc_base":"1f574-1f3fc","uc_output":"1f574-1f3fc","uc_match":"1f574-fe0f-1f3fc","uc_greedy":"1f574-fe0f-1f3fc","shortnames":[":man_in_business_suit_levitating_tone2:",":man_in_business_suit_levitating_medium_light_skin_tone:"],"category":"people"},":levitate_tone3:":{"uc_base":"1f574-1f3fd","uc_output":"1f574-1f3fd","uc_match":"1f574-fe0f-1f3fd","uc_greedy":"1f574-fe0f-1f3fd","shortnames":[":man_in_business_suit_levitating_tone3:",":man_in_business_suit_levitating_medium_skin_tone:"],"category":"people"},":levitate_tone4:":{"uc_base":"1f574-1f3fe","uc_output":"1f574-1f3fe","uc_match":"1f574-fe0f-1f3fe","uc_greedy":"1f574-fe0f-1f3fe","shortnames":[":man_in_business_suit_levitating_tone4:",":man_in_business_suit_levitating_medium_dark_skin_tone:"],"category":"people"},":levitate_tone5:":{"uc_base":"1f574-1f3ff","uc_output":"1f574-1f3ff","uc_match":"1f574-fe0f-1f3ff","uc_greedy":"1f574-fe0f-1f3ff","shortnames":[":man_in_business_suit_levitating_tone5:",":man_in_business_suit_levitating_dark_skin_tone:"],"category":"people"},":love_you_gesture_tone1:":{"uc_base":"1f91f-1f3fb","uc_output":"1f91f-1f3fb","uc_match":"1f91f-1f3fb","uc_greedy":"1f91f-1f3fb","shortnames":[":love_you_gesture_light_skin_tone:"],"category":"people"},":love_you_gesture_tone2:":{"uc_base":"1f91f-1f3fc","uc_output":"1f91f-1f3fc","uc_match":"1f91f-1f3fc","uc_greedy":"1f91f-1f3fc","shortnames":[":love_you_gesture_medium_light_skin_tone:"],"category":"people"},":love_you_gesture_tone3:":{"uc_base":"1f91f-1f3fd","uc_output":"1f91f-1f3fd","uc_match":"1f91f-1f3fd","uc_greedy":"1f91f-1f3fd","shortnames":[":love_you_gesture_medium_skin_tone:"],"category":"people"},":love_you_gesture_tone4:":{"uc_base":"1f91f-1f3fe","uc_output":"1f91f-1f3fe","uc_match":"1f91f-1f3fe","uc_greedy":"1f91f-1f3fe","shortnames":[":love_you_gesture_medium_dark_skin_tone:"],"category":"people"},":love_you_gesture_tone5:":{"uc_base":"1f91f-1f3ff","uc_output":"1f91f-1f3ff","uc_match":"1f91f-1f3ff","uc_greedy":"1f91f-1f3ff","shortnames":[":love_you_gesture_dark_skin_tone:"],"category":"people"},":mage_tone1:":{"uc_base":"1f9d9-1f3fb","uc_output":"1f9d9-1f3fb","uc_match":"1f9d9-1f3fb","uc_greedy":"1f9d9-1f3fb","shortnames":[":mage_light_skin_tone:"],"category":"people"},":mage_tone2:":{"uc_base":"1f9d9-1f3fc","uc_output":"1f9d9-1f3fc","uc_match":"1f9d9-1f3fc","uc_greedy":"1f9d9-1f3fc","shortnames":[":mage_medium_light_skin_tone:"],"category":"people"},":mage_tone3:":{"uc_base":"1f9d9-1f3fd","uc_output":"1f9d9-1f3fd","uc_match":"1f9d9-1f3fd","uc_greedy":"1f9d9-1f3fd","shortnames":[":mage_medium_skin_tone:"],"category":"people"},":mage_tone4:":{"uc_base":"1f9d9-1f3fe","uc_output":"1f9d9-1f3fe","uc_match":"1f9d9-1f3fe","uc_greedy":"1f9d9-1f3fe","shortnames":[":mage_medium_dark_skin_tone:"],"category":"people"},":mage_tone5:":{"uc_base":"1f9d9-1f3ff","uc_output":"1f9d9-1f3ff","uc_match":"1f9d9-1f3ff","uc_greedy":"1f9d9-1f3ff","shortnames":[":mage_dark_skin_tone:"],"category":"people"},":man_dancing_tone1:":{"uc_base":"1f57a-1f3fb","uc_output":"1f57a-1f3fb","uc_match":"1f57a-1f3fb","uc_greedy":"1f57a-1f3fb","shortnames":[":male_dancer_tone1:"],"category":"people"},":man_dancing_tone2:":{"uc_base":"1f57a-1f3fc","uc_output":"1f57a-1f3fc","uc_match":"1f57a-1f3fc","uc_greedy":"1f57a-1f3fc","shortnames":[":male_dancer_tone2:"],"category":"people"},":man_dancing_tone3:":{"uc_base":"1f57a-1f3fd","uc_output":"1f57a-1f3fd","uc_match":"1f57a-1f3fd","uc_greedy":"1f57a-1f3fd","shortnames":[":male_dancer_tone3:"],"category":"people"},":man_dancing_tone4:":{"uc_base":"1f57a-1f3fe","uc_output":"1f57a-1f3fe","uc_match":"1f57a-1f3fe","uc_greedy":"1f57a-1f3fe","shortnames":[":male_dancer_tone4:"],"category":"people"},":man_dancing_tone5:":{"uc_base":"1f57a-1f3ff","uc_output":"1f57a-1f3ff","uc_match":"1f57a-1f3ff","uc_greedy":"1f57a-1f3ff","shortnames":[":male_dancer_tone5:"],"category":"people"},":man_in_tuxedo_tone1:":{"uc_base":"1f935-1f3fb","uc_output":"1f935-1f3fb","uc_match":"1f935-1f3fb","uc_greedy":"1f935-1f3fb","shortnames":[":tuxedo_tone1:"],"category":"people"},":man_in_tuxedo_tone2:":{"uc_base":"1f935-1f3fc","uc_output":"1f935-1f3fc","uc_match":"1f935-1f3fc","uc_greedy":"1f935-1f3fc","shortnames":[":tuxedo_tone2:"],"category":"people"},":man_in_tuxedo_tone3:":{"uc_base":"1f935-1f3fd","uc_output":"1f935-1f3fd","uc_match":"1f935-1f3fd","uc_greedy":"1f935-1f3fd","shortnames":[":tuxedo_tone3:"],"category":"people"},":man_in_tuxedo_tone4:":{"uc_base":"1f935-1f3fe","uc_output":"1f935-1f3fe","uc_match":"1f935-1f3fe","uc_greedy":"1f935-1f3fe","shortnames":[":tuxedo_tone4:"],"category":"people"},":man_in_tuxedo_tone5:":{"uc_base":"1f935-1f3ff","uc_output":"1f935-1f3ff","uc_match":"1f935-1f3ff","uc_greedy":"1f935-1f3ff","shortnames":[":tuxedo_tone5:"],"category":"people"},":man_tone1:":{"uc_base":"1f468-1f3fb","uc_output":"1f468-1f3fb","uc_match":"1f468-1f3fb","uc_greedy":"1f468-1f3fb","shortnames":[],"category":"people"},":man_tone2:":{"uc_base":"1f468-1f3fc","uc_output":"1f468-1f3fc","uc_match":"1f468-1f3fc","uc_greedy":"1f468-1f3fc","shortnames":[],"category":"people"},":man_tone3:":{"uc_base":"1f468-1f3fd","uc_output":"1f468-1f3fd","uc_match":"1f468-1f3fd","uc_greedy":"1f468-1f3fd","shortnames":[],"category":"people"},":man_tone4:":{"uc_base":"1f468-1f3fe","uc_output":"1f468-1f3fe","uc_match":"1f468-1f3fe","uc_greedy":"1f468-1f3fe","shortnames":[],"category":"people"},":man_tone5:":{"uc_base":"1f468-1f3ff","uc_output":"1f468-1f3ff","uc_match":"1f468-1f3ff","uc_greedy":"1f468-1f3ff","shortnames":[],"category":"people"},":man_with_chinese_cap_tone1:":{"uc_base":"1f472-1f3fb","uc_output":"1f472-1f3fb","uc_match":"1f472-1f3fb","uc_greedy":"1f472-1f3fb","shortnames":[":man_with_gua_pi_mao_tone1:"],"category":"people"},":man_with_chinese_cap_tone2:":{"uc_base":"1f472-1f3fc","uc_output":"1f472-1f3fc","uc_match":"1f472-1f3fc","uc_greedy":"1f472-1f3fc","shortnames":[":man_with_gua_pi_mao_tone2:"],"category":"people"},":man_with_chinese_cap_tone3:":{"uc_base":"1f472-1f3fd","uc_output":"1f472-1f3fd","uc_match":"1f472-1f3fd","uc_greedy":"1f472-1f3fd","shortnames":[":man_with_gua_pi_mao_tone3:"],"category":"people"},":man_with_chinese_cap_tone4:":{"uc_base":"1f472-1f3fe","uc_output":"1f472-1f3fe","uc_match":"1f472-1f3fe","uc_greedy":"1f472-1f3fe","shortnames":[":man_with_gua_pi_mao_tone4:"],"category":"people"},":man_with_chinese_cap_tone5:":{"uc_base":"1f472-1f3ff","uc_output":"1f472-1f3ff","uc_match":"1f472-1f3ff","uc_greedy":"1f472-1f3ff","shortnames":[":man_with_gua_pi_mao_tone5:"],"category":"people"},":merperson_tone1:":{"uc_base":"1f9dc-1f3fb","uc_output":"1f9dc-1f3fb","uc_match":"1f9dc-1f3fb","uc_greedy":"1f9dc-1f3fb","shortnames":[":merperson_light_skin_tone:"],"category":"people"},":merperson_tone2:":{"uc_base":"1f9dc-1f3fc","uc_output":"1f9dc-1f3fc","uc_match":"1f9dc-1f3fc","uc_greedy":"1f9dc-1f3fc","shortnames":[":merperson_medium_light_skin_tone:"],"category":"people"},":merperson_tone3:":{"uc_base":"1f9dc-1f3fd","uc_output":"1f9dc-1f3fd","uc_match":"1f9dc-1f3fd","uc_greedy":"1f9dc-1f3fd","shortnames":[":merperson_medium_skin_tone:"],"category":"people"},":merperson_tone4:":{"uc_base":"1f9dc-1f3fe","uc_output":"1f9dc-1f3fe","uc_match":"1f9dc-1f3fe","uc_greedy":"1f9dc-1f3fe","shortnames":[":merperson_medium_dark_skin_tone:"],"category":"people"},":merperson_tone5:":{"uc_base":"1f9dc-1f3ff","uc_output":"1f9dc-1f3ff","uc_match":"1f9dc-1f3ff","uc_greedy":"1f9dc-1f3ff","shortnames":[":merperson_dark_skin_tone:"],"category":"people"},":metal_tone1:":{"uc_base":"1f918-1f3fb","uc_output":"1f918-1f3fb","uc_match":"1f918-1f3fb","uc_greedy":"1f918-1f3fb","shortnames":[":sign_of_the_horns_tone1:"],"category":"people"},":metal_tone2:":{"uc_base":"1f918-1f3fc","uc_output":"1f918-1f3fc","uc_match":"1f918-1f3fc","uc_greedy":"1f918-1f3fc","shortnames":[":sign_of_the_horns_tone2:"],"category":"people"},":metal_tone3:":{"uc_base":"1f918-1f3fd","uc_output":"1f918-1f3fd","uc_match":"1f918-1f3fd","uc_greedy":"1f918-1f3fd","shortnames":[":sign_of_the_horns_tone3:"],"category":"people"},":metal_tone4:":{"uc_base":"1f918-1f3fe","uc_output":"1f918-1f3fe","uc_match":"1f918-1f3fe","uc_greedy":"1f918-1f3fe","shortnames":[":sign_of_the_horns_tone4:"],"category":"people"},":metal_tone5:":{"uc_base":"1f918-1f3ff","uc_output":"1f918-1f3ff","uc_match":"1f918-1f3ff","uc_greedy":"1f918-1f3ff","shortnames":[":sign_of_the_horns_tone5:"],"category":"people"},":middle_finger_tone1:":{"uc_base":"1f595-1f3fb","uc_output":"1f595-1f3fb","uc_match":"1f595-1f3fb","uc_greedy":"1f595-1f3fb","shortnames":[":reversed_hand_with_middle_finger_extended_tone1:"],"category":"people"},":middle_finger_tone2:":{"uc_base":"1f595-1f3fc","uc_output":"1f595-1f3fc","uc_match":"1f595-1f3fc","uc_greedy":"1f595-1f3fc","shortnames":[":reversed_hand_with_middle_finger_extended_tone2:"],"category":"people"},":middle_finger_tone3:":{"uc_base":"1f595-1f3fd","uc_output":"1f595-1f3fd","uc_match":"1f595-1f3fd","uc_greedy":"1f595-1f3fd","shortnames":[":reversed_hand_with_middle_finger_extended_tone3:"],"category":"people"},":middle_finger_tone4:":{"uc_base":"1f595-1f3fe","uc_output":"1f595-1f3fe","uc_match":"1f595-1f3fe","uc_greedy":"1f595-1f3fe","shortnames":[":reversed_hand_with_middle_finger_extended_tone4:"],"category":"people"},":middle_finger_tone5:":{"uc_base":"1f595-1f3ff","uc_output":"1f595-1f3ff","uc_match":"1f595-1f3ff","uc_greedy":"1f595-1f3ff","shortnames":[":reversed_hand_with_middle_finger_extended_tone5:"],"category":"people"},":mrs_claus_tone1:":{"uc_base":"1f936-1f3fb","uc_output":"1f936-1f3fb","uc_match":"1f936-1f3fb","uc_greedy":"1f936-1f3fb","shortnames":[":mother_christmas_tone1:"],"category":"people"},":mrs_claus_tone2:":{"uc_base":"1f936-1f3fc","uc_output":"1f936-1f3fc","uc_match":"1f936-1f3fc","uc_greedy":"1f936-1f3fc","shortnames":[":mother_christmas_tone2:"],"category":"people"},":mrs_claus_tone3:":{"uc_base":"1f936-1f3fd","uc_output":"1f936-1f3fd","uc_match":"1f936-1f3fd","uc_greedy":"1f936-1f3fd","shortnames":[":mother_christmas_tone3:"],"category":"people"},":mrs_claus_tone4:":{"uc_base":"1f936-1f3fe","uc_output":"1f936-1f3fe","uc_match":"1f936-1f3fe","uc_greedy":"1f936-1f3fe","shortnames":[":mother_christmas_tone4:"],"category":"people"},":mrs_claus_tone5:":{"uc_base":"1f936-1f3ff","uc_output":"1f936-1f3ff","uc_match":"1f936-1f3ff","uc_greedy":"1f936-1f3ff","shortnames":[":mother_christmas_tone5:"],"category":"people"},":muscle_tone1:":{"uc_base":"1f4aa-1f3fb","uc_output":"1f4aa-1f3fb","uc_match":"1f4aa-1f3fb","uc_greedy":"1f4aa-1f3fb","shortnames":[],"category":"people"},":muscle_tone2:":{"uc_base":"1f4aa-1f3fc","uc_output":"1f4aa-1f3fc","uc_match":"1f4aa-1f3fc","uc_greedy":"1f4aa-1f3fc","shortnames":[],"category":"people"},":muscle_tone3:":{"uc_base":"1f4aa-1f3fd","uc_output":"1f4aa-1f3fd","uc_match":"1f4aa-1f3fd","uc_greedy":"1f4aa-1f3fd","shortnames":[],"category":"people"},":muscle_tone4:":{"uc_base":"1f4aa-1f3fe","uc_output":"1f4aa-1f3fe","uc_match":"1f4aa-1f3fe","uc_greedy":"1f4aa-1f3fe","shortnames":[],"category":"people"},":muscle_tone5:":{"uc_base":"1f4aa-1f3ff","uc_output":"1f4aa-1f3ff","uc_match":"1f4aa-1f3ff","uc_greedy":"1f4aa-1f3ff","shortnames":[],"category":"people"},":nail_care_tone1:":{"uc_base":"1f485-1f3fb","uc_output":"1f485-1f3fb","uc_match":"1f485-1f3fb","uc_greedy":"1f485-1f3fb","shortnames":[],"category":"people"},":nail_care_tone2:":{"uc_base":"1f485-1f3fc","uc_output":"1f485-1f3fc","uc_match":"1f485-1f3fc","uc_greedy":"1f485-1f3fc","shortnames":[],"category":"people"},":nail_care_tone3:":{"uc_base":"1f485-1f3fd","uc_output":"1f485-1f3fd","uc_match":"1f485-1f3fd","uc_greedy":"1f485-1f3fd","shortnames":[],"category":"people"},":nail_care_tone4:":{"uc_base":"1f485-1f3fe","uc_output":"1f485-1f3fe","uc_match":"1f485-1f3fe","uc_greedy":"1f485-1f3fe","shortnames":[],"category":"people"},":nail_care_tone5:":{"uc_base":"1f485-1f3ff","uc_output":"1f485-1f3ff","uc_match":"1f485-1f3ff","uc_greedy":"1f485-1f3ff","shortnames":[],"category":"people"},":nose_tone1:":{"uc_base":"1f443-1f3fb","uc_output":"1f443-1f3fb","uc_match":"1f443-1f3fb","uc_greedy":"1f443-1f3fb","shortnames":[],"category":"people"},":nose_tone2:":{"uc_base":"1f443-1f3fc","uc_output":"1f443-1f3fc","uc_match":"1f443-1f3fc","uc_greedy":"1f443-1f3fc","shortnames":[],"category":"people"},":nose_tone3:":{"uc_base":"1f443-1f3fd","uc_output":"1f443-1f3fd","uc_match":"1f443-1f3fd","uc_greedy":"1f443-1f3fd","shortnames":[],"category":"people"},":nose_tone4:":{"uc_base":"1f443-1f3fe","uc_output":"1f443-1f3fe","uc_match":"1f443-1f3fe","uc_greedy":"1f443-1f3fe","shortnames":[],"category":"people"},":nose_tone5:":{"uc_base":"1f443-1f3ff","uc_output":"1f443-1f3ff","uc_match":"1f443-1f3ff","uc_greedy":"1f443-1f3ff","shortnames":[],"category":"people"},":ok_hand_tone1:":{"uc_base":"1f44c-1f3fb","uc_output":"1f44c-1f3fb","uc_match":"1f44c-1f3fb","uc_greedy":"1f44c-1f3fb","shortnames":[],"category":"people"},":ok_hand_tone2:":{"uc_base":"1f44c-1f3fc","uc_output":"1f44c-1f3fc","uc_match":"1f44c-1f3fc","uc_greedy":"1f44c-1f3fc","shortnames":[],"category":"people"},":ok_hand_tone3:":{"uc_base":"1f44c-1f3fd","uc_output":"1f44c-1f3fd","uc_match":"1f44c-1f3fd","uc_greedy":"1f44c-1f3fd","shortnames":[],"category":"people"},":ok_hand_tone4:":{"uc_base":"1f44c-1f3fe","uc_output":"1f44c-1f3fe","uc_match":"1f44c-1f3fe","uc_greedy":"1f44c-1f3fe","shortnames":[],"category":"people"},":ok_hand_tone5:":{"uc_base":"1f44c-1f3ff","uc_output":"1f44c-1f3ff","uc_match":"1f44c-1f3ff","uc_greedy":"1f44c-1f3ff","shortnames":[],"category":"people"},":older_adult_tone1:":{"uc_base":"1f9d3-1f3fb","uc_output":"1f9d3-1f3fb","uc_match":"1f9d3-1f3fb","uc_greedy":"1f9d3-1f3fb","shortnames":[":older_adult_light_skin_tone:"],"category":"people"},":older_adult_tone2:":{"uc_base":"1f9d3-1f3fc","uc_output":"1f9d3-1f3fc","uc_match":"1f9d3-1f3fc","uc_greedy":"1f9d3-1f3fc","shortnames":[":older_adult_medium_light_skin_tone:"],"category":"people"},":older_adult_tone3:":{"uc_base":"1f9d3-1f3fd","uc_output":"1f9d3-1f3fd","uc_match":"1f9d3-1f3fd","uc_greedy":"1f9d3-1f3fd","shortnames":[":older_adult_medium_skin_tone:"],"category":"people"},":older_adult_tone4:":{"uc_base":"1f9d3-1f3fe","uc_output":"1f9d3-1f3fe","uc_match":"1f9d3-1f3fe","uc_greedy":"1f9d3-1f3fe","shortnames":[":older_adult_medium_dark_skin_tone:"],"category":"people"},":older_adult_tone5:":{"uc_base":"1f9d3-1f3ff","uc_output":"1f9d3-1f3ff","uc_match":"1f9d3-1f3ff","uc_greedy":"1f9d3-1f3ff","shortnames":[":older_adult_dark_skin_tone:"],"category":"people"},":older_man_tone1:":{"uc_base":"1f474-1f3fb","uc_output":"1f474-1f3fb","uc_match":"1f474-1f3fb","uc_greedy":"1f474-1f3fb","shortnames":[],"category":"people"},":older_man_tone2:":{"uc_base":"1f474-1f3fc","uc_output":"1f474-1f3fc","uc_match":"1f474-1f3fc","uc_greedy":"1f474-1f3fc","shortnames":[],"category":"people"},":older_man_tone3:":{"uc_base":"1f474-1f3fd","uc_output":"1f474-1f3fd","uc_match":"1f474-1f3fd","uc_greedy":"1f474-1f3fd","shortnames":[],"category":"people"},":older_man_tone4:":{"uc_base":"1f474-1f3fe","uc_output":"1f474-1f3fe","uc_match":"1f474-1f3fe","uc_greedy":"1f474-1f3fe","shortnames":[],"category":"people"},":older_man_tone5:":{"uc_base":"1f474-1f3ff","uc_output":"1f474-1f3ff","uc_match":"1f474-1f3ff","uc_greedy":"1f474-1f3ff","shortnames":[],"category":"people"},":older_woman_tone1:":{"uc_base":"1f475-1f3fb","uc_output":"1f475-1f3fb","uc_match":"1f475-1f3fb","uc_greedy":"1f475-1f3fb","shortnames":[":grandma_tone1:"],"category":"people"},":older_woman_tone2:":{"uc_base":"1f475-1f3fc","uc_output":"1f475-1f3fc","uc_match":"1f475-1f3fc","uc_greedy":"1f475-1f3fc","shortnames":[":grandma_tone2:"],"category":"people"},":older_woman_tone3:":{"uc_base":"1f475-1f3fd","uc_output":"1f475-1f3fd","uc_match":"1f475-1f3fd","uc_greedy":"1f475-1f3fd","shortnames":[":grandma_tone3:"],"category":"people"},":older_woman_tone4:":{"uc_base":"1f475-1f3fe","uc_output":"1f475-1f3fe","uc_match":"1f475-1f3fe","uc_greedy":"1f475-1f3fe","shortnames":[":grandma_tone4:"],"category":"people"},":older_woman_tone5:":{"uc_base":"1f475-1f3ff","uc_output":"1f475-1f3ff","uc_match":"1f475-1f3ff","uc_greedy":"1f475-1f3ff","shortnames":[":grandma_tone5:"],"category":"people"},":open_hands_tone1:":{"uc_base":"1f450-1f3fb","uc_output":"1f450-1f3fb","uc_match":"1f450-1f3fb","uc_greedy":"1f450-1f3fb","shortnames":[],"category":"people"},":open_hands_tone2:":{"uc_base":"1f450-1f3fc","uc_output":"1f450-1f3fc","uc_match":"1f450-1f3fc","uc_greedy":"1f450-1f3fc","shortnames":[],"category":"people"},":open_hands_tone3:":{"uc_base":"1f450-1f3fd","uc_output":"1f450-1f3fd","uc_match":"1f450-1f3fd","uc_greedy":"1f450-1f3fd","shortnames":[],"category":"people"},":open_hands_tone4:":{"uc_base":"1f450-1f3fe","uc_output":"1f450-1f3fe","uc_match":"1f450-1f3fe","uc_greedy":"1f450-1f3fe","shortnames":[],"category":"people"},":open_hands_tone5:":{"uc_base":"1f450-1f3ff","uc_output":"1f450-1f3ff","uc_match":"1f450-1f3ff","uc_greedy":"1f450-1f3ff","shortnames":[],"category":"people"},":palms_up_together_tone1:":{"uc_base":"1f932-1f3fb","uc_output":"1f932-1f3fb","uc_match":"1f932-1f3fb","uc_greedy":"1f932-1f3fb","shortnames":[":palms_up_together_light_skin_tone:"],"category":"people"},":palms_up_together_tone2:":{"uc_base":"1f932-1f3fc","uc_output":"1f932-1f3fc","uc_match":"1f932-1f3fc","uc_greedy":"1f932-1f3fc","shortnames":[":palms_up_together_medium_light_skin_tone:"],"category":"people"},":palms_up_together_tone3:":{"uc_base":"1f932-1f3fd","uc_output":"1f932-1f3fd","uc_match":"1f932-1f3fd","uc_greedy":"1f932-1f3fd","shortnames":[":palms_up_together_medium_skin_tone:"],"category":"people"},":palms_up_together_tone4:":{"uc_base":"1f932-1f3fe","uc_output":"1f932-1f3fe","uc_match":"1f932-1f3fe","uc_greedy":"1f932-1f3fe","shortnames":[":palms_up_together_medium_dark_skin_tone:"],"category":"people"},":palms_up_together_tone5:":{"uc_base":"1f932-1f3ff","uc_output":"1f932-1f3ff","uc_match":"1f932-1f3ff","uc_greedy":"1f932-1f3ff","shortnames":[":palms_up_together_dark_skin_tone:"],"category":"people"},":person_biking_tone1:":{"uc_base":"1f6b4-1f3fb","uc_output":"1f6b4-1f3fb","uc_match":"1f6b4-1f3fb","uc_greedy":"1f6b4-1f3fb","shortnames":[":bicyclist_tone1:"],"category":"activity"},":person_biking_tone2:":{"uc_base":"1f6b4-1f3fc","uc_output":"1f6b4-1f3fc","uc_match":"1f6b4-1f3fc","uc_greedy":"1f6b4-1f3fc","shortnames":[":bicyclist_tone2:"],"category":"activity"},":person_biking_tone3:":{"uc_base":"1f6b4-1f3fd","uc_output":"1f6b4-1f3fd","uc_match":"1f6b4-1f3fd","uc_greedy":"1f6b4-1f3fd","shortnames":[":bicyclist_tone3:"],"category":"activity"},":person_biking_tone4:":{"uc_base":"1f6b4-1f3fe","uc_output":"1f6b4-1f3fe","uc_match":"1f6b4-1f3fe","uc_greedy":"1f6b4-1f3fe","shortnames":[":bicyclist_tone4:"],"category":"activity"},":person_biking_tone5:":{"uc_base":"1f6b4-1f3ff","uc_output":"1f6b4-1f3ff","uc_match":"1f6b4-1f3ff","uc_greedy":"1f6b4-1f3ff","shortnames":[":bicyclist_tone5:"],"category":"activity"},":person_bowing_tone1:":{"uc_base":"1f647-1f3fb","uc_output":"1f647-1f3fb","uc_match":"1f647-1f3fb","uc_greedy":"1f647-1f3fb","shortnames":[":bow_tone1:"],"category":"people"},":person_bowing_tone2:":{"uc_base":"1f647-1f3fc","uc_output":"1f647-1f3fc","uc_match":"1f647-1f3fc","uc_greedy":"1f647-1f3fc","shortnames":[":bow_tone2:"],"category":"people"},":person_bowing_tone3:":{"uc_base":"1f647-1f3fd","uc_output":"1f647-1f3fd","uc_match":"1f647-1f3fd","uc_greedy":"1f647-1f3fd","shortnames":[":bow_tone3:"],"category":"people"},":person_bowing_tone4:":{"uc_base":"1f647-1f3fe","uc_output":"1f647-1f3fe","uc_match":"1f647-1f3fe","uc_greedy":"1f647-1f3fe","shortnames":[":bow_tone4:"],"category":"people"},":person_bowing_tone5:":{"uc_base":"1f647-1f3ff","uc_output":"1f647-1f3ff","uc_match":"1f647-1f3ff","uc_greedy":"1f647-1f3ff","shortnames":[":bow_tone5:"],"category":"people"},":person_climbing_tone1:":{"uc_base":"1f9d7-1f3fb","uc_output":"1f9d7-1f3fb","uc_match":"1f9d7-1f3fb","uc_greedy":"1f9d7-1f3fb","shortnames":[":person_climbing_light_skin_tone:"],"category":"activity"},":person_climbing_tone2:":{"uc_base":"1f9d7-1f3fc","uc_output":"1f9d7-1f3fc","uc_match":"1f9d7-1f3fc","uc_greedy":"1f9d7-1f3fc","shortnames":[":person_climbing_medium_light_skin_tone:"],"category":"activity"},":person_climbing_tone3:":{"uc_base":"1f9d7-1f3fd","uc_output":"1f9d7-1f3fd","uc_match":"1f9d7-1f3fd","uc_greedy":"1f9d7-1f3fd","shortnames":[":person_climbing_medium_skin_tone:"],"category":"activity"},":person_climbing_tone4:":{"uc_base":"1f9d7-1f3fe","uc_output":"1f9d7-1f3fe","uc_match":"1f9d7-1f3fe","uc_greedy":"1f9d7-1f3fe","shortnames":[":person_climbing_medium_dark_skin_tone:"],"category":"activity"},":person_climbing_tone5:":{"uc_base":"1f9d7-1f3ff","uc_output":"1f9d7-1f3ff","uc_match":"1f9d7-1f3ff","uc_greedy":"1f9d7-1f3ff","shortnames":[":person_climbing_dark_skin_tone:"],"category":"activity"},":person_doing_cartwheel_tone1:":{"uc_base":"1f938-1f3fb","uc_output":"1f938-1f3fb","uc_match":"1f938-1f3fb","uc_greedy":"1f938-1f3fb","shortnames":[":cartwheel_tone1:"],"category":"activity"},":person_doing_cartwheel_tone2:":{"uc_base":"1f938-1f3fc","uc_output":"1f938-1f3fc","uc_match":"1f938-1f3fc","uc_greedy":"1f938-1f3fc","shortnames":[":cartwheel_tone2:"],"category":"activity"},":person_doing_cartwheel_tone3:":{"uc_base":"1f938-1f3fd","uc_output":"1f938-1f3fd","uc_match":"1f938-1f3fd","uc_greedy":"1f938-1f3fd","shortnames":[":cartwheel_tone3:"],"category":"activity"},":person_doing_cartwheel_tone4:":{"uc_base":"1f938-1f3fe","uc_output":"1f938-1f3fe","uc_match":"1f938-1f3fe","uc_greedy":"1f938-1f3fe","shortnames":[":cartwheel_tone4:"],"category":"activity"},":person_doing_cartwheel_tone5:":{"uc_base":"1f938-1f3ff","uc_output":"1f938-1f3ff","uc_match":"1f938-1f3ff","uc_greedy":"1f938-1f3ff","shortnames":[":cartwheel_tone5:"],"category":"activity"},":person_facepalming_tone1:":{"uc_base":"1f926-1f3fb","uc_output":"1f926-1f3fb","uc_match":"1f926-1f3fb","uc_greedy":"1f926-1f3fb","shortnames":[":face_palm_tone1:",":facepalm_tone1:"],"category":"people"},":person_facepalming_tone2:":{"uc_base":"1f926-1f3fc","uc_output":"1f926-1f3fc","uc_match":"1f926-1f3fc","uc_greedy":"1f926-1f3fc","shortnames":[":face_palm_tone2:",":facepalm_tone2:"],"category":"people"},":person_facepalming_tone3:":{"uc_base":"1f926-1f3fd","uc_output":"1f926-1f3fd","uc_match":"1f926-1f3fd","uc_greedy":"1f926-1f3fd","shortnames":[":face_palm_tone3:",":facepalm_tone3:"],"category":"people"},":person_facepalming_tone4:":{"uc_base":"1f926-1f3fe","uc_output":"1f926-1f3fe","uc_match":"1f926-1f3fe","uc_greedy":"1f926-1f3fe","shortnames":[":face_palm_tone4:",":facepalm_tone4:"],"category":"people"},":person_facepalming_tone5:":{"uc_base":"1f926-1f3ff","uc_output":"1f926-1f3ff","uc_match":"1f926-1f3ff","uc_greedy":"1f926-1f3ff","shortnames":[":face_palm_tone5:",":facepalm_tone5:"],"category":"people"},":person_frowning_tone1:":{"uc_base":"1f64d-1f3fb","uc_output":"1f64d-1f3fb","uc_match":"1f64d-1f3fb","uc_greedy":"1f64d-1f3fb","shortnames":[],"category":"people"},":person_frowning_tone2:":{"uc_base":"1f64d-1f3fc","uc_output":"1f64d-1f3fc","uc_match":"1f64d-1f3fc","uc_greedy":"1f64d-1f3fc","shortnames":[],"category":"people"},":person_frowning_tone3:":{"uc_base":"1f64d-1f3fd","uc_output":"1f64d-1f3fd","uc_match":"1f64d-1f3fd","uc_greedy":"1f64d-1f3fd","shortnames":[],"category":"people"},":person_frowning_tone4:":{"uc_base":"1f64d-1f3fe","uc_output":"1f64d-1f3fe","uc_match":"1f64d-1f3fe","uc_greedy":"1f64d-1f3fe","shortnames":[],"category":"people"},":person_frowning_tone5:":{"uc_base":"1f64d-1f3ff","uc_output":"1f64d-1f3ff","uc_match":"1f64d-1f3ff","uc_greedy":"1f64d-1f3ff","shortnames":[],"category":"people"},":person_gesturing_no_tone1:":{"uc_base":"1f645-1f3fb","uc_output":"1f645-1f3fb","uc_match":"1f645-1f3fb","uc_greedy":"1f645-1f3fb","shortnames":[":no_good_tone1:"],"category":"people"},":person_gesturing_no_tone2:":{"uc_base":"1f645-1f3fc","uc_output":"1f645-1f3fc","uc_match":"1f645-1f3fc","uc_greedy":"1f645-1f3fc","shortnames":[":no_good_tone2:"],"category":"people"},":person_gesturing_no_tone3:":{"uc_base":"1f645-1f3fd","uc_output":"1f645-1f3fd","uc_match":"1f645-1f3fd","uc_greedy":"1f645-1f3fd","shortnames":[":no_good_tone3:"],"category":"people"},":person_gesturing_no_tone4:":{"uc_base":"1f645-1f3fe","uc_output":"1f645-1f3fe","uc_match":"1f645-1f3fe","uc_greedy":"1f645-1f3fe","shortnames":[":no_good_tone4:"],"category":"people"},":person_gesturing_no_tone5:":{"uc_base":"1f645-1f3ff","uc_output":"1f645-1f3ff","uc_match":"1f645-1f3ff","uc_greedy":"1f645-1f3ff","shortnames":[":no_good_tone5:"],"category":"people"},":person_gesturing_ok_tone1:":{"uc_base":"1f646-1f3fb","uc_output":"1f646-1f3fb","uc_match":"1f646-1f3fb","uc_greedy":"1f646-1f3fb","shortnames":[":ok_woman_tone1:"],"category":"people"},":person_gesturing_ok_tone2:":{"uc_base":"1f646-1f3fc","uc_output":"1f646-1f3fc","uc_match":"1f646-1f3fc","uc_greedy":"1f646-1f3fc","shortnames":[":ok_woman_tone2:"],"category":"people"},":person_gesturing_ok_tone3:":{"uc_base":"1f646-1f3fd","uc_output":"1f646-1f3fd","uc_match":"1f646-1f3fd","uc_greedy":"1f646-1f3fd","shortnames":[":ok_woman_tone3:"],"category":"people"},":person_gesturing_ok_tone4:":{"uc_base":"1f646-1f3fe","uc_output":"1f646-1f3fe","uc_match":"1f646-1f3fe","uc_greedy":"1f646-1f3fe","shortnames":[":ok_woman_tone4:"],"category":"people"},":person_gesturing_ok_tone5:":{"uc_base":"1f646-1f3ff","uc_output":"1f646-1f3ff","uc_match":"1f646-1f3ff","uc_greedy":"1f646-1f3ff","shortnames":[":ok_woman_tone5:"],"category":"people"},":person_getting_haircut_tone1:":{"uc_base":"1f487-1f3fb","uc_output":"1f487-1f3fb","uc_match":"1f487-1f3fb","uc_greedy":"1f487-1f3fb","shortnames":[":haircut_tone1:"],"category":"people"},":person_getting_haircut_tone2:":{"uc_base":"1f487-1f3fc","uc_output":"1f487-1f3fc","uc_match":"1f487-1f3fc","uc_greedy":"1f487-1f3fc","shortnames":[":haircut_tone2:"],"category":"people"},":person_getting_haircut_tone3:":{"uc_base":"1f487-1f3fd","uc_output":"1f487-1f3fd","uc_match":"1f487-1f3fd","uc_greedy":"1f487-1f3fd","shortnames":[":haircut_tone3:"],"category":"people"},":person_getting_haircut_tone4:":{"uc_base":"1f487-1f3fe","uc_output":"1f487-1f3fe","uc_match":"1f487-1f3fe","uc_greedy":"1f487-1f3fe","shortnames":[":haircut_tone4:"],"category":"people"},":person_getting_haircut_tone5:":{"uc_base":"1f487-1f3ff","uc_output":"1f487-1f3ff","uc_match":"1f487-1f3ff","uc_greedy":"1f487-1f3ff","shortnames":[":haircut_tone5:"],"category":"people"},":person_getting_massage_tone1:":{"uc_base":"1f486-1f3fb","uc_output":"1f486-1f3fb","uc_match":"1f486-1f3fb","uc_greedy":"1f486-1f3fb","shortnames":[":massage_tone1:"],"category":"people"},":person_getting_massage_tone2:":{"uc_base":"1f486-1f3fc","uc_output":"1f486-1f3fc","uc_match":"1f486-1f3fc","uc_greedy":"1f486-1f3fc","shortnames":[":massage_tone2:"],"category":"people"},":person_getting_massage_tone3:":{"uc_base":"1f486-1f3fd","uc_output":"1f486-1f3fd","uc_match":"1f486-1f3fd","uc_greedy":"1f486-1f3fd","shortnames":[":massage_tone3:"],"category":"people"},":person_getting_massage_tone4:":{"uc_base":"1f486-1f3fe","uc_output":"1f486-1f3fe","uc_match":"1f486-1f3fe","uc_greedy":"1f486-1f3fe","shortnames":[":massage_tone4:"],"category":"people"},":person_getting_massage_tone5:":{"uc_base":"1f486-1f3ff","uc_output":"1f486-1f3ff","uc_match":"1f486-1f3ff","uc_greedy":"1f486-1f3ff","shortnames":[":massage_tone5:"],"category":"people"},":person_golfing_tone1:":{"uc_base":"1f3cc-1f3fb","uc_output":"1f3cc-1f3fb","uc_match":"1f3cc-fe0f-1f3fb","uc_greedy":"1f3cc-fe0f-1f3fb","shortnames":[":person_golfing_light_skin_tone:"],"category":"activity"},":person_golfing_tone2:":{"uc_base":"1f3cc-1f3fc","uc_output":"1f3cc-1f3fc","uc_match":"1f3cc-fe0f-1f3fc","uc_greedy":"1f3cc-fe0f-1f3fc","shortnames":[":person_golfing_medium_light_skin_tone:"],"category":"activity"},":person_golfing_tone3:":{"uc_base":"1f3cc-1f3fd","uc_output":"1f3cc-1f3fd","uc_match":"1f3cc-fe0f-1f3fd","uc_greedy":"1f3cc-fe0f-1f3fd","shortnames":[":person_golfing_medium_skin_tone:"],"category":"activity"},":person_golfing_tone4:":{"uc_base":"1f3cc-1f3fe","uc_output":"1f3cc-1f3fe","uc_match":"1f3cc-fe0f-1f3fe","uc_greedy":"1f3cc-fe0f-1f3fe","shortnames":[":person_golfing_medium_dark_skin_tone:"],"category":"activity"},":person_golfing_tone5:":{"uc_base":"1f3cc-1f3ff","uc_output":"1f3cc-1f3ff","uc_match":"1f3cc-fe0f-1f3ff","uc_greedy":"1f3cc-fe0f-1f3ff","shortnames":[":person_golfing_dark_skin_tone:"],"category":"activity"},":person_in_bed_tone1:":{"uc_base":"1f6cc-1f3fb","uc_output":"1f6cc-1f3fb","uc_match":"1f6cc-1f3fb","uc_greedy":"1f6cc-1f3fb","shortnames":[":person_in_bed_light_skin_tone:"],"category":"objects"},":person_in_bed_tone2:":{"uc_base":"1f6cc-1f3fc","uc_output":"1f6cc-1f3fc","uc_match":"1f6cc-1f3fc","uc_greedy":"1f6cc-1f3fc","shortnames":[":person_in_bed_medium_light_skin_tone:"],"category":"objects"},":person_in_bed_tone3:":{"uc_base":"1f6cc-1f3fd","uc_output":"1f6cc-1f3fd","uc_match":"1f6cc-1f3fd","uc_greedy":"1f6cc-1f3fd","shortnames":[":person_in_bed_medium_skin_tone:"],"category":"objects"},":person_in_bed_tone4:":{"uc_base":"1f6cc-1f3fe","uc_output":"1f6cc-1f3fe","uc_match":"1f6cc-1f3fe","uc_greedy":"1f6cc-1f3fe","shortnames":[":person_in_bed_medium_dark_skin_tone:"],"category":"objects"},":person_in_bed_tone5:":{"uc_base":"1f6cc-1f3ff","uc_output":"1f6cc-1f3ff","uc_match":"1f6cc-1f3ff","uc_greedy":"1f6cc-1f3ff","shortnames":[":person_in_bed_dark_skin_tone:"],"category":"objects"},":person_in_lotus_position_tone1:":{"uc_base":"1f9d8-1f3fb","uc_output":"1f9d8-1f3fb","uc_match":"1f9d8-1f3fb","uc_greedy":"1f9d8-1f3fb","shortnames":[":person_in_lotus_position_light_skin_tone:"],"category":"activity"},":person_in_lotus_position_tone2:":{"uc_base":"1f9d8-1f3fc","uc_output":"1f9d8-1f3fc","uc_match":"1f9d8-1f3fc","uc_greedy":"1f9d8-1f3fc","shortnames":[":person_in_lotus_position_medium_light_skin_tone:"],"category":"activity"},":person_in_lotus_position_tone3:":{"uc_base":"1f9d8-1f3fd","uc_output":"1f9d8-1f3fd","uc_match":"1f9d8-1f3fd","uc_greedy":"1f9d8-1f3fd","shortnames":[":person_in_lotus_position_medium_skin_tone:"],"category":"activity"},":person_in_lotus_position_tone4:":{"uc_base":"1f9d8-1f3fe","uc_output":"1f9d8-1f3fe","uc_match":"1f9d8-1f3fe","uc_greedy":"1f9d8-1f3fe","shortnames":[":person_in_lotus_position_medium_dark_skin_tone:"],"category":"activity"},":person_in_lotus_position_tone5:":{"uc_base":"1f9d8-1f3ff","uc_output":"1f9d8-1f3ff","uc_match":"1f9d8-1f3ff","uc_greedy":"1f9d8-1f3ff","shortnames":[":person_in_lotus_position_dark_skin_tone:"],"category":"activity"},":person_in_steamy_room_tone1:":{"uc_base":"1f9d6-1f3fb","uc_output":"1f9d6-1f3fb","uc_match":"1f9d6-1f3fb","uc_greedy":"1f9d6-1f3fb","shortnames":[":person_in_steamy_room_light_skin_tone:"],"category":"people"},":person_in_steamy_room_tone2:":{"uc_base":"1f9d6-1f3fc","uc_output":"1f9d6-1f3fc","uc_match":"1f9d6-1f3fc","uc_greedy":"1f9d6-1f3fc","shortnames":[":person_in_steamy_room_medium_light_skin_tone:"],"category":"people"},":person_in_steamy_room_tone3:":{"uc_base":"1f9d6-1f3fd","uc_output":"1f9d6-1f3fd","uc_match":"1f9d6-1f3fd","uc_greedy":"1f9d6-1f3fd","shortnames":[":person_in_steamy_room_medium_skin_tone:"],"category":"people"},":person_in_steamy_room_tone4:":{"uc_base":"1f9d6-1f3fe","uc_output":"1f9d6-1f3fe","uc_match":"1f9d6-1f3fe","uc_greedy":"1f9d6-1f3fe","shortnames":[":person_in_steamy_room_medium_dark_skin_tone:"],"category":"people"},":person_in_steamy_room_tone5:":{"uc_base":"1f9d6-1f3ff","uc_output":"1f9d6-1f3ff","uc_match":"1f9d6-1f3ff","uc_greedy":"1f9d6-1f3ff","shortnames":[":person_in_steamy_room_dark_skin_tone:"],"category":"people"},":person_juggling_tone1:":{"uc_base":"1f939-1f3fb","uc_output":"1f939-1f3fb","uc_match":"1f939-1f3fb","uc_greedy":"1f939-1f3fb","shortnames":[":juggling_tone1:",":juggler_tone1:"],"category":"activity"},":person_juggling_tone2:":{"uc_base":"1f939-1f3fc","uc_output":"1f939-1f3fc","uc_match":"1f939-1f3fc","uc_greedy":"1f939-1f3fc","shortnames":[":juggling_tone2:",":juggler_tone2:"],"category":"activity"},":person_juggling_tone3:":{"uc_base":"1f939-1f3fd","uc_output":"1f939-1f3fd","uc_match":"1f939-1f3fd","uc_greedy":"1f939-1f3fd","shortnames":[":juggling_tone3:",":juggler_tone3:"],"category":"activity"},":person_juggling_tone4:":{"uc_base":"1f939-1f3fe","uc_output":"1f939-1f3fe","uc_match":"1f939-1f3fe","uc_greedy":"1f939-1f3fe","shortnames":[":juggling_tone4:",":juggler_tone4:"],"category":"activity"},":person_juggling_tone5:":{"uc_base":"1f939-1f3ff","uc_output":"1f939-1f3ff","uc_match":"1f939-1f3ff","uc_greedy":"1f939-1f3ff","shortnames":[":juggling_tone5:",":juggler_tone5:"],"category":"activity"},":person_lifting_weights_tone1:":{"uc_base":"1f3cb-1f3fb","uc_output":"1f3cb-1f3fb","uc_match":"1f3cb-fe0f-1f3fb","uc_greedy":"1f3cb-fe0f-1f3fb","shortnames":[":lifter_tone1:",":weight_lifter_tone1:"],"category":"activity"},":person_lifting_weights_tone2:":{"uc_base":"1f3cb-1f3fc","uc_output":"1f3cb-1f3fc","uc_match":"1f3cb-fe0f-1f3fc","uc_greedy":"1f3cb-fe0f-1f3fc","shortnames":[":lifter_tone2:",":weight_lifter_tone2:"],"category":"activity"},":person_lifting_weights_tone3:":{"uc_base":"1f3cb-1f3fd","uc_output":"1f3cb-1f3fd","uc_match":"1f3cb-fe0f-1f3fd","uc_greedy":"1f3cb-fe0f-1f3fd","shortnames":[":lifter_tone3:",":weight_lifter_tone3:"],"category":"activity"},":person_lifting_weights_tone4:":{"uc_base":"1f3cb-1f3fe","uc_output":"1f3cb-1f3fe","uc_match":"1f3cb-fe0f-1f3fe","uc_greedy":"1f3cb-fe0f-1f3fe","shortnames":[":lifter_tone4:",":weight_lifter_tone4:"],"category":"activity"},":person_lifting_weights_tone5:":{"uc_base":"1f3cb-1f3ff","uc_output":"1f3cb-1f3ff","uc_match":"1f3cb-fe0f-1f3ff","uc_greedy":"1f3cb-fe0f-1f3ff","shortnames":[":lifter_tone5:",":weight_lifter_tone5:"],"category":"activity"},":person_mountain_biking_tone1:":{"uc_base":"1f6b5-1f3fb","uc_output":"1f6b5-1f3fb","uc_match":"1f6b5-1f3fb","uc_greedy":"1f6b5-1f3fb","shortnames":[":mountain_bicyclist_tone1:"],"category":"activity"},":person_mountain_biking_tone2:":{"uc_base":"1f6b5-1f3fc","uc_output":"1f6b5-1f3fc","uc_match":"1f6b5-1f3fc","uc_greedy":"1f6b5-1f3fc","shortnames":[":mountain_bicyclist_tone2:"],"category":"activity"},":person_mountain_biking_tone3:":{"uc_base":"1f6b5-1f3fd","uc_output":"1f6b5-1f3fd","uc_match":"1f6b5-1f3fd","uc_greedy":"1f6b5-1f3fd","shortnames":[":mountain_bicyclist_tone3:"],"category":"activity"},":person_mountain_biking_tone4:":{"uc_base":"1f6b5-1f3fe","uc_output":"1f6b5-1f3fe","uc_match":"1f6b5-1f3fe","uc_greedy":"1f6b5-1f3fe","shortnames":[":mountain_bicyclist_tone4:"],"category":"activity"},":person_mountain_biking_tone5:":{"uc_base":"1f6b5-1f3ff","uc_output":"1f6b5-1f3ff","uc_match":"1f6b5-1f3ff","uc_greedy":"1f6b5-1f3ff","shortnames":[":mountain_bicyclist_tone5:"],"category":"activity"},":person_playing_handball_tone1:":{"uc_base":"1f93e-1f3fb","uc_output":"1f93e-1f3fb","uc_match":"1f93e-1f3fb","uc_greedy":"1f93e-1f3fb","shortnames":[":handball_tone1:"],"category":"activity"},":person_playing_handball_tone2:":{"uc_base":"1f93e-1f3fc","uc_output":"1f93e-1f3fc","uc_match":"1f93e-1f3fc","uc_greedy":"1f93e-1f3fc","shortnames":[":handball_tone2:"],"category":"activity"},":person_playing_handball_tone3:":{"uc_base":"1f93e-1f3fd","uc_output":"1f93e-1f3fd","uc_match":"1f93e-1f3fd","uc_greedy":"1f93e-1f3fd","shortnames":[":handball_tone3:"],"category":"activity"},":person_playing_handball_tone4:":{"uc_base":"1f93e-1f3fe","uc_output":"1f93e-1f3fe","uc_match":"1f93e-1f3fe","uc_greedy":"1f93e-1f3fe","shortnames":[":handball_tone4:"],"category":"activity"},":person_playing_handball_tone5:":{"uc_base":"1f93e-1f3ff","uc_output":"1f93e-1f3ff","uc_match":"1f93e-1f3ff","uc_greedy":"1f93e-1f3ff","shortnames":[":handball_tone5:"],"category":"activity"},":person_playing_water_polo_tone1:":{"uc_base":"1f93d-1f3fb","uc_output":"1f93d-1f3fb","uc_match":"1f93d-1f3fb","uc_greedy":"1f93d-1f3fb","shortnames":[":water_polo_tone1:"],"category":"activity"},":person_playing_water_polo_tone2:":{"uc_base":"1f93d-1f3fc","uc_output":"1f93d-1f3fc","uc_match":"1f93d-1f3fc","uc_greedy":"1f93d-1f3fc","shortnames":[":water_polo_tone2:"],"category":"activity"},":person_playing_water_polo_tone3:":{"uc_base":"1f93d-1f3fd","uc_output":"1f93d-1f3fd","uc_match":"1f93d-1f3fd","uc_greedy":"1f93d-1f3fd","shortnames":[":water_polo_tone3:"],"category":"activity"},":person_playing_water_polo_tone4:":{"uc_base":"1f93d-1f3fe","uc_output":"1f93d-1f3fe","uc_match":"1f93d-1f3fe","uc_greedy":"1f93d-1f3fe","shortnames":[":water_polo_tone4:"],"category":"activity"},":person_playing_water_polo_tone5:":{"uc_base":"1f93d-1f3ff","uc_output":"1f93d-1f3ff","uc_match":"1f93d-1f3ff","uc_greedy":"1f93d-1f3ff","shortnames":[":water_polo_tone5:"],"category":"activity"},":person_pouting_tone1:":{"uc_base":"1f64e-1f3fb","uc_output":"1f64e-1f3fb","uc_match":"1f64e-1f3fb","uc_greedy":"1f64e-1f3fb","shortnames":[":person_with_pouting_face_tone1:"],"category":"people"},":person_pouting_tone2:":{"uc_base":"1f64e-1f3fc","uc_output":"1f64e-1f3fc","uc_match":"1f64e-1f3fc","uc_greedy":"1f64e-1f3fc","shortnames":[":person_with_pouting_face_tone2:"],"category":"people"},":person_pouting_tone3:":{"uc_base":"1f64e-1f3fd","uc_output":"1f64e-1f3fd","uc_match":"1f64e-1f3fd","uc_greedy":"1f64e-1f3fd","shortnames":[":person_with_pouting_face_tone3:"],"category":"people"},":person_pouting_tone4:":{"uc_base":"1f64e-1f3fe","uc_output":"1f64e-1f3fe","uc_match":"1f64e-1f3fe","uc_greedy":"1f64e-1f3fe","shortnames":[":person_with_pouting_face_tone4:"],"category":"people"},":person_pouting_tone5:":{"uc_base":"1f64e-1f3ff","uc_output":"1f64e-1f3ff","uc_match":"1f64e-1f3ff","uc_greedy":"1f64e-1f3ff","shortnames":[":person_with_pouting_face_tone5:"],"category":"people"},":person_raising_hand_tone1:":{"uc_base":"1f64b-1f3fb","uc_output":"1f64b-1f3fb","uc_match":"1f64b-1f3fb","uc_greedy":"1f64b-1f3fb","shortnames":[":raising_hand_tone1:"],"category":"people"},":person_raising_hand_tone2:":{"uc_base":"1f64b-1f3fc","uc_output":"1f64b-1f3fc","uc_match":"1f64b-1f3fc","uc_greedy":"1f64b-1f3fc","shortnames":[":raising_hand_tone2:"],"category":"people"},":person_raising_hand_tone3:":{"uc_base":"1f64b-1f3fd","uc_output":"1f64b-1f3fd","uc_match":"1f64b-1f3fd","uc_greedy":"1f64b-1f3fd","shortnames":[":raising_hand_tone3:"],"category":"people"},":person_raising_hand_tone4:":{"uc_base":"1f64b-1f3fe","uc_output":"1f64b-1f3fe","uc_match":"1f64b-1f3fe","uc_greedy":"1f64b-1f3fe","shortnames":[":raising_hand_tone4:"],"category":"people"},":person_raising_hand_tone5:":{"uc_base":"1f64b-1f3ff","uc_output":"1f64b-1f3ff","uc_match":"1f64b-1f3ff","uc_greedy":"1f64b-1f3ff","shortnames":[":raising_hand_tone5:"],"category":"people"},":person_rowing_boat_tone1:":{"uc_base":"1f6a3-1f3fb","uc_output":"1f6a3-1f3fb","uc_match":"1f6a3-1f3fb","uc_greedy":"1f6a3-1f3fb","shortnames":[":rowboat_tone1:"],"category":"activity"},":person_rowing_boat_tone2:":{"uc_base":"1f6a3-1f3fc","uc_output":"1f6a3-1f3fc","uc_match":"1f6a3-1f3fc","uc_greedy":"1f6a3-1f3fc","shortnames":[":rowboat_tone2:"],"category":"activity"},":person_rowing_boat_tone3:":{"uc_base":"1f6a3-1f3fd","uc_output":"1f6a3-1f3fd","uc_match":"1f6a3-1f3fd","uc_greedy":"1f6a3-1f3fd","shortnames":[":rowboat_tone3:"],"category":"activity"},":person_rowing_boat_tone4:":{"uc_base":"1f6a3-1f3fe","uc_output":"1f6a3-1f3fe","uc_match":"1f6a3-1f3fe","uc_greedy":"1f6a3-1f3fe","shortnames":[":rowboat_tone4:"],"category":"activity"},":person_rowing_boat_tone5:":{"uc_base":"1f6a3-1f3ff","uc_output":"1f6a3-1f3ff","uc_match":"1f6a3-1f3ff","uc_greedy":"1f6a3-1f3ff","shortnames":[":rowboat_tone5:"],"category":"activity"},":person_running_tone1:":{"uc_base":"1f3c3-1f3fb","uc_output":"1f3c3-1f3fb","uc_match":"1f3c3-1f3fb","uc_greedy":"1f3c3-1f3fb","shortnames":[":runner_tone1:"],"category":"people"},":person_running_tone2:":{"uc_base":"1f3c3-1f3fc","uc_output":"1f3c3-1f3fc","uc_match":"1f3c3-1f3fc","uc_greedy":"1f3c3-1f3fc","shortnames":[":runner_tone2:"],"category":"people"},":person_running_tone3:":{"uc_base":"1f3c3-1f3fd","uc_output":"1f3c3-1f3fd","uc_match":"1f3c3-1f3fd","uc_greedy":"1f3c3-1f3fd","shortnames":[":runner_tone3:"],"category":"people"},":person_running_tone4:":{"uc_base":"1f3c3-1f3fe","uc_output":"1f3c3-1f3fe","uc_match":"1f3c3-1f3fe","uc_greedy":"1f3c3-1f3fe","shortnames":[":runner_tone4:"],"category":"people"},":person_running_tone5:":{"uc_base":"1f3c3-1f3ff","uc_output":"1f3c3-1f3ff","uc_match":"1f3c3-1f3ff","uc_greedy":"1f3c3-1f3ff","shortnames":[":runner_tone5:"],"category":"people"},":person_shrugging_tone1:":{"uc_base":"1f937-1f3fb","uc_output":"1f937-1f3fb","uc_match":"1f937-1f3fb","uc_greedy":"1f937-1f3fb","shortnames":[":shrug_tone1:"],"category":"people"},":person_shrugging_tone2:":{"uc_base":"1f937-1f3fc","uc_output":"1f937-1f3fc","uc_match":"1f937-1f3fc","uc_greedy":"1f937-1f3fc","shortnames":[":shrug_tone2:"],"category":"people"},":person_shrugging_tone3:":{"uc_base":"1f937-1f3fd","uc_output":"1f937-1f3fd","uc_match":"1f937-1f3fd","uc_greedy":"1f937-1f3fd","shortnames":[":shrug_tone3:"],"category":"people"},":person_shrugging_tone4:":{"uc_base":"1f937-1f3fe","uc_output":"1f937-1f3fe","uc_match":"1f937-1f3fe","uc_greedy":"1f937-1f3fe","shortnames":[":shrug_tone4:"],"category":"people"},":person_shrugging_tone5:":{"uc_base":"1f937-1f3ff","uc_output":"1f937-1f3ff","uc_match":"1f937-1f3ff","uc_greedy":"1f937-1f3ff","shortnames":[":shrug_tone5:"],"category":"people"},":person_surfing_tone1:":{"uc_base":"1f3c4-1f3fb","uc_output":"1f3c4-1f3fb","uc_match":"1f3c4-1f3fb","uc_greedy":"1f3c4-1f3fb","shortnames":[":surfer_tone1:"],"category":"activity"},":person_surfing_tone2:":{"uc_base":"1f3c4-1f3fc","uc_output":"1f3c4-1f3fc","uc_match":"1f3c4-1f3fc","uc_greedy":"1f3c4-1f3fc","shortnames":[":surfer_tone2:"],"category":"activity"},":person_surfing_tone3:":{"uc_base":"1f3c4-1f3fd","uc_output":"1f3c4-1f3fd","uc_match":"1f3c4-1f3fd","uc_greedy":"1f3c4-1f3fd","shortnames":[":surfer_tone3:"],"category":"activity"},":person_surfing_tone4:":{"uc_base":"1f3c4-1f3fe","uc_output":"1f3c4-1f3fe","uc_match":"1f3c4-1f3fe","uc_greedy":"1f3c4-1f3fe","shortnames":[":surfer_tone4:"],"category":"activity"},":person_surfing_tone5:":{"uc_base":"1f3c4-1f3ff","uc_output":"1f3c4-1f3ff","uc_match":"1f3c4-1f3ff","uc_greedy":"1f3c4-1f3ff","shortnames":[":surfer_tone5:"],"category":"activity"},":person_swimming_tone1:":{"uc_base":"1f3ca-1f3fb","uc_output":"1f3ca-1f3fb","uc_match":"1f3ca-1f3fb","uc_greedy":"1f3ca-1f3fb","shortnames":[":swimmer_tone1:"],"category":"activity"},":person_swimming_tone2:":{"uc_base":"1f3ca-1f3fc","uc_output":"1f3ca-1f3fc","uc_match":"1f3ca-1f3fc","uc_greedy":"1f3ca-1f3fc","shortnames":[":swimmer_tone2:"],"category":"activity"},":person_swimming_tone3:":{"uc_base":"1f3ca-1f3fd","uc_output":"1f3ca-1f3fd","uc_match":"1f3ca-1f3fd","uc_greedy":"1f3ca-1f3fd","shortnames":[":swimmer_tone3:"],"category":"activity"},":person_swimming_tone4:":{"uc_base":"1f3ca-1f3fe","uc_output":"1f3ca-1f3fe","uc_match":"1f3ca-1f3fe","uc_greedy":"1f3ca-1f3fe","shortnames":[":swimmer_tone4:"],"category":"activity"},":person_swimming_tone5:":{"uc_base":"1f3ca-1f3ff","uc_output":"1f3ca-1f3ff","uc_match":"1f3ca-1f3ff","uc_greedy":"1f3ca-1f3ff","shortnames":[":swimmer_tone5:"],"category":"activity"},":person_tipping_hand_tone1:":{"uc_base":"1f481-1f3fb","uc_output":"1f481-1f3fb","uc_match":"1f481-1f3fb","uc_greedy":"1f481-1f3fb","shortnames":[":information_desk_person_tone1:"],"category":"people"},":person_tipping_hand_tone2:":{"uc_base":"1f481-1f3fc","uc_output":"1f481-1f3fc","uc_match":"1f481-1f3fc","uc_greedy":"1f481-1f3fc","shortnames":[":information_desk_person_tone2:"],"category":"people"},":person_tipping_hand_tone3:":{"uc_base":"1f481-1f3fd","uc_output":"1f481-1f3fd","uc_match":"1f481-1f3fd","uc_greedy":"1f481-1f3fd","shortnames":[":information_desk_person_tone3:"],"category":"people"},":person_tipping_hand_tone4:":{"uc_base":"1f481-1f3fe","uc_output":"1f481-1f3fe","uc_match":"1f481-1f3fe","uc_greedy":"1f481-1f3fe","shortnames":[":information_desk_person_tone4:"],"category":"people"},":person_tipping_hand_tone5:":{"uc_base":"1f481-1f3ff","uc_output":"1f481-1f3ff","uc_match":"1f481-1f3ff","uc_greedy":"1f481-1f3ff","shortnames":[":information_desk_person_tone5:"],"category":"people"},":person_walking_tone1:":{"uc_base":"1f6b6-1f3fb","uc_output":"1f6b6-1f3fb","uc_match":"1f6b6-1f3fb","uc_greedy":"1f6b6-1f3fb","shortnames":[":walking_tone1:"],"category":"people"},":person_walking_tone2:":{"uc_base":"1f6b6-1f3fc","uc_output":"1f6b6-1f3fc","uc_match":"1f6b6-1f3fc","uc_greedy":"1f6b6-1f3fc","shortnames":[":walking_tone2:"],"category":"people"},":person_walking_tone3:":{"uc_base":"1f6b6-1f3fd","uc_output":"1f6b6-1f3fd","uc_match":"1f6b6-1f3fd","uc_greedy":"1f6b6-1f3fd","shortnames":[":walking_tone3:"],"category":"people"},":person_walking_tone4:":{"uc_base":"1f6b6-1f3fe","uc_output":"1f6b6-1f3fe","uc_match":"1f6b6-1f3fe","uc_greedy":"1f6b6-1f3fe","shortnames":[":walking_tone4:"],"category":"people"},":person_walking_tone5:":{"uc_base":"1f6b6-1f3ff","uc_output":"1f6b6-1f3ff","uc_match":"1f6b6-1f3ff","uc_greedy":"1f6b6-1f3ff","shortnames":[":walking_tone5:"],"category":"people"},":person_wearing_turban_tone1:":{"uc_base":"1f473-1f3fb","uc_output":"1f473-1f3fb","uc_match":"1f473-1f3fb","uc_greedy":"1f473-1f3fb","shortnames":[":man_with_turban_tone1:"],"category":"people"},":person_wearing_turban_tone2:":{"uc_base":"1f473-1f3fc","uc_output":"1f473-1f3fc","uc_match":"1f473-1f3fc","uc_greedy":"1f473-1f3fc","shortnames":[":man_with_turban_tone2:"],"category":"people"},":person_wearing_turban_tone3:":{"uc_base":"1f473-1f3fd","uc_output":"1f473-1f3fd","uc_match":"1f473-1f3fd","uc_greedy":"1f473-1f3fd","shortnames":[":man_with_turban_tone3:"],"category":"people"},":person_wearing_turban_tone4:":{"uc_base":"1f473-1f3fe","uc_output":"1f473-1f3fe","uc_match":"1f473-1f3fe","uc_greedy":"1f473-1f3fe","shortnames":[":man_with_turban_tone4:"],"category":"people"},":person_wearing_turban_tone5:":{"uc_base":"1f473-1f3ff","uc_output":"1f473-1f3ff","uc_match":"1f473-1f3ff","uc_greedy":"1f473-1f3ff","shortnames":[":man_with_turban_tone5:"],"category":"people"},":point_down_tone1:":{"uc_base":"1f447-1f3fb","uc_output":"1f447-1f3fb","uc_match":"1f447-1f3fb","uc_greedy":"1f447-1f3fb","shortnames":[],"category":"people"},":point_down_tone2:":{"uc_base":"1f447-1f3fc","uc_output":"1f447-1f3fc","uc_match":"1f447-1f3fc","uc_greedy":"1f447-1f3fc","shortnames":[],"category":"people"},":point_down_tone3:":{"uc_base":"1f447-1f3fd","uc_output":"1f447-1f3fd","uc_match":"1f447-1f3fd","uc_greedy":"1f447-1f3fd","shortnames":[],"category":"people"},":point_down_tone4:":{"uc_base":"1f447-1f3fe","uc_output":"1f447-1f3fe","uc_match":"1f447-1f3fe","uc_greedy":"1f447-1f3fe","shortnames":[],"category":"people"},":point_down_tone5:":{"uc_base":"1f447-1f3ff","uc_output":"1f447-1f3ff","uc_match":"1f447-1f3ff","uc_greedy":"1f447-1f3ff","shortnames":[],"category":"people"},":point_left_tone1:":{"uc_base":"1f448-1f3fb","uc_output":"1f448-1f3fb","uc_match":"1f448-1f3fb","uc_greedy":"1f448-1f3fb","shortnames":[],"category":"people"},":point_left_tone2:":{"uc_base":"1f448-1f3fc","uc_output":"1f448-1f3fc","uc_match":"1f448-1f3fc","uc_greedy":"1f448-1f3fc","shortnames":[],"category":"people"},":point_left_tone3:":{"uc_base":"1f448-1f3fd","uc_output":"1f448-1f3fd","uc_match":"1f448-1f3fd","uc_greedy":"1f448-1f3fd","shortnames":[],"category":"people"},":point_left_tone4:":{"uc_base":"1f448-1f3fe","uc_output":"1f448-1f3fe","uc_match":"1f448-1f3fe","uc_greedy":"1f448-1f3fe","shortnames":[],"category":"people"},":point_left_tone5:":{"uc_base":"1f448-1f3ff","uc_output":"1f448-1f3ff","uc_match":"1f448-1f3ff","uc_greedy":"1f448-1f3ff","shortnames":[],"category":"people"},":point_right_tone1:":{"uc_base":"1f449-1f3fb","uc_output":"1f449-1f3fb","uc_match":"1f449-1f3fb","uc_greedy":"1f449-1f3fb","shortnames":[],"category":"people"},":point_right_tone2:":{"uc_base":"1f449-1f3fc","uc_output":"1f449-1f3fc","uc_match":"1f449-1f3fc","uc_greedy":"1f449-1f3fc","shortnames":[],"category":"people"},":point_right_tone3:":{"uc_base":"1f449-1f3fd","uc_output":"1f449-1f3fd","uc_match":"1f449-1f3fd","uc_greedy":"1f449-1f3fd","shortnames":[],"category":"people"},":point_right_tone4:":{"uc_base":"1f449-1f3fe","uc_output":"1f449-1f3fe","uc_match":"1f449-1f3fe","uc_greedy":"1f449-1f3fe","shortnames":[],"category":"people"},":point_right_tone5:":{"uc_base":"1f449-1f3ff","uc_output":"1f449-1f3ff","uc_match":"1f449-1f3ff","uc_greedy":"1f449-1f3ff","shortnames":[],"category":"people"},":point_up_2_tone1:":{"uc_base":"1f446-1f3fb","uc_output":"1f446-1f3fb","uc_match":"1f446-1f3fb","uc_greedy":"1f446-1f3fb","shortnames":[],"category":"people"},":point_up_2_tone2:":{"uc_base":"1f446-1f3fc","uc_output":"1f446-1f3fc","uc_match":"1f446-1f3fc","uc_greedy":"1f446-1f3fc","shortnames":[],"category":"people"},":point_up_2_tone3:":{"uc_base":"1f446-1f3fd","uc_output":"1f446-1f3fd","uc_match":"1f446-1f3fd","uc_greedy":"1f446-1f3fd","shortnames":[],"category":"people"},":point_up_2_tone4:":{"uc_base":"1f446-1f3fe","uc_output":"1f446-1f3fe","uc_match":"1f446-1f3fe","uc_greedy":"1f446-1f3fe","shortnames":[],"category":"people"},":point_up_2_tone5:":{"uc_base":"1f446-1f3ff","uc_output":"1f446-1f3ff","uc_match":"1f446-1f3ff","uc_greedy":"1f446-1f3ff","shortnames":[],"category":"people"},":police_officer_tone1:":{"uc_base":"1f46e-1f3fb","uc_output":"1f46e-1f3fb","uc_match":"1f46e-1f3fb","uc_greedy":"1f46e-1f3fb","shortnames":[":cop_tone1:"],"category":"people"},":police_officer_tone2:":{"uc_base":"1f46e-1f3fc","uc_output":"1f46e-1f3fc","uc_match":"1f46e-1f3fc","uc_greedy":"1f46e-1f3fc","shortnames":[":cop_tone2:"],"category":"people"},":police_officer_tone3:":{"uc_base":"1f46e-1f3fd","uc_output":"1f46e-1f3fd","uc_match":"1f46e-1f3fd","uc_greedy":"1f46e-1f3fd","shortnames":[":cop_tone3:"],"category":"people"},":police_officer_tone4:":{"uc_base":"1f46e-1f3fe","uc_output":"1f46e-1f3fe","uc_match":"1f46e-1f3fe","uc_greedy":"1f46e-1f3fe","shortnames":[":cop_tone4:"],"category":"people"},":police_officer_tone5:":{"uc_base":"1f46e-1f3ff","uc_output":"1f46e-1f3ff","uc_match":"1f46e-1f3ff","uc_greedy":"1f46e-1f3ff","shortnames":[":cop_tone5:"],"category":"people"},":pray_tone1:":{"uc_base":"1f64f-1f3fb","uc_output":"1f64f-1f3fb","uc_match":"1f64f-1f3fb","uc_greedy":"1f64f-1f3fb","shortnames":[],"category":"people"},":pray_tone2:":{"uc_base":"1f64f-1f3fc","uc_output":"1f64f-1f3fc","uc_match":"1f64f-1f3fc","uc_greedy":"1f64f-1f3fc","shortnames":[],"category":"people"},":pray_tone3:":{"uc_base":"1f64f-1f3fd","uc_output":"1f64f-1f3fd","uc_match":"1f64f-1f3fd","uc_greedy":"1f64f-1f3fd","shortnames":[],"category":"people"},":pray_tone4:":{"uc_base":"1f64f-1f3fe","uc_output":"1f64f-1f3fe","uc_match":"1f64f-1f3fe","uc_greedy":"1f64f-1f3fe","shortnames":[],"category":"people"},":pray_tone5:":{"uc_base":"1f64f-1f3ff","uc_output":"1f64f-1f3ff","uc_match":"1f64f-1f3ff","uc_greedy":"1f64f-1f3ff","shortnames":[],"category":"people"},":pregnant_woman_tone1:":{"uc_base":"1f930-1f3fb","uc_output":"1f930-1f3fb","uc_match":"1f930-1f3fb","uc_greedy":"1f930-1f3fb","shortnames":[":expecting_woman_tone1:"],"category":"people"},":pregnant_woman_tone2:":{"uc_base":"1f930-1f3fc","uc_output":"1f930-1f3fc","uc_match":"1f930-1f3fc","uc_greedy":"1f930-1f3fc","shortnames":[":expecting_woman_tone2:"],"category":"people"},":pregnant_woman_tone3:":{"uc_base":"1f930-1f3fd","uc_output":"1f930-1f3fd","uc_match":"1f930-1f3fd","uc_greedy":"1f930-1f3fd","shortnames":[":expecting_woman_tone3:"],"category":"people"},":pregnant_woman_tone4:":{"uc_base":"1f930-1f3fe","uc_output":"1f930-1f3fe","uc_match":"1f930-1f3fe","uc_greedy":"1f930-1f3fe","shortnames":[":expecting_woman_tone4:"],"category":"people"},":pregnant_woman_tone5:":{"uc_base":"1f930-1f3ff","uc_output":"1f930-1f3ff","uc_match":"1f930-1f3ff","uc_greedy":"1f930-1f3ff","shortnames":[":expecting_woman_tone5:"],"category":"people"},":prince_tone1:":{"uc_base":"1f934-1f3fb","uc_output":"1f934-1f3fb","uc_match":"1f934-1f3fb","uc_greedy":"1f934-1f3fb","shortnames":[],"category":"people"},":prince_tone2:":{"uc_base":"1f934-1f3fc","uc_output":"1f934-1f3fc","uc_match":"1f934-1f3fc","uc_greedy":"1f934-1f3fc","shortnames":[],"category":"people"},":prince_tone3:":{"uc_base":"1f934-1f3fd","uc_output":"1f934-1f3fd","uc_match":"1f934-1f3fd","uc_greedy":"1f934-1f3fd","shortnames":[],"category":"people"},":prince_tone4:":{"uc_base":"1f934-1f3fe","uc_output":"1f934-1f3fe","uc_match":"1f934-1f3fe","uc_greedy":"1f934-1f3fe","shortnames":[],"category":"people"},":prince_tone5:":{"uc_base":"1f934-1f3ff","uc_output":"1f934-1f3ff","uc_match":"1f934-1f3ff","uc_greedy":"1f934-1f3ff","shortnames":[],"category":"people"},":princess_tone1:":{"uc_base":"1f478-1f3fb","uc_output":"1f478-1f3fb","uc_match":"1f478-1f3fb","uc_greedy":"1f478-1f3fb","shortnames":[],"category":"people"},":princess_tone2:":{"uc_base":"1f478-1f3fc","uc_output":"1f478-1f3fc","uc_match":"1f478-1f3fc","uc_greedy":"1f478-1f3fc","shortnames":[],"category":"people"},":princess_tone3:":{"uc_base":"1f478-1f3fd","uc_output":"1f478-1f3fd","uc_match":"1f478-1f3fd","uc_greedy":"1f478-1f3fd","shortnames":[],"category":"people"},":princess_tone4:":{"uc_base":"1f478-1f3fe","uc_output":"1f478-1f3fe","uc_match":"1f478-1f3fe","uc_greedy":"1f478-1f3fe","shortnames":[],"category":"people"},":princess_tone5:":{"uc_base":"1f478-1f3ff","uc_output":"1f478-1f3ff","uc_match":"1f478-1f3ff","uc_greedy":"1f478-1f3ff","shortnames":[],"category":"people"},":punch_tone1:":{"uc_base":"1f44a-1f3fb","uc_output":"1f44a-1f3fb","uc_match":"1f44a-1f3fb","uc_greedy":"1f44a-1f3fb","shortnames":[],"category":"people"},":punch_tone2:":{"uc_base":"1f44a-1f3fc","uc_output":"1f44a-1f3fc","uc_match":"1f44a-1f3fc","uc_greedy":"1f44a-1f3fc","shortnames":[],"category":"people"},":punch_tone3:":{"uc_base":"1f44a-1f3fd","uc_output":"1f44a-1f3fd","uc_match":"1f44a-1f3fd","uc_greedy":"1f44a-1f3fd","shortnames":[],"category":"people"},":punch_tone4:":{"uc_base":"1f44a-1f3fe","uc_output":"1f44a-1f3fe","uc_match":"1f44a-1f3fe","uc_greedy":"1f44a-1f3fe","shortnames":[],"category":"people"},":punch_tone5:":{"uc_base":"1f44a-1f3ff","uc_output":"1f44a-1f3ff","uc_match":"1f44a-1f3ff","uc_greedy":"1f44a-1f3ff","shortnames":[],"category":"people"},":raised_back_of_hand_tone1:":{"uc_base":"1f91a-1f3fb","uc_output":"1f91a-1f3fb","uc_match":"1f91a-1f3fb","uc_greedy":"1f91a-1f3fb","shortnames":[":back_of_hand_tone1:"],"category":"people"},":raised_back_of_hand_tone2:":{"uc_base":"1f91a-1f3fc","uc_output":"1f91a-1f3fc","uc_match":"1f91a-1f3fc","uc_greedy":"1f91a-1f3fc","shortnames":[":back_of_hand_tone2:"],"category":"people"},":raised_back_of_hand_tone3:":{"uc_base":"1f91a-1f3fd","uc_output":"1f91a-1f3fd","uc_match":"1f91a-1f3fd","uc_greedy":"1f91a-1f3fd","shortnames":[":back_of_hand_tone3:"],"category":"people"},":raised_back_of_hand_tone4:":{"uc_base":"1f91a-1f3fe","uc_output":"1f91a-1f3fe","uc_match":"1f91a-1f3fe","uc_greedy":"1f91a-1f3fe","shortnames":[":back_of_hand_tone4:"],"category":"people"},":raised_back_of_hand_tone5:":{"uc_base":"1f91a-1f3ff","uc_output":"1f91a-1f3ff","uc_match":"1f91a-1f3ff","uc_greedy":"1f91a-1f3ff","shortnames":[":back_of_hand_tone5:"],"category":"people"},":raised_hands_tone1:":{"uc_base":"1f64c-1f3fb","uc_output":"1f64c-1f3fb","uc_match":"1f64c-1f3fb","uc_greedy":"1f64c-1f3fb","shortnames":[],"category":"people"},":raised_hands_tone2:":{"uc_base":"1f64c-1f3fc","uc_output":"1f64c-1f3fc","uc_match":"1f64c-1f3fc","uc_greedy":"1f64c-1f3fc","shortnames":[],"category":"people"},":raised_hands_tone3:":{"uc_base":"1f64c-1f3fd","uc_output":"1f64c-1f3fd","uc_match":"1f64c-1f3fd","uc_greedy":"1f64c-1f3fd","shortnames":[],"category":"people"},":raised_hands_tone4:":{"uc_base":"1f64c-1f3fe","uc_output":"1f64c-1f3fe","uc_match":"1f64c-1f3fe","uc_greedy":"1f64c-1f3fe","shortnames":[],"category":"people"},":raised_hands_tone5:":{"uc_base":"1f64c-1f3ff","uc_output":"1f64c-1f3ff","uc_match":"1f64c-1f3ff","uc_greedy":"1f64c-1f3ff","shortnames":[],"category":"people"},":right_facing_fist_tone1:":{"uc_base":"1f91c-1f3fb","uc_output":"1f91c-1f3fb","uc_match":"1f91c-1f3fb","uc_greedy":"1f91c-1f3fb","shortnames":[":right_fist_tone1:"],"category":"people"},":right_facing_fist_tone2:":{"uc_base":"1f91c-1f3fc","uc_output":"1f91c-1f3fc","uc_match":"1f91c-1f3fc","uc_greedy":"1f91c-1f3fc","shortnames":[":right_fist_tone2:"],"category":"people"},":right_facing_fist_tone3:":{"uc_base":"1f91c-1f3fd","uc_output":"1f91c-1f3fd","uc_match":"1f91c-1f3fd","uc_greedy":"1f91c-1f3fd","shortnames":[":right_fist_tone3:"],"category":"people"},":right_facing_fist_tone4:":{"uc_base":"1f91c-1f3fe","uc_output":"1f91c-1f3fe","uc_match":"1f91c-1f3fe","uc_greedy":"1f91c-1f3fe","shortnames":[":right_fist_tone4:"],"category":"people"},":right_facing_fist_tone5:":{"uc_base":"1f91c-1f3ff","uc_output":"1f91c-1f3ff","uc_match":"1f91c-1f3ff","uc_greedy":"1f91c-1f3ff","shortnames":[":right_fist_tone5:"],"category":"people"},":santa_tone1:":{"uc_base":"1f385-1f3fb","uc_output":"1f385-1f3fb","uc_match":"1f385-1f3fb","uc_greedy":"1f385-1f3fb","shortnames":[],"category":"people"},":santa_tone2:":{"uc_base":"1f385-1f3fc","uc_output":"1f385-1f3fc","uc_match":"1f385-1f3fc","uc_greedy":"1f385-1f3fc","shortnames":[],"category":"people"},":santa_tone3:":{"uc_base":"1f385-1f3fd","uc_output":"1f385-1f3fd","uc_match":"1f385-1f3fd","uc_greedy":"1f385-1f3fd","shortnames":[],"category":"people"},":santa_tone4:":{"uc_base":"1f385-1f3fe","uc_output":"1f385-1f3fe","uc_match":"1f385-1f3fe","uc_greedy":"1f385-1f3fe","shortnames":[],"category":"people"},":santa_tone5:":{"uc_base":"1f385-1f3ff","uc_output":"1f385-1f3ff","uc_match":"1f385-1f3ff","uc_greedy":"1f385-1f3ff","shortnames":[],"category":"people"},":selfie_tone1:":{"uc_base":"1f933-1f3fb","uc_output":"1f933-1f3fb","uc_match":"1f933-1f3fb","uc_greedy":"1f933-1f3fb","shortnames":[],"category":"people"},":selfie_tone2:":{"uc_base":"1f933-1f3fc","uc_output":"1f933-1f3fc","uc_match":"1f933-1f3fc","uc_greedy":"1f933-1f3fc","shortnames":[],"category":"people"},":selfie_tone3:":{"uc_base":"1f933-1f3fd","uc_output":"1f933-1f3fd","uc_match":"1f933-1f3fd","uc_greedy":"1f933-1f3fd","shortnames":[],"category":"people"},":selfie_tone4:":{"uc_base":"1f933-1f3fe","uc_output":"1f933-1f3fe","uc_match":"1f933-1f3fe","uc_greedy":"1f933-1f3fe","shortnames":[],"category":"people"},":selfie_tone5:":{"uc_base":"1f933-1f3ff","uc_output":"1f933-1f3ff","uc_match":"1f933-1f3ff","uc_greedy":"1f933-1f3ff","shortnames":[],"category":"people"},":snowboarder_tone1:":{"uc_base":"1f3c2-1f3fb","uc_output":"1f3c2-1f3fb","uc_match":"1f3c2-1f3fb","uc_greedy":"1f3c2-1f3fb","shortnames":[":snowboarder_light_skin_tone:"],"category":"activity"},":snowboarder_tone2:":{"uc_base":"1f3c2-1f3fc","uc_output":"1f3c2-1f3fc","uc_match":"1f3c2-1f3fc","uc_greedy":"1f3c2-1f3fc","shortnames":[":snowboarder_medium_light_skin_tone:"],"category":"activity"},":snowboarder_tone3:":{"uc_base":"1f3c2-1f3fd","uc_output":"1f3c2-1f3fd","uc_match":"1f3c2-1f3fd","uc_greedy":"1f3c2-1f3fd","shortnames":[":snowboarder_medium_skin_tone:"],"category":"activity"},":snowboarder_tone4:":{"uc_base":"1f3c2-1f3fe","uc_output":"1f3c2-1f3fe","uc_match":"1f3c2-1f3fe","uc_greedy":"1f3c2-1f3fe","shortnames":[":snowboarder_medium_dark_skin_tone:"],"category":"activity"},":snowboarder_tone5:":{"uc_base":"1f3c2-1f3ff","uc_output":"1f3c2-1f3ff","uc_match":"1f3c2-1f3ff","uc_greedy":"1f3c2-1f3ff","shortnames":[":snowboarder_dark_skin_tone:"],"category":"activity"},":thumbsdown_tone1:":{"uc_base":"1f44e-1f3fb","uc_output":"1f44e-1f3fb","uc_match":"1f44e-1f3fb","uc_greedy":"1f44e-1f3fb","shortnames":[":-1_tone1:",":thumbdown_tone1:"],"category":"people"},":thumbsdown_tone2:":{"uc_base":"1f44e-1f3fc","uc_output":"1f44e-1f3fc","uc_match":"1f44e-1f3fc","uc_greedy":"1f44e-1f3fc","shortnames":[":-1_tone2:",":thumbdown_tone2:"],"category":"people"},":thumbsdown_tone3:":{"uc_base":"1f44e-1f3fd","uc_output":"1f44e-1f3fd","uc_match":"1f44e-1f3fd","uc_greedy":"1f44e-1f3fd","shortnames":[":-1_tone3:",":thumbdown_tone3:"],"category":"people"},":thumbsdown_tone4:":{"uc_base":"1f44e-1f3fe","uc_output":"1f44e-1f3fe","uc_match":"1f44e-1f3fe","uc_greedy":"1f44e-1f3fe","shortnames":[":-1_tone4:",":thumbdown_tone4:"],"category":"people"},":thumbsdown_tone5:":{"uc_base":"1f44e-1f3ff","uc_output":"1f44e-1f3ff","uc_match":"1f44e-1f3ff","uc_greedy":"1f44e-1f3ff","shortnames":[":-1_tone5:",":thumbdown_tone5:"],"category":"people"},":thumbsup_tone1:":{"uc_base":"1f44d-1f3fb","uc_output":"1f44d-1f3fb","uc_match":"1f44d-1f3fb","uc_greedy":"1f44d-1f3fb","shortnames":[":+1_tone1:",":thumbup_tone1:"],"category":"people"},":thumbsup_tone2:":{"uc_base":"1f44d-1f3fc","uc_output":"1f44d-1f3fc","uc_match":"1f44d-1f3fc","uc_greedy":"1f44d-1f3fc","shortnames":[":+1_tone2:",":thumbup_tone2:"],"category":"people"},":thumbsup_tone3:":{"uc_base":"1f44d-1f3fd","uc_output":"1f44d-1f3fd","uc_match":"1f44d-1f3fd","uc_greedy":"1f44d-1f3fd","shortnames":[":+1_tone3:",":thumbup_tone3:"],"category":"people"},":thumbsup_tone4:":{"uc_base":"1f44d-1f3fe","uc_output":"1f44d-1f3fe","uc_match":"1f44d-1f3fe","uc_greedy":"1f44d-1f3fe","shortnames":[":+1_tone4:",":thumbup_tone4:"],"category":"people"},":thumbsup_tone5:":{"uc_base":"1f44d-1f3ff","uc_output":"1f44d-1f3ff","uc_match":"1f44d-1f3ff","uc_greedy":"1f44d-1f3ff","shortnames":[":+1_tone5:",":thumbup_tone5:"],"category":"people"},":united_nations:":{"uc_base":"1f1fa-1f1f3","uc_output":"1f1fa-1f1f3","uc_match":"1f1fa-1f1f3","uc_greedy":"1f1fa-1f1f3","shortnames":[],"category":"flags"},":vampire_tone1:":{"uc_base":"1f9db-1f3fb","uc_output":"1f9db-1f3fb","uc_match":"1f9db-1f3fb","uc_greedy":"1f9db-1f3fb","shortnames":[":vampire_light_skin_tone:"],"category":"people"},":vampire_tone2:":{"uc_base":"1f9db-1f3fc","uc_output":"1f9db-1f3fc","uc_match":"1f9db-1f3fc","uc_greedy":"1f9db-1f3fc","shortnames":[":vampire_medium_light_skin_tone:"],"category":"people"},":vampire_tone3:":{"uc_base":"1f9db-1f3fd","uc_output":"1f9db-1f3fd","uc_match":"1f9db-1f3fd","uc_greedy":"1f9db-1f3fd","shortnames":[":vampire_medium_skin_tone:"],"category":"people"},":vampire_tone4:":{"uc_base":"1f9db-1f3fe","uc_output":"1f9db-1f3fe","uc_match":"1f9db-1f3fe","uc_greedy":"1f9db-1f3fe","shortnames":[":vampire_medium_dark_skin_tone:"],"category":"people"},":vampire_tone5:":{"uc_base":"1f9db-1f3ff","uc_output":"1f9db-1f3ff","uc_match":"1f9db-1f3ff","uc_greedy":"1f9db-1f3ff","shortnames":[":vampire_dark_skin_tone:"],"category":"people"},":vulcan_tone1:":{"uc_base":"1f596-1f3fb","uc_output":"1f596-1f3fb","uc_match":"1f596-1f3fb","uc_greedy":"1f596-1f3fb","shortnames":[":raised_hand_with_part_between_middle_and_ring_fingers_tone1:"],"category":"people"},":vulcan_tone2:":{"uc_base":"1f596-1f3fc","uc_output":"1f596-1f3fc","uc_match":"1f596-1f3fc","uc_greedy":"1f596-1f3fc","shortnames":[":raised_hand_with_part_between_middle_and_ring_fingers_tone2:"],"category":"people"},":vulcan_tone3:":{"uc_base":"1f596-1f3fd","uc_output":"1f596-1f3fd","uc_match":"1f596-1f3fd","uc_greedy":"1f596-1f3fd","shortnames":[":raised_hand_with_part_between_middle_and_ring_fingers_tone3:"],"category":"people"},":vulcan_tone4:":{"uc_base":"1f596-1f3fe","uc_output":"1f596-1f3fe","uc_match":"1f596-1f3fe","uc_greedy":"1f596-1f3fe","shortnames":[":raised_hand_with_part_between_middle_and_ring_fingers_tone4:"],"category":"people"},":vulcan_tone5:":{"uc_base":"1f596-1f3ff","uc_output":"1f596-1f3ff","uc_match":"1f596-1f3ff","uc_greedy":"1f596-1f3ff","shortnames":[":raised_hand_with_part_between_middle_and_ring_fingers_tone5:"],"category":"people"},":wave_tone1:":{"uc_base":"1f44b-1f3fb","uc_output":"1f44b-1f3fb","uc_match":"1f44b-1f3fb","uc_greedy":"1f44b-1f3fb","shortnames":[],"category":"people"},":wave_tone2:":{"uc_base":"1f44b-1f3fc","uc_output":"1f44b-1f3fc","uc_match":"1f44b-1f3fc","uc_greedy":"1f44b-1f3fc","shortnames":[],"category":"people"},":wave_tone3:":{"uc_base":"1f44b-1f3fd","uc_output":"1f44b-1f3fd","uc_match":"1f44b-1f3fd","uc_greedy":"1f44b-1f3fd","shortnames":[],"category":"people"},":wave_tone4:":{"uc_base":"1f44b-1f3fe","uc_output":"1f44b-1f3fe","uc_match":"1f44b-1f3fe","uc_greedy":"1f44b-1f3fe","shortnames":[],"category":"people"},":wave_tone5:":{"uc_base":"1f44b-1f3ff","uc_output":"1f44b-1f3ff","uc_match":"1f44b-1f3ff","uc_greedy":"1f44b-1f3ff","shortnames":[],"category":"people"},":woman_tone1:":{"uc_base":"1f469-1f3fb","uc_output":"1f469-1f3fb","uc_match":"1f469-1f3fb","uc_greedy":"1f469-1f3fb","shortnames":[],"category":"people"},":woman_tone2:":{"uc_base":"1f469-1f3fc","uc_output":"1f469-1f3fc","uc_match":"1f469-1f3fc","uc_greedy":"1f469-1f3fc","shortnames":[],"category":"people"},":woman_tone3:":{"uc_base":"1f469-1f3fd","uc_output":"1f469-1f3fd","uc_match":"1f469-1f3fd","uc_greedy":"1f469-1f3fd","shortnames":[],"category":"people"},":woman_tone4:":{"uc_base":"1f469-1f3fe","uc_output":"1f469-1f3fe","uc_match":"1f469-1f3fe","uc_greedy":"1f469-1f3fe","shortnames":[],"category":"people"},":woman_tone5:":{"uc_base":"1f469-1f3ff","uc_output":"1f469-1f3ff","uc_match":"1f469-1f3ff","uc_greedy":"1f469-1f3ff","shortnames":[],"category":"people"},":woman_with_headscarf_tone1:":{"uc_base":"1f9d5-1f3fb","uc_output":"1f9d5-1f3fb","uc_match":"1f9d5-1f3fb","uc_greedy":"1f9d5-1f3fb","shortnames":[":woman_with_headscarf_light_skin_tone:"],"category":"people"},":woman_with_headscarf_tone2:":{"uc_base":"1f9d5-1f3fc","uc_output":"1f9d5-1f3fc","uc_match":"1f9d5-1f3fc","uc_greedy":"1f9d5-1f3fc","shortnames":[":woman_with_headscarf_medium_light_skin_tone:"],"category":"people"},":woman_with_headscarf_tone3:":{"uc_base":"1f9d5-1f3fd","uc_output":"1f9d5-1f3fd","uc_match":"1f9d5-1f3fd","uc_greedy":"1f9d5-1f3fd","shortnames":[":woman_with_headscarf_medium_skin_tone:"],"category":"people"},":woman_with_headscarf_tone4:":{"uc_base":"1f9d5-1f3fe","uc_output":"1f9d5-1f3fe","uc_match":"1f9d5-1f3fe","uc_greedy":"1f9d5-1f3fe","shortnames":[":woman_with_headscarf_medium_dark_skin_tone:"],"category":"people"},":woman_with_headscarf_tone5:":{"uc_base":"1f9d5-1f3ff","uc_output":"1f9d5-1f3ff","uc_match":"1f9d5-1f3ff","uc_greedy":"1f9d5-1f3ff","shortnames":[":woman_with_headscarf_dark_skin_tone:"],"category":"people"},":fist_tone1:":{"uc_base":"270a-1f3fb","uc_output":"270a-1f3fb","uc_match":"270a-1f3fb","uc_greedy":"270a-1f3fb","shortnames":[],"category":"people"},":fist_tone2:":{"uc_base":"270a-1f3fc","uc_output":"270a-1f3fc","uc_match":"270a-1f3fc","uc_greedy":"270a-1f3fc","shortnames":[],"category":"people"},":fist_tone3:":{"uc_base":"270a-1f3fd","uc_output":"270a-1f3fd","uc_match":"270a-1f3fd","uc_greedy":"270a-1f3fd","shortnames":[],"category":"people"},":fist_tone4:":{"uc_base":"270a-1f3fe","uc_output":"270a-1f3fe","uc_match":"270a-1f3fe","uc_greedy":"270a-1f3fe","shortnames":[],"category":"people"},":fist_tone5:":{"uc_base":"270a-1f3ff","uc_output":"270a-1f3ff","uc_match":"270a-1f3ff","uc_greedy":"270a-1f3ff","shortnames":[],"category":"people"},":person_bouncing_ball_tone1:":{"uc_base":"26f9-1f3fb","uc_output":"26f9-1f3fb","uc_match":"26f9-fe0f-1f3fb","uc_greedy":"26f9-fe0f-1f3fb","shortnames":[":basketball_player_tone1:",":person_with_ball_tone1:"],"category":"activity"},":person_bouncing_ball_tone2:":{"uc_base":"26f9-1f3fc","uc_output":"26f9-1f3fc","uc_match":"26f9-fe0f-1f3fc","uc_greedy":"26f9-fe0f-1f3fc","shortnames":[":basketball_player_tone2:",":person_with_ball_tone2:"],"category":"activity"},":person_bouncing_ball_tone3:":{"uc_base":"26f9-1f3fd","uc_output":"26f9-1f3fd","uc_match":"26f9-fe0f-1f3fd","uc_greedy":"26f9-fe0f-1f3fd","shortnames":[":basketball_player_tone3:",":person_with_ball_tone3:"],"category":"activity"},":person_bouncing_ball_tone4:":{"uc_base":"26f9-1f3fe","uc_output":"26f9-1f3fe","uc_match":"26f9-fe0f-1f3fe","uc_greedy":"26f9-fe0f-1f3fe","shortnames":[":basketball_player_tone4:",":person_with_ball_tone4:"],"category":"activity"},":person_bouncing_ball_tone5:":{"uc_base":"26f9-1f3ff","uc_output":"26f9-1f3ff","uc_match":"26f9-fe0f-1f3ff","uc_greedy":"26f9-fe0f-1f3ff","shortnames":[":basketball_player_tone5:",":person_with_ball_tone5:"],"category":"activity"},":point_up_tone1:":{"uc_base":"261d-1f3fb","uc_output":"261d-1f3fb","uc_match":"261d-fe0f-1f3fb","uc_greedy":"261d-fe0f-1f3fb","shortnames":[],"category":"people"},":point_up_tone2:":{"uc_base":"261d-1f3fc","uc_output":"261d-1f3fc","uc_match":"261d-fe0f-1f3fc","uc_greedy":"261d-fe0f-1f3fc","shortnames":[],"category":"people"},":point_up_tone3:":{"uc_base":"261d-1f3fd","uc_output":"261d-1f3fd","uc_match":"261d-fe0f-1f3fd","uc_greedy":"261d-fe0f-1f3fd","shortnames":[],"category":"people"},":point_up_tone4:":{"uc_base":"261d-1f3fe","uc_output":"261d-1f3fe","uc_match":"261d-fe0f-1f3fe","uc_greedy":"261d-fe0f-1f3fe","shortnames":[],"category":"people"},":point_up_tone5:":{"uc_base":"261d-1f3ff","uc_output":"261d-1f3ff","uc_match":"261d-fe0f-1f3ff","uc_greedy":"261d-fe0f-1f3ff","shortnames":[],"category":"people"},":raised_hand_tone1:":{"uc_base":"270b-1f3fb","uc_output":"270b-1f3fb","uc_match":"270b-1f3fb","uc_greedy":"270b-1f3fb","shortnames":[],"category":"people"},":raised_hand_tone2:":{"uc_base":"270b-1f3fc","uc_output":"270b-1f3fc","uc_match":"270b-1f3fc","uc_greedy":"270b-1f3fc","shortnames":[],"category":"people"},":raised_hand_tone3:":{"uc_base":"270b-1f3fd","uc_output":"270b-1f3fd","uc_match":"270b-1f3fd","uc_greedy":"270b-1f3fd","shortnames":[],"category":"people"},":raised_hand_tone4:":{"uc_base":"270b-1f3fe","uc_output":"270b-1f3fe","uc_match":"270b-1f3fe","uc_greedy":"270b-1f3fe","shortnames":[],"category":"people"},":raised_hand_tone5:":{"uc_base":"270b-1f3ff","uc_output":"270b-1f3ff","uc_match":"270b-1f3ff","uc_greedy":"270b-1f3ff","shortnames":[],"category":"people"},":v_tone1:":{"uc_base":"270c-1f3fb","uc_output":"270c-1f3fb","uc_match":"270c-fe0f-1f3fb","uc_greedy":"270c-fe0f-1f3fb","shortnames":[],"category":"people"},":v_tone2:":{"uc_base":"270c-1f3fc","uc_output":"270c-1f3fc","uc_match":"270c-fe0f-1f3fc","uc_greedy":"270c-fe0f-1f3fc","shortnames":[],"category":"people"},":v_tone3:":{"uc_base":"270c-1f3fd","uc_output":"270c-1f3fd","uc_match":"270c-fe0f-1f3fd","uc_greedy":"270c-fe0f-1f3fd","shortnames":[],"category":"people"},":v_tone4:":{"uc_base":"270c-1f3fe","uc_output":"270c-1f3fe","uc_match":"270c-fe0f-1f3fe","uc_greedy":"270c-fe0f-1f3fe","shortnames":[],"category":"people"},":v_tone5:":{"uc_base":"270c-1f3ff","uc_output":"270c-1f3ff","uc_match":"270c-fe0f-1f3ff","uc_greedy":"270c-fe0f-1f3ff","shortnames":[],"category":"people"},":writing_hand_tone1:":{"uc_base":"270d-1f3fb","uc_output":"270d-1f3fb","uc_match":"270d-fe0f-1f3fb","uc_greedy":"270d-fe0f-1f3fb","shortnames":[],"category":"people"},":writing_hand_tone2:":{"uc_base":"270d-1f3fc","uc_output":"270d-1f3fc","uc_match":"270d-fe0f-1f3fc","uc_greedy":"270d-fe0f-1f3fc","shortnames":[],"category":"people"},":writing_hand_tone3:":{"uc_base":"270d-1f3fd","uc_output":"270d-1f3fd","uc_match":"270d-fe0f-1f3fd","uc_greedy":"270d-fe0f-1f3fd","shortnames":[],"category":"people"},":writing_hand_tone4:":{"uc_base":"270d-1f3fe","uc_output":"270d-1f3fe","uc_match":"270d-fe0f-1f3fe","uc_greedy":"270d-fe0f-1f3fe","shortnames":[],"category":"people"},":writing_hand_tone5:":{"uc_base":"270d-1f3ff","uc_output":"270d-1f3ff","uc_match":"270d-fe0f-1f3ff","uc_greedy":"270d-fe0f-1f3ff","shortnames":[],"category":"people"},":100:":{"uc_base":"1f4af","uc_output":"1f4af","uc_match":"1f4af","uc_greedy":"1f4af","shortnames":[],"category":"symbols"},":1234:":{"uc_base":"1f522","uc_output":"1f522","uc_match":"1f522","uc_greedy":"1f522","shortnames":[],"category":"symbols"},":8ball:":{"uc_base":"1f3b1","uc_output":"1f3b1","uc_match":"1f3b1","uc_greedy":"1f3b1","shortnames":[],"category":"activity"},":a:":{"uc_base":"1f170","uc_output":"1f170","uc_match":"1f170-fe0f","uc_greedy":"1f170-fe0f","shortnames":[],"category":"symbols"},":ab:":{"uc_base":"1f18e","uc_output":"1f18e","uc_match":"1f18e","uc_greedy":"1f18e","shortnames":[],"category":"symbols"},":abc:":{"uc_base":"1f524","uc_output":"1f524","uc_match":"1f524","uc_greedy":"1f524","shortnames":[],"category":"symbols"},":abcd:":{"uc_base":"1f521","uc_output":"1f521","uc_match":"1f521","uc_greedy":"1f521","shortnames":[],"category":"symbols"},":accept:":{"uc_base":"1f251","uc_output":"1f251","uc_match":"1f251","uc_greedy":"1f251","shortnames":[],"category":"symbols"},":adult:":{"uc_base":"1f9d1","uc_output":"1f9d1","uc_match":"1f9d1","uc_greedy":"1f9d1","shortnames":[],"category":"people"},":aerial_tramway:":{"uc_base":"1f6a1","uc_output":"1f6a1","uc_match":"1f6a1","uc_greedy":"1f6a1","shortnames":[],"category":"travel"},":airplane_arriving:":{"uc_base":"1f6ec","uc_output":"1f6ec","uc_match":"1f6ec","uc_greedy":"1f6ec","shortnames":[],"category":"travel"},":airplane_departure:":{"uc_base":"1f6eb","uc_output":"1f6eb","uc_match":"1f6eb","uc_greedy":"1f6eb","shortnames":[],"category":"travel"},":airplane_small:":{"uc_base":"1f6e9","uc_output":"1f6e9","uc_match":"1f6e9-fe0f","uc_greedy":"1f6e9-fe0f","shortnames":[":small_airplane:"],"category":"travel"},":alien:":{"uc_base":"1f47d","uc_output":"1f47d","uc_match":"1f47d-fe0f","uc_greedy":"1f47d-fe0f","shortnames":[],"category":"people"},":ambulance:":{"uc_base":"1f691","uc_output":"1f691","uc_match":"1f691-fe0f","uc_greedy":"1f691-fe0f","shortnames":[],"category":"travel"},":amphora:":{"uc_base":"1f3fa","uc_output":"1f3fa","uc_match":"1f3fa","uc_greedy":"1f3fa","shortnames":[],"category":"objects"},":angel:":{"uc_base":"1f47c","uc_output":"1f47c","uc_match":"1f47c","uc_greedy":"1f47c","shortnames":[],"category":"people"},":anger:":{"uc_base":"1f4a2","uc_output":"1f4a2","uc_match":"1f4a2","uc_greedy":"1f4a2","shortnames":[],"category":"symbols"},":anger_right:":{"uc_base":"1f5ef","uc_output":"1f5ef","uc_match":"1f5ef-fe0f","uc_greedy":"1f5ef-fe0f","shortnames":[":right_anger_bubble:"],"category":"symbols"},":angry:":{"uc_base":"1f620","uc_output":"1f620","uc_match":"1f620","uc_greedy":"1f620","shortnames":[],"category":"people"},":anguished:":{"uc_base":"1f627","uc_output":"1f627","uc_match":"1f627","uc_greedy":"1f627","shortnames":[],"category":"people"},":ant:":{"uc_base":"1f41c","uc_output":"1f41c","uc_match":"1f41c","uc_greedy":"1f41c","shortnames":[],"category":"nature"},":apple:":{"uc_base":"1f34e","uc_output":"1f34e","uc_match":"1f34e","uc_greedy":"1f34e","shortnames":[],"category":"food"},":arrow_down_small:":{"uc_base":"1f53d","uc_output":"1f53d","uc_match":"1f53d","uc_greedy":"1f53d","shortnames":[],"category":"symbols"},":arrow_up_small:":{"uc_base":"1f53c","uc_output":"1f53c","uc_match":"1f53c","uc_greedy":"1f53c","shortnames":[],"category":"symbols"},":arrows_clockwise:":{"uc_base":"1f503","uc_output":"1f503","uc_match":"1f503","uc_greedy":"1f503","shortnames":[],"category":"symbols"},":arrows_counterclockwise:":{"uc_base":"1f504","uc_output":"1f504","uc_match":"1f504","uc_greedy":"1f504","shortnames":[],"category":"symbols"},":art:":{"uc_base":"1f3a8","uc_output":"1f3a8","uc_match":"1f3a8","uc_greedy":"1f3a8","shortnames":[],"category":"activity"},":articulated_lorry:":{"uc_base":"1f69b","uc_output":"1f69b","uc_match":"1f69b","uc_greedy":"1f69b","shortnames":[],"category":"travel"},":astonished:":{"uc_base":"1f632","uc_output":"1f632","uc_match":"1f632","uc_greedy":"1f632","shortnames":[],"category":"people"},":athletic_shoe:":{"uc_base":"1f45f","uc_output":"1f45f","uc_match":"1f45f","uc_greedy":"1f45f","shortnames":[],"category":"people"},":atm:":{"uc_base":"1f3e7","uc_output":"1f3e7","uc_match":"1f3e7","uc_greedy":"1f3e7","shortnames":[],"category":"symbols"},":avocado:":{"uc_base":"1f951","uc_output":"1f951","uc_match":"1f951","uc_greedy":"1f951","shortnames":[],"category":"food"},":b:":{"uc_base":"1f171","uc_output":"1f171","uc_match":"1f171-fe0f","uc_greedy":"1f171-fe0f","shortnames":[],"category":"symbols"},":baby:":{"uc_base":"1f476","uc_output":"1f476","uc_match":"1f476","uc_greedy":"1f476","shortnames":[],"category":"people"},":baby_bottle:":{"uc_base":"1f37c","uc_output":"1f37c","uc_match":"1f37c","uc_greedy":"1f37c","shortnames":[],"category":"food"},":baby_chick:":{"uc_base":"1f424","uc_output":"1f424","uc_match":"1f424","uc_greedy":"1f424","shortnames":[],"category":"nature"},":baby_symbol:":{"uc_base":"1f6bc","uc_output":"1f6bc","uc_match":"1f6bc-fe0f","uc_greedy":"1f6bc-fe0f","shortnames":[],"category":"symbols"},":back:":{"uc_base":"1f519","uc_output":"1f519","uc_match":"1f519","uc_greedy":"1f519","shortnames":[],"category":"symbols"},":bacon:":{"uc_base":"1f953","uc_output":"1f953","uc_match":"1f953","uc_greedy":"1f953","shortnames":[],"category":"food"},":badminton:":{"uc_base":"1f3f8","uc_output":"1f3f8","uc_match":"1f3f8","uc_greedy":"1f3f8","shortnames":[],"category":"activity"},":baggage_claim:":{"uc_base":"1f6c4","uc_output":"1f6c4","uc_match":"1f6c4","uc_greedy":"1f6c4","shortnames":[],"category":"symbols"},":balloon:":{"uc_base":"1f388","uc_output":"1f388","uc_match":"1f388","uc_greedy":"1f388","shortnames":[],"category":"objects"},":ballot_box:":{"uc_base":"1f5f3","uc_output":"1f5f3","uc_match":"1f5f3-fe0f","uc_greedy":"1f5f3-fe0f","shortnames":[":ballot_box_with_ballot:"],"category":"objects"},":bamboo:":{"uc_base":"1f38d","uc_output":"1f38d","uc_match":"1f38d","uc_greedy":"1f38d","shortnames":[],"category":"nature"},":banana:":{"uc_base":"1f34c","uc_output":"1f34c","uc_match":"1f34c","uc_greedy":"1f34c","shortnames":[],"category":"food"},":bank:":{"uc_base":"1f3e6","uc_output":"1f3e6","uc_match":"1f3e6","uc_greedy":"1f3e6","shortnames":[],"category":"travel"},":bar_chart:":{"uc_base":"1f4ca","uc_output":"1f4ca","uc_match":"1f4ca","uc_greedy":"1f4ca","shortnames":[],"category":"objects"},":barber:":{"uc_base":"1f488","uc_output":"1f488","uc_match":"1f488","uc_greedy":"1f488","shortnames":[],"category":"objects"},":basketball:":{"uc_base":"1f3c0","uc_output":"1f3c0","uc_match":"1f3c0","uc_greedy":"1f3c0","shortnames":[],"category":"activity"},":bat:":{"uc_base":"1f987","uc_output":"1f987","uc_match":"1f987","uc_greedy":"1f987","shortnames":[],"category":"nature"},":bath:":{"uc_base":"1f6c0","uc_output":"1f6c0","uc_match":"1f6c0","uc_greedy":"1f6c0","shortnames":[],"category":"objects"},":bathtub:":{"uc_base":"1f6c1","uc_output":"1f6c1","uc_match":"1f6c1","uc_greedy":"1f6c1","shortnames":[],"category":"objects"},":battery:":{"uc_base":"1f50b","uc_output":"1f50b","uc_match":"1f50b","uc_greedy":"1f50b","shortnames":[],"category":"objects"},":beach:":{"uc_base":"1f3d6","uc_output":"1f3d6","uc_match":"1f3d6-fe0f","uc_greedy":"1f3d6-fe0f","shortnames":[":beach_with_umbrella:"],"category":"travel"},":bear:":{"uc_base":"1f43b","uc_output":"1f43b","uc_match":"1f43b","uc_greedy":"1f43b","shortnames":[],"category":"nature"},":bearded_person:":{"uc_base":"1f9d4","uc_output":"1f9d4","uc_match":"1f9d4","uc_greedy":"1f9d4","shortnames":[],"category":"people"},":bed:":{"uc_base":"1f6cf","uc_output":"1f6cf","uc_match":"1f6cf-fe0f","uc_greedy":"1f6cf-fe0f","shortnames":[],"category":"objects"},":bee:":{"uc_base":"1f41d","uc_output":"1f41d","uc_match":"1f41d","uc_greedy":"1f41d","shortnames":[],"category":"nature"},":beer:":{"uc_base":"1f37a","uc_output":"1f37a","uc_match":"1f37a","uc_greedy":"1f37a","shortnames":[],"category":"food"},":beers:":{"uc_base":"1f37b","uc_output":"1f37b","uc_match":"1f37b","uc_greedy":"1f37b","shortnames":[],"category":"food"},":beetle:":{"uc_base":"1f41e","uc_output":"1f41e","uc_match":"1f41e","uc_greedy":"1f41e","shortnames":[],"category":"nature"},":beginner:":{"uc_base":"1f530","uc_output":"1f530","uc_match":"1f530","uc_greedy":"1f530","shortnames":[],"category":"symbols"},":bell:":{"uc_base":"1f514","uc_output":"1f514","uc_match":"1f514","uc_greedy":"1f514","shortnames":[],"category":"symbols"},":bellhop:":{"uc_base":"1f6ce","uc_output":"1f6ce","uc_match":"1f6ce-fe0f","uc_greedy":"1f6ce-fe0f","shortnames":[":bellhop_bell:"],"category":"objects"},":bento:":{"uc_base":"1f371","uc_output":"1f371","uc_match":"1f371","uc_greedy":"1f371","shortnames":[],"category":"food"},":bike:":{"uc_base":"1f6b2","uc_output":"1f6b2","uc_match":"1f6b2-fe0f","uc_greedy":"1f6b2-fe0f","shortnames":[],"category":"travel"},":bikini:":{"uc_base":"1f459","uc_output":"1f459","uc_match":"1f459","uc_greedy":"1f459","shortnames":[],"category":"people"},":billed_cap:":{"uc_base":"1f9e2","uc_output":"1f9e2","uc_match":"1f9e2","uc_greedy":"1f9e2","shortnames":[],"category":"people"},":bird:":{"uc_base":"1f426","uc_output":"1f426","uc_match":"1f426-fe0f","uc_greedy":"1f426-fe0f","shortnames":[],"category":"nature"},":birthday:":{"uc_base":"1f382","uc_output":"1f382","uc_match":"1f382","uc_greedy":"1f382","shortnames":[],"category":"food"},":black_heart:":{"uc_base":"1f5a4","uc_output":"1f5a4","uc_match":"1f5a4","uc_greedy":"1f5a4","shortnames":[],"category":"symbols"},":black_joker:":{"uc_base":"1f0cf","uc_output":"1f0cf","uc_match":"1f0cf","uc_greedy":"1f0cf","shortnames":[],"category":"symbols"},":black_square_button:":{"uc_base":"1f532","uc_output":"1f532","uc_match":"1f532","uc_greedy":"1f532","shortnames":[],"category":"symbols"},":blond_haired_person:":{"uc_base":"1f471","uc_output":"1f471","uc_match":"1f471","uc_greedy":"1f471","shortnames":[":person_with_blond_hair:"],"category":"people"},":blossom:":{"uc_base":"1f33c","uc_output":"1f33c","uc_match":"1f33c","uc_greedy":"1f33c","shortnames":[],"category":"nature"},":blowfish:":{"uc_base":"1f421","uc_output":"1f421","uc_match":"1f421","uc_greedy":"1f421","shortnames":[],"category":"nature"},":blue_book:":{"uc_base":"1f4d8","uc_output":"1f4d8","uc_match":"1f4d8","uc_greedy":"1f4d8","shortnames":[],"category":"objects"},":blue_car:":{"uc_base":"1f699","uc_output":"1f699","uc_match":"1f699","uc_greedy":"1f699","shortnames":[],"category":"travel"},":blue_circle:":{"uc_base":"1f535","uc_output":"1f535","uc_match":"1f535","uc_greedy":"1f535","shortnames":[],"category":"symbols"},":blue_heart:":{"uc_base":"1f499","uc_output":"1f499","uc_match":"1f499","uc_greedy":"1f499","shortnames":[],"category":"symbols"},":blush:":{"uc_base":"1f60a","uc_output":"1f60a","uc_match":"1f60a","uc_greedy":"1f60a","shortnames":[],"category":"people"},":boar:":{"uc_base":"1f417","uc_output":"1f417","uc_match":"1f417","uc_greedy":"1f417","shortnames":[],"category":"nature"},":bomb:":{"uc_base":"1f4a3","uc_output":"1f4a3","uc_match":"1f4a3-fe0f","uc_greedy":"1f4a3-fe0f","shortnames":[],"category":"objects"},":book:":{"uc_base":"1f4d6","uc_output":"1f4d6","uc_match":"1f4d6","uc_greedy":"1f4d6","shortnames":[],"category":"objects"},":bookmark:":{"uc_base":"1f516","uc_output":"1f516","uc_match":"1f516","uc_greedy":"1f516","shortnames":[],"category":"objects"},":bookmark_tabs:":{"uc_base":"1f4d1","uc_output":"1f4d1","uc_match":"1f4d1","uc_greedy":"1f4d1","shortnames":[],"category":"objects"},":books:":{"uc_base":"1f4da","uc_output":"1f4da","uc_match":"1f4da-fe0f","uc_greedy":"1f4da-fe0f","shortnames":[],"category":"objects"},":boom:":{"uc_base":"1f4a5","uc_output":"1f4a5","uc_match":"1f4a5","uc_greedy":"1f4a5","shortnames":[],"category":"nature"},":boot:":{"uc_base":"1f462","uc_output":"1f462","uc_match":"1f462","uc_greedy":"1f462","shortnames":[],"category":"people"},":bouquet:":{"uc_base":"1f490","uc_output":"1f490","uc_match":"1f490","uc_greedy":"1f490","shortnames":[],"category":"nature"},":bow_and_arrow:":{"uc_base":"1f3f9","uc_output":"1f3f9","uc_match":"1f3f9","uc_greedy":"1f3f9","shortnames":[":archery:"],"category":"activity"},":bowl_with_spoon:":{"uc_base":"1f963","uc_output":"1f963","uc_match":"1f963","uc_greedy":"1f963","shortnames":[],"category":"food"},":bowling:":{"uc_base":"1f3b3","uc_output":"1f3b3","uc_match":"1f3b3","uc_greedy":"1f3b3","shortnames":[],"category":"activity"},":boxing_glove:":{"uc_base":"1f94a","uc_output":"1f94a","uc_match":"1f94a","uc_greedy":"1f94a","shortnames":[":boxing_gloves:"],"category":"activity"},":boy:":{"uc_base":"1f466","uc_output":"1f466","uc_match":"1f466","uc_greedy":"1f466","shortnames":[],"category":"people"},":brain:":{"uc_base":"1f9e0","uc_output":"1f9e0","uc_match":"1f9e0","uc_greedy":"1f9e0","shortnames":[],"category":"people"},":bread:":{"uc_base":"1f35e","uc_output":"1f35e","uc_match":"1f35e","uc_greedy":"1f35e","shortnames":[],"category":"food"},":breast_feeding:":{"uc_base":"1f931","uc_output":"1f931","uc_match":"1f931","uc_greedy":"1f931","shortnames":[],"category":"people"},":bride_with_veil:":{"uc_base":"1f470","uc_output":"1f470","uc_match":"1f470","uc_greedy":"1f470","shortnames":[],"category":"people"},":bridge_at_night:":{"uc_base":"1f309","uc_output":"1f309","uc_match":"1f309","uc_greedy":"1f309","shortnames":[],"category":"travel"},":briefcase:":{"uc_base":"1f4bc","uc_output":"1f4bc","uc_match":"1f4bc","uc_greedy":"1f4bc","shortnames":[],"category":"people"},":broccoli:":{"uc_base":"1f966","uc_output":"1f966","uc_match":"1f966","uc_greedy":"1f966","shortnames":[],"category":"food"},":broken_heart:":{"uc_base":"1f494","uc_output":"1f494","uc_match":"1f494","uc_greedy":"1f494","shortnames":[],"category":"symbols"},":bug:":{"uc_base":"1f41b","uc_output":"1f41b","uc_match":"1f41b","uc_greedy":"1f41b","shortnames":[],"category":"nature"},":bulb:":{"uc_base":"1f4a1","uc_output":"1f4a1","uc_match":"1f4a1","uc_greedy":"1f4a1","shortnames":[],"category":"objects"},":bullettrain_front:":{"uc_base":"1f685","uc_output":"1f685","uc_match":"1f685","uc_greedy":"1f685","shortnames":[],"category":"travel"},":bullettrain_side:":{"uc_base":"1f684","uc_output":"1f684","uc_match":"1f684","uc_greedy":"1f684","shortnames":[],"category":"travel"},":burrito:":{"uc_base":"1f32f","uc_output":"1f32f","uc_match":"1f32f","uc_greedy":"1f32f","shortnames":[],"category":"food"},":bus:":{"uc_base":"1f68c","uc_output":"1f68c","uc_match":"1f68c","uc_greedy":"1f68c","shortnames":[],"category":"travel"},":busstop:":{"uc_base":"1f68f","uc_output":"1f68f","uc_match":"1f68f","uc_greedy":"1f68f","shortnames":[],"category":"travel"},":bust_in_silhouette:":{"uc_base":"1f464","uc_output":"1f464","uc_match":"1f464","uc_greedy":"1f464","shortnames":[],"category":"people"},":busts_in_silhouette:":{"uc_base":"1f465","uc_output":"1f465","uc_match":"1f465","uc_greedy":"1f465","shortnames":[],"category":"people"},":butterfly:":{"uc_base":"1f98b","uc_output":"1f98b","uc_match":"1f98b","uc_greedy":"1f98b","shortnames":[],"category":"nature"},":cactus:":{"uc_base":"1f335","uc_output":"1f335","uc_match":"1f335","uc_greedy":"1f335","shortnames":[],"category":"nature"},":cake:":{"uc_base":"1f370","uc_output":"1f370","uc_match":"1f370","uc_greedy":"1f370","shortnames":[],"category":"food"},":calendar:":{"uc_base":"1f4c6","uc_output":"1f4c6","uc_match":"1f4c6","uc_greedy":"1f4c6","shortnames":[],"category":"objects"},":calendar_spiral:":{"uc_base":"1f5d3","uc_output":"1f5d3","uc_match":"1f5d3-fe0f","uc_greedy":"1f5d3-fe0f","shortnames":[":spiral_calendar_pad:"],"category":"objects"},":call_me:":{"uc_base":"1f919","uc_output":"1f919","uc_match":"1f919","uc_greedy":"1f919","shortnames":[":call_me_hand:"],"category":"people"},":calling:":{"uc_base":"1f4f2","uc_output":"1f4f2","uc_match":"1f4f2","uc_greedy":"1f4f2","shortnames":[],"category":"objects"},":camel:":{"uc_base":"1f42b","uc_output":"1f42b","uc_match":"1f42b","uc_greedy":"1f42b","shortnames":[],"category":"nature"},":camera:":{"uc_base":"1f4f7","uc_output":"1f4f7","uc_match":"1f4f7-fe0f","uc_greedy":"1f4f7-fe0f","shortnames":[],"category":"objects"},":camera_with_flash:":{"uc_base":"1f4f8","uc_output":"1f4f8","uc_match":"1f4f8","uc_greedy":"1f4f8","shortnames":[],"category":"objects"},":camping:":{"uc_base":"1f3d5","uc_output":"1f3d5","uc_match":"1f3d5-fe0f","uc_greedy":"1f3d5-fe0f","shortnames":[],"category":"travel"},":candle:":{"uc_base":"1f56f","uc_output":"1f56f","uc_match":"1f56f-fe0f","uc_greedy":"1f56f-fe0f","shortnames":[],"category":"objects"},":candy:":{"uc_base":"1f36c","uc_output":"1f36c","uc_match":"1f36c","uc_greedy":"1f36c","shortnames":[],"category":"food"},":canned_food:":{"uc_base":"1f96b","uc_output":"1f96b","uc_match":"1f96b","uc_greedy":"1f96b","shortnames":[],"category":"food"},":canoe:":{"uc_base":"1f6f6","uc_output":"1f6f6","uc_match":"1f6f6","uc_greedy":"1f6f6","shortnames":[":kayak:"],"category":"travel"},":capital_abcd:":{"uc_base":"1f520","uc_output":"1f520","uc_match":"1f520","uc_greedy":"1f520","shortnames":[],"category":"symbols"},":card_box:":{"uc_base":"1f5c3","uc_output":"1f5c3","uc_match":"1f5c3-fe0f","uc_greedy":"1f5c3-fe0f","shortnames":[":card_file_box:"],"category":"objects"},":card_index:":{"uc_base":"1f4c7","uc_output":"1f4c7","uc_match":"1f4c7","uc_greedy":"1f4c7","shortnames":[],"category":"objects"},":carousel_horse:":{"uc_base":"1f3a0","uc_output":"1f3a0","uc_match":"1f3a0","uc_greedy":"1f3a0","shortnames":[],"category":"travel"},":carrot:":{"uc_base":"1f955","uc_output":"1f955","uc_match":"1f955","uc_greedy":"1f955","shortnames":[],"category":"food"},":cat2:":{"uc_base":"1f408","uc_output":"1f408","uc_match":"1f408-fe0f","uc_greedy":"1f408-fe0f","shortnames":[],"category":"nature"},":cat:":{"uc_base":"1f431","uc_output":"1f431","uc_match":"1f431","uc_greedy":"1f431","shortnames":[],"category":"nature"},":cd:":{"uc_base":"1f4bf","uc_output":"1f4bf","uc_match":"1f4bf-fe0f","uc_greedy":"1f4bf-fe0f","shortnames":[],"category":"objects"},":champagne:":{"uc_base":"1f37e","uc_output":"1f37e","uc_match":"1f37e","uc_greedy":"1f37e","shortnames":[":bottle_with_popping_cork:"],"category":"food"},":champagne_glass:":{"uc_base":"1f942","uc_output":"1f942","uc_match":"1f942","uc_greedy":"1f942","shortnames":[":clinking_glass:"],"category":"food"},":chart:":{"uc_base":"1f4b9","uc_output":"1f4b9","uc_match":"1f4b9","uc_greedy":"1f4b9","shortnames":[],"category":"symbols"},":chart_with_downwards_trend:":{"uc_base":"1f4c9","uc_output":"1f4c9","uc_match":"1f4c9","uc_greedy":"1f4c9","shortnames":[],"category":"objects"},":chart_with_upwards_trend:":{"uc_base":"1f4c8","uc_output":"1f4c8","uc_match":"1f4c8","uc_greedy":"1f4c8","shortnames":[],"category":"objects"},":checkered_flag:":{"uc_base":"1f3c1","uc_output":"1f3c1","uc_match":"1f3c1","uc_greedy":"1f3c1","shortnames":[],"category":"flags"},":cheese:":{"uc_base":"1f9c0","uc_output":"1f9c0","uc_match":"1f9c0","uc_greedy":"1f9c0","shortnames":[":cheese_wedge:"],"category":"food"},":cherries:":{"uc_base":"1f352","uc_output":"1f352","uc_match":"1f352","uc_greedy":"1f352","shortnames":[],"category":"food"},":cherry_blossom:":{"uc_base":"1f338","uc_output":"1f338","uc_match":"1f338","uc_greedy":"1f338","shortnames":[],"category":"nature"},":chestnut:":{"uc_base":"1f330","uc_output":"1f330","uc_match":"1f330","uc_greedy":"1f330","shortnames":[],"category":"food"},":chicken:":{"uc_base":"1f414","uc_output":"1f414","uc_match":"1f414","uc_greedy":"1f414","shortnames":[],"category":"nature"},":child:":{"uc_base":"1f9d2","uc_output":"1f9d2","uc_match":"1f9d2","uc_greedy":"1f9d2","shortnames":[],"category":"people"},":children_crossing:":{"uc_base":"1f6b8","uc_output":"1f6b8","uc_match":"1f6b8","uc_greedy":"1f6b8","shortnames":[],"category":"symbols"},":chipmunk:":{"uc_base":"1f43f","uc_output":"1f43f","uc_match":"1f43f-fe0f","uc_greedy":"1f43f-fe0f","shortnames":[],"category":"nature"},":chocolate_bar:":{"uc_base":"1f36b","uc_output":"1f36b","uc_match":"1f36b","uc_greedy":"1f36b","shortnames":[],"category":"food"},":chopsticks:":{"uc_base":"1f962","uc_output":"1f962","uc_match":"1f962","uc_greedy":"1f962","shortnames":[],"category":"food"},":christmas_tree:":{"uc_base":"1f384","uc_output":"1f384","uc_match":"1f384","uc_greedy":"1f384","shortnames":[],"category":"nature"},":cinema:":{"uc_base":"1f3a6","uc_output":"1f3a6","uc_match":"1f3a6","uc_greedy":"1f3a6","shortnames":[],"category":"symbols"},":circus_tent:":{"uc_base":"1f3aa","uc_output":"1f3aa","uc_match":"1f3aa","uc_greedy":"1f3aa","shortnames":[],"category":"activity"},":city_dusk:":{"uc_base":"1f306","uc_output":"1f306","uc_match":"1f306","uc_greedy":"1f306","shortnames":[],"category":"travel"},":city_sunset:":{"uc_base":"1f307","uc_output":"1f307","uc_match":"1f307","uc_greedy":"1f307","shortnames":[":city_sunrise:"],"category":"travel"},":cityscape:":{"uc_base":"1f3d9","uc_output":"1f3d9","uc_match":"1f3d9-fe0f","uc_greedy":"1f3d9-fe0f","shortnames":[],"category":"travel"},":cl:":{"uc_base":"1f191","uc_output":"1f191","uc_match":"1f191","uc_greedy":"1f191","shortnames":[],"category":"symbols"},":clap:":{"uc_base":"1f44f","uc_output":"1f44f","uc_match":"1f44f","uc_greedy":"1f44f","shortnames":[],"category":"people"},":clapper:":{"uc_base":"1f3ac","uc_output":"1f3ac","uc_match":"1f3ac-fe0f","uc_greedy":"1f3ac-fe0f","shortnames":[],"category":"activity"},":classical_building:":{"uc_base":"1f3db","uc_output":"1f3db","uc_match":"1f3db-fe0f","uc_greedy":"1f3db-fe0f","shortnames":[],"category":"travel"},":clipboard:":{"uc_base":"1f4cb","uc_output":"1f4cb","uc_match":"1f4cb-fe0f","uc_greedy":"1f4cb-fe0f","shortnames":[],"category":"objects"},":clock1030:":{"uc_base":"1f565","uc_output":"1f565","uc_match":"1f565-fe0f","uc_greedy":"1f565-fe0f","shortnames":[],"category":"symbols"},":clock10:":{"uc_base":"1f559","uc_output":"1f559","uc_match":"1f559-fe0f","uc_greedy":"1f559-fe0f","shortnames":[],"category":"symbols"},":clock1130:":{"uc_base":"1f566","uc_output":"1f566","uc_match":"1f566-fe0f","uc_greedy":"1f566-fe0f","shortnames":[],"category":"symbols"},":clock11:":{"uc_base":"1f55a","uc_output":"1f55a","uc_match":"1f55a-fe0f","uc_greedy":"1f55a-fe0f","shortnames":[],"category":"symbols"},":clock1230:":{"uc_base":"1f567","uc_output":"1f567","uc_match":"1f567-fe0f","uc_greedy":"1f567-fe0f","shortnames":[],"category":"symbols"},":clock12:":{"uc_base":"1f55b","uc_output":"1f55b","uc_match":"1f55b-fe0f","uc_greedy":"1f55b-fe0f","shortnames":[],"category":"symbols"},":clock130:":{"uc_base":"1f55c","uc_output":"1f55c","uc_match":"1f55c-fe0f","uc_greedy":"1f55c-fe0f","shortnames":[],"category":"symbols"},":clock1:":{"uc_base":"1f550","uc_output":"1f550","uc_match":"1f550-fe0f","uc_greedy":"1f550-fe0f","shortnames":[],"category":"symbols"},":clock230:":{"uc_base":"1f55d","uc_output":"1f55d","uc_match":"1f55d-fe0f","uc_greedy":"1f55d-fe0f","shortnames":[],"category":"symbols"},":clock2:":{"uc_base":"1f551","uc_output":"1f551","uc_match":"1f551-fe0f","uc_greedy":"1f551-fe0f","shortnames":[],"category":"symbols"},":clock330:":{"uc_base":"1f55e","uc_output":"1f55e","uc_match":"1f55e-fe0f","uc_greedy":"1f55e-fe0f","shortnames":[],"category":"symbols"},":clock3:":{"uc_base":"1f552","uc_output":"1f552","uc_match":"1f552-fe0f","uc_greedy":"1f552-fe0f","shortnames":[],"category":"symbols"},":clock430:":{"uc_base":"1f55f","uc_output":"1f55f","uc_match":"1f55f-fe0f","uc_greedy":"1f55f-fe0f","shortnames":[],"category":"symbols"},":clock4:":{"uc_base":"1f553","uc_output":"1f553","uc_match":"1f553-fe0f","uc_greedy":"1f553-fe0f","shortnames":[],"category":"symbols"},":clock530:":{"uc_base":"1f560","uc_output":"1f560","uc_match":"1f560-fe0f","uc_greedy":"1f560-fe0f","shortnames":[],"category":"symbols"},":clock5:":{"uc_base":"1f554","uc_output":"1f554","uc_match":"1f554-fe0f","uc_greedy":"1f554-fe0f","shortnames":[],"category":"symbols"},":clock630:":{"uc_base":"1f561","uc_output":"1f561","uc_match":"1f561-fe0f","uc_greedy":"1f561-fe0f","shortnames":[],"category":"symbols"},":clock6:":{"uc_base":"1f555","uc_output":"1f555","uc_match":"1f555-fe0f","uc_greedy":"1f555-fe0f","shortnames":[],"category":"symbols"},":clock730:":{"uc_base":"1f562","uc_output":"1f562","uc_match":"1f562-fe0f","uc_greedy":"1f562-fe0f","shortnames":[],"category":"symbols"},":clock7:":{"uc_base":"1f556","uc_output":"1f556","uc_match":"1f556-fe0f","uc_greedy":"1f556-fe0f","shortnames":[],"category":"symbols"},":clock830:":{"uc_base":"1f563","uc_output":"1f563","uc_match":"1f563-fe0f","uc_greedy":"1f563-fe0f","shortnames":[],"category":"symbols"},":clock8:":{"uc_base":"1f557","uc_output":"1f557","uc_match":"1f557-fe0f","uc_greedy":"1f557-fe0f","shortnames":[],"category":"symbols"},":clock930:":{"uc_base":"1f564","uc_output":"1f564","uc_match":"1f564-fe0f","uc_greedy":"1f564-fe0f","shortnames":[],"category":"symbols"},":clock9:":{"uc_base":"1f558","uc_output":"1f558","uc_match":"1f558-fe0f","uc_greedy":"1f558-fe0f","shortnames":[],"category":"symbols"},":clock:":{"uc_base":"1f570","uc_output":"1f570","uc_match":"1f570-fe0f","uc_greedy":"1f570-fe0f","shortnames":[":mantlepiece_clock:"],"category":"objects"},":closed_book:":{"uc_base":"1f4d5","uc_output":"1f4d5","uc_match":"1f4d5","uc_greedy":"1f4d5","shortnames":[],"category":"objects"},":closed_lock_with_key:":{"uc_base":"1f510","uc_output":"1f510","uc_match":"1f510","uc_greedy":"1f510","shortnames":[],"category":"objects"},":closed_umbrella:":{"uc_base":"1f302","uc_output":"1f302","uc_match":"1f302","uc_greedy":"1f302","shortnames":[],"category":"people"},":cloud_lightning:":{"uc_base":"1f329","uc_output":"1f329","uc_match":"1f329-fe0f","uc_greedy":"1f329-fe0f","shortnames":[":cloud_with_lightning:"],"category":"nature"},":cloud_rain:":{"uc_base":"1f327","uc_output":"1f327","uc_match":"1f327-fe0f","uc_greedy":"1f327-fe0f","shortnames":[":cloud_with_rain:"],"category":"nature"},":cloud_snow:":{"uc_base":"1f328","uc_output":"1f328","uc_match":"1f328-fe0f","uc_greedy":"1f328-fe0f","shortnames":[":cloud_with_snow:"],"category":"nature"},":cloud_tornado:":{"uc_base":"1f32a","uc_output":"1f32a","uc_match":"1f32a-fe0f","uc_greedy":"1f32a-fe0f","shortnames":[":cloud_with_tornado:"],"category":"nature"},":clown:":{"uc_base":"1f921","uc_output":"1f921","uc_match":"1f921","uc_greedy":"1f921","shortnames":[":clown_face:"],"category":"people"},":coat:":{"uc_base":"1f9e5","uc_output":"1f9e5","uc_match":"1f9e5","uc_greedy":"1f9e5","shortnames":[],"category":"people"},":cocktail:":{"uc_base":"1f378","uc_output":"1f378","uc_match":"1f378-fe0f","uc_greedy":"1f378-fe0f","shortnames":[],"category":"food"},":coconut:":{"uc_base":"1f965","uc_output":"1f965","uc_match":"1f965","uc_greedy":"1f965","shortnames":[],"category":"food"},":cold_sweat:":{"uc_base":"1f630","uc_output":"1f630","uc_match":"1f630","uc_greedy":"1f630","shortnames":[],"category":"people"},":compression:":{"uc_base":"1f5dc","uc_output":"1f5dc","uc_match":"1f5dc-fe0f","uc_greedy":"1f5dc-fe0f","shortnames":[],"category":"objects"},":computer:":{"uc_base":"1f4bb","uc_output":"1f4bb","uc_match":"1f4bb-fe0f","uc_greedy":"1f4bb-fe0f","shortnames":[],"category":"objects"},":confetti_ball:":{"uc_base":"1f38a","uc_output":"1f38a","uc_match":"1f38a","uc_greedy":"1f38a","shortnames":[],"category":"objects"},":confounded:":{"uc_base":"1f616","uc_output":"1f616","uc_match":"1f616","uc_greedy":"1f616","shortnames":[],"category":"people"},":confused:":{"uc_base":"1f615","uc_output":"1f615","uc_match":"1f615","uc_greedy":"1f615","shortnames":[],"category":"people"},":construction:":{"uc_base":"1f6a7","uc_output":"1f6a7","uc_match":"1f6a7","uc_greedy":"1f6a7","shortnames":[],"category":"travel"},":construction_site:":{"uc_base":"1f3d7","uc_output":"1f3d7","uc_match":"1f3d7-fe0f","uc_greedy":"1f3d7-fe0f","shortnames":[":building_construction:"],"category":"travel"},":construction_worker:":{"uc_base":"1f477","uc_output":"1f477","uc_match":"1f477","uc_greedy":"1f477","shortnames":[],"category":"people"},":control_knobs:":{"uc_base":"1f39b","uc_output":"1f39b","uc_match":"1f39b-fe0f","uc_greedy":"1f39b-fe0f","shortnames":[],"category":"objects"},":convenience_store:":{"uc_base":"1f3ea","uc_output":"1f3ea","uc_match":"1f3ea","uc_greedy":"1f3ea","shortnames":[],"category":"travel"},":cookie:":{"uc_base":"1f36a","uc_output":"1f36a","uc_match":"1f36a","uc_greedy":"1f36a","shortnames":[],"category":"food"},":cooking:":{"uc_base":"1f373","uc_output":"1f373","uc_match":"1f373","uc_greedy":"1f373","shortnames":[],"category":"food"},":cool:":{"uc_base":"1f192","uc_output":"1f192","uc_match":"1f192","uc_greedy":"1f192","shortnames":[],"category":"symbols"},":corn:":{"uc_base":"1f33d","uc_output":"1f33d","uc_match":"1f33d","uc_greedy":"1f33d","shortnames":[],"category":"food"},":couch:":{"uc_base":"1f6cb","uc_output":"1f6cb","uc_match":"1f6cb-fe0f","uc_greedy":"1f6cb-fe0f","shortnames":[":couch_and_lamp:"],"category":"objects"},":couple:":{"uc_base":"1f46b","uc_output":"1f46b","uc_match":"1f46b","uc_greedy":"1f46b","shortnames":[],"category":"people"},":couple_with_heart:":{"uc_base":"1f491","uc_output":"1f491","uc_match":"1f491","uc_greedy":"1f491","shortnames":[],"category":"people"},":couplekiss:":{"uc_base":"1f48f","uc_output":"1f48f","uc_match":"1f48f","uc_greedy":"1f48f","shortnames":[],"category":"people"},":cow2:":{"uc_base":"1f404","uc_output":"1f404","uc_match":"1f404","uc_greedy":"1f404","shortnames":[],"category":"nature"},":cow:":{"uc_base":"1f42e","uc_output":"1f42e","uc_match":"1f42e","uc_greedy":"1f42e","shortnames":[],"category":"nature"},":cowboy:":{"uc_base":"1f920","uc_output":"1f920","uc_match":"1f920","uc_greedy":"1f920","shortnames":[":face_with_cowboy_hat:"],"category":"people"},":crab:":{"uc_base":"1f980","uc_output":"1f980","uc_match":"1f980","uc_greedy":"1f980","shortnames":[],"category":"nature"},":crayon:":{"uc_base":"1f58d","uc_output":"1f58d","uc_match":"1f58d-fe0f","uc_greedy":"1f58d-fe0f","shortnames":[":lower_left_crayon:"],"category":"objects"},":crazy_face:":{"uc_base":"1f92a","uc_output":"1f92a","uc_match":"1f92a","uc_greedy":"1f92a","shortnames":[],"category":"people"},":credit_card:":{"uc_base":"1f4b3","uc_output":"1f4b3","uc_match":"1f4b3-fe0f","uc_greedy":"1f4b3-fe0f","shortnames":[],"category":"objects"},":crescent_moon:":{"uc_base":"1f319","uc_output":"1f319","uc_match":"1f319","uc_greedy":"1f319","shortnames":[],"category":"nature"},":cricket:":{"uc_base":"1f997","uc_output":"1f997","uc_match":"1f997","uc_greedy":"1f997","shortnames":[],"category":"nature"},":cricket_game:":{"uc_base":"1f3cf","uc_output":"1f3cf","uc_match":"1f3cf","uc_greedy":"1f3cf","shortnames":[":cricket_bat_ball:"],"category":"activity"},":crocodile:":{"uc_base":"1f40a","uc_output":"1f40a","uc_match":"1f40a","uc_greedy":"1f40a","shortnames":[],"category":"nature"},":croissant:":{"uc_base":"1f950","uc_output":"1f950","uc_match":"1f950","uc_greedy":"1f950","shortnames":[],"category":"food"},":crossed_flags:":{"uc_base":"1f38c","uc_output":"1f38c","uc_match":"1f38c","uc_greedy":"1f38c","shortnames":[],"category":"flags"},":crown:":{"uc_base":"1f451","uc_output":"1f451","uc_match":"1f451","uc_greedy":"1f451","shortnames":[],"category":"people"},":cruise_ship:":{"uc_base":"1f6f3","uc_output":"1f6f3","uc_match":"1f6f3-fe0f","uc_greedy":"1f6f3-fe0f","shortnames":[":passenger_ship:"],"category":"travel"},":cry:":{"uc_base":"1f622","uc_output":"1f622","uc_match":"1f622","uc_greedy":"1f622","shortnames":[],"category":"people"},":crying_cat_face:":{"uc_base":"1f63f","uc_output":"1f63f","uc_match":"1f63f","uc_greedy":"1f63f","shortnames":[],"category":"people"},":crystal_ball:":{"uc_base":"1f52e","uc_output":"1f52e","uc_match":"1f52e","uc_greedy":"1f52e","shortnames":[],"category":"objects"},":cucumber:":{"uc_base":"1f952","uc_output":"1f952","uc_match":"1f952","uc_greedy":"1f952","shortnames":[],"category":"food"},":cup_with_straw:":{"uc_base":"1f964","uc_output":"1f964","uc_match":"1f964","uc_greedy":"1f964","shortnames":[],"category":"food"},":cupid:":{"uc_base":"1f498","uc_output":"1f498","uc_match":"1f498","uc_greedy":"1f498","shortnames":[],"category":"symbols"},":curling_stone:":{"uc_base":"1f94c","uc_output":"1f94c","uc_match":"1f94c","uc_greedy":"1f94c","shortnames":[],"category":"activity"},":currency_exchange:":{"uc_base":"1f4b1","uc_output":"1f4b1","uc_match":"1f4b1","uc_greedy":"1f4b1","shortnames":[],"category":"symbols"},":curry:":{"uc_base":"1f35b","uc_output":"1f35b","uc_match":"1f35b","uc_greedy":"1f35b","shortnames":[],"category":"food"},":custard:":{"uc_base":"1f36e","uc_output":"1f36e","uc_match":"1f36e","uc_greedy":"1f36e","shortnames":[":pudding:",":flan:"],"category":"food"},":customs:":{"uc_base":"1f6c3","uc_output":"1f6c3","uc_match":"1f6c3","uc_greedy":"1f6c3","shortnames":[],"category":"symbols"},":cut_of_meat:":{"uc_base":"1f969","uc_output":"1f969","uc_match":"1f969","uc_greedy":"1f969","shortnames":[],"category":"food"},":cyclone:":{"uc_base":"1f300","uc_output":"1f300","uc_match":"1f300","uc_greedy":"1f300","shortnames":[],"category":"symbols"},":dagger:":{"uc_base":"1f5e1","uc_output":"1f5e1","uc_match":"1f5e1-fe0f","uc_greedy":"1f5e1-fe0f","shortnames":[":dagger_knife:"],"category":"objects"},":dancer:":{"uc_base":"1f483","uc_output":"1f483","uc_match":"1f483","uc_greedy":"1f483","shortnames":[],"category":"people"},":dango:":{"uc_base":"1f361","uc_output":"1f361","uc_match":"1f361","uc_greedy":"1f361","shortnames":[],"category":"food"},":dark_sunglasses:":{"uc_base":"1f576","uc_output":"1f576","uc_match":"1f576-fe0f","uc_greedy":"1f576-fe0f","shortnames":[],"category":"people"},":dart:":{"uc_base":"1f3af","uc_output":"1f3af","uc_match":"1f3af","uc_greedy":"1f3af","shortnames":[],"category":"activity"},":dash:":{"uc_base":"1f4a8","uc_output":"1f4a8","uc_match":"1f4a8","uc_greedy":"1f4a8","shortnames":[],"category":"nature"},":date:":{"uc_base":"1f4c5","uc_output":"1f4c5","uc_match":"1f4c5","uc_greedy":"1f4c5","shortnames":[],"category":"objects"},":deciduous_tree:":{"uc_base":"1f333","uc_output":"1f333","uc_match":"1f333","uc_greedy":"1f333","shortnames":[],"category":"nature"},":deer:":{"uc_base":"1f98c","uc_output":"1f98c","uc_match":"1f98c","uc_greedy":"1f98c","shortnames":[],"category":"nature"},":department_store:":{"uc_base":"1f3ec","uc_output":"1f3ec","uc_match":"1f3ec","uc_greedy":"1f3ec","shortnames":[],"category":"travel"},":desert:":{"uc_base":"1f3dc","uc_output":"1f3dc","uc_match":"1f3dc-fe0f","uc_greedy":"1f3dc-fe0f","shortnames":[],"category":"travel"},":desktop:":{"uc_base":"1f5a5","uc_output":"1f5a5","uc_match":"1f5a5-fe0f","uc_greedy":"1f5a5-fe0f","shortnames":[":desktop_computer:"],"category":"objects"},":detective:":{"uc_base":"1f575","uc_output":"1f575","uc_match":"1f575-fe0f","uc_greedy":"1f575-fe0f","shortnames":[":spy:",":sleuth_or_spy:"],"category":"people"},":diamond_shape_with_a_dot_inside:":{"uc_base":"1f4a0","uc_output":"1f4a0","uc_match":"1f4a0","uc_greedy":"1f4a0","shortnames":[],"category":"symbols"},":disappointed:":{"uc_base":"1f61e","uc_output":"1f61e","uc_match":"1f61e","uc_greedy":"1f61e","shortnames":[],"category":"people"},":disappointed_relieved:":{"uc_base":"1f625","uc_output":"1f625","uc_match":"1f625","uc_greedy":"1f625","shortnames":[],"category":"people"},":dividers:":{"uc_base":"1f5c2","uc_output":"1f5c2","uc_match":"1f5c2-fe0f","uc_greedy":"1f5c2-fe0f","shortnames":[":card_index_dividers:"],"category":"objects"},":dizzy:":{"uc_base":"1f4ab","uc_output":"1f4ab","uc_match":"1f4ab","uc_greedy":"1f4ab","shortnames":[],"category":"nature"},":dizzy_face:":{"uc_base":"1f635","uc_output":"1f635","uc_match":"1f635","uc_greedy":"1f635","shortnames":[],"category":"people"},":do_not_litter:":{"uc_base":"1f6af","uc_output":"1f6af","uc_match":"1f6af","uc_greedy":"1f6af","shortnames":[],"category":"symbols"},":dog2:":{"uc_base":"1f415","uc_output":"1f415","uc_match":"1f415-fe0f","uc_greedy":"1f415-fe0f","shortnames":[],"category":"nature"},":dog:":{"uc_base":"1f436","uc_output":"1f436","uc_match":"1f436","uc_greedy":"1f436","shortnames":[],"category":"nature"},":dollar:":{"uc_base":"1f4b5","uc_output":"1f4b5","uc_match":"1f4b5","uc_greedy":"1f4b5","shortnames":[],"category":"objects"},":dolls:":{"uc_base":"1f38e","uc_output":"1f38e","uc_match":"1f38e","uc_greedy":"1f38e","shortnames":[],"category":"objects"},":dolphin:":{"uc_base":"1f42c","uc_output":"1f42c","uc_match":"1f42c","uc_greedy":"1f42c","shortnames":[],"category":"nature"},":door:":{"uc_base":"1f6aa","uc_output":"1f6aa","uc_match":"1f6aa","uc_greedy":"1f6aa","shortnames":[],"category":"objects"},":doughnut:":{"uc_base":"1f369","uc_output":"1f369","uc_match":"1f369","uc_greedy":"1f369","shortnames":[],"category":"food"},":dove:":{"uc_base":"1f54a","uc_output":"1f54a","uc_match":"1f54a-fe0f","uc_greedy":"1f54a-fe0f","shortnames":[":dove_of_peace:"],"category":"nature"},":dragon:":{"uc_base":"1f409","uc_output":"1f409","uc_match":"1f409","uc_greedy":"1f409","shortnames":[],"category":"nature"},":dragon_face:":{"uc_base":"1f432","uc_output":"1f432","uc_match":"1f432","uc_greedy":"1f432","shortnames":[],"category":"nature"},":dress:":{"uc_base":"1f457","uc_output":"1f457","uc_match":"1f457","uc_greedy":"1f457","shortnames":[],"category":"people"},":dromedary_camel:":{"uc_base":"1f42a","uc_output":"1f42a","uc_match":"1f42a","uc_greedy":"1f42a","shortnames":[],"category":"nature"},":drooling_face:":{"uc_base":"1f924","uc_output":"1f924","uc_match":"1f924","uc_greedy":"1f924","shortnames":[":drool:"],"category":"people"},":droplet:":{"uc_base":"1f4a7","uc_output":"1f4a7","uc_match":"1f4a7","uc_greedy":"1f4a7","shortnames":[],"category":"nature"},":drum:":{"uc_base":"1f941","uc_output":"1f941","uc_match":"1f941","uc_greedy":"1f941","shortnames":[":drum_with_drumsticks:"],"category":"activity"},":duck:":{"uc_base":"1f986","uc_output":"1f986","uc_match":"1f986","uc_greedy":"1f986","shortnames":[],"category":"nature"},":dumpling:":{"uc_base":"1f95f","uc_output":"1f95f","uc_match":"1f95f","uc_greedy":"1f95f","shortnames":[],"category":"food"},":dvd:":{"uc_base":"1f4c0","uc_output":"1f4c0","uc_match":"1f4c0","uc_greedy":"1f4c0","shortnames":[],"category":"objects"},":e-mail:":{"uc_base":"1f4e7","uc_output":"1f4e7","uc_match":"1f4e7","uc_greedy":"1f4e7","shortnames":[":email:"],"category":"objects"},":eagle:":{"uc_base":"1f985","uc_output":"1f985","uc_match":"1f985","uc_greedy":"1f985","shortnames":[],"category":"nature"},":ear:":{"uc_base":"1f442","uc_output":"1f442","uc_match":"1f442-fe0f","uc_greedy":"1f442-fe0f","shortnames":[],"category":"people"},":ear_of_rice:":{"uc_base":"1f33e","uc_output":"1f33e","uc_match":"1f33e","uc_greedy":"1f33e","shortnames":[],"category":"nature"},":earth_africa:":{"uc_base":"1f30d","uc_output":"1f30d","uc_match":"1f30d-fe0f","uc_greedy":"1f30d-fe0f","shortnames":[],"category":"nature"},":earth_americas:":{"uc_base":"1f30e","uc_output":"1f30e","uc_match":"1f30e-fe0f","uc_greedy":"1f30e-fe0f","shortnames":[],"category":"nature"},":earth_asia:":{"uc_base":"1f30f","uc_output":"1f30f","uc_match":"1f30f-fe0f","uc_greedy":"1f30f-fe0f","shortnames":[],"category":"nature"},":egg:":{"uc_base":"1f95a","uc_output":"1f95a","uc_match":"1f95a","uc_greedy":"1f95a","shortnames":[],"category":"food"},":eggplant:":{"uc_base":"1f346","uc_output":"1f346","uc_match":"1f346","uc_greedy":"1f346","shortnames":[],"category":"food"},":electric_plug:":{"uc_base":"1f50c","uc_output":"1f50c","uc_match":"1f50c","uc_greedy":"1f50c","shortnames":[],"category":"objects"},":elephant:":{"uc_base":"1f418","uc_output":"1f418","uc_match":"1f418","uc_greedy":"1f418","shortnames":[],"category":"nature"},":elf:":{"uc_base":"1f9dd","uc_output":"1f9dd","uc_match":"1f9dd","uc_greedy":"1f9dd","shortnames":[],"category":"people"},":end:":{"uc_base":"1f51a","uc_output":"1f51a","uc_match":"1f51a","uc_greedy":"1f51a","shortnames":[],"category":"symbols"},":envelope_with_arrow:":{"uc_base":"1f4e9","uc_output":"1f4e9","uc_match":"1f4e9","uc_greedy":"1f4e9","shortnames":[],"category":"objects"},":euro:":{"uc_base":"1f4b6","uc_output":"1f4b6","uc_match":"1f4b6","uc_greedy":"1f4b6","shortnames":[],"category":"objects"},":european_castle:":{"uc_base":"1f3f0","uc_output":"1f3f0","uc_match":"1f3f0","uc_greedy":"1f3f0","shortnames":[],"category":"travel"},":european_post_office:":{"uc_base":"1f3e4","uc_output":"1f3e4","uc_match":"1f3e4","uc_greedy":"1f3e4","shortnames":[],"category":"travel"},":evergreen_tree:":{"uc_base":"1f332","uc_output":"1f332","uc_match":"1f332","uc_greedy":"1f332","shortnames":[],"category":"nature"},":exploding_head:":{"uc_base":"1f92f","uc_output":"1f92f","uc_match":"1f92f","uc_greedy":"1f92f","shortnames":[],"category":"people"},":expressionless:":{"uc_base":"1f611","uc_output":"1f611","uc_match":"1f611","uc_greedy":"1f611","shortnames":[],"category":"people"},":eye:":{"uc_base":"1f441","uc_output":"1f441","uc_match":"1f441-fe0f","uc_greedy":"1f441-fe0f","shortnames":[],"category":"people"},":eyeglasses:":{"uc_base":"1f453","uc_output":"1f453","uc_match":"1f453-fe0f","uc_greedy":"1f453-fe0f","shortnames":[],"category":"people"},":eyes:":{"uc_base":"1f440","uc_output":"1f440","uc_match":"1f440","uc_greedy":"1f440","shortnames":[],"category":"people"},":face_vomiting:":{"uc_base":"1f92e","uc_output":"1f92e","uc_match":"1f92e","uc_greedy":"1f92e","shortnames":[],"category":"people"},":face_with_hand_over_mouth:":{"uc_base":"1f92d","uc_output":"1f92d","uc_match":"1f92d","uc_greedy":"1f92d","shortnames":[],"category":"people"},":face_with_monocle:":{"uc_base":"1f9d0","uc_output":"1f9d0","uc_match":"1f9d0","uc_greedy":"1f9d0","shortnames":[],"category":"people"},":face_with_raised_eyebrow:":{"uc_base":"1f928","uc_output":"1f928","uc_match":"1f928","uc_greedy":"1f928","shortnames":[],"category":"people"},":face_with_symbols_over_mouth:":{"uc_base":"1f92c","uc_output":"1f92c","uc_match":"1f92c","uc_greedy":"1f92c","shortnames":[],"category":"people"},":factory:":{"uc_base":"1f3ed","uc_output":"1f3ed","uc_match":"1f3ed-fe0f","uc_greedy":"1f3ed-fe0f","shortnames":[],"category":"travel"},":fairy:":{"uc_base":"1f9da","uc_output":"1f9da","uc_match":"1f9da","uc_greedy":"1f9da","shortnames":[],"category":"people"},":fallen_leaf:":{"uc_base":"1f342","uc_output":"1f342","uc_match":"1f342","uc_greedy":"1f342","shortnames":[],"category":"nature"},":family:":{"uc_base":"1f46a","uc_output":"1f46a","uc_match":"1f46a-fe0f","uc_greedy":"1f46a-fe0f","shortnames":[],"category":"people"},":fax:":{"uc_base":"1f4e0","uc_output":"1f4e0","uc_match":"1f4e0","uc_greedy":"1f4e0","shortnames":[],"category":"objects"},":fearful:":{"uc_base":"1f628","uc_output":"1f628","uc_match":"1f628","uc_greedy":"1f628","shortnames":[],"category":"people"},":feet:":{"uc_base":"1f43e","uc_output":"1f43e","uc_match":"1f43e","uc_greedy":"1f43e","shortnames":[":paw_prints:"],"category":"nature"},":ferris_wheel:":{"uc_base":"1f3a1","uc_output":"1f3a1","uc_match":"1f3a1","uc_greedy":"1f3a1","shortnames":[],"category":"travel"},":field_hockey:":{"uc_base":"1f3d1","uc_output":"1f3d1","uc_match":"1f3d1","uc_greedy":"1f3d1","shortnames":[],"category":"activity"},":file_cabinet:":{"uc_base":"1f5c4","uc_output":"1f5c4","uc_match":"1f5c4-fe0f","uc_greedy":"1f5c4-fe0f","shortnames":[],"category":"objects"},":file_folder:":{"uc_base":"1f4c1","uc_output":"1f4c1","uc_match":"1f4c1","uc_greedy":"1f4c1","shortnames":[],"category":"objects"},":film_frames:":{"uc_base":"1f39e","uc_output":"1f39e","uc_match":"1f39e-fe0f","uc_greedy":"1f39e-fe0f","shortnames":[],"category":"objects"},":fingers_crossed:":{"uc_base":"1f91e","uc_output":"1f91e","uc_match":"1f91e","uc_greedy":"1f91e","shortnames":[":hand_with_index_and_middle_finger_crossed:"],"category":"people"},":fire:":{"uc_base":"1f525","uc_output":"1f525","uc_match":"1f525","uc_greedy":"1f525","shortnames":[":flame:"],"category":"nature"},":fire_engine:":{"uc_base":"1f692","uc_output":"1f692","uc_match":"1f692","uc_greedy":"1f692","shortnames":[],"category":"travel"},":fireworks:":{"uc_base":"1f386","uc_output":"1f386","uc_match":"1f386","uc_greedy":"1f386","shortnames":[],"category":"travel"},":first_place:":{"uc_base":"1f947","uc_output":"1f947","uc_match":"1f947","uc_greedy":"1f947","shortnames":[":first_place_medal:"],"category":"activity"},":first_quarter_moon:":{"uc_base":"1f313","uc_output":"1f313","uc_match":"1f313","uc_greedy":"1f313","shortnames":[],"category":"nature"},":first_quarter_moon_with_face:":{"uc_base":"1f31b","uc_output":"1f31b","uc_match":"1f31b","uc_greedy":"1f31b","shortnames":[],"category":"nature"},":fish:":{"uc_base":"1f41f","uc_output":"1f41f","uc_match":"1f41f-fe0f","uc_greedy":"1f41f-fe0f","shortnames":[],"category":"nature"},":fish_cake:":{"uc_base":"1f365","uc_output":"1f365","uc_match":"1f365","uc_greedy":"1f365","shortnames":[],"category":"food"},":fishing_pole_and_fish:":{"uc_base":"1f3a3","uc_output":"1f3a3","uc_match":"1f3a3","uc_greedy":"1f3a3","shortnames":[],"category":"activity"},":flag_black:":{"uc_base":"1f3f4","uc_output":"1f3f4","uc_match":"1f3f4","uc_greedy":"1f3f4","shortnames":[":waving_black_flag:"],"category":"flags"},":flag_white:":{"uc_base":"1f3f3","uc_output":"1f3f3","uc_match":"1f3f3-fe0f","uc_greedy":"1f3f3-fe0f","shortnames":[":waving_white_flag:"],"category":"flags"},":flags:":{"uc_base":"1f38f","uc_output":"1f38f","uc_match":"1f38f","uc_greedy":"1f38f","shortnames":[],"category":"objects"},":flashlight:":{"uc_base":"1f526","uc_output":"1f526","uc_match":"1f526","uc_greedy":"1f526","shortnames":[],"category":"objects"},":floppy_disk:":{"uc_base":"1f4be","uc_output":"1f4be","uc_match":"1f4be","uc_greedy":"1f4be","shortnames":[],"category":"objects"},":flower_playing_cards:":{"uc_base":"1f3b4","uc_output":"1f3b4","uc_match":"1f3b4","uc_greedy":"1f3b4","shortnames":[],"category":"symbols"},":flushed:":{"uc_base":"1f633","uc_output":"1f633","uc_match":"1f633","uc_greedy":"1f633","shortnames":[],"category":"people"},":flying_saucer:":{"uc_base":"1f6f8","uc_output":"1f6f8","uc_match":"1f6f8","uc_greedy":"1f6f8","shortnames":[],"category":"travel"},":fog:":{"uc_base":"1f32b","uc_output":"1f32b","uc_match":"1f32b-fe0f","uc_greedy":"1f32b-fe0f","shortnames":[],"category":"nature"},":foggy:":{"uc_base":"1f301","uc_output":"1f301","uc_match":"1f301","uc_greedy":"1f301","shortnames":[],"category":"travel"},":football:":{"uc_base":"1f3c8","uc_output":"1f3c8","uc_match":"1f3c8","uc_greedy":"1f3c8","shortnames":[],"category":"activity"},":footprints:":{"uc_base":"1f463","uc_output":"1f463","uc_match":"1f463","uc_greedy":"1f463","shortnames":[],"category":"people"},":fork_and_knife:":{"uc_base":"1f374","uc_output":"1f374","uc_match":"1f374","uc_greedy":"1f374","shortnames":[],"category":"food"},":fork_knife_plate:":{"uc_base":"1f37d","uc_output":"1f37d","uc_match":"1f37d-fe0f","uc_greedy":"1f37d-fe0f","shortnames":[":fork_and_knife_with_plate:"],"category":"food"},":fortune_cookie:":{"uc_base":"1f960","uc_output":"1f960","uc_match":"1f960","uc_greedy":"1f960","shortnames":[],"category":"food"},":four_leaf_clover:":{"uc_base":"1f340","uc_output":"1f340","uc_match":"1f340","uc_greedy":"1f340","shortnames":[],"category":"nature"},":fox:":{"uc_base":"1f98a","uc_output":"1f98a","uc_match":"1f98a","uc_greedy":"1f98a","shortnames":[":fox_face:"],"category":"nature"},":frame_photo:":{"uc_base":"1f5bc","uc_output":"1f5bc","uc_match":"1f5bc-fe0f","uc_greedy":"1f5bc-fe0f","shortnames":[":frame_with_picture:"],"category":"objects"},":free:":{"uc_base":"1f193","uc_output":"1f193","uc_match":"1f193","uc_greedy":"1f193","shortnames":[],"category":"symbols"},":french_bread:":{"uc_base":"1f956","uc_output":"1f956","uc_match":"1f956","uc_greedy":"1f956","shortnames":[":baguette_bread:"],"category":"food"},":fried_shrimp:":{"uc_base":"1f364","uc_output":"1f364","uc_match":"1f364","uc_greedy":"1f364","shortnames":[],"category":"food"},":fries:":{"uc_base":"1f35f","uc_output":"1f35f","uc_match":"1f35f","uc_greedy":"1f35f","shortnames":[],"category":"food"},":frog:":{"uc_base":"1f438","uc_output":"1f438","uc_match":"1f438","uc_greedy":"1f438","shortnames":[],"category":"nature"},":frowning:":{"uc_base":"1f626","uc_output":"1f626","uc_match":"1f626","uc_greedy":"1f626","shortnames":[],"category":"people"},":full_moon:":{"uc_base":"1f315","uc_output":"1f315","uc_match":"1f315-fe0f","uc_greedy":"1f315-fe0f","shortnames":[],"category":"nature"},":full_moon_with_face:":{"uc_base":"1f31d","uc_output":"1f31d","uc_match":"1f31d","uc_greedy":"1f31d","shortnames":[],"category":"nature"},":game_die:":{"uc_base":"1f3b2","uc_output":"1f3b2","uc_match":"1f3b2","uc_greedy":"1f3b2","shortnames":[],"category":"activity"},":gem:":{"uc_base":"1f48e","uc_output":"1f48e","uc_match":"1f48e","uc_greedy":"1f48e","shortnames":[],"category":"objects"},":genie:":{"uc_base":"1f9de","uc_output":"1f9de","uc_match":"1f9de","uc_greedy":"1f9de","shortnames":[],"category":"people"},":ghost:":{"uc_base":"1f47b","uc_output":"1f47b","uc_match":"1f47b","uc_greedy":"1f47b","shortnames":[],"category":"people"},":gift:":{"uc_base":"1f381","uc_output":"1f381","uc_match":"1f381","uc_greedy":"1f381","shortnames":[],"category":"objects"},":gift_heart:":{"uc_base":"1f49d","uc_output":"1f49d","uc_match":"1f49d","uc_greedy":"1f49d","shortnames":[],"category":"symbols"},":giraffe:":{"uc_base":"1f992","uc_output":"1f992","uc_match":"1f992","uc_greedy":"1f992","shortnames":[],"category":"nature"},":girl:":{"uc_base":"1f467","uc_output":"1f467","uc_match":"1f467","uc_greedy":"1f467","shortnames":[],"category":"people"},":globe_with_meridians:":{"uc_base":"1f310","uc_output":"1f310","uc_match":"1f310","uc_greedy":"1f310","shortnames":[],"category":"symbols"},":gloves:":{"uc_base":"1f9e4","uc_output":"1f9e4","uc_match":"1f9e4","uc_greedy":"1f9e4","shortnames":[],"category":"people"},":goal:":{"uc_base":"1f945","uc_output":"1f945","uc_match":"1f945","uc_greedy":"1f945","shortnames":[":goal_net:"],"category":"activity"},":goat:":{"uc_base":"1f410","uc_output":"1f410","uc_match":"1f410","uc_greedy":"1f410","shortnames":[],"category":"nature"},":gorilla:":{"uc_base":"1f98d","uc_output":"1f98d","uc_match":"1f98d","uc_greedy":"1f98d","shortnames":[],"category":"nature"},":grapes:":{"uc_base":"1f347","uc_output":"1f347","uc_match":"1f347","uc_greedy":"1f347","shortnames":[],"category":"food"},":green_apple:":{"uc_base":"1f34f","uc_output":"1f34f","uc_match":"1f34f","uc_greedy":"1f34f","shortnames":[],"category":"food"},":green_book:":{"uc_base":"1f4d7","uc_output":"1f4d7","uc_match":"1f4d7","uc_greedy":"1f4d7","shortnames":[],"category":"objects"},":green_heart:":{"uc_base":"1f49a","uc_output":"1f49a","uc_match":"1f49a","uc_greedy":"1f49a","shortnames":[],"category":"symbols"},":grimacing:":{"uc_base":"1f62c","uc_output":"1f62c","uc_match":"1f62c","uc_greedy":"1f62c","shortnames":[],"category":"people"},":grin:":{"uc_base":"1f601","uc_output":"1f601","uc_match":"1f601","uc_greedy":"1f601","shortnames":[],"category":"people"},":grinning:":{"uc_base":"1f600","uc_output":"1f600","uc_match":"1f600","uc_greedy":"1f600","shortnames":[],"category":"people"},":guard:":{"uc_base":"1f482","uc_output":"1f482","uc_match":"1f482","uc_greedy":"1f482","shortnames":[":guardsman:"],"category":"people"},":guitar:":{"uc_base":"1f3b8","uc_output":"1f3b8","uc_match":"1f3b8","uc_greedy":"1f3b8","shortnames":[],"category":"activity"},":gun:":{"uc_base":"1f52b","uc_output":"1f52b","uc_match":"1f52b","uc_greedy":"1f52b","shortnames":[],"category":"objects"},":hamburger:":{"uc_base":"1f354","uc_output":"1f354","uc_match":"1f354","uc_greedy":"1f354","shortnames":[],"category":"food"},":hammer:":{"uc_base":"1f528","uc_output":"1f528","uc_match":"1f528","uc_greedy":"1f528","shortnames":[],"category":"objects"},":hamster:":{"uc_base":"1f439","uc_output":"1f439","uc_match":"1f439","uc_greedy":"1f439","shortnames":[],"category":"nature"},":hand_splayed:":{"uc_base":"1f590","uc_output":"1f590","uc_match":"1f590-fe0f","uc_greedy":"1f590-fe0f","shortnames":[":raised_hand_with_fingers_splayed:"],"category":"people"},":handbag:":{"uc_base":"1f45c","uc_output":"1f45c","uc_match":"1f45c","uc_greedy":"1f45c","shortnames":[],"category":"people"},":handshake:":{"uc_base":"1f91d","uc_output":"1f91d","uc_match":"1f91d","uc_greedy":"1f91d","shortnames":[":shaking_hands:"],"category":"people"},":hatched_chick:":{"uc_base":"1f425","uc_output":"1f425","uc_match":"1f425","uc_greedy":"1f425","shortnames":[],"category":"nature"},":hatching_chick:":{"uc_base":"1f423","uc_output":"1f423","uc_match":"1f423","uc_greedy":"1f423","shortnames":[],"category":"nature"},":head_bandage:":{"uc_base":"1f915","uc_output":"1f915","uc_match":"1f915","uc_greedy":"1f915","shortnames":[":face_with_head_bandage:"],"category":"people"},":headphones:":{"uc_base":"1f3a7","uc_output":"1f3a7","uc_match":"1f3a7-fe0f","uc_greedy":"1f3a7-fe0f","shortnames":[],"category":"activity"},":hear_no_evil:":{"uc_base":"1f649","uc_output":"1f649","uc_match":"1f649","uc_greedy":"1f649","shortnames":[],"category":"nature"},":heart_decoration:":{"uc_base":"1f49f","uc_output":"1f49f","uc_match":"1f49f","uc_greedy":"1f49f","shortnames":[],"category":"symbols"},":heart_eyes:":{"uc_base":"1f60d","uc_output":"1f60d","uc_match":"1f60d","uc_greedy":"1f60d","shortnames":[],"category":"people"},":heart_eyes_cat:":{"uc_base":"1f63b","uc_output":"1f63b","uc_match":"1f63b","uc_greedy":"1f63b","shortnames":[],"category":"people"},":heartbeat:":{"uc_base":"1f493","uc_output":"1f493","uc_match":"1f493","uc_greedy":"1f493","shortnames":[],"category":"symbols"},":heartpulse:":{"uc_base":"1f497","uc_output":"1f497","uc_match":"1f497","uc_greedy":"1f497","shortnames":[],"category":"symbols"},":heavy_dollar_sign:":{"uc_base":"1f4b2","uc_output":"1f4b2","uc_match":"1f4b2","uc_greedy":"1f4b2","shortnames":[],"category":"symbols"},":hedgehog:":{"uc_base":"1f994","uc_output":"1f994","uc_match":"1f994","uc_greedy":"1f994","shortnames":[],"category":"nature"},":helicopter:":{"uc_base":"1f681","uc_output":"1f681","uc_match":"1f681","uc_greedy":"1f681","shortnames":[],"category":"travel"},":herb:":{"uc_base":"1f33f","uc_output":"1f33f","uc_match":"1f33f","uc_greedy":"1f33f","shortnames":[],"category":"nature"},":hibiscus:":{"uc_base":"1f33a","uc_output":"1f33a","uc_match":"1f33a","uc_greedy":"1f33a","shortnames":[],"category":"nature"},":high_brightness:":{"uc_base":"1f506","uc_output":"1f506","uc_match":"1f506","uc_greedy":"1f506","shortnames":[],"category":"symbols"},":high_heel:":{"uc_base":"1f460","uc_output":"1f460","uc_match":"1f460","uc_greedy":"1f460","shortnames":[],"category":"people"},":hockey:":{"uc_base":"1f3d2","uc_output":"1f3d2","uc_match":"1f3d2","uc_greedy":"1f3d2","shortnames":[],"category":"activity"},":hole:":{"uc_base":"1f573","uc_output":"1f573","uc_match":"1f573-fe0f","uc_greedy":"1f573-fe0f","shortnames":[],"category":"objects"},":homes:":{"uc_base":"1f3d8","uc_output":"1f3d8","uc_match":"1f3d8-fe0f","uc_greedy":"1f3d8-fe0f","shortnames":[":house_buildings:"],"category":"travel"},":honey_pot:":{"uc_base":"1f36f","uc_output":"1f36f","uc_match":"1f36f","uc_greedy":"1f36f","shortnames":[],"category":"food"},":horse:":{"uc_base":"1f434","uc_output":"1f434","uc_match":"1f434","uc_greedy":"1f434","shortnames":[],"category":"nature"},":horse_racing:":{"uc_base":"1f3c7","uc_output":"1f3c7","uc_match":"1f3c7","uc_greedy":"1f3c7","shortnames":[],"category":"activity"},":hospital:":{"uc_base":"1f3e5","uc_output":"1f3e5","uc_match":"1f3e5","uc_greedy":"1f3e5","shortnames":[],"category":"travel"},":hot_pepper:":{"uc_base":"1f336","uc_output":"1f336","uc_match":"1f336-fe0f","uc_greedy":"1f336-fe0f","shortnames":[],"category":"food"},":hotdog:":{"uc_base":"1f32d","uc_output":"1f32d","uc_match":"1f32d","uc_greedy":"1f32d","shortnames":[":hot_dog:"],"category":"food"},":hotel:":{"uc_base":"1f3e8","uc_output":"1f3e8","uc_match":"1f3e8","uc_greedy":"1f3e8","shortnames":[],"category":"travel"},":house:":{"uc_base":"1f3e0","uc_output":"1f3e0","uc_match":"1f3e0-fe0f","uc_greedy":"1f3e0-fe0f","shortnames":[],"category":"travel"},":house_abandoned:":{"uc_base":"1f3da","uc_output":"1f3da","uc_match":"1f3da-fe0f","uc_greedy":"1f3da-fe0f","shortnames":[":derelict_house_building:"],"category":"travel"},":house_with_garden:":{"uc_base":"1f3e1","uc_output":"1f3e1","uc_match":"1f3e1","uc_greedy":"1f3e1","shortnames":[],"category":"travel"},":hugging:":{"uc_base":"1f917","uc_output":"1f917","uc_match":"1f917","uc_greedy":"1f917","shortnames":[":hugging_face:"],"category":"people"},":hushed:":{"uc_base":"1f62f","uc_output":"1f62f","uc_match":"1f62f","uc_greedy":"1f62f","shortnames":[],"category":"people"},":ice_cream:":{"uc_base":"1f368","uc_output":"1f368","uc_match":"1f368","uc_greedy":"1f368","shortnames":[],"category":"food"},":icecream:":{"uc_base":"1f366","uc_output":"1f366","uc_match":"1f366","uc_greedy":"1f366","shortnames":[],"category":"food"},":id:":{"uc_base":"1f194","uc_output":"1f194","uc_match":"1f194","uc_greedy":"1f194","shortnames":[],"category":"symbols"},":ideograph_advantage:":{"uc_base":"1f250","uc_output":"1f250","uc_match":"1f250","uc_greedy":"1f250","shortnames":[],"category":"symbols"},":imp:":{"uc_base":"1f47f","uc_output":"1f47f","uc_match":"1f47f","uc_greedy":"1f47f","shortnames":[],"category":"people"},":inbox_tray:":{"uc_base":"1f4e5","uc_output":"1f4e5","uc_match":"1f4e5-fe0f","uc_greedy":"1f4e5-fe0f","shortnames":[],"category":"objects"},":incoming_envelope:":{"uc_base":"1f4e8","uc_output":"1f4e8","uc_match":"1f4e8","uc_greedy":"1f4e8","shortnames":[],"category":"objects"},":innocent:":{"uc_base":"1f607","uc_output":"1f607","uc_match":"1f607","uc_greedy":"1f607","shortnames":[],"category":"people"},":iphone:":{"uc_base":"1f4f1","uc_output":"1f4f1","uc_match":"1f4f1","uc_greedy":"1f4f1","shortnames":[],"category":"objects"},":island:":{"uc_base":"1f3dd","uc_output":"1f3dd","uc_match":"1f3dd-fe0f","uc_greedy":"1f3dd-fe0f","shortnames":[":desert_island:"],"category":"travel"},":izakaya_lantern:":{"uc_base":"1f3ee","uc_output":"1f3ee","uc_match":"1f3ee","uc_greedy":"1f3ee","shortnames":[],"category":"objects"},":jack_o_lantern:":{"uc_base":"1f383","uc_output":"1f383","uc_match":"1f383","uc_greedy":"1f383","shortnames":[],"category":"people"},":japan:":{"uc_base":"1f5fe","uc_output":"1f5fe","uc_match":"1f5fe","uc_greedy":"1f5fe","shortnames":[],"category":"travel"},":japanese_castle:":{"uc_base":"1f3ef","uc_output":"1f3ef","uc_match":"1f3ef","uc_greedy":"1f3ef","shortnames":[],"category":"travel"},":japanese_goblin:":{"uc_base":"1f47a","uc_output":"1f47a","uc_match":"1f47a","uc_greedy":"1f47a","shortnames":[],"category":"people"},":japanese_ogre:":{"uc_base":"1f479","uc_output":"1f479","uc_match":"1f479","uc_greedy":"1f479","shortnames":[],"category":"people"},":jeans:":{"uc_base":"1f456","uc_output":"1f456","uc_match":"1f456","uc_greedy":"1f456","shortnames":[],"category":"people"},":joy:":{"uc_base":"1f602","uc_output":"1f602","uc_match":"1f602","uc_greedy":"1f602","shortnames":[],"category":"people"},":joy_cat:":{"uc_base":"1f639","uc_output":"1f639","uc_match":"1f639","uc_greedy":"1f639","shortnames":[],"category":"people"},":joystick:":{"uc_base":"1f579","uc_output":"1f579","uc_match":"1f579-fe0f","uc_greedy":"1f579-fe0f","shortnames":[],"category":"objects"},":kaaba:":{"uc_base":"1f54b","uc_output":"1f54b","uc_match":"1f54b","uc_greedy":"1f54b","shortnames":[],"category":"travel"},":key2:":{"uc_base":"1f5dd","uc_output":"1f5dd","uc_match":"1f5dd-fe0f","uc_greedy":"1f5dd","shortnames":[":old_key:"],"category":"objects"},":key:":{"uc_base":"1f511","uc_output":"1f511","uc_match":"1f511","uc_greedy":"1f511","shortnames":[],"category":"objects"},":keycap_ten:":{"uc_base":"1f51f","uc_output":"1f51f","uc_match":"1f51f","uc_greedy":"1f51f","shortnames":[],"category":"symbols"},":kimono:":{"uc_base":"1f458","uc_output":"1f458","uc_match":"1f458","uc_greedy":"1f458","shortnames":[],"category":"people"},":kiss:":{"uc_base":"1f48b","uc_output":"1f48b","uc_match":"1f48b","uc_greedy":"1f48b","shortnames":[],"category":"people"},":kissing:":{"uc_base":"1f617","uc_output":"1f617","uc_match":"1f617","uc_greedy":"1f617","shortnames":[],"category":"people"},":kissing_cat:":{"uc_base":"1f63d","uc_output":"1f63d","uc_match":"1f63d","uc_greedy":"1f63d","shortnames":[],"category":"people"},":kissing_closed_eyes:":{"uc_base":"1f61a","uc_output":"1f61a","uc_match":"1f61a","uc_greedy":"1f61a","shortnames":[],"category":"people"},":kissing_heart:":{"uc_base":"1f618","uc_output":"1f618","uc_match":"1f618","uc_greedy":"1f618","shortnames":[],"category":"people"},":kissing_smiling_eyes:":{"uc_base":"1f619","uc_output":"1f619","uc_match":"1f619","uc_greedy":"1f619","shortnames":[],"category":"people"},":kiwi:":{"uc_base":"1f95d","uc_output":"1f95d","uc_match":"1f95d","uc_greedy":"1f95d","shortnames":[":kiwifruit:"],"category":"food"},":knife:":{"uc_base":"1f52a","uc_output":"1f52a","uc_match":"1f52a","uc_greedy":"1f52a","shortnames":[],"category":"objects"},":koala:":{"uc_base":"1f428","uc_output":"1f428","uc_match":"1f428","uc_greedy":"1f428","shortnames":[],"category":"nature"},":koko:":{"uc_base":"1f201","uc_output":"1f201","uc_match":"1f201","uc_greedy":"1f201","shortnames":[],"category":"symbols"},":label:":{"uc_base":"1f3f7","uc_output":"1f3f7","uc_match":"1f3f7-fe0f","uc_greedy":"1f3f7-fe0f","shortnames":[],"category":"objects"},":large_blue_diamond:":{"uc_base":"1f537","uc_output":"1f537","uc_match":"1f537","uc_greedy":"1f537","shortnames":[],"category":"symbols"},":large_orange_diamond:":{"uc_base":"1f536","uc_output":"1f536","uc_match":"1f536","uc_greedy":"1f536","shortnames":[],"category":"symbols"},":last_quarter_moon:":{"uc_base":"1f317","uc_output":"1f317","uc_match":"1f317","uc_greedy":"1f317","shortnames":[],"category":"nature"},":last_quarter_moon_with_face:":{"uc_base":"1f31c","uc_output":"1f31c","uc_match":"1f31c-fe0f","uc_greedy":"1f31c-fe0f","shortnames":[],"category":"nature"},":laughing:":{"uc_base":"1f606","uc_output":"1f606","uc_match":"1f606","uc_greedy":"1f606","shortnames":[":satisfied:"],"category":"people"},":leaves:":{"uc_base":"1f343","uc_output":"1f343","uc_match":"1f343","uc_greedy":"1f343","shortnames":[],"category":"nature"},":ledger:":{"uc_base":"1f4d2","uc_output":"1f4d2","uc_match":"1f4d2","uc_greedy":"1f4d2","shortnames":[],"category":"objects"},":left_facing_fist:":{"uc_base":"1f91b","uc_output":"1f91b","uc_match":"1f91b","uc_greedy":"1f91b","shortnames":[":left_fist:"],"category":"people"},":left_luggage:":{"uc_base":"1f6c5","uc_output":"1f6c5","uc_match":"1f6c5","uc_greedy":"1f6c5","shortnames":[],"category":"symbols"},":lemon:":{"uc_base":"1f34b","uc_output":"1f34b","uc_match":"1f34b","uc_greedy":"1f34b","shortnames":[],"category":"food"},":leopard:":{"uc_base":"1f406","uc_output":"1f406","uc_match":"1f406","uc_greedy":"1f406","shortnames":[],"category":"nature"},":level_slider:":{"uc_base":"1f39a","uc_output":"1f39a","uc_match":"1f39a-fe0f","uc_greedy":"1f39a-fe0f","shortnames":[],"category":"objects"},":levitate:":{"uc_base":"1f574","uc_output":"1f574","uc_match":"1f574-fe0f","uc_greedy":"1f574-fe0f","shortnames":[":man_in_business_suit_levitating:"],"category":"people"},":light_rail:":{"uc_base":"1f688","uc_output":"1f688","uc_match":"1f688","uc_greedy":"1f688","shortnames":[],"category":"travel"},":link:":{"uc_base":"1f517","uc_output":"1f517","uc_match":"1f517","uc_greedy":"1f517","shortnames":[],"category":"objects"},":lion_face:":{"uc_base":"1f981","uc_output":"1f981","uc_match":"1f981","uc_greedy":"1f981","shortnames":[":lion:"],"category":"nature"},":lips:":{"uc_base":"1f444","uc_output":"1f444","uc_match":"1f444","uc_greedy":"1f444","shortnames":[],"category":"people"},":lipstick:":{"uc_base":"1f484","uc_output":"1f484","uc_match":"1f484","uc_greedy":"1f484","shortnames":[],"category":"people"},":lizard:":{"uc_base":"1f98e","uc_output":"1f98e","uc_match":"1f98e","uc_greedy":"1f98e","shortnames":[],"category":"nature"},":lock:":{"uc_base":"1f512","uc_output":"1f512","uc_match":"1f512-fe0f","uc_greedy":"1f512-fe0f","shortnames":[],"category":"objects"},":lock_with_ink_pen:":{"uc_base":"1f50f","uc_output":"1f50f","uc_match":"1f50f","uc_greedy":"1f50f","shortnames":[],"category":"objects"},":lollipop:":{"uc_base":"1f36d","uc_output":"1f36d","uc_match":"1f36d","uc_greedy":"1f36d","shortnames":[],"category":"food"},":loud_sound:":{"uc_base":"1f50a","uc_output":"1f50a","uc_match":"1f50a","uc_greedy":"1f50a","shortnames":[],"category":"symbols"},":loudspeaker:":{"uc_base":"1f4e2","uc_output":"1f4e2","uc_match":"1f4e2","uc_greedy":"1f4e2","shortnames":[],"category":"symbols"},":love_hotel:":{"uc_base":"1f3e9","uc_output":"1f3e9","uc_match":"1f3e9","uc_greedy":"1f3e9","shortnames":[],"category":"travel"},":love_letter:":{"uc_base":"1f48c","uc_output":"1f48c","uc_match":"1f48c","uc_greedy":"1f48c","shortnames":[],"category":"objects"},":love_you_gesture:":{"uc_base":"1f91f","uc_output":"1f91f","uc_match":"1f91f","uc_greedy":"1f91f","shortnames":[],"category":"people"},":low_brightness:":{"uc_base":"1f505","uc_output":"1f505","uc_match":"1f505","uc_greedy":"1f505","shortnames":[],"category":"symbols"},":lying_face:":{"uc_base":"1f925","uc_output":"1f925","uc_match":"1f925","uc_greedy":"1f925","shortnames":[":liar:"],"category":"people"},":mag:":{"uc_base":"1f50d","uc_output":"1f50d","uc_match":"1f50d-fe0f","uc_greedy":"1f50d-fe0f","shortnames":[],"category":"objects"},":mag_right:":{"uc_base":"1f50e","uc_output":"1f50e","uc_match":"1f50e","uc_greedy":"1f50e","shortnames":[],"category":"objects"},":mage:":{"uc_base":"1f9d9","uc_output":"1f9d9","uc_match":"1f9d9","uc_greedy":"1f9d9","shortnames":[],"category":"people"},":mahjong:":{"uc_base":"1f004","uc_output":"1f004","uc_match":"1f004-fe0f","uc_greedy":"1f004-fe0f","shortnames":[],"category":"symbols"},":mailbox:":{"uc_base":"1f4eb","uc_output":"1f4eb","uc_match":"1f4eb-fe0f","uc_greedy":"1f4eb-fe0f","shortnames":[],"category":"objects"},":mailbox_closed:":{"uc_base":"1f4ea","uc_output":"1f4ea","uc_match":"1f4ea-fe0f","uc_greedy":"1f4ea-fe0f","shortnames":[],"category":"objects"},":mailbox_with_mail:":{"uc_base":"1f4ec","uc_output":"1f4ec","uc_match":"1f4ec-fe0f","uc_greedy":"1f4ec-fe0f","shortnames":[],"category":"objects"},":mailbox_with_no_mail:":{"uc_base":"1f4ed","uc_output":"1f4ed","uc_match":"1f4ed-fe0f","uc_greedy":"1f4ed-fe0f","shortnames":[],"category":"objects"},":man:":{"uc_base":"1f468","uc_output":"1f468","uc_match":"1f468","uc_greedy":"1f468","shortnames":[],"category":"people"},":man_dancing:":{"uc_base":"1f57a","uc_output":"1f57a","uc_match":"1f57a","uc_greedy":"1f57a","shortnames":[":male_dancer:"],"category":"people"},":man_in_tuxedo:":{"uc_base":"1f935","uc_output":"1f935","uc_match":"1f935","uc_greedy":"1f935","shortnames":[],"category":"people"},":man_with_chinese_cap:":{"uc_base":"1f472","uc_output":"1f472","uc_match":"1f472","uc_greedy":"1f472","shortnames":[":man_with_gua_pi_mao:"],"category":"people"},":mans_shoe:":{"uc_base":"1f45e","uc_output":"1f45e","uc_match":"1f45e","uc_greedy":"1f45e","shortnames":[],"category":"people"},":map:":{"uc_base":"1f5fa","uc_output":"1f5fa","uc_match":"1f5fa-fe0f","uc_greedy":"1f5fa-fe0f","shortnames":[":world_map:"],"category":"travel"},":maple_leaf:":{"uc_base":"1f341","uc_output":"1f341","uc_match":"1f341","uc_greedy":"1f341","shortnames":[],"category":"nature"},":martial_arts_uniform:":{"uc_base":"1f94b","uc_output":"1f94b","uc_match":"1f94b","uc_greedy":"1f94b","shortnames":[":karate_uniform:"],"category":"activity"},":mask:":{"uc_base":"1f637","uc_output":"1f637","uc_match":"1f637","uc_greedy":"1f637","shortnames":[],"category":"people"},":meat_on_bone:":{"uc_base":"1f356","uc_output":"1f356","uc_match":"1f356","uc_greedy":"1f356","shortnames":[],"category":"food"},":medal:":{"uc_base":"1f3c5","uc_output":"1f3c5","uc_match":"1f3c5","uc_greedy":"1f3c5","shortnames":[":sports_medal:"],"category":"activity"},":mega:":{"uc_base":"1f4e3","uc_output":"1f4e3","uc_match":"1f4e3","uc_greedy":"1f4e3","shortnames":[],"category":"symbols"},":melon:":{"uc_base":"1f348","uc_output":"1f348","uc_match":"1f348","uc_greedy":"1f348","shortnames":[],"category":"food"},":menorah:":{"uc_base":"1f54e","uc_output":"1f54e","uc_match":"1f54e","uc_greedy":"1f54e","shortnames":[],"category":"symbols"},":mens:":{"uc_base":"1f6b9","uc_output":"1f6b9","uc_match":"1f6b9-fe0f","uc_greedy":"1f6b9-fe0f","shortnames":[],"category":"symbols"},":merperson:":{"uc_base":"1f9dc","uc_output":"1f9dc","uc_match":"1f9dc","uc_greedy":"1f9dc","shortnames":[],"category":"people"},":metal:":{"uc_base":"1f918","uc_output":"1f918","uc_match":"1f918","uc_greedy":"1f918","shortnames":[":sign_of_the_horns:"],"category":"people"},":metro:":{"uc_base":"1f687","uc_output":"1f687","uc_match":"1f687-fe0f","uc_greedy":"1f687-fe0f","shortnames":[],"category":"travel"},":microphone2:":{"uc_base":"1f399","uc_output":"1f399","uc_match":"1f399-fe0f","uc_greedy":"1f399-fe0f","shortnames":[":studio_microphone:"],"category":"objects"},":microphone:":{"uc_base":"1f3a4","uc_output":"1f3a4","uc_match":"1f3a4","uc_greedy":"1f3a4","shortnames":[],"category":"activity"},":microscope:":{"uc_base":"1f52c","uc_output":"1f52c","uc_match":"1f52c","uc_greedy":"1f52c","shortnames":[],"category":"objects"},":middle_finger:":{"uc_base":"1f595","uc_output":"1f595","uc_match":"1f595","uc_greedy":"1f595","shortnames":[":reversed_hand_with_middle_finger_extended:"],"category":"people"},":military_medal:":{"uc_base":"1f396","uc_output":"1f396","uc_match":"1f396-fe0f","uc_greedy":"1f396-fe0f","shortnames":[],"category":"activity"},":milk:":{"uc_base":"1f95b","uc_output":"1f95b","uc_match":"1f95b","uc_greedy":"1f95b","shortnames":[":glass_of_milk:"],"category":"food"},":milky_way:":{"uc_base":"1f30c","uc_output":"1f30c","uc_match":"1f30c","uc_greedy":"1f30c","shortnames":[],"category":"travel"},":minibus:":{"uc_base":"1f690","uc_output":"1f690","uc_match":"1f690","uc_greedy":"1f690","shortnames":[],"category":"travel"},":minidisc:":{"uc_base":"1f4bd","uc_output":"1f4bd","uc_match":"1f4bd","uc_greedy":"1f4bd","shortnames":[],"category":"objects"},":mobile_phone_off:":{"uc_base":"1f4f4","uc_output":"1f4f4","uc_match":"1f4f4","uc_greedy":"1f4f4","shortnames":[],"category":"symbols"},":money_mouth:":{"uc_base":"1f911","uc_output":"1f911","uc_match":"1f911","uc_greedy":"1f911","shortnames":[":money_mouth_face:"],"category":"people"},":money_with_wings:":{"uc_base":"1f4b8","uc_output":"1f4b8","uc_match":"1f4b8","uc_greedy":"1f4b8","shortnames":[],"category":"objects"},":moneybag:":{"uc_base":"1f4b0","uc_output":"1f4b0","uc_match":"1f4b0-fe0f","uc_greedy":"1f4b0-fe0f","shortnames":[],"category":"objects"},":monkey:":{"uc_base":"1f412","uc_output":"1f412","uc_match":"1f412","uc_greedy":"1f412","shortnames":[],"category":"nature"},":monkey_face:":{"uc_base":"1f435","uc_output":"1f435","uc_match":"1f435","uc_greedy":"1f435","shortnames":[],"category":"nature"},":monorail:":{"uc_base":"1f69d","uc_output":"1f69d","uc_match":"1f69d","uc_greedy":"1f69d","shortnames":[],"category":"travel"},":mortar_board:":{"uc_base":"1f393","uc_output":"1f393","uc_match":"1f393-fe0f","uc_greedy":"1f393-fe0f","shortnames":[],"category":"people"},":mosque:":{"uc_base":"1f54c","uc_output":"1f54c","uc_match":"1f54c","uc_greedy":"1f54c","shortnames":[],"category":"travel"},":motor_scooter:":{"uc_base":"1f6f5","uc_output":"1f6f5","uc_match":"1f6f5","uc_greedy":"1f6f5","shortnames":[":motorbike:"],"category":"travel"},":motorboat:":{"uc_base":"1f6e5","uc_output":"1f6e5","uc_match":"1f6e5-fe0f","uc_greedy":"1f6e5-fe0f","shortnames":[],"category":"travel"},":motorcycle:":{"uc_base":"1f3cd","uc_output":"1f3cd","uc_match":"1f3cd-fe0f","uc_greedy":"1f3cd-fe0f","shortnames":[":racing_motorcycle:"],"category":"travel"},":motorway:":{"uc_base":"1f6e3","uc_output":"1f6e3","uc_match":"1f6e3-fe0f","uc_greedy":"1f6e3-fe0f","shortnames":[],"category":"travel"},":mount_fuji:":{"uc_base":"1f5fb","uc_output":"1f5fb","uc_match":"1f5fb","uc_greedy":"1f5fb","shortnames":[],"category":"travel"},":mountain_cableway:":{"uc_base":"1f6a0","uc_output":"1f6a0","uc_match":"1f6a0","uc_greedy":"1f6a0","shortnames":[],"category":"travel"},":mountain_railway:":{"uc_base":"1f69e","uc_output":"1f69e","uc_match":"1f69e","uc_greedy":"1f69e","shortnames":[],"category":"travel"},":mountain_snow:":{"uc_base":"1f3d4","uc_output":"1f3d4","uc_match":"1f3d4-fe0f","uc_greedy":"1f3d4-fe0f","shortnames":[":snow_capped_mountain:"],"category":"travel"},":mouse2:":{"uc_base":"1f401","uc_output":"1f401","uc_match":"1f401","uc_greedy":"1f401","shortnames":[],"category":"nature"},":mouse:":{"uc_base":"1f42d","uc_output":"1f42d","uc_match":"1f42d","uc_greedy":"1f42d","shortnames":[],"category":"nature"},":mouse_three_button:":{"uc_base":"1f5b1","uc_output":"1f5b1","uc_match":"1f5b1-fe0f","uc_greedy":"1f5b1-fe0f","shortnames":[":three_button_mouse:"],"category":"objects"},":movie_camera:":{"uc_base":"1f3a5","uc_output":"1f3a5","uc_match":"1f3a5","uc_greedy":"1f3a5","shortnames":[],"category":"objects"},":moyai:":{"uc_base":"1f5ff","uc_output":"1f5ff","uc_match":"1f5ff","uc_greedy":"1f5ff","shortnames":[],"category":"travel"},":mrs_claus:":{"uc_base":"1f936","uc_output":"1f936","uc_match":"1f936","uc_greedy":"1f936","shortnames":[":mother_christmas:"],"category":"people"},":muscle:":{"uc_base":"1f4aa","uc_output":"1f4aa","uc_match":"1f4aa","uc_greedy":"1f4aa","shortnames":[],"category":"people"},":mushroom:":{"uc_base":"1f344","uc_output":"1f344","uc_match":"1f344","uc_greedy":"1f344","shortnames":[],"category":"nature"},":musical_keyboard:":{"uc_base":"1f3b9","uc_output":"1f3b9","uc_match":"1f3b9","uc_greedy":"1f3b9","shortnames":[],"category":"activity"},":musical_note:":{"uc_base":"1f3b5","uc_output":"1f3b5","uc_match":"1f3b5","uc_greedy":"1f3b5","shortnames":[],"category":"symbols"},":musical_score:":{"uc_base":"1f3bc","uc_output":"1f3bc","uc_match":"1f3bc","uc_greedy":"1f3bc","shortnames":[],"category":"activity"},":mute:":{"uc_base":"1f507","uc_output":"1f507","uc_match":"1f507","uc_greedy":"1f507","shortnames":[],"category":"symbols"},":nail_care:":{"uc_base":"1f485","uc_output":"1f485","uc_match":"1f485","uc_greedy":"1f485","shortnames":[],"category":"people"},":name_badge:":{"uc_base":"1f4db","uc_output":"1f4db","uc_match":"1f4db","uc_greedy":"1f4db","shortnames":[],"category":"symbols"},":nauseated_face:":{"uc_base":"1f922","uc_output":"1f922","uc_match":"1f922","uc_greedy":"1f922","shortnames":[":sick:"],"category":"people"},":necktie:":{"uc_base":"1f454","uc_output":"1f454","uc_match":"1f454","uc_greedy":"1f454","shortnames":[],"category":"people"},":nerd:":{"uc_base":"1f913","uc_output":"1f913","uc_match":"1f913","uc_greedy":"1f913","shortnames":[":nerd_face:"],"category":"people"},":neutral_face:":{"uc_base":"1f610","uc_output":"1f610","uc_match":"1f610-fe0f","uc_greedy":"1f610-fe0f","shortnames":[],"category":"people"},":new:":{"uc_base":"1f195","uc_output":"1f195","uc_match":"1f195","uc_greedy":"1f195","shortnames":[],"category":"symbols"},":new_moon:":{"uc_base":"1f311","uc_output":"1f311","uc_match":"1f311","uc_greedy":"1f311","shortnames":[],"category":"nature"},":new_moon_with_face:":{"uc_base":"1f31a","uc_output":"1f31a","uc_match":"1f31a","uc_greedy":"1f31a","shortnames":[],"category":"nature"},":newspaper2:":{"uc_base":"1f5de","uc_output":"1f5de","uc_match":"1f5de-fe0f","uc_greedy":"1f5de-fe0f","shortnames":[":rolled_up_newspaper:"],"category":"objects"},":newspaper:":{"uc_base":"1f4f0","uc_output":"1f4f0","uc_match":"1f4f0","uc_greedy":"1f4f0","shortnames":[],"category":"objects"},":ng:":{"uc_base":"1f196","uc_output":"1f196","uc_match":"1f196","uc_greedy":"1f196","shortnames":[],"category":"symbols"},":night_with_stars:":{"uc_base":"1f303","uc_output":"1f303","uc_match":"1f303","uc_greedy":"1f303","shortnames":[],"category":"travel"},":no_bell:":{"uc_base":"1f515","uc_output":"1f515","uc_match":"1f515","uc_greedy":"1f515","shortnames":[],"category":"symbols"},":no_bicycles:":{"uc_base":"1f6b3","uc_output":"1f6b3","uc_match":"1f6b3","uc_greedy":"1f6b3","shortnames":[],"category":"symbols"},":no_entry_sign:":{"uc_base":"1f6ab","uc_output":"1f6ab","uc_match":"1f6ab","uc_greedy":"1f6ab","shortnames":[],"category":"symbols"},":no_mobile_phones:":{"uc_base":"1f4f5","uc_output":"1f4f5","uc_match":"1f4f5","uc_greedy":"1f4f5","shortnames":[],"category":"symbols"},":no_mouth:":{"uc_base":"1f636","uc_output":"1f636","uc_match":"1f636","uc_greedy":"1f636","shortnames":[],"category":"people"},":no_pedestrians:":{"uc_base":"1f6b7","uc_output":"1f6b7","uc_match":"1f6b7","uc_greedy":"1f6b7","shortnames":[],"category":"symbols"},":no_smoking:":{"uc_base":"1f6ad","uc_output":"1f6ad","uc_match":"1f6ad-fe0f","uc_greedy":"1f6ad-fe0f","shortnames":[],"category":"symbols"},":non-potable_water:":{"uc_base":"1f6b1","uc_output":"1f6b1","uc_match":"1f6b1","uc_greedy":"1f6b1","shortnames":[],"category":"symbols"},":nose:":{"uc_base":"1f443","uc_output":"1f443","uc_match":"1f443","uc_greedy":"1f443","shortnames":[],"category":"people"},":notebook:":{"uc_base":"1f4d3","uc_output":"1f4d3","uc_match":"1f4d3","uc_greedy":"1f4d3","shortnames":[],"category":"objects"},":notebook_with_decorative_cover:":{"uc_base":"1f4d4","uc_output":"1f4d4","uc_match":"1f4d4","uc_greedy":"1f4d4","shortnames":[],"category":"objects"},":notepad_spiral:":{"uc_base":"1f5d2","uc_output":"1f5d2","uc_match":"1f5d2-fe0f","uc_greedy":"1f5d2-fe0f","shortnames":[":spiral_note_pad:"],"category":"objects"},":notes:":{"uc_base":"1f3b6","uc_output":"1f3b6","uc_match":"1f3b6","uc_greedy":"1f3b6","shortnames":[],"category":"symbols"},":nut_and_bolt:":{"uc_base":"1f529","uc_output":"1f529","uc_match":"1f529","uc_greedy":"1f529","shortnames":[],"category":"objects"},":o2:":{"uc_base":"1f17e","uc_output":"1f17e","uc_match":"1f17e-fe0f","uc_greedy":"1f17e-fe0f","shortnames":[],"category":"symbols"},":ocean:":{"uc_base":"1f30a","uc_output":"1f30a","uc_match":"1f30a","uc_greedy":"1f30a","shortnames":[],"category":"nature"},":octagonal_sign:":{"uc_base":"1f6d1","uc_output":"1f6d1","uc_match":"1f6d1","uc_greedy":"1f6d1","shortnames":[":stop_sign:"],"category":"symbols"},":octopus:":{"uc_base":"1f419","uc_output":"1f419","uc_match":"1f419","uc_greedy":"1f419","shortnames":[],"category":"nature"},":oden:":{"uc_base":"1f362","uc_output":"1f362","uc_match":"1f362","uc_greedy":"1f362","shortnames":[],"category":"food"},":office:":{"uc_base":"1f3e2","uc_output":"1f3e2","uc_match":"1f3e2","uc_greedy":"1f3e2","shortnames":[],"category":"travel"},":oil:":{"uc_base":"1f6e2","uc_output":"1f6e2","uc_match":"1f6e2-fe0f","uc_greedy":"1f6e2-fe0f","shortnames":[":oil_drum:"],"category":"objects"},":ok:":{"uc_base":"1f197","uc_output":"1f197","uc_match":"1f197","uc_greedy":"1f197","shortnames":[],"category":"symbols"},":ok_hand:":{"uc_base":"1f44c","uc_output":"1f44c","uc_match":"1f44c","uc_greedy":"1f44c","shortnames":[],"category":"people"},":older_adult:":{"uc_base":"1f9d3","uc_output":"1f9d3","uc_match":"1f9d3","uc_greedy":"1f9d3","shortnames":[],"category":"people"},":older_man:":{"uc_base":"1f474","uc_output":"1f474","uc_match":"1f474","uc_greedy":"1f474","shortnames":[],"category":"people"},":older_woman:":{"uc_base":"1f475","uc_output":"1f475","uc_match":"1f475","uc_greedy":"1f475","shortnames":[":grandma:"],"category":"people"},":om_symbol:":{"uc_base":"1f549","uc_output":"1f549","uc_match":"1f549-fe0f","uc_greedy":"1f549","shortnames":[],"category":"symbols"},":on:":{"uc_base":"1f51b","uc_output":"1f51b","uc_match":"1f51b","uc_greedy":"1f51b","shortnames":[],"category":"symbols"},":oncoming_automobile:":{"uc_base":"1f698","uc_output":"1f698","uc_match":"1f698-fe0f","uc_greedy":"1f698-fe0f","shortnames":[],"category":"travel"},":oncoming_bus:":{"uc_base":"1f68d","uc_output":"1f68d","uc_match":"1f68d-fe0f","uc_greedy":"1f68d-fe0f","shortnames":[],"category":"travel"},":oncoming_police_car:":{"uc_base":"1f694","uc_output":"1f694","uc_match":"1f694-fe0f","uc_greedy":"1f694-fe0f","shortnames":[],"category":"travel"},":oncoming_taxi:":{"uc_base":"1f696","uc_output":"1f696","uc_match":"1f696","uc_greedy":"1f696","shortnames":[],"category":"travel"},":open_file_folder:":{"uc_base":"1f4c2","uc_output":"1f4c2","uc_match":"1f4c2","uc_greedy":"1f4c2","shortnames":[],"category":"objects"},":open_hands:":{"uc_base":"1f450","uc_output":"1f450","uc_match":"1f450","uc_greedy":"1f450","shortnames":[],"category":"people"},":open_mouth:":{"uc_base":"1f62e","uc_output":"1f62e","uc_match":"1f62e","uc_greedy":"1f62e","shortnames":[],"category":"people"},":orange_book:":{"uc_base":"1f4d9","uc_output":"1f4d9","uc_match":"1f4d9","uc_greedy":"1f4d9","shortnames":[],"category":"objects"},":orange_heart:":{"uc_base":"1f9e1","uc_output":"1f9e1","uc_match":"1f9e1","uc_greedy":"1f9e1","shortnames":[],"category":"symbols"},":outbox_tray:":{"uc_base":"1f4e4","uc_output":"1f4e4","uc_match":"1f4e4-fe0f","uc_greedy":"1f4e4-fe0f","shortnames":[],"category":"objects"},":owl:":{"uc_base":"1f989","uc_output":"1f989","uc_match":"1f989","uc_greedy":"1f989","shortnames":[],"category":"nature"},":ox:":{"uc_base":"1f402","uc_output":"1f402","uc_match":"1f402","uc_greedy":"1f402","shortnames":[],"category":"nature"},":package:":{"uc_base":"1f4e6","uc_output":"1f4e6","uc_match":"1f4e6-fe0f","uc_greedy":"1f4e6-fe0f","shortnames":[],"category":"objects"},":page_facing_up:":{"uc_base":"1f4c4","uc_output":"1f4c4","uc_match":"1f4c4","uc_greedy":"1f4c4","shortnames":[],"category":"objects"},":page_with_curl:":{"uc_base":"1f4c3","uc_output":"1f4c3","uc_match":"1f4c3","uc_greedy":"1f4c3","shortnames":[],"category":"objects"},":pager:":{"uc_base":"1f4df","uc_output":"1f4df","uc_match":"1f4df-fe0f","uc_greedy":"1f4df-fe0f","shortnames":[],"category":"objects"},":paintbrush:":{"uc_base":"1f58c","uc_output":"1f58c","uc_match":"1f58c-fe0f","uc_greedy":"1f58c-fe0f","shortnames":[":lower_left_paintbrush:"],"category":"objects"},":palm_tree:":{"uc_base":"1f334","uc_output":"1f334","uc_match":"1f334","uc_greedy":"1f334","shortnames":[],"category":"nature"},":palms_up_together:":{"uc_base":"1f932","uc_output":"1f932","uc_match":"1f932","uc_greedy":"1f932","shortnames":[],"category":"people"},":pancakes:":{"uc_base":"1f95e","uc_output":"1f95e","uc_match":"1f95e","uc_greedy":"1f95e","shortnames":[],"category":"food"},":panda_face:":{"uc_base":"1f43c","uc_output":"1f43c","uc_match":"1f43c","uc_greedy":"1f43c","shortnames":[],"category":"nature"},":paperclip:":{"uc_base":"1f4ce","uc_output":"1f4ce","uc_match":"1f4ce","uc_greedy":"1f4ce","shortnames":[],"category":"objects"},":paperclips:":{"uc_base":"1f587","uc_output":"1f587","uc_match":"1f587-fe0f","uc_greedy":"1f587-fe0f","shortnames":[":linked_paperclips:"],"category":"objects"},":park:":{"uc_base":"1f3de","uc_output":"1f3de","uc_match":"1f3de-fe0f","uc_greedy":"1f3de-fe0f","shortnames":[":national_park:"],"category":"travel"},":parking:":{"uc_base":"1f17f","uc_output":"1f17f","uc_match":"1f17f-fe0f","uc_greedy":"1f17f-fe0f","shortnames":[],"category":"symbols"},":passport_control:":{"uc_base":"1f6c2","uc_output":"1f6c2","uc_match":"1f6c2","uc_greedy":"1f6c2","shortnames":[],"category":"symbols"},":peach:":{"uc_base":"1f351","uc_output":"1f351","uc_match":"1f351","uc_greedy":"1f351","shortnames":[],"category":"food"},":peanuts:":{"uc_base":"1f95c","uc_output":"1f95c","uc_match":"1f95c","uc_greedy":"1f95c","shortnames":[":shelled_peanut:"],"category":"food"},":pear:":{"uc_base":"1f350","uc_output":"1f350","uc_match":"1f350","uc_greedy":"1f350","shortnames":[],"category":"food"},":pen_ballpoint:":{"uc_base":"1f58a","uc_output":"1f58a","uc_match":"1f58a-fe0f","uc_greedy":"1f58a-fe0f","shortnames":[":lower_left_ballpoint_pen:"],"category":"objects"},":pen_fountain:":{"uc_base":"1f58b","uc_output":"1f58b","uc_match":"1f58b-fe0f","uc_greedy":"1f58b-fe0f","shortnames":[":lower_left_fountain_pen:"],"category":"objects"},":pencil:":{"uc_base":"1f4dd","uc_output":"1f4dd","uc_match":"1f4dd","uc_greedy":"1f4dd","shortnames":[":memo:"],"category":"objects"},":penguin:":{"uc_base":"1f427","uc_output":"1f427","uc_match":"1f427","uc_greedy":"1f427","shortnames":[],"category":"nature"},":pensive:":{"uc_base":"1f614","uc_output":"1f614","uc_match":"1f614","uc_greedy":"1f614","shortnames":[],"category":"people"},":people_with_bunny_ears_partying:":{"uc_base":"1f46f","uc_output":"1f46f","uc_match":"1f46f","uc_greedy":"1f46f","shortnames":[":dancers:"],"category":"people"},":people_wrestling:":{"uc_base":"1f93c","uc_output":"1f93c","uc_match":"1f93c","uc_greedy":"1f93c","shortnames":[":wrestlers:",":wrestling:"],"category":"activity"},":performing_arts:":{"uc_base":"1f3ad","uc_output":"1f3ad","uc_match":"1f3ad-fe0f","uc_greedy":"1f3ad-fe0f","shortnames":[],"category":"activity"},":persevere:":{"uc_base":"1f623","uc_output":"1f623","uc_match":"1f623","uc_greedy":"1f623","shortnames":[],"category":"people"},":person_biking:":{"uc_base":"1f6b4","uc_output":"1f6b4","uc_match":"1f6b4","uc_greedy":"1f6b4","shortnames":[":bicyclist:"],"category":"activity"},":person_bowing:":{"uc_base":"1f647","uc_output":"1f647","uc_match":"1f647","uc_greedy":"1f647","shortnames":[":bow:"],"category":"people"},":person_climbing:":{"uc_base":"1f9d7","uc_output":"1f9d7","uc_match":"1f9d7","uc_greedy":"1f9d7","shortnames":[],"category":"activity"},":person_doing_cartwheel:":{"uc_base":"1f938","uc_output":"1f938","uc_match":"1f938","uc_greedy":"1f938","shortnames":[":cartwheel:"],"category":"activity"},":person_facepalming:":{"uc_base":"1f926","uc_output":"1f926","uc_match":"1f926","uc_greedy":"1f926","shortnames":[":face_palm:",":facepalm:"],"category":"people"},":person_fencing:":{"uc_base":"1f93a","uc_output":"1f93a","uc_match":"1f93a","uc_greedy":"1f93a","shortnames":[":fencer:",":fencing:"],"category":"activity"},":person_frowning:":{"uc_base":"1f64d","uc_output":"1f64d","uc_match":"1f64d","uc_greedy":"1f64d","shortnames":[],"category":"people"},":person_gesturing_no:":{"uc_base":"1f645","uc_output":"1f645","uc_match":"1f645","uc_greedy":"1f645","shortnames":[":no_good:"],"category":"people"},":person_gesturing_ok:":{"uc_base":"1f646","uc_output":"1f646","uc_match":"1f646","uc_greedy":"1f646","shortnames":[":ok_woman:"],"category":"people"},":person_getting_haircut:":{"uc_base":"1f487","uc_output":"1f487","uc_match":"1f487","uc_greedy":"1f487","shortnames":[":haircut:"],"category":"people"},":person_getting_massage:":{"uc_base":"1f486","uc_output":"1f486","uc_match":"1f486","uc_greedy":"1f486","shortnames":[":massage:"],"category":"people"},":person_golfing:":{"uc_base":"1f3cc","uc_output":"1f3cc","uc_match":"1f3cc-fe0f","uc_greedy":"1f3cc-fe0f","shortnames":[":golfer:"],"category":"activity"},":person_in_lotus_position:":{"uc_base":"1f9d8","uc_output":"1f9d8","uc_match":"1f9d8","uc_greedy":"1f9d8","shortnames":[],"category":"activity"},":person_in_steamy_room:":{"uc_base":"1f9d6","uc_output":"1f9d6","uc_match":"1f9d6","uc_greedy":"1f9d6","shortnames":[],"category":"people"},":person_juggling:":{"uc_base":"1f939","uc_output":"1f939","uc_match":"1f939","uc_greedy":"1f939","shortnames":[":juggling:",":juggler:"],"category":"activity"},":person_lifting_weights:":{"uc_base":"1f3cb","uc_output":"1f3cb","uc_match":"1f3cb-fe0f","uc_greedy":"1f3cb-fe0f","shortnames":[":lifter:",":weight_lifter:"],"category":"activity"},":person_mountain_biking:":{"uc_base":"1f6b5","uc_output":"1f6b5","uc_match":"1f6b5","uc_greedy":"1f6b5","shortnames":[":mountain_bicyclist:"],"category":"activity"},":person_playing_handball:":{"uc_base":"1f93e","uc_output":"1f93e","uc_match":"1f93e","uc_greedy":"1f93e","shortnames":[":handball:"],"category":"activity"},":person_playing_water_polo:":{"uc_base":"1f93d","uc_output":"1f93d","uc_match":"1f93d","uc_greedy":"1f93d","shortnames":[":water_polo:"],"category":"activity"},":person_pouting:":{"uc_base":"1f64e","uc_output":"1f64e","uc_match":"1f64e","uc_greedy":"1f64e","shortnames":[":person_with_pouting_face:"],"category":"people"},":person_raising_hand:":{"uc_base":"1f64b","uc_output":"1f64b","uc_match":"1f64b","uc_greedy":"1f64b","shortnames":[":raising_hand:"],"category":"people"},":person_rowing_boat:":{"uc_base":"1f6a3","uc_output":"1f6a3","uc_match":"1f6a3","uc_greedy":"1f6a3","shortnames":[":rowboat:"],"category":"activity"},":person_running:":{"uc_base":"1f3c3","uc_output":"1f3c3","uc_match":"1f3c3","uc_greedy":"1f3c3","shortnames":[":runner:"],"category":"people"},":person_shrugging:":{"uc_base":"1f937","uc_output":"1f937","uc_match":"1f937","uc_greedy":"1f937","shortnames":[":shrug:"],"category":"people"},":person_surfing:":{"uc_base":"1f3c4","uc_output":"1f3c4","uc_match":"1f3c4-fe0f","uc_greedy":"1f3c4-fe0f","shortnames":[":surfer:"],"category":"activity"},":person_swimming:":{"uc_base":"1f3ca","uc_output":"1f3ca","uc_match":"1f3ca-fe0f","uc_greedy":"1f3ca-fe0f","shortnames":[":swimmer:"],"category":"activity"},":person_tipping_hand:":{"uc_base":"1f481","uc_output":"1f481","uc_match":"1f481","uc_greedy":"1f481","shortnames":[":information_desk_person:"],"category":"people"},":person_walking:":{"uc_base":"1f6b6","uc_output":"1f6b6","uc_match":"1f6b6","uc_greedy":"1f6b6","shortnames":[":walking:"],"category":"people"},":person_wearing_turban:":{"uc_base":"1f473","uc_output":"1f473","uc_match":"1f473","uc_greedy":"1f473","shortnames":[":man_with_turban:"],"category":"people"},":pie:":{"uc_base":"1f967","uc_output":"1f967","uc_match":"1f967","uc_greedy":"1f967","shortnames":[],"category":"food"},":pig2:":{"uc_base":"1f416","uc_output":"1f416","uc_match":"1f416","uc_greedy":"1f416","shortnames":[],"category":"nature"},":pig:":{"uc_base":"1f437","uc_output":"1f437","uc_match":"1f437","uc_greedy":"1f437","shortnames":[],"category":"nature"},":pig_nose:":{"uc_base":"1f43d","uc_output":"1f43d","uc_match":"1f43d","uc_greedy":"1f43d","shortnames":[],"category":"nature"},":pill:":{"uc_base":"1f48a","uc_output":"1f48a","uc_match":"1f48a","uc_greedy":"1f48a","shortnames":[],"category":"objects"},":pineapple:":{"uc_base":"1f34d","uc_output":"1f34d","uc_match":"1f34d","uc_greedy":"1f34d","shortnames":[],"category":"food"},":ping_pong:":{"uc_base":"1f3d3","uc_output":"1f3d3","uc_match":"1f3d3","uc_greedy":"1f3d3","shortnames":[":table_tennis:"],"category":"activity"},":pizza:":{"uc_base":"1f355","uc_output":"1f355","uc_match":"1f355","uc_greedy":"1f355","shortnames":[],"category":"food"},":place_of_worship:":{"uc_base":"1f6d0","uc_output":"1f6d0","uc_match":"1f6d0","uc_greedy":"1f6d0","shortnames":[":worship_symbol:"],"category":"symbols"},":point_down:":{"uc_base":"1f447","uc_output":"1f447","uc_match":"1f447-fe0f","uc_greedy":"1f447-fe0f","shortnames":[],"category":"people"},":point_left:":{"uc_base":"1f448","uc_output":"1f448","uc_match":"1f448-fe0f","uc_greedy":"1f448-fe0f","shortnames":[],"category":"people"},":point_right:":{"uc_base":"1f449","uc_output":"1f449","uc_match":"1f449-fe0f","uc_greedy":"1f449-fe0f","shortnames":[],"category":"people"},":point_up_2:":{"uc_base":"1f446","uc_output":"1f446","uc_match":"1f446-fe0f","uc_greedy":"1f446-fe0f","shortnames":[],"category":"people"},":police_car:":{"uc_base":"1f693","uc_output":"1f693","uc_match":"1f693","uc_greedy":"1f693","shortnames":[],"category":"travel"},":police_officer:":{"uc_base":"1f46e","uc_output":"1f46e","uc_match":"1f46e","uc_greedy":"1f46e","shortnames":[":cop:"],"category":"people"},":poodle:":{"uc_base":"1f429","uc_output":"1f429","uc_match":"1f429","uc_greedy":"1f429","shortnames":[],"category":"nature"},":poop:":{"uc_base":"1f4a9","uc_output":"1f4a9","uc_match":"1f4a9","uc_greedy":"1f4a9","shortnames":[":shit:",":hankey:",":poo:"],"category":"people"},":popcorn:":{"uc_base":"1f37f","uc_output":"1f37f","uc_match":"1f37f","uc_greedy":"1f37f","shortnames":[],"category":"food"},":post_office:":{"uc_base":"1f3e3","uc_output":"1f3e3","uc_match":"1f3e3","uc_greedy":"1f3e3","shortnames":[],"category":"travel"},":postal_horn:":{"uc_base":"1f4ef","uc_output":"1f4ef","uc_match":"1f4ef","uc_greedy":"1f4ef","shortnames":[],"category":"objects"},":postbox:":{"uc_base":"1f4ee","uc_output":"1f4ee","uc_match":"1f4ee","uc_greedy":"1f4ee","shortnames":[],"category":"objects"},":potable_water:":{"uc_base":"1f6b0","uc_output":"1f6b0","uc_match":"1f6b0","uc_greedy":"1f6b0","shortnames":[],"category":"objects"},":potato:":{"uc_base":"1f954","uc_output":"1f954","uc_match":"1f954","uc_greedy":"1f954","shortnames":[],"category":"food"},":pouch:":{"uc_base":"1f45d","uc_output":"1f45d","uc_match":"1f45d","uc_greedy":"1f45d","shortnames":[],"category":"people"},":poultry_leg:":{"uc_base":"1f357","uc_output":"1f357","uc_match":"1f357","uc_greedy":"1f357","shortnames":[],"category":"food"},":pound:":{"uc_base":"1f4b7","uc_output":"1f4b7","uc_match":"1f4b7","uc_greedy":"1f4b7","shortnames":[],"category":"objects"},":pouting_cat:":{"uc_base":"1f63e","uc_output":"1f63e","uc_match":"1f63e","uc_greedy":"1f63e","shortnames":[],"category":"people"},":pray:":{"uc_base":"1f64f","uc_output":"1f64f","uc_match":"1f64f","uc_greedy":"1f64f","shortnames":[],"category":"people"},":prayer_beads:":{"uc_base":"1f4ff","uc_output":"1f4ff","uc_match":"1f4ff","uc_greedy":"1f4ff","shortnames":[],"category":"objects"},":pregnant_woman:":{"uc_base":"1f930","uc_output":"1f930","uc_match":"1f930","uc_greedy":"1f930","shortnames":[":expecting_woman:"],"category":"people"},":pretzel:":{"uc_base":"1f968","uc_output":"1f968","uc_match":"1f968","uc_greedy":"1f968","shortnames":[],"category":"food"},":prince:":{"uc_base":"1f934","uc_output":"1f934","uc_match":"1f934","uc_greedy":"1f934","shortnames":[],"category":"people"},":princess:":{"uc_base":"1f478","uc_output":"1f478","uc_match":"1f478","uc_greedy":"1f478","shortnames":[],"category":"people"},":printer:":{"uc_base":"1f5a8","uc_output":"1f5a8","uc_match":"1f5a8-fe0f","uc_greedy":"1f5a8-fe0f","shortnames":[],"category":"objects"},":projector:":{"uc_base":"1f4fd","uc_output":"1f4fd","uc_match":"1f4fd-fe0f","uc_greedy":"1f4fd-fe0f","shortnames":[":film_projector:"],"category":"objects"},":punch:":{"uc_base":"1f44a","uc_output":"1f44a","uc_match":"1f44a","uc_greedy":"1f44a","shortnames":[],"category":"people"},":purple_heart:":{"uc_base":"1f49c","uc_output":"1f49c","uc_match":"1f49c","uc_greedy":"1f49c","shortnames":[],"category":"symbols"},":purse:":{"uc_base":"1f45b","uc_output":"1f45b","uc_match":"1f45b","uc_greedy":"1f45b","shortnames":[],"category":"people"},":pushpin:":{"uc_base":"1f4cc","uc_output":"1f4cc","uc_match":"1f4cc","uc_greedy":"1f4cc","shortnames":[],"category":"objects"},":put_litter_in_its_place:":{"uc_base":"1f6ae","uc_output":"1f6ae","uc_match":"1f6ae","uc_greedy":"1f6ae","shortnames":[],"category":"symbols"},":rabbit2:":{"uc_base":"1f407","uc_output":"1f407","uc_match":"1f407","uc_greedy":"1f407","shortnames":[],"category":"nature"},":rabbit:":{"uc_base":"1f430","uc_output":"1f430","uc_match":"1f430","uc_greedy":"1f430","shortnames":[],"category":"nature"},":race_car:":{"uc_base":"1f3ce","uc_output":"1f3ce","uc_match":"1f3ce-fe0f","uc_greedy":"1f3ce-fe0f","shortnames":[":racing_car:"],"category":"travel"},":racehorse:":{"uc_base":"1f40e","uc_output":"1f40e","uc_match":"1f40e","uc_greedy":"1f40e","shortnames":[],"category":"nature"},":radio:":{"uc_base":"1f4fb","uc_output":"1f4fb","uc_match":"1f4fb-fe0f","uc_greedy":"1f4fb-fe0f","shortnames":[],"category":"objects"},":radio_button:":{"uc_base":"1f518","uc_output":"1f518","uc_match":"1f518","uc_greedy":"1f518","shortnames":[],"category":"symbols"},":rage:":{"uc_base":"1f621","uc_output":"1f621","uc_match":"1f621","uc_greedy":"1f621","shortnames":[],"category":"people"},":railway_car:":{"uc_base":"1f683","uc_output":"1f683","uc_match":"1f683","uc_greedy":"1f683","shortnames":[],"category":"travel"},":railway_track:":{"uc_base":"1f6e4","uc_output":"1f6e4","uc_match":"1f6e4-fe0f","uc_greedy":"1f6e4-fe0f","shortnames":[":railroad_track:"],"category":"travel"},":rainbow:":{"uc_base":"1f308","uc_output":"1f308","uc_match":"1f308","uc_greedy":"1f308","shortnames":[],"category":"nature"},":raised_back_of_hand:":{"uc_base":"1f91a","uc_output":"1f91a","uc_match":"1f91a","uc_greedy":"1f91a","shortnames":[":back_of_hand:"],"category":"people"},":raised_hands:":{"uc_base":"1f64c","uc_output":"1f64c","uc_match":"1f64c","uc_greedy":"1f64c","shortnames":[],"category":"people"},":ram:":{"uc_base":"1f40f","uc_output":"1f40f","uc_match":"1f40f","uc_greedy":"1f40f","shortnames":[],"category":"nature"},":ramen:":{"uc_base":"1f35c","uc_output":"1f35c","uc_match":"1f35c","uc_greedy":"1f35c","shortnames":[],"category":"food"},":rat:":{"uc_base":"1f400","uc_output":"1f400","uc_match":"1f400","uc_greedy":"1f400","shortnames":[],"category":"nature"},":red_car:":{"uc_base":"1f697","uc_output":"1f697","uc_match":"1f697","uc_greedy":"1f697","shortnames":[],"category":"travel"},":red_circle:":{"uc_base":"1f534","uc_output":"1f534","uc_match":"1f534","uc_greedy":"1f534","shortnames":[],"category":"symbols"},":regional_indicator_a:":{"uc_base":"1f1e6","uc_output":"1f1e6","uc_match":"1f1e6","uc_greedy":"1f1e6","shortnames":[],"category":"regional"},":regional_indicator_b:":{"uc_base":"1f1e7","uc_output":"1f1e7","uc_match":"1f1e7","uc_greedy":"1f1e7","shortnames":[],"category":"regional"},":regional_indicator_c:":{"uc_base":"1f1e8","uc_output":"1f1e8","uc_match":"1f1e8","uc_greedy":"1f1e8","shortnames":[],"category":"regional"},":regional_indicator_d:":{"uc_base":"1f1e9","uc_output":"1f1e9","uc_match":"1f1e9","uc_greedy":"1f1e9","shortnames":[],"category":"regional"},":regional_indicator_e:":{"uc_base":"1f1ea","uc_output":"1f1ea","uc_match":"1f1ea","uc_greedy":"1f1ea","shortnames":[],"category":"regional"},":regional_indicator_f:":{"uc_base":"1f1eb","uc_output":"1f1eb","uc_match":"1f1eb","uc_greedy":"1f1eb","shortnames":[],"category":"regional"},":regional_indicator_g:":{"uc_base":"1f1ec","uc_output":"1f1ec","uc_match":"1f1ec","uc_greedy":"1f1ec","shortnames":[],"category":"regional"},":regional_indicator_h:":{"uc_base":"1f1ed","uc_output":"1f1ed","uc_match":"1f1ed","uc_greedy":"1f1ed","shortnames":[],"category":"regional"},":regional_indicator_i:":{"uc_base":"1f1ee","uc_output":"1f1ee","uc_match":"1f1ee","uc_greedy":"1f1ee","shortnames":[],"category":"regional"},":regional_indicator_j:":{"uc_base":"1f1ef","uc_output":"1f1ef","uc_match":"1f1ef","uc_greedy":"1f1ef","shortnames":[],"category":"regional"},":regional_indicator_k:":{"uc_base":"1f1f0","uc_output":"1f1f0","uc_match":"1f1f0","uc_greedy":"1f1f0","shortnames":[],"category":"regional"},":regional_indicator_l:":{"uc_base":"1f1f1","uc_output":"1f1f1","uc_match":"1f1f1","uc_greedy":"1f1f1","shortnames":[],"category":"regional"},":regional_indicator_m:":{"uc_base":"1f1f2","uc_output":"1f1f2","uc_match":"1f1f2","uc_greedy":"1f1f2","shortnames":[],"category":"regional"},":regional_indicator_n:":{"uc_base":"1f1f3","uc_output":"1f1f3","uc_match":"1f1f3","uc_greedy":"1f1f3","shortnames":[],"category":"regional"},":regional_indicator_o:":{"uc_base":"1f1f4","uc_output":"1f1f4","uc_match":"1f1f4","uc_greedy":"1f1f4","shortnames":[],"category":"regional"},":regional_indicator_p:":{"uc_base":"1f1f5","uc_output":"1f1f5","uc_match":"1f1f5","uc_greedy":"1f1f5","shortnames":[],"category":"regional"},":regional_indicator_q:":{"uc_base":"1f1f6","uc_output":"1f1f6","uc_match":"1f1f6","uc_greedy":"1f1f6","shortnames":[],"category":"regional"},":regional_indicator_r:":{"uc_base":"1f1f7","uc_output":"1f1f7","uc_match":"1f1f7","uc_greedy":"1f1f7","shortnames":[],"category":"regional"},":regional_indicator_s:":{"uc_base":"1f1f8","uc_output":"1f1f8","uc_match":"1f1f8","uc_greedy":"1f1f8","shortnames":[],"category":"regional"},":regional_indicator_t:":{"uc_base":"1f1f9","uc_output":"1f1f9","uc_match":"1f1f9","uc_greedy":"1f1f9","shortnames":[],"category":"regional"},":regional_indicator_u:":{"uc_base":"1f1fa","uc_output":"1f1fa","uc_match":"1f1fa","uc_greedy":"1f1fa","shortnames":[],"category":"regional"},":regional_indicator_v:":{"uc_base":"1f1fb","uc_output":"1f1fb","uc_match":"1f1fb","uc_greedy":"1f1fb","shortnames":[],"category":"regional"},":regional_indicator_w:":{"uc_base":"1f1fc","uc_output":"1f1fc","uc_match":"1f1fc","uc_greedy":"1f1fc","shortnames":[],"category":"regional"},":regional_indicator_x:":{"uc_base":"1f1fd","uc_output":"1f1fd","uc_match":"1f1fd","uc_greedy":"1f1fd","shortnames":[],"category":"regional"},":regional_indicator_y:":{"uc_base":"1f1fe","uc_output":"1f1fe","uc_match":"1f1fe","uc_greedy":"1f1fe","shortnames":[],"category":"regional"},":regional_indicator_z:":{"uc_base":"1f1ff","uc_output":"1f1ff","uc_match":"1f1ff","uc_greedy":"1f1ff","shortnames":[],"category":"regional"},":relieved:":{"uc_base":"1f60c","uc_output":"1f60c","uc_match":"1f60c","uc_greedy":"1f60c","shortnames":[],"category":"people"},":reminder_ribbon:":{"uc_base":"1f397","uc_output":"1f397","uc_match":"1f397-fe0f","uc_greedy":"1f397-fe0f","shortnames":[],"category":"activity"},":repeat:":{"uc_base":"1f501","uc_output":"1f501","uc_match":"1f501","uc_greedy":"1f501","shortnames":[],"category":"symbols"},":repeat_one:":{"uc_base":"1f502","uc_output":"1f502","uc_match":"1f502","uc_greedy":"1f502","shortnames":[],"category":"symbols"},":restroom:":{"uc_base":"1f6bb","uc_output":"1f6bb","uc_match":"1f6bb","uc_greedy":"1f6bb","shortnames":[],"category":"symbols"},":revolving_hearts:":{"uc_base":"1f49e","uc_output":"1f49e","uc_match":"1f49e","uc_greedy":"1f49e","shortnames":[],"category":"symbols"},":rhino:":{"uc_base":"1f98f","uc_output":"1f98f","uc_match":"1f98f","uc_greedy":"1f98f","shortnames":[":rhinoceros:"],"category":"nature"},":ribbon:":{"uc_base":"1f380","uc_output":"1f380","uc_match":"1f380","uc_greedy":"1f380","shortnames":[],"category":"objects"},":rice:":{"uc_base":"1f35a","uc_output":"1f35a","uc_match":"1f35a","uc_greedy":"1f35a","shortnames":[],"category":"food"},":rice_ball:":{"uc_base":"1f359","uc_output":"1f359","uc_match":"1f359","uc_greedy":"1f359","shortnames":[],"category":"food"},":rice_cracker:":{"uc_base":"1f358","uc_output":"1f358","uc_match":"1f358","uc_greedy":"1f358","shortnames":[],"category":"food"},":rice_scene:":{"uc_base":"1f391","uc_output":"1f391","uc_match":"1f391","uc_greedy":"1f391","shortnames":[],"category":"travel"},":right_facing_fist:":{"uc_base":"1f91c","uc_output":"1f91c","uc_match":"1f91c","uc_greedy":"1f91c","shortnames":[":right_fist:"],"category":"people"},":ring:":{"uc_base":"1f48d","uc_output":"1f48d","uc_match":"1f48d","uc_greedy":"1f48d","shortnames":[],"category":"people"},":robot:":{"uc_base":"1f916","uc_output":"1f916","uc_match":"1f916","uc_greedy":"1f916","shortnames":[":robot_face:"],"category":"people"},":rocket:":{"uc_base":"1f680","uc_output":"1f680","uc_match":"1f680","uc_greedy":"1f680","shortnames":[],"category":"travel"},":rofl:":{"uc_base":"1f923","uc_output":"1f923","uc_match":"1f923","uc_greedy":"1f923","shortnames":[":rolling_on_the_floor_laughing:"],"category":"people"},":roller_coaster:":{"uc_base":"1f3a2","uc_output":"1f3a2","uc_match":"1f3a2","uc_greedy":"1f3a2","shortnames":[],"category":"travel"},":rolling_eyes:":{"uc_base":"1f644","uc_output":"1f644","uc_match":"1f644","uc_greedy":"1f644","shortnames":[":face_with_rolling_eyes:"],"category":"people"},":rooster:":{"uc_base":"1f413","uc_output":"1f413","uc_match":"1f413","uc_greedy":"1f413","shortnames":[],"category":"nature"},":rose:":{"uc_base":"1f339","uc_output":"1f339","uc_match":"1f339","uc_greedy":"1f339","shortnames":[],"category":"nature"},":rosette:":{"uc_base":"1f3f5","uc_output":"1f3f5","uc_match":"1f3f5-fe0f","uc_greedy":"1f3f5-fe0f","shortnames":[],"category":"activity"},":rotating_light:":{"uc_base":"1f6a8","uc_output":"1f6a8","uc_match":"1f6a8","uc_greedy":"1f6a8","shortnames":[],"category":"travel"},":round_pushpin:":{"uc_base":"1f4cd","uc_output":"1f4cd","uc_match":"1f4cd","uc_greedy":"1f4cd","shortnames":[],"category":"objects"},":rugby_football:":{"uc_base":"1f3c9","uc_output":"1f3c9","uc_match":"1f3c9","uc_greedy":"1f3c9","shortnames":[],"category":"activity"},":running_shirt_with_sash:":{"uc_base":"1f3bd","uc_output":"1f3bd","uc_match":"1f3bd","uc_greedy":"1f3bd","shortnames":[],"category":"activity"},":sa:":{"uc_base":"1f202","uc_output":"1f202","uc_match":"1f202-fe0f","uc_greedy":"1f202-fe0f","shortnames":[],"category":"symbols"},":sake:":{"uc_base":"1f376","uc_output":"1f376","uc_match":"1f376","uc_greedy":"1f376","shortnames":[],"category":"food"},":salad:":{"uc_base":"1f957","uc_output":"1f957","uc_match":"1f957","uc_greedy":"1f957","shortnames":[":green_salad:"],"category":"food"},":sandal:":{"uc_base":"1f461","uc_output":"1f461","uc_match":"1f461","uc_greedy":"1f461","shortnames":[],"category":"people"},":sandwich:":{"uc_base":"1f96a","uc_output":"1f96a","uc_match":"1f96a","uc_greedy":"1f96a","shortnames":[],"category":"food"},":santa:":{"uc_base":"1f385","uc_output":"1f385","uc_match":"1f385","uc_greedy":"1f385","shortnames":[],"category":"people"},":satellite:":{"uc_base":"1f4e1","uc_output":"1f4e1","uc_match":"1f4e1","uc_greedy":"1f4e1","shortnames":[],"category":"objects"},":satellite_orbital:":{"uc_base":"1f6f0","uc_output":"1f6f0","uc_match":"1f6f0-fe0f","uc_greedy":"1f6f0-fe0f","shortnames":[],"category":"travel"},":sauropod:":{"uc_base":"1f995","uc_output":"1f995","uc_match":"1f995","uc_greedy":"1f995","shortnames":[],"category":"nature"},":saxophone:":{"uc_base":"1f3b7","uc_output":"1f3b7","uc_match":"1f3b7","uc_greedy":"1f3b7","shortnames":[],"category":"activity"},":scarf:":{"uc_base":"1f9e3","uc_output":"1f9e3","uc_match":"1f9e3","uc_greedy":"1f9e3","shortnames":[],"category":"people"},":school:":{"uc_base":"1f3eb","uc_output":"1f3eb","uc_match":"1f3eb","uc_greedy":"1f3eb","shortnames":[],"category":"travel"},":school_satchel:":{"uc_base":"1f392","uc_output":"1f392","uc_match":"1f392","uc_greedy":"1f392","shortnames":[],"category":"people"},":scooter:":{"uc_base":"1f6f4","uc_output":"1f6f4","uc_match":"1f6f4","uc_greedy":"1f6f4","shortnames":[],"category":"travel"},":scorpion:":{"uc_base":"1f982","uc_output":"1f982","uc_match":"1f982","uc_greedy":"1f982","shortnames":[],"category":"nature"},":scream:":{"uc_base":"1f631","uc_output":"1f631","uc_match":"1f631","uc_greedy":"1f631","shortnames":[],"category":"people"},":scream_cat:":{"uc_base":"1f640","uc_output":"1f640","uc_match":"1f640","uc_greedy":"1f640","shortnames":[],"category":"people"},":scroll:":{"uc_base":"1f4dc","uc_output":"1f4dc","uc_match":"1f4dc","uc_greedy":"1f4dc","shortnames":[],"category":"objects"},":seat:":{"uc_base":"1f4ba","uc_output":"1f4ba","uc_match":"1f4ba","uc_greedy":"1f4ba","shortnames":[],"category":"travel"},":second_place:":{"uc_base":"1f948","uc_output":"1f948","uc_match":"1f948","uc_greedy":"1f948","shortnames":[":second_place_medal:"],"category":"activity"},":see_no_evil:":{"uc_base":"1f648","uc_output":"1f648","uc_match":"1f648","uc_greedy":"1f648","shortnames":[],"category":"nature"},":seedling:":{"uc_base":"1f331","uc_output":"1f331","uc_match":"1f331","uc_greedy":"1f331","shortnames":[],"category":"nature"},":selfie:":{"uc_base":"1f933","uc_output":"1f933","uc_match":"1f933","uc_greedy":"1f933","shortnames":[],"category":"people"},":shallow_pan_of_food:":{"uc_base":"1f958","uc_output":"1f958","uc_match":"1f958","uc_greedy":"1f958","shortnames":[":paella:"],"category":"food"},":shark:":{"uc_base":"1f988","uc_output":"1f988","uc_match":"1f988","uc_greedy":"1f988","shortnames":[],"category":"nature"},":shaved_ice:":{"uc_base":"1f367","uc_output":"1f367","uc_match":"1f367","uc_greedy":"1f367","shortnames":[],"category":"food"},":sheep:":{"uc_base":"1f411","uc_output":"1f411","uc_match":"1f411","uc_greedy":"1f411","shortnames":[],"category":"nature"},":shell:":{"uc_base":"1f41a","uc_output":"1f41a","uc_match":"1f41a","uc_greedy":"1f41a","shortnames":[],"category":"nature"},":shield:":{"uc_base":"1f6e1","uc_output":"1f6e1","uc_match":"1f6e1-fe0f","uc_greedy":"1f6e1-fe0f","shortnames":[],"category":"objects"},":ship:":{"uc_base":"1f6a2","uc_output":"1f6a2","uc_match":"1f6a2","uc_greedy":"1f6a2","shortnames":[],"category":"travel"},":shirt:":{"uc_base":"1f455","uc_output":"1f455","uc_match":"1f455","uc_greedy":"1f455","shortnames":[],"category":"people"},":shopping_bags:":{"uc_base":"1f6cd","uc_output":"1f6cd","uc_match":"1f6cd-fe0f","uc_greedy":"1f6cd-fe0f","shortnames":[],"category":"objects"},":shopping_cart:":{"uc_base":"1f6d2","uc_output":"1f6d2","uc_match":"1f6d2","uc_greedy":"1f6d2","shortnames":[":shopping_trolley:"],"category":"objects"},":shower:":{"uc_base":"1f6bf","uc_output":"1f6bf","uc_match":"1f6bf","uc_greedy":"1f6bf","shortnames":[],"category":"objects"},":shrimp:":{"uc_base":"1f990","uc_output":"1f990","uc_match":"1f990","uc_greedy":"1f990","shortnames":[],"category":"nature"},":shushing_face:":{"uc_base":"1f92b","uc_output":"1f92b","uc_match":"1f92b","uc_greedy":"1f92b","shortnames":[],"category":"people"},":signal_strength:":{"uc_base":"1f4f6","uc_output":"1f4f6","uc_match":"1f4f6","uc_greedy":"1f4f6","shortnames":[],"category":"symbols"},":six_pointed_star:":{"uc_base":"1f52f","uc_output":"1f52f","uc_match":"1f52f","uc_greedy":"1f52f","shortnames":[],"category":"symbols"},":ski:":{"uc_base":"1f3bf","uc_output":"1f3bf","uc_match":"1f3bf","uc_greedy":"1f3bf","shortnames":[],"category":"activity"},":skull:":{"uc_base":"1f480","uc_output":"1f480","uc_match":"1f480","uc_greedy":"1f480","shortnames":[":skeleton:"],"category":"people"},":sled:":{"uc_base":"1f6f7","uc_output":"1f6f7","uc_match":"1f6f7","uc_greedy":"1f6f7","shortnames":[],"category":"activity"},":sleeping:":{"uc_base":"1f634","uc_output":"1f634","uc_match":"1f634","uc_greedy":"1f634","shortnames":[],"category":"people"},":sleeping_accommodation:":{"uc_base":"1f6cc","uc_output":"1f6cc","uc_match":"1f6cc","uc_greedy":"1f6cc","shortnames":[],"category":"objects"},":sleepy:":{"uc_base":"1f62a","uc_output":"1f62a","uc_match":"1f62a","uc_greedy":"1f62a","shortnames":[],"category":"people"},":slight_frown:":{"uc_base":"1f641","uc_output":"1f641","uc_match":"1f641","uc_greedy":"1f641","shortnames":[":slightly_frowning_face:"],"category":"people"},":slight_smile:":{"uc_base":"1f642","uc_output":"1f642","uc_match":"1f642","uc_greedy":"1f642","shortnames":[":slightly_smiling_face:"],"category":"people"},":slot_machine:":{"uc_base":"1f3b0","uc_output":"1f3b0","uc_match":"1f3b0","uc_greedy":"1f3b0","shortnames":[],"category":"activity"},":small_blue_diamond:":{"uc_base":"1f539","uc_output":"1f539","uc_match":"1f539","uc_greedy":"1f539","shortnames":[],"category":"symbols"},":small_orange_diamond:":{"uc_base":"1f538","uc_output":"1f538","uc_match":"1f538","uc_greedy":"1f538","shortnames":[],"category":"symbols"},":small_red_triangle:":{"uc_base":"1f53a","uc_output":"1f53a","uc_match":"1f53a","uc_greedy":"1f53a","shortnames":[],"category":"symbols"},":small_red_triangle_down:":{"uc_base":"1f53b","uc_output":"1f53b","uc_match":"1f53b","uc_greedy":"1f53b","shortnames":[],"category":"symbols"},":smile:":{"uc_base":"1f604","uc_output":"1f604","uc_match":"1f604","uc_greedy":"1f604","shortnames":[],"category":"people"},":smile_cat:":{"uc_base":"1f638","uc_output":"1f638","uc_match":"1f638","uc_greedy":"1f638","shortnames":[],"category":"people"},":smiley:":{"uc_base":"1f603","uc_output":"1f603","uc_match":"1f603","uc_greedy":"1f603","shortnames":[],"category":"people"},":smiley_cat:":{"uc_base":"1f63a","uc_output":"1f63a","uc_match":"1f63a","uc_greedy":"1f63a","shortnames":[],"category":"people"},":smiling_imp:":{"uc_base":"1f608","uc_output":"1f608","uc_match":"1f608","uc_greedy":"1f608","shortnames":[],"category":"people"},":smirk:":{"uc_base":"1f60f","uc_output":"1f60f","uc_match":"1f60f","uc_greedy":"1f60f","shortnames":[],"category":"people"},":smirk_cat:":{"uc_base":"1f63c","uc_output":"1f63c","uc_match":"1f63c","uc_greedy":"1f63c","shortnames":[],"category":"people"},":smoking:":{"uc_base":"1f6ac","uc_output":"1f6ac","uc_match":"1f6ac","uc_greedy":"1f6ac","shortnames":[],"category":"objects"},":snail:":{"uc_base":"1f40c","uc_output":"1f40c","uc_match":"1f40c","uc_greedy":"1f40c","shortnames":[],"category":"nature"},":snake:":{"uc_base":"1f40d","uc_output":"1f40d","uc_match":"1f40d","uc_greedy":"1f40d","shortnames":[],"category":"nature"},":sneezing_face:":{"uc_base":"1f927","uc_output":"1f927","uc_match":"1f927","uc_greedy":"1f927","shortnames":[":sneeze:"],"category":"people"},":snowboarder:":{"uc_base":"1f3c2","uc_output":"1f3c2","uc_match":"1f3c2-fe0f","uc_greedy":"1f3c2-fe0f","shortnames":[],"category":"activity"},":sob:":{"uc_base":"1f62d","uc_output":"1f62d","uc_match":"1f62d","uc_greedy":"1f62d","shortnames":[],"category":"people"},":socks:":{"uc_base":"1f9e6","uc_output":"1f9e6","uc_match":"1f9e6","uc_greedy":"1f9e6","shortnames":[],"category":"people"},":soon:":{"uc_base":"1f51c","uc_output":"1f51c","uc_match":"1f51c","uc_greedy":"1f51c","shortnames":[],"category":"symbols"},":sos:":{"uc_base":"1f198","uc_output":"1f198","uc_match":"1f198","uc_greedy":"1f198","shortnames":[],"category":"symbols"},":sound:":{"uc_base":"1f509","uc_output":"1f509","uc_match":"1f509","uc_greedy":"1f509","shortnames":[],"category":"symbols"},":space_invader:":{"uc_base":"1f47e","uc_output":"1f47e","uc_match":"1f47e","uc_greedy":"1f47e","shortnames":[],"category":"people"},":spaghetti:":{"uc_base":"1f35d","uc_output":"1f35d","uc_match":"1f35d","uc_greedy":"1f35d","shortnames":[],"category":"food"},":sparkler:":{"uc_base":"1f387","uc_output":"1f387","uc_match":"1f387","uc_greedy":"1f387","shortnames":[],"category":"travel"},":sparkling_heart:":{"uc_base":"1f496","uc_output":"1f496","uc_match":"1f496","uc_greedy":"1f496","shortnames":[],"category":"symbols"},":speak_no_evil:":{"uc_base":"1f64a","uc_output":"1f64a","uc_match":"1f64a","uc_greedy":"1f64a","shortnames":[],"category":"nature"},":speaker:":{"uc_base":"1f508","uc_output":"1f508","uc_match":"1f508-fe0f","uc_greedy":"1f508-fe0f","shortnames":[],"category":"symbols"},":speaking_head:":{"uc_base":"1f5e3","uc_output":"1f5e3","uc_match":"1f5e3-fe0f","uc_greedy":"1f5e3-fe0f","shortnames":[":speaking_head_in_silhouette:"],"category":"people"},":speech_balloon:":{"uc_base":"1f4ac","uc_output":"1f4ac","uc_match":"1f4ac","uc_greedy":"1f4ac","shortnames":[],"category":"symbols"},":speech_left:":{"uc_base":"1f5e8","uc_output":"1f5e8","uc_match":"1f5e8-fe0f","uc_greedy":"1f5e8-fe0f","shortnames":[":left_speech_bubble:"],"category":"symbols"},":speedboat:":{"uc_base":"1f6a4","uc_output":"1f6a4","uc_match":"1f6a4","uc_greedy":"1f6a4","shortnames":[],"category":"travel"},":spider:":{"uc_base":"1f577","uc_output":"1f577","uc_match":"1f577-fe0f","uc_greedy":"1f577-fe0f","shortnames":[],"category":"nature"},":spider_web:":{"uc_base":"1f578","uc_output":"1f578","uc_match":"1f578-fe0f","uc_greedy":"1f578-fe0f","shortnames":[],"category":"nature"},":spoon:":{"uc_base":"1f944","uc_output":"1f944","uc_match":"1f944","uc_greedy":"1f944","shortnames":[],"category":"food"},":squid:":{"uc_base":"1f991","uc_output":"1f991","uc_match":"1f991","uc_greedy":"1f991","shortnames":[],"category":"nature"},":stadium:":{"uc_base":"1f3df","uc_output":"1f3df","uc_match":"1f3df-fe0f","uc_greedy":"1f3df-fe0f","shortnames":[],"category":"travel"},":star2:":{"uc_base":"1f31f","uc_output":"1f31f","uc_match":"1f31f","uc_greedy":"1f31f","shortnames":[],"category":"nature"},":star_struck:":{"uc_base":"1f929","uc_output":"1f929","uc_match":"1f929","uc_greedy":"1f929","shortnames":[],"category":"people"},":stars:":{"uc_base":"1f320","uc_output":"1f320","uc_match":"1f320","uc_greedy":"1f320","shortnames":[],"category":"travel"},":station:":{"uc_base":"1f689","uc_output":"1f689","uc_match":"1f689","uc_greedy":"1f689","shortnames":[],"category":"travel"},":statue_of_liberty:":{"uc_base":"1f5fd","uc_output":"1f5fd","uc_match":"1f5fd","uc_greedy":"1f5fd","shortnames":[],"category":"travel"},":steam_locomotive:":{"uc_base":"1f682","uc_output":"1f682","uc_match":"1f682","uc_greedy":"1f682","shortnames":[],"category":"travel"},":stew:":{"uc_base":"1f372","uc_output":"1f372","uc_match":"1f372","uc_greedy":"1f372","shortnames":[],"category":"food"},":straight_ruler:":{"uc_base":"1f4cf","uc_output":"1f4cf","uc_match":"1f4cf","uc_greedy":"1f4cf","shortnames":[],"category":"objects"},":strawberry:":{"uc_base":"1f353","uc_output":"1f353","uc_match":"1f353","uc_greedy":"1f353","shortnames":[],"category":"food"},":stuck_out_tongue:":{"uc_base":"1f61b","uc_output":"1f61b","uc_match":"1f61b","uc_greedy":"1f61b","shortnames":[],"category":"people"},":stuck_out_tongue_closed_eyes:":{"uc_base":"1f61d","uc_output":"1f61d","uc_match":"1f61d","uc_greedy":"1f61d","shortnames":[],"category":"people"},":stuck_out_tongue_winking_eye:":{"uc_base":"1f61c","uc_output":"1f61c","uc_match":"1f61c","uc_greedy":"1f61c","shortnames":[],"category":"people"},":stuffed_flatbread:":{"uc_base":"1f959","uc_output":"1f959","uc_match":"1f959","uc_greedy":"1f959","shortnames":[":stuffed_pita:"],"category":"food"},":sun_with_face:":{"uc_base":"1f31e","uc_output":"1f31e","uc_match":"1f31e","uc_greedy":"1f31e","shortnames":[],"category":"nature"},":sunflower:":{"uc_base":"1f33b","uc_output":"1f33b","uc_match":"1f33b","uc_greedy":"1f33b","shortnames":[],"category":"nature"},":sunglasses:":{"uc_base":"1f60e","uc_output":"1f60e","uc_match":"1f60e","uc_greedy":"1f60e","shortnames":[],"category":"people"},":sunrise:":{"uc_base":"1f305","uc_output":"1f305","uc_match":"1f305","uc_greedy":"1f305","shortnames":[],"category":"travel"},":sunrise_over_mountains:":{"uc_base":"1f304","uc_output":"1f304","uc_match":"1f304","uc_greedy":"1f304","shortnames":[],"category":"travel"},":sushi:":{"uc_base":"1f363","uc_output":"1f363","uc_match":"1f363","uc_greedy":"1f363","shortnames":[],"category":"food"},":suspension_railway:":{"uc_base":"1f69f","uc_output":"1f69f","uc_match":"1f69f","uc_greedy":"1f69f","shortnames":[],"category":"travel"},":sweat:":{"uc_base":"1f613","uc_output":"1f613","uc_match":"1f613","uc_greedy":"1f613","shortnames":[],"category":"people"},":sweat_drops:":{"uc_base":"1f4a6","uc_output":"1f4a6","uc_match":"1f4a6","uc_greedy":"1f4a6","shortnames":[],"category":"nature"},":sweat_smile:":{"uc_base":"1f605","uc_output":"1f605","uc_match":"1f605","uc_greedy":"1f605","shortnames":[],"category":"people"},":sweet_potato:":{"uc_base":"1f360","uc_output":"1f360","uc_match":"1f360","uc_greedy":"1f360","shortnames":[],"category":"food"},":symbols:":{"uc_base":"1f523","uc_output":"1f523","uc_match":"1f523","uc_greedy":"1f523","shortnames":[],"category":"symbols"},":synagogue:":{"uc_base":"1f54d","uc_output":"1f54d","uc_match":"1f54d","uc_greedy":"1f54d","shortnames":[],"category":"travel"},":syringe:":{"uc_base":"1f489","uc_output":"1f489","uc_match":"1f489","uc_greedy":"1f489","shortnames":[],"category":"objects"},":t_rex:":{"uc_base":"1f996","uc_output":"1f996","uc_match":"1f996","uc_greedy":"1f996","shortnames":[],"category":"nature"},":taco:":{"uc_base":"1f32e","uc_output":"1f32e","uc_match":"1f32e","uc_greedy":"1f32e","shortnames":[],"category":"food"},":tada:":{"uc_base":"1f389","uc_output":"1f389","uc_match":"1f389","uc_greedy":"1f389","shortnames":[],"category":"objects"},":takeout_box:":{"uc_base":"1f961","uc_output":"1f961","uc_match":"1f961","uc_greedy":"1f961","shortnames":[],"category":"food"},":tanabata_tree:":{"uc_base":"1f38b","uc_output":"1f38b","uc_match":"1f38b","uc_greedy":"1f38b","shortnames":[],"category":"nature"},":tangerine:":{"uc_base":"1f34a","uc_output":"1f34a","uc_match":"1f34a","uc_greedy":"1f34a","shortnames":[],"category":"food"},":taxi:":{"uc_base":"1f695","uc_output":"1f695","uc_match":"1f695","uc_greedy":"1f695","shortnames":[],"category":"travel"},":tea:":{"uc_base":"1f375","uc_output":"1f375","uc_match":"1f375","uc_greedy":"1f375","shortnames":[],"category":"food"},":telephone_receiver:":{"uc_base":"1f4de","uc_output":"1f4de","uc_match":"1f4de","uc_greedy":"1f4de","shortnames":[],"category":"objects"},":telescope:":{"uc_base":"1f52d","uc_output":"1f52d","uc_match":"1f52d","uc_greedy":"1f52d","shortnames":[],"category":"objects"},":tennis:":{"uc_base":"1f3be","uc_output":"1f3be","uc_match":"1f3be","uc_greedy":"1f3be","shortnames":[],"category":"activity"},":thermometer:":{"uc_base":"1f321","uc_output":"1f321","uc_match":"1f321-fe0f","uc_greedy":"1f321-fe0f","shortnames":[],"category":"objects"},":thermometer_face:":{"uc_base":"1f912","uc_output":"1f912","uc_match":"1f912","uc_greedy":"1f912","shortnames":[":face_with_thermometer:"],"category":"people"},":thinking:":{"uc_base":"1f914","uc_output":"1f914","uc_match":"1f914","uc_greedy":"1f914","shortnames":[":thinking_face:"],"category":"people"},":third_place:":{"uc_base":"1f949","uc_output":"1f949","uc_match":"1f949","uc_greedy":"1f949","shortnames":[":third_place_medal:"],"category":"activity"},":thought_balloon:":{"uc_base":"1f4ad","uc_output":"1f4ad","uc_match":"1f4ad","uc_greedy":"1f4ad","shortnames":[],"category":"symbols"},":thumbsdown:":{"uc_base":"1f44e","uc_output":"1f44e","uc_match":"1f44e-fe0f","uc_greedy":"1f44e-fe0f","shortnames":[":-1:",":thumbdown:"],"category":"people"},":thumbsup:":{"uc_base":"1f44d","uc_output":"1f44d","uc_match":"1f44d-fe0f","uc_greedy":"1f44d-fe0f","shortnames":[":+1:",":thumbup:"],"category":"people"},":ticket:":{"uc_base":"1f3ab","uc_output":"1f3ab","uc_match":"1f3ab","uc_greedy":"1f3ab","shortnames":[],"category":"activity"},":tickets:":{"uc_base":"1f39f","uc_output":"1f39f","uc_match":"1f39f-fe0f","uc_greedy":"1f39f-fe0f","shortnames":[":admission_tickets:"],"category":"activity"},":tiger2:":{"uc_base":"1f405","uc_output":"1f405","uc_match":"1f405","uc_greedy":"1f405","shortnames":[],"category":"nature"},":tiger:":{"uc_base":"1f42f","uc_output":"1f42f","uc_match":"1f42f","uc_greedy":"1f42f","shortnames":[],"category":"nature"},":tired_face:":{"uc_base":"1f62b","uc_output":"1f62b","uc_match":"1f62b","uc_greedy":"1f62b","shortnames":[],"category":"people"},":toilet:":{"uc_base":"1f6bd","uc_output":"1f6bd","uc_match":"1f6bd","uc_greedy":"1f6bd","shortnames":[],"category":"objects"},":tokyo_tower:":{"uc_base":"1f5fc","uc_output":"1f5fc","uc_match":"1f5fc","uc_greedy":"1f5fc","shortnames":[],"category":"travel"},":tomato:":{"uc_base":"1f345","uc_output":"1f345","uc_match":"1f345","uc_greedy":"1f345","shortnames":[],"category":"food"},":tone1:":{"uc_base":"1f3fb","uc_output":"1f3fb","uc_match":"1f3fb","uc_greedy":"1f3fb","shortnames":[],"category":"modifier"},":tone2:":{"uc_base":"1f3fc","uc_output":"1f3fc","uc_match":"1f3fc","uc_greedy":"1f3fc","shortnames":[],"category":"modifier"},":tone3:":{"uc_base":"1f3fd","uc_output":"1f3fd","uc_match":"1f3fd","uc_greedy":"1f3fd","shortnames":[],"category":"modifier"},":tone4:":{"uc_base":"1f3fe","uc_output":"1f3fe","uc_match":"1f3fe","uc_greedy":"1f3fe","shortnames":[],"category":"modifier"},":tone5:":{"uc_base":"1f3ff","uc_output":"1f3ff","uc_match":"1f3ff","uc_greedy":"1f3ff","shortnames":[],"category":"modifier"},":tongue:":{"uc_base":"1f445","uc_output":"1f445","uc_match":"1f445","uc_greedy":"1f445","shortnames":[],"category":"people"},":tools:":{"uc_base":"1f6e0","uc_output":"1f6e0","uc_match":"1f6e0-fe0f","uc_greedy":"1f6e0-fe0f","shortnames":[":hammer_and_wrench:"],"category":"objects"},":top:":{"uc_base":"1f51d","uc_output":"1f51d","uc_match":"1f51d","uc_greedy":"1f51d","shortnames":[],"category":"symbols"},":tophat:":{"uc_base":"1f3a9","uc_output":"1f3a9","uc_match":"1f3a9","uc_greedy":"1f3a9","shortnames":[],"category":"people"},":trackball:":{"uc_base":"1f5b2","uc_output":"1f5b2","uc_match":"1f5b2-fe0f","uc_greedy":"1f5b2-fe0f","shortnames":[],"category":"objects"},":tractor:":{"uc_base":"1f69c","uc_output":"1f69c","uc_match":"1f69c","uc_greedy":"1f69c","shortnames":[],"category":"travel"},":traffic_light:":{"uc_base":"1f6a5","uc_output":"1f6a5","uc_match":"1f6a5","uc_greedy":"1f6a5","shortnames":[],"category":"travel"},":train2:":{"uc_base":"1f686","uc_output":"1f686","uc_match":"1f686","uc_greedy":"1f686","shortnames":[],"category":"travel"},":train:":{"uc_base":"1f68b","uc_output":"1f68b","uc_match":"1f68b","uc_greedy":"1f68b","shortnames":[],"category":"travel"},":tram:":{"uc_base":"1f68a","uc_output":"1f68a","uc_match":"1f68a","uc_greedy":"1f68a","shortnames":[],"category":"travel"},":triangular_flag_on_post:":{"uc_base":"1f6a9","uc_output":"1f6a9","uc_match":"1f6a9","uc_greedy":"1f6a9","shortnames":[],"category":"flags"},":triangular_ruler:":{"uc_base":"1f4d0","uc_output":"1f4d0","uc_match":"1f4d0","uc_greedy":"1f4d0","shortnames":[],"category":"objects"},":trident:":{"uc_base":"1f531","uc_output":"1f531","uc_match":"1f531","uc_greedy":"1f531","shortnames":[],"category":"symbols"},":triumph:":{"uc_base":"1f624","uc_output":"1f624","uc_match":"1f624","uc_greedy":"1f624","shortnames":[],"category":"people"},":trolleybus:":{"uc_base":"1f68e","uc_output":"1f68e","uc_match":"1f68e","uc_greedy":"1f68e","shortnames":[],"category":"travel"},":trophy:":{"uc_base":"1f3c6","uc_output":"1f3c6","uc_match":"1f3c6-fe0f","uc_greedy":"1f3c6-fe0f","shortnames":[],"category":"activity"},":tropical_drink:":{"uc_base":"1f379","uc_output":"1f379","uc_match":"1f379","uc_greedy":"1f379","shortnames":[],"category":"food"},":tropical_fish:":{"uc_base":"1f420","uc_output":"1f420","uc_match":"1f420","uc_greedy":"1f420","shortnames":[],"category":"nature"},":truck:":{"uc_base":"1f69a","uc_output":"1f69a","uc_match":"1f69a","uc_greedy":"1f69a","shortnames":[],"category":"travel"},":trumpet:":{"uc_base":"1f3ba","uc_output":"1f3ba","uc_match":"1f3ba","uc_greedy":"1f3ba","shortnames":[],"category":"activity"},":tulip:":{"uc_base":"1f337","uc_output":"1f337","uc_match":"1f337","uc_greedy":"1f337","shortnames":[],"category":"nature"},":tumbler_glass:":{"uc_base":"1f943","uc_output":"1f943","uc_match":"1f943","uc_greedy":"1f943","shortnames":[":whisky:"],"category":"food"},":turkey:":{"uc_base":"1f983","uc_output":"1f983","uc_match":"1f983","uc_greedy":"1f983","shortnames":[],"category":"nature"},":turtle:":{"uc_base":"1f422","uc_output":"1f422","uc_match":"1f422","uc_greedy":"1f422","shortnames":[],"category":"nature"},":tv:":{"uc_base":"1f4fa","uc_output":"1f4fa","uc_match":"1f4fa-fe0f","uc_greedy":"1f4fa-fe0f","shortnames":[],"category":"objects"},":twisted_rightwards_arrows:":{"uc_base":"1f500","uc_output":"1f500","uc_match":"1f500","uc_greedy":"1f500","shortnames":[],"category":"symbols"},":two_hearts:":{"uc_base":"1f495","uc_output":"1f495","uc_match":"1f495","uc_greedy":"1f495","shortnames":[],"category":"symbols"},":two_men_holding_hands:":{"uc_base":"1f46c","uc_output":"1f46c","uc_match":"1f46c","uc_greedy":"1f46c","shortnames":[],"category":"people"},":two_women_holding_hands:":{"uc_base":"1f46d","uc_output":"1f46d","uc_match":"1f46d","uc_greedy":"1f46d","shortnames":[],"category":"people"},":u5272:":{"uc_base":"1f239","uc_output":"1f239","uc_match":"1f239","uc_greedy":"1f239","shortnames":[],"category":"symbols"},":u5408:":{"uc_base":"1f234","uc_output":"1f234","uc_match":"1f234","uc_greedy":"1f234","shortnames":[],"category":"symbols"},":u55b6:":{"uc_base":"1f23a","uc_output":"1f23a","uc_match":"1f23a","uc_greedy":"1f23a","shortnames":[],"category":"symbols"},":u6307:":{"uc_base":"1f22f","uc_output":"1f22f","uc_match":"1f22f-fe0f","uc_greedy":"1f22f-fe0f","shortnames":[],"category":"symbols"},":u6708:":{"uc_base":"1f237","uc_output":"1f237","uc_match":"1f237-fe0f","uc_greedy":"1f237-fe0f","shortnames":[],"category":"symbols"},":u6709:":{"uc_base":"1f236","uc_output":"1f236","uc_match":"1f236","uc_greedy":"1f236","shortnames":[],"category":"symbols"},":u6e80:":{"uc_base":"1f235","uc_output":"1f235","uc_match":"1f235","uc_greedy":"1f235","shortnames":[],"category":"symbols"},":u7121:":{"uc_base":"1f21a","uc_output":"1f21a","uc_match":"1f21a-fe0f","uc_greedy":"1f21a-fe0f","shortnames":[],"category":"symbols"},":u7533:":{"uc_base":"1f238","uc_output":"1f238","uc_match":"1f238","uc_greedy":"1f238","shortnames":[],"category":"symbols"},":u7981:":{"uc_base":"1f232","uc_output":"1f232","uc_match":"1f232","uc_greedy":"1f232","shortnames":[],"category":"symbols"},":u7a7a:":{"uc_base":"1f233","uc_output":"1f233","uc_match":"1f233","uc_greedy":"1f233","shortnames":[],"category":"symbols"},":unamused:":{"uc_base":"1f612","uc_output":"1f612","uc_match":"1f612","uc_greedy":"1f612","shortnames":[],"category":"people"},":underage:":{"uc_base":"1f51e","uc_output":"1f51e","uc_match":"1f51e","uc_greedy":"1f51e","shortnames":[],"category":"symbols"},":unicorn:":{"uc_base":"1f984","uc_output":"1f984","uc_match":"1f984","uc_greedy":"1f984","shortnames":[":unicorn_face:"],"category":"nature"},":unlock:":{"uc_base":"1f513","uc_output":"1f513","uc_match":"1f513-fe0f","uc_greedy":"1f513-fe0f","shortnames":[],"category":"objects"},":up:":{"uc_base":"1f199","uc_output":"1f199","uc_match":"1f199","uc_greedy":"1f199","shortnames":[],"category":"symbols"},":upside_down:":{"uc_base":"1f643","uc_output":"1f643","uc_match":"1f643","uc_greedy":"1f643","shortnames":[":upside_down_face:"],"category":"people"},":vampire:":{"uc_base":"1f9db","uc_output":"1f9db","uc_match":"1f9db","uc_greedy":"1f9db","shortnames":[],"category":"people"},":vertical_traffic_light:":{"uc_base":"1f6a6","uc_output":"1f6a6","uc_match":"1f6a6","uc_greedy":"1f6a6","shortnames":[],"category":"travel"},":vhs:":{"uc_base":"1f4fc","uc_output":"1f4fc","uc_match":"1f4fc","uc_greedy":"1f4fc","shortnames":[],"category":"objects"},":vibration_mode:":{"uc_base":"1f4f3","uc_output":"1f4f3","uc_match":"1f4f3","uc_greedy":"1f4f3","shortnames":[],"category":"symbols"},":video_camera:":{"uc_base":"1f4f9","uc_output":"1f4f9","uc_match":"1f4f9-fe0f","uc_greedy":"1f4f9-fe0f","shortnames":[],"category":"objects"},":video_game:":{"uc_base":"1f3ae","uc_output":"1f3ae","uc_match":"1f3ae-fe0f","uc_greedy":"1f3ae-fe0f","shortnames":[],"category":"activity"},":violin:":{"uc_base":"1f3bb","uc_output":"1f3bb","uc_match":"1f3bb","uc_greedy":"1f3bb","shortnames":[],"category":"activity"},":volcano:":{"uc_base":"1f30b","uc_output":"1f30b","uc_match":"1f30b","uc_greedy":"1f30b","shortnames":[],"category":"travel"},":volleyball:":{"uc_base":"1f3d0","uc_output":"1f3d0","uc_match":"1f3d0","uc_greedy":"1f3d0","shortnames":[],"category":"activity"},":vs:":{"uc_base":"1f19a","uc_output":"1f19a","uc_match":"1f19a","uc_greedy":"1f19a","shortnames":[],"category":"symbols"},":vulcan:":{"uc_base":"1f596","uc_output":"1f596","uc_match":"1f596","uc_greedy":"1f596","shortnames":[":raised_hand_with_part_between_middle_and_ring_fingers:"],"category":"people"},":waning_crescent_moon:":{"uc_base":"1f318","uc_output":"1f318","uc_match":"1f318","uc_greedy":"1f318","shortnames":[],"category":"nature"},":waning_gibbous_moon:":{"uc_base":"1f316","uc_output":"1f316","uc_match":"1f316","uc_greedy":"1f316","shortnames":[],"category":"nature"},":wastebasket:":{"uc_base":"1f5d1","uc_output":"1f5d1","uc_match":"1f5d1-fe0f","uc_greedy":"1f5d1-fe0f","shortnames":[],"category":"objects"},":water_buffalo:":{"uc_base":"1f403","uc_output":"1f403","uc_match":"1f403","uc_greedy":"1f403","shortnames":[],"category":"nature"},":watermelon:":{"uc_base":"1f349","uc_output":"1f349","uc_match":"1f349","uc_greedy":"1f349","shortnames":[],"category":"food"},":wave:":{"uc_base":"1f44b","uc_output":"1f44b","uc_match":"1f44b","uc_greedy":"1f44b","shortnames":[],"category":"people"},":waxing_crescent_moon:":{"uc_base":"1f312","uc_output":"1f312","uc_match":"1f312","uc_greedy":"1f312","shortnames":[],"category":"nature"},":waxing_gibbous_moon:":{"uc_base":"1f314","uc_output":"1f314","uc_match":"1f314","uc_greedy":"1f314","shortnames":[],"category":"nature"},":wc:":{"uc_base":"1f6be","uc_output":"1f6be","uc_match":"1f6be","uc_greedy":"1f6be","shortnames":[],"category":"symbols"},":weary:":{"uc_base":"1f629","uc_output":"1f629","uc_match":"1f629","uc_greedy":"1f629","shortnames":[],"category":"people"},":wedding:":{"uc_base":"1f492","uc_output":"1f492","uc_match":"1f492","uc_greedy":"1f492","shortnames":[],"category":"travel"},":whale2:":{"uc_base":"1f40b","uc_output":"1f40b","uc_match":"1f40b","uc_greedy":"1f40b","shortnames":[],"category":"nature"},":whale:":{"uc_base":"1f433","uc_output":"1f433","uc_match":"1f433","uc_greedy":"1f433","shortnames":[],"category":"nature"},":white_flower:":{"uc_base":"1f4ae","uc_output":"1f4ae","uc_match":"1f4ae","uc_greedy":"1f4ae","shortnames":[],"category":"symbols"},":white_square_button:":{"uc_base":"1f533","uc_output":"1f533","uc_match":"1f533","uc_greedy":"1f533","shortnames":[],"category":"symbols"},":white_sun_cloud:":{"uc_base":"1f325","uc_output":"1f325","uc_match":"1f325-fe0f","uc_greedy":"1f325-fe0f","shortnames":[":white_sun_behind_cloud:"],"category":"nature"},":white_sun_rain_cloud:":{"uc_base":"1f326","uc_output":"1f326","uc_match":"1f326-fe0f","uc_greedy":"1f326-fe0f","shortnames":[":white_sun_behind_cloud_with_rain:"],"category":"nature"},":white_sun_small_cloud:":{"uc_base":"1f324","uc_output":"1f324","uc_match":"1f324-fe0f","uc_greedy":"1f324-fe0f","shortnames":[":white_sun_with_small_cloud:"],"category":"nature"},":wilted_rose:":{"uc_base":"1f940","uc_output":"1f940","uc_match":"1f940","uc_greedy":"1f940","shortnames":[":wilted_flower:"],"category":"nature"},":wind_blowing_face:":{"uc_base":"1f32c","uc_output":"1f32c","uc_match":"1f32c-fe0f","uc_greedy":"1f32c-fe0f","shortnames":[],"category":"nature"},":wind_chime:":{"uc_base":"1f390","uc_output":"1f390","uc_match":"1f390","uc_greedy":"1f390","shortnames":[],"category":"objects"},":wine_glass:":{"uc_base":"1f377","uc_output":"1f377","uc_match":"1f377","uc_greedy":"1f377","shortnames":[],"category":"food"},":wink:":{"uc_base":"1f609","uc_output":"1f609","uc_match":"1f609","uc_greedy":"1f609","shortnames":[],"category":"people"},":wolf:":{"uc_base":"1f43a","uc_output":"1f43a","uc_match":"1f43a","uc_greedy":"1f43a","shortnames":[],"category":"nature"},":woman:":{"uc_base":"1f469","uc_output":"1f469","uc_match":"1f469","uc_greedy":"1f469","shortnames":[],"category":"people"},":woman_with_headscarf:":{"uc_base":"1f9d5","uc_output":"1f9d5","uc_match":"1f9d5","uc_greedy":"1f9d5","shortnames":[],"category":"people"},":womans_clothes:":{"uc_base":"1f45a","uc_output":"1f45a","uc_match":"1f45a","uc_greedy":"1f45a","shortnames":[],"category":"people"},":womans_hat:":{"uc_base":"1f452","uc_output":"1f452","uc_match":"1f452","uc_greedy":"1f452","shortnames":[],"category":"people"},":womens:":{"uc_base":"1f6ba","uc_output":"1f6ba","uc_match":"1f6ba-fe0f","uc_greedy":"1f6ba-fe0f","shortnames":[],"category":"symbols"},":worried:":{"uc_base":"1f61f","uc_output":"1f61f","uc_match":"1f61f","uc_greedy":"1f61f","shortnames":[],"category":"people"},":wrench:":{"uc_base":"1f527","uc_output":"1f527","uc_match":"1f527","uc_greedy":"1f527","shortnames":[],"category":"objects"},":yellow_heart:":{"uc_base":"1f49b","uc_output":"1f49b","uc_match":"1f49b","uc_greedy":"1f49b","shortnames":[],"category":"symbols"},":yen:":{"uc_base":"1f4b4","uc_output":"1f4b4","uc_match":"1f4b4","uc_greedy":"1f4b4","shortnames":[],"category":"objects"},":yum:":{"uc_base":"1f60b","uc_output":"1f60b","uc_match":"1f60b","uc_greedy":"1f60b","shortnames":[],"category":"people"},":zebra:":{"uc_base":"1f993","uc_output":"1f993","uc_match":"1f993","uc_greedy":"1f993","shortnames":[],"category":"nature"},":zipper_mouth:":{"uc_base":"1f910","uc_output":"1f910","uc_match":"1f910","uc_greedy":"1f910","shortnames":[":zipper_mouth_face:"],"category":"people"},":zombie:":{"uc_base":"1f9df","uc_output":"1f9df","uc_match":"1f9df","uc_greedy":"1f9df","shortnames":[],"category":"people"},":zzz:":{"uc_base":"1f4a4","uc_output":"1f4a4","uc_match":"1f4a4","uc_greedy":"1f4a4","shortnames":[],"category":"symbols"},":airplane:":{"uc_base":"2708","uc_output":"2708","uc_match":"2708-fe0f","uc_greedy":"2708-fe0f","shortnames":[],"category":"travel"},":alarm_clock:":{"uc_base":"23f0","uc_output":"23f0","uc_match":"23f0","uc_greedy":"23f0","shortnames":[],"category":"objects"},":alembic:":{"uc_base":"2697","uc_output":"2697","uc_match":"2697-fe0f","uc_greedy":"2697-fe0f","shortnames":[],"category":"objects"},":anchor:":{"uc_base":"2693","uc_output":"2693","uc_match":"2693-fe0f","uc_greedy":"2693-fe0f","shortnames":[],"category":"travel"},":aquarius:":{"uc_base":"2652","uc_output":"2652","uc_match":"2652-fe0f","uc_greedy":"2652-fe0f","shortnames":[],"category":"symbols"},":aries:":{"uc_base":"2648","uc_output":"2648","uc_match":"2648-fe0f","uc_greedy":"2648-fe0f","shortnames":[],"category":"symbols"},":arrow_backward:":{"uc_base":"25c0","uc_output":"25c0","uc_match":"25c0-fe0f","uc_greedy":"25c0","shortnames":[],"category":"symbols"},":arrow_double_down:":{"uc_base":"23ec","uc_output":"23ec","uc_match":"23ec","uc_greedy":"23ec","shortnames":[],"category":"symbols"},":arrow_double_up:":{"uc_base":"23eb","uc_output":"23eb","uc_match":"23eb","uc_greedy":"23eb","shortnames":[],"category":"symbols"},":arrow_down:":{"uc_base":"2b07","uc_output":"2b07","uc_match":"2b07-fe0f","uc_greedy":"2b07","shortnames":[],"category":"symbols"},":arrow_forward:":{"uc_base":"25b6","uc_output":"25b6","uc_match":"25b6-fe0f","uc_greedy":"25b6","shortnames":[],"category":"symbols"},":arrow_heading_down:":{"uc_base":"2935","uc_output":"2935","uc_match":"2935-fe0f","uc_greedy":"2935","shortnames":[],"category":"symbols"},":arrow_heading_up:":{"uc_base":"2934","uc_output":"2934","uc_match":"2934-fe0f","uc_greedy":"2934","shortnames":[],"category":"symbols"},":arrow_left:":{"uc_base":"2b05","uc_output":"2b05","uc_match":"2b05-fe0f","uc_greedy":"2b05","shortnames":[],"category":"symbols"},":arrow_lower_left:":{"uc_base":"2199","uc_output":"2199","uc_match":"2199-fe0f","uc_greedy":"2199","shortnames":[],"category":"symbols"},":arrow_lower_right:":{"uc_base":"2198","uc_output":"2198","uc_match":"2198-fe0f","uc_greedy":"2198","shortnames":[],"category":"symbols"},":arrow_right:":{"uc_base":"27a1","uc_output":"27a1","uc_match":"27a1-fe0f","uc_greedy":"27a1","shortnames":[],"category":"symbols"},":arrow_right_hook:":{"uc_base":"21aa","uc_output":"21aa","uc_match":"21aa-fe0f","uc_greedy":"21aa","shortnames":[],"category":"symbols"},":arrow_up:":{"uc_base":"2b06","uc_output":"2b06","uc_match":"2b06-fe0f","uc_greedy":"2b06","shortnames":[],"category":"symbols"},":arrow_up_down:":{"uc_base":"2195","uc_output":"2195","uc_match":"2195-fe0f","uc_greedy":"2195","shortnames":[],"category":"symbols"},":arrow_upper_left:":{"uc_base":"2196","uc_output":"2196","uc_match":"2196-fe0f","uc_greedy":"2196","shortnames":[],"category":"symbols"},":arrow_upper_right:":{"uc_base":"2197","uc_output":"2197","uc_match":"2197-fe0f","uc_greedy":"2197","shortnames":[],"category":"symbols"},":atom:":{"uc_base":"269b","uc_output":"269b","uc_match":"269b-fe0f","uc_greedy":"269b","shortnames":[":atom_symbol:"],"category":"symbols"},":ballot_box_with_check:":{"uc_base":"2611","uc_output":"2611","uc_match":"2611-fe0f","uc_greedy":"2611","shortnames":[],"category":"symbols"},":bangbang:":{"uc_base":"203c","uc_output":"203c","uc_match":"203c-fe0f","uc_greedy":"203c","shortnames":[],"category":"symbols"},":baseball:":{"uc_base":"26be","uc_output":"26be","uc_match":"26be-fe0f","uc_greedy":"26be-fe0f","shortnames":[],"category":"activity"},":beach_umbrella:":{"uc_base":"26f1","uc_output":"26f1","uc_match":"26f1-fe0f","uc_greedy":"26f1-fe0f","shortnames":[":umbrella_on_ground:"],"category":"travel"},":biohazard:":{"uc_base":"2623","uc_output":"2623","uc_match":"2623-fe0f","uc_greedy":"2623","shortnames":[":biohazard_sign:"],"category":"symbols"},":black_circle:":{"uc_base":"26ab","uc_output":"26ab","uc_match":"26ab-fe0f","uc_greedy":"26ab-fe0f","shortnames":[],"category":"symbols"},":black_large_square:":{"uc_base":"2b1b","uc_output":"2b1b","uc_match":"2b1b-fe0f","uc_greedy":"2b1b-fe0f","shortnames":[],"category":"symbols"},":black_medium_small_square:":{"uc_base":"25fe","uc_output":"25fe","uc_match":"25fe-fe0f","uc_greedy":"25fe-fe0f","shortnames":[],"category":"symbols"},":black_medium_square:":{"uc_base":"25fc","uc_output":"25fc","uc_match":"25fc-fe0f","uc_greedy":"25fc","shortnames":[],"category":"symbols"},":black_nib:":{"uc_base":"2712","uc_output":"2712","uc_match":"2712-fe0f","uc_greedy":"2712-fe0f","shortnames":[],"category":"objects"},":black_small_square:":{"uc_base":"25aa","uc_output":"25aa","uc_match":"25aa-fe0f","uc_greedy":"25aa","shortnames":[],"category":"symbols"},":cancer:":{"uc_base":"264b","uc_output":"264b","uc_match":"264b-fe0f","uc_greedy":"264b-fe0f","shortnames":[],"category":"symbols"},":capricorn:":{"uc_base":"2651","uc_output":"2651","uc_match":"2651-fe0f","uc_greedy":"2651-fe0f","shortnames":[],"category":"symbols"},":chains:":{"uc_base":"26d3","uc_output":"26d3","uc_match":"26d3-fe0f","uc_greedy":"26d3-fe0f","shortnames":[],"category":"objects"},":church:":{"uc_base":"26ea","uc_output":"26ea","uc_match":"26ea-fe0f","uc_greedy":"26ea-fe0f","shortnames":[],"category":"travel"},":cloud:":{"uc_base":"2601","uc_output":"2601","uc_match":"2601-fe0f","uc_greedy":"2601-fe0f","shortnames":[],"category":"nature"},":clubs:":{"uc_base":"2663","uc_output":"2663","uc_match":"2663-fe0f","uc_greedy":"2663-fe0f","shortnames":[],"category":"symbols"},":coffee:":{"uc_base":"2615","uc_output":"2615","uc_match":"2615-fe0f","uc_greedy":"2615-fe0f","shortnames":[],"category":"food"},":coffin:":{"uc_base":"26b0","uc_output":"26b0","uc_match":"26b0-fe0f","uc_greedy":"26b0-fe0f","shortnames":[],"category":"objects"},":comet:":{"uc_base":"2604","uc_output":"2604","uc_match":"2604-fe0f","uc_greedy":"2604-fe0f","shortnames":[],"category":"nature"},":congratulations:":{"uc_base":"3297","uc_output":"3297","uc_match":"3297-fe0f","uc_greedy":"3297-fe0f","shortnames":[],"category":"symbols"},":copyright:":{"uc_base":"00a9","uc_output":"00a9","uc_match":"00a9-fe0f","uc_greedy":"00a9","shortnames":[],"category":"symbols"},":cross:":{"uc_base":"271d","uc_output":"271d","uc_match":"271d-fe0f","uc_greedy":"271d","shortnames":[":latin_cross:"],"category":"symbols"},":crossed_swords:":{"uc_base":"2694","uc_output":"2694","uc_match":"2694-fe0f","uc_greedy":"2694-fe0f","shortnames":[],"category":"objects"},":curly_loop:":{"uc_base":"27b0","uc_output":"27b0","uc_match":"27b0","uc_greedy":"27b0","shortnames":[],"category":"symbols"},":diamonds:":{"uc_base":"2666","uc_output":"2666","uc_match":"2666-fe0f","uc_greedy":"2666-fe0f","shortnames":[],"category":"symbols"},":eight_pointed_black_star:":{"uc_base":"2734","uc_output":"2734","uc_match":"2734-fe0f","uc_greedy":"2734-fe0f","shortnames":[],"category":"symbols"},":eight_spoked_asterisk:":{"uc_base":"2733","uc_output":"2733","uc_match":"2733-fe0f","uc_greedy":"2733-fe0f","shortnames":[],"category":"symbols"},":eject:":{"uc_base":"23cf","uc_output":"23cf","uc_match":"23cf-fe0f","uc_greedy":"23cf","shortnames":[":eject_symbol:"],"category":"symbols"},":envelope:":{"uc_base":"2709","uc_output":"2709","uc_match":"2709-fe0f","uc_greedy":"2709-fe0f","shortnames":[],"category":"objects"},":exclamation:":{"uc_base":"2757","uc_output":"2757","uc_match":"2757-fe0f","uc_greedy":"2757-fe0f","shortnames":[],"category":"symbols"},":fast_forward:":{"uc_base":"23e9","uc_output":"23e9","uc_match":"23e9-fe0f","uc_greedy":"23e9-fe0f","shortnames":[],"category":"symbols"},":female_sign:":{"uc_base":"2640","uc_output":"2640","uc_match":"2640-fe0f","uc_greedy":"2640","shortnames":[],"category":"symbols"},":ferry:":{"uc_base":"26f4","uc_output":"26f4","uc_match":"26f4-fe0f","uc_greedy":"26f4-fe0f","shortnames":[],"category":"travel"},":fist:":{"uc_base":"270a","uc_output":"270a","uc_match":"270a","uc_greedy":"270a","shortnames":[],"category":"people"},":fleur-de-lis:":{"uc_base":"269c","uc_output":"269c","uc_match":"269c-fe0f","uc_greedy":"269c-fe0f","shortnames":[],"category":"symbols"},":fountain:":{"uc_base":"26f2","uc_output":"26f2","uc_match":"26f2-fe0f","uc_greedy":"26f2-fe0f","shortnames":[],"category":"travel"},":frowning2:":{"uc_base":"2639","uc_output":"2639","uc_match":"2639-fe0f","uc_greedy":"2639-fe0f","shortnames":[":white_frowning_face:"],"category":"people"},":fuelpump:":{"uc_base":"26fd","uc_output":"26fd","uc_match":"26fd-fe0f","uc_greedy":"26fd-fe0f","shortnames":[],"category":"travel"},":gear:":{"uc_base":"2699","uc_output":"2699","uc_match":"2699-fe0f","uc_greedy":"2699-fe0f","shortnames":[],"category":"objects"},":gemini:":{"uc_base":"264a","uc_output":"264a","uc_match":"264a-fe0f","uc_greedy":"264a-fe0f","shortnames":[],"category":"symbols"},":golf:":{"uc_base":"26f3","uc_output":"26f3","uc_match":"26f3-fe0f","uc_greedy":"26f3-fe0f","shortnames":[],"category":"activity"},":grey_exclamation:":{"uc_base":"2755","uc_output":"2755","uc_match":"2755","uc_greedy":"2755","shortnames":[],"category":"symbols"},":grey_question:":{"uc_base":"2754","uc_output":"2754","uc_match":"2754","uc_greedy":"2754","shortnames":[],"category":"symbols"},":hammer_pick:":{"uc_base":"2692","uc_output":"2692","uc_match":"2692-fe0f","uc_greedy":"2692-fe0f","shortnames":[":hammer_and_pick:"],"category":"objects"},":heart:":{"uc_base":"2764","uc_output":"2764","uc_match":"2764-fe0f","uc_greedy":"2764-fe0f","shortnames":[],"category":"symbols"},":heart_exclamation:":{"uc_base":"2763","uc_output":"2763","uc_match":"2763-fe0f","uc_greedy":"2763-fe0f","shortnames":[":heavy_heart_exclamation_mark_ornament:"],"category":"symbols"},":hearts:":{"uc_base":"2665","uc_output":"2665","uc_match":"2665-fe0f","uc_greedy":"2665-fe0f","shortnames":[],"category":"symbols"},":heavy_check_mark:":{"uc_base":"2714","uc_output":"2714","uc_match":"2714-fe0f","uc_greedy":"2714","shortnames":[],"category":"symbols"},":heavy_division_sign:":{"uc_base":"2797","uc_output":"2797","uc_match":"2797","uc_greedy":"2797","shortnames":[],"category":"symbols"},":heavy_minus_sign:":{"uc_base":"2796","uc_output":"2796","uc_match":"2796","uc_greedy":"2796","shortnames":[],"category":"symbols"},":heavy_multiplication_x:":{"uc_base":"2716","uc_output":"2716","uc_match":"2716-fe0f","uc_greedy":"2716","shortnames":[],"category":"symbols"},":heavy_plus_sign:":{"uc_base":"2795","uc_output":"2795","uc_match":"2795","uc_greedy":"2795","shortnames":[],"category":"symbols"},":helmet_with_cross:":{"uc_base":"26d1","uc_output":"26d1","uc_match":"26d1-fe0f","uc_greedy":"26d1-fe0f","shortnames":[":helmet_with_white_cross:"],"category":"people"},":hotsprings:":{"uc_base":"2668","uc_output":"2668","uc_match":"2668-fe0f","uc_greedy":"2668-fe0f","shortnames":[],"category":"symbols"},":hourglass:":{"uc_base":"231b","uc_output":"231b","uc_match":"231b-fe0f","uc_greedy":"231b-fe0f","shortnames":[],"category":"objects"},":hourglass_flowing_sand:":{"uc_base":"23f3","uc_output":"23f3","uc_match":"23f3-fe0f","uc_greedy":"23f3-fe0f","shortnames":[],"category":"objects"},":ice_skate:":{"uc_base":"26f8","uc_output":"26f8","uc_match":"26f8-fe0f","uc_greedy":"26f8-fe0f","shortnames":[],"category":"activity"},":information_source:":{"uc_base":"2139","uc_output":"2139","uc_match":"2139-fe0f","uc_greedy":"2139","shortnames":[],"category":"symbols"},":interrobang:":{"uc_base":"2049","uc_output":"2049","uc_match":"2049-fe0f","uc_greedy":"2049","shortnames":[],"category":"symbols"},":keyboard:":{"uc_base":"2328","uc_output":"2328","uc_match":"2328-fe0f","uc_greedy":"2328-fe0f","shortnames":[],"category":"objects"},":left_right_arrow:":{"uc_base":"2194","uc_output":"2194","uc_match":"2194-fe0f","uc_greedy":"2194","shortnames":[],"category":"symbols"},":leftwards_arrow_with_hook:":{"uc_base":"21a9","uc_output":"21a9","uc_match":"21a9-fe0f","uc_greedy":"21a9","shortnames":[],"category":"symbols"},":leo:":{"uc_base":"264c","uc_output":"264c","uc_match":"264c-fe0f","uc_greedy":"264c-fe0f","shortnames":[],"category":"symbols"},":libra:":{"uc_base":"264e","uc_output":"264e","uc_match":"264e-fe0f","uc_greedy":"264e-fe0f","shortnames":[],"category":"symbols"},":loop:":{"uc_base":"27bf","uc_output":"27bf","uc_match":"27bf","uc_greedy":"27bf","shortnames":[],"category":"symbols"},":m:":{"uc_base":"24c2","uc_output":"24c2","uc_match":"24c2-fe0f","uc_greedy":"24c2-fe0f","shortnames":[],"category":"symbols"},":male_sign:":{"uc_base":"2642","uc_output":"2642","uc_match":"2642-fe0f","uc_greedy":"2642","shortnames":[],"category":"symbols"},":medical_symbol:":{"uc_base":"2695","uc_output":"2695","uc_match":"2695-fe0f","uc_greedy":"2695","shortnames":[],"category":"symbols"},":mountain:":{"uc_base":"26f0","uc_output":"26f0","uc_match":"26f0-fe0f","uc_greedy":"26f0-fe0f","shortnames":[],"category":"travel"},":negative_squared_cross_mark:":{"uc_base":"274e","uc_output":"274e","uc_match":"274e","uc_greedy":"274e","shortnames":[],"category":"symbols"},":no_entry:":{"uc_base":"26d4","uc_output":"26d4","uc_match":"26d4-fe0f","uc_greedy":"26d4-fe0f","shortnames":[],"category":"symbols"},":o:":{"uc_base":"2b55","uc_output":"2b55","uc_match":"2b55-fe0f","uc_greedy":"2b55-fe0f","shortnames":[],"category":"symbols"},":ophiuchus:":{"uc_base":"26ce","uc_output":"26ce","uc_match":"26ce","uc_greedy":"26ce","shortnames":[],"category":"symbols"},":orthodox_cross:":{"uc_base":"2626","uc_output":"2626","uc_match":"2626-fe0f","uc_greedy":"2626","shortnames":[],"category":"symbols"},":part_alternation_mark:":{"uc_base":"303d","uc_output":"303d","uc_match":"303d-fe0f","uc_greedy":"303d-fe0f","shortnames":[],"category":"symbols"},":partly_sunny:":{"uc_base":"26c5","uc_output":"26c5","uc_match":"26c5-fe0f","uc_greedy":"26c5-fe0f","shortnames":[],"category":"nature"},":pause_button:":{"uc_base":"23f8","uc_output":"23f8","uc_match":"23f8-fe0f","uc_greedy":"23f8","shortnames":[":double_vertical_bar:"],"category":"symbols"},":peace:":{"uc_base":"262e","uc_output":"262e","uc_match":"262e-fe0f","uc_greedy":"262e","shortnames":[":peace_symbol:"],"category":"symbols"},":pencil2:":{"uc_base":"270f","uc_output":"270f","uc_match":"270f-fe0f","uc_greedy":"270f-fe0f","shortnames":[],"category":"objects"},":person_bouncing_ball:":{"uc_base":"26f9","uc_output":"26f9","uc_match":"26f9-fe0f","uc_greedy":"26f9-fe0f","shortnames":[":basketball_player:",":person_with_ball:"],"category":"activity"},":pick:":{"uc_base":"26cf","uc_output":"26cf","uc_match":"26cf-fe0f","uc_greedy":"26cf-fe0f","shortnames":[],"category":"objects"},":pisces:":{"uc_base":"2653","uc_output":"2653","uc_match":"2653-fe0f","uc_greedy":"2653-fe0f","shortnames":[],"category":"symbols"},":play_pause:":{"uc_base":"23ef","uc_output":"23ef","uc_match":"23ef-fe0f","uc_greedy":"23ef","shortnames":[],"category":"symbols"},":point_up:":{"uc_base":"261d","uc_output":"261d","uc_match":"261d-fe0f","uc_greedy":"261d-fe0f","shortnames":[],"category":"people"},":question:":{"uc_base":"2753","uc_output":"2753","uc_match":"2753-fe0f","uc_greedy":"2753-fe0f","shortnames":[],"category":"symbols"},":radioactive:":{"uc_base":"2622","uc_output":"2622","uc_match":"2622-fe0f","uc_greedy":"2622","shortnames":[":radioactive_sign:"],"category":"symbols"},":raised_hand:":{"uc_base":"270b","uc_output":"270b","uc_match":"270b","uc_greedy":"270b","shortnames":[],"category":"people"},":record_button:":{"uc_base":"23fa","uc_output":"23fa","uc_match":"23fa-fe0f","uc_greedy":"23fa","shortnames":[],"category":"symbols"},":recycle:":{"uc_base":"267b","uc_output":"267b","uc_match":"267b-fe0f","uc_greedy":"267b-fe0f","shortnames":[],"category":"symbols"},":registered:":{"uc_base":"00ae","uc_output":"00ae","uc_match":"00ae-fe0f","uc_greedy":"00ae","shortnames":[],"category":"symbols"},":relaxed:":{"uc_base":"263a","uc_output":"263a","uc_match":"263a-fe0f","uc_greedy":"263a-fe0f","shortnames":[],"category":"people"},":rewind:":{"uc_base":"23ea","uc_output":"23ea","uc_match":"23ea-fe0f","uc_greedy":"23ea-fe0f","shortnames":[],"category":"symbols"},":sagittarius:":{"uc_base":"2650","uc_output":"2650","uc_match":"2650-fe0f","uc_greedy":"2650-fe0f","shortnames":[],"category":"symbols"},":sailboat:":{"uc_base":"26f5","uc_output":"26f5","uc_match":"26f5-fe0f","uc_greedy":"26f5-fe0f","shortnames":[],"category":"travel"},":scales:":{"uc_base":"2696","uc_output":"2696","uc_match":"2696-fe0f","uc_greedy":"2696-fe0f","shortnames":[],"category":"objects"},":scissors:":{"uc_base":"2702","uc_output":"2702","uc_match":"2702-fe0f","uc_greedy":"2702-fe0f","shortnames":[],"category":"objects"},":scorpius:":{"uc_base":"264f","uc_output":"264f","uc_match":"264f-fe0f","uc_greedy":"264f-fe0f","shortnames":[],"category":"symbols"},":secret:":{"uc_base":"3299","uc_output":"3299","uc_match":"3299-fe0f","uc_greedy":"3299-fe0f","shortnames":[],"category":"symbols"},":shamrock:":{"uc_base":"2618","uc_output":"2618","uc_match":"2618-fe0f","uc_greedy":"2618-fe0f","shortnames":[],"category":"nature"},":shinto_shrine:":{"uc_base":"26e9","uc_output":"26e9","uc_match":"26e9-fe0f","uc_greedy":"26e9-fe0f","shortnames":[],"category":"travel"},":skier:":{"uc_base":"26f7","uc_output":"26f7","uc_match":"26f7-fe0f","uc_greedy":"26f7-fe0f","shortnames":[],"category":"activity"},":skull_crossbones:":{"uc_base":"2620","uc_output":"2620","uc_match":"2620-fe0f","uc_greedy":"2620-fe0f","shortnames":[":skull_and_crossbones:"],"category":"people"},":snowflake:":{"uc_base":"2744","uc_output":"2744","uc_match":"2744-fe0f","uc_greedy":"2744-fe0f","shortnames":[],"category":"nature"},":snowman2:":{"uc_base":"2603","uc_output":"2603","uc_match":"2603-fe0f","uc_greedy":"2603-fe0f","shortnames":[],"category":"nature"},":snowman:":{"uc_base":"26c4","uc_output":"26c4","uc_match":"26c4-fe0f","uc_greedy":"26c4-fe0f","shortnames":[],"category":"nature"},":soccer:":{"uc_base":"26bd","uc_output":"26bd","uc_match":"26bd-fe0f","uc_greedy":"26bd-fe0f","shortnames":[],"category":"activity"},":spades:":{"uc_base":"2660","uc_output":"2660","uc_match":"2660-fe0f","uc_greedy":"2660-fe0f","shortnames":[],"category":"symbols"},":sparkle:":{"uc_base":"2747","uc_output":"2747","uc_match":"2747-fe0f","uc_greedy":"2747-fe0f","shortnames":[],"category":"symbols"},":sparkles:":{"uc_base":"2728","uc_output":"2728","uc_match":"2728","uc_greedy":"2728","shortnames":[],"category":"nature"},":star:":{"uc_base":"2b50","uc_output":"2b50","uc_match":"2b50-fe0f","uc_greedy":"2b50-fe0f","shortnames":[],"category":"nature"},":star_and_crescent:":{"uc_base":"262a","uc_output":"262a","uc_match":"262a-fe0f","uc_greedy":"262a","shortnames":[],"category":"symbols"},":star_of_david:":{"uc_base":"2721","uc_output":"2721","uc_match":"2721-fe0f","uc_greedy":"2721","shortnames":[],"category":"symbols"},":stop_button:":{"uc_base":"23f9","uc_output":"23f9","uc_match":"23f9-fe0f","uc_greedy":"23f9","shortnames":[],"category":"symbols"},":stopwatch:":{"uc_base":"23f1","uc_output":"23f1","uc_match":"23f1-fe0f","uc_greedy":"23f1-fe0f","shortnames":[],"category":"objects"},":sunny:":{"uc_base":"2600","uc_output":"2600","uc_match":"2600-fe0f","uc_greedy":"2600-fe0f","shortnames":[],"category":"nature"},":taurus:":{"uc_base":"2649","uc_output":"2649","uc_match":"2649-fe0f","uc_greedy":"2649-fe0f","shortnames":[],"category":"symbols"},":telephone:":{"uc_base":"260e","uc_output":"260e","uc_match":"260e-fe0f","uc_greedy":"260e-fe0f","shortnames":[],"category":"objects"},":tent:":{"uc_base":"26fa","uc_output":"26fa","uc_match":"26fa-fe0f","uc_greedy":"26fa-fe0f","shortnames":[],"category":"travel"},":thunder_cloud_rain:":{"uc_base":"26c8","uc_output":"26c8","uc_match":"26c8-fe0f","uc_greedy":"26c8-fe0f","shortnames":[":thunder_cloud_and_rain:"],"category":"nature"},":timer:":{"uc_base":"23f2","uc_output":"23f2","uc_match":"23f2-fe0f","uc_greedy":"23f2-fe0f","shortnames":[":timer_clock:"],"category":"objects"},":tm:":{"uc_base":"2122","uc_output":"2122","uc_match":"2122-fe0f","uc_greedy":"2122","shortnames":[],"category":"symbols"},":track_next:":{"uc_base":"23ed","uc_output":"23ed","uc_match":"23ed-fe0f","uc_greedy":"23ed","shortnames":[":next_track:"],"category":"symbols"},":track_previous:":{"uc_base":"23ee","uc_output":"23ee","uc_match":"23ee-fe0f","uc_greedy":"23ee","shortnames":[":previous_track:"],"category":"symbols"},":umbrella2:":{"uc_base":"2602","uc_output":"2602","uc_match":"2602-fe0f","uc_greedy":"2602-fe0f","shortnames":[],"category":"nature"},":umbrella:":{"uc_base":"2614","uc_output":"2614","uc_match":"2614-fe0f","uc_greedy":"2614-fe0f","shortnames":[],"category":"nature"},":urn:":{"uc_base":"26b1","uc_output":"26b1","uc_match":"26b1-fe0f","uc_greedy":"26b1-fe0f","shortnames":[":funeral_urn:"],"category":"objects"},":v:":{"uc_base":"270c","uc_output":"270c","uc_match":"270c-fe0f","uc_greedy":"270c-fe0f","shortnames":[],"category":"people"},":virgo:":{"uc_base":"264d","uc_output":"264d","uc_match":"264d-fe0f","uc_greedy":"264d-fe0f","shortnames":[],"category":"symbols"},":warning:":{"uc_base":"26a0","uc_output":"26a0","uc_match":"26a0-fe0f","uc_greedy":"26a0","shortnames":[],"category":"symbols"},":watch:":{"uc_base":"231a","uc_output":"231a","uc_match":"231a-fe0f","uc_greedy":"231a-fe0f","shortnames":[],"category":"objects"},":wavy_dash:":{"uc_base":"3030","uc_output":"3030","uc_match":"3030-fe0f","uc_greedy":"3030","shortnames":[],"category":"symbols"},":wheel_of_dharma:":{"uc_base":"2638","uc_output":"2638","uc_match":"2638-fe0f","uc_greedy":"2638","shortnames":[],"category":"symbols"},":wheelchair:":{"uc_base":"267f","uc_output":"267f","uc_match":"267f-fe0f","uc_greedy":"267f-fe0f","shortnames":[],"category":"symbols"},":white_check_mark:":{"uc_base":"2705","uc_output":"2705","uc_match":"2705","uc_greedy":"2705","shortnames":[],"category":"symbols"},":white_circle:":{"uc_base":"26aa","uc_output":"26aa","uc_match":"26aa-fe0f","uc_greedy":"26aa-fe0f","shortnames":[],"category":"symbols"},":white_large_square:":{"uc_base":"2b1c","uc_output":"2b1c","uc_match":"2b1c-fe0f","uc_greedy":"2b1c-fe0f","shortnames":[],"category":"symbols"},":white_medium_small_square:":{"uc_base":"25fd","uc_output":"25fd","uc_match":"25fd-fe0f","uc_greedy":"25fd-fe0f","shortnames":[],"category":"symbols"},":white_medium_square:":{"uc_base":"25fb","uc_output":"25fb","uc_match":"25fb-fe0f","uc_greedy":"25fb","shortnames":[],"category":"symbols"},":white_small_square:":{"uc_base":"25ab","uc_output":"25ab","uc_match":"25ab-fe0f","uc_greedy":"25ab","shortnames":[],"category":"symbols"},":writing_hand:":{"uc_base":"270d","uc_output":"270d","uc_match":"270d-fe0f","uc_greedy":"270d-fe0f","shortnames":[],"category":"people"},":x:":{"uc_base":"274c","uc_output":"274c","uc_match":"274c","uc_greedy":"274c","shortnames":[],"category":"symbols"},":yin_yang:":{"uc_base":"262f","uc_output":"262f","uc_match":"262f-fe0f","uc_greedy":"262f","shortnames":[],"category":"symbols"},":zap:":{"uc_base":"26a1","uc_output":"26a1","uc_match":"26a1-fe0f","uc_greedy":"26a1-fe0f","shortnames":[],"category":"nature"}};
+
+ var tmpShortNames = [], emoji;
+ for (emoji in ns.emojioneList) {
+ if (!ns.emojioneList.hasOwnProperty(emoji) || (emoji === '')) continue;
+ tmpShortNames.push(emoji.replace(/[+]/g, "\\$&"));
+ for (var i = 0; i < ns.emojioneList[emoji].shortnames.length; i++) {
+ tmpShortNames.push(ns.emojioneList[emoji].shortnames[i].replace(/[+]/g, "\\$&"));
+ }
+ }
+ ns.shortnames = tmpShortNames.join('|');
+
+ // javascript escapes here must be ordered from largest length to shortest
+ ns.jsEscapeMap = {"\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69":"1f469-2764-1f48b-1f469","\uD83D\uDC68\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68":"1f468-2764-1f48b-1f468","\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68":"1f469-2764-1f48b-1f468","\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67\uDB40\uDC7F":"1f3f4-e0067-e0062-e0065-e006e-e0067-e007f","\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74\uDB40\uDC7F":"1f3f4-e0067-e0062-e0073-e0063-e0074-e007f","\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73\uDB40\uDC7F":"1f3f4-e0067-e0062-e0077-e006c-e0073-e007f","\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC66\u200D\uD83D\uDC66":"1f468-1f468-1f466-1f466","\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC66":"1f468-1f468-1f467-1f466","\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC67":"1f468-1f468-1f467-1f467","\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66":"1f468-1f469-1f466-1f466","\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66":"1f468-1f469-1f467-1f466","\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC67":"1f468-1f469-1f467-1f467","\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66":"1f469-1f469-1f466-1f466","\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66":"1f469-1f469-1f467-1f466","\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC67":"1f469-1f469-1f467-1f467","\uD83D\uDC68\u200D\u2764\u200D\uD83D\uDC8B\u200D\uD83D\uDC68":"1f468-2764-1f48b-1f468","\uD83D\uDC69\u200D\u2764\u200D\uD83D\uDC8B\u200D\uD83D\uDC68":"1f469-2764-1f48b-1f468","\uD83D\uDC69\u200D\u2764\u200D\uD83D\uDC8B\u200D\uD83D\uDC69":"1f469-2764-1f48b-1f469","\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC69":"1f469-2764-1f469","\uD83D\uDC68\u200D\u2764\uFE0F\u200D\uD83D\uDC68":"1f468-2764-1f468","\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC68":"1f469-2764-1f468","\uD83D\uDD75\uFE0F\uD83C\uDFFB\u200D\u2640\uFE0F":"1f575-1f3fb-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFB\u200D\u2642\uFE0F":"1f575-1f3fb-2642","\uD83D\uDD75\uFE0F\uD83C\uDFFC\u200D\u2640\uFE0F":"1f575-1f3fc-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFC\u200D\u2642\uFE0F":"1f575-1f3fc-2642","\uD83D\uDD75\uFE0F\uD83C\uDFFD\u200D\u2640\uFE0F":"1f575-1f3fd-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFD\u200D\u2642\uFE0F":"1f575-1f3fd-2642","\uD83D\uDD75\uFE0F\uD83C\uDFFE\u200D\u2640\uFE0F":"1f575-1f3fe-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFE\u200D\u2642\uFE0F":"1f575-1f3fe-2642","\uD83D\uDD75\uFE0F\uD83C\uDFFF\u200D\u2640\uFE0F":"1f575-1f3ff-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFF\u200D\u2642\uFE0F":"1f575-1f3ff-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFB\u200D\u2640\uFE0F":"1f3cb-1f3fb-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFB\u200D\u2642\uFE0F":"1f3cb-1f3fb-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFC\u200D\u2640\uFE0F":"1f3cb-1f3fc-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFC\u200D\u2642\uFE0F":"1f3cb-1f3fc-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFD\u200D\u2640\uFE0F":"1f3cb-1f3fd-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFD\u200D\u2642\uFE0F":"1f3cb-1f3fd-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFE\u200D\u2640\uFE0F":"1f3cb-1f3fe-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFE\u200D\u2642\uFE0F":"1f3cb-1f3fe-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFF\u200D\u2640\uFE0F":"1f3cb-1f3ff-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFF\u200D\u2642\uFE0F":"1f3cb-1f3ff-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFB\u200D\u2640\uFE0F":"1f3cc-1f3fb-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFB\u200D\u2642\uFE0F":"1f3cc-1f3fb-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFC\u200D\u2640\uFE0F":"1f3cc-1f3fc-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFC\u200D\u2642\uFE0F":"1f3cc-1f3fc-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFD\u200D\u2640\uFE0F":"1f3cc-1f3fd-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFD\u200D\u2642\uFE0F":"1f3cc-1f3fd-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFE\u200D\u2640\uFE0F":"1f3cc-1f3fe-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFE\u200D\u2642\uFE0F":"1f3cc-1f3fe-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFF\u200D\u2640\uFE0F":"1f3cc-1f3ff-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFF\u200D\u2642\uFE0F":"1f3cc-1f3ff-2642","\u26F9\uFE0F\uD83C\uDFFB\u200D\u2640\uFE0F":"26f9-1f3fb-2640","\u26F9\uFE0F\uD83C\uDFFB\u200D\u2642\uFE0F":"26f9-1f3fb-2642","\u26F9\uFE0F\uD83C\uDFFC\u200D\u2640\uFE0F":"26f9-1f3fc-2640","\u26F9\uFE0F\uD83C\uDFFC\u200D\u2642\uFE0F":"26f9-1f3fc-2642","\u26F9\uFE0F\uD83C\uDFFD\u200D\u2640\uFE0F":"26f9-1f3fd-2640","\u26F9\uFE0F\uD83C\uDFFD\u200D\u2642\uFE0F":"26f9-1f3fd-2642","\u26F9\uFE0F\uD83C\uDFFE\u200D\u2640\uFE0F":"26f9-1f3fe-2640","\u26F9\uFE0F\uD83C\uDFFE\u200D\u2642\uFE0F":"26f9-1f3fe-2642","\u26F9\uFE0F\uD83C\uDFFF\u200D\u2640\uFE0F":"26f9-1f3ff-2640","\u26F9\uFE0F\uD83C\uDFFF\u200D\u2642\uFE0F":"26f9-1f3ff-2642","\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC66":"1f468-1f468-1f466","\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67":"1f468-1f468-1f467","\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67":"1f468-1f469-1f467","\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC66":"1f469-1f469-1f466","\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC67":"1f469-1f469-1f467","\uD83D\uDC68\u200D\uD83D\uDC66\u200D\uD83D\uDC66":"1f468-1f466-1f466","\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC66":"1f468-1f467-1f466","\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66":"1f469-1f466-1f466","\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66":"1f469-1f467-1f466","\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC67":"1f469-1f467-1f467","\uD83D\uDC68\u2764\uFE0F\uD83D\uDC8B\uD83D\uDC68":"1f468-2764-1f48b-1f468","\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC67":"1f468-1f467-1f467","\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC66":"1f468-1f469-1f466","\uD83D\uDC69\u2764\uFE0F\uD83D\uDC8B\uD83D\uDC68":"1f469-2764-1f48b-1f468","\uD83D\uDC69\u2764\uFE0F\uD83D\uDC8B\uD83D\uDC69":"1f469-2764-1f48b-1f469","\uD83D\uDC68\u200D\u2764\u200D\uD83D\uDC68":"1f468-2764-1f468","\uD83D\uDC69\u200D\u2764\u200D\uD83D\uDC68":"1f469-2764-1f468","\uD83D\uDC69\u200D\u2764\u200D\uD83D\uDC69":"1f469-2764-1f469","\uD83D\uDC68\uD83C\uDFFB\u200D\u2695\uFE0F":"1f468-1f3fb-2695","\uD83D\uDC68\uD83C\uDFFB\u200D\u2696\uFE0F":"1f468-1f3fb-2696","\uD83D\uDC68\uD83C\uDFFB\u200D\u2708\uFE0F":"1f468-1f3fb-2708","\uD83D\uDC68\uD83C\uDFFC\u200D\u2695\uFE0F":"1f468-1f3fc-2695","\uD83D\uDC68\uD83C\uDFFC\u200D\u2696\uFE0F":"1f468-1f3fc-2696","\uD83D\uDC68\uD83C\uDFFC\u200D\u2708\uFE0F":"1f468-1f3fc-2708","\uD83D\uDC68\uD83C\uDFFD\u200D\u2695\uFE0F":"1f468-1f3fd-2695","\uD83D\uDC68\uD83C\uDFFD\u200D\u2696\uFE0F":"1f468-1f3fd-2696","\uD83D\uDC68\uD83C\uDFFD\u200D\u2708\uFE0F":"1f468-1f3fd-2708","\uD83D\uDC68\uD83C\uDFFE\u200D\u2695\uFE0F":"1f468-1f3fe-2695","\uD83D\uDC68\uD83C\uDFFE\u200D\u2696\uFE0F":"1f468-1f3fe-2696","\uD83D\uDC68\uD83C\uDFFE\u200D\u2708\uFE0F":"1f468-1f3fe-2708","\uD83D\uDC68\uD83C\uDFFF\u200D\u2695\uFE0F":"1f468-1f3ff-2695","\uD83D\uDC68\uD83C\uDFFF\u200D\u2696\uFE0F":"1f468-1f3ff-2696","\uD83D\uDC68\uD83C\uDFFF\u200D\u2708\uFE0F":"1f468-1f3ff-2708","\uD83D\uDC69\uD83C\uDFFB\u200D\u2695\uFE0F":"1f469-1f3fb-2695","\uD83D\uDC69\uD83C\uDFFB\u200D\u2696\uFE0F":"1f469-1f3fb-2696","\uD83D\uDC69\uD83C\uDFFB\u200D\u2708\uFE0F":"1f469-1f3fb-2708","\uD83D\uDC69\uD83C\uDFFC\u200D\u2695\uFE0F":"1f469-1f3fc-2695","\uD83D\uDC69\uD83C\uDFFC\u200D\u2696\uFE0F":"1f469-1f3fc-2696","\uD83D\uDC69\uD83C\uDFFC\u200D\u2708\uFE0F":"1f469-1f3fc-2708","\uD83D\uDC69\uD83C\uDFFD\u200D\u2695\uFE0F":"1f469-1f3fd-2695","\uD83D\uDC69\uD83C\uDFFD\u200D\u2696\uFE0F":"1f469-1f3fd-2696","\uD83D\uDC69\uD83C\uDFFD\u200D\u2708\uFE0F":"1f469-1f3fd-2708","\uD83D\uDC69\uD83C\uDFFE\u200D\u2695\uFE0F":"1f469-1f3fe-2695","\uD83D\uDC69\uD83C\uDFFE\u200D\u2696\uFE0F":"1f469-1f3fe-2696","\uD83D\uDC69\uD83C\uDFFE\u200D\u2708\uFE0F":"1f469-1f3fe-2708","\uD83D\uDC69\uD83C\uDFFF\u200D\u2695\uFE0F":"1f469-1f3ff-2695","\uD83D\uDC69\uD83C\uDFFF\u200D\u2696\uFE0F":"1f469-1f3ff-2696","\uD83D\uDC69\uD83C\uDFFF\u200D\u2708\uFE0F":"1f469-1f3ff-2708","\uD83D\uDC6E\uD83C\uDFFB\u200D\u2640\uFE0F":"1f46e-1f3fb-2640","\uD83D\uDC6E\uD83C\uDFFB\u200D\u2642\uFE0F":"1f46e-1f3fb-2642","\uD83D\uDC6E\uD83C\uDFFC\u200D\u2640\uFE0F":"1f46e-1f3fc-2640","\uD83D\uDC6E\uD83C\uDFFC\u200D\u2642\uFE0F":"1f46e-1f3fc-2642","\uD83D\uDC6E\uD83C\uDFFD\u200D\u2640\uFE0F":"1f46e-1f3fd-2640","\uD83D\uDC6E\uD83C\uDFFD\u200D\u2642\uFE0F":"1f46e-1f3fd-2642","\uD83D\uDC6E\uD83C\uDFFE\u200D\u2640\uFE0F":"1f46e-1f3fe-2640","\uD83D\uDC6E\uD83C\uDFFE\u200D\u2642\uFE0F":"1f46e-1f3fe-2642","\uD83D\uDC6E\uD83C\uDFFF\u200D\u2640\uFE0F":"1f46e-1f3ff-2640","\uD83D\uDC6E\uD83C\uDFFF\u200D\u2642\uFE0F":"1f46e-1f3ff-2642","\uD83D\uDC71\uD83C\uDFFB\u200D\u2640\uFE0F":"1f471-1f3fb-2640","\uD83D\uDC71\uD83C\uDFFB\u200D\u2642\uFE0F":"1f471-1f3fb-2642","\uD83D\uDC71\uD83C\uDFFC\u200D\u2640\uFE0F":"1f471-1f3fc-2640","\uD83D\uDC71\uD83C\uDFFC\u200D\u2642\uFE0F":"1f471-1f3fc-2642","\uD83D\uDC71\uD83C\uDFFD\u200D\u2640\uFE0F":"1f471-1f3fd-2640","\uD83D\uDC71\uD83C\uDFFD\u200D\u2642\uFE0F":"1f471-1f3fd-2642","\uD83D\uDC71\uD83C\uDFFE\u200D\u2640\uFE0F":"1f471-1f3fe-2640","\uD83D\uDC71\uD83C\uDFFE\u200D\u2642\uFE0F":"1f471-1f3fe-2642","\uD83D\uDC71\uD83C\uDFFF\u200D\u2640\uFE0F":"1f471-1f3ff-2640","\uD83D\uDC71\uD83C\uDFFF\u200D\u2642\uFE0F":"1f471-1f3ff-2642","\uD83D\uDC73\uD83C\uDFFB\u200D\u2640\uFE0F":"1f473-1f3fb-2640","\uD83D\uDC73\uD83C\uDFFB\u200D\u2642\uFE0F":"1f473-1f3fb-2642","\uD83D\uDC73\uD83C\uDFFC\u200D\u2640\uFE0F":"1f473-1f3fc-2640","\uD83D\uDC73\uD83C\uDFFC\u200D\u2642\uFE0F":"1f473-1f3fc-2642","\uD83D\uDC73\uD83C\uDFFD\u200D\u2640\uFE0F":"1f473-1f3fd-2640","\uD83D\uDC73\uD83C\uDFFD\u200D\u2642\uFE0F":"1f473-1f3fd-2642","\uD83D\uDC73\uD83C\uDFFE\u200D\u2640\uFE0F":"1f473-1f3fe-2640","\uD83D\uDC73\uD83C\uDFFE\u200D\u2642\uFE0F":"1f473-1f3fe-2642","\uD83D\uDC73\uD83C\uDFFF\u200D\u2640\uFE0F":"1f473-1f3ff-2640","\uD83D\uDC73\uD83C\uDFFF\u200D\u2642\uFE0F":"1f473-1f3ff-2642","\uD83D\uDC77\uD83C\uDFFB\u200D\u2640\uFE0F":"1f477-1f3fb-2640","\uD83D\uDC77\uD83C\uDFFB\u200D\u2642\uFE0F":"1f477-1f3fb-2642","\uD83D\uDC77\uD83C\uDFFC\u200D\u2640\uFE0F":"1f477-1f3fc-2640","\uD83D\uDC77\uD83C\uDFFC\u200D\u2642\uFE0F":"1f477-1f3fc-2642","\uD83D\uDC77\uD83C\uDFFD\u200D\u2640\uFE0F":"1f477-1f3fd-2640","\uD83D\uDC77\uD83C\uDFFD\u200D\u2642\uFE0F":"1f477-1f3fd-2642","\uD83D\uDC77\uD83C\uDFFE\u200D\u2640\uFE0F":"1f477-1f3fe-2640","\uD83D\uDC77\uD83C\uDFFE\u200D\u2642\uFE0F":"1f477-1f3fe-2642","\uD83D\uDC77\uD83C\uDFFF\u200D\u2640\uFE0F":"1f477-1f3ff-2640","\uD83D\uDC77\uD83C\uDFFF\u200D\u2642\uFE0F":"1f477-1f3ff-2642","\uD83D\uDC82\uD83C\uDFFB\u200D\u2640\uFE0F":"1f482-1f3fb-2640","\uD83D\uDC82\uD83C\uDFFB\u200D\u2642\uFE0F":"1f482-1f3fb-2642","\uD83D\uDC82\uD83C\uDFFC\u200D\u2640\uFE0F":"1f482-1f3fc-2640","\uD83D\uDC82\uD83C\uDFFC\u200D\u2642\uFE0F":"1f482-1f3fc-2642","\uD83D\uDC82\uD83C\uDFFD\u200D\u2640\uFE0F":"1f482-1f3fd-2640","\uD83D\uDC82\uD83C\uDFFD\u200D\u2642\uFE0F":"1f482-1f3fd-2642","\uD83D\uDC82\uD83C\uDFFE\u200D\u2640\uFE0F":"1f482-1f3fe-2640","\uD83D\uDC82\uD83C\uDFFE\u200D\u2642\uFE0F":"1f482-1f3fe-2642","\uD83D\uDC82\uD83C\uDFFF\u200D\u2640\uFE0F":"1f482-1f3ff-2640","\uD83D\uDC82\uD83C\uDFFF\u200D\u2642\uFE0F":"1f482-1f3ff-2642","\uD83D\uDD75\uFE0F\uD83C\uDFFB\u2640\uFE0F":"1f575-1f3fb-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFB\u2642\uFE0F":"1f575-1f3fb-2642","\uD83D\uDD75\uFE0F\uD83C\uDFFC\u2640\uFE0F":"1f575-1f3fc-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFC\u2642\uFE0F":"1f575-1f3fc-2642","\uD83D\uDD75\uFE0F\uD83C\uDFFD\u2640\uFE0F":"1f575-1f3fd-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFD\u2642\uFE0F":"1f575-1f3fd-2642","\uD83D\uDD75\uFE0F\uD83C\uDFFE\u2640\uFE0F":"1f575-1f3fe-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFE\u2642\uFE0F":"1f575-1f3fe-2642","\uD83D\uDD75\uFE0F\uD83C\uDFFF\u2640\uFE0F":"1f575-1f3ff-2640","\uD83D\uDD75\uFE0F\uD83C\uDFFF\u2642\uFE0F":"1f575-1f3ff-2642","\uD83C\uDFC3\uD83C\uDFFB\u200D\u2640\uFE0F":"1f3c3-1f3fb-2640","\uD83C\uDFC3\uD83C\uDFFB\u200D\u2642\uFE0F":"1f3c3-1f3fb-2642","\uD83C\uDFC3\uD83C\uDFFC\u200D\u2640\uFE0F":"1f3c3-1f3fc-2640","\uD83C\uDFC3\uD83C\uDFFC\u200D\u2642\uFE0F":"1f3c3-1f3fc-2642","\uD83C\uDFC3\uD83C\uDFFD\u200D\u2640\uFE0F":"1f3c3-1f3fd-2640","\uD83C\uDFC3\uD83C\uDFFD\u200D\u2642\uFE0F":"1f3c3-1f3fd-2642","\uD83C\uDFC3\uD83C\uDFFE\u200D\u2640\uFE0F":"1f3c3-1f3fe-2640","\uD83C\uDFC3\uD83C\uDFFE\u200D\u2642\uFE0F":"1f3c3-1f3fe-2642","\uD83C\uDFC3\uD83C\uDFFF\u200D\u2640\uFE0F":"1f3c3-1f3ff-2640","\uD83C\uDFC3\uD83C\uDFFF\u200D\u2642\uFE0F":"1f3c3-1f3ff-2642","\uD83C\uDFC4\uD83C\uDFFB\u200D\u2640\uFE0F":"1f3c4-1f3fb-2640","\uD83C\uDFC4\uD83C\uDFFB\u200D\u2642\uFE0F":"1f3c4-1f3fb-2642","\uD83C\uDFC4\uD83C\uDFFC\u200D\u2640\uFE0F":"1f3c4-1f3fc-2640","\uD83C\uDFC4\uD83C\uDFFC\u200D\u2642\uFE0F":"1f3c4-1f3fc-2642","\uD83C\uDFC4\uD83C\uDFFD\u200D\u2640\uFE0F":"1f3c4-1f3fd-2640","\uD83C\uDFC4\uD83C\uDFFD\u200D\u2642\uFE0F":"1f3c4-1f3fd-2642","\uD83C\uDFC4\uD83C\uDFFE\u200D\u2640\uFE0F":"1f3c4-1f3fe-2640","\uD83C\uDFC4\uD83C\uDFFE\u200D\u2642\uFE0F":"1f3c4-1f3fe-2642","\uD83C\uDFC4\uD83C\uDFFF\u200D\u2640\uFE0F":"1f3c4-1f3ff-2640","\uD83C\uDFC4\uD83C\uDFFF\u200D\u2642\uFE0F":"1f3c4-1f3ff-2642","\uD83C\uDFCA\uD83C\uDFFB\u200D\u2640\uFE0F":"1f3ca-1f3fb-2640","\uD83C\uDFCA\uD83C\uDFFB\u200D\u2642\uFE0F":"1f3ca-1f3fb-2642","\uD83C\uDFCA\uD83C\uDFFC\u200D\u2640\uFE0F":"1f3ca-1f3fc-2640","\uD83C\uDFCA\uD83C\uDFFC\u200D\u2642\uFE0F":"1f3ca-1f3fc-2642","\uD83C\uDFCA\uD83C\uDFFD\u200D\u2640\uFE0F":"1f3ca-1f3fd-2640","\uD83C\uDFCA\uD83C\uDFFD\u200D\u2642\uFE0F":"1f3ca-1f3fd-2642","\uD83C\uDFCA\uD83C\uDFFE\u200D\u2640\uFE0F":"1f3ca-1f3fe-2640","\uD83C\uDFCA\uD83C\uDFFE\u200D\u2642\uFE0F":"1f3ca-1f3fe-2642","\uD83C\uDFCA\uD83C\uDFFF\u200D\u2640\uFE0F":"1f3ca-1f3ff-2640","\uD83C\uDFCA\uD83C\uDFFF\u200D\u2642\uFE0F":"1f3ca-1f3ff-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFB\u2640\uFE0F":"1f3cb-1f3fb-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFB\u2642\uFE0F":"1f3cb-1f3fb-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFC\u2640\uFE0F":"1f3cb-1f3fc-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFC\u2642\uFE0F":"1f3cb-1f3fc-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFD\u2640\uFE0F":"1f3cb-1f3fd-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFD\u2642\uFE0F":"1f3cb-1f3fd-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFE\u2640\uFE0F":"1f3cb-1f3fe-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFE\u2642\uFE0F":"1f3cb-1f3fe-2642","\uD83C\uDFCB\uFE0F\uD83C\uDFFF\u2640\uFE0F":"1f3cb-1f3ff-2640","\uD83C\uDFCB\uFE0F\uD83C\uDFFF\u2642\uFE0F":"1f3cb-1f3ff-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFB\u2640\uFE0F":"1f3cc-1f3fb-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFB\u2642\uFE0F":"1f3cc-1f3fb-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFC\u2640\uFE0F":"1f3cc-1f3fc-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFC\u2642\uFE0F":"1f3cc-1f3fc-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFD\u2640\uFE0F":"1f3cc-1f3fd-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFD\u2642\uFE0F":"1f3cc-1f3fd-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFE\u2640\uFE0F":"1f3cc-1f3fe-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFE\u2642\uFE0F":"1f3cc-1f3fe-2642","\uD83C\uDFCC\uFE0F\uD83C\uDFFF\u2640\uFE0F":"1f3cc-1f3ff-2640","\uD83C\uDFCC\uFE0F\uD83C\uDFFF\u2642\uFE0F":"1f3cc-1f3ff-2642","\uD83D\uDC86\uD83C\uDFFB\u200D\u2640\uFE0F":"1f486-1f3fb-2640","\uD83D\uDC86\uD83C\uDFFB\u200D\u2642\uFE0F":"1f486-1f3fb-2642","\uD83D\uDC86\uD83C\uDFFC\u200D\u2640\uFE0F":"1f486-1f3fc-2640","\uD83D\uDC86\uD83C\uDFFC\u200D\u2642\uFE0F":"1f486-1f3fc-2642","\uD83D\uDC86\uD83C\uDFFD\u200D\u2640\uFE0F":"1f486-1f3fd-2640","\uD83D\uDC86\uD83C\uDFFD\u200D\u2642\uFE0F":"1f486-1f3fd-2642","\uD83D\uDC86\uD83C\uDFFE\u200D\u2640\uFE0F":"1f486-1f3fe-2640","\uD83D\uDC86\uD83C\uDFFE\u200D\u2642\uFE0F":"1f486-1f3fe-2642","\uD83D\uDC86\uD83C\uDFFF\u200D\u2640\uFE0F":"1f486-1f3ff-2640","\uD83D\uDC86\uD83C\uDFFF\u200D\u2642\uFE0F":"1f486-1f3ff-2642","\uD83D\uDC87\uD83C\uDFFB\u200D\u2640\uFE0F":"1f487-1f3fb-2640","\uD83D\uDC87\uD83C\uDFFB\u200D\u2642\uFE0F":"1f487-1f3fb-2642","\uD83D\uDC87\uD83C\uDFFC\u200D\u2640\uFE0F":"1f487-1f3fc-2640","\uD83D\uDC87\uD83C\uDFFC\u200D\u2642\uFE0F":"1f487-1f3fc-2642","\uD83D\uDC87\uD83C\uDFFD\u200D\u2640\uFE0F":"1f487-1f3fd-2640","\uD83D\uDC87\uD83C\uDFFD\u200D\u2642\uFE0F":"1f487-1f3fd-2642","\uD83D\uDC87\uD83C\uDFFE\u200D\u2640\uFE0F":"1f487-1f3fe-2640","\uD83D\uDC87\uD83C\uDFFE\u200D\u2642\uFE0F":"1f487-1f3fe-2642","\uD83D\uDC87\uD83C\uDFFF\u200D\u2640\uFE0F":"1f487-1f3ff-2640","\uD83D\uDC87\uD83C\uDFFF\u200D\u2642\uFE0F":"1f487-1f3ff-2642","\uD83D\uDEA3\uD83C\uDFFB\u200D\u2640\uFE0F":"1f6a3-1f3fb-2640","\uD83D\uDEA3\uD83C\uDFFB\u200D\u2642\uFE0F":"1f6a3-1f3fb-2642","\uD83D\uDEA3\uD83C\uDFFC\u200D\u2640\uFE0F":"1f6a3-1f3fc-2640","\uD83D\uDEA3\uD83C\uDFFC\u200D\u2642\uFE0F":"1f6a3-1f3fc-2642","\uD83D\uDEA3\uD83C\uDFFD\u200D\u2640\uFE0F":"1f6a3-1f3fd-2640","\uD83D\uDEA3\uD83C\uDFFD\u200D\u2642\uFE0F":"1f6a3-1f3fd-2642","\uD83D\uDEA3\uD83C\uDFFE\u200D\u2640\uFE0F":"1f6a3-1f3fe-2640","\uD83D\uDEA3\uD83C\uDFFE\u200D\u2642\uFE0F":"1f6a3-1f3fe-2642","\uD83D\uDEA3\uD83C\uDFFF\u200D\u2640\uFE0F":"1f6a3-1f3ff-2640","\uD83D\uDEA3\uD83C\uDFFF\u200D\u2642\uFE0F":"1f6a3-1f3ff-2642","\uD83D\uDEB4\uD83C\uDFFB\u200D\u2640\uFE0F":"1f6b4-1f3fb-2640","\uD83D\uDEB4\uD83C\uDFFB\u200D\u2642\uFE0F":"1f6b4-1f3fb-2642","\uD83D\uDEB4\uD83C\uDFFC\u200D\u2640\uFE0F":"1f6b4-1f3fc-2640","\uD83D\uDEB4\uD83C\uDFFC\u200D\u2642\uFE0F":"1f6b4-1f3fc-2642","\uD83D\uDEB4\uD83C\uDFFD\u200D\u2640\uFE0F":"1f6b4-1f3fd-2640","\uD83D\uDEB4\uD83C\uDFFD\u200D\u2642\uFE0F":"1f6b4-1f3fd-2642","\uD83D\uDEB4\uD83C\uDFFE\u200D\u2640\uFE0F":"1f6b4-1f3fe-2640","\uD83D\uDEB4\uD83C\uDFFE\u200D\u2642\uFE0F":"1f6b4-1f3fe-2642","\uD83D\uDEB4\uD83C\uDFFF\u200D\u2640\uFE0F":"1f6b4-1f3ff-2640","\uD83D\uDEB4\uD83C\uDFFF\u200D\u2642\uFE0F":"1f6b4-1f3ff-2642","\uD83D\uDEB5\uD83C\uDFFB\u200D\u2640\uFE0F":"1f6b5-1f3fb-2640","\uD83D\uDEB5\uD83C\uDFFB\u200D\u2642\uFE0F":"1f6b5-1f3fb-2642","\uD83D\uDEB5\uD83C\uDFFC\u200D\u2640\uFE0F":"1f6b5-1f3fc-2640","\uD83D\uDEB5\uD83C\uDFFC\u200D\u2642\uFE0F":"1f6b5-1f3fc-2642","\uD83D\uDEB5\uD83C\uDFFD\u200D\u2640\uFE0F":"1f6b5-1f3fd-2640","\uD83D\uDEB5\uD83C\uDFFD\u200D\u2642\uFE0F":"1f6b5-1f3fd-2642","\uD83D\uDEB5\uD83C\uDFFE\u200D\u2640\uFE0F":"1f6b5-1f3fe-2640","\uD83D\uDEB5\uD83C\uDFFE\u200D\u2642\uFE0F":"1f6b5-1f3fe-2642","\uD83D\uDEB5\uD83C\uDFFF\u200D\u2640\uFE0F":"1f6b5-1f3ff-2640","\uD83D\uDEB5\uD83C\uDFFF\u200D\u2642\uFE0F":"1f6b5-1f3ff-2642","\uD83D\uDEB6\uD83C\uDFFB\u200D\u2640\uFE0F":"1f6b6-1f3fb-2640","\uD83D\uDEB6\uD83C\uDFFB\u200D\u2642\uFE0F":"1f6b6-1f3fb-2642","\uD83D\uDEB6\uD83C\uDFFC\u200D\u2640\uFE0F":"1f6b6-1f3fc-2640","\uD83D\uDEB6\uD83C\uDFFC\u200D\u2642\uFE0F":"1f6b6-1f3fc-2642","\uD83D\uDEB6\uD83C\uDFFD\u200D\u2640\uFE0F":"1f6b6-1f3fd-2640","\uD83D\uDEB6\uD83C\uDFFD\u200D\u2642\uFE0F":"1f6b6-1f3fd-2642","\uD83D\uDEB6\uD83C\uDFFE\u200D\u2640\uFE0F":"1f6b6-1f3fe-2640","\uD83D\uDEB6\uD83C\uDFFE\u200D\u2642\uFE0F":"1f6b6-1f3fe-2642","\uD83D\uDEB6\uD83C\uDFFF\u200D\u2640\uFE0F":"1f6b6-1f3ff-2640","\uD83D\uDEB6\uD83C\uDFFF\u200D\u2642\uFE0F":"1f6b6-1f3ff-2642","\uD83E\uDD38\uD83C\uDFFB\u200D\u2640\uFE0F":"1f938-1f3fb-2640","\uD83E\uDD38\uD83C\uDFFB\u200D\u2642\uFE0F":"1f938-1f3fb-2642","\uD83E\uDD38\uD83C\uDFFC\u200D\u2640\uFE0F":"1f938-1f3fc-2640","\uD83E\uDD38\uD83C\uDFFC\u200D\u2642\uFE0F":"1f938-1f3fc-2642","\uD83E\uDD38\uD83C\uDFFD\u200D\u2640\uFE0F":"1f938-1f3fd-2640","\uD83E\uDD38\uD83C\uDFFD\u200D\u2642\uFE0F":"1f938-1f3fd-2642","\uD83E\uDD38\uD83C\uDFFE\u200D\u2640\uFE0F":"1f938-1f3fe-2640","\uD83E\uDD38\uD83C\uDFFE\u200D\u2642\uFE0F":"1f938-1f3fe-2642","\uD83E\uDD38\uD83C\uDFFF\u200D\u2640\uFE0F":"1f938-1f3ff-2640","\uD83E\uDD38\uD83C\uDFFF\u200D\u2642\uFE0F":"1f938-1f3ff-2642","\uD83E\uDD39\uD83C\uDFFB\u200D\u2640\uFE0F":"1f939-1f3fb-2640","\uD83E\uDD39\uD83C\uDFFB\u200D\u2642\uFE0F":"1f939-1f3fb-2642","\uD83E\uDD39\uD83C\uDFFC\u200D\u2640\uFE0F":"1f939-1f3fc-2640","\uD83E\uDD39\uD83C\uDFFC\u200D\u2642\uFE0F":"1f939-1f3fc-2642","\uD83E\uDD39\uD83C\uDFFD\u200D\u2640\uFE0F":"1f939-1f3fd-2640","\uD83E\uDD39\uD83C\uDFFD\u200D\u2642\uFE0F":"1f939-1f3fd-2642","\uD83E\uDD39\uD83C\uDFFE\u200D\u2640\uFE0F":"1f939-1f3fe-2640","\uD83E\uDD39\uD83C\uDFFE\u200D\u2642\uFE0F":"1f939-1f3fe-2642","\uD83E\uDD39\uD83C\uDFFF\u200D\u2640\uFE0F":"1f939-1f3ff-2640","\uD83E\uDD39\uD83C\uDFFF\u200D\u2642\uFE0F":"1f939-1f3ff-2642","\uD83E\uDD3D\uD83C\uDFFB\u200D\u2640\uFE0F":"1f93d-1f3fb-2640","\uD83E\uDD3D\uD83C\uDFFB\u200D\u2642\uFE0F":"1f93d-1f3fb-2642","\uD83E\uDD3D\uD83C\uDFFC\u200D\u2640\uFE0F":"1f93d-1f3fc-2640","\uD83E\uDD3D\uD83C\uDFFC\u200D\u2642\uFE0F":"1f93d-1f3fc-2642","\uD83E\uDD3D\uD83C\uDFFD\u200D\u2640\uFE0F":"1f93d-1f3fd-2640","\uD83E\uDD3D\uD83C\uDFFD\u200D\u2642\uFE0F":"1f93d-1f3fd-2642","\uD83E\uDD3D\uD83C\uDFFE\u200D\u2640\uFE0F":"1f93d-1f3fe-2640","\uD83E\uDD3D\uD83C\uDFFE\u200D\u2642\uFE0F":"1f93d-1f3fe-2642","\uD83E\uDD3D\uD83C\uDFFF\u200D\u2640\uFE0F":"1f93d-1f3ff-2640","\uD83E\uDD3D\uD83C\uDFFF\u200D\u2642\uFE0F":"1f93d-1f3ff-2642","\uD83E\uDD3E\uD83C\uDFFB\u200D\u2640\uFE0F":"1f93e-1f3fb-2640","\uD83E\uDD3E\uD83C\uDFFB\u200D\u2642\uFE0F":"1f93e-1f3fb-2642","\uD83E\uDD3E\uD83C\uDFFC\u200D\u2640\uFE0F":"1f93e-1f3fc-2640","\uD83E\uDD3E\uD83C\uDFFC\u200D\u2642\uFE0F":"1f93e-1f3fc-2642","\uD83E\uDD3E\uD83C\uDFFD\u200D\u2640\uFE0F":"1f93e-1f3fd-2640","\uD83E\uDD3E\uD83C\uDFFD\u200D\u2642\uFE0F":"1f93e-1f3fd-2642","\uD83E\uDD3E\uD83C\uDFFE\u200D\u2640\uFE0F":"1f93e-1f3fe-2640","\uD83E\uDD3E\uD83C\uDFFE\u200D\u2642\uFE0F":"1f93e-1f3fe-2642","\uD83E\uDD3E\uD83C\uDFFF\u200D\u2640\uFE0F":"1f93e-1f3ff-2640","\uD83E\uDD3E\uD83C\uDFFF\u200D\u2642\uFE0F":"1f93e-1f3ff-2642","\uD83D\uDC81\uD83C\uDFFB\u200D\u2640\uFE0F":"1f481-1f3fb-2640","\uD83D\uDC81\uD83C\uDFFB\u200D\u2642\uFE0F":"1f481-1f3fb-2642","\uD83D\uDC81\uD83C\uDFFC\u200D\u2640\uFE0F":"1f481-1f3fc-2640","\uD83D\uDC81\uD83C\uDFFC\u200D\u2642\uFE0F":"1f481-1f3fc-2642","\uD83D\uDC81\uD83C\uDFFD\u200D\u2640\uFE0F":"1f481-1f3fd-2640","\uD83D\uDC81\uD83C\uDFFD\u200D\u2642\uFE0F":"1f481-1f3fd-2642","\uD83D\uDC81\uD83C\uDFFE\u200D\u2640\uFE0F":"1f481-1f3fe-2640","\uD83D\uDC81\uD83C\uDFFE\u200D\u2642\uFE0F":"1f481-1f3fe-2642","\uD83D\uDC81\uD83C\uDFFF\u200D\u2640\uFE0F":"1f481-1f3ff-2640","\uD83D\uDC81\uD83C\uDFFF\u200D\u2642\uFE0F":"1f481-1f3ff-2642","\uD83D\uDE45\uD83C\uDFFB\u200D\u2640\uFE0F":"1f645-1f3fb-2640","\uD83D\uDE45\uD83C\uDFFB\u200D\u2642\uFE0F":"1f645-1f3fb-2642","\uD83D\uDE45\uD83C\uDFFC\u200D\u2640\uFE0F":"1f645-1f3fc-2640","\uD83D\uDE45\uD83C\uDFFC\u200D\u2642\uFE0F":"1f645-1f3fc-2642","\uD83D\uDE45\uD83C\uDFFD\u200D\u2640\uFE0F":"1f645-1f3fd-2640","\uD83D\uDE45\uD83C\uDFFD\u200D\u2642\uFE0F":"1f645-1f3fd-2642","\uD83D\uDE45\uD83C\uDFFE\u200D\u2640\uFE0F":"1f645-1f3fe-2640","\uD83D\uDE45\uD83C\uDFFE\u200D\u2642\uFE0F":"1f645-1f3fe-2642","\uD83D\uDE45\uD83C\uDFFF\u200D\u2640\uFE0F":"1f645-1f3ff-2640","\uD83D\uDE45\uD83C\uDFFF\u200D\u2642\uFE0F":"1f645-1f3ff-2642","\uD83D\uDE46\uD83C\uDFFB\u200D\u2640\uFE0F":"1f646-1f3fb-2640","\uD83D\uDE46\uD83C\uDFFB\u200D\u2642\uFE0F":"1f646-1f3fb-2642","\uD83D\uDE46\uD83C\uDFFC\u200D\u2640\uFE0F":"1f646-1f3fc-2640","\uD83D\uDE46\uD83C\uDFFC\u200D\u2642\uFE0F":"1f646-1f3fc-2642","\uD83D\uDE46\uD83C\uDFFD\u200D\u2640\uFE0F":"1f646-1f3fd-2640","\uD83D\uDE46\uD83C\uDFFD\u200D\u2642\uFE0F":"1f646-1f3fd-2642","\uD83D\uDE46\uD83C\uDFFE\u200D\u2640\uFE0F":"1f646-1f3fe-2640","\uD83D\uDE46\uD83C\uDFFE\u200D\u2642\uFE0F":"1f646-1f3fe-2642","\uD83D\uDE46\uD83C\uDFFF\u200D\u2640\uFE0F":"1f646-1f3ff-2640","\uD83D\uDE46\uD83C\uDFFF\u200D\u2642\uFE0F":"1f646-1f3ff-2642","\uD83D\uDE47\uD83C\uDFFB\u200D\u2640\uFE0F":"1f647-1f3fb-2640","\uD83D\uDE47\uD83C\uDFFB\u200D\u2642\uFE0F":"1f647-1f3fb-2642","\uD83D\uDE47\uD83C\uDFFC\u200D\u2640\uFE0F":"1f647-1f3fc-2640","\uD83D\uDE47\uD83C\uDFFC\u200D\u2642\uFE0F":"1f647-1f3fc-2642","\uD83D\uDE47\uD83C\uDFFD\u200D\u2640\uFE0F":"1f647-1f3fd-2640","\uD83D\uDE47\uD83C\uDFFD\u200D\u2642\uFE0F":"1f647-1f3fd-2642","\uD83D\uDE47\uD83C\uDFFE\u200D\u2640\uFE0F":"1f647-1f3fe-2640","\uD83D\uDE47\uD83C\uDFFE\u200D\u2642\uFE0F":"1f647-1f3fe-2642","\uD83D\uDE47\uD83C\uDFFF\u200D\u2640\uFE0F":"1f647-1f3ff-2640","\uD83D\uDE47\uD83C\uDFFF\u200D\u2642\uFE0F":"1f647-1f3ff-2642","\uD83D\uDE4B\uD83C\uDFFB\u200D\u2640\uFE0F":"1f64b-1f3fb-2640","\uD83D\uDE4B\uD83C\uDFFB\u200D\u2642\uFE0F":"1f64b-1f3fb-2642","\uD83D\uDE4B\uD83C\uDFFC\u200D\u2640\uFE0F":"1f64b-1f3fc-2640","\uD83D\uDE4B\uD83C\uDFFC\u200D\u2642\uFE0F":"1f64b-1f3fc-2642","\uD83D\uDE4B\uD83C\uDFFD\u200D\u2640\uFE0F":"1f64b-1f3fd-2640","\uD83D\uDE4B\uD83C\uDFFD\u200D\u2642\uFE0F":"1f64b-1f3fd-2642","\uD83D\uDE4B\uD83C\uDFFE\u200D\u2640\uFE0F":"1f64b-1f3fe-2640","\uD83D\uDE4B\uD83C\uDFFE\u200D\u2642\uFE0F":"1f64b-1f3fe-2642","\uD83D\uDE4B\uD83C\uDFFF\u200D\u2640\uFE0F":"1f64b-1f3ff-2640","\uD83D\uDE4B\uD83C\uDFFF\u200D\u2642\uFE0F":"1f64b-1f3ff-2642","\uD83D\uDE4D\uD83C\uDFFB\u200D\u2640\uFE0F":"1f64d-1f3fb-2640","\uD83D\uDE4D\uD83C\uDFFB\u200D\u2642\uFE0F":"1f64d-1f3fb-2642","\uD83D\uDE4D\uD83C\uDFFC\u200D\u2640\uFE0F":"1f64d-1f3fc-2640","\uD83D\uDE4D\uD83C\uDFFC\u200D\u2642\uFE0F":"1f64d-1f3fc-2642","\uD83D\uDE4D\uD83C\uDFFD\u200D\u2640\uFE0F":"1f64d-1f3fd-2640","\uD83D\uDE4D\uD83C\uDFFD\u200D\u2642\uFE0F":"1f64d-1f3fd-2642","\uD83D\uDE4D\uD83C\uDFFE\u200D\u2640\uFE0F":"1f64d-1f3fe-2640","\uD83D\uDE4D\uD83C\uDFFE\u200D\u2642\uFE0F":"1f64d-1f3fe-2642","\uD83D\uDE4D\uD83C\uDFFF\u200D\u2640\uFE0F":"1f64d-1f3ff-2640","\uD83D\uDE4D\uD83C\uDFFF\u200D\u2642\uFE0F":"1f64d-1f3ff-2642","\uD83D\uDE4E\uD83C\uDFFB\u200D\u2640\uFE0F":"1f64e-1f3fb-2640","\uD83D\uDE4E\uD83C\uDFFB\u200D\u2642\uFE0F":"1f64e-1f3fb-2642","\uD83D\uDE4E\uD83C\uDFFC\u200D\u2640\uFE0F":"1f64e-1f3fc-2640","\uD83D\uDE4E\uD83C\uDFFC\u200D\u2642\uFE0F":"1f64e-1f3fc-2642","\uD83D\uDE4E\uD83C\uDFFD\u200D\u2640\uFE0F":"1f64e-1f3fd-2640","\uD83D\uDE4E\uD83C\uDFFD\u200D\u2642\uFE0F":"1f64e-1f3fd-2642","\uD83D\uDE4E\uD83C\uDFFE\u200D\u2640\uFE0F":"1f64e-1f3fe-2640","\uD83D\uDE4E\uD83C\uDFFE\u200D\u2642\uFE0F":"1f64e-1f3fe-2642","\uD83D\uDE4E\uD83C\uDFFF\u200D\u2640\uFE0F":"1f64e-1f3ff-2640","\uD83D\uDE4E\uD83C\uDFFF\u200D\u2642\uFE0F":"1f64e-1f3ff-2642","\uD83E\uDD26\uD83C\uDFFB\u200D\u2640\uFE0F":"1f926-1f3fb-2640","\uD83E\uDD26\uD83C\uDFFB\u200D\u2642\uFE0F":"1f926-1f3fb-2642","\uD83E\uDD26\uD83C\uDFFC\u200D\u2640\uFE0F":"1f926-1f3fc-2640","\uD83E\uDD26\uD83C\uDFFC\u200D\u2642\uFE0F":"1f926-1f3fc-2642","\uD83E\uDD26\uD83C\uDFFD\u200D\u2640\uFE0F":"1f926-1f3fd-2640","\uD83E\uDD26\uD83C\uDFFD\u200D\u2642\uFE0F":"1f926-1f3fd-2642","\uD83E\uDD26\uD83C\uDFFE\u200D\u2640\uFE0F":"1f926-1f3fe-2640","\uD83E\uDD26\uD83C\uDFFE\u200D\u2642\uFE0F":"1f926-1f3fe-2642","\uD83E\uDD26\uD83C\uDFFF\u200D\u2640\uFE0F":"1f926-1f3ff-2640","\uD83E\uDD26\uD83C\uDFFF\u200D\u2642\uFE0F":"1f926-1f3ff-2642","\uD83E\uDD37\uD83C\uDFFB\u200D\u2640\uFE0F":"1f937-1f3fb-2640","\uD83E\uDD37\uD83C\uDFFB\u200D\u2642\uFE0F":"1f937-1f3fb-2642","\uD83E\uDD37\uD83C\uDFFC\u200D\u2640\uFE0F":"1f937-1f3fc-2640","\uD83E\uDD37\uD83C\uDFFC\u200D\u2642\uFE0F":"1f937-1f3fc-2642","\uD83E\uDD37\uD83C\uDFFD\u200D\u2640\uFE0F":"1f937-1f3fd-2640","\uD83E\uDD37\uD83C\uDFFD\u200D\u2642\uFE0F":"1f937-1f3fd-2642","\uD83E\uDD37\uD83C\uDFFE\u200D\u2640\uFE0F":"1f937-1f3fe-2640","\uD83E\uDD37\uD83C\uDFFE\u200D\u2642\uFE0F":"1f937-1f3fe-2642","\uD83E\uDD37\uD83C\uDFFF\u200D\u2640\uFE0F":"1f937-1f3ff-2640","\uD83E\uDD37\uD83C\uDFFF\u200D\u2642\uFE0F":"1f937-1f3ff-2642","\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8\uFE0F":"1f441-1f5e8","\uD83D\uDD75\uD83C\uDFFB\u200D\u2640\uFE0F":"1f575-1f3fb-2640","\uD83D\uDD75\uD83C\uDFFB\u200D\u2642\uFE0F":"1f575-1f3fb-2642","\uD83D\uDD75\uD83C\uDFFC\u200D\u2640\uFE0F":"1f575-1f3fc-2640","\uD83D\uDD75\uD83C\uDFFC\u200D\u2642\uFE0F":"1f575-1f3fc-2642","\uD83D\uDD75\uD83C\uDFFD\u200D\u2640\uFE0F":"1f575-1f3fd-2640","\uD83D\uDD75\uD83C\uDFFD\u200D\u2642\uFE0F":"1f575-1f3fd-2642","\uD83D\uDD75\uD83C\uDFFE\u200D\u2640\uFE0F":"1f575-1f3fe-2640","\uD83D\uDD75\uD83C\uDFFE\u200D\u2642\uFE0F":"1f575-1f3fe-2642","\uD83D\uDD75\uD83C\uDFFF\u200D\u2640\uFE0F":"1f575-1f3ff-2640","\uD83D\uDD75\uD83C\uDFFF\u200D\u2642\uFE0F":"1f575-1f3ff-2642","\uD83C\uDFCB\uD83C\uDFFB\u200D\u2640\uFE0F":"1f3cb-1f3fb-2640","\uD83C\uDFCB\uD83C\uDFFB\u200D\u2642\uFE0F":"1f3cb-1f3fb-2642","\uD83C\uDFCB\uD83C\uDFFC\u200D\u2640\uFE0F":"1f3cb-1f3fc-2640","\uD83C\uDFCB\uD83C\uDFFC\u200D\u2642\uFE0F":"1f3cb-1f3fc-2642","\uD83C\uDFCB\uD83C\uDFFD\u200D\u2640\uFE0F":"1f3cb-1f3fd-2640","\uD83C\uDFCB\uD83C\uDFFD\u200D\u2642\uFE0F":"1f3cb-1f3fd-2642","\uD83C\uDFCB\uD83C\uDFFE\u200D\u2640\uFE0F":"1f3cb-1f3fe-2640","\uD83C\uDFCB\uD83C\uDFFE\u200D\u2642\uFE0F":"1f3cb-1f3fe-2642","\uD83C\uDFCB\uD83C\uDFFF\u200D\u2640\uFE0F":"1f3cb-1f3ff-2640","\uD83C\uDFCB\uD83C\uDFFF\u200D\u2642\uFE0F":"1f3cb-1f3ff-2642","\uD83C\uDFCC\uD83C\uDFFB\u200D\u2640\uFE0F":"1f3cc-1f3fb-2640","\uD83C\uDFCC\uD83C\uDFFB\u200D\u2642\uFE0F":"1f3cc-1f3fb-2642","\uD83C\uDFCC\uD83C\uDFFC\u200D\u2640\uFE0F":"1f3cc-1f3fc-2640","\uD83C\uDFCC\uD83C\uDFFC\u200D\u2642\uFE0F":"1f3cc-1f3fc-2642","\uD83C\uDFCC\uD83C\uDFFD\u200D\u2640\uFE0F":"1f3cc-1f3fd-2640","\uD83C\uDFCC\uD83C\uDFFD\u200D\u2642\uFE0F":"1f3cc-1f3fd-2642","\uD83C\uDFCC\uD83C\uDFFE\u200D\u2640\uFE0F":"1f3cc-1f3fe-2640","\uD83C\uDFCC\uD83C\uDFFE\u200D\u2642\uFE0F":"1f3cc-1f3fe-2642","\uD83C\uDFCC\uD83C\uDFFF\u200D\u2640\uFE0F":"1f3cc-1f3ff-2640","\uD83C\uDFCC\uD83C\uDFFF\u200D\u2642\uFE0F":"1f3cc-1f3ff-2642","\uD83E\uDDD9\uD83C\uDFFB\u200D\u2640\uFE0F":"1f9d9-1f3fb-2640","\uD83E\uDDD9\uD83C\uDFFB\u200D\u2642\uFE0F":"1f9d9-1f3fb-2642","\uD83E\uDDD9\uD83C\uDFFC\u200D\u2640\uFE0F":"1f9d9-1f3fc-2640","\uD83E\uDDD9\uD83C\uDFFC\u200D\u2642\uFE0F":"1f9d9-1f3fc-2642","\uD83E\uDDD9\uD83C\uDFFD\u200D\u2640\uFE0F":"1f9d9-1f3fd-2640","\uD83E\uDDD9\uD83C\uDFFD\u200D\u2642\uFE0F":"1f9d9-1f3fd-2642","\uD83E\uDDD9\uD83C\uDFFE\u200D\u2640\uFE0F":"1f9d9-1f3fe-2640","\uD83E\uDDD9\uD83C\uDFFE\u200D\u2642\uFE0F":"1f9d9-1f3fe-2642","\uD83E\uDDD9\uD83C\uDFFF\u200D\u2640\uFE0F":"1f9d9-1f3ff-2640","\uD83E\uDDD9\uD83C\uDFFF\u200D\u2642\uFE0F":"1f9d9-1f3ff-2642","\uD83E\uDDDA\uD83C\uDFFB\u200D\u2640\uFE0F":"1f9da-1f3fb-2640","\uD83E\uDDDA\uD83C\uDFFB\u200D\u2642\uFE0F":"1f9da-1f3fb-2642","\uD83E\uDDDA\uD83C\uDFFC\u200D\u2640\uFE0F":"1f9da-1f3fc-2640","\uD83E\uDDDA\uD83C\uDFFC\u200D\u2642\uFE0F":"1f9da-1f3fc-2642","\uD83E\uDDDA\uD83C\uDFFD\u200D\u2640\uFE0F":"1f9da-1f3fd-2640","\uD83E\uDDDA\uD83C\uDFFD\u200D\u2642\uFE0F":"1f9da-1f3fd-2642","\uD83E\uDDDA\uD83C\uDFFE\u200D\u2640\uFE0F":"1f9da-1f3fe-2640","\uD83E\uDDDA\uD83C\uDFFE\u200D\u2642\uFE0F":"1f9da-1f3fe-2642","\uD83E\uDDDA\uD83C\uDFFF\u200D\u2640\uFE0F":"1f9da-1f3ff-2640","\uD83E\uDDDA\uD83C\uDFFF\u200D\u2642\uFE0F":"1f9da-1f3ff-2642","\uD83E\uDDDB\uD83C\uDFFB\u200D\u2640\uFE0F":"1f9db-1f3fb-2640","\uD83E\uDDDB\uD83C\uDFFB\u200D\u2642\uFE0F":"1f9db-1f3fb-2642","\uD83E\uDDDB\uD83C\uDFFC\u200D\u2640\uFE0F":"1f9db-1f3fc-2640","\uD83E\uDDDB\uD83C\uDFFC\u200D\u2642\uFE0F":"1f9db-1f3fc-2642","\uD83E\uDDDB\uD83C\uDFFD\u200D\u2640\uFE0F":"1f9db-1f3fd-2640","\uD83E\uDDDB\uD83C\uDFFD\u200D\u2642\uFE0F":"1f9db-1f3fd-2642","\uD83E\uDDDB\uD83C\uDFFE\u200D\u2640\uFE0F":"1f9db-1f3fe-2640","\uD83E\uDDDB\uD83C\uDFFE\u200D\u2642\uFE0F":"1f9db-1f3fe-2642","\uD83E\uDDDB\uD83C\uDFFF\u200D\u2640\uFE0F":"1f9db-1f3ff-2640","\uD83E\uDDDB\uD83C\uDFFF\u200D\u2642\uFE0F":"1f9db-1f3ff-2642","\uD83E\uDDDC\uD83C\uDFFB\u200D\u2640\uFE0F":"1f9dc-1f3fb-2640","\uD83E\uDDDC\uD83C\uDFFB\u200D\u2642\uFE0F":"1f9dc-1f3fb-2642","\uD83E\uDDDC\uD83C\uDFFC\u200D\u2640\uFE0F":"1f9dc-1f3fc-2640","\uD83E\uDDDC\uD83C\uDFFC\u200D\u2642\uFE0F":"1f9dc-1f3fc-2642","\uD83E\uDDDC\uD83C\uDFFD\u200D\u2640\uFE0F":"1f9dc-1f3fd-2640","\uD83E\uDDDC\uD83C\uDFFD\u200D\u2642\uFE0F":"1f9dc-1f3fd-2642","\uD83E\uDDDC\uD83C\uDFFE\u200D\u2640\uFE0F":"1f9dc-1f3fe-2640","\uD83E\uDDDC\uD83C\uDFFE\u200D\u2642\uFE0F":"1f9dc-1f3fe-2642","\uD83E\uDDDC\uD83C\uDFFF\u200D\u2640\uFE0F":"1f9dc-1f3ff-2640","\uD83E\uDDDC\uD83C\uDFFF\u200D\u2642\uFE0F":"1f9dc-1f3ff-2642","\uD83E\uDDDD\uD83C\uDFFB\u200D\u2640\uFE0F":"1f9dd-1f3fb-2640","\uD83E\uDDDD\uD83C\uDFFB\u200D\u2642\uFE0F":"1f9dd-1f3fb-2642","\uD83E\uDDDD\uD83C\uDFFC\u200D\u2640\uFE0F":"1f9dd-1f3fc-2640","\uD83E\uDDDD\uD83C\uDFFC\u200D\u2642\uFE0F":"1f9dd-1f3fc-2642","\uD83E\uDDDD\uD83C\uDFFD\u200D\u2640\uFE0F":"1f9dd-1f3fd-2640","\uD83E\uDDDD\uD83C\uDFFD\u200D\u2642\uFE0F":"1f9dd-1f3fd-2642","\uD83E\uDDDD\uD83C\uDFFE\u200D\u2640\uFE0F":"1f9dd-1f3fe-2640","\uD83E\uDDDD\uD83C\uDFFE\u200D\u2642\uFE0F":"1f9dd-1f3fe-2642","\uD83E\uDDDD\uD83C\uDFFF\u200D\u2640\uFE0F":"1f9dd-1f3ff-2640","\uD83E\uDDDD\uD83C\uDFFF\u200D\u2642\uFE0F":"1f9dd-1f3ff-2642","\uD83E\uDDD6\uD83C\uDFFB\u200D\u2640\uFE0F":"1f9d6-1f3fb-2640","\uD83E\uDDD6\uD83C\uDFFB\u200D\u2642\uFE0F":"1f9d6-1f3fb-2642","\uD83E\uDDD6\uD83C\uDFFC\u200D\u2640\uFE0F":"1f9d6-1f3fc-2640","\uD83E\uDDD6\uD83C\uDFFC\u200D\u2642\uFE0F":"1f9d6-1f3fc-2642","\uD83E\uDDD6\uD83C\uDFFD\u200D\u2640\uFE0F":"1f9d6-1f3fd-2640","\uD83E\uDDD6\uD83C\uDFFD\u200D\u2642\uFE0F":"1f9d6-1f3fd-2642","\uD83E\uDDD6\uD83C\uDFFE\u200D\u2640\uFE0F":"1f9d6-1f3fe-2640","\uD83E\uDDD6\uD83C\uDFFE\u200D\u2642\uFE0F":"1f9d6-1f3fe-2642","\uD83E\uDDD6\uD83C\uDFFF\u200D\u2640\uFE0F":"1f9d6-1f3ff-2640","\uD83E\uDDD6\uD83C\uDFFF\u200D\u2642\uFE0F":"1f9d6-1f3ff-2642","\uD83E\uDDD7\uD83C\uDFFB\u200D\u2640\uFE0F":"1f9d7-1f3fb-2640","\uD83E\uDDD7\uD83C\uDFFB\u200D\u2642\uFE0F":"1f9d7-1f3fb-2642","\uD83E\uDDD7\uD83C\uDFFC\u200D\u2640\uFE0F":"1f9d7-1f3fc-2640","\uD83E\uDDD7\uD83C\uDFFC\u200D\u2642\uFE0F":"1f9d7-1f3fc-2642","\uD83E\uDDD7\uD83C\uDFFD\u200D\u2640\uFE0F":"1f9d7-1f3fd-2640","\uD83E\uDDD7\uD83C\uDFFD\u200D\u2642\uFE0F":"1f9d7-1f3fd-2642","\uD83E\uDDD7\uD83C\uDFFE\u200D\u2640\uFE0F":"1f9d7-1f3fe-2640","\uD83E\uDDD7\uD83C\uDFFE\u200D\u2642\uFE0F":"1f9d7-1f3fe-2642","\uD83E\uDDD7\uD83C\uDFFF\u200D\u2640\uFE0F":"1f9d7-1f3ff-2640","\uD83E\uDDD7\uD83C\uDFFF\u200D\u2642\uFE0F":"1f9d7-1f3ff-2642","\uD83E\uDDD8\uD83C\uDFFB\u200D\u2640\uFE0F":"1f9d8-1f3fb-2640","\uD83E\uDDD8\uD83C\uDFFB\u200D\u2642\uFE0F":"1f9d8-1f3fb-2642","\uD83E\uDDD8\uD83C\uDFFC\u200D\u2640\uFE0F":"1f9d8-1f3fc-2640","\uD83E\uDDD8\uD83C\uDFFC\u200D\u2642\uFE0F":"1f9d8-1f3fc-2642","\uD83E\uDDD8\uD83C\uDFFD\u200D\u2640\uFE0F":"1f9d8-1f3fd-2640","\uD83E\uDDD8\uD83C\uDFFD\u200D\u2642\uFE0F":"1f9d8-1f3fd-2642","\uD83E\uDDD8\uD83C\uDFFE\u200D\u2640\uFE0F":"1f9d8-1f3fe-2640","\uD83E\uDDD8\uD83C\uDFFE\u200D\u2642\uFE0F":"1f9d8-1f3fe-2642","\uD83E\uDDD8\uD83C\uDFFF\u200D\u2640\uFE0F":"1f9d8-1f3ff-2640","\uD83E\uDDD8\uD83C\uDFFF\u200D\u2642\uFE0F":"1f9d8-1f3ff-2642","\uD83D\uDD75\uFE0F\u200D\u2640\uFE0F":"1f575-2640","\uD83D\uDD75\uFE0F\u200D\u2642\uFE0F":"1f575-2642","\u26F9\uFE0F\uD83C\uDFFB\u2640\uFE0F":"26f9-1f3fb-2640","\u26F9\uFE0F\uD83C\uDFFB\u2642\uFE0F":"26f9-1f3fb-2642","\u26F9\uFE0F\uD83C\uDFFC\u2640\uFE0F":"26f9-1f3fc-2640","\u26F9\uFE0F\uD83C\uDFFC\u2642\uFE0F":"26f9-1f3fc-2642","\u26F9\uFE0F\uD83C\uDFFD\u2640\uFE0F":"26f9-1f3fd-2640","\u26F9\uFE0F\uD83C\uDFFD\u2642\uFE0F":"26f9-1f3fd-2642","\u26F9\uFE0F\uD83C\uDFFE\u2640\uFE0F":"26f9-1f3fe-2640","\u26F9\uFE0F\uD83C\uDFFE\u2642\uFE0F":"26f9-1f3fe-2642","\u26F9\uFE0F\uD83C\uDFFF\u2640\uFE0F":"26f9-1f3ff-2640","\u26F9\uFE0F\uD83C\uDFFF\u2642\uFE0F":"26f9-1f3ff-2642","\uD83C\uDFCB\uFE0F\u200D\u2640\uFE0F":"1f3cb-2640","\uD83C\uDFCB\uFE0F\u200D\u2642\uFE0F":"1f3cb-2642","\uD83C\uDFCC\uFE0F\u200D\u2640\uFE0F":"1f3cc-2640","\uD83C\uDFCC\uFE0F\u200D\u2642\uFE0F":"1f3cc-2642","\u26F9\uD83C\uDFFB\u200D\u2640\uFE0F":"26f9-1f3fb-2640","\u26F9\uD83C\uDFFB\u200D\u2642\uFE0F":"26f9-1f3fb-2642","\u26F9\uD83C\uDFFC\u200D\u2640\uFE0F":"26f9-1f3fc-2640","\u26F9\uD83C\uDFFC\u200D\u2642\uFE0F":"26f9-1f3fc-2642","\u26F9\uD83C\uDFFD\u200D\u2640\uFE0F":"26f9-1f3fd-2640","\u26F9\uD83C\uDFFD\u200D\u2642\uFE0F":"26f9-1f3fd-2642","\u26F9\uD83C\uDFFE\u200D\u2640\uFE0F":"26f9-1f3fe-2640","\u26F9\uD83C\uDFFE\u200D\u2642\uFE0F":"26f9-1f3fe-2642","\u26F9\uD83C\uDFFF\u200D\u2640\uFE0F":"26f9-1f3ff-2640","\u26F9\uD83C\uDFFF\u200D\u2642\uFE0F":"26f9-1f3ff-2642","\u26F9\uFE0F\u200D\u2640\uFE0F":"26f9-2640","\u26F9\uFE0F\u200D\u2642\uFE0F":"26f9-2642","\uD83D\uDC68\uD83D\uDC68\uD83D\uDC66\uD83D\uDC66":"1f468-1f468-1f466-1f466","\uD83D\uDC68\uD83D\uDC68\uD83D\uDC67\uD83D\uDC66":"1f468-1f468-1f467-1f466","\uD83D\uDC68\uD83D\uDC68\uD83D\uDC67\uD83D\uDC67":"1f468-1f468-1f467-1f467","\uD83D\uDC68\uD83D\uDC69\uD83D\uDC66\uD83D\uDC66":"1f468-1f469-1f466-1f466","\uD83D\uDC68\uD83D\uDC69\uD83D\uDC67\uD83D\uDC66":"1f468-1f469-1f467-1f466","\uD83D\uDC68\uD83D\uDC69\uD83D\uDC67\uD83D\uDC67":"1f468-1f469-1f467-1f467","\uD83D\uDC69\uD83D\uDC69\uD83D\uDC66\uD83D\uDC66":"1f469-1f469-1f466-1f466","\uD83D\uDC69\uD83D\uDC69\uD83D\uDC67\uD83D\uDC66":"1f469-1f469-1f467-1f466","\uD83D\uDC69\uD83D\uDC69\uD83D\uDC67\uD83D\uDC67":"1f469-1f469-1f467-1f467","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDCBB":"1f468-1f3ff-1f4bb","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDCBB":"1f468-1f3fe-1f4bb","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDCBB":"1f468-1f3fd-1f4bb","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDCBB":"1f468-1f3fc-1f4bb","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDCBB":"1f468-1f3fb-1f4bb","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDCBB":"1f469-1f3ff-1f4bb","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDCBB":"1f469-1f3fe-1f4bb","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDCBB":"1f469-1f3fd-1f4bb","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDCBB":"1f469-1f3fc-1f4bb","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDCBB":"1f469-1f3fb-1f4bb","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFEB":"1f468-1f3ff-1f3eb","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFEB":"1f468-1f3fe-1f3eb","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFEB":"1f468-1f3fd-1f3eb","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFEB":"1f468-1f3fc-1f3eb","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFEB":"1f468-1f3fb-1f3eb","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFEB":"1f469-1f3ff-1f3eb","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFEB":"1f469-1f3fe-1f3eb","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFEB":"1f469-1f3fd-1f3eb","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFEB":"1f469-1f3fc-1f3eb","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFEB":"1f469-1f3fb-1f3eb","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF93":"1f468-1f3ff-1f393","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF93":"1f468-1f3fe-1f393","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF93":"1f468-1f3fd-1f393","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF93":"1f468-1f3fc-1f393","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF93":"1f468-1f3fb-1f393","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF93":"1f469-1f3ff-1f393","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF93":"1f469-1f3fe-1f393","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF93":"1f469-1f3fd-1f393","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF93":"1f469-1f3fc-1f393","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF93":"1f469-1f3fb-1f393","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFA4":"1f468-1f3ff-1f3a4","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFA4":"1f468-1f3fe-1f3a4","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFA4":"1f468-1f3fd-1f3a4","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFA4":"1f468-1f3fc-1f3a4","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFA4":"1f468-1f3fb-1f3a4","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFA4":"1f469-1f3ff-1f3a4","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFA4":"1f469-1f3fe-1f3a4","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFA4":"1f469-1f3fd-1f3a4","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFA4":"1f469-1f3fc-1f3a4","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFA4":"1f469-1f3fb-1f3a4","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDD2C":"1f468-1f3ff-1f52c","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDD2C":"1f468-1f3fe-1f52c","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDD2C":"1f468-1f3fd-1f52c","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDD2C":"1f468-1f3fc-1f52c","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDD2C":"1f468-1f3fb-1f52c","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDD2C":"1f469-1f3ff-1f52c","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDD2C":"1f469-1f3fe-1f52c","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDD2C":"1f469-1f3fd-1f52c","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDD2C":"1f469-1f3fc-1f52c","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDD2C":"1f469-1f3fb-1f52c","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDCBC":"1f468-1f3ff-1f4bc","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDCBC":"1f468-1f3fe-1f4bc","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDCBC":"1f468-1f3fd-1f4bc","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDCBC":"1f468-1f3fc-1f4bc","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDCBC":"1f468-1f3fb-1f4bc","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDCBC":"1f469-1f3ff-1f4bc","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDCBC":"1f469-1f3fe-1f4bc","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDCBC":"1f469-1f3fd-1f4bc","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDCBC":"1f469-1f3fc-1f4bc","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDCBC":"1f469-1f3fb-1f4bc","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDD27":"1f468-1f3ff-1f527","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDD27":"1f468-1f3fe-1f527","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDD27":"1f468-1f3fd-1f527","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDD27":"1f468-1f3fc-1f527","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDD27":"1f468-1f3fb-1f527","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDD27":"1f469-1f3ff-1f527","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDD27":"1f469-1f3fe-1f527","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDD27":"1f469-1f3fd-1f527","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDD27":"1f469-1f3fc-1f527","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDD27":"1f469-1f3fb-1f527","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFED":"1f468-1f3ff-1f3ed","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFED":"1f468-1f3fe-1f3ed","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFED":"1f468-1f3fd-1f3ed","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFED":"1f468-1f3fc-1f3ed","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFED":"1f468-1f3fb-1f3ed","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFED":"1f469-1f3ff-1f3ed","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFED":"1f469-1f3fe-1f3ed","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFED":"1f469-1f3fd-1f3ed","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFED":"1f469-1f3fc-1f3ed","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFED":"1f469-1f3fb-1f3ed","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF73":"1f468-1f3ff-1f373","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF73":"1f468-1f3fe-1f373","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF73":"1f468-1f3fd-1f373","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF73":"1f468-1f3fc-1f373","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF73":"1f468-1f3fb-1f373","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF73":"1f469-1f3ff-1f373","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF73":"1f469-1f3fe-1f373","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF73":"1f469-1f3fd-1f373","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF73":"1f469-1f3fc-1f373","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF73":"1f469-1f3fb-1f373","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF3E":"1f468-1f3ff-1f33e","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF3E":"1f468-1f3fe-1f33e","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF3E":"1f468-1f3fd-1f33e","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF3E":"1f468-1f3fc-1f33e","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF3E":"1f468-1f3fb-1f33e","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF3E":"1f469-1f3ff-1f33e","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF3E":"1f469-1f3fe-1f33e","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF3E":"1f469-1f3fd-1f33e","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF3E":"1f469-1f3fc-1f33e","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF3E":"1f469-1f3fb-1f33e","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFA8":"1f468-1f3fb-1f3a8","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFA8":"1f468-1f3fc-1f3a8","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFA8":"1f468-1f3fd-1f3a8","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFA8":"1f468-1f3fe-1f3a8","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFA8":"1f468-1f3ff-1f3a8","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFA8":"1f469-1f3fb-1f3a8","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFA8":"1f469-1f3fc-1f3a8","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFA8":"1f469-1f3fd-1f3a8","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFA8":"1f469-1f3fe-1f3a8","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFA8":"1f469-1f3ff-1f3a8","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDE80":"1f468-1f3fb-1f680","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDE80":"1f468-1f3fc-1f680","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDE80":"1f468-1f3fd-1f680","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDE80":"1f468-1f3fe-1f680","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDE80":"1f468-1f3ff-1f680","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDE80":"1f469-1f3fb-1f680","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDE80":"1f469-1f3fc-1f680","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDE80":"1f469-1f3fd-1f680","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDE80":"1f469-1f3fe-1f680","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDE80":"1f469-1f3ff-1f680","\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDE92":"1f468-1f3fb-1f692","\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDE92":"1f468-1f3fc-1f692","\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDE92":"1f468-1f3fd-1f692","\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDE92":"1f468-1f3fe-1f692","\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDE92":"1f468-1f3ff-1f692","\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDE92":"1f469-1f3fb-1f692","\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDE92":"1f469-1f3fc-1f692","\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDE92":"1f469-1f3fd-1f692","\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDE92":"1f469-1f3fe-1f692","\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDE92":"1f469-1f3ff-1f692","\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08":"1f3f3-1f308","\uD83C\uDFCC\uD83C\uDFFB\u200D\u2642":"1f3cc-1f3fb-2642","\uD83C\uDFCC\uD83C\uDFFC\u200D\u2642":"1f3cc-1f3fc-2642","\uD83C\uDFCC\uD83C\uDFFD\u200D\u2642":"1f3cc-1f3fd-2642","\uD83C\uDFCC\uD83C\uDFFE\u200D\u2642":"1f3cc-1f3fe-2642","\uD83C\uDFCC\uD83C\uDFFF\u200D\u2642":"1f3cc-1f3ff-2642","\uD83C\uDFCC\uD83C\uDFFB\u200D\u2640":"1f3cc-1f3fb-2640","\uD83C\uDFCC\uD83C\uDFFC\u200D\u2640":"1f3cc-1f3fc-2640","\uD83C\uDFCC\uD83C\uDFFD\u200D\u2640":"1f3cc-1f3fd-2640","\uD83C\uDFCC\uD83C\uDFFE\u200D\u2640":"1f3cc-1f3fe-2640","\uD83C\uDFCC\uD83C\uDFFF\u200D\u2640":"1f3cc-1f3ff-2640","\uD83E\uDD39\uD83C\uDFFF\u200D\u2642":"1f939-1f3ff-2642","\uD83E\uDD39\uD83C\uDFFE\u200D\u2642":"1f939-1f3fe-2642","\uD83E\uDD39\uD83C\uDFFD\u200D\u2642":"1f939-1f3fd-2642","\uD83E\uDD39\uD83C\uDFFC\u200D\u2642":"1f939-1f3fc-2642","\uD83E\uDD39\uD83C\uDFFB\u200D\u2642":"1f939-1f3fb-2642","\uD83E\uDD39\uD83C\uDFFF\u200D\u2640":"1f939-1f3ff-2640","\uD83E\uDD39\uD83C\uDFFE\u200D\u2640":"1f939-1f3fe-2640","\uD83E\uDD39\uD83C\uDFFD\u200D\u2640":"1f939-1f3fd-2640","\uD83E\uDD39\uD83C\uDFFC\u200D\u2640":"1f939-1f3fc-2640","\uD83E\uDD39\uD83C\uDFFB\u200D\u2640":"1f939-1f3fb-2640","\uD83E\uDD3E\uD83C\uDFFF\u200D\u2642":"1f93e-1f3ff-2642","\uD83E\uDD3E\uD83C\uDFFE\u200D\u2642":"1f93e-1f3fe-2642","\uD83E\uDD3E\uD83C\uDFFD\u200D\u2642":"1f93e-1f3fd-2642","\uD83E\uDD3E\uD83C\uDFFC\u200D\u2642":"1f93e-1f3fc-2642","\uD83E\uDD3E\uD83C\uDFFB\u200D\u2642":"1f93e-1f3fb-2642","\uD83E\uDD3E\uD83C\uDFFF\u200D\u2640":"1f93e-1f3ff-2640","\uD83E\uDD3E\uD83C\uDFFE\u200D\u2640":"1f93e-1f3fe-2640","\uD83E\uDD3E\uD83C\uDFFD\u200D\u2640":"1f93e-1f3fd-2640","\uD83E\uDD3E\uD83C\uDFFC\u200D\u2640":"1f93e-1f3fc-2640","\uD83E\uDD3E\uD83C\uDFFB\u200D\u2640":"1f93e-1f3fb-2640","\uD83E\uDD3D\uD83C\uDFFF\u200D\u2642":"1f93d-1f3ff-2642","\uD83E\uDD3D\uD83C\uDFFE\u200D\u2642":"1f93d-1f3fe-2642","\uD83E\uDD3D\uD83C\uDFFD\u200D\u2642":"1f93d-1f3fd-2642","\uD83E\uDD3D\uD83C\uDFFC\u200D\u2642":"1f93d-1f3fc-2642","\uD83E\uDD3D\uD83C\uDFFB\u200D\u2642":"1f93d-1f3fb-2642","\uD83E\uDD3D\uD83C\uDFFF\u200D\u2640":"1f93d-1f3ff-2640","\uD83E\uDD3D\uD83C\uDFFE\u200D\u2640":"1f93d-1f3fe-2640","\uD83E\uDD3D\uD83C\uDFFD\u200D\u2640":"1f93d-1f3fd-2640","\uD83E\uDD3D\uD83C\uDFFC\u200D\u2640":"1f93d-1f3fc-2640","\uD83E\uDD3D\uD83C\uDFFB\u200D\u2640":"1f93d-1f3fb-2640","\uD83E\uDD38\uD83C\uDFFF\u200D\u2642":"1f938-1f3ff-2642","\uD83E\uDD38\uD83C\uDFFE\u200D\u2642":"1f938-1f3fe-2642","\uD83E\uDD38\uD83C\uDFFD\u200D\u2642":"1f938-1f3fd-2642","\uD83E\uDD38\uD83C\uDFFC\u200D\u2642":"1f938-1f3fc-2642","\uD83E\uDD38\uD83C\uDFFB\u200D\u2642":"1f938-1f3fb-2642","\uD83E\uDD38\uD83C\uDFFF\u200D\u2640":"1f938-1f3ff-2640","\uD83E\uDD38\uD83C\uDFFE\u200D\u2640":"1f938-1f3fe-2640","\uD83E\uDD38\uD83C\uDFFD\u200D\u2640":"1f938-1f3fd-2640","\uD83E\uDD38\uD83C\uDFFC\u200D\u2640":"1f938-1f3fc-2640","\uD83E\uDD38\uD83C\uDFFB\u200D\u2640":"1f938-1f3fb-2640","\uD83D\uDEB6\uD83C\uDFFF\u200D\u2642":"1f6b6-1f3ff-2642","\uD83D\uDEB6\uD83C\uDFFE\u200D\u2642":"1f6b6-1f3fe-2642","\uD83D\uDEB6\uD83C\uDFFD\u200D\u2642":"1f6b6-1f3fd-2642","\uD83D\uDEB6\uD83C\uDFFC\u200D\u2642":"1f6b6-1f3fc-2642","\uD83D\uDEB6\uD83C\uDFFB\u200D\u2642":"1f6b6-1f3fb-2642","\uD83D\uDEB6\uD83C\uDFFF\u200D\u2640":"1f6b6-1f3ff-2640","\uD83D\uDEB6\uD83C\uDFFE\u200D\u2640":"1f6b6-1f3fe-2640","\uD83D\uDEB6\uD83C\uDFFD\u200D\u2640":"1f6b6-1f3fd-2640","\uD83D\uDEB6\uD83C\uDFFC\u200D\u2640":"1f6b6-1f3fc-2640","\uD83D\uDEB6\uD83C\uDFFB\u200D\u2640":"1f6b6-1f3fb-2640","\uD83D\uDEB5\uD83C\uDFFF\u200D\u2642":"1f6b5-1f3ff-2642","\uD83D\uDEB5\uD83C\uDFFE\u200D\u2642":"1f6b5-1f3fe-2642","\uD83D\uDEB5\uD83C\uDFFD\u200D\u2642":"1f6b5-1f3fd-2642","\uD83D\uDEB5\uD83C\uDFFC\u200D\u2642":"1f6b5-1f3fc-2642","\uD83D\uDEB5\uD83C\uDFFB\u200D\u2642":"1f6b5-1f3fb-2642","\uD83D\uDEB5\uD83C\uDFFF\u200D\u2640":"1f6b5-1f3ff-2640","\uD83D\uDEB5\uD83C\uDFFE\u200D\u2640":"1f6b5-1f3fe-2640","\uD83D\uDEB5\uD83C\uDFFD\u200D\u2640":"1f6b5-1f3fd-2640","\uD83D\uDEB5\uD83C\uDFFC\u200D\u2640":"1f6b5-1f3fc-2640","\uD83D\uDEB5\uD83C\uDFFB\u200D\u2640":"1f6b5-1f3fb-2640","\uD83D\uDEB4\uD83C\uDFFF\u200D\u2642":"1f6b4-1f3ff-2642","\uD83D\uDEB4\uD83C\uDFFE\u200D\u2642":"1f6b4-1f3fe-2642","\uD83D\uDEB4\uD83C\uDFFD\u200D\u2642":"1f6b4-1f3fd-2642","\uD83D\uDEB4\uD83C\uDFFC\u200D\u2642":"1f6b4-1f3fc-2642","\uD83D\uDEB4\uD83C\uDFFB\u200D\u2642":"1f6b4-1f3fb-2642","\uD83D\uDEB4\uD83C\uDFFF\u200D\u2640":"1f6b4-1f3ff-2640","\uD83D\uDEB4\uD83C\uDFFE\u200D\u2640":"1f6b4-1f3fe-2640","\uD83D\uDEB4\uD83C\uDFFD\u200D\u2640":"1f6b4-1f3fd-2640","\uD83D\uDEB4\uD83C\uDFFC\u200D\u2640":"1f6b4-1f3fc-2640","\uD83D\uDEB4\uD83C\uDFFB\u200D\u2640":"1f6b4-1f3fb-2640","\uD83D\uDEA3\uD83C\uDFFF\u200D\u2642":"1f6a3-1f3ff-2642","\uD83D\uDEA3\uD83C\uDFFE\u200D\u2642":"1f6a3-1f3fe-2642","\uD83D\uDEA3\uD83C\uDFFD\u200D\u2642":"1f6a3-1f3fd-2642","\uD83D\uDEA3\uD83C\uDFFC\u200D\u2642":"1f6a3-1f3fc-2642","\uD83D\uDEA3\uD83C\uDFFB\u200D\u2642":"1f6a3-1f3fb-2642","\uD83D\uDEA3\uD83C\uDFFF\u200D\u2640":"1f6a3-1f3ff-2640","\uD83D\uDEA3\uD83C\uDFFE\u200D\u2640":"1f6a3-1f3fe-2640","\uD83D\uDEA3\uD83C\uDFFD\u200D\u2640":"1f6a3-1f3fd-2640","\uD83D\uDEA3\uD83C\uDFFC\u200D\u2640":"1f6a3-1f3fc-2640","\uD83D\uDEA3\uD83C\uDFFB\u200D\u2640":"1f6a3-1f3fb-2640","\uD83C\uDFCB\uD83C\uDFFF\u200D\u2642":"1f3cb-1f3ff-2642","\uD83C\uDFCB\uD83C\uDFFE\u200D\u2642":"1f3cb-1f3fe-2642","\uD83C\uDFCB\uD83C\uDFFD\u200D\u2642":"1f3cb-1f3fd-2642","\uD83C\uDFCB\uD83C\uDFFC\u200D\u2642":"1f3cb-1f3fc-2642","\uD83C\uDFCB\uD83C\uDFFB\u200D\u2642":"1f3cb-1f3fb-2642","\uD83C\uDFCB\uD83C\uDFFF\u200D\u2640":"1f3cb-1f3ff-2640","\uD83C\uDFCB\uD83C\uDFFE\u200D\u2640":"1f3cb-1f3fe-2640","\uD83C\uDFCB\uD83C\uDFFD\u200D\u2640":"1f3cb-1f3fd-2640","\uD83C\uDFCB\uD83C\uDFFC\u200D\u2640":"1f3cb-1f3fc-2640","\uD83C\uDFCB\uD83C\uDFFB\u200D\u2640":"1f3cb-1f3fb-2640","\uD83C\uDFCA\uD83C\uDFFF\u200D\u2642":"1f3ca-1f3ff-2642","\uD83C\uDFCA\uD83C\uDFFE\u200D\u2642":"1f3ca-1f3fe-2642","\uD83C\uDFCA\uD83C\uDFFD\u200D\u2642":"1f3ca-1f3fd-2642","\uD83C\uDFCA\uD83C\uDFFC\u200D\u2642":"1f3ca-1f3fc-2642","\uD83C\uDFCA\uD83C\uDFFB\u200D\u2642":"1f3ca-1f3fb-2642","\uD83C\uDFCA\uD83C\uDFFF\u200D\u2640":"1f3ca-1f3ff-2640","\uD83C\uDFCA\uD83C\uDFFE\u200D\u2640":"1f3ca-1f3fe-2640","\uD83C\uDFCA\uD83C\uDFFD\u200D\u2640":"1f3ca-1f3fd-2640","\uD83C\uDFCA\uD83C\uDFFC\u200D\u2640":"1f3ca-1f3fc-2640","\uD83C\uDFCA\uD83C\uDFFB\u200D\u2640":"1f3ca-1f3fb-2640","\uD83C\uDFC4\uD83C\uDFFF\u200D\u2642":"1f3c4-1f3ff-2642","\uD83C\uDFC4\uD83C\uDFFE\u200D\u2642":"1f3c4-1f3fe-2642","\uD83C\uDFC4\uD83C\uDFFD\u200D\u2642":"1f3c4-1f3fd-2642","\uD83C\uDFC4\uD83C\uDFFC\u200D\u2642":"1f3c4-1f3fc-2642","\uD83C\uDFC4\uD83C\uDFFB\u200D\u2642":"1f3c4-1f3fb-2642","\uD83C\uDFC4\uD83C\uDFFF\u200D\u2640":"1f3c4-1f3ff-2640","\uD83C\uDFC4\uD83C\uDFFE\u200D\u2640":"1f3c4-1f3fe-2640","\uD83C\uDFC4\uD83C\uDFFD\u200D\u2640":"1f3c4-1f3fd-2640","\uD83C\uDFC4\uD83C\uDFFC\u200D\u2640":"1f3c4-1f3fc-2640","\uD83C\uDFC4\uD83C\uDFFB\u200D\u2640":"1f3c4-1f3fb-2640","\uD83C\uDFC3\uD83C\uDFFF\u200D\u2642":"1f3c3-1f3ff-2642","\uD83C\uDFC3\uD83C\uDFFE\u200D\u2642":"1f3c3-1f3fe-2642","\uD83C\uDFC3\uD83C\uDFFD\u200D\u2642":"1f3c3-1f3fd-2642","\uD83C\uDFC3\uD83C\uDFFC\u200D\u2642":"1f3c3-1f3fc-2642","\uD83C\uDFC3\uD83C\uDFFB\u200D\u2642":"1f3c3-1f3fb-2642","\uD83C\uDFC3\uD83C\uDFFF\u200D\u2640":"1f3c3-1f3ff-2640","\uD83C\uDFC3\uD83C\uDFFE\u200D\u2640":"1f3c3-1f3fe-2640","\uD83C\uDFC3\uD83C\uDFFD\u200D\u2640":"1f3c3-1f3fd-2640","\uD83C\uDFC3\uD83C\uDFFC\u200D\u2640":"1f3c3-1f3fc-2640","\uD83C\uDFC3\uD83C\uDFFB\u200D\u2640":"1f3c3-1f3fb-2640","\uD83E\uDD37\uD83C\uDFFF\u200D\u2642":"1f937-1f3ff-2642","\uD83E\uDD37\uD83C\uDFFE\u200D\u2642":"1f937-1f3fe-2642","\uD83E\uDD37\uD83C\uDFFD\u200D\u2642":"1f937-1f3fd-2642","\uD83E\uDD37\uD83C\uDFFC\u200D\u2642":"1f937-1f3fc-2642","\uD83E\uDD37\uD83C\uDFFB\u200D\u2642":"1f937-1f3fb-2642","\uD83E\uDD37\uD83C\uDFFF\u200D\u2640":"1f937-1f3ff-2640","\uD83E\uDD37\uD83C\uDFFE\u200D\u2640":"1f937-1f3fe-2640","\uD83E\uDD37\uD83C\uDFFD\u200D\u2640":"1f937-1f3fd-2640","\uD83E\uDD37\uD83C\uDFFC\u200D\u2640":"1f937-1f3fc-2640","\uD83E\uDD37\uD83C\uDFFB\u200D\u2640":"1f937-1f3fb-2640","\uD83E\uDD26\uD83C\uDFFF\u200D\u2642":"1f926-1f3ff-2642","\uD83E\uDD26\uD83C\uDFFE\u200D\u2642":"1f926-1f3fe-2642","\uD83E\uDD26\uD83C\uDFFD\u200D\u2642":"1f926-1f3fd-2642","\uD83E\uDD26\uD83C\uDFFC\u200D\u2642":"1f926-1f3fc-2642","\uD83E\uDD26\uD83C\uDFFB\u200D\u2642":"1f926-1f3fb-2642","\uD83E\uDD26\uD83C\uDFFF\u200D\u2640":"1f926-1f3ff-2640","\uD83E\uDD26\uD83C\uDFFE\u200D\u2640":"1f926-1f3fe-2640","\uD83E\uDD26\uD83C\uDFFD\u200D\u2640":"1f926-1f3fd-2640","\uD83E\uDD26\uD83C\uDFFC\u200D\u2640":"1f926-1f3fc-2640","\uD83E\uDD26\uD83C\uDFFB\u200D\u2640":"1f926-1f3fb-2640","\uD83D\uDE4E\uD83C\uDFFF\u200D\u2642":"1f64e-1f3ff-2642","\uD83D\uDE4E\uD83C\uDFFE\u200D\u2642":"1f64e-1f3fe-2642","\uD83D\uDE4E\uD83C\uDFFD\u200D\u2642":"1f64e-1f3fd-2642","\uD83D\uDE4E\uD83C\uDFFC\u200D\u2642":"1f64e-1f3fc-2642","\uD83D\uDE4E\uD83C\uDFFB\u200D\u2642":"1f64e-1f3fb-2642","\uD83D\uDE4E\uD83C\uDFFF\u200D\u2640":"1f64e-1f3ff-2640","\uD83D\uDE4E\uD83C\uDFFE\u200D\u2640":"1f64e-1f3fe-2640","\uD83D\uDE4E\uD83C\uDFFD\u200D\u2640":"1f64e-1f3fd-2640","\uD83D\uDE4E\uD83C\uDFFC\u200D\u2640":"1f64e-1f3fc-2640","\uD83D\uDE4E\uD83C\uDFFB\u200D\u2640":"1f64e-1f3fb-2640","\uD83D\uDE4D\uD83C\uDFFF\u200D\u2642":"1f64d-1f3ff-2642","\uD83D\uDE4D\uD83C\uDFFE\u200D\u2642":"1f64d-1f3fe-2642","\uD83D\uDE4D\uD83C\uDFFD\u200D\u2642":"1f64d-1f3fd-2642","\uD83D\uDE4D\uD83C\uDFFC\u200D\u2642":"1f64d-1f3fc-2642","\uD83D\uDE4D\uD83C\uDFFB\u200D\u2642":"1f64d-1f3fb-2642","\uD83D\uDE4D\uD83C\uDFFF\u200D\u2640":"1f64d-1f3ff-2640","\uD83D\uDE4D\uD83C\uDFFE\u200D\u2640":"1f64d-1f3fe-2640","\uD83D\uDE4D\uD83C\uDFFD\u200D\u2640":"1f64d-1f3fd-2640","\uD83D\uDE4D\uD83C\uDFFC\u200D\u2640":"1f64d-1f3fc-2640","\uD83D\uDE4D\uD83C\uDFFB\u200D\u2640":"1f64d-1f3fb-2640","\uD83D\uDE4B\uD83C\uDFFF\u200D\u2642":"1f64b-1f3ff-2642","\uD83D\uDE4B\uD83C\uDFFE\u200D\u2642":"1f64b-1f3fe-2642","\uD83D\uDE4B\uD83C\uDFFD\u200D\u2642":"1f64b-1f3fd-2642","\uD83D\uDE4B\uD83C\uDFFC\u200D\u2642":"1f64b-1f3fc-2642","\uD83D\uDE4B\uD83C\uDFFB\u200D\u2642":"1f64b-1f3fb-2642","\uD83D\uDE4B\uD83C\uDFFF\u200D\u2640":"1f64b-1f3ff-2640","\uD83D\uDE4B\uD83C\uDFFE\u200D\u2640":"1f64b-1f3fe-2640","\uD83D\uDE4B\uD83C\uDFFD\u200D\u2640":"1f64b-1f3fd-2640","\uD83D\uDE4B\uD83C\uDFFC\u200D\u2640":"1f64b-1f3fc-2640","\uD83D\uDE4B\uD83C\uDFFB\u200D\u2640":"1f64b-1f3fb-2640","\uD83D\uDE47\uD83C\uDFFF\u200D\u2642":"1f647-1f3ff-2642","\uD83D\uDE47\uD83C\uDFFE\u200D\u2642":"1f647-1f3fe-2642","\uD83D\uDE47\uD83C\uDFFD\u200D\u2642":"1f647-1f3fd-2642","\uD83D\uDE47\uD83C\uDFFC\u200D\u2642":"1f647-1f3fc-2642","\uD83D\uDE47\uD83C\uDFFB\u200D\u2642":"1f647-1f3fb-2642","\uD83D\uDE47\uD83C\uDFFF\u200D\u2640":"1f647-1f3ff-2640","\uD83D\uDE47\uD83C\uDFFE\u200D\u2640":"1f647-1f3fe-2640","\uD83D\uDE47\uD83C\uDFFD\u200D\u2640":"1f647-1f3fd-2640","\uD83D\uDE47\uD83C\uDFFC\u200D\u2640":"1f647-1f3fc-2640","\uD83D\uDE47\uD83C\uDFFB\u200D\u2640":"1f647-1f3fb-2640","\uD83D\uDE46\uD83C\uDFFF\u200D\u2642":"1f646-1f3ff-2642","\uD83D\uDE46\uD83C\uDFFE\u200D\u2642":"1f646-1f3fe-2642","\uD83D\uDE46\uD83C\uDFFD\u200D\u2642":"1f646-1f3fd-2642","\uD83D\uDE46\uD83C\uDFFC\u200D\u2642":"1f646-1f3fc-2642","\uD83D\uDE46\uD83C\uDFFB\u200D\u2642":"1f646-1f3fb-2642","\uD83D\uDE46\uD83C\uDFFF\u200D\u2640":"1f646-1f3ff-2640","\uD83D\uDE46\uD83C\uDFFE\u200D\u2640":"1f646-1f3fe-2640","\uD83D\uDE46\uD83C\uDFFD\u200D\u2640":"1f646-1f3fd-2640","\uD83D\uDE46\uD83C\uDFFC\u200D\u2640":"1f646-1f3fc-2640","\uD83D\uDE46\uD83C\uDFFB\u200D\u2640":"1f646-1f3fb-2640","\uD83D\uDE45\uD83C\uDFFF\u200D\u2642":"1f645-1f3ff-2642","\uD83D\uDE45\uD83C\uDFFE\u200D\u2642":"1f645-1f3fe-2642","\uD83D\uDE45\uD83C\uDFFD\u200D\u2642":"1f645-1f3fd-2642","\uD83D\uDE45\uD83C\uDFFC\u200D\u2642":"1f645-1f3fc-2642","\uD83D\uDE45\uD83C\uDFFB\u200D\u2642":"1f645-1f3fb-2642","\uD83D\uDE45\uD83C\uDFFF\u200D\u2640":"1f645-1f3ff-2640","\uD83D\uDE45\uD83C\uDFFE\u200D\u2640":"1f645-1f3fe-2640","\uD83D\uDE45\uD83C\uDFFD\u200D\u2640":"1f645-1f3fd-2640","\uD83D\uDE45\uD83C\uDFFC\u200D\u2640":"1f645-1f3fc-2640","\uD83D\uDE45\uD83C\uDFFB\u200D\u2640":"1f645-1f3fb-2640","\uD83D\uDC87\uD83C\uDFFF\u200D\u2642":"1f487-1f3ff-2642","\uD83D\uDC87\uD83C\uDFFE\u200D\u2642":"1f487-1f3fe-2642","\uD83D\uDC87\uD83C\uDFFD\u200D\u2642":"1f487-1f3fd-2642","\uD83D\uDC87\uD83C\uDFFC\u200D\u2642":"1f487-1f3fc-2642","\uD83D\uDC87\uD83C\uDFFB\u200D\u2642":"1f487-1f3fb-2642","\uD83D\uDC87\uD83C\uDFFF\u200D\u2640":"1f487-1f3ff-2640","\uD83D\uDC87\uD83C\uDFFE\u200D\u2640":"1f487-1f3fe-2640","\uD83D\uDC87\uD83C\uDFFD\u200D\u2640":"1f487-1f3fd-2640","\uD83D\uDC87\uD83C\uDFFC\u200D\u2640":"1f487-1f3fc-2640","\uD83D\uDC87\uD83C\uDFFB\u200D\u2640":"1f487-1f3fb-2640","\uD83D\uDC86\uD83C\uDFFF\u200D\u2642":"1f486-1f3ff-2642","\uD83D\uDC86\uD83C\uDFFE\u200D\u2642":"1f486-1f3fe-2642","\uD83D\uDC86\uD83C\uDFFD\u200D\u2642":"1f486-1f3fd-2642","\uD83D\uDC86\uD83C\uDFFC\u200D\u2642":"1f486-1f3fc-2642","\uD83D\uDC86\uD83C\uDFFB\u200D\u2642":"1f486-1f3fb-2642","\uD83D\uDC86\uD83C\uDFFF\u200D\u2640":"1f486-1f3ff-2640","\uD83D\uDC86\uD83C\uDFFE\u200D\u2640":"1f486-1f3fe-2640","\uD83D\uDC86\uD83C\uDFFD\u200D\u2640":"1f486-1f3fd-2640","\uD83D\uDC86\uD83C\uDFFC\u200D\u2640":"1f486-1f3fc-2640","\uD83D\uDC86\uD83C\uDFFB\u200D\u2640":"1f486-1f3fb-2640","\uD83D\uDC81\uD83C\uDFFF\u200D\u2642":"1f481-1f3ff-2642","\uD83D\uDC81\uD83C\uDFFE\u200D\u2642":"1f481-1f3fe-2642","\uD83D\uDC81\uD83C\uDFFD\u200D\u2642":"1f481-1f3fd-2642","\uD83D\uDC81\uD83C\uDFFC\u200D\u2642":"1f481-1f3fc-2642","\uD83D\uDC81\uD83C\uDFFB\u200D\u2642":"1f481-1f3fb-2642","\uD83D\uDC81\uD83C\uDFFF\u200D\u2640":"1f481-1f3ff-2640","\uD83D\uDC81\uD83C\uDFFE\u200D\u2640":"1f481-1f3fe-2640","\uD83D\uDC81\uD83C\uDFFD\u200D\u2640":"1f481-1f3fd-2640","\uD83D\uDC81\uD83C\uDFFC\u200D\u2640":"1f481-1f3fc-2640","\uD83D\uDC81\uD83C\uDFFB\u200D\u2640":"1f481-1f3fb-2640","\uD83D\uDC71\uD83C\uDFFF\u200D\u2642":"1f471-1f3ff-2642","\uD83D\uDC71\uD83C\uDFFE\u200D\u2642":"1f471-1f3fe-2642","\uD83D\uDC71\uD83C\uDFFD\u200D\u2642":"1f471-1f3fd-2642","\uD83D\uDC71\uD83C\uDFFC\u200D\u2642":"1f471-1f3fc-2642","\uD83D\uDC71\uD83C\uDFFB\u200D\u2642":"1f471-1f3fb-2642","\uD83D\uDC71\uD83C\uDFFF\u200D\u2640":"1f471-1f3ff-2640","\uD83D\uDC71\uD83C\uDFFE\u200D\u2640":"1f471-1f3fe-2640","\uD83D\uDC71\uD83C\uDFFD\u200D\u2640":"1f471-1f3fd-2640","\uD83D\uDC71\uD83C\uDFFC\u200D\u2640":"1f471-1f3fc-2640","\uD83D\uDC71\uD83C\uDFFB\u200D\u2640":"1f471-1f3fb-2640","\uD83D\uDC73\uD83C\uDFFF\u200D\u2642":"1f473-1f3ff-2642","\uD83D\uDC73\uD83C\uDFFE\u200D\u2642":"1f473-1f3fe-2642","\uD83D\uDC73\uD83C\uDFFD\u200D\u2642":"1f473-1f3fd-2642","\uD83D\uDC73\uD83C\uDFFC\u200D\u2642":"1f473-1f3fc-2642","\uD83D\uDC73\uD83C\uDFFB\u200D\u2642":"1f473-1f3fb-2642","\uD83D\uDC73\uD83C\uDFFF\u200D\u2640":"1f473-1f3ff-2640","\uD83D\uDC73\uD83C\uDFFE\u200D\u2640":"1f473-1f3fe-2640","\uD83D\uDC73\uD83C\uDFFD\u200D\u2640":"1f473-1f3fd-2640","\uD83D\uDC73\uD83C\uDFFC\u200D\u2640":"1f473-1f3fc-2640","\uD83D\uDC73\uD83C\uDFFB\u200D\u2640":"1f473-1f3fb-2640","\uD83D\uDC82\uD83C\uDFFF\u200D\u2642":"1f482-1f3ff-2642","\uD83D\uDC82\uD83C\uDFFE\u200D\u2642":"1f482-1f3fe-2642","\uD83D\uDC82\uD83C\uDFFD\u200D\u2642":"1f482-1f3fd-2642","\uD83D\uDC82\uD83C\uDFFC\u200D\u2642":"1f482-1f3fc-2642","\uD83D\uDC82\uD83C\uDFFB\u200D\u2642":"1f482-1f3fb-2642","\uD83D\uDC82\uD83C\uDFFF\u200D\u2640":"1f482-1f3ff-2640","\uD83D\uDC82\uD83C\uDFFE\u200D\u2640":"1f482-1f3fe-2640","\uD83D\uDC82\uD83C\uDFFD\u200D\u2640":"1f482-1f3fd-2640","\uD83D\uDC82\uD83C\uDFFC\u200D\u2640":"1f482-1f3fc-2640","\uD83D\uDC82\uD83C\uDFFB\u200D\u2640":"1f482-1f3fb-2640","\uD83D\uDD75\uD83C\uDFFF\u200D\u2642":"1f575-1f3ff-2642","\uD83D\uDD75\uD83C\uDFFE\u200D\u2642":"1f575-1f3fe-2642","\uD83D\uDD75\uD83C\uDFFD\u200D\u2642":"1f575-1f3fd-2642","\uD83D\uDD75\uD83C\uDFFC\u200D\u2642":"1f575-1f3fc-2642","\uD83D\uDD75\uD83C\uDFFB\u200D\u2642":"1f575-1f3fb-2642","\uD83D\uDD75\uD83C\uDFFF\u200D\u2640":"1f575-1f3ff-2640","\uD83D\uDD75\uD83C\uDFFE\u200D\u2640":"1f575-1f3fe-2640","\uD83D\uDD75\uD83C\uDFFD\u200D\u2640":"1f575-1f3fd-2640","\uD83D\uDD75\uD83C\uDFFC\u200D\u2640":"1f575-1f3fc-2640","\uD83D\uDD75\uD83C\uDFFB\u200D\u2640":"1f575-1f3fb-2640","\uD83D\uDC77\uD83C\uDFFF\u200D\u2642":"1f477-1f3ff-2642","\uD83D\uDC77\uD83C\uDFFE\u200D\u2642":"1f477-1f3fe-2642","\uD83D\uDC77\uD83C\uDFFD\u200D\u2642":"1f477-1f3fd-2642","\uD83D\uDC77\uD83C\uDFFC\u200D\u2642":"1f477-1f3fc-2642","\uD83D\uDC77\uD83C\uDFFB\u200D\u2642":"1f477-1f3fb-2642","\uD83D\uDC77\uD83C\uDFFF\u200D\u2640":"1f477-1f3ff-2640","\uD83D\uDC77\uD83C\uDFFE\u200D\u2640":"1f477-1f3fe-2640","\uD83D\uDC77\uD83C\uDFFD\u200D\u2640":"1f477-1f3fd-2640","\uD83D\uDC77\uD83C\uDFFC\u200D\u2640":"1f477-1f3fc-2640","\uD83D\uDC77\uD83C\uDFFB\u200D\u2640":"1f477-1f3fb-2640","\uD83D\uDC6E\uD83C\uDFFF\u200D\u2642":"1f46e-1f3ff-2642","\uD83D\uDC6E\uD83C\uDFFE\u200D\u2642":"1f46e-1f3fe-2642","\uD83D\uDC6E\uD83C\uDFFD\u200D\u2642":"1f46e-1f3fd-2642","\uD83D\uDC6E\uD83C\uDFFC\u200D\u2642":"1f46e-1f3fc-2642","\uD83D\uDC6E\uD83C\uDFFB\u200D\u2642":"1f46e-1f3fb-2642","\uD83D\uDC6E\uD83C\uDFFF\u200D\u2640":"1f46e-1f3ff-2640","\uD83D\uDC6E\uD83C\uDFFE\u200D\u2640":"1f46e-1f3fe-2640","\uD83D\uDC6E\uD83C\uDFFD\u200D\u2640":"1f46e-1f3fd-2640","\uD83D\uDC6E\uD83C\uDFFC\u200D\u2640":"1f46e-1f3fc-2640","\uD83D\uDC6E\uD83C\uDFFB\u200D\u2640":"1f46e-1f3fb-2640","\uD83D\uDC68\uD83C\uDFFF\u200D\u2695":"1f468-1f3ff-2695","\uD83D\uDC68\uD83C\uDFFE\u200D\u2695":"1f468-1f3fe-2695","\uD83D\uDC68\uD83C\uDFFD\u200D\u2695":"1f468-1f3fd-2695","\uD83D\uDC68\uD83C\uDFFC\u200D\u2695":"1f468-1f3fc-2695","\uD83D\uDC68\uD83C\uDFFB\u200D\u2695":"1f468-1f3fb-2695","\uD83D\uDC69\uD83C\uDFFF\u200D\u2695":"1f469-1f3ff-2695","\uD83D\uDC69\uD83C\uDFFE\u200D\u2695":"1f469-1f3fe-2695","\uD83D\uDC69\uD83C\uDFFD\u200D\u2695":"1f469-1f3fd-2695","\uD83D\uDC69\uD83C\uDFFC\u200D\u2695":"1f469-1f3fc-2695","\uD83D\uDC69\uD83C\uDFFB\u200D\u2695":"1f469-1f3fb-2695","\uD83D\uDC68\uD83C\uDFFB\u200D\u2696":"1f468-1f3fb-2696","\uD83D\uDC68\uD83C\uDFFC\u200D\u2696":"1f468-1f3fc-2696","\uD83D\uDC68\uD83C\uDFFD\u200D\u2696":"1f468-1f3fd-2696","\uD83D\uDC68\uD83C\uDFFE\u200D\u2696":"1f468-1f3fe-2696","\uD83D\uDC68\uD83C\uDFFF\u200D\u2696":"1f468-1f3ff-2696","\uD83D\uDC69\uD83C\uDFFB\u200D\u2696":"1f469-1f3fb-2696","\uD83D\uDC69\uD83C\uDFFC\u200D\u2696":"1f469-1f3fc-2696","\uD83D\uDC69\uD83C\uDFFD\u200D\u2696":"1f469-1f3fd-2696","\uD83D\uDC69\uD83C\uDFFE\u200D\u2696":"1f469-1f3fe-2696","\uD83D\uDC69\uD83C\uDFFF\u200D\u2696":"1f469-1f3ff-2696","\uD83D\uDC68\uD83C\uDFFB\u200D\u2708":"1f468-1f3fb-2708","\uD83D\uDC68\uD83C\uDFFC\u200D\u2708":"1f468-1f3fc-2708","\uD83D\uDC68\uD83C\uDFFD\u200D\u2708":"1f468-1f3fd-2708","\uD83D\uDC68\uD83C\uDFFE\u200D\u2708":"1f468-1f3fe-2708","\uD83D\uDC68\uD83C\uDFFF\u200D\u2708":"1f468-1f3ff-2708","\uD83D\uDC69\uD83C\uDFFB\u200D\u2708":"1f469-1f3fb-2708","\uD83D\uDC69\uD83C\uDFFC\u200D\u2708":"1f469-1f3fc-2708","\uD83D\uDC69\uD83C\uDFFD\u200D\u2708":"1f469-1f3fd-2708","\uD83D\uDC69\uD83C\uDFFE\u200D\u2708":"1f469-1f3fe-2708","\uD83D\uDC69\uD83C\uDFFF\u200D\u2708":"1f469-1f3ff-2708","\uD83D\uDC68\u2764\uFE0F\uD83D\uDC68":"1f468-2764-1f468","\uD83D\uDC69\u2764\uFE0F\uD83D\uDC68":"1f469-2764-1f468","\uD83D\uDC69\u2764\uFE0F\uD83D\uDC69":"1f469-2764-1f469","\uD83D\uDC68\uD83C\uDFFB\u2695\uFE0F":"1f468-1f3fb-2695","\uD83D\uDC68\uD83C\uDFFB\u2696\uFE0F":"1f468-1f3fb-2696","\uD83D\uDC68\uD83C\uDFFB\u2708\uFE0F":"1f468-1f3fb-2708","\uD83D\uDC68\uD83C\uDFFC\u2695\uFE0F":"1f468-1f3fc-2695","\uD83D\uDC68\uD83C\uDFFC\u2696\uFE0F":"1f468-1f3fc-2696","\uD83D\uDC68\uD83C\uDFFC\u2708\uFE0F":"1f468-1f3fc-2708","\uD83D\uDC68\uD83C\uDFFD\u2695\uFE0F":"1f468-1f3fd-2695","\uD83D\uDC68\uD83C\uDFFD\u2696\uFE0F":"1f468-1f3fd-2696","\uD83D\uDC68\uD83C\uDFFD\u2708\uFE0F":"1f468-1f3fd-2708","\uD83D\uDC68\uD83C\uDFFE\u2695\uFE0F":"1f468-1f3fe-2695","\uD83D\uDC68\uD83C\uDFFE\u2696\uFE0F":"1f468-1f3fe-2696","\uD83D\uDC68\uD83C\uDFFE\u2708\uFE0F":"1f468-1f3fe-2708","\uD83D\uDC68\uD83C\uDFFF\u2695\uFE0F":"1f468-1f3ff-2695","\uD83D\uDC68\uD83C\uDFFF\u2696\uFE0F":"1f468-1f3ff-2696","\uD83D\uDC68\uD83C\uDFFF\u2708\uFE0F":"1f468-1f3ff-2708","\uD83D\uDC69\uD83C\uDFFB\u2695\uFE0F":"1f469-1f3fb-2695","\uD83D\uDC69\uD83C\uDFFB\u2696\uFE0F":"1f469-1f3fb-2696","\uD83D\uDC69\uD83C\uDFFB\u2708\uFE0F":"1f469-1f3fb-2708","\uD83D\uDC69\uD83C\uDFFC\u2695\uFE0F":"1f469-1f3fc-2695","\uD83D\uDC69\uD83C\uDFFC\u2696\uFE0F":"1f469-1f3fc-2696","\uD83D\uDC69\uD83C\uDFFC\u2708\uFE0F":"1f469-1f3fc-2708","\uD83D\uDC69\uD83C\uDFFD\u2695\uFE0F":"1f469-1f3fd-2695","\uD83D\uDC69\uD83C\uDFFD\u2696\uFE0F":"1f469-1f3fd-2696","\uD83D\uDC69\uD83C\uDFFD\u2708\uFE0F":"1f469-1f3fd-2708","\uD83D\uDC69\uD83C\uDFFE\u2695\uFE0F":"1f469-1f3fe-2695","\uD83D\uDC69\uD83C\uDFFE\u2696\uFE0F":"1f469-1f3fe-2696","\uD83D\uDC69\uD83C\uDFFE\u2708\uFE0F":"1f469-1f3fe-2708","\uD83D\uDC69\uD83C\uDFFF\u2695\uFE0F":"1f469-1f3ff-2695","\uD83D\uDC69\uD83C\uDFFF\u2696\uFE0F":"1f469-1f3ff-2696","\uD83D\uDC69\uD83C\uDFFF\u2708\uFE0F":"1f469-1f3ff-2708","\uD83D\uDC6E\uD83C\uDFFB\u2640\uFE0F":"1f46e-1f3fb-2640","\uD83D\uDC6E\uD83C\uDFFB\u2642\uFE0F":"1f46e-1f3fb-2642","\uD83D\uDC6E\uD83C\uDFFC\u2640\uFE0F":"1f46e-1f3fc-2640","\uD83D\uDC6E\uD83C\uDFFC\u2642\uFE0F":"1f46e-1f3fc-2642","\uD83D\uDC6E\uD83C\uDFFD\u2640\uFE0F":"1f46e-1f3fd-2640","\uD83D\uDC6E\uD83C\uDFFD\u2642\uFE0F":"1f46e-1f3fd-2642","\uD83D\uDC6E\uD83C\uDFFE\u2640\uFE0F":"1f46e-1f3fe-2640","\uD83D\uDC6E\uD83C\uDFFE\u2642\uFE0F":"1f46e-1f3fe-2642","\uD83D\uDC6E\uD83C\uDFFF\u2640\uFE0F":"1f46e-1f3ff-2640","\uD83D\uDC6E\uD83C\uDFFF\u2642\uFE0F":"1f46e-1f3ff-2642","\uD83D\uDC71\uD83C\uDFFB\u2640\uFE0F":"1f471-1f3fb-2640","\uD83D\uDC71\uD83C\uDFFB\u2642\uFE0F":"1f471-1f3fb-2642","\uD83D\uDC71\uD83C\uDFFC\u2640\uFE0F":"1f471-1f3fc-2640","\uD83D\uDC71\uD83C\uDFFC\u2642\uFE0F":"1f471-1f3fc-2642","\uD83D\uDC71\uD83C\uDFFD\u2640\uFE0F":"1f471-1f3fd-2640","\uD83D\uDC71\uD83C\uDFFD\u2642\uFE0F":"1f471-1f3fd-2642","\uD83D\uDC71\uD83C\uDFFE\u2640\uFE0F":"1f471-1f3fe-2640","\uD83D\uDC71\uD83C\uDFFE\u2642\uFE0F":"1f471-1f3fe-2642","\uD83D\uDC71\uD83C\uDFFF\u2640\uFE0F":"1f471-1f3ff-2640","\uD83D\uDC71\uD83C\uDFFF\u2642\uFE0F":"1f471-1f3ff-2642","\uD83D\uDC73\uD83C\uDFFB\u2640\uFE0F":"1f473-1f3fb-2640","\uD83D\uDC73\uD83C\uDFFB\u2642\uFE0F":"1f473-1f3fb-2642","\uD83D\uDC73\uD83C\uDFFC\u2640\uFE0F":"1f473-1f3fc-2640","\uD83D\uDC73\uD83C\uDFFC\u2642\uFE0F":"1f473-1f3fc-2642","\uD83D\uDC73\uD83C\uDFFD\u2640\uFE0F":"1f473-1f3fd-2640","\uD83D\uDC73\uD83C\uDFFD\u2642\uFE0F":"1f473-1f3fd-2642","\uD83D\uDC73\uD83C\uDFFE\u2640\uFE0F":"1f473-1f3fe-2640","\uD83D\uDC73\uD83C\uDFFE\u2642\uFE0F":"1f473-1f3fe-2642","\uD83D\uDC73\uD83C\uDFFF\u2640\uFE0F":"1f473-1f3ff-2640","\uD83D\uDC73\uD83C\uDFFF\u2642\uFE0F":"1f473-1f3ff-2642","\uD83D\uDC77\uD83C\uDFFB\u2640\uFE0F":"1f477-1f3fb-2640","\uD83D\uDC77\uD83C\uDFFB\u2642\uFE0F":"1f477-1f3fb-2642","\uD83D\uDC77\uD83C\uDFFC\u2640\uFE0F":"1f477-1f3fc-2640","\uD83D\uDC77\uD83C\uDFFC\u2642\uFE0F":"1f477-1f3fc-2642","\uD83D\uDC77\uD83C\uDFFD\u2640\uFE0F":"1f477-1f3fd-2640","\uD83D\uDC77\uD83C\uDFFD\u2642\uFE0F":"1f477-1f3fd-2642","\uD83D\uDC77\uD83C\uDFFE\u2640\uFE0F":"1f477-1f3fe-2640","\uD83D\uDC77\uD83C\uDFFE\u2642\uFE0F":"1f477-1f3fe-2642","\uD83D\uDC77\uD83C\uDFFF\u2640\uFE0F":"1f477-1f3ff-2640","\uD83D\uDC77\uD83C\uDFFF\u2642\uFE0F":"1f477-1f3ff-2642","\uD83D\uDC82\uD83C\uDFFB\u2640\uFE0F":"1f482-1f3fb-2640","\uD83D\uDC82\uD83C\uDFFB\u2642\uFE0F":"1f482-1f3fb-2642","\uD83D\uDC82\uD83C\uDFFC\u2640\uFE0F":"1f482-1f3fc-2640","\uD83D\uDC82\uD83C\uDFFC\u2642\uFE0F":"1f482-1f3fc-2642","\uD83D\uDC82\uD83C\uDFFD\u2640\uFE0F":"1f482-1f3fd-2640","\uD83D\uDC82\uD83C\uDFFD\u2642\uFE0F":"1f482-1f3fd-2642","\uD83D\uDC82\uD83C\uDFFE\u2640\uFE0F":"1f482-1f3fe-2640","\uD83D\uDC82\uD83C\uDFFE\u2642\uFE0F":"1f482-1f3fe-2642","\uD83D\uDC82\uD83C\uDFFF\u2640\uFE0F":"1f482-1f3ff-2640","\uD83D\uDC82\uD83C\uDFFF\u2642\uFE0F":"1f482-1f3ff-2642","\uD83C\uDFC3\uD83C\uDFFB\u2640\uFE0F":"1f3c3-1f3fb-2640","\uD83C\uDFC3\uD83C\uDFFB\u2642\uFE0F":"1f3c3-1f3fb-2642","\uD83C\uDFC3\uD83C\uDFFC\u2640\uFE0F":"1f3c3-1f3fc-2640","\uD83C\uDFC3\uD83C\uDFFC\u2642\uFE0F":"1f3c3-1f3fc-2642","\uD83C\uDFC3\uD83C\uDFFD\u2640\uFE0F":"1f3c3-1f3fd-2640","\uD83C\uDFC3\uD83C\uDFFD\u2642\uFE0F":"1f3c3-1f3fd-2642","\uD83C\uDFC3\uD83C\uDFFE\u2640\uFE0F":"1f3c3-1f3fe-2640","\uD83C\uDFC3\uD83C\uDFFE\u2642\uFE0F":"1f3c3-1f3fe-2642","\uD83C\uDFC3\uD83C\uDFFF\u2640\uFE0F":"1f3c3-1f3ff-2640","\uD83C\uDFC3\uD83C\uDFFF\u2642\uFE0F":"1f3c3-1f3ff-2642","\uD83C\uDFC4\uD83C\uDFFB\u2640\uFE0F":"1f3c4-1f3fb-2640","\uD83C\uDFC4\uD83C\uDFFB\u2642\uFE0F":"1f3c4-1f3fb-2642","\uD83C\uDFC4\uD83C\uDFFC\u2640\uFE0F":"1f3c4-1f3fc-2640","\uD83C\uDFC4\uD83C\uDFFC\u2642\uFE0F":"1f3c4-1f3fc-2642","\uD83C\uDFC4\uD83C\uDFFD\u2640\uFE0F":"1f3c4-1f3fd-2640","\uD83C\uDFC4\uD83C\uDFFD\u2642\uFE0F":"1f3c4-1f3fd-2642","\uD83C\uDFC4\uD83C\uDFFE\u2640\uFE0F":"1f3c4-1f3fe-2640","\uD83C\uDFC4\uD83C\uDFFE\u2642\uFE0F":"1f3c4-1f3fe-2642","\uD83C\uDFC4\uD83C\uDFFF\u2640\uFE0F":"1f3c4-1f3ff-2640","\uD83C\uDFC4\uD83C\uDFFF\u2642\uFE0F":"1f3c4-1f3ff-2642","\uD83C\uDFCA\uD83C\uDFFB\u2640\uFE0F":"1f3ca-1f3fb-2640","\uD83C\uDFCA\uD83C\uDFFB\u2642\uFE0F":"1f3ca-1f3fb-2642","\uD83C\uDFCA\uD83C\uDFFC\u2640\uFE0F":"1f3ca-1f3fc-2640","\uD83C\uDFCA\uD83C\uDFFC\u2642\uFE0F":"1f3ca-1f3fc-2642","\uD83C\uDFCA\uD83C\uDFFD\u2640\uFE0F":"1f3ca-1f3fd-2640","\uD83C\uDFCA\uD83C\uDFFD\u2642\uFE0F":"1f3ca-1f3fd-2642","\uD83C\uDFCA\uD83C\uDFFE\u2640\uFE0F":"1f3ca-1f3fe-2640","\uD83C\uDFCA\uD83C\uDFFE\u2642\uFE0F":"1f3ca-1f3fe-2642","\uD83C\uDFCA\uD83C\uDFFF\u2640\uFE0F":"1f3ca-1f3ff-2640","\uD83C\uDFCA\uD83C\uDFFF\u2642\uFE0F":"1f3ca-1f3ff-2642","\uD83D\uDC86\uD83C\uDFFB\u2640\uFE0F":"1f486-1f3fb-2640","\uD83D\uDC86\uD83C\uDFFB\u2642\uFE0F":"1f486-1f3fb-2642","\uD83D\uDC86\uD83C\uDFFC\u2640\uFE0F":"1f486-1f3fc-2640","\uD83D\uDC86\uD83C\uDFFC\u2642\uFE0F":"1f486-1f3fc-2642","\uD83D\uDC86\uD83C\uDFFD\u2640\uFE0F":"1f486-1f3fd-2640","\uD83D\uDC86\uD83C\uDFFD\u2642\uFE0F":"1f486-1f3fd-2642","\uD83D\uDC86\uD83C\uDFFE\u2640\uFE0F":"1f486-1f3fe-2640","\uD83D\uDC86\uD83C\uDFFE\u2642\uFE0F":"1f486-1f3fe-2642","\uD83D\uDC86\uD83C\uDFFF\u2640\uFE0F":"1f486-1f3ff-2640","\uD83D\uDC86\uD83C\uDFFF\u2642\uFE0F":"1f486-1f3ff-2642","\uD83D\uDC87\uD83C\uDFFB\u2640\uFE0F":"1f487-1f3fb-2640","\uD83D\uDC87\uD83C\uDFFB\u2642\uFE0F":"1f487-1f3fb-2642","\uD83D\uDC87\uD83C\uDFFC\u2640\uFE0F":"1f487-1f3fc-2640","\uD83D\uDC87\uD83C\uDFFC\u2642\uFE0F":"1f487-1f3fc-2642","\uD83D\uDC87\uD83C\uDFFD\u2640\uFE0F":"1f487-1f3fd-2640","\uD83D\uDC87\uD83C\uDFFD\u2642\uFE0F":"1f487-1f3fd-2642","\uD83D\uDC87\uD83C\uDFFE\u2640\uFE0F":"1f487-1f3fe-2640","\uD83D\uDC87\uD83C\uDFFE\u2642\uFE0F":"1f487-1f3fe-2642","\uD83D\uDC87\uD83C\uDFFF\u2640\uFE0F":"1f487-1f3ff-2640","\uD83D\uDC87\uD83C\uDFFF\u2642\uFE0F":"1f487-1f3ff-2642","\uD83D\uDEA3\uD83C\uDFFB\u2640\uFE0F":"1f6a3-1f3fb-2640","\uD83D\uDEA3\uD83C\uDFFB\u2642\uFE0F":"1f6a3-1f3fb-2642","\uD83D\uDEA3\uD83C\uDFFC\u2640\uFE0F":"1f6a3-1f3fc-2640","\uD83D\uDEA3\uD83C\uDFFC\u2642\uFE0F":"1f6a3-1f3fc-2642","\uD83D\uDEA3\uD83C\uDFFD\u2640\uFE0F":"1f6a3-1f3fd-2640","\uD83D\uDEA3\uD83C\uDFFD\u2642\uFE0F":"1f6a3-1f3fd-2642","\uD83D\uDEA3\uD83C\uDFFE\u2640\uFE0F":"1f6a3-1f3fe-2640","\uD83D\uDEA3\uD83C\uDFFE\u2642\uFE0F":"1f6a3-1f3fe-2642","\uD83D\uDEA3\uD83C\uDFFF\u2640\uFE0F":"1f6a3-1f3ff-2640","\uD83D\uDEA3\uD83C\uDFFF\u2642\uFE0F":"1f6a3-1f3ff-2642","\uD83D\uDEB4\uD83C\uDFFB\u2640\uFE0F":"1f6b4-1f3fb-2640","\uD83D\uDEB4\uD83C\uDFFB\u2642\uFE0F":"1f6b4-1f3fb-2642","\uD83D\uDEB4\uD83C\uDFFC\u2640\uFE0F":"1f6b4-1f3fc-2640","\uD83D\uDEB4\uD83C\uDFFC\u2642\uFE0F":"1f6b4-1f3fc-2642","\uD83D\uDEB4\uD83C\uDFFD\u2640\uFE0F":"1f6b4-1f3fd-2640","\uD83D\uDEB4\uD83C\uDFFD\u2642\uFE0F":"1f6b4-1f3fd-2642","\uD83D\uDEB4\uD83C\uDFFE\u2640\uFE0F":"1f6b4-1f3fe-2640","\uD83D\uDEB4\uD83C\uDFFE\u2642\uFE0F":"1f6b4-1f3fe-2642","\uD83D\uDEB4\uD83C\uDFFF\u2640\uFE0F":"1f6b4-1f3ff-2640","\uD83D\uDEB4\uD83C\uDFFF\u2642\uFE0F":"1f6b4-1f3ff-2642","\uD83D\uDEB5\uD83C\uDFFB\u2640\uFE0F":"1f6b5-1f3fb-2640","\uD83D\uDEB5\uD83C\uDFFB\u2642\uFE0F":"1f6b5-1f3fb-2642","\uD83D\uDEB5\uD83C\uDFFC\u2640\uFE0F":"1f6b5-1f3fc-2640","\uD83D\uDEB5\uD83C\uDFFC\u2642\uFE0F":"1f6b5-1f3fc-2642","\uD83D\uDEB5\uD83C\uDFFD\u2640\uFE0F":"1f6b5-1f3fd-2640","\uD83D\uDEB5\uD83C\uDFFD\u2642\uFE0F":"1f6b5-1f3fd-2642","\uD83D\uDEB5\uD83C\uDFFE\u2640\uFE0F":"1f6b5-1f3fe-2640","\uD83D\uDEB5\uD83C\uDFFE\u2642\uFE0F":"1f6b5-1f3fe-2642","\uD83D\uDEB5\uD83C\uDFFF\u2640\uFE0F":"1f6b5-1f3ff-2640","\uD83D\uDEB5\uD83C\uDFFF\u2642\uFE0F":"1f6b5-1f3ff-2642","\uD83D\uDEB6\uD83C\uDFFB\u2640\uFE0F":"1f6b6-1f3fb-2640","\uD83D\uDEB6\uD83C\uDFFB\u2642\uFE0F":"1f6b6-1f3fb-2642","\uD83D\uDEB6\uD83C\uDFFC\u2640\uFE0F":"1f6b6-1f3fc-2640","\uD83D\uDEB6\uD83C\uDFFC\u2642\uFE0F":"1f6b6-1f3fc-2642","\uD83D\uDEB6\uD83C\uDFFD\u2640\uFE0F":"1f6b6-1f3fd-2640","\uD83D\uDEB6\uD83C\uDFFD\u2642\uFE0F":"1f6b6-1f3fd-2642","\uD83D\uDEB6\uD83C\uDFFE\u2640\uFE0F":"1f6b6-1f3fe-2640","\uD83D\uDEB6\uD83C\uDFFE\u2642\uFE0F":"1f6b6-1f3fe-2642","\uD83D\uDEB6\uD83C\uDFFF\u2640\uFE0F":"1f6b6-1f3ff-2640","\uD83D\uDEB6\uD83C\uDFFF\u2642\uFE0F":"1f6b6-1f3ff-2642","\uD83E\uDD38\uD83C\uDFFB\u2640\uFE0F":"1f938-1f3fb-2640","\uD83E\uDD38\uD83C\uDFFB\u2642\uFE0F":"1f938-1f3fb-2642","\uD83E\uDD38\uD83C\uDFFC\u2640\uFE0F":"1f938-1f3fc-2640","\uD83E\uDD38\uD83C\uDFFC\u2642\uFE0F":"1f938-1f3fc-2642","\uD83E\uDD38\uD83C\uDFFD\u2640\uFE0F":"1f938-1f3fd-2640","\uD83E\uDD38\uD83C\uDFFD\u2642\uFE0F":"1f938-1f3fd-2642","\uD83E\uDD38\uD83C\uDFFE\u2640\uFE0F":"1f938-1f3fe-2640","\uD83E\uDD38\uD83C\uDFFE\u2642\uFE0F":"1f938-1f3fe-2642","\uD83E\uDD38\uD83C\uDFFF\u2640\uFE0F":"1f938-1f3ff-2640","\uD83E\uDD38\uD83C\uDFFF\u2642\uFE0F":"1f938-1f3ff-2642","\uD83E\uDD39\uD83C\uDFFB\u2640\uFE0F":"1f939-1f3fb-2640","\uD83E\uDD39\uD83C\uDFFB\u2642\uFE0F":"1f939-1f3fb-2642","\uD83E\uDD39\uD83C\uDFFC\u2640\uFE0F":"1f939-1f3fc-2640","\uD83E\uDD39\uD83C\uDFFC\u2642\uFE0F":"1f939-1f3fc-2642","\uD83E\uDD39\uD83C\uDFFD\u2640\uFE0F":"1f939-1f3fd-2640","\uD83E\uDD39\uD83C\uDFFD\u2642\uFE0F":"1f939-1f3fd-2642","\uD83E\uDD39\uD83C\uDFFE\u2640\uFE0F":"1f939-1f3fe-2640","\uD83E\uDD39\uD83C\uDFFE\u2642\uFE0F":"1f939-1f3fe-2642","\uD83E\uDD39\uD83C\uDFFF\u2640\uFE0F":"1f939-1f3ff-2640","\uD83E\uDD39\uD83C\uDFFF\u2642\uFE0F":"1f939-1f3ff-2642","\uD83E\uDD3D\uD83C\uDFFB\u2640\uFE0F":"1f93d-1f3fb-2640","\uD83E\uDD3D\uD83C\uDFFB\u2642\uFE0F":"1f93d-1f3fb-2642","\uD83E\uDD3D\uD83C\uDFFC\u2640\uFE0F":"1f93d-1f3fc-2640","\uD83E\uDD3D\uD83C\uDFFC\u2642\uFE0F":"1f93d-1f3fc-2642","\uD83E\uDD3D\uD83C\uDFFD\u2640\uFE0F":"1f93d-1f3fd-2640","\uD83E\uDD3D\uD83C\uDFFD\u2642\uFE0F":"1f93d-1f3fd-2642","\uD83E\uDD3D\uD83C\uDFFE\u2640\uFE0F":"1f93d-1f3fe-2640","\uD83E\uDD3D\uD83C\uDFFE\u2642\uFE0F":"1f93d-1f3fe-2642","\uD83E\uDD3D\uD83C\uDFFF\u2640\uFE0F":"1f93d-1f3ff-2640","\uD83E\uDD3D\uD83C\uDFFF\u2642\uFE0F":"1f93d-1f3ff-2642","\uD83E\uDD3E\uD83C\uDFFB\u2640\uFE0F":"1f93e-1f3fb-2640","\uD83E\uDD3E\uD83C\uDFFB\u2642\uFE0F":"1f93e-1f3fb-2642","\uD83E\uDD3E\uD83C\uDFFC\u2640\uFE0F":"1f93e-1f3fc-2640","\uD83E\uDD3E\uD83C\uDFFC\u2642\uFE0F":"1f93e-1f3fc-2642","\uD83E\uDD3E\uD83C\uDFFD\u2640\uFE0F":"1f93e-1f3fd-2640","\uD83E\uDD3E\uD83C\uDFFD\u2642\uFE0F":"1f93e-1f3fd-2642","\uD83E\uDD3E\uD83C\uDFFE\u2640\uFE0F":"1f93e-1f3fe-2640","\uD83E\uDD3E\uD83C\uDFFE\u2642\uFE0F":"1f93e-1f3fe-2642","\uD83E\uDD3E\uD83C\uDFFF\u2640\uFE0F":"1f93e-1f3ff-2640","\uD83E\uDD3E\uD83C\uDFFF\u2642\uFE0F":"1f93e-1f3ff-2642","\uD83D\uDC81\uD83C\uDFFB\u2640\uFE0F":"1f481-1f3fb-2640","\uD83D\uDC81\uD83C\uDFFB\u2642\uFE0F":"1f481-1f3fb-2642","\uD83D\uDC81\uD83C\uDFFC\u2640\uFE0F":"1f481-1f3fc-2640","\uD83D\uDC81\uD83C\uDFFC\u2642\uFE0F":"1f481-1f3fc-2642","\uD83D\uDC81\uD83C\uDFFD\u2640\uFE0F":"1f481-1f3fd-2640","\uD83D\uDC81\uD83C\uDFFD\u2642\uFE0F":"1f481-1f3fd-2642","\uD83D\uDC81\uD83C\uDFFE\u2640\uFE0F":"1f481-1f3fe-2640","\uD83D\uDC81\uD83C\uDFFE\u2642\uFE0F":"1f481-1f3fe-2642","\uD83D\uDC81\uD83C\uDFFF\u2640\uFE0F":"1f481-1f3ff-2640","\uD83D\uDC81\uD83C\uDFFF\u2642\uFE0F":"1f481-1f3ff-2642","\uD83D\uDE45\uD83C\uDFFB\u2640\uFE0F":"1f645-1f3fb-2640","\uD83D\uDE45\uD83C\uDFFB\u2642\uFE0F":"1f645-1f3fb-2642","\uD83D\uDE45\uD83C\uDFFC\u2640\uFE0F":"1f645-1f3fc-2640","\uD83D\uDE45\uD83C\uDFFC\u2642\uFE0F":"1f645-1f3fc-2642","\uD83D\uDE45\uD83C\uDFFD\u2640\uFE0F":"1f645-1f3fd-2640","\uD83D\uDE45\uD83C\uDFFD\u2642\uFE0F":"1f645-1f3fd-2642","\uD83D\uDE45\uD83C\uDFFE\u2640\uFE0F":"1f645-1f3fe-2640","\uD83D\uDE45\uD83C\uDFFE\u2642\uFE0F":"1f645-1f3fe-2642","\uD83D\uDE45\uD83C\uDFFF\u2640\uFE0F":"1f645-1f3ff-2640","\uD83D\uDE45\uD83C\uDFFF\u2642\uFE0F":"1f645-1f3ff-2642","\uD83D\uDE46\uD83C\uDFFB\u2640\uFE0F":"1f646-1f3fb-2640","\uD83D\uDE46\uD83C\uDFFB\u2642\uFE0F":"1f646-1f3fb-2642","\uD83D\uDE46\uD83C\uDFFC\u2640\uFE0F":"1f646-1f3fc-2640","\uD83D\uDE46\uD83C\uDFFC\u2642\uFE0F":"1f646-1f3fc-2642","\uD83D\uDE46\uD83C\uDFFD\u2640\uFE0F":"1f646-1f3fd-2640","\uD83D\uDE46\uD83C\uDFFD\u2642\uFE0F":"1f646-1f3fd-2642","\uD83D\uDE46\uD83C\uDFFE\u2640\uFE0F":"1f646-1f3fe-2640","\uD83D\uDE46\uD83C\uDFFE\u2642\uFE0F":"1f646-1f3fe-2642","\uD83D\uDE46\uD83C\uDFFF\u2640\uFE0F":"1f646-1f3ff-2640","\uD83D\uDE46\uD83C\uDFFF\u2642\uFE0F":"1f646-1f3ff-2642","\uD83D\uDE47\uD83C\uDFFB\u2640\uFE0F":"1f647-1f3fb-2640","\uD83D\uDE47\uD83C\uDFFB\u2642\uFE0F":"1f647-1f3fb-2642","\uD83D\uDE47\uD83C\uDFFC\u2640\uFE0F":"1f647-1f3fc-2640","\uD83D\uDE47\uD83C\uDFFC\u2642\uFE0F":"1f647-1f3fc-2642","\uD83D\uDE47\uD83C\uDFFD\u2640\uFE0F":"1f647-1f3fd-2640","\uD83D\uDE47\uD83C\uDFFD\u2642\uFE0F":"1f647-1f3fd-2642","\uD83D\uDE47\uD83C\uDFFE\u2640\uFE0F":"1f647-1f3fe-2640","\uD83D\uDE47\uD83C\uDFFE\u2642\uFE0F":"1f647-1f3fe-2642","\uD83D\uDE47\uD83C\uDFFF\u2640\uFE0F":"1f647-1f3ff-2640","\uD83D\uDE47\uD83C\uDFFF\u2642\uFE0F":"1f647-1f3ff-2642","\uD83D\uDE4B\uD83C\uDFFB\u2640\uFE0F":"1f64b-1f3fb-2640","\uD83D\uDE4B\uD83C\uDFFB\u2642\uFE0F":"1f64b-1f3fb-2642","\uD83D\uDE4B\uD83C\uDFFC\u2640\uFE0F":"1f64b-1f3fc-2640","\uD83D\uDE4B\uD83C\uDFFC\u2642\uFE0F":"1f64b-1f3fc-2642","\uD83D\uDE4B\uD83C\uDFFD\u2640\uFE0F":"1f64b-1f3fd-2640","\uD83D\uDE4B\uD83C\uDFFD\u2642\uFE0F":"1f64b-1f3fd-2642","\uD83D\uDE4B\uD83C\uDFFE\u2640\uFE0F":"1f64b-1f3fe-2640","\uD83D\uDE4B\uD83C\uDFFE\u2642\uFE0F":"1f64b-1f3fe-2642","\uD83D\uDE4B\uD83C\uDFFF\u2640\uFE0F":"1f64b-1f3ff-2640","\uD83D\uDE4B\uD83C\uDFFF\u2642\uFE0F":"1f64b-1f3ff-2642","\uD83D\uDE4D\uD83C\uDFFB\u2640\uFE0F":"1f64d-1f3fb-2640","\uD83D\uDE4D\uD83C\uDFFB\u2642\uFE0F":"1f64d-1f3fb-2642","\uD83D\uDE4D\uD83C\uDFFC\u2640\uFE0F":"1f64d-1f3fc-2640","\uD83D\uDE4D\uD83C\uDFFC\u2642\uFE0F":"1f64d-1f3fc-2642","\uD83D\uDE4D\uD83C\uDFFD\u2640\uFE0F":"1f64d-1f3fd-2640","\uD83D\uDE4D\uD83C\uDFFD\u2642\uFE0F":"1f64d-1f3fd-2642","\uD83D\uDE4D\uD83C\uDFFE\u2640\uFE0F":"1f64d-1f3fe-2640","\uD83D\uDE4D\uD83C\uDFFE\u2642\uFE0F":"1f64d-1f3fe-2642","\uD83D\uDE4D\uD83C\uDFFF\u2640\uFE0F":"1f64d-1f3ff-2640","\uD83D\uDE4D\uD83C\uDFFF\u2642\uFE0F":"1f64d-1f3ff-2642","\uD83D\uDE4E\uD83C\uDFFB\u2640\uFE0F":"1f64e-1f3fb-2640","\uD83D\uDE4E\uD83C\uDFFB\u2642\uFE0F":"1f64e-1f3fb-2642","\uD83D\uDE4E\uD83C\uDFFC\u2640\uFE0F":"1f64e-1f3fc-2640","\uD83D\uDE4E\uD83C\uDFFC\u2642\uFE0F":"1f64e-1f3fc-2642","\uD83D\uDE4E\uD83C\uDFFD\u2640\uFE0F":"1f64e-1f3fd-2640","\uD83D\uDE4E\uD83C\uDFFD\u2642\uFE0F":"1f64e-1f3fd-2642","\uD83D\uDE4E\uD83C\uDFFE\u2640\uFE0F":"1f64e-1f3fe-2640","\uD83D\uDE4E\uD83C\uDFFE\u2642\uFE0F":"1f64e-1f3fe-2642","\uD83D\uDE4E\uD83C\uDFFF\u2640\uFE0F":"1f64e-1f3ff-2640","\uD83D\uDE4E\uD83C\uDFFF\u2642\uFE0F":"1f64e-1f3ff-2642","\uD83E\uDD26\uD83C\uDFFB\u2640\uFE0F":"1f926-1f3fb-2640","\uD83E\uDD26\uD83C\uDFFB\u2642\uFE0F":"1f926-1f3fb-2642","\uD83E\uDD26\uD83C\uDFFC\u2640\uFE0F":"1f926-1f3fc-2640","\uD83E\uDD26\uD83C\uDFFC\u2642\uFE0F":"1f926-1f3fc-2642","\uD83E\uDD26\uD83C\uDFFD\u2640\uFE0F":"1f926-1f3fd-2640","\uD83E\uDD26\uD83C\uDFFD\u2642\uFE0F":"1f926-1f3fd-2642","\uD83E\uDD26\uD83C\uDFFE\u2640\uFE0F":"1f926-1f3fe-2640","\uD83E\uDD26\uD83C\uDFFE\u2642\uFE0F":"1f926-1f3fe-2642","\uD83E\uDD26\uD83C\uDFFF\u2640\uFE0F":"1f926-1f3ff-2640","\uD83E\uDD26\uD83C\uDFFF\u2642\uFE0F":"1f926-1f3ff-2642","\uD83E\uDD37\uD83C\uDFFB\u2640\uFE0F":"1f937-1f3fb-2640","\uD83E\uDD37\uD83C\uDFFB\u2642\uFE0F":"1f937-1f3fb-2642","\uD83E\uDD37\uD83C\uDFFC\u2640\uFE0F":"1f937-1f3fc-2640","\uD83E\uDD37\uD83C\uDFFC\u2642\uFE0F":"1f937-1f3fc-2642","\uD83E\uDD37\uD83C\uDFFD\u2640\uFE0F":"1f937-1f3fd-2640","\uD83E\uDD37\uD83C\uDFFD\u2642\uFE0F":"1f937-1f3fd-2642","\uD83E\uDD37\uD83C\uDFFE\u2640\uFE0F":"1f937-1f3fe-2640","\uD83E\uDD37\uD83C\uDFFE\u2642\uFE0F":"1f937-1f3fe-2642","\uD83E\uDD37\uD83C\uDFFF\u2640\uFE0F":"1f937-1f3ff-2640","\uD83E\uDD37\uD83C\uDFFF\u2642\uFE0F":"1f937-1f3ff-2642","\uD83D\uDC41\uFE0F\uD83D\uDDE8\uFE0F":"1f441-1f5e8","\uD83E\uDDD9\uD83C\uDFFB\u200D\u2640":"1f9d9-1f3fb-2640","\uD83E\uDDD9\uD83C\uDFFB\u2640\uFE0F":"1f9d9-1f3fb-2640","\uD83E\uDDD9\uD83C\uDFFB\u200D\u2642":"1f9d9-1f3fb-2642","\uD83E\uDDD9\uD83C\uDFFB\u2642\uFE0F":"1f9d9-1f3fb-2642","\uD83E\uDDD9\uD83C\uDFFC\u200D\u2640":"1f9d9-1f3fc-2640","\uD83E\uDDD9\uD83C\uDFFC\u2640\uFE0F":"1f9d9-1f3fc-2640","\uD83E\uDDD9\uD83C\uDFFC\u200D\u2642":"1f9d9-1f3fc-2642","\uD83E\uDDD9\uD83C\uDFFC\u2642\uFE0F":"1f9d9-1f3fc-2642","\uD83E\uDDD9\uD83C\uDFFD\u200D\u2640":"1f9d9-1f3fd-2640","\uD83E\uDDD9\uD83C\uDFFD\u2640\uFE0F":"1f9d9-1f3fd-2640","\uD83E\uDDD9\uD83C\uDFFD\u200D\u2642":"1f9d9-1f3fd-2642","\uD83E\uDDD9\uD83C\uDFFD\u2642\uFE0F":"1f9d9-1f3fd-2642","\uD83E\uDDD9\uD83C\uDFFE\u200D\u2640":"1f9d9-1f3fe-2640","\uD83E\uDDD9\uD83C\uDFFE\u2640\uFE0F":"1f9d9-1f3fe-2640","\uD83E\uDDD9\uD83C\uDFFE\u200D\u2642":"1f9d9-1f3fe-2642","\uD83E\uDDD9\uD83C\uDFFE\u2642\uFE0F":"1f9d9-1f3fe-2642","\uD83E\uDDD9\uD83C\uDFFF\u200D\u2640":"1f9d9-1f3ff-2640","\uD83E\uDDD9\uD83C\uDFFF\u2640\uFE0F":"1f9d9-1f3ff-2640","\uD83E\uDDD9\uD83C\uDFFF\u200D\u2642":"1f9d9-1f3ff-2642","\uD83E\uDDD9\uD83C\uDFFF\u2642\uFE0F":"1f9d9-1f3ff-2642","\uD83E\uDDDA\uD83C\uDFFB\u200D\u2640":"1f9da-1f3fb-2640","\uD83E\uDDDA\uD83C\uDFFB\u2640\uFE0F":"1f9da-1f3fb-2640","\uD83E\uDDDA\uD83C\uDFFB\u200D\u2642":"1f9da-1f3fb-2642","\uD83E\uDDDA\uD83C\uDFFB\u2642\uFE0F":"1f9da-1f3fb-2642","\uD83E\uDDDA\uD83C\uDFFC\u200D\u2640":"1f9da-1f3fc-2640","\uD83E\uDDDA\uD83C\uDFFC\u2640\uFE0F":"1f9da-1f3fc-2640","\uD83E\uDDDA\uD83C\uDFFC\u200D\u2642":"1f9da-1f3fc-2642","\uD83E\uDDDA\uD83C\uDFFC\u2642\uFE0F":"1f9da-1f3fc-2642","\uD83E\uDDDA\uD83C\uDFFD\u200D\u2640":"1f9da-1f3fd-2640","\uD83E\uDDDA\uD83C\uDFFD\u2640\uFE0F":"1f9da-1f3fd-2640","\uD83E\uDDDA\uD83C\uDFFD\u200D\u2642":"1f9da-1f3fd-2642","\uD83E\uDDDA\uD83C\uDFFD\u2642\uFE0F":"1f9da-1f3fd-2642","\uD83E\uDDDA\uD83C\uDFFE\u200D\u2640":"1f9da-1f3fe-2640","\uD83E\uDDDA\uD83C\uDFFE\u2640\uFE0F":"1f9da-1f3fe-2640","\uD83E\uDDDA\uD83C\uDFFE\u200D\u2642":"1f9da-1f3fe-2642","\uD83E\uDDDA\uD83C\uDFFE\u2642\uFE0F":"1f9da-1f3fe-2642","\uD83E\uDDDA\uD83C\uDFFF\u200D\u2640":"1f9da-1f3ff-2640","\uD83E\uDDDA\uD83C\uDFFF\u2640\uFE0F":"1f9da-1f3ff-2640","\uD83E\uDDDA\uD83C\uDFFF\u200D\u2642":"1f9da-1f3ff-2642","\uD83E\uDDDA\uD83C\uDFFF\u2642\uFE0F":"1f9da-1f3ff-2642","\uD83E\uDDDB\uD83C\uDFFB\u200D\u2640":"1f9db-1f3fb-2640","\uD83E\uDDDB\uD83C\uDFFB\u2640\uFE0F":"1f9db-1f3fb-2640","\uD83E\uDDDB\uD83C\uDFFB\u200D\u2642":"1f9db-1f3fb-2642","\uD83E\uDDDB\uD83C\uDFFB\u2642\uFE0F":"1f9db-1f3fb-2642","\uD83E\uDDDB\uD83C\uDFFC\u200D\u2640":"1f9db-1f3fc-2640","\uD83E\uDDDB\uD83C\uDFFC\u2640\uFE0F":"1f9db-1f3fc-2640","\uD83E\uDDDB\uD83C\uDFFC\u200D\u2642":"1f9db-1f3fc-2642","\uD83E\uDDDB\uD83C\uDFFC\u2642\uFE0F":"1f9db-1f3fc-2642","\uD83E\uDDDB\uD83C\uDFFD\u200D\u2640":"1f9db-1f3fd-2640","\uD83E\uDDDB\uD83C\uDFFD\u2640\uFE0F":"1f9db-1f3fd-2640","\uD83E\uDDDB\uD83C\uDFFD\u200D\u2642":"1f9db-1f3fd-2642","\uD83E\uDDDB\uD83C\uDFFD\u2642\uFE0F":"1f9db-1f3fd-2642","\uD83E\uDDDB\uD83C\uDFFE\u200D\u2640":"1f9db-1f3fe-2640","\uD83E\uDDDB\uD83C\uDFFE\u2640\uFE0F":"1f9db-1f3fe-2640","\uD83E\uDDDB\uD83C\uDFFE\u200D\u2642":"1f9db-1f3fe-2642","\uD83E\uDDDB\uD83C\uDFFE\u2642\uFE0F":"1f9db-1f3fe-2642","\uD83E\uDDDB\uD83C\uDFFF\u200D\u2640":"1f9db-1f3ff-2640","\uD83E\uDDDB\uD83C\uDFFF\u2640\uFE0F":"1f9db-1f3ff-2640","\uD83E\uDDDB\uD83C\uDFFF\u200D\u2642":"1f9db-1f3ff-2642","\uD83E\uDDDB\uD83C\uDFFF\u2642\uFE0F":"1f9db-1f3ff-2642","\uD83E\uDDDC\uD83C\uDFFB\u200D\u2640":"1f9dc-1f3fb-2640","\uD83E\uDDDC\uD83C\uDFFB\u2640\uFE0F":"1f9dc-1f3fb-2640","\uD83E\uDDDC\uD83C\uDFFB\u200D\u2642":"1f9dc-1f3fb-2642","\uD83E\uDDDC\uD83C\uDFFB\u2642\uFE0F":"1f9dc-1f3fb-2642","\uD83E\uDDDC\uD83C\uDFFC\u200D\u2640":"1f9dc-1f3fc-2640","\uD83E\uDDDC\uD83C\uDFFC\u2640\uFE0F":"1f9dc-1f3fc-2640","\uD83E\uDDDC\uD83C\uDFFC\u200D\u2642":"1f9dc-1f3fc-2642","\uD83E\uDDDC\uD83C\uDFFC\u2642\uFE0F":"1f9dc-1f3fc-2642","\uD83E\uDDDC\uD83C\uDFFD\u200D\u2640":"1f9dc-1f3fd-2640","\uD83E\uDDDC\uD83C\uDFFD\u2640\uFE0F":"1f9dc-1f3fd-2640","\uD83E\uDDDC\uD83C\uDFFD\u200D\u2642":"1f9dc-1f3fd-2642","\uD83E\uDDDC\uD83C\uDFFD\u2642\uFE0F":"1f9dc-1f3fd-2642","\uD83E\uDDDC\uD83C\uDFFE\u200D\u2640":"1f9dc-1f3fe-2640","\uD83E\uDDDC\uD83C\uDFFE\u2640\uFE0F":"1f9dc-1f3fe-2640","\uD83E\uDDDC\uD83C\uDFFE\u200D\u2642":"1f9dc-1f3fe-2642","\uD83E\uDDDC\uD83C\uDFFE\u2642\uFE0F":"1f9dc-1f3fe-2642","\uD83E\uDDDC\uD83C\uDFFF\u200D\u2640":"1f9dc-1f3ff-2640","\uD83E\uDDDC\uD83C\uDFFF\u2640\uFE0F":"1f9dc-1f3ff-2640","\uD83E\uDDDC\uD83C\uDFFF\u200D\u2642":"1f9dc-1f3ff-2642","\uD83E\uDDDC\uD83C\uDFFF\u2642\uFE0F":"1f9dc-1f3ff-2642","\uD83E\uDDDD\uD83C\uDFFB\u200D\u2640":"1f9dd-1f3fb-2640","\uD83E\uDDDD\uD83C\uDFFB\u2640\uFE0F":"1f9dd-1f3fb-2640","\uD83E\uDDDD\uD83C\uDFFB\u200D\u2642":"1f9dd-1f3fb-2642","\uD83E\uDDDD\uD83C\uDFFB\u2642\uFE0F":"1f9dd-1f3fb-2642","\uD83E\uDDDD\uD83C\uDFFC\u200D\u2640":"1f9dd-1f3fc-2640","\uD83E\uDDDD\uD83C\uDFFC\u2640\uFE0F":"1f9dd-1f3fc-2640","\uD83E\uDDDD\uD83C\uDFFC\u200D\u2642":"1f9dd-1f3fc-2642","\uD83E\uDDDD\uD83C\uDFFC\u2642\uFE0F":"1f9dd-1f3fc-2642","\uD83E\uDDDD\uD83C\uDFFD\u200D\u2640":"1f9dd-1f3fd-2640","\uD83E\uDDDD\uD83C\uDFFD\u2640\uFE0F":"1f9dd-1f3fd-2640","\uD83E\uDDDD\uD83C\uDFFD\u200D\u2642":"1f9dd-1f3fd-2642","\uD83E\uDDDD\uD83C\uDFFD\u2642\uFE0F":"1f9dd-1f3fd-2642","\uD83E\uDDDD\uD83C\uDFFE\u200D\u2640":"1f9dd-1f3fe-2640","\uD83E\uDDDD\uD83C\uDFFE\u2640\uFE0F":"1f9dd-1f3fe-2640","\uD83E\uDDDD\uD83C\uDFFE\u200D\u2642":"1f9dd-1f3fe-2642","\uD83E\uDDDD\uD83C\uDFFE\u2642\uFE0F":"1f9dd-1f3fe-2642","\uD83E\uDDDD\uD83C\uDFFF\u200D\u2640":"1f9dd-1f3ff-2640","\uD83E\uDDDD\uD83C\uDFFF\u2640\uFE0F":"1f9dd-1f3ff-2640","\uD83E\uDDDD\uD83C\uDFFF\u200D\u2642":"1f9dd-1f3ff-2642","\uD83E\uDDDD\uD83C\uDFFF\u2642\uFE0F":"1f9dd-1f3ff-2642","\uD83E\uDDD6\uD83C\uDFFB\u200D\u2640":"1f9d6-1f3fb-2640","\uD83E\uDDD6\uD83C\uDFFB\u2640\uFE0F":"1f9d6-1f3fb-2640","\uD83E\uDDD6\uD83C\uDFFB\u200D\u2642":"1f9d6-1f3fb-2642","\uD83E\uDDD6\uD83C\uDFFB\u2642\uFE0F":"1f9d6-1f3fb-2642","\uD83E\uDDD6\uD83C\uDFFC\u200D\u2640":"1f9d6-1f3fc-2640","\uD83E\uDDD6\uD83C\uDFFC\u2640\uFE0F":"1f9d6-1f3fc-2640","\uD83E\uDDD6\uD83C\uDFFC\u200D\u2642":"1f9d6-1f3fc-2642","\uD83E\uDDD6\uD83C\uDFFC\u2642\uFE0F":"1f9d6-1f3fc-2642","\uD83E\uDDD6\uD83C\uDFFD\u200D\u2640":"1f9d6-1f3fd-2640","\uD83E\uDDD6\uD83C\uDFFD\u2640\uFE0F":"1f9d6-1f3fd-2640","\uD83E\uDDD6\uD83C\uDFFD\u200D\u2642":"1f9d6-1f3fd-2642","\uD83E\uDDD6\uD83C\uDFFD\u2642\uFE0F":"1f9d6-1f3fd-2642","\uD83E\uDDD6\uD83C\uDFFE\u200D\u2640":"1f9d6-1f3fe-2640","\uD83E\uDDD6\uD83C\uDFFE\u2640\uFE0F":"1f9d6-1f3fe-2640","\uD83E\uDDD6\uD83C\uDFFE\u200D\u2642":"1f9d6-1f3fe-2642","\uD83E\uDDD6\uD83C\uDFFE\u2642\uFE0F":"1f9d6-1f3fe-2642","\uD83E\uDDD6\uD83C\uDFFF\u200D\u2640":"1f9d6-1f3ff-2640","\uD83E\uDDD6\uD83C\uDFFF\u2640\uFE0F":"1f9d6-1f3ff-2640","\uD83E\uDDD6\uD83C\uDFFF\u200D\u2642":"1f9d6-1f3ff-2642","\uD83E\uDDD6\uD83C\uDFFF\u2642\uFE0F":"1f9d6-1f3ff-2642","\uD83E\uDDD7\uD83C\uDFFB\u200D\u2640":"1f9d7-1f3fb-2640","\uD83E\uDDD7\uD83C\uDFFB\u2640\uFE0F":"1f9d7-1f3fb-2640","\uD83E\uDDD7\uD83C\uDFFB\u200D\u2642":"1f9d7-1f3fb-2642","\uD83E\uDDD7\uD83C\uDFFB\u2642\uFE0F":"1f9d7-1f3fb-2642","\uD83E\uDDD7\uD83C\uDFFC\u200D\u2640":"1f9d7-1f3fc-2640","\uD83E\uDDD7\uD83C\uDFFC\u2640\uFE0F":"1f9d7-1f3fc-2640","\uD83E\uDDD7\uD83C\uDFFC\u200D\u2642":"1f9d7-1f3fc-2642","\uD83E\uDDD7\uD83C\uDFFC\u2642\uFE0F":"1f9d7-1f3fc-2642","\uD83E\uDDD7\uD83C\uDFFD\u200D\u2640":"1f9d7-1f3fd-2640","\uD83E\uDDD7\uD83C\uDFFD\u2640\uFE0F":"1f9d7-1f3fd-2640","\uD83E\uDDD7\uD83C\uDFFD\u200D\u2642":"1f9d7-1f3fd-2642","\uD83E\uDDD7\uD83C\uDFFD\u2642\uFE0F":"1f9d7-1f3fd-2642","\uD83E\uDDD7\uD83C\uDFFE\u200D\u2640":"1f9d7-1f3fe-2640","\uD83E\uDDD7\uD83C\uDFFE\u2640\uFE0F":"1f9d7-1f3fe-2640","\uD83E\uDDD7\uD83C\uDFFE\u200D\u2642":"1f9d7-1f3fe-2642","\uD83E\uDDD7\uD83C\uDFFE\u2642\uFE0F":"1f9d7-1f3fe-2642","\uD83E\uDDD7\uD83C\uDFFF\u200D\u2640":"1f9d7-1f3ff-2640","\uD83E\uDDD7\uD83C\uDFFF\u2640\uFE0F":"1f9d7-1f3ff-2640","\uD83E\uDDD7\uD83C\uDFFF\u200D\u2642":"1f9d7-1f3ff-2642","\uD83E\uDDD7\uD83C\uDFFF\u2642\uFE0F":"1f9d7-1f3ff-2642","\uD83E\uDDD8\uD83C\uDFFB\u200D\u2640":"1f9d8-1f3fb-2640","\uD83E\uDDD8\uD83C\uDFFB\u2640\uFE0F":"1f9d8-1f3fb-2640","\uD83E\uDDD8\uD83C\uDFFB\u200D\u2642":"1f9d8-1f3fb-2642","\uD83E\uDDD8\uD83C\uDFFB\u2642\uFE0F":"1f9d8-1f3fb-2642","\uD83E\uDDD8\uD83C\uDFFC\u200D\u2640":"1f9d8-1f3fc-2640","\uD83E\uDDD8\uD83C\uDFFC\u2640\uFE0F":"1f9d8-1f3fc-2640","\uD83E\uDDD8\uD83C\uDFFC\u200D\u2642":"1f9d8-1f3fc-2642","\uD83E\uDDD8\uD83C\uDFFC\u2642\uFE0F":"1f9d8-1f3fc-2642","\uD83E\uDDD8\uD83C\uDFFD\u200D\u2640":"1f9d8-1f3fd-2640","\uD83E\uDDD8\uD83C\uDFFD\u2640\uFE0F":"1f9d8-1f3fd-2640","\uD83E\uDDD8\uD83C\uDFFD\u200D\u2642":"1f9d8-1f3fd-2642","\uD83E\uDDD8\uD83C\uDFFD\u2642\uFE0F":"1f9d8-1f3fd-2642","\uD83E\uDDD8\uD83C\uDFFE\u200D\u2640":"1f9d8-1f3fe-2640","\uD83E\uDDD8\uD83C\uDFFE\u2640\uFE0F":"1f9d8-1f3fe-2640","\uD83E\uDDD8\uD83C\uDFFE\u200D\u2642":"1f9d8-1f3fe-2642","\uD83E\uDDD8\uD83C\uDFFE\u2642\uFE0F":"1f9d8-1f3fe-2642","\uD83E\uDDD8\uD83C\uDFFF\u200D\u2640":"1f9d8-1f3ff-2640","\uD83E\uDDD8\uD83C\uDFFF\u2640\uFE0F":"1f9d8-1f3ff-2640","\uD83E\uDDD8\uD83C\uDFFF\u200D\u2642":"1f9d8-1f3ff-2642","\uD83E\uDDD8\uD83C\uDFFF\u2642\uFE0F":"1f9d8-1f3ff-2642","\uD83D\uDC41\u200D\uD83D\uDDE8\uFE0F":"1f441-1f5e8","\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8":"1f441-1f5e8","\u26F9\uD83C\uDFFF\u200D\u2642":"26f9-1f3ff-2642","\u26F9\uD83C\uDFFE\u200D\u2642":"26f9-1f3fe-2642","\u26F9\uD83C\uDFFD\u200D\u2642":"26f9-1f3fd-2642","\u26F9\uD83C\uDFFC\u200D\u2642":"26f9-1f3fc-2642","\u26F9\uD83C\uDFFB\u200D\u2642":"26f9-1f3fb-2642","\u26F9\uD83C\uDFFF\u200D\u2640":"26f9-1f3ff-2640","\u26F9\uD83C\uDFFE\u200D\u2640":"26f9-1f3fe-2640","\u26F9\uD83C\uDFFD\u200D\u2640":"26f9-1f3fd-2640","\u26F9\uD83C\uDFFC\u200D\u2640":"26f9-1f3fc-2640","\u26F9\uD83C\uDFFB\u200D\u2640":"26f9-1f3fb-2640","\uD83D\uDC68\u200D\u2695\uFE0F":"1f468-2695","\uD83D\uDC68\u200D\u2696\uFE0F":"1f468-2696","\uD83D\uDC68\u200D\u2708\uFE0F":"1f468-2708","\uD83D\uDC69\u200D\u2695\uFE0F":"1f469-2695","\uD83D\uDC69\u200D\u2696\uFE0F":"1f469-2696","\uD83D\uDC69\u200D\u2708\uFE0F":"1f469-2708","\uD83D\uDC6E\u200D\u2640\uFE0F":"1f46e-2640","\uD83D\uDC6E\u200D\u2642\uFE0F":"1f46e-2642","\uD83D\uDC71\u200D\u2640\uFE0F":"1f471-2640","\uD83D\uDC71\u200D\u2642\uFE0F":"1f471-2642","\uD83D\uDC73\u200D\u2640\uFE0F":"1f473-2640","\uD83D\uDC73\u200D\u2642\uFE0F":"1f473-2642","\uD83D\uDC77\u200D\u2640\uFE0F":"1f477-2640","\uD83D\uDC77\u200D\u2642\uFE0F":"1f477-2642","\uD83D\uDC82\u200D\u2640\uFE0F":"1f482-2640","\uD83D\uDC82\u200D\u2642\uFE0F":"1f482-2642","\uD83D\uDD75\uFE0F\u2640\uFE0F":"1f575-2640","\uD83D\uDD75\uFE0F\u2642\uFE0F":"1f575-2642","\uD83C\uDFC3\u200D\u2640\uFE0F":"1f3c3-2640","\uD83C\uDFC3\u200D\u2642\uFE0F":"1f3c3-2642","\uD83C\uDFC4\u200D\u2640\uFE0F":"1f3c4-2640","\uD83C\uDFC4\u200D\u2642\uFE0F":"1f3c4-2642","\uD83C\uDFCA\u200D\u2640\uFE0F":"1f3ca-2640","\uD83C\uDFCA\u200D\u2642\uFE0F":"1f3ca-2642","\uD83C\uDFCB\uFE0F\u2640\uFE0F":"1f3cb-2640","\uD83C\uDFCB\uFE0F\u2642\uFE0F":"1f3cb-2642","\uD83C\uDFCC\uFE0F\u2640\uFE0F":"1f3cc-2640","\uD83C\uDFCC\uFE0F\u2642\uFE0F":"1f3cc-2642","\uD83D\uDC6F\u200D\u2640\uFE0F":"1f46f-2640","\uD83D\uDC6F\u200D\u2642\uFE0F":"1f46f-2642","\uD83D\uDC86\u200D\u2640\uFE0F":"1f486-2640","\uD83D\uDC86\u200D\u2642\uFE0F":"1f486-2642","\uD83D\uDC87\u200D\u2640\uFE0F":"1f487-2640","\uD83D\uDC87\u200D\u2642\uFE0F":"1f487-2642","\uD83D\uDEA3\u200D\u2640\uFE0F":"1f6a3-2640","\uD83D\uDEA3\u200D\u2642\uFE0F":"1f6a3-2642","\uD83D\uDEB4\u200D\u2640\uFE0F":"1f6b4-2640","\uD83D\uDEB4\u200D\u2642\uFE0F":"1f6b4-2642","\uD83D\uDEB5\u200D\u2640\uFE0F":"1f6b5-2640","\uD83D\uDEB5\u200D\u2642\uFE0F":"1f6b5-2642","\uD83D\uDEB6\u200D\u2640\uFE0F":"1f6b6-2640","\uD83D\uDEB6\u200D\u2642\uFE0F":"1f6b6-2642","\uD83E\uDD38\u200D\u2640\uFE0F":"1f938-2640","\uD83E\uDD38\u200D\u2642\uFE0F":"1f938-2642","\uD83E\uDD39\u200D\u2640\uFE0F":"1f939-2640","\uD83E\uDD39\u200D\u2642\uFE0F":"1f939-2642","\uD83E\uDD3C\u200D\u2640\uFE0F":"1f93c-2640","\uD83E\uDD3C\u200D\u2642\uFE0F":"1f93c-2642","\uD83E\uDD3D\u200D\u2640\uFE0F":"1f93d-2640","\uD83E\uDD3D\u200D\u2642\uFE0F":"1f93d-2642","\uD83E\uDD3E\u200D\u2640\uFE0F":"1f93e-2640","\uD83E\uDD3E\u200D\u2642\uFE0F":"1f93e-2642","\uD83D\uDC81\u200D\u2640\uFE0F":"1f481-2640","\uD83D\uDC81\u200D\u2642\uFE0F":"1f481-2642","\uD83D\uDE45\u200D\u2640\uFE0F":"1f645-2640","\uD83D\uDE45\u200D\u2642\uFE0F":"1f645-2642","\uD83D\uDE46\u200D\u2640\uFE0F":"1f646-2640","\uD83D\uDE46\u200D\u2642\uFE0F":"1f646-2642","\uD83D\uDE47\u200D\u2640\uFE0F":"1f647-2640","\uD83D\uDE47\u200D\u2642\uFE0F":"1f647-2642","\uD83D\uDE4B\u200D\u2640\uFE0F":"1f64b-2640","\uD83D\uDE4B\u200D\u2642\uFE0F":"1f64b-2642","\uD83D\uDE4D\u200D\u2640\uFE0F":"1f64d-2640","\uD83D\uDE4D\u200D\u2642\uFE0F":"1f64d-2642","\uD83D\uDE4E\u200D\u2640\uFE0F":"1f64e-2640","\uD83D\uDE4E\u200D\u2642\uFE0F":"1f64e-2642","\uD83E\uDD26\u200D\u2640\uFE0F":"1f926-2640","\uD83E\uDD26\u200D\u2642\uFE0F":"1f926-2642","\uD83E\uDD37\u200D\u2640\uFE0F":"1f937-2640","\uD83E\uDD37\u200D\u2642\uFE0F":"1f937-2642","\uD83E\uDDD9\u200D\u2640\uFE0F":"1f9d9-2640","\uD83E\uDDD9\u200D\u2642\uFE0F":"1f9d9-2642","\uD83E\uDDDA\u200D\u2640\uFE0F":"1f9da-2640","\uD83E\uDDDA\u200D\u2642\uFE0F":"1f9da-2642","\uD83E\uDDDB\u200D\u2640\uFE0F":"1f9db-2640","\uD83E\uDDDB\u200D\u2642\uFE0F":"1f9db-2642","\uD83E\uDDDC\u200D\u2640\uFE0F":"1f9dc-2640","\uD83E\uDDDC\u200D\u2642\uFE0F":"1f9dc-2642","\uD83E\uDDDD\u200D\u2640\uFE0F":"1f9dd-2640","\uD83E\uDDDD\u200D\u2642\uFE0F":"1f9dd-2642","\uD83E\uDDDE\u200D\u2640\uFE0F":"1f9de-2640","\uD83E\uDDDE\u200D\u2642\uFE0F":"1f9de-2642","\uD83E\uDDDF\u200D\u2640\uFE0F":"1f9df-2640","\uD83E\uDDDF\u200D\u2642\uFE0F":"1f9df-2642","\uD83E\uDDD6\u200D\u2640\uFE0F":"1f9d6-2640","\uD83E\uDDD6\u200D\u2642\uFE0F":"1f9d6-2642","\uD83E\uDDD7\u200D\u2640\uFE0F":"1f9d7-2640","\uD83E\uDDD7\u200D\u2642\uFE0F":"1f9d7-2642","\uD83E\uDDD8\u200D\u2640\uFE0F":"1f9d8-2640","\uD83E\uDDD8\u200D\u2642\uFE0F":"1f9d8-2642","\uD83D\uDD75\u200D\u2640\uFE0F":"1f575-2640","\uD83D\uDD75\uFE0F\u200D\u2640":"1f575-2640","\uD83D\uDD75\u200D\u2642\uFE0F":"1f575-2642","\uD83D\uDD75\uFE0F\u200D\u2642":"1f575-2642","\uD83C\uDFCB\u200D\u2640\uFE0F":"1f3cb-2640","\uD83C\uDFCB\uFE0F\u200D\u2640":"1f3cb-2640","\uD83C\uDFCB\u200D\u2642\uFE0F":"1f3cb-2642","\uD83C\uDFCB\uFE0F\u200D\u2642":"1f3cb-2642","\uD83C\uDFCC\u200D\u2640\uFE0F":"1f3cc-2640","\uD83C\uDFCC\uFE0F\u200D\u2640":"1f3cc-2640","\uD83C\uDFCC\u200D\u2642\uFE0F":"1f3cc-2642","\uD83C\uDFCC\uFE0F\u200D\u2642":"1f3cc-2642","\u26F9\uFE0F\u2640\uFE0F":"26f9-2640","\u26F9\uFE0F\u2642\uFE0F":"26f9-2642","\u26F9\u200D\u2640\uFE0F":"26f9-2640","\u26F9\uFE0F\u200D\u2640":"26f9-2640","\u26F9\u200D\u2642\uFE0F":"26f9-2642","\u26F9\uFE0F\u200D\u2642":"26f9-2642","\uD83D\uDC68\uD83D\uDC68\uD83D\uDC66":"1f468-1f468-1f466","\uD83D\uDC68\uD83D\uDC68\uD83D\uDC67":"1f468-1f468-1f467","\uD83D\uDC68\uD83D\uDC69\uD83D\uDC67":"1f468-1f469-1f467","\uD83D\uDC69\uD83D\uDC69\uD83D\uDC66":"1f469-1f469-1f466","\uD83D\uDC69\uD83D\uDC69\uD83D\uDC67":"1f469-1f469-1f467","\uD83D\uDC68\uD83D\uDC66\uD83D\uDC66":"1f468-1f466-1f466","\uD83D\uDC68\uD83D\uDC67\uD83D\uDC66":"1f468-1f467-1f466","\uD83D\uDC69\uD83D\uDC66\uD83D\uDC66":"1f469-1f466-1f466","\uD83D\uDC69\uD83D\uDC67\uD83D\uDC66":"1f469-1f467-1f466","\uD83D\uDC69\uD83D\uDC67\uD83D\uDC67":"1f469-1f467-1f467","\uD83D\uDC68\uD83C\uDFFB\uD83C\uDFA8":"1f468-1f3fb-1f3a8","\uD83D\uDC68\uD83C\uDFFC\uD83C\uDFA8":"1f468-1f3fc-1f3a8","\uD83D\uDC68\uD83C\uDFFD\uD83C\uDFA8":"1f468-1f3fd-1f3a8","\uD83D\uDC68\uD83C\uDFFE\uD83C\uDFA8":"1f468-1f3fe-1f3a8","\uD83D\uDC68\uD83C\uDFFF\uD83C\uDFA8":"1f468-1f3ff-1f3a8","\uD83D\uDC69\uD83C\uDFFB\uD83C\uDFA8":"1f469-1f3fb-1f3a8","\uD83D\uDC69\uD83C\uDFFC\uD83C\uDFA8":"1f469-1f3fc-1f3a8","\uD83D\uDC69\uD83C\uDFFD\uD83C\uDFA8":"1f469-1f3fd-1f3a8","\uD83D\uDC69\uD83C\uDFFE\uD83C\uDFA8":"1f469-1f3fe-1f3a8","\uD83D\uDC69\uD83C\uDFFF\uD83C\uDFA8":"1f469-1f3ff-1f3a8","\uD83D\uDC68\uD83C\uDFFB\uD83D\uDE80":"1f468-1f3fb-1f680","\uD83D\uDC68\uD83C\uDFFC\uD83D\uDE80":"1f468-1f3fc-1f680","\uD83D\uDC68\uD83C\uDFFD\uD83D\uDE80":"1f468-1f3fd-1f680","\uD83D\uDC68\uD83C\uDFFE\uD83D\uDE80":"1f468-1f3fe-1f680","\uD83D\uDC68\uD83C\uDFFF\uD83D\uDE80":"1f468-1f3ff-1f680","\uD83D\uDC69\uD83C\uDFFB\uD83D\uDE80":"1f469-1f3fb-1f680","\uD83D\uDC69\uD83C\uDFFC\uD83D\uDE80":"1f469-1f3fc-1f680","\uD83D\uDC69\uD83C\uDFFD\uD83D\uDE80":"1f469-1f3fd-1f680","\uD83D\uDC69\uD83C\uDFFE\uD83D\uDE80":"1f469-1f3fe-1f680","\uD83D\uDC69\uD83C\uDFFF\uD83D\uDE80":"1f469-1f3ff-1f680","\uD83D\uDC68\uD83C\uDFFB\uD83D\uDE92":"1f468-1f3fb-1f692","\uD83D\uDC68\uD83C\uDFFC\uD83D\uDE92":"1f468-1f3fc-1f692","\uD83D\uDC68\uD83C\uDFFD\uD83D\uDE92":"1f468-1f3fd-1f692","\uD83D\uDC68\uD83C\uDFFE\uD83D\uDE92":"1f468-1f3fe-1f692","\uD83D\uDC68\uD83C\uDFFF\uD83D\uDE92":"1f468-1f3ff-1f692","\uD83D\uDC69\uD83C\uDFFB\uD83D\uDE92":"1f469-1f3fb-1f692","\uD83D\uDC69\uD83C\uDFFC\uD83D\uDE92":"1f469-1f3fc-1f692","\uD83D\uDC69\uD83C\uDFFD\uD83D\uDE92":"1f469-1f3fd-1f692","\uD83D\uDC69\uD83C\uDFFE\uD83D\uDE92":"1f469-1f3fe-1f692","\uD83D\uDC69\uD83C\uDFFF\uD83D\uDE92":"1f469-1f3ff-1f692","\uD83D\uDC68\uD83D\uDC69\uD83D\uDC66":"1f468-1f469-1f466","\uD83D\uDC68\uD83D\uDC67\uD83D\uDC67":"1f468-1f467-1f467","\uD83D\uDC68\uD83C\uDFFB\uD83C\uDF3E":"1f468-1f3fb-1f33e","\uD83D\uDC68\uD83C\uDFFB\uD83C\uDF73":"1f468-1f3fb-1f373","\uD83D\uDC68\uD83C\uDFFB\uD83C\uDF93":"1f468-1f3fb-1f393","\uD83D\uDC68\uD83C\uDFFB\uD83C\uDFA4":"1f468-1f3fb-1f3a4","\uD83D\uDC68\uD83C\uDFFB\uD83C\uDFEB":"1f468-1f3fb-1f3eb","\uD83D\uDC68\uD83C\uDFFB\uD83C\uDFED":"1f468-1f3fb-1f3ed","\uD83D\uDC68\uD83C\uDFFB\uD83D\uDCBB":"1f468-1f3fb-1f4bb","\uD83D\uDC68\uD83C\uDFFB\uD83D\uDCBC":"1f468-1f3fb-1f4bc","\uD83D\uDC68\uD83C\uDFFB\uD83D\uDD27":"1f468-1f3fb-1f527","\uD83D\uDC68\uD83C\uDFFB\uD83D\uDD2C":"1f468-1f3fb-1f52c","\uD83D\uDC68\uD83C\uDFFC\uD83C\uDF3E":"1f468-1f3fc-1f33e","\uD83D\uDC68\uD83C\uDFFC\uD83C\uDF73":"1f468-1f3fc-1f373","\uD83D\uDC68\uD83C\uDFFC\uD83C\uDF93":"1f468-1f3fc-1f393","\uD83D\uDC68\uD83C\uDFFC\uD83C\uDFA4":"1f468-1f3fc-1f3a4","\uD83D\uDC68\uD83C\uDFFC\uD83C\uDFEB":"1f468-1f3fc-1f3eb","\uD83D\uDC68\uD83C\uDFFC\uD83C\uDFED":"1f468-1f3fc-1f3ed","\uD83D\uDC68\uD83C\uDFFC\uD83D\uDCBB":"1f468-1f3fc-1f4bb","\uD83D\uDC68\uD83C\uDFFC\uD83D\uDCBC":"1f468-1f3fc-1f4bc","\uD83D\uDC68\uD83C\uDFFC\uD83D\uDD27":"1f468-1f3fc-1f527","\uD83D\uDC68\uD83C\uDFFC\uD83D\uDD2C":"1f468-1f3fc-1f52c","\uD83D\uDC68\uD83C\uDFFD\uD83C\uDF3E":"1f468-1f3fd-1f33e","\uD83D\uDC68\uD83C\uDFFD\uD83C\uDF73":"1f468-1f3fd-1f373","\uD83D\uDC68\uD83C\uDFFD\uD83C\uDF93":"1f468-1f3fd-1f393","\uD83D\uDC68\uD83C\uDFFD\uD83C\uDFA4":"1f468-1f3fd-1f3a4","\uD83D\uDC68\uD83C\uDFFD\uD83C\uDFEB":"1f468-1f3fd-1f3eb","\uD83D\uDC68\uD83C\uDFFD\uD83C\uDFED":"1f468-1f3fd-1f3ed","\uD83D\uDC68\uD83C\uDFFD\uD83D\uDCBB":"1f468-1f3fd-1f4bb","\uD83D\uDC68\uD83C\uDFFD\uD83D\uDCBC":"1f468-1f3fd-1f4bc","\uD83D\uDC68\uD83C\uDFFD\uD83D\uDD27":"1f468-1f3fd-1f527","\uD83D\uDC68\uD83C\uDFFD\uD83D\uDD2C":"1f468-1f3fd-1f52c","\uD83D\uDC68\uD83C\uDFFE\uD83C\uDF3E":"1f468-1f3fe-1f33e","\uD83D\uDC68\uD83C\uDFFE\uD83C\uDF73":"1f468-1f3fe-1f373","\uD83D\uDC68\uD83C\uDFFE\uD83C\uDF93":"1f468-1f3fe-1f393","\uD83D\uDC68\uD83C\uDFFE\uD83C\uDFA4":"1f468-1f3fe-1f3a4","\uD83D\uDC68\uD83C\uDFFE\uD83C\uDFEB":"1f468-1f3fe-1f3eb","\uD83D\uDC68\uD83C\uDFFE\uD83C\uDFED":"1f468-1f3fe-1f3ed","\uD83D\uDC68\uD83C\uDFFE\uD83D\uDCBB":"1f468-1f3fe-1f4bb","\uD83D\uDC68\uD83C\uDFFE\uD83D\uDCBC":"1f468-1f3fe-1f4bc","\uD83D\uDC68\uD83C\uDFFE\uD83D\uDD27":"1f468-1f3fe-1f527","\uD83D\uDC68\uD83C\uDFFE\uD83D\uDD2C":"1f468-1f3fe-1f52c","\uD83D\uDC68\uD83C\uDFFF\uD83C\uDF3E":"1f468-1f3ff-1f33e","\uD83D\uDC68\uD83C\uDFFF\uD83C\uDF73":"1f468-1f3ff-1f373","\uD83D\uDC68\uD83C\uDFFF\uD83C\uDF93":"1f468-1f3ff-1f393","\uD83D\uDC68\uD83C\uDFFF\uD83C\uDFA4":"1f468-1f3ff-1f3a4","\uD83D\uDC68\uD83C\uDFFF\uD83C\uDFEB":"1f468-1f3ff-1f3eb","\uD83D\uDC68\uD83C\uDFFF\uD83C\uDFED":"1f468-1f3ff-1f3ed","\uD83D\uDC68\uD83C\uDFFF\uD83D\uDCBB":"1f468-1f3ff-1f4bb","\uD83D\uDC68\uD83C\uDFFF\uD83D\uDCBC":"1f468-1f3ff-1f4bc","\uD83D\uDC68\uD83C\uDFFF\uD83D\uDD27":"1f468-1f3ff-1f527","\uD83D\uDC68\uD83C\uDFFF\uD83D\uDD2C":"1f468-1f3ff-1f52c","\uD83D\uDC69\uD83C\uDFFB\uD83C\uDF3E":"1f469-1f3fb-1f33e","\uD83D\uDC69\uD83C\uDFFB\uD83C\uDF73":"1f469-1f3fb-1f373","\uD83D\uDC69\uD83C\uDFFB\uD83C\uDF93":"1f469-1f3fb-1f393","\uD83D\uDC69\uD83C\uDFFB\uD83C\uDFA4":"1f469-1f3fb-1f3a4","\uD83D\uDC69\uD83C\uDFFB\uD83C\uDFEB":"1f469-1f3fb-1f3eb","\uD83D\uDC69\uD83C\uDFFB\uD83C\uDFED":"1f469-1f3fb-1f3ed","\uD83D\uDC69\uD83C\uDFFB\uD83D\uDCBB":"1f469-1f3fb-1f4bb","\uD83D\uDC69\uD83C\uDFFB\uD83D\uDCBC":"1f469-1f3fb-1f4bc","\uD83D\uDC69\uD83C\uDFFB\uD83D\uDD27":"1f469-1f3fb-1f527","\uD83D\uDC69\uD83C\uDFFB\uD83D\uDD2C":"1f469-1f3fb-1f52c","\uD83D\uDC69\uD83C\uDFFC\uD83C\uDF3E":"1f469-1f3fc-1f33e","\uD83D\uDC69\uD83C\uDFFC\uD83C\uDF73":"1f469-1f3fc-1f373","\uD83D\uDC69\uD83C\uDFFC\uD83C\uDF93":"1f469-1f3fc-1f393","\uD83D\uDC69\uD83C\uDFFC\uD83C\uDFA4":"1f469-1f3fc-1f3a4","\uD83D\uDC69\uD83C\uDFFC\uD83C\uDFEB":"1f469-1f3fc-1f3eb","\uD83D\uDC69\uD83C\uDFFC\uD83C\uDFED":"1f469-1f3fc-1f3ed","\uD83D\uDC69\uD83C\uDFFC\uD83D\uDCBB":"1f469-1f3fc-1f4bb","\uD83D\uDC69\uD83C\uDFFC\uD83D\uDCBC":"1f469-1f3fc-1f4bc","\uD83D\uDC69\uD83C\uDFFC\uD83D\uDD27":"1f469-1f3fc-1f527","\uD83D\uDC69\uD83C\uDFFC\uD83D\uDD2C":"1f469-1f3fc-1f52c","\uD83D\uDC69\uD83C\uDFFD\uD83C\uDF3E":"1f469-1f3fd-1f33e","\uD83D\uDC69\uD83C\uDFFD\uD83C\uDF73":"1f469-1f3fd-1f373","\uD83D\uDC69\uD83C\uDFFD\uD83C\uDF93":"1f469-1f3fd-1f393","\uD83D\uDC69\uD83C\uDFFD\uD83C\uDFA4":"1f469-1f3fd-1f3a4","\uD83D\uDC69\uD83C\uDFFD\uD83C\uDFEB":"1f469-1f3fd-1f3eb","\uD83D\uDC69\uD83C\uDFFD\uD83C\uDFED":"1f469-1f3fd-1f3ed","\uD83D\uDC69\uD83C\uDFFD\uD83D\uDCBB":"1f469-1f3fd-1f4bb","\uD83D\uDC69\uD83C\uDFFD\uD83D\uDCBC":"1f469-1f3fd-1f4bc","\uD83D\uDC69\uD83C\uDFFD\uD83D\uDD27":"1f469-1f3fd-1f527","\uD83D\uDC69\uD83C\uDFFD\uD83D\uDD2C":"1f469-1f3fd-1f52c","\uD83D\uDC69\uD83C\uDFFE\uD83C\uDF3E":"1f469-1f3fe-1f33e","\uD83D\uDC69\uD83C\uDFFE\uD83C\uDF73":"1f469-1f3fe-1f373","\uD83D\uDC69\uD83C\uDFFE\uD83C\uDF93":"1f469-1f3fe-1f393","\uD83D\uDC69\uD83C\uDFFE\uD83C\uDFA4":"1f469-1f3fe-1f3a4","\uD83D\uDC69\uD83C\uDFFE\uD83C\uDFEB":"1f469-1f3fe-1f3eb","\uD83D\uDC69\uD83C\uDFFE\uD83C\uDFED":"1f469-1f3fe-1f3ed","\uD83D\uDC69\uD83C\uDFFE\uD83D\uDCBB":"1f469-1f3fe-1f4bb","\uD83D\uDC69\uD83C\uDFFE\uD83D\uDCBC":"1f469-1f3fe-1f4bc","\uD83D\uDC69\uD83C\uDFFE\uD83D\uDD27":"1f469-1f3fe-1f527","\uD83D\uDC69\uD83C\uDFFE\uD83D\uDD2C":"1f469-1f3fe-1f52c","\uD83D\uDC69\uD83C\uDFFF\uD83C\uDF3E":"1f469-1f3ff-1f33e","\uD83D\uDC69\uD83C\uDFFF\uD83C\uDF73":"1f469-1f3ff-1f373","\uD83D\uDC69\uD83C\uDFFF\uD83C\uDF93":"1f469-1f3ff-1f393","\uD83D\uDC69\uD83C\uDFFF\uD83C\uDFA4":"1f469-1f3ff-1f3a4","\uD83D\uDC69\uD83C\uDFFF\uD83C\uDFEB":"1f469-1f3ff-1f3eb","\uD83D\uDC69\uD83C\uDFFF\uD83C\uDFED":"1f469-1f3ff-1f3ed","\uD83D\uDC69\uD83C\uDFFF\uD83D\uDCBB":"1f469-1f3ff-1f4bb","\uD83D\uDC69\uD83C\uDFFF\uD83D\uDCBC":"1f469-1f3ff-1f4bc","\uD83D\uDC69\uD83C\uDFFF\uD83D\uDD27":"1f469-1f3ff-1f527","\uD83D\uDC69\uD83C\uDFFF\uD83D\uDD2C":"1f469-1f3ff-1f52c","\uD83D\uDC41\u200D\uD83D\uDDE8":"1f441-1f5e8","\uD83D\uDC68\u200D\uD83D\uDCBB":"1f468-1f4bb","\uD83D\uDC69\u200D\uD83D\uDCBB":"1f469-1f4bb","\uD83D\uDC68\u200D\uD83C\uDFEB":"1f468-1f3eb","\uD83D\uDC69\u200D\uD83C\uDFEB":"1f469-1f3eb","\uD83D\uDC68\u200D\uD83C\uDF93":"1f468-1f393","\uD83D\uDC69\u200D\uD83C\uDF93":"1f469-1f393","\uD83D\uDC68\u200D\uD83C\uDFA4":"1f468-1f3a4","\uD83D\uDC69\u200D\uD83C\uDFA4":"1f469-1f3a4","\uD83D\uDC68\u200D\uD83D\uDD2C":"1f468-1f52c","\uD83D\uDC69\u200D\uD83D\uDD2C":"1f469-1f52c","\uD83D\uDC68\u200D\uD83D\uDCBC":"1f468-1f4bc","\uD83D\uDC69\u200D\uD83D\uDCBC":"1f469-1f4bc","\uD83D\uDC68\u200D\uD83D\uDD27":"1f468-1f527","\uD83D\uDC69\u200D\uD83D\uDD27":"1f469-1f527","\uD83D\uDC68\u200D\uD83C\uDFED":"1f468-1f3ed","\uD83D\uDC69\u200D\uD83C\uDFED":"1f469-1f3ed","\uD83D\uDC68\u200D\uD83C\uDF73":"1f468-1f373","\uD83D\uDC69\u200D\uD83C\uDF73":"1f469-1f373","\uD83D\uDC68\u200D\uD83C\uDF3E":"1f468-1f33e","\uD83D\uDC69\u200D\uD83C\uDF3E":"1f469-1f33e","\uD83D\uDC68\u200D\uD83D\uDC66":"1f468-1f466","\uD83D\uDC68\u200D\uD83D\uDC67":"1f468-1f467","\uD83D\uDC69\u200D\uD83D\uDC66":"1f469-1f466","\uD83D\uDC69\u200D\uD83D\uDC67":"1f469-1f467","\uD83D\uDC68\u200D\uD83C\uDFA8":"1f468-1f3a8","\uD83D\uDC69\u200D\uD83C\uDFA8":"1f469-1f3a8","\uD83D\uDC68\u200D\uD83D\uDE80":"1f468-1f680","\uD83D\uDC69\u200D\uD83D\uDE80":"1f469-1f680","\uD83D\uDC68\u200D\uD83D\uDE92":"1f468-1f692","\uD83D\uDC69\u200D\uD83D\uDE92":"1f469-1f692","\uD83C\uDFCB\uFE0F\uD83C\uDFFB":"1f3cb-1f3fb","\uD83C\uDFCB\uFE0F\uD83C\uDFFC":"1f3cb-1f3fc","\uD83C\uDFCB\uFE0F\uD83C\uDFFD":"1f3cb-1f3fd","\uD83C\uDFCB\uFE0F\uD83C\uDFFE":"1f3cb-1f3fe","\uD83C\uDFCB\uFE0F\uD83C\uDFFF":"1f3cb-1f3ff","\uD83C\uDFCC\uFE0F\uD83C\uDFFB":"1f3cc-1f3fb","\uD83C\uDFCC\uFE0F\uD83C\uDFFC":"1f3cc-1f3fc","\uD83C\uDFCC\uFE0F\uD83C\uDFFD":"1f3cc-1f3fd","\uD83C\uDFCC\uFE0F\uD83C\uDFFE":"1f3cc-1f3fe","\uD83C\uDFCC\uFE0F\uD83C\uDFFF":"1f3cc-1f3ff","\uD83D\uDD74\uFE0F\uD83C\uDFFB":"1f574-1f3fb","\uD83D\uDD74\uFE0F\uD83C\uDFFC":"1f574-1f3fc","\uD83D\uDD74\uFE0F\uD83C\uDFFD":"1f574-1f3fd","\uD83D\uDD74\uFE0F\uD83C\uDFFE":"1f574-1f3fe","\uD83D\uDD74\uFE0F\uD83C\uDFFF":"1f574-1f3ff","\uD83D\uDD75\uFE0F\uD83C\uDFFB":"1f575-1f3fb","\uD83D\uDD75\uFE0F\uD83C\uDFFC":"1f575-1f3fc","\uD83D\uDD75\uFE0F\uD83C\uDFFD":"1f575-1f3fd","\uD83D\uDD75\uFE0F\uD83C\uDFFE":"1f575-1f3fe","\uD83D\uDD75\uFE0F\uD83C\uDFFF":"1f575-1f3ff","\uD83D\uDD90\uFE0F\uD83C\uDFFB":"1f590-1f3fb","\uD83D\uDD90\uFE0F\uD83C\uDFFC":"1f590-1f3fc","\uD83D\uDD90\uFE0F\uD83C\uDFFD":"1f590-1f3fd","\uD83D\uDD90\uFE0F\uD83C\uDFFE":"1f590-1f3fe","\uD83D\uDD90\uFE0F\uD83C\uDFFF":"1f590-1f3ff","\uD83C\uDFF3\u200D\uD83C\uDF08":"1f3f3-1f308","\uD83C\uDFF3\uFE0F\uD83C\uDF08":"1f3f3-1f308","\uD83D\uDC6F\u200D\u2642":"1f46f-2642","\uD83D\uDC6F\u200D\u2640":"1f46f-2640","\uD83E\uDD3C\u200D\u2642":"1f93c-2642","\uD83E\uDD3C\u200D\u2640":"1f93c-2640","\uD83E\uDD39\u200D\u2642":"1f939-2642","\uD83E\uDD39\u200D\u2640":"1f939-2640","\uD83E\uDD3E\u200D\u2642":"1f93e-2642","\uD83E\uDD3E\u200D\u2640":"1f93e-2640","\uD83E\uDD3D\u200D\u2642":"1f93d-2642","\uD83E\uDD3D\u200D\u2640":"1f93d-2640","\uD83E\uDD38\u200D\u2642":"1f938-2642","\uD83E\uDD38\u200D\u2640":"1f938-2640","\uD83D\uDEB6\u200D\u2642":"1f6b6-2642","\uD83D\uDEB6\u200D\u2640":"1f6b6-2640","\uD83D\uDEB5\u200D\u2642":"1f6b5-2642","\uD83D\uDEB5\u200D\u2640":"1f6b5-2640","\uD83D\uDEB4\u200D\u2642":"1f6b4-2642","\uD83D\uDEB4\u200D\u2640":"1f6b4-2640","\uD83D\uDEA3\u200D\u2642":"1f6a3-2642","\uD83D\uDEA3\u200D\u2640":"1f6a3-2640","\uD83C\uDFCA\u200D\u2642":"1f3ca-2642","\uD83C\uDFCA\u200D\u2640":"1f3ca-2640","\uD83C\uDFC4\u200D\u2642":"1f3c4-2642","\uD83C\uDFC4\u200D\u2640":"1f3c4-2640","\uD83C\uDFC3\u200D\u2642":"1f3c3-2642","\uD83C\uDFC3\u200D\u2640":"1f3c3-2640","\uD83E\uDD37\u200D\u2642":"1f937-2642","\uD83E\uDD37\u200D\u2640":"1f937-2640","\uD83E\uDD26\u200D\u2642":"1f926-2642","\uD83E\uDD26\u200D\u2640":"1f926-2640","\uD83D\uDE4E\u200D\u2642":"1f64e-2642","\uD83D\uDE4E\u200D\u2640":"1f64e-2640","\uD83D\uDE4D\u200D\u2642":"1f64d-2642","\uD83D\uDE4D\u200D\u2640":"1f64d-2640","\uD83D\uDE4B\u200D\u2642":"1f64b-2642","\uD83D\uDE4B\u200D\u2640":"1f64b-2640","\uD83D\uDE47\u200D\u2642":"1f647-2642","\uD83D\uDE47\u200D\u2640":"1f647-2640","\uD83D\uDE46\u200D\u2642":"1f646-2642","\uD83D\uDE46\u200D\u2640":"1f646-2640","\uD83D\uDE45\u200D\u2642":"1f645-2642","\uD83D\uDE45\u200D\u2640":"1f645-2640","\uD83D\uDC87\u200D\u2642":"1f487-2642","\uD83D\uDC87\u200D\u2640":"1f487-2640","\uD83D\uDC86\u200D\u2642":"1f486-2642","\uD83D\uDC86\u200D\u2640":"1f486-2640","\uD83D\uDC81\u200D\u2642":"1f481-2642","\uD83D\uDC81\u200D\u2640":"1f481-2640","\uD83D\uDC71\u200D\u2642":"1f471-2642","\uD83D\uDC71\u200D\u2640":"1f471-2640","\uD83D\uDC73\u200D\u2642":"1f473-2642","\uD83D\uDC73\u200D\u2640":"1f473-2640","\uD83D\uDC82\u200D\u2642":"1f482-2642","\uD83D\uDC82\u200D\u2640":"1f482-2640","\uD83D\uDC77\u200D\u2642":"1f477-2642","\uD83D\uDC77\u200D\u2640":"1f477-2640","\uD83D\uDC6E\u200D\u2642":"1f46e-2642","\uD83D\uDC6E\u200D\u2640":"1f46e-2640","\uD83D\uDC68\u200D\u2695":"1f468-2695","\uD83D\uDC69\u200D\u2695":"1f469-2695","\uD83D\uDC68\u200D\u2696":"1f468-2696","\uD83D\uDC69\u200D\u2696":"1f469-2696","\uD83D\uDC68\u200D\u2708":"1f468-2708","\uD83D\uDC69\u200D\u2708":"1f469-2708","\u261D\uFE0F\uD83C\uDFFB":"261d-1f3fb","\u261D\uFE0F\uD83C\uDFFC":"261d-1f3fc","\u261D\uFE0F\uD83C\uDFFD":"261d-1f3fd","\u261D\uFE0F\uD83C\uDFFE":"261d-1f3fe","\u261D\uFE0F\uD83C\uDFFF":"261d-1f3ff","\u26F9\uFE0F\uD83C\uDFFB":"26f9-1f3fb","\u26F9\uFE0F\uD83C\uDFFC":"26f9-1f3fc","\u26F9\uFE0F\uD83C\uDFFD":"26f9-1f3fd","\u26F9\uFE0F\uD83C\uDFFE":"26f9-1f3fe","\u26F9\uFE0F\uD83C\uDFFF":"26f9-1f3ff","\u270C\uFE0F\uD83C\uDFFB":"270c-1f3fb","\u270C\uFE0F\uD83C\uDFFC":"270c-1f3fc","\u270C\uFE0F\uD83C\uDFFD":"270c-1f3fd","\u270C\uFE0F\uD83C\uDFFE":"270c-1f3fe","\u270C\uFE0F\uD83C\uDFFF":"270c-1f3ff","\u270D\uFE0F\uD83C\uDFFB":"270d-1f3fb","\u270D\uFE0F\uD83C\uDFFC":"270d-1f3fc","\u270D\uFE0F\uD83C\uDFFD":"270d-1f3fd","\u270D\uFE0F\uD83C\uDFFE":"270d-1f3fe","\u270D\uFE0F\uD83C\uDFFF":"270d-1f3ff","\uD83D\uDC68\u2695\uFE0F":"1f468-2695","\uD83D\uDC68\u2696\uFE0F":"1f468-2696","\uD83D\uDC68\u2708\uFE0F":"1f468-2708","\uD83D\uDC69\u2695\uFE0F":"1f469-2695","\uD83D\uDC69\u2696\uFE0F":"1f469-2696","\uD83D\uDC69\u2708\uFE0F":"1f469-2708","\uD83D\uDC6E\u2640\uFE0F":"1f46e-2640","\uD83D\uDC6E\u2642\uFE0F":"1f46e-2642","\uD83D\uDC71\u2640\uFE0F":"1f471-2640","\uD83D\uDC71\u2642\uFE0F":"1f471-2642","\uD83D\uDC73\u2640\uFE0F":"1f473-2640","\uD83D\uDC73\u2642\uFE0F":"1f473-2642","\uD83D\uDC77\u2640\uFE0F":"1f477-2640","\uD83D\uDC77\u2642\uFE0F":"1f477-2642","\uD83D\uDC82\u2640\uFE0F":"1f482-2640","\uD83D\uDC82\u2642\uFE0F":"1f482-2642","\uD83D\uDD75\u200D\u2640":"1f575-2640","\uD83D\uDD75\u200D\u2642":"1f575-2642","\uD83C\uDFC3\u2640\uFE0F":"1f3c3-2640","\uD83C\uDFC3\u2642\uFE0F":"1f3c3-2642","\uD83C\uDFC4\u2640\uFE0F":"1f3c4-2640","\uD83C\uDFC4\u2642\uFE0F":"1f3c4-2642","\uD83C\uDFCA\u2640\uFE0F":"1f3ca-2640","\uD83C\uDFCA\u2642\uFE0F":"1f3ca-2642","\uD83C\uDFCB\u200D\u2640":"1f3cb-2640","\uD83C\uDFCB\u200D\u2642":"1f3cb-2642","\uD83C\uDFCC\u200D\u2640":"1f3cc-2640","\uD83C\uDFCC\u200D\u2642":"1f3cc-2642","\uD83D\uDC6F\u2640\uFE0F":"1f46f-2640","\uD83D\uDC6F\u2642\uFE0F":"1f46f-2642","\uD83D\uDC86\u2640\uFE0F":"1f486-2640","\uD83D\uDC86\u2642\uFE0F":"1f486-2642","\uD83D\uDC87\u2640\uFE0F":"1f487-2640","\uD83D\uDC87\u2642\uFE0F":"1f487-2642","\uD83D\uDEA3\u2640\uFE0F":"1f6a3-2640","\uD83D\uDEA3\u2642\uFE0F":"1f6a3-2642","\uD83D\uDEB4\u2640\uFE0F":"1f6b4-2640","\uD83D\uDEB4\u2642\uFE0F":"1f6b4-2642","\uD83D\uDEB5\u2640\uFE0F":"1f6b5-2640","\uD83D\uDEB5\u2642\uFE0F":"1f6b5-2642","\uD83D\uDEB6\u2640\uFE0F":"1f6b6-2640","\uD83D\uDEB6\u2642\uFE0F":"1f6b6-2642","\uD83E\uDD38\u2640\uFE0F":"1f938-2640","\uD83E\uDD38\u2642\uFE0F":"1f938-2642","\uD83E\uDD39\u2640\uFE0F":"1f939-2640","\uD83E\uDD39\u2642\uFE0F":"1f939-2642","\uD83E\uDD3C\u2640\uFE0F":"1f93c-2640","\uD83E\uDD3C\u2642\uFE0F":"1f93c-2642","\uD83E\uDD3D\u2640\uFE0F":"1f93d-2640","\uD83E\uDD3D\u2642\uFE0F":"1f93d-2642","\uD83E\uDD3E\u2640\uFE0F":"1f93e-2640","\uD83E\uDD3E\u2642\uFE0F":"1f93e-2642","\uD83D\uDC81\u2640\uFE0F":"1f481-2640","\uD83D\uDC81\u2642\uFE0F":"1f481-2642","\uD83D\uDE45\u2640\uFE0F":"1f645-2640","\uD83D\uDE45\u2642\uFE0F":"1f645-2642","\uD83D\uDE46\u2640\uFE0F":"1f646-2640","\uD83D\uDE46\u2642\uFE0F":"1f646-2642","\uD83D\uDE47\u2640\uFE0F":"1f647-2640","\uD83D\uDE47\u2642\uFE0F":"1f647-2642","\uD83D\uDE4B\u2640\uFE0F":"1f64b-2640","\uD83D\uDE4B\u2642\uFE0F":"1f64b-2642","\uD83D\uDE4D\u2640\uFE0F":"1f64d-2640","\uD83D\uDE4D\u2642\uFE0F":"1f64d-2642","\uD83D\uDE4E\u2640\uFE0F":"1f64e-2640","\uD83D\uDE4E\u2642\uFE0F":"1f64e-2642","\uD83E\uDD26\u2640\uFE0F":"1f926-2640","\uD83E\uDD26\u2642\uFE0F":"1f926-2642","\uD83E\uDD37\u2640\uFE0F":"1f937-2640","\uD83E\uDD37\u2642\uFE0F":"1f937-2642","\uD83E\uDDD9\u200D\u2640":"1f9d9-2640","\uD83E\uDDD9\u2640\uFE0F":"1f9d9-2640","\uD83E\uDDD9\u200D\u2642":"1f9d9-2642","\uD83E\uDDD9\u2642\uFE0F":"1f9d9-2642","\uD83E\uDDDA\u200D\u2640":"1f9da-2640","\uD83E\uDDDA\u2640\uFE0F":"1f9da-2640","\uD83E\uDDDA\u200D\u2642":"1f9da-2642","\uD83E\uDDDA\u2642\uFE0F":"1f9da-2642","\uD83E\uDDDB\u200D\u2640":"1f9db-2640","\uD83E\uDDDB\u2640\uFE0F":"1f9db-2640","\uD83E\uDDDB\u200D\u2642":"1f9db-2642","\uD83E\uDDDB\u2642\uFE0F":"1f9db-2642","\uD83E\uDDDC\u200D\u2640":"1f9dc-2640","\uD83E\uDDDC\u2640\uFE0F":"1f9dc-2640","\uD83E\uDDDC\u200D\u2642":"1f9dc-2642","\uD83E\uDDDC\u2642\uFE0F":"1f9dc-2642","\uD83E\uDDDD\u200D\u2640":"1f9dd-2640","\uD83E\uDDDD\u2640\uFE0F":"1f9dd-2640","\uD83E\uDDDD\u200D\u2642":"1f9dd-2642","\uD83E\uDDDD\u2642\uFE0F":"1f9dd-2642","\uD83E\uDDDE\u200D\u2640":"1f9de-2640","\uD83E\uDDDE\u2640\uFE0F":"1f9de-2640","\uD83E\uDDDE\u200D\u2642":"1f9de-2642","\uD83E\uDDDE\u2642\uFE0F":"1f9de-2642","\uD83E\uDDDF\u200D\u2640":"1f9df-2640","\uD83E\uDDDF\u2640\uFE0F":"1f9df-2640","\uD83E\uDDDF\u200D\u2642":"1f9df-2642","\uD83E\uDDDF\u2642\uFE0F":"1f9df-2642","\uD83E\uDDD6\u200D\u2640":"1f9d6-2640","\uD83E\uDDD6\u2640\uFE0F":"1f9d6-2640","\uD83E\uDDD6\u200D\u2642":"1f9d6-2642","\uD83E\uDDD6\u2642\uFE0F":"1f9d6-2642","\uD83E\uDDD7\u200D\u2640":"1f9d7-2640","\uD83E\uDDD7\u2640\uFE0F":"1f9d7-2640","\uD83E\uDDD7\u200D\u2642":"1f9d7-2642","\uD83E\uDDD7\u2642\uFE0F":"1f9d7-2642","\uD83E\uDDD8\u200D\u2640":"1f9d8-2640","\uD83E\uDDD8\u2640\uFE0F":"1f9d8-2640","\uD83E\uDDD8\u200D\u2642":"1f9d8-2642","\uD83E\uDDD8\u2642\uFE0F":"1f9d8-2642","#\uFE0F\u20E3":"0023-20e3","0\uFE0F\u20E3":"0030-20e3","1\uFE0F\u20E3":"0031-20e3","2\uFE0F\u20E3":"0032-20e3","3\uFE0F\u20E3":"0033-20e3","4\uFE0F\u20E3":"0034-20e3","5\uFE0F\u20E3":"0035-20e3","6\uFE0F\u20E3":"0036-20e3","7\uFE0F\u20E3":"0037-20e3","8\uFE0F\u20E3":"0038-20e3","9\uFE0F\u20E3":"0039-20e3","*\uFE0F\u20E3":"002a-20e3","\u26F9\u200D\u2640":"26f9-2640","\u26F9\u200D\u2642":"26f9-2642","\uD83C\uDDE8\uD83C\uDDF3":"1f1e8-1f1f3","\uD83C\uDDE9\uD83C\uDDEA":"1f1e9-1f1ea","\uD83C\uDDEA\uD83C\uDDF8":"1f1ea-1f1f8","\uD83C\uDDEB\uD83C\uDDF7":"1f1eb-1f1f7","\uD83C\uDDEC\uD83C\uDDE7":"1f1ec-1f1e7","\uD83C\uDDEE\uD83C\uDDF9":"1f1ee-1f1f9","\uD83C\uDDEF\uD83C\uDDF5":"1f1ef-1f1f5","\uD83C\uDDF0\uD83C\uDDF7":"1f1f0-1f1f7","\uD83C\uDDFA\uD83C\uDDF8":"1f1fa-1f1f8","\uD83C\uDDF7\uD83C\uDDFA":"1f1f7-1f1fa","\uD83E\uDD34\uD83C\uDFFB":"1f934-1f3fb","\uD83E\uDD34\uD83C\uDFFC":"1f934-1f3fc","\uD83E\uDD34\uD83C\uDFFD":"1f934-1f3fd","\uD83E\uDD34\uD83C\uDFFE":"1f934-1f3fe","\uD83E\uDD34\uD83C\uDFFF":"1f934-1f3ff","\uD83E\uDD36\uD83C\uDFFB":"1f936-1f3fb","\uD83E\uDD36\uD83C\uDFFC":"1f936-1f3fc","\uD83E\uDD36\uD83C\uDFFD":"1f936-1f3fd","\uD83E\uDD36\uD83C\uDFFE":"1f936-1f3fe","\uD83E\uDD36\uD83C\uDFFF":"1f936-1f3ff","\uD83E\uDD35\uD83C\uDFFB":"1f935-1f3fb","\uD83E\uDD35\uD83C\uDFFC":"1f935-1f3fc","\uD83E\uDD35\uD83C\uDFFD":"1f935-1f3fd","\uD83E\uDD35\uD83C\uDFFE":"1f935-1f3fe","\uD83E\uDD35\uD83C\uDFFF":"1f935-1f3ff","\uD83E\uDD37\uD83C\uDFFB":"1f937-1f3fb","\uD83E\uDD37\uD83C\uDFFC":"1f937-1f3fc","\uD83E\uDD37\uD83C\uDFFD":"1f937-1f3fd","\uD83E\uDD37\uD83C\uDFFE":"1f937-1f3fe","\uD83E\uDD37\uD83C\uDFFF":"1f937-1f3ff","\uD83E\uDD26\uD83C\uDFFB":"1f926-1f3fb","\uD83E\uDD26\uD83C\uDFFC":"1f926-1f3fc","\uD83E\uDD26\uD83C\uDFFD":"1f926-1f3fd","\uD83E\uDD26\uD83C\uDFFE":"1f926-1f3fe","\uD83E\uDD26\uD83C\uDFFF":"1f926-1f3ff","\uD83E\uDD30\uD83C\uDFFB":"1f930-1f3fb","\uD83E\uDD30\uD83C\uDFFC":"1f930-1f3fc","\uD83E\uDD30\uD83C\uDFFD":"1f930-1f3fd","\uD83E\uDD30\uD83C\uDFFE":"1f930-1f3fe","\uD83E\uDD30\uD83C\uDFFF":"1f930-1f3ff","\uD83D\uDD7A\uD83C\uDFFB":"1f57a-1f3fb","\uD83D\uDD7A\uD83C\uDFFC":"1f57a-1f3fc","\uD83D\uDD7A\uD83C\uDFFD":"1f57a-1f3fd","\uD83D\uDD7A\uD83C\uDFFE":"1f57a-1f3fe","\uD83D\uDD7A\uD83C\uDFFF":"1f57a-1f3ff","\uD83E\uDD33\uD83C\uDFFB":"1f933-1f3fb","\uD83E\uDD33\uD83C\uDFFC":"1f933-1f3fc","\uD83E\uDD33\uD83C\uDFFD":"1f933-1f3fd","\uD83E\uDD33\uD83C\uDFFE":"1f933-1f3fe","\uD83E\uDD33\uD83C\uDFFF":"1f933-1f3ff","\uD83E\uDD1E\uD83C\uDFFB":"1f91e-1f3fb","\uD83E\uDD1E\uD83C\uDFFC":"1f91e-1f3fc","\uD83E\uDD1E\uD83C\uDFFD":"1f91e-1f3fd","\uD83E\uDD1E\uD83C\uDFFE":"1f91e-1f3fe","\uD83E\uDD1E\uD83C\uDFFF":"1f91e-1f3ff","\uD83E\uDD19\uD83C\uDFFB":"1f919-1f3fb","\uD83E\uDD19\uD83C\uDFFC":"1f919-1f3fc","\uD83E\uDD19\uD83C\uDFFD":"1f919-1f3fd","\uD83C\uDDE6\uD83C\uDDEB":"1f1e6-1f1eb","\uD83C\uDDE6\uD83C\uDDF1":"1f1e6-1f1f1","\uD83C\uDDE9\uD83C\uDDFF":"1f1e9-1f1ff","\uD83C\uDDE6\uD83C\uDDE9":"1f1e6-1f1e9","\uD83C\uDDE6\uD83C\uDDF4":"1f1e6-1f1f4","\uD83C\uDDE6\uD83C\uDDEC":"1f1e6-1f1ec","\uD83C\uDDE6\uD83C\uDDF7":"1f1e6-1f1f7","\uD83C\uDDE6\uD83C\uDDF2":"1f1e6-1f1f2","\uD83C\uDDE6\uD83C\uDDFA":"1f1e6-1f1fa","\uD83C\uDDE6\uD83C\uDDF9":"1f1e6-1f1f9","\uD83C\uDDE6\uD83C\uDDFF":"1f1e6-1f1ff","\uD83C\uDDE7\uD83C\uDDF8":"1f1e7-1f1f8","\uD83C\uDDE7\uD83C\uDDED":"1f1e7-1f1ed","\uD83C\uDDE7\uD83C\uDDE9":"1f1e7-1f1e9","\uD83C\uDDE7\uD83C\uDDE7":"1f1e7-1f1e7","\uD83C\uDDE7\uD83C\uDDFE":"1f1e7-1f1fe","\uD83C\uDDE7\uD83C\uDDEA":"1f1e7-1f1ea","\uD83C\uDDE7\uD83C\uDDFF":"1f1e7-1f1ff","\uD83C\uDDE7\uD83C\uDDEF":"1f1e7-1f1ef","\uD83C\uDDE7\uD83C\uDDF9":"1f1e7-1f1f9","\uD83C\uDDE7\uD83C\uDDF4":"1f1e7-1f1f4","\uD83C\uDDE7\uD83C\uDDE6":"1f1e7-1f1e6","\uD83C\uDDE7\uD83C\uDDFC":"1f1e7-1f1fc","\uD83C\uDDE7\uD83C\uDDF7":"1f1e7-1f1f7","\uD83C\uDDE7\uD83C\uDDF3":"1f1e7-1f1f3","\uD83C\uDDE7\uD83C\uDDEC":"1f1e7-1f1ec","\uD83C\uDDE7\uD83C\uDDEB":"1f1e7-1f1eb","\uD83C\uDDE7\uD83C\uDDEE":"1f1e7-1f1ee","\uD83C\uDDF0\uD83C\uDDED":"1f1f0-1f1ed","\uD83C\uDDE8\uD83C\uDDF2":"1f1e8-1f1f2","\uD83C\uDDE8\uD83C\uDDE6":"1f1e8-1f1e6","\uD83C\uDDE8\uD83C\uDDFB":"1f1e8-1f1fb","\uD83E\uDD19\uD83C\uDFFE":"1f919-1f3fe","\uD83C\uDDE8\uD83C\uDDEB":"1f1e8-1f1eb","\uD83C\uDDF9\uD83C\uDDE9":"1f1f9-1f1e9","\uD83C\uDDE8\uD83C\uDDF1":"1f1e8-1f1f1","\uD83C\uDDE8\uD83C\uDDF4":"1f1e8-1f1f4","\uD83C\uDDF0\uD83C\uDDF2":"1f1f0-1f1f2","\uD83C\uDDE8\uD83C\uDDF7":"1f1e8-1f1f7","\uD83C\uDDE8\uD83C\uDDEE":"1f1e8-1f1ee","\uD83C\uDDED\uD83C\uDDF7":"1f1ed-1f1f7","\uD83C\uDDE8\uD83C\uDDFA":"1f1e8-1f1fa","\uD83C\uDDE8\uD83C\uDDFE":"1f1e8-1f1fe","\uD83C\uDDE8\uD83C\uDDFF":"1f1e8-1f1ff","\uD83E\uDD19\uD83C\uDFFF":"1f919-1f3ff","\uD83C\uDDE8\uD83C\uDDE9":"1f1e8-1f1e9","\uD83E\uDD1B\uD83C\uDFFB":"1f91b-1f3fb","\uD83C\uDDE9\uD83C\uDDF0":"1f1e9-1f1f0","\uD83C\uDDE9\uD83C\uDDEF":"1f1e9-1f1ef","\uD83C\uDDE9\uD83C\uDDF2":"1f1e9-1f1f2","\uD83C\uDDE9\uD83C\uDDF4":"1f1e9-1f1f4","\uD83C\uDDF9\uD83C\uDDF1":"1f1f9-1f1f1","\uD83C\uDDEA\uD83C\uDDE8":"1f1ea-1f1e8","\uD83C\uDDEA\uD83C\uDDEC":"1f1ea-1f1ec","\uD83C\uDDF8\uD83C\uDDFB":"1f1f8-1f1fb","\uD83C\uDDEC\uD83C\uDDF6":"1f1ec-1f1f6","\uD83C\uDDEA\uD83C\uDDF7":"1f1ea-1f1f7","\uD83C\uDDEA\uD83C\uDDEA":"1f1ea-1f1ea","\uD83C\uDDEA\uD83C\uDDF9":"1f1ea-1f1f9","\uD83E\uDD1B\uD83C\uDFFC":"1f91b-1f3fc","\uD83C\uDDEB\uD83C\uDDEF":"1f1eb-1f1ef","\uD83C\uDDEB\uD83C\uDDEE":"1f1eb-1f1ee","\uD83C\uDDEC\uD83C\uDDE6":"1f1ec-1f1e6","\uD83C\uDDEC\uD83C\uDDF2":"1f1ec-1f1f2","\uD83C\uDDEC\uD83C\uDDEA":"1f1ec-1f1ea","\uD83C\uDDEC\uD83C\uDDED":"1f1ec-1f1ed","\uD83C\uDDEC\uD83C\uDDF7":"1f1ec-1f1f7","\uD83C\uDDEC\uD83C\uDDE9":"1f1ec-1f1e9","\uD83C\uDDEC\uD83C\uDDF9":"1f1ec-1f1f9","\uD83C\uDDEC\uD83C\uDDF3":"1f1ec-1f1f3","\uD83C\uDDEC\uD83C\uDDFC":"1f1ec-1f1fc","\uD83C\uDDEC\uD83C\uDDFE":"1f1ec-1f1fe","\uD83C\uDDED\uD83C\uDDF9":"1f1ed-1f1f9","\uD83C\uDDED\uD83C\uDDF3":"1f1ed-1f1f3","\uD83C\uDDED\uD83C\uDDFA":"1f1ed-1f1fa","\uD83C\uDDEE\uD83C\uDDF8":"1f1ee-1f1f8","\uD83C\uDDEE\uD83C\uDDF3":"1f1ee-1f1f3","\uD83C\uDDEE\uD83C\uDDE9":"1f1ee-1f1e9","\uD83C\uDDEE\uD83C\uDDF7":"1f1ee-1f1f7","\uD83C\uDDEE\uD83C\uDDF6":"1f1ee-1f1f6","\uD83C\uDDEE\uD83C\uDDEA":"1f1ee-1f1ea","\uD83C\uDDEE\uD83C\uDDF1":"1f1ee-1f1f1","\uD83C\uDDEF\uD83C\uDDF2":"1f1ef-1f1f2","\uD83C\uDDEF\uD83C\uDDF4":"1f1ef-1f1f4","\uD83C\uDDF0\uD83C\uDDFF":"1f1f0-1f1ff","\uD83C\uDDF0\uD83C\uDDEA":"1f1f0-1f1ea","\uD83C\uDDF0\uD83C\uDDEE":"1f1f0-1f1ee","\uD83C\uDDFD\uD83C\uDDF0":"1f1fd-1f1f0","\uD83C\uDDF0\uD83C\uDDFC":"1f1f0-1f1fc","\uD83C\uDDF0\uD83C\uDDEC":"1f1f0-1f1ec","\uD83E\uDD1B\uD83C\uDFFD":"1f91b-1f3fd","\uD83C\uDDF1\uD83C\uDDE6":"1f1f1-1f1e6","\uD83C\uDDF1\uD83C\uDDFB":"1f1f1-1f1fb","\uD83C\uDDF1\uD83C\uDDE7":"1f1f1-1f1e7","\uD83C\uDDF1\uD83C\uDDF8":"1f1f1-1f1f8","\uD83C\uDDF1\uD83C\uDDF7":"1f1f1-1f1f7","\uD83C\uDDF1\uD83C\uDDFE":"1f1f1-1f1fe","\uD83C\uDDF1\uD83C\uDDEE":"1f1f1-1f1ee","\uD83C\uDDF1\uD83C\uDDF9":"1f1f1-1f1f9","\uD83C\uDDF1\uD83C\uDDFA":"1f1f1-1f1fa","\uD83C\uDDF2\uD83C\uDDF0":"1f1f2-1f1f0","\uD83C\uDDF2\uD83C\uDDEC":"1f1f2-1f1ec","\uD83C\uDDF2\uD83C\uDDFC":"1f1f2-1f1fc","\uD83C\uDDF2\uD83C\uDDFE":"1f1f2-1f1fe","\uD83C\uDDF2\uD83C\uDDFB":"1f1f2-1f1fb","\uD83C\uDDF2\uD83C\uDDF1":"1f1f2-1f1f1","\uD83C\uDDF2\uD83C\uDDF9":"1f1f2-1f1f9","\uD83C\uDDF2\uD83C\uDDED":"1f1f2-1f1ed","\uD83C\uDDF2\uD83C\uDDF7":"1f1f2-1f1f7","\uD83C\uDDF2\uD83C\uDDFA":"1f1f2-1f1fa","\uD83C\uDDF2\uD83C\uDDFD":"1f1f2-1f1fd","\uD83C\uDDEB\uD83C\uDDF2":"1f1eb-1f1f2","\uD83C\uDDF2\uD83C\uDDE9":"1f1f2-1f1e9","\uD83C\uDDF2\uD83C\uDDE8":"1f1f2-1f1e8","\uD83C\uDDF2\uD83C\uDDF3":"1f1f2-1f1f3","\uD83C\uDDF2\uD83C\uDDEA":"1f1f2-1f1ea","\uD83C\uDDF2\uD83C\uDDE6":"1f1f2-1f1e6","\uD83C\uDDF2\uD83C\uDDFF":"1f1f2-1f1ff","\uD83C\uDDF2\uD83C\uDDF2":"1f1f2-1f1f2","\uD83C\uDDF3\uD83C\uDDE6":"1f1f3-1f1e6","\uD83C\uDDF3\uD83C\uDDF7":"1f1f3-1f1f7","\uD83C\uDDF3\uD83C\uDDF5":"1f1f3-1f1f5","\uD83C\uDDF3\uD83C\uDDF1":"1f1f3-1f1f1","\uD83C\uDDF3\uD83C\uDDFF":"1f1f3-1f1ff","\uD83C\uDDF3\uD83C\uDDEE":"1f1f3-1f1ee","\uD83C\uDDF3\uD83C\uDDEA":"1f1f3-1f1ea","\uD83C\uDDF3\uD83C\uDDEC":"1f1f3-1f1ec","\uD83C\uDDF0\uD83C\uDDF5":"1f1f0-1f1f5","\uD83C\uDDF3\uD83C\uDDF4":"1f1f3-1f1f4","\uD83C\uDDF4\uD83C\uDDF2":"1f1f4-1f1f2","\uD83C\uDDF5\uD83C\uDDF0":"1f1f5-1f1f0","\uD83C\uDDF5\uD83C\uDDFC":"1f1f5-1f1fc","\uD83C\uDDF5\uD83C\uDDE6":"1f1f5-1f1e6","\uD83C\uDDF5\uD83C\uDDEC":"1f1f5-1f1ec","\uD83E\uDD1B\uD83C\uDFFE":"1f91b-1f3fe","\uD83C\uDDF5\uD83C\uDDFE":"1f1f5-1f1fe","\uD83C\uDDF5\uD83C\uDDEA":"1f1f5-1f1ea","\uD83C\uDDF5\uD83C\uDDED":"1f1f5-1f1ed","\uD83C\uDDF5\uD83C\uDDF1":"1f1f5-1f1f1","\uD83C\uDDF5\uD83C\uDDF9":"1f1f5-1f1f9","\uD83C\uDDF6\uD83C\uDDE6":"1f1f6-1f1e6","\uD83C\uDDF9\uD83C\uDDFC":"1f1f9-1f1fc","\uD83C\uDDE8\uD83C\uDDEC":"1f1e8-1f1ec","\uD83C\uDDF7\uD83C\uDDF4":"1f1f7-1f1f4","\uD83C\uDDF7\uD83C\uDDFC":"1f1f7-1f1fc","\uD83C\uDDF0\uD83C\uDDF3":"1f1f0-1f1f3","\uD83C\uDDF1\uD83C\uDDE8":"1f1f1-1f1e8","\uD83C\uDDFB\uD83C\uDDE8":"1f1fb-1f1e8","\uD83C\uDDFC\uD83C\uDDF8":"1f1fc-1f1f8","\uD83C\uDDF8\uD83C\uDDF2":"1f1f8-1f1f2","\uD83C\uDDF8\uD83C\uDDF9":"1f1f8-1f1f9","\uD83C\uDDF8\uD83C\uDDE6":"1f1f8-1f1e6","\uD83E\uDD1B\uD83C\uDFFF":"1f91b-1f3ff","\uD83C\uDDF8\uD83C\uDDF3":"1f1f8-1f1f3","\uD83C\uDDF7\uD83C\uDDF8":"1f1f7-1f1f8","\uD83C\uDDF8\uD83C\uDDE8":"1f1f8-1f1e8","\uD83C\uDDF8\uD83C\uDDF1":"1f1f8-1f1f1","\uD83C\uDDF8\uD83C\uDDEC":"1f1f8-1f1ec","\uD83C\uDDF8\uD83C\uDDF0":"1f1f8-1f1f0","\uD83C\uDDF8\uD83C\uDDEE":"1f1f8-1f1ee","\uD83C\uDDF8\uD83C\uDDE7":"1f1f8-1f1e7","\uD83C\uDDF8\uD83C\uDDF4":"1f1f8-1f1f4","\uD83C\uDDFF\uD83C\uDDE6":"1f1ff-1f1e6","\uD83C\uDDF1\uD83C\uDDF0":"1f1f1-1f1f0","\uD83C\uDDF8\uD83C\uDDE9":"1f1f8-1f1e9","\uD83C\uDDF8\uD83C\uDDF7":"1f1f8-1f1f7","\uD83C\uDDF8\uD83C\uDDFF":"1f1f8-1f1ff","\uD83C\uDDF8\uD83C\uDDEA":"1f1f8-1f1ea","\uD83C\uDDE8\uD83C\uDDED":"1f1e8-1f1ed","\uD83C\uDDF8\uD83C\uDDFE":"1f1f8-1f1fe","\uD83C\uDDF9\uD83C\uDDEF":"1f1f9-1f1ef","\uD83C\uDDF9\uD83C\uDDFF":"1f1f9-1f1ff","\uD83C\uDDF9\uD83C\uDDED":"1f1f9-1f1ed","\uD83C\uDDF9\uD83C\uDDEC":"1f1f9-1f1ec","\uD83C\uDDF9\uD83C\uDDF4":"1f1f9-1f1f4","\uD83C\uDDF9\uD83C\uDDF9":"1f1f9-1f1f9","\uD83C\uDDF9\uD83C\uDDF3":"1f1f9-1f1f3","\uD83C\uDDF9\uD83C\uDDF7":"1f1f9-1f1f7","\uD83C\uDDF9\uD83C\uDDF2":"1f1f9-1f1f2","\uD83C\uDDF9\uD83C\uDDFB":"1f1f9-1f1fb","\uD83C\uDDFA\uD83C\uDDEC":"1f1fa-1f1ec","\uD83C\uDDFA\uD83C\uDDE6":"1f1fa-1f1e6","\uD83C\uDDE6\uD83C\uDDEA":"1f1e6-1f1ea","\uD83C\uDDFA\uD83C\uDDFE":"1f1fa-1f1fe","\uD83C\uDDFA\uD83C\uDDFF":"1f1fa-1f1ff","\uD83C\uDDFB\uD83C\uDDFA":"1f1fb-1f1fa","\uD83C\uDDFB\uD83C\uDDE6":"1f1fb-1f1e6","\uD83C\uDDFB\uD83C\uDDEA":"1f1fb-1f1ea","\uD83C\uDDFB\uD83C\uDDF3":"1f1fb-1f1f3","\uD83C\uDDEA\uD83C\uDDED":"1f1ea-1f1ed","\uD83E\uDD1C\uD83C\uDFFB":"1f91c-1f3fb","\uD83C\uDDFE\uD83C\uDDEA":"1f1fe-1f1ea","\uD83C\uDDFF\uD83C\uDDF2":"1f1ff-1f1f2","\uD83C\uDDFF\uD83C\uDDFC":"1f1ff-1f1fc","\uD83C\uDDF5\uD83C\uDDF7":"1f1f5-1f1f7","\uD83C\uDDF0\uD83C\uDDFE":"1f1f0-1f1fe","\uD83C\uDDE7\uD83C\uDDF2":"1f1e7-1f1f2","\uD83C\uDDF5\uD83C\uDDEB":"1f1f5-1f1eb","\uD83C\uDDF5\uD83C\uDDF8":"1f1f5-1f1f8","\uD83C\uDDF3\uD83C\uDDE8":"1f1f3-1f1e8","\uD83E\uDD1C\uD83C\uDFFC":"1f91c-1f3fc","\uD83C\uDDF8\uD83C\uDDED":"1f1f8-1f1ed","\uD83C\uDDE6\uD83C\uDDFC":"1f1e6-1f1fc","\uD83C\uDDFB\uD83C\uDDEE":"1f1fb-1f1ee","\uD83C\uDDED\uD83C\uDDF0":"1f1ed-1f1f0","\uD83C\uDDE6\uD83C\uDDE8":"1f1e6-1f1e8","\uD83C\uDDF2\uD83C\uDDF8":"1f1f2-1f1f8","\uD83C\uDDEC\uD83C\uDDFA":"1f1ec-1f1fa","\uD83C\uDDEC\uD83C\uDDF1":"1f1ec-1f1f1","\uD83C\uDDF3\uD83C\uDDFA":"1f1f3-1f1fa","\uD83C\uDDFC\uD83C\uDDEB":"1f1fc-1f1eb","\uD83C\uDDF2\uD83C\uDDF4":"1f1f2-1f1f4","\uD83E\uDD1C\uD83C\uDFFD":"1f91c-1f3fd","\uD83C\uDDEB\uD83C\uDDF4":"1f1eb-1f1f4","\uD83C\uDDEB\uD83C\uDDF0":"1f1eb-1f1f0","\uD83C\uDDEF\uD83C\uDDEA":"1f1ef-1f1ea","\uD83C\uDDE6\uD83C\uDDEE":"1f1e6-1f1ee","\uD83C\uDDEC\uD83C\uDDEE":"1f1ec-1f1ee","\uD83E\uDD1C\uD83C\uDFFE":"1f91c-1f3fe","\uD83E\uDD1C\uD83C\uDFFF":"1f91c-1f3ff","\uD83E\uDD1A\uD83C\uDFFB":"1f91a-1f3fb","\uD83E\uDD1A\uD83C\uDFFC":"1f91a-1f3fc","\uD83E\uDD1A\uD83C\uDFFD":"1f91a-1f3fd","\uD83E\uDD1A\uD83C\uDFFE":"1f91a-1f3fe","\uD83D\uDC76\uD83C\uDFFB":"1f476-1f3fb","\uD83D\uDC76\uD83C\uDFFC":"1f476-1f3fc","\uD83D\uDC76\uD83C\uDFFD":"1f476-1f3fd","\uD83D\uDC76\uD83C\uDFFE":"1f476-1f3fe","\uD83D\uDC76\uD83C\uDFFF":"1f476-1f3ff","\uD83D\uDC66\uD83C\uDFFB":"1f466-1f3fb","\uD83D\uDC66\uD83C\uDFFC":"1f466-1f3fc","\uD83D\uDC66\uD83C\uDFFD":"1f466-1f3fd","\uD83D\uDC66\uD83C\uDFFE":"1f466-1f3fe","\uD83D\uDC66\uD83C\uDFFF":"1f466-1f3ff","\uD83D\uDC67\uD83C\uDFFB":"1f467-1f3fb","\uD83D\uDC67\uD83C\uDFFC":"1f467-1f3fc","\uD83D\uDC67\uD83C\uDFFD":"1f467-1f3fd","\uD83D\uDC67\uD83C\uDFFE":"1f467-1f3fe","\uD83D\uDC67\uD83C\uDFFF":"1f467-1f3ff","\uD83D\uDC68\uD83C\uDFFB":"1f468-1f3fb","\uD83D\uDC68\uD83C\uDFFC":"1f468-1f3fc","\uD83D\uDC68\uD83C\uDFFD":"1f468-1f3fd","\uD83D\uDC68\uD83C\uDFFE":"1f468-1f3fe","\uD83D\uDC68\uD83C\uDFFF":"1f468-1f3ff","\uD83D\uDC69\uD83C\uDFFB":"1f469-1f3fb","\uD83D\uDC69\uD83C\uDFFC":"1f469-1f3fc","\uD83D\uDC69\uD83C\uDFFD":"1f469-1f3fd","\uD83D\uDC69\uD83C\uDFFE":"1f469-1f3fe","\uD83D\uDC69\uD83C\uDFFF":"1f469-1f3ff","\uD83D\uDC70\uD83C\uDFFB":"1f470-1f3fb","\uD83D\uDC70\uD83C\uDFFC":"1f470-1f3fc","\uD83E\uDD1A\uD83C\uDFFF":"1f91a-1f3ff","\uD83D\uDC70\uD83C\uDFFD":"1f470-1f3fd","\uD83D\uDC70\uD83C\uDFFE":"1f470-1f3fe","\uD83D\uDC70\uD83C\uDFFF":"1f470-1f3ff","\uD83D\uDC71\uD83C\uDFFB":"1f471-1f3fb","\uD83D\uDC71\uD83C\uDFFC":"1f471-1f3fc","\uD83D\uDC71\uD83C\uDFFD":"1f471-1f3fd","\uD83D\uDC71\uD83C\uDFFE":"1f471-1f3fe","\uD83D\uDC71\uD83C\uDFFF":"1f471-1f3ff","\uD83D\uDC72\uD83C\uDFFB":"1f472-1f3fb","\uD83D\uDC72\uD83C\uDFFC":"1f472-1f3fc","\uD83D\uDC72\uD83C\uDFFD":"1f472-1f3fd","\uD83D\uDC72\uD83C\uDFFE":"1f472-1f3fe","\uD83D\uDC72\uD83C\uDFFF":"1f472-1f3ff","\uD83D\uDC73\uD83C\uDFFB":"1f473-1f3fb","\uD83D\uDC73\uD83C\uDFFC":"1f473-1f3fc","\uD83D\uDC73\uD83C\uDFFD":"1f473-1f3fd","\uD83D\uDC73\uD83C\uDFFE":"1f473-1f3fe","\uD83D\uDC73\uD83C\uDFFF":"1f473-1f3ff","\uD83D\uDC74\uD83C\uDFFB":"1f474-1f3fb","\uD83D\uDC74\uD83C\uDFFC":"1f474-1f3fc","\uD83D\uDC74\uD83C\uDFFD":"1f474-1f3fd","\uD83D\uDC74\uD83C\uDFFE":"1f474-1f3fe","\uD83D\uDC74\uD83C\uDFFF":"1f474-1f3ff","\uD83D\uDC75\uD83C\uDFFB":"1f475-1f3fb","\uD83D\uDC75\uD83C\uDFFC":"1f475-1f3fc","\uD83D\uDC75\uD83C\uDFFD":"1f475-1f3fd","\uD83D\uDC75\uD83C\uDFFE":"1f475-1f3fe","\uD83D\uDC75\uD83C\uDFFF":"1f475-1f3ff","\uD83D\uDC6E\uD83C\uDFFB":"1f46e-1f3fb","\uD83D\uDC6E\uD83C\uDFFC":"1f46e-1f3fc","\uD83D\uDC6E\uD83C\uDFFD":"1f46e-1f3fd","\uD83D\uDC6E\uD83C\uDFFE":"1f46e-1f3fe","\uD83D\uDC6E\uD83C\uDFFF":"1f46e-1f3ff","\uD83D\uDC77\uD83C\uDFFB":"1f477-1f3fb","\uD83D\uDC77\uD83C\uDFFC":"1f477-1f3fc","\uD83D\uDC77\uD83C\uDFFD":"1f477-1f3fd","\uD83D\uDC77\uD83C\uDFFE":"1f477-1f3fe","\uD83D\uDC77\uD83C\uDFFF":"1f477-1f3ff","\uD83D\uDC78\uD83C\uDFFB":"1f478-1f3fb","\uD83D\uDC78\uD83C\uDFFC":"1f478-1f3fc","\uD83D\uDC78\uD83C\uDFFD":"1f478-1f3fd","\uD83D\uDC78\uD83C\uDFFE":"1f478-1f3fe","\uD83E\uDD38\uD83C\uDFFB":"1f938-1f3fb","\uD83D\uDC78\uD83C\uDFFF":"1f478-1f3ff","\uD83D\uDC82\uD83C\uDFFB":"1f482-1f3fb","\uD83D\uDC82\uD83C\uDFFC":"1f482-1f3fc","\uD83E\uDD38\uD83C\uDFFC":"1f938-1f3fc","\uD83D\uDC82\uD83C\uDFFD":"1f482-1f3fd","\uD83D\uDC82\uD83C\uDFFE":"1f482-1f3fe","\uD83D\uDC82\uD83C\uDFFF":"1f482-1f3ff","\uD83E\uDD38\uD83C\uDFFD":"1f938-1f3fd","\uD83D\uDC7C\uD83C\uDFFB":"1f47c-1f3fb","\uD83D\uDC7C\uD83C\uDFFC":"1f47c-1f3fc","\uD83D\uDC7C\uD83C\uDFFD":"1f47c-1f3fd","\uD83D\uDC7C\uD83C\uDFFE":"1f47c-1f3fe","\uD83D\uDC7C\uD83C\uDFFF":"1f47c-1f3ff","\uD83D\uDE47\uD83C\uDFFB":"1f647-1f3fb","\uD83D\uDE47\uD83C\uDFFC":"1f647-1f3fc","\uD83D\uDE47\uD83C\uDFFD":"1f647-1f3fd","\uD83D\uDE47\uD83C\uDFFE":"1f647-1f3fe","\uD83D\uDE47\uD83C\uDFFF":"1f647-1f3ff","\uD83D\uDC81\uD83C\uDFFB":"1f481-1f3fb","\uD83D\uDC81\uD83C\uDFFC":"1f481-1f3fc","\uD83D\uDC81\uD83C\uDFFD":"1f481-1f3fd","\uD83E\uDD38\uD83C\uDFFE":"1f938-1f3fe","\uD83D\uDC81\uD83C\uDFFE":"1f481-1f3fe","\uD83D\uDC81\uD83C\uDFFF":"1f481-1f3ff","\uD83D\uDE45\uD83C\uDFFB":"1f645-1f3fb","\uD83E\uDD38\uD83C\uDFFF":"1f938-1f3ff","\uD83D\uDE45\uD83C\uDFFC":"1f645-1f3fc","\uD83D\uDE45\uD83C\uDFFD":"1f645-1f3fd","\uD83D\uDE45\uD83C\uDFFE":"1f645-1f3fe","\uD83D\uDE45\uD83C\uDFFF":"1f645-1f3ff","\uD83D\uDE46\uD83C\uDFFB":"1f646-1f3fb","\uD83D\uDE46\uD83C\uDFFC":"1f646-1f3fc","\uD83D\uDE46\uD83C\uDFFD":"1f646-1f3fd","\uD83D\uDE46\uD83C\uDFFE":"1f646-1f3fe","\uD83D\uDE46\uD83C\uDFFF":"1f646-1f3ff","\uD83D\uDE4B\uD83C\uDFFB":"1f64b-1f3fb","\uD83D\uDE4B\uD83C\uDFFC":"1f64b-1f3fc","\uD83D\uDE4B\uD83C\uDFFD":"1f64b-1f3fd","\uD83D\uDE4B\uD83C\uDFFE":"1f64b-1f3fe","\uD83D\uDE4B\uD83C\uDFFF":"1f64b-1f3ff","\uD83D\uDE4E\uD83C\uDFFB":"1f64e-1f3fb","\uD83D\uDE4E\uD83C\uDFFC":"1f64e-1f3fc","\uD83D\uDE4E\uD83C\uDFFD":"1f64e-1f3fd","\uD83D\uDE4E\uD83C\uDFFE":"1f64e-1f3fe","\uD83D\uDE4E\uD83C\uDFFF":"1f64e-1f3ff","\uD83D\uDE4D\uD83C\uDFFB":"1f64d-1f3fb","\uD83D\uDE4D\uD83C\uDFFC":"1f64d-1f3fc","\uD83D\uDE4D\uD83C\uDFFD":"1f64d-1f3fd","\uD83D\uDE4D\uD83C\uDFFE":"1f64d-1f3fe","\uD83D\uDE4D\uD83C\uDFFF":"1f64d-1f3ff","\uD83D\uDC86\uD83C\uDFFB":"1f486-1f3fb","\uD83D\uDC86\uD83C\uDFFC":"1f486-1f3fc","\uD83D\uDC86\uD83C\uDFFD":"1f486-1f3fd","\uD83D\uDC86\uD83C\uDFFE":"1f486-1f3fe","\uD83D\uDC86\uD83C\uDFFF":"1f486-1f3ff","\uD83D\uDC87\uD83C\uDFFB":"1f487-1f3fb","\uD83D\uDC87\uD83C\uDFFC":"1f487-1f3fc","\uD83D\uDC87\uD83C\uDFFD":"1f487-1f3fd","\uD83D\uDC87\uD83C\uDFFE":"1f487-1f3fe","\uD83D\uDC87\uD83C\uDFFF":"1f487-1f3ff","\uD83D\uDE4C\uD83C\uDFFB":"1f64c-1f3fb","\uD83D\uDE4C\uD83C\uDFFC":"1f64c-1f3fc","\uD83D\uDE4C\uD83C\uDFFD":"1f64c-1f3fd","\uD83D\uDE4C\uD83C\uDFFE":"1f64c-1f3fe","\uD83D\uDE4C\uD83C\uDFFF":"1f64c-1f3ff","\uD83D\uDC4F\uD83C\uDFFB":"1f44f-1f3fb","\uD83D\uDC4F\uD83C\uDFFC":"1f44f-1f3fc","\uD83D\uDC4F\uD83C\uDFFD":"1f44f-1f3fd","\uD83E\uDD3D\uD83C\uDFFB":"1f93d-1f3fb","\uD83D\uDC4F\uD83C\uDFFE":"1f44f-1f3fe","\uD83D\uDC4F\uD83C\uDFFF":"1f44f-1f3ff","\uD83E\uDD3D\uD83C\uDFFC":"1f93d-1f3fc","\uD83D\uDC42\uD83C\uDFFB":"1f442-1f3fb","\uD83D\uDC42\uD83C\uDFFC":"1f442-1f3fc","\uD83D\uDC42\uD83C\uDFFD":"1f442-1f3fd","\uD83D\uDC42\uD83C\uDFFE":"1f442-1f3fe","\uD83D\uDC42\uD83C\uDFFF":"1f442-1f3ff","\uD83D\uDC43\uD83C\uDFFB":"1f443-1f3fb","\uD83D\uDC43\uD83C\uDFFC":"1f443-1f3fc","\uD83D\uDC43\uD83C\uDFFD":"1f443-1f3fd","\uD83D\uDC43\uD83C\uDFFE":"1f443-1f3fe","\uD83D\uDC43\uD83C\uDFFF":"1f443-1f3ff","\uD83D\uDC85\uD83C\uDFFB":"1f485-1f3fb","\uD83D\uDC85\uD83C\uDFFC":"1f485-1f3fc","\uD83D\uDC85\uD83C\uDFFD":"1f485-1f3fd","\uD83D\uDC85\uD83C\uDFFE":"1f485-1f3fe","\uD83D\uDC85\uD83C\uDFFF":"1f485-1f3ff","\uD83D\uDC4B\uD83C\uDFFB":"1f44b-1f3fb","\uD83D\uDC4B\uD83C\uDFFC":"1f44b-1f3fc","\uD83D\uDC4B\uD83C\uDFFD":"1f44b-1f3fd","\uD83D\uDC4B\uD83C\uDFFE":"1f44b-1f3fe","\uD83D\uDC4B\uD83C\uDFFF":"1f44b-1f3ff","\uD83D\uDC4D\uD83C\uDFFB":"1f44d-1f3fb","\uD83D\uDC4D\uD83C\uDFFC":"1f44d-1f3fc","\uD83D\uDC4D\uD83C\uDFFD":"1f44d-1f3fd","\uD83D\uDC4D\uD83C\uDFFE":"1f44d-1f3fe","\uD83D\uDC4D\uD83C\uDFFF":"1f44d-1f3ff","\uD83D\uDC4E\uD83C\uDFFB":"1f44e-1f3fb","\uD83D\uDC4E\uD83C\uDFFC":"1f44e-1f3fc","\uD83D\uDC4E\uD83C\uDFFD":"1f44e-1f3fd","\uD83D\uDC4E\uD83C\uDFFE":"1f44e-1f3fe","\uD83D\uDC4E\uD83C\uDFFF":"1f44e-1f3ff","\uD83D\uDC46\uD83C\uDFFB":"1f446-1f3fb","\uD83D\uDC46\uD83C\uDFFC":"1f446-1f3fc","\uD83D\uDC46\uD83C\uDFFD":"1f446-1f3fd","\uD83D\uDC46\uD83C\uDFFE":"1f446-1f3fe","\uD83D\uDC46\uD83C\uDFFF":"1f446-1f3ff","\uD83D\uDC47\uD83C\uDFFB":"1f447-1f3fb","\uD83D\uDC47\uD83C\uDFFC":"1f447-1f3fc","\uD83D\uDC47\uD83C\uDFFD":"1f447-1f3fd","\uD83D\uDC47\uD83C\uDFFE":"1f447-1f3fe","\uD83D\uDC47\uD83C\uDFFF":"1f447-1f3ff","\uD83D\uDC48\uD83C\uDFFB":"1f448-1f3fb","\uD83D\uDC48\uD83C\uDFFC":"1f448-1f3fc","\uD83D\uDC48\uD83C\uDFFD":"1f448-1f3fd","\uD83D\uDC48\uD83C\uDFFE":"1f448-1f3fe","\uD83D\uDC48\uD83C\uDFFF":"1f448-1f3ff","\uD83D\uDC49\uD83C\uDFFB":"1f449-1f3fb","\uD83D\uDC49\uD83C\uDFFC":"1f449-1f3fc","\uD83D\uDC49\uD83C\uDFFD":"1f449-1f3fd","\uD83D\uDC49\uD83C\uDFFE":"1f449-1f3fe","\uD83D\uDC49\uD83C\uDFFF":"1f449-1f3ff","\uD83D\uDC4C\uD83C\uDFFB":"1f44c-1f3fb","\uD83D\uDC4C\uD83C\uDFFC":"1f44c-1f3fc","\uD83E\uDD3D\uD83C\uDFFD":"1f93d-1f3fd","\uD83D\uDC4C\uD83C\uDFFD":"1f44c-1f3fd","\uD83D\uDC4C\uD83C\uDFFE":"1f44c-1f3fe","\uD83E\uDD3D\uD83C\uDFFE":"1f93d-1f3fe","\uD83D\uDC4C\uD83C\uDFFF":"1f44c-1f3ff","\uD83D\uDC4A\uD83C\uDFFB":"1f44a-1f3fb","\uD83D\uDC4A\uD83C\uDFFC":"1f44a-1f3fc","\uD83D\uDC4A\uD83C\uDFFD":"1f44a-1f3fd","\uD83D\uDC4A\uD83C\uDFFE":"1f44a-1f3fe","\uD83D\uDC4A\uD83C\uDFFF":"1f44a-1f3ff","\uD83D\uDCAA\uD83C\uDFFB":"1f4aa-1f3fb","\uD83D\uDCAA\uD83C\uDFFC":"1f4aa-1f3fc","\uD83D\uDCAA\uD83C\uDFFD":"1f4aa-1f3fd","\uD83D\uDCAA\uD83C\uDFFE":"1f4aa-1f3fe","\uD83D\uDCAA\uD83C\uDFFF":"1f4aa-1f3ff","\uD83D\uDC50\uD83C\uDFFB":"1f450-1f3fb","\uD83D\uDC50\uD83C\uDFFC":"1f450-1f3fc","\uD83D\uDC50\uD83C\uDFFD":"1f450-1f3fd","\uD83D\uDC50\uD83C\uDFFE":"1f450-1f3fe","\uD83D\uDC50\uD83C\uDFFF":"1f450-1f3ff","\uD83D\uDE4F\uD83C\uDFFB":"1f64f-1f3fb","\uD83E\uDD3D\uD83C\uDFFF":"1f93d-1f3ff","\uD83D\uDE4F\uD83C\uDFFC":"1f64f-1f3fc","\uD83D\uDE4F\uD83C\uDFFD":"1f64f-1f3fd","\uD83E\uDD3E\uD83C\uDFFB":"1f93e-1f3fb","\uD83D\uDE4F\uD83C\uDFFE":"1f64f-1f3fe","\uD83D\uDE4F\uD83C\uDFFF":"1f64f-1f3ff","\uD83E\uDD3E\uD83C\uDFFC":"1f93e-1f3fc","\uD83C\uDFC3\uD83C\uDFFB":"1f3c3-1f3fb","\uD83C\uDFC3\uD83C\uDFFC":"1f3c3-1f3fc","\uD83C\uDFC3\uD83C\uDFFD":"1f3c3-1f3fd","\uD83C\uDFC3\uD83C\uDFFE":"1f3c3-1f3fe","\uD83E\uDD3E\uD83C\uDFFD":"1f93e-1f3fd","\uD83C\uDFC3\uD83C\uDFFF":"1f3c3-1f3ff","\uD83D\uDEB6\uD83C\uDFFB":"1f6b6-1f3fb","\uD83D\uDEB6\uD83C\uDFFC":"1f6b6-1f3fc","\uD83D\uDEB6\uD83C\uDFFD":"1f6b6-1f3fd","\uD83D\uDEB6\uD83C\uDFFE":"1f6b6-1f3fe","\uD83D\uDEB6\uD83C\uDFFF":"1f6b6-1f3ff","\uD83D\uDC83\uD83C\uDFFB":"1f483-1f3fb","\uD83E\uDD3E\uD83C\uDFFE":"1f93e-1f3fe","\uD83D\uDC83\uD83C\uDFFC":"1f483-1f3fc","\uD83D\uDC83\uD83C\uDFFD":"1f483-1f3fd","\uD83E\uDD3E\uD83C\uDFFF":"1f93e-1f3ff","\uD83D\uDC83\uD83C\uDFFE":"1f483-1f3fe","\uD83D\uDC83\uD83C\uDFFF":"1f483-1f3ff","\uD83E\uDD39\uD83C\uDFFB":"1f939-1f3fb","\uD83D\uDEA3\uD83C\uDFFB":"1f6a3-1f3fb","\uD83D\uDEA3\uD83C\uDFFC":"1f6a3-1f3fc","\uD83D\uDEA3\uD83C\uDFFD":"1f6a3-1f3fd","\uD83D\uDEA3\uD83C\uDFFE":"1f6a3-1f3fe","\uD83D\uDEA3\uD83C\uDFFF":"1f6a3-1f3ff","\uD83C\uDFCA\uD83C\uDFFB":"1f3ca-1f3fb","\uD83C\uDFCA\uD83C\uDFFC":"1f3ca-1f3fc","\uD83E\uDD39\uD83C\uDFFC":"1f939-1f3fc","\uD83C\uDFCA\uD83C\uDFFD":"1f3ca-1f3fd","\uD83C\uDFCA\uD83C\uDFFE":"1f3ca-1f3fe","\uD83C\uDFCA\uD83C\uDFFF":"1f3ca-1f3ff","\uD83E\uDD39\uD83C\uDFFD":"1f939-1f3fd","\uD83C\uDFC4\uD83C\uDFFB":"1f3c4-1f3fb","\uD83C\uDFC4\uD83C\uDFFC":"1f3c4-1f3fc","\uD83C\uDFC4\uD83C\uDFFD":"1f3c4-1f3fd","\uD83C\uDFC4\uD83C\uDFFE":"1f3c4-1f3fe","\uD83C\uDFC4\uD83C\uDFFF":"1f3c4-1f3ff","\uD83D\uDEC0\uD83C\uDFFB":"1f6c0-1f3fb","\uD83D\uDEC0\uD83C\uDFFC":"1f6c0-1f3fc","\uD83E\uDD39\uD83C\uDFFE":"1f939-1f3fe","\uD83D\uDEC0\uD83C\uDFFD":"1f6c0-1f3fd","\uD83D\uDEC0\uD83C\uDFFE":"1f6c0-1f3fe","\uD83D\uDEC0\uD83C\uDFFF":"1f6c0-1f3ff","\uD83E\uDD39\uD83C\uDFFF":"1f939-1f3ff","\uD83D\uDEB4\uD83C\uDFFB":"1f6b4-1f3fb","\uD83D\uDEB4\uD83C\uDFFC":"1f6b4-1f3fc","\uD83D\uDEB4\uD83C\uDFFD":"1f6b4-1f3fd","\uD83D\uDEB4\uD83C\uDFFE":"1f6b4-1f3fe","\uD83D\uDEB4\uD83C\uDFFF":"1f6b4-1f3ff","\uD83D\uDEB5\uD83C\uDFFB":"1f6b5-1f3fb","\uD83D\uDEB5\uD83C\uDFFC":"1f6b5-1f3fc","\uD83D\uDEB5\uD83C\uDFFD":"1f6b5-1f3fd","\uD83D\uDEB5\uD83C\uDFFE":"1f6b5-1f3fe","\uD83D\uDEB5\uD83C\uDFFF":"1f6b5-1f3ff","\uD83C\uDFC7\uD83C\uDFFB":"1f3c7-1f3fb","\uD83C\uDFC7\uD83C\uDFFC":"1f3c7-1f3fc","\uD83C\uDFC7\uD83C\uDFFD":"1f3c7-1f3fd","\uD83C\uDFC7\uD83C\uDFFE":"1f3c7-1f3fe","\uD83C\uDFC7\uD83C\uDFFF":"1f3c7-1f3ff","\uD83D\uDD90\uD83C\uDFFB":"1f590-1f3fb","\uD83D\uDD90\uD83C\uDFFC":"1f590-1f3fc","\uD83D\uDD90\uD83C\uDFFD":"1f590-1f3fd","\uD83D\uDD90\uD83C\uDFFE":"1f590-1f3fe","\uD83D\uDD90\uD83C\uDFFF":"1f590-1f3ff","\uD83D\uDD95\uD83C\uDFFB":"1f595-1f3fb","\uD83D\uDD95\uD83C\uDFFC":"1f595-1f3fc","\uD83D\uDD95\uD83C\uDFFD":"1f595-1f3fd","\uD83D\uDD95\uD83C\uDFFE":"1f595-1f3fe","\uD83D\uDD95\uD83C\uDFFF":"1f595-1f3ff","\uD83D\uDD96\uD83C\uDFFB":"1f596-1f3fb","\uD83D\uDD96\uD83C\uDFFC":"1f596-1f3fc","\uD83D\uDD96\uD83C\uDFFD":"1f596-1f3fd","\uD83D\uDD96\uD83C\uDFFE":"1f596-1f3fe","\uD83D\uDD96\uD83C\uDFFF":"1f596-1f3ff","\uD83C\uDF85\uD83C\uDFFB":"1f385-1f3fb","\uD83C\uDF85\uD83C\uDFFC":"1f385-1f3fc","\uD83C\uDF85\uD83C\uDFFD":"1f385-1f3fd","\uD83C\uDF85\uD83C\uDFFE":"1f385-1f3fe","\uD83C\uDF85\uD83C\uDFFF":"1f385-1f3ff","\uD83E\uDD18\uD83C\uDFFB":"1f918-1f3fb","\uD83E\uDD18\uD83C\uDFFC":"1f918-1f3fc","\uD83E\uDD18\uD83C\uDFFD":"1f918-1f3fd","\uD83E\uDD18\uD83C\uDFFE":"1f918-1f3fe","\uD83E\uDD18\uD83C\uDFFF":"1f918-1f3ff","\uD83C\uDFCB\uD83C\uDFFB":"1f3cb-1f3fb","\uD83C\uDFCB\uD83C\uDFFC":"1f3cb-1f3fc","\uD83C\uDFCB\uD83C\uDFFD":"1f3cb-1f3fd","\uD83C\uDFCB\uD83C\uDFFE":"1f3cb-1f3fe","\uD83C\uDFCB\uD83C\uDFFF":"1f3cb-1f3ff","\uD83C\uDDE6\uD83C\uDDFD":"1f1e6-1f1fd","\uD83C\uDDF9\uD83C\uDDE6":"1f1f9-1f1e6","\uD83C\uDDEE\uD83C\uDDF4":"1f1ee-1f1f4","\uD83C\uDDE7\uD83C\uDDF6":"1f1e7-1f1f6","\uD83C\uDDE8\uD83C\uDDFD":"1f1e8-1f1fd","\uD83C\uDDE8\uD83C\uDDE8":"1f1e8-1f1e8","\uD83C\uDDEC\uD83C\uDDEC":"1f1ec-1f1ec","\uD83C\uDDEE\uD83C\uDDF2":"1f1ee-1f1f2","\uD83C\uDDFE\uD83C\uDDF9":"1f1fe-1f1f9","\uD83C\uDDF3\uD83C\uDDEB":"1f1f3-1f1eb","\uD83C\uDDF5\uD83C\uDDF3":"1f1f5-1f1f3","\uD83C\uDDE7\uD83C\uDDF1":"1f1e7-1f1f1","\uD83C\uDDF5\uD83C\uDDF2":"1f1f5-1f1f2","\uD83C\uDDEC\uD83C\uDDF8":"1f1ec-1f1f8","\uD83C\uDDF9\uD83C\uDDF0":"1f1f9-1f1f0","\uD83C\uDDE7\uD83C\uDDFB":"1f1e7-1f1fb","\uD83C\uDDED\uD83C\uDDF2":"1f1ed-1f1f2","\uD83C\uDDF8\uD83C\uDDEF":"1f1f8-1f1ef","\uD83C\uDDFA\uD83C\uDDF2":"1f1fa-1f1f2","\uD83C\uDDEE\uD83C\uDDE8":"1f1ee-1f1e8","\uD83C\uDDEA\uD83C\uDDE6":"1f1ea-1f1e6","\uD83C\uDDE8\uD83C\uDDF5":"1f1e8-1f1f5","\uD83C\uDDE9\uD83C\uDDEC":"1f1e9-1f1ec","\uD83C\uDDE6\uD83C\uDDF8":"1f1e6-1f1f8","\uD83C\uDDE6\uD83C\uDDF6":"1f1e6-1f1f6","\uD83C\uDDFB\uD83C\uDDEC":"1f1fb-1f1ec","\uD83C\uDDE8\uD83C\uDDF0":"1f1e8-1f1f0","\uD83C\uDDE8\uD83C\uDDFC":"1f1e8-1f1fc","\uD83C\uDDEA\uD83C\uDDFA":"1f1ea-1f1fa","\uD83C\uDDEC\uD83C\uDDEB":"1f1ec-1f1eb","\uD83C\uDDF9\uD83C\uDDEB":"1f1f9-1f1eb","\uD83C\uDDEC\uD83C\uDDF5":"1f1ec-1f1f5","\uD83C\uDDF2\uD83C\uDDF6":"1f1f2-1f1f6","\uD83C\uDDF2\uD83C\uDDF5":"1f1f2-1f1f5","\uD83C\uDDF7\uD83C\uDDEA":"1f1f7-1f1ea","\uD83C\uDDF8\uD83C\uDDFD":"1f1f8-1f1fd","\uD83C\uDDF8\uD83C\uDDF8":"1f1f8-1f1f8","\uD83C\uDDF9\uD83C\uDDE8":"1f1f9-1f1e8","\uD83C\uDDF2\uD83C\uDDEB":"1f1f2-1f1eb","\uD83D\uDD75\uD83C\uDFFB":"1f575-1f3fb","\uD83D\uDD75\uD83C\uDFFC":"1f575-1f3fc","\uD83D\uDD75\uD83C\uDFFD":"1f575-1f3fd","\uD83D\uDD75\uD83C\uDFFE":"1f575-1f3fe","\uD83D\uDD75\uD83C\uDFFF":"1f575-1f3ff","\uD83C\uDFC2\uD83C\uDFFB":"1f3c2-1f3fb","\uD83D\uDC68\uD83D\uDCBB":"1f468-1f4bb","\uD83D\uDC69\uD83D\uDCBB":"1f469-1f4bb","\uD83D\uDC68\uD83C\uDFEB":"1f468-1f3eb","\uD83D\uDC69\uD83C\uDFEB":"1f469-1f3eb","\uD83D\uDC68\uD83C\uDF93":"1f468-1f393","\uD83D\uDC69\uD83C\uDF93":"1f469-1f393","\uD83D\uDC68\uD83C\uDFA4":"1f468-1f3a4","\uD83D\uDC69\uD83C\uDFA4":"1f469-1f3a4","\uD83D\uDC68\uD83D\uDD2C":"1f468-1f52c","\uD83D\uDC69\uD83D\uDD2C":"1f469-1f52c","\uD83D\uDC68\uD83D\uDCBC":"1f468-1f4bc","\uD83D\uDC69\uD83D\uDCBC":"1f469-1f4bc","\uD83D\uDC68\uD83D\uDD27":"1f468-1f527","\uD83D\uDC69\uD83D\uDD27":"1f469-1f527","\uD83D\uDC68\uD83C\uDFED":"1f468-1f3ed","\uD83D\uDC69\uD83C\uDFED":"1f469-1f3ed","\uD83D\uDC68\uD83C\uDF73":"1f468-1f373","\uD83D\uDC69\uD83C\uDF73":"1f469-1f373","\uD83D\uDC68\uD83C\uDF3E":"1f468-1f33e","\uD83D\uDC69\uD83C\uDF3E":"1f469-1f33e","\uD83D\uDD74\uD83C\uDFFB":"1f574-1f3fb","\uD83D\uDD74\uD83C\uDFFC":"1f574-1f3fc","\uD83D\uDD74\uD83C\uDFFD":"1f574-1f3fd","\uD83D\uDD74\uD83C\uDFFE":"1f574-1f3fe","\uD83D\uDD74\uD83C\uDFFF":"1f574-1f3ff","\uD83D\uDECC\uD83C\uDFFB":"1f6cc-1f3fb","\uD83D\uDECC\uD83C\uDFFC":"1f6cc-1f3fc","\uD83D\uDECC\uD83C\uDFFD":"1f6cc-1f3fd","\uD83D\uDECC\uD83C\uDFFE":"1f6cc-1f3fe","\uD83D\uDECC\uD83C\uDFFF":"1f6cc-1f3ff","\uD83D\uDC68\uD83D\uDC66":"1f468-1f466","\uD83D\uDC68\uD83D\uDC67":"1f468-1f467","\uD83D\uDC69\uD83D\uDC66":"1f469-1f466","\uD83D\uDC69\uD83D\uDC67":"1f469-1f467","\uD83D\uDC68\uD83C\uDFA8":"1f468-1f3a8","\uD83D\uDC69\uD83C\uDFA8":"1f469-1f3a8","\uD83D\uDC68\uD83D\uDE80":"1f468-1f680","\uD83D\uDC69\uD83D\uDE80":"1f469-1f680","\uD83D\uDC68\uD83D\uDE92":"1f468-1f692","\uD83D\uDC69\uD83D\uDE92":"1f469-1f692","\uD83C\uDDFA\uD83C\uDDF3":"1f1fa-1f1f3","\uD83C\uDFC2\uD83C\uDFFC":"1f3c2-1f3fc","\uD83C\uDFC2\uD83C\uDFFD":"1f3c2-1f3fd","\uD83C\uDFC2\uD83C\uDFFE":"1f3c2-1f3fe","\uD83C\uDFC2\uD83C\uDFFF":"1f3c2-1f3ff","\uD83C\uDFCC\uD83C\uDFFB":"1f3cc-1f3fb","\uD83C\uDFCC\uD83C\uDFFC":"1f3cc-1f3fc","\uD83C\uDFCC\uD83C\uDFFD":"1f3cc-1f3fd","\uD83C\uDFCC\uD83C\uDFFE":"1f3cc-1f3fe","\uD83C\uDFCC\uD83C\uDFFF":"1f3cc-1f3ff","\uD83E\uDD1F\uD83C\uDFFB":"1f91f-1f3fb","\uD83E\uDD1F\uD83C\uDFFC":"1f91f-1f3fc","\uD83E\uDD1F\uD83C\uDFFD":"1f91f-1f3fd","\uD83E\uDD1F\uD83C\uDFFE":"1f91f-1f3fe","\uD83E\uDD1F\uD83C\uDFFF":"1f91f-1f3ff","\uD83E\uDD31\uD83C\uDFFB":"1f931-1f3fb","\uD83E\uDD31\uD83C\uDFFC":"1f931-1f3fc","\uD83E\uDD31\uD83C\uDFFD":"1f931-1f3fd","\uD83E\uDD31\uD83C\uDFFE":"1f931-1f3fe","\uD83E\uDD31\uD83C\uDFFF":"1f931-1f3ff","\uD83E\uDD32\uD83C\uDFFB":"1f932-1f3fb","\uD83E\uDD32\uD83C\uDFFC":"1f932-1f3fc","\uD83E\uDD32\uD83C\uDFFD":"1f932-1f3fd","\uD83E\uDD32\uD83C\uDFFE":"1f932-1f3fe","\uD83E\uDD32\uD83C\uDFFF":"1f932-1f3ff","\uD83E\uDDD1\uD83C\uDFFB":"1f9d1-1f3fb","\uD83E\uDDD1\uD83C\uDFFC":"1f9d1-1f3fc","\uD83E\uDDD1\uD83C\uDFFD":"1f9d1-1f3fd","\uD83E\uDDD1\uD83C\uDFFE":"1f9d1-1f3fe","\uD83E\uDDD1\uD83C\uDFFF":"1f9d1-1f3ff","\uD83E\uDDD2\uD83C\uDFFB":"1f9d2-1f3fb","\uD83E\uDDD2\uD83C\uDFFC":"1f9d2-1f3fc","\uD83E\uDDD2\uD83C\uDFFD":"1f9d2-1f3fd","\uD83E\uDDD2\uD83C\uDFFE":"1f9d2-1f3fe","\uD83E\uDDD2\uD83C\uDFFF":"1f9d2-1f3ff","\uD83E\uDDD3\uD83C\uDFFB":"1f9d3-1f3fb","\uD83E\uDDD3\uD83C\uDFFC":"1f9d3-1f3fc","\uD83E\uDDD3\uD83C\uDFFD":"1f9d3-1f3fd","\uD83E\uDDD3\uD83C\uDFFE":"1f9d3-1f3fe","\uD83E\uDDD3\uD83C\uDFFF":"1f9d3-1f3ff","\uD83E\uDDD4\uD83C\uDFFB":"1f9d4-1f3fb","\uD83E\uDDD4\uD83C\uDFFC":"1f9d4-1f3fc","\uD83E\uDDD4\uD83C\uDFFD":"1f9d4-1f3fd","\uD83E\uDDD4\uD83C\uDFFE":"1f9d4-1f3fe","\uD83E\uDDD4\uD83C\uDFFF":"1f9d4-1f3ff","\uD83E\uDDD5\uD83C\uDFFB":"1f9d5-1f3fb","\uD83E\uDDD5\uD83C\uDFFC":"1f9d5-1f3fc","\uD83E\uDDD5\uD83C\uDFFD":"1f9d5-1f3fd","\uD83E\uDDD5\uD83C\uDFFE":"1f9d5-1f3fe","\uD83E\uDDD5\uD83C\uDFFF":"1f9d5-1f3ff","\uD83E\uDDD6\uD83C\uDFFB":"1f9d6-1f3fb","\uD83E\uDDD6\uD83C\uDFFC":"1f9d6-1f3fc","\uD83E\uDDD6\uD83C\uDFFD":"1f9d6-1f3fd","\uD83E\uDDD6\uD83C\uDFFE":"1f9d6-1f3fe","\uD83E\uDDD6\uD83C\uDFFF":"1f9d6-1f3ff","\uD83E\uDDD7\uD83C\uDFFB":"1f9d7-1f3fb","\uD83E\uDDD7\uD83C\uDFFC":"1f9d7-1f3fc","\uD83E\uDDD7\uD83C\uDFFD":"1f9d7-1f3fd","\uD83E\uDDD7\uD83C\uDFFE":"1f9d7-1f3fe","\uD83E\uDDD7\uD83C\uDFFF":"1f9d7-1f3ff","\uD83E\uDDD8\uD83C\uDFFB":"1f9d8-1f3fb","\uD83E\uDDD8\uD83C\uDFFC":"1f9d8-1f3fc","\uD83E\uDDD8\uD83C\uDFFD":"1f9d8-1f3fd","\uD83E\uDDD8\uD83C\uDFFE":"1f9d8-1f3fe","\uD83E\uDDD8\uD83C\uDFFF":"1f9d8-1f3ff","\uD83E\uDDD9\uD83C\uDFFB":"1f9d9-1f3fb","\uD83E\uDDD9\uD83C\uDFFC":"1f9d9-1f3fc","\uD83E\uDDD9\uD83C\uDFFD":"1f9d9-1f3fd","\uD83E\uDDD9\uD83C\uDFFE":"1f9d9-1f3fe","\uD83E\uDDD9\uD83C\uDFFF":"1f9d9-1f3ff","\uD83E\uDDDA\uD83C\uDFFB":"1f9da-1f3fb","\uD83E\uDDDA\uD83C\uDFFC":"1f9da-1f3fc","\uD83E\uDDDA\uD83C\uDFFD":"1f9da-1f3fd","\uD83E\uDDDA\uD83C\uDFFE":"1f9da-1f3fe","\uD83E\uDDDA\uD83C\uDFFF":"1f9da-1f3ff","\uD83E\uDDDB\uD83C\uDFFB":"1f9db-1f3fb","\uD83E\uDDDB\uD83C\uDFFC":"1f9db-1f3fc","\uD83E\uDDDB\uD83C\uDFFD":"1f9db-1f3fd","\uD83E\uDDDB\uD83C\uDFFE":"1f9db-1f3fe","\uD83E\uDDDB\uD83C\uDFFF":"1f9db-1f3ff","\uD83E\uDDDC\uD83C\uDFFB":"1f9dc-1f3fb","\uD83E\uDDDC\uD83C\uDFFC":"1f9dc-1f3fc","\uD83E\uDDDC\uD83C\uDFFD":"1f9dc-1f3fd","\uD83E\uDDDC\uD83C\uDFFE":"1f9dc-1f3fe","\uD83E\uDDDC\uD83C\uDFFF":"1f9dc-1f3ff","\uD83E\uDDDD\uD83C\uDFFB":"1f9dd-1f3fb","\uD83E\uDDDD\uD83C\uDFFC":"1f9dd-1f3fc","\uD83E\uDDDD\uD83C\uDFFD":"1f9dd-1f3fd","\uD83E\uDDDD\uD83C\uDFFE":"1f9dd-1f3fe","\uD83E\uDDDD\uD83C\uDFFF":"1f9dd-1f3ff","\uD83C\uDD7F\uFE0F":"1f17f","\uD83C\uDE02\uFE0F":"1f202","\uD83C\uDE37\uFE0F":"1f237","\uD83C\uDF9E\uFE0F":"1f39e","\uD83C\uDF9F\uFE0F":"1f39f","\uD83C\uDFCB\uFE0F":"1f3cb","\uD83C\uDFCC\uFE0F":"1f3cc","\uD83C\uDFCD\uFE0F":"1f3cd","\uD83C\uDFCE\uFE0F":"1f3ce","\uD83C\uDF96\uFE0F":"1f396","\uD83C\uDF97\uFE0F":"1f397","\uD83C\uDF36\uFE0F":"1f336","\uD83C\uDF27\uFE0F":"1f327","\uD83C\uDF28\uFE0F":"1f328","\uD83C\uDF29\uFE0F":"1f329","\uD83C\uDF2A\uFE0F":"1f32a","\uD83C\uDF2B\uFE0F":"1f32b","\uD83C\uDF2C\uFE0F":"1f32c","\uD83D\uDC3F\uFE0F":"1f43f","\uD83D\uDD77\uFE0F":"1f577","\uD83D\uDD78\uFE0F":"1f578","\uD83C\uDF21\uFE0F":"1f321","\uD83C\uDF99\uFE0F":"1f399","\uD83C\uDF9A\uFE0F":"1f39a","\uD83C\uDF9B\uFE0F":"1f39b","\uD83C\uDFF3\uFE0F":"1f3f3","\uD83C\uDFF5\uFE0F":"1f3f5","\uD83C\uDFF7\uFE0F":"1f3f7","\uD83D\uDCFD\uFE0F":"1f4fd","\uD83D\uDD49\uFE0F":"1f549","\uD83D\uDD4A\uFE0F":"1f54a","\uD83D\uDD6F\uFE0F":"1f56f","\uD83D\uDD70\uFE0F":"1f570","\uD83D\uDD73\uFE0F":"1f573","\uD83D\uDD76\uFE0F":"1f576","\uD83D\uDD79\uFE0F":"1f579","\uD83D\uDD87\uFE0F":"1f587","\uD83D\uDD8A\uFE0F":"1f58a","\uD83D\uDD8B\uFE0F":"1f58b","\uD83D\uDD8C\uFE0F":"1f58c","\uD83D\uDD8D\uFE0F":"1f58d","\uD83D\uDDA5\uFE0F":"1f5a5","\uD83D\uDDA8\uFE0F":"1f5a8","\uD83D\uDDB2\uFE0F":"1f5b2","\uD83D\uDDBC\uFE0F":"1f5bc","\uD83D\uDDC2\uFE0F":"1f5c2","\uD83D\uDDC3\uFE0F":"1f5c3","\uD83D\uDDC4\uFE0F":"1f5c4","\uD83D\uDDD1\uFE0F":"1f5d1","\uD83D\uDDD2\uFE0F":"1f5d2","\uD83D\uDDD3\uFE0F":"1f5d3","\uD83D\uDDDC\uFE0F":"1f5dc","\uD83D\uDDDD\uFE0F":"1f5dd","\uD83D\uDDDE\uFE0F":"1f5de","\uD83D\uDDE1\uFE0F":"1f5e1","\uD83D\uDDE3\uFE0F":"1f5e3","\uD83D\uDDE8\uFE0F":"1f5e8","\uD83D\uDDEF\uFE0F":"1f5ef","\uD83D\uDDF3\uFE0F":"1f5f3","\uD83D\uDDFA\uFE0F":"1f5fa","\uD83D\uDEE0\uFE0F":"1f6e0","\uD83D\uDEE1\uFE0F":"1f6e1","\uD83D\uDEE2\uFE0F":"1f6e2","\uD83D\uDEF0\uFE0F":"1f6f0","\uD83C\uDF7D\uFE0F":"1f37d","\uD83D\uDC41\uFE0F":"1f441","\uD83D\uDD74\uFE0F":"1f574","\uD83D\uDD75\uFE0F":"1f575","\uD83D\uDD90\uFE0F":"1f590","\uD83C\uDFD4\uFE0F":"1f3d4","\uD83C\uDFD5\uFE0F":"1f3d5","\uD83C\uDFD6\uFE0F":"1f3d6","\uD83C\uDFD7\uFE0F":"1f3d7","\uD83C\uDFD8\uFE0F":"1f3d8","\uD83C\uDFD9\uFE0F":"1f3d9","\uD83C\uDFDA\uFE0F":"1f3da","\uD83C\uDFDB\uFE0F":"1f3db","\uD83C\uDFDC\uFE0F":"1f3dc","\uD83C\uDFDD\uFE0F":"1f3dd","\uD83C\uDFDE\uFE0F":"1f3de","\uD83C\uDFDF\uFE0F":"1f3df","\uD83D\uDECB\uFE0F":"1f6cb","\uD83D\uDECD\uFE0F":"1f6cd","\uD83D\uDECE\uFE0F":"1f6ce","\uD83D\uDECF\uFE0F":"1f6cf","\uD83D\uDEE3\uFE0F":"1f6e3","\uD83D\uDEE4\uFE0F":"1f6e4","\uD83D\uDEE5\uFE0F":"1f6e5","\uD83D\uDEE9\uFE0F":"1f6e9","\uD83D\uDEF3\uFE0F":"1f6f3","\u261D\uD83C\uDFFB":"261d-1f3fb","\u261D\uD83C\uDFFC":"261d-1f3fc","\u261D\uD83C\uDFFD":"261d-1f3fd","\u261D\uD83C\uDFFE":"261d-1f3fe","\u261D\uD83C\uDFFF":"261d-1f3ff","\u270C\uD83C\uDFFB":"270c-1f3fb","\u270C\uD83C\uDFFC":"270c-1f3fc","\u270C\uD83C\uDFFD":"270c-1f3fd","\u270C\uD83C\uDFFE":"270c-1f3fe","\u270C\uD83C\uDFFF":"270c-1f3ff","\u270A\uD83C\uDFFB":"270a-1f3fb","\u270A\uD83C\uDFFC":"270a-1f3fc","\u270A\uD83C\uDFFD":"270a-1f3fd","\u270A\uD83C\uDFFE":"270a-1f3fe","\u270A\uD83C\uDFFF":"270a-1f3ff","\u270B\uD83C\uDFFB":"270b-1f3fb","\u270B\uD83C\uDFFC":"270b-1f3fc","\u270B\uD83C\uDFFD":"270b-1f3fd","\u270B\uD83C\uDFFE":"270b-1f3fe","\u270B\uD83C\uDFFF":"270b-1f3ff","\u270D\uD83C\uDFFB":"270d-1f3fb","\u270D\uD83C\uDFFC":"270d-1f3fc","\u270D\uD83C\uDFFD":"270d-1f3fd","\u270D\uD83C\uDFFE":"270d-1f3fe","\u270D\uD83C\uDFFF":"270d-1f3ff","\uD83C\uDF24\uFE0F":"1f324","\uD83C\uDF25\uFE0F":"1f325","\uD83C\uDF26\uFE0F":"1f326","\uD83D\uDDB1\uFE0F":"1f5b1","\u26F9\uD83C\uDFFB":"26f9-1f3fb","\u26F9\uD83C\uDFFC":"26f9-1f3fc","\u26F9\uD83C\uDFFD":"26f9-1f3fd","\u26F9\uD83C\uDFFE":"26f9-1f3fe","\u26F9\uD83C\uDFFF":"26f9-1f3ff","\uD83C\uDD70\uFE0F":"1f170","\uD83C\uDD71\uFE0F":"1f171","\uD83C\uDD7E\uFE0F":"1f17e","\uD83C\uDC04\uFE0F":"1f004","\uD83C\uDE1A\uFE0F":"1f21a","\uD83C\uDE2F\uFE0F":"1f22f","\uD83C\uDF0D\uFE0F":"1f30d","\uD83C\uDF0E\uFE0F":"1f30e","\uD83C\uDF0F\uFE0F":"1f30f","\uD83C\uDF15\uFE0F":"1f315","\uD83C\uDF1C\uFE0F":"1f31c","\uD83C\uDF78\uFE0F":"1f378","\uD83C\uDF93\uFE0F":"1f393","\uD83C\uDFA7\uFE0F":"1f3a7","\uD83C\uDFAC\uFE0F":"1f3ac","\uD83C\uDFAD\uFE0F":"1f3ad","\uD83C\uDFAE\uFE0F":"1f3ae","\uD83C\uDFC2\uFE0F":"1f3c2","\uD83C\uDFC4\uFE0F":"1f3c4","\uD83C\uDFC6\uFE0F":"1f3c6","\uD83C\uDFCA\uFE0F":"1f3ca","\uD83C\uDFE0\uFE0F":"1f3e0","\uD83C\uDFED\uFE0F":"1f3ed","\uD83D\uDC08\uFE0F":"1f408","\uD83D\uDC15\uFE0F":"1f415","\uD83D\uDC1F\uFE0F":"1f41f","\uD83D\uDC26\uFE0F":"1f426","\uD83D\uDC42\uFE0F":"1f442","\uD83D\uDC46\uFE0F":"1f446","\uD83D\uDC47\uFE0F":"1f447","\uD83D\uDC48\uFE0F":"1f448","\uD83D\uDC49\uFE0F":"1f449","\uD83D\uDC4D\uFE0F":"1f44d","\uD83D\uDC4E\uFE0F":"1f44e","\uD83D\uDC53\uFE0F":"1f453","\uD83D\uDC6A\uFE0F":"1f46a","\uD83D\uDC7D\uFE0F":"1f47d","\uD83D\uDCA3\uFE0F":"1f4a3","\uD83D\uDCB0\uFE0F":"1f4b0","\uD83D\uDCB3\uFE0F":"1f4b3","\uD83D\uDCBB\uFE0F":"1f4bb","\uD83D\uDCBF\uFE0F":"1f4bf","\uD83D\uDCCB\uFE0F":"1f4cb","\uD83D\uDCDA\uFE0F":"1f4da","\uD83D\uDCDF\uFE0F":"1f4df","\uD83D\uDCE4\uFE0F":"1f4e4","\uD83D\uDCE5\uFE0F":"1f4e5","\uD83D\uDCE6\uFE0F":"1f4e6","\uD83D\uDCEA\uFE0F":"1f4ea","\uD83D\uDCEB\uFE0F":"1f4eb","\uD83D\uDCEC\uFE0F":"1f4ec","\uD83D\uDCED\uFE0F":"1f4ed","\uD83D\uDCF7\uFE0F":"1f4f7","\uD83D\uDCF9\uFE0F":"1f4f9","\uD83D\uDCFA\uFE0F":"1f4fa","\uD83D\uDCFB\uFE0F":"1f4fb","\uD83D\uDD08\uFE0F":"1f508","\uD83D\uDD0D\uFE0F":"1f50d","\uD83D\uDD12\uFE0F":"1f512","\uD83D\uDD13\uFE0F":"1f513","\uD83D\uDD50\uFE0F":"1f550","\uD83D\uDD51\uFE0F":"1f551","\uD83D\uDD52\uFE0F":"1f552","\uD83D\uDD53\uFE0F":"1f553","\uD83D\uDD54\uFE0F":"1f554","\uD83D\uDD55\uFE0F":"1f555","\uD83D\uDD56\uFE0F":"1f556","\uD83D\uDD57\uFE0F":"1f557","\uD83D\uDD58\uFE0F":"1f558","\uD83D\uDD59\uFE0F":"1f559","\uD83D\uDD5A\uFE0F":"1f55a","\uD83D\uDD5B\uFE0F":"1f55b","\uD83D\uDD5C\uFE0F":"1f55c","\uD83D\uDD5D\uFE0F":"1f55d","\uD83D\uDD5E\uFE0F":"1f55e","\uD83D\uDD5F\uFE0F":"1f55f","\uD83D\uDD60\uFE0F":"1f560","\uD83D\uDD61\uFE0F":"1f561","\uD83D\uDD62\uFE0F":"1f562","\uD83D\uDD63\uFE0F":"1f563","\uD83D\uDD64\uFE0F":"1f564","\uD83D\uDD65\uFE0F":"1f565","\uD83D\uDD66\uFE0F":"1f566","\uD83D\uDD67\uFE0F":"1f567","\uD83D\uDE10\uFE0F":"1f610","\uD83D\uDE87\uFE0F":"1f687","\uD83D\uDE8D\uFE0F":"1f68d","\uD83D\uDE91\uFE0F":"1f691","\uD83D\uDE94\uFE0F":"1f694","\uD83D\uDE98\uFE0F":"1f698","\uD83D\uDEAD\uFE0F":"1f6ad","\uD83D\uDEB2\uFE0F":"1f6b2","\uD83D\uDEB9\uFE0F":"1f6b9","\uD83D\uDEBA\uFE0F":"1f6ba","\uD83D\uDEBC\uFE0F":"1f6bc","#\u20E3":"0023-20e3","0\u20E3":"0030-20e3","1\u20E3":"0031-20e3","2\u20E3":"0032-20e3","3\u20E3":"0033-20e3","4\u20E3":"0034-20e3","5\u20E3":"0035-20e3","6\u20E3":"0036-20e3","7\u20E3":"0037-20e3","8\u20E3":"0038-20e3","9\u20E3":"0039-20e3","\u00A9\uFE0F":"00a9","\u00AE\uFE0F":"00ae","\u203C\uFE0F":"203c","\u2049\uFE0F":"2049","\u2122\uFE0F":"2122","\u2139\uFE0F":"2139","\u2194\uFE0F":"2194","\u2195\uFE0F":"2195","\u2196\uFE0F":"2196","\u2197\uFE0F":"2197","\u2198\uFE0F":"2198","\u2199\uFE0F":"2199","\u21A9\uFE0F":"21a9","\u21AA\uFE0F":"21aa","\u24C2\uFE0F":"24c2","\u25AA\uFE0F":"25aa","\u25AB\uFE0F":"25ab","\u25B6\uFE0F":"25b6","\u25C0\uFE0F":"25c0","\u25FB\uFE0F":"25fb","\u25FC\uFE0F":"25fc","\u2600\uFE0F":"2600","\u2601\uFE0F":"2601","\u260E\uFE0F":"260e","\u2611\uFE0F":"2611","\u261D\uFE0F":"261d","\u263A\uFE0F":"263a","\u2660\uFE0F":"2660","\u2663\uFE0F":"2663","\u2665\uFE0F":"2665","\u2666\uFE0F":"2666","\u2668\uFE0F":"2668","\u267B\uFE0F":"267b","\u26A0\uFE0F":"26a0","\u2702\uFE0F":"2702","\u2708\uFE0F":"2708","\u2709\uFE0F":"2709","\u270C\uFE0F":"270c","\u270F\uFE0F":"270f","\u2712\uFE0F":"2712","\u2714\uFE0F":"2714","\u2716\uFE0F":"2716","\u2733\uFE0F":"2733","\u2734\uFE0F":"2734","\u2744\uFE0F":"2744","\u2747\uFE0F":"2747","\u2764\uFE0F":"2764","\u27A1\uFE0F":"27a1","\u2934\uFE0F":"2934","\u2935\uFE0F":"2935","\u2B05\uFE0F":"2b05","\u2B06\uFE0F":"2b06","\u2B07\uFE0F":"2b07","\u3030\uFE0F":"3030","\u303D\uFE0F":"303d","\u3297\uFE0F":"3297","\u3299\uFE0F":"3299","\u271D\uFE0F":"271d","\u2328\uFE0F":"2328","\u270D\uFE0F":"270d","*\u20E3":"002a-20e3","\u23CF\uFE0F":"23cf","\u23ED\uFE0F":"23ed","\u23EE\uFE0F":"23ee","\u23EF\uFE0F":"23ef","\u23F1\uFE0F":"23f1","\u23F2\uFE0F":"23f2","\u23F8\uFE0F":"23f8","\u23F9\uFE0F":"23f9","\u23FA\uFE0F":"23fa","\u2602\uFE0F":"2602","\u2603\uFE0F":"2603","\u2604\uFE0F":"2604","\u2618\uFE0F":"2618","\u2620\uFE0F":"2620","\u2622\uFE0F":"2622","\u2623\uFE0F":"2623","\u2626\uFE0F":"2626","\u262A\uFE0F":"262a","\u262E\uFE0F":"262e","\u262F\uFE0F":"262f","\u2638\uFE0F":"2638","\u2639\uFE0F":"2639","\u2692\uFE0F":"2692","\u2694\uFE0F":"2694","\u2696\uFE0F":"2696","\u2697\uFE0F":"2697","\u2699\uFE0F":"2699","\u269B\uFE0F":"269b","\u269C\uFE0F":"269c","\u26B0\uFE0F":"26b0","\u26B1\uFE0F":"26b1","\u26C8\uFE0F":"26c8","\u26CF\uFE0F":"26cf","\u26D1\uFE0F":"26d1","\u26D3\uFE0F":"26d3","\u26E9\uFE0F":"26e9","\u26F0\uFE0F":"26f0","\u26F1\uFE0F":"26f1","\u26F4\uFE0F":"26f4","\u26F7\uFE0F":"26f7","\u26F8\uFE0F":"26f8","\u26F9\uFE0F":"26f9","\u2721\uFE0F":"2721","\u2763\uFE0F":"2763","#\uFE0F":"0023","*\uFE0F":"002a","0\uFE0F":"0030","1\uFE0F":"0031","2\uFE0F":"0032","3\uFE0F":"0033","4\uFE0F":"0034","5\uFE0F":"0035","6\uFE0F":"0036","7\uFE0F":"0037","8\uFE0F":"0038","9\uFE0F":"0039","\u2640\uFE0F":"2640","\u2642\uFE0F":"2642","\u2695\uFE0F":"2695","\u231A\uFE0F":"231a","\u231B\uFE0F":"231b","\u23E9\uFE0F":"23e9","\u23EA\uFE0F":"23ea","\u23F3\uFE0F":"23f3","\u25FD\uFE0F":"25fd","\u25FE\uFE0F":"25fe","\u2614\uFE0F":"2614","\u2615\uFE0F":"2615","\u2648\uFE0F":"2648","\u2649\uFE0F":"2649","\u264A\uFE0F":"264a","\u264B\uFE0F":"264b","\u264C\uFE0F":"264c","\u264D\uFE0F":"264d","\u264E\uFE0F":"264e","\u264F\uFE0F":"264f","\u2650\uFE0F":"2650","\u2651\uFE0F":"2651","\u2652\uFE0F":"2652","\u2653\uFE0F":"2653","\u267F\uFE0F":"267f","\u2693\uFE0F":"2693","\u26A1\uFE0F":"26a1","\u26AA\uFE0F":"26aa","\u26AB\uFE0F":"26ab","\u26BD\uFE0F":"26bd","\u26BE\uFE0F":"26be","\u26C4\uFE0F":"26c4","\u26C5\uFE0F":"26c5","\u26D4\uFE0F":"26d4","\u26EA\uFE0F":"26ea","\u26F2\uFE0F":"26f2","\u26F3\uFE0F":"26f3","\u26F5\uFE0F":"26f5","\u26FA\uFE0F":"26fa","\u26FD\uFE0F":"26fd","\u2753\uFE0F":"2753","\u2757\uFE0F":"2757","\u2B1B\uFE0F":"2b1b","\u2B1C\uFE0F":"2b1c","\u2B50\uFE0F":"2b50","\u2B55\uFE0F":"2b55","\uD83E\uDD49":"1f949","\uD83E\uDD48":"1f948","\uD83E\uDD47":"1f947","\uD83E\uDD3A":"1f93a","\uD83E\uDD45":"1f945","\uD83E\uDD3E":"1f93e","\uD83C\uDDFF":"1f1ff","\uD83E\uDD3D":"1f93d","\uD83E\uDD4B":"1f94b","\uD83E\uDD4A":"1f94a","\uD83E\uDD3C":"1f93c","\uD83E\uDD39":"1f939","\uD83E\uDD38":"1f938","\uD83D\uDEF6":"1f6f6","\uD83D\uDEF5":"1f6f5","\uD83D\uDEF4":"1f6f4","\uD83D\uDED2":"1f6d2","\uD83C\uDC04":"1f004","\uD83C\uDCCF":"1f0cf","\uD83C\uDD70":"1f170","\uD83C\uDD71":"1f171","\uD83C\uDD7E":"1f17e","\uD83C\uDD7F":"1f17f","\uD83D\uDED1":"1f6d1","\uD83C\uDD8E":"1f18e","\uD83C\uDD91":"1f191","\uD83C\uDDFE":"1f1fe","\uD83C\uDD92":"1f192","\uD83C\uDD93":"1f193","\uD83C\uDD94":"1f194","\uD83C\uDD95":"1f195","\uD83C\uDD96":"1f196","\uD83C\uDD97":"1f197","\uD83C\uDD98":"1f198","\uD83E\uDD44":"1f944","\uD83C\uDD99":"1f199","\uD83C\uDD9A":"1f19a","\uD83E\uDD42":"1f942","\uD83E\uDD43":"1f943","\uD83C\uDE01":"1f201","\uD83C\uDE02":"1f202","\uD83C\uDE1A":"1f21a","\uD83C\uDE2F":"1f22f","\uD83E\uDD59":"1f959","\uD83C\uDE32":"1f232","\uD83C\uDE33":"1f233","\uD83C\uDE34":"1f234","\uD83C\uDE35":"1f235","\uD83C\uDE36":"1f236","\uD83E\uDD58":"1f958","\uD83C\uDE37":"1f237","\uD83C\uDE38":"1f238","\uD83C\uDE39":"1f239","\uD83E\uDD57":"1f957","\uD83C\uDE3A":"1f23a","\uD83C\uDE50":"1f250","\uD83C\uDE51":"1f251","\uD83C\uDF00":"1f300","\uD83E\uDD56":"1f956","\uD83C\uDF01":"1f301","\uD83C\uDF02":"1f302","\uD83C\uDF03":"1f303","\uD83C\uDF04":"1f304","\uD83C\uDF05":"1f305","\uD83C\uDF06":"1f306","\uD83E\uDD55":"1f955","\uD83C\uDF07":"1f307","\uD83C\uDF08":"1f308","\uD83E\uDD54":"1f954","\uD83C\uDF09":"1f309","\uD83C\uDF0A":"1f30a","\uD83C\uDF0B":"1f30b","\uD83C\uDF0C":"1f30c","\uD83C\uDF0F":"1f30f","\uD83C\uDF11":"1f311","\uD83E\uDD53":"1f953","\uD83C\uDF13":"1f313","\uD83C\uDF14":"1f314","\uD83C\uDF15":"1f315","\uD83C\uDF19":"1f319","\uD83C\uDF1B":"1f31b","\uD83C\uDF1F":"1f31f","\uD83E\uDD52":"1f952","\uD83C\uDF20":"1f320","\uD83C\uDF30":"1f330","\uD83E\uDD51":"1f951","\uD83C\uDF31":"1f331","\uD83C\uDF34":"1f334","\uD83C\uDF35":"1f335","\uD83C\uDF37":"1f337","\uD83C\uDF38":"1f338","\uD83C\uDF39":"1f339","\uD83C\uDF3A":"1f33a","\uD83C\uDF3B":"1f33b","\uD83C\uDF3C":"1f33c","\uD83C\uDF3D":"1f33d","\uD83E\uDD50":"1f950","\uD83C\uDF3E":"1f33e","\uD83C\uDF3F":"1f33f","\uD83C\uDF40":"1f340","\uD83C\uDF41":"1f341","\uD83C\uDF42":"1f342","\uD83C\uDF43":"1f343","\uD83C\uDF44":"1f344","\uD83C\uDF45":"1f345","\uD83C\uDF46":"1f346","\uD83C\uDF47":"1f347","\uD83C\uDF48":"1f348","\uD83C\uDF49":"1f349","\uD83C\uDF4A":"1f34a","\uD83E\uDD40":"1f940","\uD83C\uDF4C":"1f34c","\uD83C\uDF4D":"1f34d","\uD83C\uDF4E":"1f34e","\uD83C\uDF4F":"1f34f","\uD83C\uDF51":"1f351","\uD83C\uDF52":"1f352","\uD83C\uDF53":"1f353","\uD83E\uDD8F":"1f98f","\uD83C\uDF54":"1f354","\uD83C\uDF55":"1f355","\uD83C\uDF56":"1f356","\uD83E\uDD8E":"1f98e","\uD83C\uDF57":"1f357","\uD83C\uDF58":"1f358","\uD83C\uDF59":"1f359","\uD83E\uDD8D":"1f98d","\uD83C\uDF5A":"1f35a","\uD83C\uDF5B":"1f35b","\uD83E\uDD8C":"1f98c","\uD83C\uDF5C":"1f35c","\uD83C\uDF5D":"1f35d","\uD83C\uDF5E":"1f35e","\uD83C\uDF5F":"1f35f","\uD83E\uDD8B":"1f98b","\uD83C\uDF60":"1f360","\uD83C\uDF61":"1f361","\uD83E\uDD8A":"1f98a","\uD83C\uDF62":"1f362","\uD83C\uDF63":"1f363","\uD83E\uDD89":"1f989","\uD83C\uDF64":"1f364","\uD83C\uDF65":"1f365","\uD83E\uDD88":"1f988","\uD83C\uDF66":"1f366","\uD83E\uDD87":"1f987","\uD83C\uDF67":"1f367","\uD83C\uDDFD":"1f1fd","\uD83C\uDF68":"1f368","\uD83E\uDD86":"1f986","\uD83C\uDF69":"1f369","\uD83E\uDD85":"1f985","\uD83C\uDF6A":"1f36a","\uD83D\uDDA4":"1f5a4","\uD83C\uDF6B":"1f36b","\uD83C\uDF6C":"1f36c","\uD83C\uDF6D":"1f36d","\uD83C\uDF6E":"1f36e","\uD83C\uDF6F":"1f36f","\uD83E\uDD1E":"1f91e","\uD83C\uDF70":"1f370","\uD83C\uDF71":"1f371","\uD83C\uDF72":"1f372","\uD83E\uDD1D":"1f91d","\uD83C\uDF73":"1f373","\uD83C\uDF74":"1f374","\uD83C\uDF75":"1f375","\uD83C\uDF76":"1f376","\uD83C\uDF77":"1f377","\uD83C\uDF78":"1f378","\uD83C\uDF79":"1f379","\uD83C\uDF7A":"1f37a","\uD83C\uDF7B":"1f37b","\uD83C\uDF80":"1f380","\uD83C\uDF81":"1f381","\uD83C\uDF82":"1f382","\uD83C\uDF83":"1f383","\uD83E\uDD1B":"1f91b","\uD83E\uDD1C":"1f91c","\uD83C\uDF84":"1f384","\uD83C\uDF85":"1f385","\uD83C\uDF86":"1f386","\uD83E\uDD1A":"1f91a","\uD83C\uDF87":"1f387","\uD83C\uDF88":"1f388","\uD83C\uDF89":"1f389","\uD83C\uDF8A":"1f38a","\uD83C\uDF8B":"1f38b","\uD83C\uDF8C":"1f38c","\uD83E\uDD19":"1f919","\uD83C\uDF8D":"1f38d","\uD83D\uDD7A":"1f57a","\uD83C\uDF8E":"1f38e","\uD83E\uDD33":"1f933","\uD83C\uDF8F":"1f38f","\uD83E\uDD30":"1f930","\uD83C\uDF90":"1f390","\uD83E\uDD26":"1f926","\uD83E\uDD37":"1f937","\uD83C\uDF91":"1f391","\uD83C\uDF92":"1f392","\uD83C\uDF93":"1f393","\uD83C\uDFA0":"1f3a0","\uD83C\uDFA1":"1f3a1","\uD83C\uDFA2":"1f3a2","\uD83C\uDFA3":"1f3a3","\uD83C\uDFA4":"1f3a4","\uD83C\uDFA5":"1f3a5","\uD83C\uDFA6":"1f3a6","\uD83C\uDFA7":"1f3a7","\uD83E\uDD36":"1f936","\uD83C\uDFA8":"1f3a8","\uD83E\uDD35":"1f935","\uD83C\uDFA9":"1f3a9","\uD83C\uDFAA":"1f3aa","\uD83E\uDD34":"1f934","\uD83C\uDFAB":"1f3ab","\uD83C\uDFAC":"1f3ac","\uD83C\uDFAD":"1f3ad","\uD83E\uDD27":"1f927","\uD83C\uDFAE":"1f3ae","\uD83C\uDFAF":"1f3af","\uD83C\uDFB0":"1f3b0","\uD83C\uDFB1":"1f3b1","\uD83C\uDFB2":"1f3b2","\uD83C\uDFB3":"1f3b3","\uD83C\uDFB4":"1f3b4","\uD83E\uDD25":"1f925","\uD83C\uDFB5":"1f3b5","\uD83C\uDFB6":"1f3b6","\uD83C\uDFB7":"1f3b7","\uD83E\uDD24":"1f924","\uD83C\uDFB8":"1f3b8","\uD83C\uDFB9":"1f3b9","\uD83C\uDFBA":"1f3ba","\uD83E\uDD23":"1f923","\uD83C\uDFBB":"1f3bb","\uD83C\uDFBC":"1f3bc","\uD83C\uDFBD":"1f3bd","\uD83E\uDD22":"1f922","\uD83C\uDFBE":"1f3be","\uD83C\uDFBF":"1f3bf","\uD83C\uDFC0":"1f3c0","\uD83C\uDFC1":"1f3c1","\uD83E\uDD21":"1f921","\uD83C\uDFC2":"1f3c2","\uD83C\uDFC3":"1f3c3","\uD83C\uDFC4":"1f3c4","\uD83C\uDFC6":"1f3c6","\uD83C\uDFC8":"1f3c8","\uD83C\uDFCA":"1f3ca","\uD83C\uDFE0":"1f3e0","\uD83C\uDFE1":"1f3e1","\uD83C\uDFE2":"1f3e2","\uD83C\uDFE3":"1f3e3","\uD83C\uDFE5":"1f3e5","\uD83C\uDFE6":"1f3e6","\uD83C\uDFE7":"1f3e7","\uD83C\uDFE8":"1f3e8","\uD83C\uDFE9":"1f3e9","\uD83C\uDFEA":"1f3ea","\uD83C\uDFEB":"1f3eb","\uD83C\uDFEC":"1f3ec","\uD83E\uDD20":"1f920","\uD83C\uDFED":"1f3ed","\uD83C\uDFEE":"1f3ee","\uD83C\uDFEF":"1f3ef","\uD83C\uDFF0":"1f3f0","\uD83D\uDC0C":"1f40c","\uD83D\uDC0D":"1f40d","\uD83D\uDC0E":"1f40e","\uD83D\uDC11":"1f411","\uD83D\uDC12":"1f412","\uD83D\uDC14":"1f414","\uD83D\uDC17":"1f417","\uD83D\uDC18":"1f418","\uD83D\uDC19":"1f419","\uD83D\uDC1A":"1f41a","\uD83D\uDC1B":"1f41b","\uD83D\uDC1C":"1f41c","\uD83D\uDC1D":"1f41d","\uD83D\uDC1E":"1f41e","\uD83D\uDC1F":"1f41f","\uD83D\uDC20":"1f420","\uD83D\uDC21":"1f421","\uD83D\uDC22":"1f422","\uD83D\uDC23":"1f423","\uD83D\uDC24":"1f424","\uD83D\uDC25":"1f425","\uD83D\uDC26":"1f426","\uD83D\uDC27":"1f427","\uD83D\uDC28":"1f428","\uD83D\uDC29":"1f429","\uD83D\uDC2B":"1f42b","\uD83D\uDC2C":"1f42c","\uD83D\uDC2D":"1f42d","\uD83D\uDC2E":"1f42e","\uD83D\uDC2F":"1f42f","\uD83D\uDC30":"1f430","\uD83D\uDC31":"1f431","\uD83D\uDC32":"1f432","\uD83D\uDC33":"1f433","\uD83D\uDC34":"1f434","\uD83D\uDC35":"1f435","\uD83D\uDC36":"1f436","\uD83D\uDC37":"1f437","\uD83D\uDC38":"1f438","\uD83D\uDC39":"1f439","\uD83D\uDC3A":"1f43a","\uD83D\uDC3B":"1f43b","\uD83D\uDC3C":"1f43c","\uD83D\uDC3D":"1f43d","\uD83D\uDC3E":"1f43e","\uD83D\uDC40":"1f440","\uD83D\uDC42":"1f442","\uD83D\uDC43":"1f443","\uD83D\uDC44":"1f444","\uD83D\uDC45":"1f445","\uD83D\uDC46":"1f446","\uD83D\uDC47":"1f447","\uD83D\uDC48":"1f448","\uD83D\uDC49":"1f449","\uD83D\uDC4A":"1f44a","\uD83D\uDC4B":"1f44b","\uD83D\uDC4C":"1f44c","\uD83D\uDC4D":"1f44d","\uD83D\uDC4E":"1f44e","\uD83D\uDC4F":"1f44f","\uD83D\uDC50":"1f450","\uD83D\uDC51":"1f451","\uD83D\uDC52":"1f452","\uD83D\uDC53":"1f453","\uD83D\uDC54":"1f454","\uD83D\uDC55":"1f455","\uD83D\uDC56":"1f456","\uD83D\uDC57":"1f457","\uD83D\uDC58":"1f458","\uD83D\uDC59":"1f459","\uD83D\uDC5A":"1f45a","\uD83D\uDC5B":"1f45b","\uD83D\uDC5C":"1f45c","\uD83D\uDC5D":"1f45d","\uD83D\uDC5E":"1f45e","\uD83D\uDC5F":"1f45f","\uD83D\uDC60":"1f460","\uD83D\uDC61":"1f461","\uD83D\uDC62":"1f462","\uD83D\uDC63":"1f463","\uD83D\uDC64":"1f464","\uD83D\uDC66":"1f466","\uD83D\uDC67":"1f467","\uD83D\uDC68":"1f468","\uD83D\uDC69":"1f469","\uD83D\uDC6A":"1f46a","\uD83D\uDC6B":"1f46b","\uD83D\uDC6E":"1f46e","\uD83D\uDC6F":"1f46f","\uD83D\uDC70":"1f470","\uD83D\uDC71":"1f471","\uD83D\uDC72":"1f472","\uD83D\uDC73":"1f473","\uD83D\uDC74":"1f474","\uD83D\uDC75":"1f475","\uD83D\uDC76":"1f476","\uD83D\uDC77":"1f477","\uD83D\uDC78":"1f478","\uD83D\uDC79":"1f479","\uD83D\uDC7A":"1f47a","\uD83D\uDC7B":"1f47b","\uD83D\uDC7C":"1f47c","\uD83D\uDC7D":"1f47d","\uD83D\uDC7E":"1f47e","\uD83D\uDC7F":"1f47f","\uD83D\uDC80":"1f480","\uD83D\uDCC7":"1f4c7","\uD83D\uDC81":"1f481","\uD83D\uDC82":"1f482","\uD83D\uDC83":"1f483","\uD83D\uDC84":"1f484","\uD83D\uDC85":"1f485","\uD83D\uDCD2":"1f4d2","\uD83D\uDC86":"1f486","\uD83D\uDCD3":"1f4d3","\uD83D\uDC87":"1f487","\uD83D\uDCD4":"1f4d4","\uD83D\uDC88":"1f488","\uD83D\uDCD5":"1f4d5","\uD83D\uDC89":"1f489","\uD83D\uDCD6":"1f4d6","\uD83D\uDC8A":"1f48a","\uD83D\uDCD7":"1f4d7","\uD83D\uDC8B":"1f48b","\uD83D\uDCD8":"1f4d8","\uD83D\uDC8C":"1f48c","\uD83D\uDCD9":"1f4d9","\uD83D\uDC8D":"1f48d","\uD83D\uDCDA":"1f4da","\uD83D\uDC8E":"1f48e","\uD83D\uDCDB":"1f4db","\uD83D\uDC8F":"1f48f","\uD83D\uDCDC":"1f4dc","\uD83D\uDC90":"1f490","\uD83D\uDCDD":"1f4dd","\uD83D\uDC91":"1f491","\uD83D\uDCDE":"1f4de","\uD83D\uDC92":"1f492","\uD83D\uDCDF":"1f4df","\uD83D\uDCE0":"1f4e0","\uD83D\uDC93":"1f493","\uD83D\uDCE1":"1f4e1","\uD83D\uDCE2":"1f4e2","\uD83D\uDC94":"1f494","\uD83D\uDCE3":"1f4e3","\uD83D\uDCE4":"1f4e4","\uD83D\uDC95":"1f495","\uD83D\uDCE5":"1f4e5","\uD83D\uDCE6":"1f4e6","\uD83D\uDC96":"1f496","\uD83D\uDCE7":"1f4e7","\uD83D\uDCE8":"1f4e8","\uD83D\uDC97":"1f497","\uD83D\uDCE9":"1f4e9","\uD83D\uDCEA":"1f4ea","\uD83D\uDC98":"1f498","\uD83D\uDCEB":"1f4eb","\uD83D\uDCEE":"1f4ee","\uD83D\uDC99":"1f499","\uD83D\uDCF0":"1f4f0","\uD83D\uDCF1":"1f4f1","\uD83D\uDC9A":"1f49a","\uD83D\uDCF2":"1f4f2","\uD83D\uDCF3":"1f4f3","\uD83D\uDC9B":"1f49b","\uD83D\uDCF4":"1f4f4","\uD83D\uDCF6":"1f4f6","\uD83D\uDC9C":"1f49c","\uD83D\uDCF7":"1f4f7","\uD83D\uDCF9":"1f4f9","\uD83D\uDC9D":"1f49d","\uD83D\uDCFA":"1f4fa","\uD83D\uDCFB":"1f4fb","\uD83D\uDC9E":"1f49e","\uD83D\uDCFC":"1f4fc","\uD83D\uDD03":"1f503","\uD83D\uDC9F":"1f49f","\uD83D\uDD0A":"1f50a","\uD83D\uDD0B":"1f50b","\uD83D\uDCA0":"1f4a0","\uD83D\uDD0C":"1f50c","\uD83D\uDD0D":"1f50d","\uD83D\uDCA1":"1f4a1","\uD83D\uDD0E":"1f50e","\uD83D\uDD0F":"1f50f","\uD83D\uDCA2":"1f4a2","\uD83D\uDD10":"1f510","\uD83D\uDD11":"1f511","\uD83D\uDCA3":"1f4a3","\uD83D\uDD12":"1f512","\uD83D\uDD13":"1f513","\uD83D\uDCA4":"1f4a4","\uD83D\uDD14":"1f514","\uD83D\uDD16":"1f516","\uD83D\uDCA5":"1f4a5","\uD83D\uDD17":"1f517","\uD83D\uDD18":"1f518","\uD83D\uDCA6":"1f4a6","\uD83D\uDD19":"1f519","\uD83D\uDD1A":"1f51a","\uD83D\uDCA7":"1f4a7","\uD83D\uDD1B":"1f51b","\uD83D\uDD1C":"1f51c","\uD83D\uDCA8":"1f4a8","\uD83D\uDD1D":"1f51d","\uD83D\uDD1E":"1f51e","\uD83D\uDCA9":"1f4a9","\uD83D\uDD1F":"1f51f","\uD83D\uDCAA":"1f4aa","\uD83D\uDD20":"1f520","\uD83D\uDD21":"1f521","\uD83D\uDCAB":"1f4ab","\uD83D\uDD22":"1f522","\uD83D\uDD23":"1f523","\uD83D\uDCAC":"1f4ac","\uD83D\uDD24":"1f524","\uD83D\uDD25":"1f525","\uD83D\uDCAE":"1f4ae","\uD83D\uDD26":"1f526","\uD83D\uDD27":"1f527","\uD83D\uDCAF":"1f4af","\uD83D\uDD28":"1f528","\uD83D\uDD29":"1f529","\uD83D\uDCB0":"1f4b0","\uD83D\uDD2A":"1f52a","\uD83D\uDD2B":"1f52b","\uD83D\uDCB1":"1f4b1","\uD83D\uDD2E":"1f52e","\uD83D\uDCB2":"1f4b2","\uD83D\uDD2F":"1f52f","\uD83D\uDCB3":"1f4b3","\uD83D\uDD30":"1f530","\uD83D\uDD31":"1f531","\uD83D\uDCB4":"1f4b4","\uD83D\uDD32":"1f532","\uD83D\uDD33":"1f533","\uD83D\uDCB5":"1f4b5","\uD83D\uDD34":"1f534","\uD83D\uDD35":"1f535","\uD83D\uDCB8":"1f4b8","\uD83D\uDD36":"1f536","\uD83D\uDD37":"1f537","\uD83D\uDCB9":"1f4b9","\uD83D\uDD38":"1f538","\uD83D\uDD39":"1f539","\uD83D\uDCBA":"1f4ba","\uD83D\uDD3A":"1f53a","\uD83D\uDD3B":"1f53b","\uD83D\uDCBB":"1f4bb","\uD83D\uDD3C":"1f53c","\uD83D\uDCBC":"1f4bc","\uD83D\uDD3D":"1f53d","\uD83D\uDD50":"1f550","\uD83D\uDCBD":"1f4bd","\uD83D\uDD51":"1f551","\uD83D\uDCBE":"1f4be","\uD83D\uDD52":"1f552","\uD83D\uDCBF":"1f4bf","\uD83D\uDD53":"1f553","\uD83D\uDCC0":"1f4c0","\uD83D\uDD54":"1f554","\uD83D\uDD55":"1f555","\uD83D\uDCC1":"1f4c1","\uD83D\uDD56":"1f556","\uD83D\uDD57":"1f557","\uD83D\uDCC2":"1f4c2","\uD83D\uDD58":"1f558","\uD83D\uDD59":"1f559","\uD83D\uDCC3":"1f4c3","\uD83D\uDD5A":"1f55a","\uD83D\uDD5B":"1f55b","\uD83D\uDCC4":"1f4c4","\uD83D\uDDFB":"1f5fb","\uD83D\uDDFC":"1f5fc","\uD83D\uDCC5":"1f4c5","\uD83D\uDDFD":"1f5fd","\uD83D\uDDFE":"1f5fe","\uD83D\uDCC6":"1f4c6","\uD83D\uDDFF":"1f5ff","\uD83D\uDE01":"1f601","\uD83D\uDE02":"1f602","\uD83D\uDE03":"1f603","\uD83D\uDCC8":"1f4c8","\uD83D\uDE04":"1f604","\uD83D\uDE05":"1f605","\uD83D\uDCC9":"1f4c9","\uD83D\uDE06":"1f606","\uD83D\uDE09":"1f609","\uD83D\uDCCA":"1f4ca","\uD83D\uDE0A":"1f60a","\uD83D\uDE0B":"1f60b","\uD83D\uDCCB":"1f4cb","\uD83D\uDE0C":"1f60c","\uD83D\uDE0D":"1f60d","\uD83D\uDCCC":"1f4cc","\uD83D\uDE0F":"1f60f","\uD83D\uDE12":"1f612","\uD83D\uDCCD":"1f4cd","\uD83D\uDE13":"1f613","\uD83D\uDE14":"1f614","\uD83D\uDCCE":"1f4ce","\uD83D\uDE16":"1f616","\uD83D\uDE18":"1f618","\uD83D\uDCCF":"1f4cf","\uD83D\uDE1A":"1f61a","\uD83D\uDE1C":"1f61c","\uD83D\uDCD0":"1f4d0","\uD83D\uDE1D":"1f61d","\uD83D\uDE1E":"1f61e","\uD83D\uDCD1":"1f4d1","\uD83D\uDE20":"1f620","\uD83D\uDE21":"1f621","\uD83D\uDE22":"1f622","\uD83D\uDE23":"1f623","\uD83D\uDE24":"1f624","\uD83D\uDE25":"1f625","\uD83D\uDE28":"1f628","\uD83D\uDE29":"1f629","\uD83D\uDE2A":"1f62a","\uD83D\uDE2B":"1f62b","\uD83D\uDE2D":"1f62d","\uD83D\uDE30":"1f630","\uD83D\uDE31":"1f631","\uD83D\uDE32":"1f632","\uD83D\uDE33":"1f633","\uD83D\uDE35":"1f635","\uD83D\uDE37":"1f637","\uD83D\uDE38":"1f638","\uD83D\uDE39":"1f639","\uD83D\uDE3A":"1f63a","\uD83D\uDE3B":"1f63b","\uD83D\uDE3C":"1f63c","\uD83D\uDE3D":"1f63d","\uD83D\uDE3E":"1f63e","\uD83D\uDE3F":"1f63f","\uD83D\uDE40":"1f640","\uD83D\uDE45":"1f645","\uD83D\uDE46":"1f646","\uD83D\uDE47":"1f647","\uD83D\uDE48":"1f648","\uD83D\uDE49":"1f649","\uD83D\uDE4A":"1f64a","\uD83D\uDE4B":"1f64b","\uD83D\uDE4C":"1f64c","\uD83D\uDE4D":"1f64d","\uD83D\uDE4E":"1f64e","\uD83D\uDE4F":"1f64f","\uD83D\uDE80":"1f680","\uD83D\uDE83":"1f683","\uD83D\uDE84":"1f684","\uD83D\uDE85":"1f685","\uD83D\uDE87":"1f687","\uD83D\uDE89":"1f689","\uD83D\uDE8C":"1f68c","\uD83D\uDE8F":"1f68f","\uD83D\uDE91":"1f691","\uD83D\uDE92":"1f692","\uD83D\uDE93":"1f693","\uD83D\uDE95":"1f695","\uD83D\uDE97":"1f697","\uD83D\uDE99":"1f699","\uD83D\uDE9A":"1f69a","\uD83D\uDEA2":"1f6a2","\uD83D\uDEA4":"1f6a4","\uD83D\uDEA5":"1f6a5","\uD83D\uDEA7":"1f6a7","\uD83D\uDEA8":"1f6a8","\uD83D\uDEA9":"1f6a9","\uD83D\uDEAA":"1f6aa","\uD83D\uDEAB":"1f6ab","\uD83D\uDEAC":"1f6ac","\uD83D\uDEAD":"1f6ad","\uD83D\uDEB2":"1f6b2","\uD83D\uDEB6":"1f6b6","\uD83D\uDEB9":"1f6b9","\uD83D\uDEBA":"1f6ba","\uD83D\uDEBB":"1f6bb","\uD83D\uDEBC":"1f6bc","\uD83D\uDEBD":"1f6bd","\uD83D\uDEBE":"1f6be","\uD83D\uDEC0":"1f6c0","\uD83E\uDD18":"1f918","\uD83D\uDE00":"1f600","\uD83D\uDE07":"1f607","\uD83D\uDE08":"1f608","\uD83D\uDE0E":"1f60e","\uD83D\uDE10":"1f610","\uD83D\uDE11":"1f611","\uD83D\uDE15":"1f615","\uD83D\uDE17":"1f617","\uD83D\uDE19":"1f619","\uD83D\uDE1B":"1f61b","\uD83D\uDE1F":"1f61f","\uD83D\uDE26":"1f626","\uD83D\uDE27":"1f627","\uD83D\uDE2C":"1f62c","\uD83D\uDE2E":"1f62e","\uD83D\uDE2F":"1f62f","\uD83D\uDE34":"1f634","\uD83D\uDE36":"1f636","\uD83D\uDE81":"1f681","\uD83D\uDE82":"1f682","\uD83D\uDE86":"1f686","\uD83D\uDE88":"1f688","\uD83D\uDE8A":"1f68a","\uD83D\uDE8D":"1f68d","\uD83D\uDE8E":"1f68e","\uD83D\uDE90":"1f690","\uD83D\uDE94":"1f694","\uD83D\uDE96":"1f696","\uD83D\uDE98":"1f698","\uD83D\uDE9B":"1f69b","\uD83D\uDE9C":"1f69c","\uD83D\uDE9D":"1f69d","\uD83D\uDE9E":"1f69e","\uD83D\uDE9F":"1f69f","\uD83D\uDEA0":"1f6a0","\uD83D\uDEA1":"1f6a1","\uD83D\uDEA3":"1f6a3","\uD83D\uDEA6":"1f6a6","\uD83D\uDEAE":"1f6ae","\uD83D\uDEAF":"1f6af","\uD83D\uDEB0":"1f6b0","\uD83D\uDEB1":"1f6b1","\uD83D\uDEB3":"1f6b3","\uD83D\uDEB4":"1f6b4","\uD83D\uDEB5":"1f6b5","\uD83D\uDEB7":"1f6b7","\uD83D\uDEB8":"1f6b8","\uD83D\uDEBF":"1f6bf","\uD83D\uDEC1":"1f6c1","\uD83D\uDEC2":"1f6c2","\uD83D\uDEC3":"1f6c3","\uD83D\uDEC4":"1f6c4","\uD83D\uDEC5":"1f6c5","\uD83C\uDF0D":"1f30d","\uD83C\uDF0E":"1f30e","\uD83C\uDF10":"1f310","\uD83C\uDF12":"1f312","\uD83C\uDF16":"1f316","\uD83C\uDF17":"1f317","\uD83C\uDF18":"1f318","\uD83C\uDF1A":"1f31a","\uD83C\uDF1C":"1f31c","\uD83C\uDF1D":"1f31d","\uD83C\uDF1E":"1f31e","\uD83C\uDF32":"1f332","\uD83C\uDF33":"1f333","\uD83C\uDF4B":"1f34b","\uD83C\uDF50":"1f350","\uD83C\uDF7C":"1f37c","\uD83C\uDFC7":"1f3c7","\uD83C\uDFC9":"1f3c9","\uD83C\uDFE4":"1f3e4","\uD83D\uDC00":"1f400","\uD83D\uDC01":"1f401","\uD83D\uDC02":"1f402","\uD83D\uDC03":"1f403","\uD83D\uDC04":"1f404","\uD83D\uDC05":"1f405","\uD83D\uDC06":"1f406","\uD83D\uDC07":"1f407","\uD83D\uDC08":"1f408","\uD83D\uDC09":"1f409","\uD83D\uDC0A":"1f40a","\uD83D\uDC0B":"1f40b","\uD83D\uDC0F":"1f40f","\uD83D\uDC10":"1f410","\uD83D\uDC13":"1f413","\uD83D\uDC15":"1f415","\uD83D\uDC16":"1f416","\uD83D\uDC2A":"1f42a","\uD83D\uDC65":"1f465","\uD83D\uDC6C":"1f46c","\uD83D\uDC6D":"1f46d","\uD83D\uDCAD":"1f4ad","\uD83D\uDCB6":"1f4b6","\uD83D\uDCB7":"1f4b7","\uD83D\uDCEC":"1f4ec","\uD83D\uDCED":"1f4ed","\uD83D\uDCEF":"1f4ef","\uD83D\uDCF5":"1f4f5","\uD83D\uDD00":"1f500","\uD83D\uDD01":"1f501","\uD83D\uDD02":"1f502","\uD83D\uDD04":"1f504","\uD83D\uDD05":"1f505","\uD83D\uDD06":"1f506","\uD83D\uDD07":"1f507","\uD83D\uDD09":"1f509","\uD83D\uDD15":"1f515","\uD83D\uDD2C":"1f52c","\uD83D\uDD2D":"1f52d","\uD83D\uDD5C":"1f55c","\uD83D\uDD5D":"1f55d","\uD83D\uDD5E":"1f55e","\uD83D\uDD5F":"1f55f","\uD83D\uDD60":"1f560","\uD83D\uDD61":"1f561","\uD83D\uDD62":"1f562","\uD83D\uDD63":"1f563","\uD83D\uDD64":"1f564","\uD83D\uDD65":"1f565","\uD83D\uDD66":"1f566","\uD83D\uDD67":"1f567","\uD83D\uDD08":"1f508","\uD83D\uDE8B":"1f68b","\uD83C\uDF9E":"1f39e","\uD83C\uDF9F":"1f39f","\uD83C\uDFC5":"1f3c5","\uD83C\uDFCB":"1f3cb","\uD83C\uDFCC":"1f3cc","\uD83C\uDFCD":"1f3cd","\uD83C\uDFCE":"1f3ce","\uD83C\uDF96":"1f396","\uD83C\uDF97":"1f397","\uD83C\uDF36":"1f336","\uD83C\uDF27":"1f327","\uD83C\uDF28":"1f328","\uD83C\uDF29":"1f329","\uD83C\uDF2A":"1f32a","\uD83C\uDF2B":"1f32b","\uD83C\uDF2C":"1f32c","\uD83D\uDC3F":"1f43f","\uD83D\uDD77":"1f577","\uD83D\uDD78":"1f578","\uD83C\uDF21":"1f321","\uD83C\uDF99":"1f399","\uD83C\uDF9A":"1f39a","\uD83C\uDF9B":"1f39b","\uD83C\uDFF3":"1f3f3","\uD83C\uDFF4":"1f3f4","\uD83C\uDFF5":"1f3f5","\uD83C\uDFF7":"1f3f7","\uD83D\uDCF8":"1f4f8","\uD83D\uDCFD":"1f4fd","\uD83D\uDD4A":"1f54a","\uD83D\uDD6F":"1f56f","\uD83D\uDD70":"1f570","\uD83D\uDD73":"1f573","\uD83D\uDD76":"1f576","\uD83D\uDD79":"1f579","\uD83D\uDD87":"1f587","\uD83D\uDD8A":"1f58a","\uD83D\uDD8B":"1f58b","\uD83D\uDD8C":"1f58c","\uD83D\uDD8D":"1f58d","\uD83D\uDDA5":"1f5a5","\uD83D\uDDA8":"1f5a8","\uD83D\uDDB2":"1f5b2","\uD83D\uDDBC":"1f5bc","\uD83D\uDDC2":"1f5c2","\uD83D\uDDC3":"1f5c3","\uD83D\uDDC4":"1f5c4","\uD83D\uDDD1":"1f5d1","\uD83D\uDDD2":"1f5d2","\uD83D\uDDD3":"1f5d3","\uD83D\uDDDC":"1f5dc","\uD83D\uDDDE":"1f5de","\uD83D\uDDE1":"1f5e1","\uD83D\uDDE3":"1f5e3","\uD83D\uDDE8":"1f5e8","\uD83D\uDDEF":"1f5ef","\uD83D\uDDF3":"1f5f3","\uD83D\uDDFA":"1f5fa","\uD83D\uDECC":"1f6cc","\uD83D\uDEE0":"1f6e0","\uD83D\uDEE1":"1f6e1","\uD83D\uDEE2":"1f6e2","\uD83D\uDEF0":"1f6f0","\uD83C\uDF7D":"1f37d","\uD83D\uDC41":"1f441","\uD83D\uDD74":"1f574","\uD83D\uDD75":"1f575","\uD83D\uDD90":"1f590","\uD83D\uDD95":"1f595","\uD83D\uDD96":"1f596","\uD83D\uDE41":"1f641","\uD83D\uDE42":"1f642","\uD83C\uDFD4":"1f3d4","\uD83C\uDFD5":"1f3d5","\uD83C\uDFD6":"1f3d6","\uD83C\uDFD7":"1f3d7","\uD83C\uDFD8":"1f3d8","\uD83C\uDFD9":"1f3d9","\uD83C\uDFDA":"1f3da","\uD83C\uDFDB":"1f3db","\uD83C\uDFDC":"1f3dc","\uD83C\uDFDD":"1f3dd","\uD83C\uDFDE":"1f3de","\uD83C\uDFDF":"1f3df","\uD83D\uDECB":"1f6cb","\uD83D\uDECD":"1f6cd","\uD83D\uDECE":"1f6ce","\uD83D\uDECF":"1f6cf","\uD83D\uDEE3":"1f6e3","\uD83D\uDEE4":"1f6e4","\uD83D\uDEE5":"1f6e5","\uD83D\uDEE9":"1f6e9","\uD83D\uDEEB":"1f6eb","\uD83D\uDEEC":"1f6ec","\uD83D\uDEF3":"1f6f3","\uD83C\uDFFB":"1f3fb","\uD83C\uDFFC":"1f3fc","\uD83C\uDFFD":"1f3fd","\uD83C\uDFFE":"1f3fe","\uD83C\uDFFF":"1f3ff","\uD83C\uDF24":"1f324","\uD83C\uDF25":"1f325","\uD83C\uDF26":"1f326","\uD83D\uDDB1":"1f5b1","\uD83D\uDE43":"1f643","\uD83E\uDD11":"1f911","\uD83E\uDD13":"1f913","\uD83E\uDD17":"1f917","\uD83D\uDE44":"1f644","\uD83E\uDD14":"1f914","\uD83E\uDD10":"1f910","\uD83E\uDD12":"1f912","\uD83E\uDD15":"1f915","\uD83E\uDD16":"1f916","\uD83E\uDD81":"1f981","\uD83E\uDD84":"1f984","\uD83E\uDD82":"1f982","\uD83E\uDD80":"1f980","\uD83E\uDD83":"1f983","\uD83E\uDDC0":"1f9c0","\uD83C\uDF2D":"1f32d","\uD83C\uDF2E":"1f32e","\uD83C\uDF2F":"1f32f","\uD83C\uDF7F":"1f37f","\uD83C\uDF7E":"1f37e","\uD83C\uDFF9":"1f3f9","\uD83C\uDFFA":"1f3fa","\uD83D\uDED0":"1f6d0","\uD83D\uDD4B":"1f54b","\uD83D\uDD4C":"1f54c","\uD83D\uDD4D":"1f54d","\uD83D\uDD4E":"1f54e","\uD83D\uDCFF":"1f4ff","\uD83C\uDFCF":"1f3cf","\uD83C\uDFD0":"1f3d0","\uD83C\uDFD1":"1f3d1","\uD83C\uDFD2":"1f3d2","\uD83C\uDFD3":"1f3d3","\uD83C\uDFF8":"1f3f8","\uD83E\uDD41":"1f941","\uD83E\uDD90":"1f990","\uD83E\uDD91":"1f991","\uD83E\uDD5A":"1f95a","\uD83E\uDD5B":"1f95b","\uD83E\uDD5C":"1f95c","\uD83E\uDD5D":"1f95d","\uD83E\uDD5E":"1f95e","\uD83C\uDDFC":"1f1fc","\uD83C\uDDFB":"1f1fb","\uD83C\uDDFA":"1f1fa","\uD83C\uDDF9":"1f1f9","\uD83C\uDDF8":"1f1f8","\uD83C\uDDF7":"1f1f7","\uD83C\uDDF6":"1f1f6","\uD83C\uDDF5":"1f1f5","\uD83C\uDDF4":"1f1f4","\uD83C\uDDF3":"1f1f3","\uD83C\uDDF2":"1f1f2","\uD83C\uDDF1":"1f1f1","\uD83C\uDDF0":"1f1f0","\uD83C\uDDEF":"1f1ef","\uD83C\uDDEE":"1f1ee","\uD83C\uDDED":"1f1ed","\uD83C\uDDEC":"1f1ec","\uD83C\uDDEB":"1f1eb","\uD83C\uDDEA":"1f1ea","\uD83C\uDDE9":"1f1e9","\uD83C\uDDE8":"1f1e8","\uD83C\uDDE7":"1f1e7","\uD83C\uDDE6":"1f1e6","\uD83D\uDEF7":"1f6f7","\uD83D\uDEF8":"1f6f8","\uD83E\uDD1F":"1f91f","\uD83E\uDD28":"1f928","\uD83E\uDD29":"1f929","\uD83E\uDD2A":"1f92a","\uD83E\uDD2B":"1f92b","\uD83E\uDD2C":"1f92c","\uD83E\uDD2D":"1f92d","\uD83E\uDD2E":"1f92e","\uD83E\uDD2F":"1f92f","\uD83E\uDD31":"1f931","\uD83E\uDD32":"1f932","\uD83E\uDD4C":"1f94c","\uD83E\uDD5F":"1f95f","\uD83E\uDD60":"1f960","\uD83E\uDD61":"1f961","\uD83E\uDD62":"1f962","\uD83E\uDD63":"1f963","\uD83E\uDD64":"1f964","\uD83E\uDD65":"1f965","\uD83E\uDD66":"1f966","\uD83E\uDD67":"1f967","\uD83E\uDD68":"1f968","\uD83E\uDD69":"1f969","\uD83E\uDD6A":"1f96a","\uD83E\uDD6B":"1f96b","\uD83E\uDD92":"1f992","\uD83E\uDD93":"1f993","\uD83E\uDD94":"1f994","\uD83E\uDD95":"1f995","\uD83E\uDD96":"1f996","\uD83E\uDD97":"1f997","\uD83E\uDDD0":"1f9d0","\uD83E\uDDD1":"1f9d1","\uD83E\uDDD2":"1f9d2","\uD83E\uDDD3":"1f9d3","\uD83E\uDDD4":"1f9d4","\uD83E\uDDD5":"1f9d5","\uD83E\uDDD6":"1f9d6","\uD83E\uDDD7":"1f9d7","\uD83E\uDDD8":"1f9d8","\uD83E\uDDD9":"1f9d9","\uD83E\uDDDA":"1f9da","\uD83E\uDDDB":"1f9db","\uD83E\uDDDC":"1f9dc","\uD83E\uDDDD":"1f9dd","\uD83E\uDDDE":"1f9de","\uD83E\uDDDF":"1f9df","\uD83E\uDDE0":"1f9e0","\uD83E\uDDE1":"1f9e1","\uD83E\uDDE2":"1f9e2","\uD83E\uDDE3":"1f9e3","\uD83E\uDDE4":"1f9e4","\uD83E\uDDE5":"1f9e5","\uD83E\uDDE6":"1f9e6","\u231A":"231a","\u231B":"231b","\u23E9":"23e9","\u23EA":"23ea","\u23EB":"23eb","\u23EC":"23ec","\u23F0":"23f0","\u23F3":"23f3","\u24C2":"24c2","\u25FD":"25fd","\u25FE":"25fe","\u2600":"2600","\u2601":"2601","\u260E":"260e","\u2614":"2614","\u2615":"2615","\u261D":"261d","\u263A":"263a","\u2648":"2648","\u2649":"2649","\u264A":"264a","\u264B":"264b","\u264C":"264c","\u264D":"264d","\u264E":"264e","\u264F":"264f","\u2650":"2650","\u2651":"2651","\u2652":"2652","\u2653":"2653","\u2660":"2660","\u2663":"2663","\u2665":"2665","\u2666":"2666","\u2668":"2668","\u267B":"267b","\u267F":"267f","\u2693":"2693","\u26A1":"26a1","\u26AA":"26aa","\u26AB":"26ab","\u26BD":"26bd","\u26BE":"26be","\u26C4":"26c4","\u26C5":"26c5","\u26CE":"26ce","\u26D4":"26d4","\u26EA":"26ea","\u26F2":"26f2","\u26F3":"26f3","\u26F5":"26f5","\u26FA":"26fa","\u26FD":"26fd","\u2702":"2702","\u2705":"2705","\u2708":"2708","\u2709":"2709","\u270A":"270a","\u270B":"270b","\u270C":"270c","\u270F":"270f","\u2712":"2712","\u2728":"2728","\u2733":"2733","\u2734":"2734","\u2744":"2744","\u2747":"2747","\u274C":"274c","\u274E":"274e","\u2753":"2753","\u2754":"2754","\u2755":"2755","\u2757":"2757","\u2764":"2764","\u2795":"2795","\u2796":"2796","\u2797":"2797","\u27B0":"27b0","\u2B1B":"2b1b","\u2B1C":"2b1c","\u2B50":"2b50","\u2B55":"2b55","\u303D":"303d","\u3297":"3297","\u3299":"3299","\u27BF":"27bf","\u2328":"2328","\u270D":"270d","\u23F1":"23f1","\u23F2":"23f2","\u2602":"2602","\u2603":"2603","\u2604":"2604","\u2618":"2618","\u2620":"2620","\u2639":"2639","\u2692":"2692","\u2694":"2694","\u2696":"2696","\u2697":"2697","\u2699":"2699","\u269C":"269c","\u26B0":"26b0","\u26B1":"26b1","\u26C8":"26c8","\u26CF":"26cf","\u26D1":"26d1","\u26D3":"26d3","\u26E9":"26e9","\u26F0":"26f0","\u26F1":"26f1","\u26F4":"26f4","\u26F7":"26f7","\u26F8":"26f8","\u26F9":"26f9","\u2763":"2763"};
+
+ ns.jsEscapeMapGreedy = {"\uD83D\uDC69\u2764\uD83D\uDC8B\uD83D\uDC69":"1f469-2764-1f48b-1f469","\uD83D\uDC68\u2764\uD83D\uDC8B\uD83D\uDC68":"1f468-2764-1f48b-1f468","\uD83D\uDC69\u2764\uD83D\uDC8B\uD83D\uDC68":"1f469-2764-1f48b-1f468","\uD83D\uDC69\u2764\uD83D\uDC69":"1f469-2764-1f469","\uD83D\uDC68\u2764\uD83D\uDC68":"1f468-2764-1f468","\uD83C\uDFCC\uD83C\uDFFB\u2642":"1f3cc-1f3fb-2642","\uD83C\uDFCC\uD83C\uDFFC\u2642":"1f3cc-1f3fc-2642","\uD83C\uDFCC\uD83C\uDFFD\u2642":"1f3cc-1f3fd-2642","\uD83C\uDFCC\uD83C\uDFFE\u2642":"1f3cc-1f3fe-2642","\uD83C\uDFCC\uD83C\uDFFF\u2642":"1f3cc-1f3ff-2642","\uD83C\uDFCC\uD83C\uDFFB\u2640":"1f3cc-1f3fb-2640","\uD83C\uDFCC\uD83C\uDFFC\u2640":"1f3cc-1f3fc-2640","\uD83C\uDFCC\uD83C\uDFFD\u2640":"1f3cc-1f3fd-2640","\uD83C\uDFCC\uD83C\uDFFE\u2640":"1f3cc-1f3fe-2640","\uD83C\uDFCC\uD83C\uDFFF\u2640":"1f3cc-1f3ff-2640","\uD83D\uDC68\uD83C\uDFFB\u2696":"1f468-1f3fb-2696","\uD83D\uDC68\uD83C\uDFFC\u2696":"1f468-1f3fc-2696","\uD83D\uDC68\uD83C\uDFFD\u2696":"1f468-1f3fd-2696","\uD83D\uDC68\uD83C\uDFFE\u2696":"1f468-1f3fe-2696","\uD83D\uDC68\uD83C\uDFFF\u2696":"1f468-1f3ff-2696","\uD83D\uDC69\uD83C\uDFFB\u2696":"1f469-1f3fb-2696","\uD83D\uDC69\uD83C\uDFFC\u2696":"1f469-1f3fc-2696","\uD83D\uDC69\uD83C\uDFFD\u2696":"1f469-1f3fd-2696","\uD83D\uDC69\uD83C\uDFFE\u2696":"1f469-1f3fe-2696","\uD83D\uDC69\uD83C\uDFFF\u2696":"1f469-1f3ff-2696","\uD83D\uDC68\uD83C\uDFFB\u2708":"1f468-1f3fb-2708","\uD83D\uDC68\uD83C\uDFFC\u2708":"1f468-1f3fc-2708","\uD83D\uDC68\uD83C\uDFFD\u2708":"1f468-1f3fd-2708","\uD83D\uDC68\uD83C\uDFFE\u2708":"1f468-1f3fe-2708","\uD83D\uDC68\uD83C\uDFFF\u2708":"1f468-1f3ff-2708","\uD83D\uDC69\uD83C\uDFFB\u2708":"1f469-1f3fb-2708","\uD83D\uDC69\uD83C\uDFFC\u2708":"1f469-1f3fc-2708","\uD83D\uDC69\uD83C\uDFFD\u2708":"1f469-1f3fd-2708","\uD83D\uDC69\uD83C\uDFFE\u2708":"1f469-1f3fe-2708","\uD83D\uDC69\uD83C\uDFFF\u2708":"1f469-1f3ff-2708","\uD83D\uDC69\u2764\uD83D\uDC68":"1f469-2764-1f468","\uD83D\uDC68\uD83C\uDFFB\u2695":"1f468-1f3fb-2695","\uD83D\uDC68\uD83C\uDFFC\u2695":"1f468-1f3fc-2695","\uD83D\uDC68\uD83C\uDFFD\u2695":"1f468-1f3fd-2695","\uD83D\uDC68\uD83C\uDFFE\u2695":"1f468-1f3fe-2695","\uD83D\uDC68\uD83C\uDFFF\u2695":"1f468-1f3ff-2695","\uD83D\uDC69\uD83C\uDFFB\u2695":"1f469-1f3fb-2695","\uD83D\uDC69\uD83C\uDFFC\u2695":"1f469-1f3fc-2695","\uD83D\uDC69\uD83C\uDFFD\u2695":"1f469-1f3fd-2695","\uD83D\uDC69\uD83C\uDFFE\u2695":"1f469-1f3fe-2695","\uD83D\uDC69\uD83C\uDFFF\u2695":"1f469-1f3ff-2695","\uD83D\uDC6E\uD83C\uDFFB\u2640":"1f46e-1f3fb-2640","\uD83D\uDC6E\uD83C\uDFFB\u2642":"1f46e-1f3fb-2642","\uD83D\uDC6E\uD83C\uDFFC\u2640":"1f46e-1f3fc-2640","\uD83D\uDC6E\uD83C\uDFFC\u2642":"1f46e-1f3fc-2642","\uD83D\uDC6E\uD83C\uDFFD\u2640":"1f46e-1f3fd-2640","\uD83D\uDC6E\uD83C\uDFFD\u2642":"1f46e-1f3fd-2642","\uD83D\uDC6E\uD83C\uDFFE\u2640":"1f46e-1f3fe-2640","\uD83D\uDC6E\uD83C\uDFFE\u2642":"1f46e-1f3fe-2642","\uD83D\uDC6E\uD83C\uDFFF\u2640":"1f46e-1f3ff-2640","\uD83D\uDC6E\uD83C\uDFFF\u2642":"1f46e-1f3ff-2642","\uD83D\uDC71\uD83C\uDFFB\u2640":"1f471-1f3fb-2640","\uD83D\uDC71\uD83C\uDFFB\u2642":"1f471-1f3fb-2642","\uD83D\uDC71\uD83C\uDFFC\u2640":"1f471-1f3fc-2640","\uD83D\uDC71\uD83C\uDFFC\u2642":"1f471-1f3fc-2642","\uD83D\uDC71\uD83C\uDFFD\u2640":"1f471-1f3fd-2640","\uD83D\uDC71\uD83C\uDFFD\u2642":"1f471-1f3fd-2642","\uD83D\uDC71\uD83C\uDFFE\u2640":"1f471-1f3fe-2640","\uD83D\uDC71\uD83C\uDFFE\u2642":"1f471-1f3fe-2642","\uD83D\uDC71\uD83C\uDFFF\u2640":"1f471-1f3ff-2640","\uD83D\uDC71\uD83C\uDFFF\u2642":"1f471-1f3ff-2642","\uD83D\uDC73\uD83C\uDFFB\u2640":"1f473-1f3fb-2640","\uD83D\uDC73\uD83C\uDFFB\u2642":"1f473-1f3fb-2642","\uD83D\uDC73\uD83C\uDFFC\u2640":"1f473-1f3fc-2640","\uD83D\uDC73\uD83C\uDFFC\u2642":"1f473-1f3fc-2642","\uD83D\uDC73\uD83C\uDFFD\u2640":"1f473-1f3fd-2640","\uD83D\uDC73\uD83C\uDFFD\u2642":"1f473-1f3fd-2642","\uD83D\uDC73\uD83C\uDFFE\u2640":"1f473-1f3fe-2640","\uD83D\uDC73\uD83C\uDFFE\u2642":"1f473-1f3fe-2642","\uD83D\uDC73\uD83C\uDFFF\u2640":"1f473-1f3ff-2640","\uD83D\uDC73\uD83C\uDFFF\u2642":"1f473-1f3ff-2642","\uD83D\uDC77\uD83C\uDFFB\u2640":"1f477-1f3fb-2640","\uD83D\uDC77\uD83C\uDFFB\u2642":"1f477-1f3fb-2642","\uD83D\uDC77\uD83C\uDFFC\u2640":"1f477-1f3fc-2640","\uD83D\uDC77\uD83C\uDFFC\u2642":"1f477-1f3fc-2642","\uD83D\uDC77\uD83C\uDFFD\u2640":"1f477-1f3fd-2640","\uD83D\uDC77\uD83C\uDFFD\u2642":"1f477-1f3fd-2642","\uD83D\uDC77\uD83C\uDFFE\u2640":"1f477-1f3fe-2640","\uD83D\uDC77\uD83C\uDFFE\u2642":"1f477-1f3fe-2642","\uD83D\uDC77\uD83C\uDFFF\u2640":"1f477-1f3ff-2640","\uD83D\uDC77\uD83C\uDFFF\u2642":"1f477-1f3ff-2642","\uD83D\uDC82\uD83C\uDFFB\u2640":"1f482-1f3fb-2640","\uD83D\uDC82\uD83C\uDFFB\u2642":"1f482-1f3fb-2642","\uD83D\uDC82\uD83C\uDFFC\u2640":"1f482-1f3fc-2640","\uD83D\uDC82\uD83C\uDFFC\u2642":"1f482-1f3fc-2642","\uD83D\uDC82\uD83C\uDFFD\u2640":"1f482-1f3fd-2640","\uD83D\uDC82\uD83C\uDFFD\u2642":"1f482-1f3fd-2642","\uD83D\uDC82\uD83C\uDFFE\u2640":"1f482-1f3fe-2640","\uD83D\uDC82\uD83C\uDFFE\u2642":"1f482-1f3fe-2642","\uD83D\uDC82\uD83C\uDFFF\u2640":"1f482-1f3ff-2640","\uD83D\uDC82\uD83C\uDFFF\u2642":"1f482-1f3ff-2642","\uD83D\uDD75\uD83C\uDFFB\u2640":"1f575-1f3fb-2640","\uD83D\uDD75\uD83C\uDFFB\u2642":"1f575-1f3fb-2642","\uD83D\uDD75\uD83C\uDFFC\u2640":"1f575-1f3fc-2640","\uD83D\uDD75\uD83C\uDFFC\u2642":"1f575-1f3fc-2642","\uD83D\uDD75\uD83C\uDFFD\u2640":"1f575-1f3fd-2640","\uD83D\uDD75\uD83C\uDFFD\u2642":"1f575-1f3fd-2642","\uD83D\uDD75\uD83C\uDFFE\u2640":"1f575-1f3fe-2640","\uD83D\uDD75\uD83C\uDFFE\u2642":"1f575-1f3fe-2642","\uD83D\uDD75\uD83C\uDFFF\u2640":"1f575-1f3ff-2640","\uD83D\uDD75\uD83C\uDFFF\u2642":"1f575-1f3ff-2642","\uD83C\uDFC3\uD83C\uDFFB\u2640":"1f3c3-1f3fb-2640","\uD83C\uDFC3\uD83C\uDFFB\u2642":"1f3c3-1f3fb-2642","\uD83C\uDFC3\uD83C\uDFFC\u2640":"1f3c3-1f3fc-2640","\uD83C\uDFC3\uD83C\uDFFC\u2642":"1f3c3-1f3fc-2642","\uD83C\uDFC3\uD83C\uDFFD\u2640":"1f3c3-1f3fd-2640","\uD83C\uDFC3\uD83C\uDFFD\u2642":"1f3c3-1f3fd-2642","\uD83C\uDFC3\uD83C\uDFFE\u2640":"1f3c3-1f3fe-2640","\uD83C\uDFC3\uD83C\uDFFE\u2642":"1f3c3-1f3fe-2642","\uD83C\uDFC3\uD83C\uDFFF\u2640":"1f3c3-1f3ff-2640","\uD83C\uDFC3\uD83C\uDFFF\u2642":"1f3c3-1f3ff-2642","\uD83C\uDFC4\uD83C\uDFFB\u2640":"1f3c4-1f3fb-2640","\uD83C\uDFC4\uD83C\uDFFB\u2642":"1f3c4-1f3fb-2642","\uD83C\uDFC4\uD83C\uDFFC\u2640":"1f3c4-1f3fc-2640","\uD83C\uDFC4\uD83C\uDFFC\u2642":"1f3c4-1f3fc-2642","\uD83C\uDFC4\uD83C\uDFFD\u2640":"1f3c4-1f3fd-2640","\uD83C\uDFC4\uD83C\uDFFD\u2642":"1f3c4-1f3fd-2642","\uD83C\uDFC4\uD83C\uDFFE\u2640":"1f3c4-1f3fe-2640","\uD83C\uDFC4\uD83C\uDFFE\u2642":"1f3c4-1f3fe-2642","\uD83C\uDFC4\uD83C\uDFFF\u2640":"1f3c4-1f3ff-2640","\uD83C\uDFC4\uD83C\uDFFF\u2642":"1f3c4-1f3ff-2642","\uD83C\uDFCA\uD83C\uDFFB\u2640":"1f3ca-1f3fb-2640","\uD83C\uDFCA\uD83C\uDFFB\u2642":"1f3ca-1f3fb-2642","\uD83C\uDFCA\uD83C\uDFFC\u2640":"1f3ca-1f3fc-2640","\uD83C\uDFCA\uD83C\uDFFC\u2642":"1f3ca-1f3fc-2642","\uD83C\uDFCA\uD83C\uDFFD\u2640":"1f3ca-1f3fd-2640","\uD83C\uDFCA\uD83C\uDFFD\u2642":"1f3ca-1f3fd-2642","\uD83C\uDFCA\uD83C\uDFFE\u2640":"1f3ca-1f3fe-2640","\uD83C\uDFCA\uD83C\uDFFE\u2642":"1f3ca-1f3fe-2642","\uD83C\uDFCA\uD83C\uDFFF\u2640":"1f3ca-1f3ff-2640","\uD83C\uDFCA\uD83C\uDFFF\u2642":"1f3ca-1f3ff-2642","\uD83C\uDFCB\uD83C\uDFFB\u2640":"1f3cb-1f3fb-2640","\uD83C\uDFCB\uD83C\uDFFB\u2642":"1f3cb-1f3fb-2642","\uD83C\uDFCB\uD83C\uDFFC\u2640":"1f3cb-1f3fc-2640","\uD83C\uDFCB\uD83C\uDFFC\u2642":"1f3cb-1f3fc-2642","\uD83C\uDFCB\uD83C\uDFFD\u2640":"1f3cb-1f3fd-2640","\uD83C\uDFCB\uD83C\uDFFD\u2642":"1f3cb-1f3fd-2642","\uD83C\uDFCB\uD83C\uDFFE\u2640":"1f3cb-1f3fe-2640","\uD83C\uDFCB\uD83C\uDFFE\u2642":"1f3cb-1f3fe-2642","\uD83C\uDFCB\uD83C\uDFFF\u2640":"1f3cb-1f3ff-2640","\uD83C\uDFCB\uD83C\uDFFF\u2642":"1f3cb-1f3ff-2642","\uD83D\uDC86\uD83C\uDFFB\u2640":"1f486-1f3fb-2640","\uD83D\uDC86\uD83C\uDFFB\u2642":"1f486-1f3fb-2642","\uD83D\uDC86\uD83C\uDFFC\u2640":"1f486-1f3fc-2640","\uD83D\uDC86\uD83C\uDFFC\u2642":"1f486-1f3fc-2642","\uD83D\uDC86\uD83C\uDFFD\u2640":"1f486-1f3fd-2640","\uD83D\uDC86\uD83C\uDFFD\u2642":"1f486-1f3fd-2642","\uD83D\uDC86\uD83C\uDFFE\u2640":"1f486-1f3fe-2640","\uD83D\uDC86\uD83C\uDFFE\u2642":"1f486-1f3fe-2642","\uD83D\uDC86\uD83C\uDFFF\u2640":"1f486-1f3ff-2640","\uD83D\uDC86\uD83C\uDFFF\u2642":"1f486-1f3ff-2642","\uD83D\uDC87\uD83C\uDFFB\u2640":"1f487-1f3fb-2640","\uD83D\uDC87\uD83C\uDFFB\u2642":"1f487-1f3fb-2642","\uD83D\uDC87\uD83C\uDFFC\u2640":"1f487-1f3fc-2640","\uD83D\uDC87\uD83C\uDFFC\u2642":"1f487-1f3fc-2642","\uD83D\uDC87\uD83C\uDFFD\u2640":"1f487-1f3fd-2640","\uD83D\uDC87\uD83C\uDFFD\u2642":"1f487-1f3fd-2642","\uD83D\uDC87\uD83C\uDFFE\u2640":"1f487-1f3fe-2640","\uD83D\uDC87\uD83C\uDFFE\u2642":"1f487-1f3fe-2642","\uD83D\uDC87\uD83C\uDFFF\u2640":"1f487-1f3ff-2640","\uD83D\uDC87\uD83C\uDFFF\u2642":"1f487-1f3ff-2642","\uD83D\uDEA3\uD83C\uDFFB\u2640":"1f6a3-1f3fb-2640","\uD83D\uDEA3\uD83C\uDFFB\u2642":"1f6a3-1f3fb-2642","\uD83D\uDEA3\uD83C\uDFFC\u2640":"1f6a3-1f3fc-2640","\uD83D\uDEA3\uD83C\uDFFC\u2642":"1f6a3-1f3fc-2642","\uD83D\uDEA3\uD83C\uDFFD\u2640":"1f6a3-1f3fd-2640","\uD83D\uDEA3\uD83C\uDFFD\u2642":"1f6a3-1f3fd-2642","\uD83D\uDEA3\uD83C\uDFFE\u2640":"1f6a3-1f3fe-2640","\uD83D\uDEA3\uD83C\uDFFE\u2642":"1f6a3-1f3fe-2642","\uD83D\uDEA3\uD83C\uDFFF\u2640":"1f6a3-1f3ff-2640","\uD83D\uDEA3\uD83C\uDFFF\u2642":"1f6a3-1f3ff-2642","\uD83D\uDEB4\uD83C\uDFFB\u2640":"1f6b4-1f3fb-2640","\uD83D\uDEB4\uD83C\uDFFB\u2642":"1f6b4-1f3fb-2642","\uD83D\uDEB4\uD83C\uDFFC\u2640":"1f6b4-1f3fc-2640","\uD83D\uDEB4\uD83C\uDFFC\u2642":"1f6b4-1f3fc-2642","\uD83D\uDEB4\uD83C\uDFFD\u2640":"1f6b4-1f3fd-2640","\uD83D\uDEB4\uD83C\uDFFD\u2642":"1f6b4-1f3fd-2642","\uD83D\uDEB4\uD83C\uDFFE\u2640":"1f6b4-1f3fe-2640","\uD83D\uDEB4\uD83C\uDFFE\u2642":"1f6b4-1f3fe-2642","\uD83D\uDEB4\uD83C\uDFFF\u2640":"1f6b4-1f3ff-2640","\uD83D\uDEB4\uD83C\uDFFF\u2642":"1f6b4-1f3ff-2642","\uD83D\uDEB5\uD83C\uDFFB\u2640":"1f6b5-1f3fb-2640","\uD83D\uDEB5\uD83C\uDFFB\u2642":"1f6b5-1f3fb-2642","\uD83D\uDEB5\uD83C\uDFFC\u2640":"1f6b5-1f3fc-2640","\uD83D\uDEB5\uD83C\uDFFC\u2642":"1f6b5-1f3fc-2642","\uD83D\uDEB5\uD83C\uDFFD\u2640":"1f6b5-1f3fd-2640","\uD83D\uDEB5\uD83C\uDFFD\u2642":"1f6b5-1f3fd-2642","\uD83D\uDEB5\uD83C\uDFFE\u2640":"1f6b5-1f3fe-2640","\uD83D\uDEB5\uD83C\uDFFE\u2642":"1f6b5-1f3fe-2642","\uD83D\uDEB5\uD83C\uDFFF\u2640":"1f6b5-1f3ff-2640","\uD83D\uDEB5\uD83C\uDFFF\u2642":"1f6b5-1f3ff-2642","\uD83D\uDEB6\uD83C\uDFFB\u2640":"1f6b6-1f3fb-2640","\uD83D\uDEB6\uD83C\uDFFB\u2642":"1f6b6-1f3fb-2642","\uD83D\uDEB6\uD83C\uDFFC\u2640":"1f6b6-1f3fc-2640","\uD83D\uDEB6\uD83C\uDFFC\u2642":"1f6b6-1f3fc-2642","\uD83D\uDEB6\uD83C\uDFFD\u2640":"1f6b6-1f3fd-2640","\uD83D\uDEB6\uD83C\uDFFD\u2642":"1f6b6-1f3fd-2642","\uD83D\uDEB6\uD83C\uDFFE\u2640":"1f6b6-1f3fe-2640","\uD83D\uDEB6\uD83C\uDFFE\u2642":"1f6b6-1f3fe-2642","\uD83D\uDEB6\uD83C\uDFFF\u2640":"1f6b6-1f3ff-2640","\uD83D\uDEB6\uD83C\uDFFF\u2642":"1f6b6-1f3ff-2642","\uD83E\uDD38\uD83C\uDFFB\u2640":"1f938-1f3fb-2640","\uD83E\uDD38\uD83C\uDFFB\u2642":"1f938-1f3fb-2642","\uD83E\uDD38\uD83C\uDFFC\u2640":"1f938-1f3fc-2640","\uD83E\uDD38\uD83C\uDFFC\u2642":"1f938-1f3fc-2642","\uD83E\uDD38\uD83C\uDFFD\u2640":"1f938-1f3fd-2640","\uD83E\uDD38\uD83C\uDFFD\u2642":"1f938-1f3fd-2642","\uD83E\uDD38\uD83C\uDFFE\u2640":"1f938-1f3fe-2640","\uD83E\uDD38\uD83C\uDFFE\u2642":"1f938-1f3fe-2642","\uD83E\uDD38\uD83C\uDFFF\u2640":"1f938-1f3ff-2640","\uD83E\uDD38\uD83C\uDFFF\u2642":"1f938-1f3ff-2642","\uD83E\uDD39\uD83C\uDFFB\u2640":"1f939-1f3fb-2640","\uD83E\uDD39\uD83C\uDFFB\u2642":"1f939-1f3fb-2642","\uD83E\uDD39\uD83C\uDFFC\u2640":"1f939-1f3fc-2640","\uD83E\uDD39\uD83C\uDFFC\u2642":"1f939-1f3fc-2642","\uD83E\uDD39\uD83C\uDFFD\u2640":"1f939-1f3fd-2640","\uD83E\uDD39\uD83C\uDFFD\u2642":"1f939-1f3fd-2642","\uD83E\uDD39\uD83C\uDFFE\u2640":"1f939-1f3fe-2640","\uD83E\uDD39\uD83C\uDFFE\u2642":"1f939-1f3fe-2642","\uD83E\uDD39\uD83C\uDFFF\u2640":"1f939-1f3ff-2640","\uD83E\uDD39\uD83C\uDFFF\u2642":"1f939-1f3ff-2642","\uD83E\uDD3D\uD83C\uDFFB\u2640":"1f93d-1f3fb-2640","\uD83E\uDD3D\uD83C\uDFFB\u2642":"1f93d-1f3fb-2642","\uD83E\uDD3D\uD83C\uDFFC\u2640":"1f93d-1f3fc-2640","\uD83E\uDD3D\uD83C\uDFFC\u2642":"1f93d-1f3fc-2642","\uD83E\uDD3D\uD83C\uDFFD\u2640":"1f93d-1f3fd-2640","\uD83E\uDD3D\uD83C\uDFFD\u2642":"1f93d-1f3fd-2642","\uD83E\uDD3D\uD83C\uDFFE\u2640":"1f93d-1f3fe-2640","\uD83E\uDD3D\uD83C\uDFFE\u2642":"1f93d-1f3fe-2642","\uD83E\uDD3D\uD83C\uDFFF\u2640":"1f93d-1f3ff-2640","\uD83E\uDD3D\uD83C\uDFFF\u2642":"1f93d-1f3ff-2642","\uD83E\uDD3E\uD83C\uDFFB\u2640":"1f93e-1f3fb-2640","\uD83E\uDD3E\uD83C\uDFFB\u2642":"1f93e-1f3fb-2642","\uD83E\uDD3E\uD83C\uDFFC\u2640":"1f93e-1f3fc-2640","\uD83E\uDD3E\uD83C\uDFFC\u2642":"1f93e-1f3fc-2642","\uD83E\uDD3E\uD83C\uDFFD\u2640":"1f93e-1f3fd-2640","\uD83E\uDD3E\uD83C\uDFFD\u2642":"1f93e-1f3fd-2642","\uD83E\uDD3E\uD83C\uDFFE\u2640":"1f93e-1f3fe-2640","\uD83E\uDD3E\uD83C\uDFFE\u2642":"1f93e-1f3fe-2642","\uD83E\uDD3E\uD83C\uDFFF\u2640":"1f93e-1f3ff-2640","\uD83E\uDD3E\uD83C\uDFFF\u2642":"1f93e-1f3ff-2642","\uD83D\uDC81\uD83C\uDFFB\u2640":"1f481-1f3fb-2640","\uD83D\uDC81\uD83C\uDFFB\u2642":"1f481-1f3fb-2642","\uD83D\uDC81\uD83C\uDFFC\u2640":"1f481-1f3fc-2640","\uD83D\uDC81\uD83C\uDFFC\u2642":"1f481-1f3fc-2642","\uD83D\uDC81\uD83C\uDFFD\u2640":"1f481-1f3fd-2640","\uD83D\uDC81\uD83C\uDFFD\u2642":"1f481-1f3fd-2642","\uD83D\uDC81\uD83C\uDFFE\u2640":"1f481-1f3fe-2640","\uD83D\uDC81\uD83C\uDFFE\u2642":"1f481-1f3fe-2642","\uD83D\uDC81\uD83C\uDFFF\u2640":"1f481-1f3ff-2640","\uD83D\uDC81\uD83C\uDFFF\u2642":"1f481-1f3ff-2642","\uD83D\uDE45\uD83C\uDFFB\u2640":"1f645-1f3fb-2640","\uD83D\uDE45\uD83C\uDFFB\u2642":"1f645-1f3fb-2642","\uD83D\uDE45\uD83C\uDFFC\u2640":"1f645-1f3fc-2640","\uD83D\uDE45\uD83C\uDFFC\u2642":"1f645-1f3fc-2642","\uD83D\uDE45\uD83C\uDFFD\u2640":"1f645-1f3fd-2640","\uD83D\uDE45\uD83C\uDFFD\u2642":"1f645-1f3fd-2642","\uD83D\uDE45\uD83C\uDFFE\u2640":"1f645-1f3fe-2640","\uD83D\uDE45\uD83C\uDFFE\u2642":"1f645-1f3fe-2642","\uD83D\uDE45\uD83C\uDFFF\u2640":"1f645-1f3ff-2640","\uD83D\uDE45\uD83C\uDFFF\u2642":"1f645-1f3ff-2642","\uD83D\uDE46\uD83C\uDFFB\u2640":"1f646-1f3fb-2640","\uD83D\uDE46\uD83C\uDFFB\u2642":"1f646-1f3fb-2642","\uD83D\uDE46\uD83C\uDFFC\u2640":"1f646-1f3fc-2640","\uD83D\uDE46\uD83C\uDFFC\u2642":"1f646-1f3fc-2642","\uD83D\uDE46\uD83C\uDFFD\u2640":"1f646-1f3fd-2640","\uD83D\uDE46\uD83C\uDFFD\u2642":"1f646-1f3fd-2642","\uD83D\uDE46\uD83C\uDFFE\u2640":"1f646-1f3fe-2640","\uD83D\uDE46\uD83C\uDFFE\u2642":"1f646-1f3fe-2642","\uD83D\uDE46\uD83C\uDFFF\u2640":"1f646-1f3ff-2640","\uD83D\uDE46\uD83C\uDFFF\u2642":"1f646-1f3ff-2642","\uD83D\uDE47\uD83C\uDFFB\u2640":"1f647-1f3fb-2640","\uD83D\uDE47\uD83C\uDFFB\u2642":"1f647-1f3fb-2642","\uD83D\uDE47\uD83C\uDFFC\u2640":"1f647-1f3fc-2640","\uD83D\uDE47\uD83C\uDFFC\u2642":"1f647-1f3fc-2642","\uD83D\uDE47\uD83C\uDFFD\u2640":"1f647-1f3fd-2640","\uD83D\uDE47\uD83C\uDFFD\u2642":"1f647-1f3fd-2642","\uD83D\uDE47\uD83C\uDFFE\u2640":"1f647-1f3fe-2640","\uD83D\uDE47\uD83C\uDFFE\u2642":"1f647-1f3fe-2642","\uD83D\uDE47\uD83C\uDFFF\u2640":"1f647-1f3ff-2640","\uD83D\uDE47\uD83C\uDFFF\u2642":"1f647-1f3ff-2642","\uD83D\uDE4B\uD83C\uDFFB\u2640":"1f64b-1f3fb-2640","\uD83D\uDE4B\uD83C\uDFFB\u2642":"1f64b-1f3fb-2642","\uD83D\uDE4B\uD83C\uDFFC\u2640":"1f64b-1f3fc-2640","\uD83D\uDE4B\uD83C\uDFFC\u2642":"1f64b-1f3fc-2642","\uD83D\uDE4B\uD83C\uDFFD\u2640":"1f64b-1f3fd-2640","\uD83D\uDE4B\uD83C\uDFFD\u2642":"1f64b-1f3fd-2642","\uD83D\uDE4B\uD83C\uDFFE\u2640":"1f64b-1f3fe-2640","\uD83D\uDE4B\uD83C\uDFFE\u2642":"1f64b-1f3fe-2642","\uD83D\uDE4B\uD83C\uDFFF\u2640":"1f64b-1f3ff-2640","\uD83D\uDE4B\uD83C\uDFFF\u2642":"1f64b-1f3ff-2642","\uD83D\uDE4D\uD83C\uDFFB\u2640":"1f64d-1f3fb-2640","\uD83D\uDE4D\uD83C\uDFFB\u2642":"1f64d-1f3fb-2642","\uD83D\uDE4D\uD83C\uDFFC\u2640":"1f64d-1f3fc-2640","\uD83D\uDE4D\uD83C\uDFFC\u2642":"1f64d-1f3fc-2642","\uD83D\uDE4D\uD83C\uDFFD\u2640":"1f64d-1f3fd-2640","\uD83D\uDE4D\uD83C\uDFFD\u2642":"1f64d-1f3fd-2642","\uD83D\uDE4D\uD83C\uDFFE\u2640":"1f64d-1f3fe-2640","\uD83D\uDE4D\uD83C\uDFFE\u2642":"1f64d-1f3fe-2642","\uD83D\uDE4D\uD83C\uDFFF\u2640":"1f64d-1f3ff-2640","\uD83D\uDE4D\uD83C\uDFFF\u2642":"1f64d-1f3ff-2642","\uD83D\uDE4E\uD83C\uDFFB\u2640":"1f64e-1f3fb-2640","\uD83D\uDE4E\uD83C\uDFFB\u2642":"1f64e-1f3fb-2642","\uD83D\uDE4E\uD83C\uDFFC\u2640":"1f64e-1f3fc-2640","\uD83D\uDE4E\uD83C\uDFFC\u2642":"1f64e-1f3fc-2642","\uD83D\uDE4E\uD83C\uDFFD\u2640":"1f64e-1f3fd-2640","\uD83D\uDE4E\uD83C\uDFFD\u2642":"1f64e-1f3fd-2642","\uD83D\uDE4E\uD83C\uDFFE\u2640":"1f64e-1f3fe-2640","\uD83D\uDE4E\uD83C\uDFFE\u2642":"1f64e-1f3fe-2642","\uD83D\uDE4E\uD83C\uDFFF\u2640":"1f64e-1f3ff-2640","\uD83D\uDE4E\uD83C\uDFFF\u2642":"1f64e-1f3ff-2642","\uD83E\uDD26\uD83C\uDFFB\u2640":"1f926-1f3fb-2640","\uD83E\uDD26\uD83C\uDFFB\u2642":"1f926-1f3fb-2642","\uD83E\uDD26\uD83C\uDFFC\u2640":"1f926-1f3fc-2640","\uD83E\uDD26\uD83C\uDFFC\u2642":"1f926-1f3fc-2642","\uD83E\uDD26\uD83C\uDFFD\u2640":"1f926-1f3fd-2640","\uD83E\uDD26\uD83C\uDFFD\u2642":"1f926-1f3fd-2642","\uD83E\uDD26\uD83C\uDFFE\u2640":"1f926-1f3fe-2640","\uD83E\uDD26\uD83C\uDFFE\u2642":"1f926-1f3fe-2642","\uD83E\uDD26\uD83C\uDFFF\u2640":"1f926-1f3ff-2640","\uD83E\uDD26\uD83C\uDFFF\u2642":"1f926-1f3ff-2642","\uD83E\uDD37\uD83C\uDFFB\u2640":"1f937-1f3fb-2640","\uD83E\uDD37\uD83C\uDFFB\u2642":"1f937-1f3fb-2642","\uD83E\uDD37\uD83C\uDFFC\u2640":"1f937-1f3fc-2640","\uD83E\uDD37\uD83C\uDFFC\u2642":"1f937-1f3fc-2642","\uD83E\uDD37\uD83C\uDFFD\u2640":"1f937-1f3fd-2640","\uD83E\uDD37\uD83C\uDFFD\u2642":"1f937-1f3fd-2642","\uD83E\uDD37\uD83C\uDFFE\u2640":"1f937-1f3fe-2640","\uD83E\uDD37\uD83C\uDFFE\u2642":"1f937-1f3fe-2642","\uD83E\uDD37\uD83C\uDFFF\u2640":"1f937-1f3ff-2640","\uD83E\uDD37\uD83C\uDFFF\u2642":"1f937-1f3ff-2642","\uD83E\uDDD9\uD83C\uDFFB\u2640":"1f9d9-1f3fb-2640","\uD83E\uDDD9\uD83C\uDFFB\u2642":"1f9d9-1f3fb-2642","\uD83E\uDDD9\uD83C\uDFFC\u2640":"1f9d9-1f3fc-2640","\uD83E\uDDD9\uD83C\uDFFC\u2642":"1f9d9-1f3fc-2642","\uD83E\uDDD9\uD83C\uDFFD\u2640":"1f9d9-1f3fd-2640","\uD83E\uDDD9\uD83C\uDFFD\u2642":"1f9d9-1f3fd-2642","\uD83E\uDDD9\uD83C\uDFFE\u2640":"1f9d9-1f3fe-2640","\uD83E\uDDD9\uD83C\uDFFE\u2642":"1f9d9-1f3fe-2642","\uD83E\uDDD9\uD83C\uDFFF\u2640":"1f9d9-1f3ff-2640","\uD83E\uDDD9\uD83C\uDFFF\u2642":"1f9d9-1f3ff-2642","\uD83E\uDDDA\uD83C\uDFFB\u2640":"1f9da-1f3fb-2640","\uD83E\uDDDA\uD83C\uDFFB\u2642":"1f9da-1f3fb-2642","\uD83E\uDDDA\uD83C\uDFFC\u2640":"1f9da-1f3fc-2640","\uD83E\uDDDA\uD83C\uDFFC\u2642":"1f9da-1f3fc-2642","\uD83E\uDDDA\uD83C\uDFFD\u2640":"1f9da-1f3fd-2640","\uD83E\uDDDA\uD83C\uDFFD\u2642":"1f9da-1f3fd-2642","\uD83E\uDDDA\uD83C\uDFFE\u2640":"1f9da-1f3fe-2640","\uD83E\uDDDA\uD83C\uDFFE\u2642":"1f9da-1f3fe-2642","\uD83E\uDDDA\uD83C\uDFFF\u2640":"1f9da-1f3ff-2640","\uD83E\uDDDA\uD83C\uDFFF\u2642":"1f9da-1f3ff-2642","\uD83E\uDDDB\uD83C\uDFFB\u2640":"1f9db-1f3fb-2640","\uD83E\uDDDB\uD83C\uDFFB\u2642":"1f9db-1f3fb-2642","\uD83E\uDDDB\uD83C\uDFFC\u2640":"1f9db-1f3fc-2640","\uD83E\uDDDB\uD83C\uDFFC\u2642":"1f9db-1f3fc-2642","\uD83E\uDDDB\uD83C\uDFFD\u2640":"1f9db-1f3fd-2640","\uD83E\uDDDB\uD83C\uDFFD\u2642":"1f9db-1f3fd-2642","\uD83E\uDDDB\uD83C\uDFFE\u2640":"1f9db-1f3fe-2640","\uD83E\uDDDB\uD83C\uDFFE\u2642":"1f9db-1f3fe-2642","\uD83E\uDDDB\uD83C\uDFFF\u2640":"1f9db-1f3ff-2640","\uD83E\uDDDB\uD83C\uDFFF\u2642":"1f9db-1f3ff-2642","\uD83E\uDDDC\uD83C\uDFFB\u2640":"1f9dc-1f3fb-2640","\uD83E\uDDDC\uD83C\uDFFB\u2642":"1f9dc-1f3fb-2642","\uD83E\uDDDC\uD83C\uDFFC\u2640":"1f9dc-1f3fc-2640","\uD83E\uDDDC\uD83C\uDFFC\u2642":"1f9dc-1f3fc-2642","\uD83E\uDDDC\uD83C\uDFFD\u2640":"1f9dc-1f3fd-2640","\uD83E\uDDDC\uD83C\uDFFD\u2642":"1f9dc-1f3fd-2642","\uD83E\uDDDC\uD83C\uDFFE\u2640":"1f9dc-1f3fe-2640","\uD83E\uDDDC\uD83C\uDFFE\u2642":"1f9dc-1f3fe-2642","\uD83E\uDDDC\uD83C\uDFFF\u2640":"1f9dc-1f3ff-2640","\uD83E\uDDDC\uD83C\uDFFF\u2642":"1f9dc-1f3ff-2642","\uD83E\uDDDD\uD83C\uDFFB\u2640":"1f9dd-1f3fb-2640","\uD83E\uDDDD\uD83C\uDFFB\u2642":"1f9dd-1f3fb-2642","\uD83E\uDDDD\uD83C\uDFFC\u2640":"1f9dd-1f3fc-2640","\uD83E\uDDDD\uD83C\uDFFC\u2642":"1f9dd-1f3fc-2642","\uD83E\uDDDD\uD83C\uDFFD\u2640":"1f9dd-1f3fd-2640","\uD83E\uDDDD\uD83C\uDFFD\u2642":"1f9dd-1f3fd-2642","\uD83E\uDDDD\uD83C\uDFFE\u2640":"1f9dd-1f3fe-2640","\uD83E\uDDDD\uD83C\uDFFE\u2642":"1f9dd-1f3fe-2642","\uD83E\uDDDD\uD83C\uDFFF\u2640":"1f9dd-1f3ff-2640","\uD83E\uDDDD\uD83C\uDFFF\u2642":"1f9dd-1f3ff-2642","\uD83E\uDDD6\uD83C\uDFFB\u2640":"1f9d6-1f3fb-2640","\uD83E\uDDD6\uD83C\uDFFB\u2642":"1f9d6-1f3fb-2642","\uD83E\uDDD6\uD83C\uDFFC\u2640":"1f9d6-1f3fc-2640","\uD83E\uDDD6\uD83C\uDFFC\u2642":"1f9d6-1f3fc-2642","\uD83E\uDDD6\uD83C\uDFFD\u2640":"1f9d6-1f3fd-2640","\uD83E\uDDD6\uD83C\uDFFD\u2642":"1f9d6-1f3fd-2642","\uD83E\uDDD6\uD83C\uDFFE\u2640":"1f9d6-1f3fe-2640","\uD83E\uDDD6\uD83C\uDFFE\u2642":"1f9d6-1f3fe-2642","\uD83E\uDDD6\uD83C\uDFFF\u2640":"1f9d6-1f3ff-2640","\uD83E\uDDD6\uD83C\uDFFF\u2642":"1f9d6-1f3ff-2642","\uD83E\uDDD7\uD83C\uDFFB\u2640":"1f9d7-1f3fb-2640","\uD83E\uDDD7\uD83C\uDFFB\u2642":"1f9d7-1f3fb-2642","\uD83E\uDDD7\uD83C\uDFFC\u2640":"1f9d7-1f3fc-2640","\uD83E\uDDD7\uD83C\uDFFC\u2642":"1f9d7-1f3fc-2642","\uD83E\uDDD7\uD83C\uDFFD\u2640":"1f9d7-1f3fd-2640","\uD83E\uDDD7\uD83C\uDFFD\u2642":"1f9d7-1f3fd-2642","\uD83E\uDDD7\uD83C\uDFFE\u2640":"1f9d7-1f3fe-2640","\uD83E\uDDD7\uD83C\uDFFE\u2642":"1f9d7-1f3fe-2642","\uD83E\uDDD7\uD83C\uDFFF\u2640":"1f9d7-1f3ff-2640","\uD83E\uDDD7\uD83C\uDFFF\u2642":"1f9d7-1f3ff-2642","\uD83E\uDDD8\uD83C\uDFFB\u2640":"1f9d8-1f3fb-2640","\uD83E\uDDD8\uD83C\uDFFB\u2642":"1f9d8-1f3fb-2642","\uD83E\uDDD8\uD83C\uDFFC\u2640":"1f9d8-1f3fc-2640","\uD83E\uDDD8\uD83C\uDFFC\u2642":"1f9d8-1f3fc-2642","\uD83E\uDDD8\uD83C\uDFFD\u2640":"1f9d8-1f3fd-2640","\uD83E\uDDD8\uD83C\uDFFD\u2642":"1f9d8-1f3fd-2642","\uD83E\uDDD8\uD83C\uDFFE\u2640":"1f9d8-1f3fe-2640","\uD83E\uDDD8\uD83C\uDFFE\u2642":"1f9d8-1f3fe-2642","\uD83E\uDDD8\uD83C\uDFFF\u2640":"1f9d8-1f3ff-2640","\uD83E\uDDD8\uD83C\uDFFF\u2642":"1f9d8-1f3ff-2642","\u26F9\uD83C\uDFFB\u2640":"26f9-1f3fb-2640","\u26F9\uD83C\uDFFB\u2642":"26f9-1f3fb-2642","\u26F9\uD83C\uDFFC\u2640":"26f9-1f3fc-2640","\u26F9\uD83C\uDFFC\u2642":"26f9-1f3fc-2642","\u26F9\uD83C\uDFFD\u2640":"26f9-1f3fd-2640","\u26F9\uD83C\uDFFD\u2642":"26f9-1f3fd-2642","\u26F9\uD83C\uDFFE\u2640":"26f9-1f3fe-2640","\u26F9\uD83C\uDFFE\u2642":"26f9-1f3fe-2642","\u26F9\uD83C\uDFFF\u2640":"26f9-1f3ff-2640","\u26F9\uD83C\uDFFF\u2642":"26f9-1f3ff-2642","\uD83C\uDFF3\uD83C\uDF08":"1f3f3-1f308","\uD83D\uDC41\uD83D\uDDE8":"1f441-1f5e8","\uD83D\uDC6F\u2642":"1f46f-2642","\uD83D\uDC6F\u2640":"1f46f-2640","\uD83C\uDFCC\u2642":"1f3cc-2642","\uD83C\uDFCC\u2640":"1f3cc-2640","\uD83E\uDD3C\u2642":"1f93c-2642","\uD83E\uDD3C\u2640":"1f93c-2640","\uD83E\uDD39\u2642":"1f939-2642","\uD83E\uDD39\u2640":"1f939-2640","\uD83E\uDD3E\u2642":"1f93e-2642","\uD83E\uDD3E\u2640":"1f93e-2640","\uD83E\uDD3D\u2642":"1f93d-2642","\uD83E\uDD3D\u2640":"1f93d-2640","\uD83E\uDD38\u2642":"1f938-2642","\uD83E\uDD38\u2640":"1f938-2640","\uD83D\uDEB6\u2642":"1f6b6-2642","\uD83D\uDEB6\u2640":"1f6b6-2640","\uD83D\uDEB5\u2642":"1f6b5-2642","\uD83D\uDEB5\u2640":"1f6b5-2640","\uD83D\uDEB4\u2642":"1f6b4-2642","\uD83D\uDEB4\u2640":"1f6b4-2640","\uD83D\uDEA3\u2642":"1f6a3-2642","\uD83D\uDEA3\u2640":"1f6a3-2640","\uD83C\uDFCB\u2642":"1f3cb-2642","\uD83C\uDFCB\u2640":"1f3cb-2640","\uD83C\uDFCA\u2642":"1f3ca-2642","\uD83C\uDFCA\u2640":"1f3ca-2640","\uD83C\uDFC4\u2642":"1f3c4-2642","\uD83C\uDFC4\u2640":"1f3c4-2640","\uD83C\uDFC3\u2642":"1f3c3-2642","\uD83C\uDFC3\u2640":"1f3c3-2640","\uD83E\uDD37\u2642":"1f937-2642","\uD83E\uDD37\u2640":"1f937-2640","\uD83E\uDD26\u2642":"1f926-2642","\uD83E\uDD26\u2640":"1f926-2640","\uD83D\uDE4E\u2642":"1f64e-2642","\uD83D\uDE4E\u2640":"1f64e-2640","\uD83D\uDE4D\u2642":"1f64d-2642","\uD83D\uDE4D\u2640":"1f64d-2640","\uD83D\uDE4B\u2642":"1f64b-2642","\uD83D\uDE4B\u2640":"1f64b-2640","\uD83D\uDE47\u2642":"1f647-2642","\uD83D\uDE47\u2640":"1f647-2640","\uD83D\uDE46\u2642":"1f646-2642","\uD83D\uDE46\u2640":"1f646-2640","\uD83D\uDE45\u2642":"1f645-2642","\uD83D\uDE45\u2640":"1f645-2640","\uD83D\uDC87\u2642":"1f487-2642","\uD83D\uDC87\u2640":"1f487-2640","\uD83D\uDC86\u2642":"1f486-2642","\uD83D\uDC86\u2640":"1f486-2640","\uD83D\uDC81\u2642":"1f481-2642","\uD83D\uDC81\u2640":"1f481-2640","\uD83D\uDC71\u2642":"1f471-2642","\uD83D\uDC71\u2640":"1f471-2640","\uD83D\uDC73\u2642":"1f473-2642","\uD83D\uDC73\u2640":"1f473-2640","\uD83D\uDC82\u2642":"1f482-2642","\uD83D\uDC82\u2640":"1f482-2640","\uD83D\uDD75\u2642":"1f575-2642","\uD83D\uDD75\u2640":"1f575-2640","\uD83D\uDC77\u2642":"1f477-2642","\uD83D\uDC77\u2640":"1f477-2640","\uD83D\uDC6E\u2642":"1f46e-2642","\uD83D\uDC6E\u2640":"1f46e-2640","\uD83D\uDC68\u2695":"1f468-2695","\uD83D\uDC69\u2695":"1f469-2695","\uD83D\uDC68\u2696":"1f468-2696","\uD83D\uDC69\u2696":"1f469-2696","\uD83D\uDC68\u2708":"1f468-2708","\uD83D\uDC69\u2708":"1f469-2708","\uD83E\uDDD9\u2640":"1f9d9-2640","\uD83E\uDDD9\u2642":"1f9d9-2642","\uD83E\uDDDA\u2640":"1f9da-2640","\uD83E\uDDDA\u2642":"1f9da-2642","\uD83E\uDDDB\u2640":"1f9db-2640","\uD83E\uDDDB\u2642":"1f9db-2642","\uD83E\uDDDC\u2640":"1f9dc-2640","\uD83E\uDDDC\u2642":"1f9dc-2642","\uD83E\uDDDD\u2640":"1f9dd-2640","\uD83E\uDDDD\u2642":"1f9dd-2642","\uD83E\uDDDE\u2640":"1f9de-2640","\uD83E\uDDDE\u2642":"1f9de-2642","\uD83E\uDDDF\u2640":"1f9df-2640","\uD83E\uDDDF\u2642":"1f9df-2642","\uD83E\uDDD6\u2640":"1f9d6-2640","\uD83E\uDDD6\u2642":"1f9d6-2642","\uD83E\uDDD7\u2640":"1f9d7-2640","\uD83E\uDDD7\u2642":"1f9d7-2642","\uD83E\uDDD8\u2640":"1f9d8-2640","\uD83E\uDDD8\u2642":"1f9d8-2642","\u26F9\u2642":"26f9-2642","\u26F9\u2640":"26f9-2640","\uD83D\uDD49":"1f549","\uD83D\uDDDD":"1f5dd","\u00A9":"00a9","\u00AE":"00ae","\u203C":"203c","\u2049":"2049","\u2122":"2122","\u2139":"2139","\u2194":"2194","\u2195":"2195","\u2196":"2196","\u2197":"2197","\u2198":"2198","\u2199":"2199","\u21A9":"21a9","\u21AA":"21aa","\u25AA":"25aa","\u25AB":"25ab","\u25B6":"25b6","\u25C0":"25c0","\u25FB":"25fb","\u25FC":"25fc","\u2611":"2611","\u26A0":"26a0","\u2714":"2714","\u2716":"2716","\u27A1":"27a1","\u2934":"2934","\u2935":"2935","\u2B05":"2b05","\u2B06":"2b06","\u2B07":"2b07","\u3030":"3030","\u271D":"271d","\u23CF":"23cf","\u23ED":"23ed","\u23EE":"23ee","\u23EF":"23ef","\u23F8":"23f8","\u23F9":"23f9","\u23FA":"23fa","\u2622":"2622","\u2623":"2623","\u2626":"2626","\u262A":"262a","\u262E":"262e","\u262F":"262f","\u2638":"2638","\u269B":"269b","\u2721":"2721","\u2640":"2640","\u2642":"2642","\u2695":"2695"};
+
+ ns.asciiList = {
+ '*\\0/*':'1f646',
+ '*\\O/*':'1f646',
+ '-___-':'1f611',
+ ':\'-)':'1f602',
+ '\':-)':'1f605',
+ '\':-D':'1f605',
+ '>:-)':'1f606',
+ '\':-(':'1f613',
+ '>:-(':'1f620',
+ ':\'-(':'1f622',
+ 'O:-)':'1f607',
+ '0:-3':'1f607',
+ '0:-)':'1f607',
+ '0;^)':'1f607',
+ 'O;-)':'1f607',
+ '0;-)':'1f607',
+ 'O:-3':'1f607',
+ '-__-':'1f611',
+ ':-Þ':'1f61b',
+ '</3':'1f494',
+ ':\')':'1f602',
+ ':-D':'1f603',
+ '\':)':'1f605',
+ '\'=)':'1f605',
+ '\':D':'1f605',
+ '\'=D':'1f605',
+ '>:)':'1f606',
+ '>;)':'1f606',
+ '>=)':'1f606',
+ ';-)':'1f609',
+ '*-)':'1f609',
+ ';-]':'1f609',
+ ';^)':'1f609',
+ '\':(':'1f613',
+ '\'=(':'1f613',
+ ':-*':'1f618',
+ ':^*':'1f618',
+ '>:P':'1f61c',
+ 'X-P':'1f61c',
+ '>:[':'1f61e',
+ ':-(':'1f61e',
+ ':-[':'1f61e',
+ '>:(':'1f620',
+ ':\'(':'1f622',
+ ';-(':'1f622',
+ '>.<':'1f623',
+ '#-)':'1f635',
+ '%-)':'1f635',
+ 'X-)':'1f635',
+ '\\0/':'1f646',
+ '\\O/':'1f646',
+ '0:3':'1f607',
+ '0:)':'1f607',
+ 'O:)':'1f607',
+ 'O=)':'1f607',
+ 'O:3':'1f607',
+ 'B-)':'1f60e',
+ '8-)':'1f60e',
+ 'B-D':'1f60e',
+ '8-D':'1f60e',
+ '-_-':'1f611',
+ '>:\\':'1f615',
+ '>:/':'1f615',
+ ':-/':'1f615',
+ ':-.':'1f615',
+ ':-P':'1f61b',
+ ':Þ':'1f61b',
+ ':-b':'1f61b',
+ ':-O':'1f62e',
+ 'O_O':'1f62e',
+ '>:O':'1f62e',
+ ':-X':'1f636',
+ ':-#':'1f636',
+ ':-)':'1f642',
+ '(y)':'1f44d',
+ '<3':'2764',
+ ':D':'1f603',
+ '=D':'1f603',
+ ';)':'1f609',
+ '*)':'1f609',
+ ';]':'1f609',
+ ';D':'1f609',
+ ':*':'1f618',
+ '=*':'1f618',
+ ':(':'1f61e',
+ ':[':'1f61e',
+ '=(':'1f61e',
+ ':@':'1f620',
+ ';(':'1f622',
+ 'D:':'1f628',
+ ':$':'1f633',
+ '=$':'1f633',
+ '#)':'1f635',
+ '%)':'1f635',
+ 'X)':'1f635',
+ 'B)':'1f60e',
+ '8)':'1f60e',
+ ':/':'1f615',
+ ':\\':'1f615',
+ '=/':'1f615',
+ '=\\':'1f615',
+ ':L':'1f615',
+ '=L':'1f615',
+ ':P':'1f61b',
+ '=P':'1f61b',
+ ':b':'1f61b',
+ ':O':'1f62e',
+ ':X':'1f636',
+ ':#':'1f636',
+ '=X':'1f636',
+ '=#':'1f636',
+ ':)':'1f642',
+ '=]':'1f642',
+ '=)':'1f642',
+ ':]':'1f642'
+ };
+
+ ns.asciiRegexp = '(\\*\\\\0\\/\\*|\\*\\\\O\\/\\*|\\-___\\-|\\:\'\\-\\)|\'\\:\\-\\)|\'\\:\\-D|\\>\\:\\-\\)|>\\:\\-\\)|\'\\:\\-\\(|\\>\\:\\-\\(|>\\:\\-\\(|\\:\'\\-\\(|O\\:\\-\\)|0\\:\\-3|0\\:\\-\\)|0;\\^\\)|O;\\-\\)|0;\\-\\)|O\\:\\-3|\\-__\\-|\\:\\-Þ|\\:\\-Þ|\\<\\/3|<\\/3|\\:\'\\)|\\:\\-D|\'\\:\\)|\'\\=\\)|\'\\:D|\'\\=D|\\>\\:\\)|>\\:\\)|\\>;\\)|>;\\)|\\>\\=\\)|>\\=\\)|;\\-\\)|\\*\\-\\)|;\\-\\]|;\\^\\)|\'\\:\\(|\'\\=\\(|\\:\\-\\*|\\:\\^\\*|\\>\\:P|>\\:P|X\\-P|\\>\\:\\[|>\\:\\[|\\:\\-\\(|\\:\\-\\[|\\>\\:\\(|>\\:\\(|\\:\'\\(|;\\-\\(|\\>\\.\\<|>\\.<|#\\-\\)|%\\-\\)|X\\-\\)|\\\\0\\/|\\\\O\\/|0\\:3|0\\:\\)|O\\:\\)|O\\=\\)|O\\:3|B\\-\\)|8\\-\\)|B\\-D|8\\-D|\\-_\\-|\\>\\:\\\\|>\\:\\\\|\\>\\:\\/|>\\:\\/|\\:\\-\\/|\\:\\-\\.|\\:\\-P|\\:Þ|\\:Þ|\\:\\-b|\\:\\-O|O_O|\\>\\:O|>\\:O|\\:\\-X|\\:\\-#|\\:\\-\\)|\\(y\\)|\\<3|<3|\\:D|\\=D|;\\)|\\*\\)|;\\]|;D|\\:\\*|\\=\\*|\\:\\(|\\:\\[|\\=\\(|\\:@|;\\(|D\\:|\\:\\$|\\=\\$|#\\)|%\\)|X\\)|B\\)|8\\)|\\:\\/|\\:\\\\|\\=\\/|\\=\\\\|\\:L|\\=L|\\:P|\\=P|\\:b|\\:O|\\:X|\\:#|\\=X|\\=#|\\:\\)|\\=\\]|\\=\\)|\\:\\])';
+
+ ns.emojiVersion = '3.1'; // you can [optionally] modify this to load alternate emoji versions. see readme for backwards compatibility and version options
+ ns.emojiSize = '32';
+ ns.greedyMatch = false; // set to true for greedy unicode matching
+ ns.blacklistChars = '';
+ ns.imagePathPNG = 'https://cdn.jsdelivr.net/emojione/assets/' + ns.emojiVersion + '/png/';
+ ns.defaultPathPNG = ns.imagePathPNG;
+ ns.imageTitleTag = true; // set to false to remove title attribute from img tag
+ ns.sprites = false; // if this is true then sprite markup will be used
+ ns.unicodeAlt = true; // use the unicode char as the alt attribute (makes copy and pasting the resulting text better)
+ ns.ascii = false; // change to true to convert ascii smileys
+ ns.riskyMatchAscii = false; // set true to match ascii without leading/trailing space char
+
+ ns.regShortNames = new RegExp("<object[^>]*>.*?<\/object>|<span[^>]*>.*?<\/span>|<(?:object|embed|svg|img|div|span|p|a)[^>]*>|("+ns.shortnames+")", "gi");
+ ns.regAscii = new RegExp("<object[^>]*>.*?<\/object>|<span[^>]*>.*?<\/span>|<(?:object|embed|svg|img|div|span|p|a)[^>]*>|((\\s|^)"+ns.asciiRegexp+"(?=\\s|$|[!,.?]))", "gi");
+ ns.regAsciiRisky = new RegExp("<object[^>]*>.*?<\/object>|<span[^>]*>.*?<\/span>|<(?:object|embed|svg|img|div|span|p|a)[^>]*>|(()"+ns.asciiRegexp+"())", "gi");
+
+ ns.regUnicode = new RegExp("<object[^>]*>.*?<\/object>|<span[^>]*>.*?<\/span>|<(?:object|embed|svg|img|div|span|p|a)[^>]*>|(?:\uD83C\uDFF3)\uFE0F?\u200D?(?:\uD83C\uDF08)|(?:\uD83D\uDC41)\uFE0F?\u200D?(?:\uD83D\uDDE8)\uFE0F?|[#-9]\uFE0F?\u20E3|(?:(?:\uD83C\uDFF4)(?:\uDB40[\uDC60-\uDCFF]){1,6})|(?:\uD83C[\uDDE0-\uDDFF]){2}|(?:(?:\uD83D[\uDC68\uDC69]))\uFE0F?(?:\uD83C[\uDFFA-\uDFFF])?\u200D?(?:[\u2695\u2696\u2708]|\uD83C[\uDF3E-\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92])|(?:\uD83D[\uDC68\uDC69]|\uD83E[\uDDD0-\uDDDF])(?:\uD83C[\uDFFA-\uDFFF])?\u200D?[\u2640\u2642\u2695\u2696\u2708]?\uFE0F?|(?:(?:\u2764|\uD83D[\uDC66-\uDC69\uDC8B])[\u200D\uFE0F]{0,2}){1,3}(?:\u2764|\uD83D[\uDC66-\uDC69\uDC8B])|(?:(?:\u2764|\uD83D[\uDC66-\uDC69\uDC8B])\uFE0F?){2,4}|(?:\uD83D[\uDC68\uDC69\uDC6E\uDC71-\uDC87\uDD75\uDE45-\uDE4E]|\uD83E[\uDD26\uDD37]|\uD83C[\uDFC3-\uDFCC]|\uD83E[\uDD38-\uDD3E]|\uD83D[\uDEA3-\uDEB6]|\u26f9|\uD83D\uDC6F)\uFE0F?(?:\uD83C[\uDFFB-\uDFFF])?\u200D?[\u2640\u2642]?\uFE0F?|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85-\uDFCC]|\uD83D[\uDC42-\uDCAA\uDD74-\uDD96\uDE45-\uDE4F\uDEA3-\uDECC]|\uD83E[\uDD18-\uDD3E])\uFE0F?(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u2194-\u2199\u21a9-\u21aa]\uFE0F?|[\u0023\u002a]|[\u3030\u303d]\uFE0F?|(?:\ud83c[\udd70-\udd71]|\ud83c\udd8e|\ud83c[\udd91-\udd9a])\uFE0F?|\u24c2\uFE0F?|[\u3297\u3299]\uFE0F?|(?:\ud83c[\ude01-\ude02]|\ud83c\ude1a|\ud83c\ude2f|\ud83c[\ude32-\ude3a]|\ud83c[\ude50-\ude51])\uFE0F?|[\u203c\u2049]\uFE0F?|[\u25aa-\u25ab\u25b6\u25c0\u25fb-\u25fe]\uFE0F?|[\u00a9\u00ae]\uFE0F?|[\u2122\u2139]\uFE0F?|\ud83c\udc04\uFE0F?|[\u2b05-\u2b07\u2b1b-\u2b1c\u2b50\u2b55]\uFE0F?|[\u231a-\u231b\u2328\u23cf\u23e9-\u23f3\u23f8-\u23fa]\uFE0F?|\ud83c\udccf|[\u2934\u2935]\uFE0F?)|[\u2700-\u27bf]\uFE0F?|[\ud800-\udbff][\udc00-\udfff]\uFE0F?|[\u2600-\u26FF]\uFE0F?|[\u0030-\u0039]\uFE0F", "g");
+
+ ns.toImage = function(str) {
+ str = ns.unicodeToImage(str);
+ str = ns.shortnameToImage(str);
+ return str;
+ };
+
+ // Uses toShort to transform all unicode into a standard shortname
+ // then transforms the shortname into unicode
+ // This is done for standardization when converting several unicode types
+ ns.unifyUnicode = function(str) {
+ str = ns.toShort(str);
+ str = ns.shortnameToUnicode(str);
+ return str;
+ };
+
+ // Replace shortnames (:wink:) with Ascii equivalents ( ;^) )
+ // Useful for systems that dont support unicode nor images
+ ns.shortnameToAscii = function(str) {
+ var unicode,
+ // something to keep in mind here is that array flip will destroy
+ // half of the ascii text "emojis" because the unicode numbers are duplicated
+ // this is ok for what it's being used for
+ unicodeToAscii = ns.objectFlip(ns.asciiList);
+
+ str = str.replace(ns.regShortNames, function(shortname) {
+ if( (typeof shortname === 'undefined') || (shortname === '') || (!(shortname in ns.emojioneList)) ) {
+ // if the shortname doesnt exist just return the entire match
+ return shortname;
+ }
+ else {
+ unicode = ns.emojioneList[shortname].uc_output;
+ if(typeof unicodeToAscii[unicode] !== 'undefined') {
+ return unicodeToAscii[unicode];
+ } else {
+ return shortname;
+ }
+ }
+ });
+ return str;
+ };
+
+ // will output unicode from shortname
+ // useful for sending emojis back to mobile devices
+ ns.shortnameToUnicode = function(str) {
+ // replace regular shortnames first
+ var unicode,fname;
+ str = str.replace(ns.regShortNames, function(shortname) {
+ if( (typeof shortname === 'undefined') || (shortname === '') || (!(shortname in ns.emojioneList)) ) {
+ // if the shortname doesnt exist just return the entire matchhju
+ return shortname;
+ }
+ unicode = ns.emojioneList[shortname].uc_output.toUpperCase();
+ fname = ns.emojioneList[shortname].uc_base;
+ return ns.convert(unicode);
+ });
+
+ // if ascii smileys are turned on, then we'll replace them!
+ if (ns.ascii) {
+
+ var asciiRX = ns.riskyMatchAscii ? ns.regAsciiRisky : ns.regAscii;
+
+ str = str.replace(asciiRX, function(entire, m1, m2, m3) {
+ if( (typeof m3 === 'undefined') || (m3 === '') || (!(ns.unescapeHTML(m3) in ns.asciiList)) ) {
+ // if the ascii doesnt exist just return the entire match
+ return entire;
+ }
+
+ m3 = ns.unescapeHTML(m3);
+ unicode = ns.asciiList[m3].toUpperCase();
+ return m2+ns.convert(unicode);
+ });
+ }
+
+ return str;
+ };
+
+ ns.shortnameToImage = function(str) {
+ // replace regular shortnames first
+ var replaceWith,shortname,unicode,fname,alt,category,title,size,ePath;
+ var mappedUnicode = ns.mapUnicodeToShort();
+ str = str.replace(ns.regShortNames, function(shortname) {
+ if( (typeof shortname === 'undefined') || (shortname === '') || (ns.shortnames.indexOf(shortname) === -1) ) {
+ // if the shortname doesnt exist just return the entire match
+ return shortname;
+ }
+ else {
+ // map shortname to parent
+ if (!ns.emojioneList[shortname]) {
+ for ( var emoji in ns.emojioneList ) {
+ if (!ns.emojioneList.hasOwnProperty(emoji) || (emoji === '')) continue;
+ if (ns.emojioneList[emoji].shortnames.indexOf(shortname) === -1) continue;
+ shortname = emoji;
+ break;
+ }
+ }
+ unicode = ns.emojioneList[shortname].uc_output;
+ fname = ns.emojioneList[shortname].uc_base;
+ category = (fname.includes("-1f3f")) ? 'diversity' : ns.emojioneList[shortname].category;
+ title = ns.imageTitleTag ? 'title="' + shortname + '"' : '';
+ size = (ns.spriteSize == '32' || ns.spriteSize == '64') ? ns.spriteSize : '32';
+ //if the emoji path has been set, we'll use the provided path, otherwise we'll use the default path
+ ePath = (ns.defaultPathPNG !== ns.imagePathPNG) ? ns.imagePathPNG : ns.defaultPathPNG + ns.emojiSize + '/';
+
+ // depending on the settings, we'll either add the native unicode as the alt tag, otherwise the shortname
+ alt = (ns.unicodeAlt) ? ns.convert(unicode.toUpperCase()) : shortname;
+
+ if(ns.sprites) {
+ replaceWith = '<span class="emojione emojione-' + size + '-' + category + ' _' + fname + '" ' + title + '>' + alt + '</span>';
+ }
+ else {
+ replaceWith = '<img class="emojione" alt="' + alt + '" ' + title + ' src="' + ePath + fname + '.png"/>';
+ }
+
+ return replaceWith;
+ }
+ });
+
+ // if ascii smileys are turned on, then we'll replace them!
+ if (ns.ascii) {
+
+ var asciiRX = ns.riskyMatchAscii ? ns.regAsciiRisky : ns.regAscii;
+
+ str = str.replace(asciiRX, function(entire, m1, m2, m3) {
+ if( (typeof m3 === 'undefined') || (m3 === '') || (!(ns.unescapeHTML(m3) in ns.asciiList)) ) {
+ // if the ascii doesnt exist just return the entire match
+ return entire;
+ }
+
+ m3 = ns.unescapeHTML(m3);
+ unicode = ns.asciiList[m3];
+ shortname = mappedUnicode[unicode];
+ category = (unicode.includes("-1f3f")) ? 'diversity' : ns.emojioneList[shortname].category;
+ title = ns.imageTitleTag ? 'title="' + ns.escapeHTML(m3) + '"' : '';
+ size = (ns.spriteSize == '32' || ns.spriteSize == '64') ? ns.spriteSize : '32';
+ //if the emoji path has been set, we'll use the provided path, otherwise we'll use the default path
+ ePath = (ns.defaultPathPNG !== ns.imagePathPNG) ? ns.imagePathPNG : ns.defaultPathPNG + ns.emojiSize + '/';
+
+ // depending on the settings, we'll either add the native unicode as the alt tag, otherwise the shortname
+ alt = (ns.unicodeAlt) ? ns.convert(unicode.toUpperCase()) : ns.escapeHTML(m3);
+
+ if(ns.sprites) {
+ replaceWith = m2+'<span class="emojione emojione-' + size + '-' + category + ' _' + unicode +'" ' + title + '>' + alt + '</span>';
+ }
+ else {
+ replaceWith = m2+'<img class="emojione" alt="'+alt+'" ' + title + ' src="' + ePath + unicode + '.png"/>';
+ }
+
+ return replaceWith;
+ });
+ }
+
+ return str;
+ };
+
+ ns.unicodeToImage = function(str) {
+
+ var replaceWith,unicode,short,fname,alt,category,title,size,ePath;
+ var mappedUnicode = ns.mapUnicodeToShort();
+ var eList = ns.emojioneList;
+ var bList = ns.blacklistChars.split(',');
+ str = str.replace(ns.regUnicode, function(unicodeChar) {
+ if( (typeof unicodeChar === 'undefined') || (unicodeChar === '') )
+ {
+ return unicodeChar;
+ }
+ else if ( unicodeChar in ns.jsEscapeMap && bList.indexOf(unicodeChar) === -1 )
+ {
+ fname = ns.jsEscapeMap[unicodeChar];
+ }
+ else if ( ns.greedyMatch && unicodeChar in ns.jsEscapeMapGreedy && bList.indexOf(unicodeChar) === -1 )
+ {
+ fname = ns.jsEscapeMapGreedy[unicodeChar];
+ }
+ else
+ {
+ return unicodeChar;
+ }
+
+ // then map to shortname and locate the filename
+ short = mappedUnicode[fname];
+
+ // then pull the unicode output from emojioneList
+ fname = eList[short].uc_base;
+ unicode = eList[short].uc_output;
+ category = (fname.includes("-1f3f")) ? 'diversity' : eList[short].category;
+ size = (ns.spriteSize == '32' || ns.spriteSize == '64') ? ns.spriteSize : '32';
+ //if the emoji path has been set, we'll use the provided path, otherwise we'll use the default path
+ ePath = (ns.defaultPathPNG !== ns.imagePathPNG) ? ns.imagePathPNG : ns.defaultPathPNG + ns.emojiSize + '/';
+
+ // depending on the settings, we'll either add the native unicode as the alt tag, otherwise the shortname
+ alt = (ns.unicodeAlt) ? ns.convert(unicode.toUpperCase()) : short;
+ title = ns.imageTitleTag ? 'title="' + short + '"' : '';
+
+ if(ns.sprites) {
+ replaceWith = '<span class="emojione emojione-' + size + '-' + category + ' _' + fname + '" ' + title + '>' + alt + '</span>';
+ }
+ else {
+ replaceWith = '<img class="emojione" alt="' + alt + '" ' + title + ' src="' + ePath + fname + '.png"/>';
+ }
+
+ return replaceWith;
+ });
+
+ // if ascii smileys are turned on, then we'll replace them!
+ if (ns.ascii) {
+
+ var asciiRX = ns.riskyMatchAscii ? ns.regAsciiRisky : ns.regAscii;
+
+ str = str.replace(asciiRX, function(entire, m1, m2, m3) {
+ if( (typeof m3 === 'undefined') || (m3 === '') || (!(ns.unescapeHTML(m3) in ns.asciiList)) ) {
+ // if the ascii doesnt exist just return the entire match
+ return entire;
+ }
+
+ m3 = ns.unescapeHTML(m3);
+ unicode = ns.asciiList[m3];
+ shortname = mappedUnicode[unicode];
+ category = (unicode.includes("-1f3f")) ? 'diversity' : ns.emojioneList[shortname].category;
+ title = ns.imageTitleTag ? 'title="' + ns.escapeHTML(m3) + '"' : '';
+ size = (ns.spriteSize == '32' || ns.spriteSize == '64') ? ns.spriteSize : '32';
+ //if the emoji path has been set, we'll use the provided path, otherwise we'll use the default path
+ ePath = (ns.defaultPathPNG !== ns.imagePathPNG) ? ns.imagePathPNG : ns.defaultPathPNG + ns.emojiSize + '/';
+
+ // depending on the settings, we'll either add the native unicode as the alt tag, otherwise the shortname
+ alt = (ns.unicodeAlt) ? ns.convert(unicode.toUpperCase()) : ns.escapeHTML(m3);
+
+ if(ns.sprites) {
+ replaceWith = m2+'<span class="emojione emojione-' + size + '-' + category + ' _' + unicode +'" ' + title + '>' + alt + '</span>';
+ }
+ else {
+ replaceWith = m2+'<img class="emojione" alt="'+alt+'" ' + title + ' src="' + ePath + unicode + '.png"/>';
+ }
+
+ return replaceWith;
+ });
+ }
+
+ return str;
+ };
+
+ // this is really just unicodeToShortname() but I opted for the shorthand name to match toImage()
+ ns.toShort = function(str) {
+ var find = ns.unicodeCharRegex();
+ return ns.replaceAll(str, find);
+ };
+
+ // for converting unicode code points and code pairs to their respective characters
+ ns.convert = function(unicode) {
+ if(unicode.indexOf("-") > -1) {
+ var parts = [];
+ var s = unicode.split('-');
+ for(var i = 0; i < s.length; i++) {
+ var part = parseInt(s[i], 16);
+ if (part >= 0x10000 && part <= 0x10FFFF) {
+ var hi = Math.floor((part - 0x10000) / 0x400) + 0xD800;
+ var lo = ((part - 0x10000) % 0x400) + 0xDC00;
+ part = (String.fromCharCode(hi) + String.fromCharCode(lo));
+ }
+ else {
+ part = String.fromCharCode(part);
+ }
+ parts.push(part);
+ }
+ return parts.join('');
+ }
+ else {
+ var s = parseInt(unicode, 16);
+ if (s >= 0x10000 && s <= 0x10FFFF) {
+ var hi = Math.floor((s - 0x10000) / 0x400) + 0xD800;
+ var lo = ((s - 0x10000) % 0x400) + 0xDC00;
+ return (String.fromCharCode(hi) + String.fromCharCode(lo));
+ }
+ else {
+ return String.fromCharCode(s);
+ }
+ }
+ };
+
+ ns.escapeHTML = function (string) {
+ var escaped = {
+ '&' : '&',
+ '<' : '<',
+ '>' : '>',
+ '"' : '"',
+ '\'': '''
+ };
+
+ return string.replace(/[&<>"']/g, function (match) {
+ return escaped[match];
+ });
+ };
+ ns.unescapeHTML = function (string) {
+ var unescaped = {
+ '&' : '&',
+ '&' : '&',
+ '&' : '&',
+ '<' : '<',
+ '<' : '<',
+ '<' : '<',
+ '>' : '>',
+ '>' : '>',
+ '>' : '>',
+ '"' : '"',
+ '"' : '"',
+ '"' : '"',
+ ''' : '\'',
+ ''' : '\'',
+ ''' : '\''
+ };
+
+ return string.replace(/&(?:amp|#38|#x26|lt|#60|#x3C|gt|#62|#x3E|apos|#39|#x27|quot|#34|#x22);/ig, function (match) {
+ return unescaped[match];
+ });
+ };
+
+ ns.shortnameConversionMap = function() {
+ var map = [], emoji;
+ for (emoji in ns.emojioneList) {
+ if (!ns.emojioneList.hasOwnProperty(emoji) || (emoji === '')) continue;
+ map[ns.convert(ns.emojioneList[emoji].uc_output)] = emoji;
+ }
+ return map;
+ };
+
+ ns.unicodeCharRegex = function() {
+ var map = [];
+ for (emoji in ns.emojioneList) {
+ if (!ns.emojioneList.hasOwnProperty(emoji) || (emoji === '')) continue;
+ map.push(ns.convert(ns.emojioneList[emoji].uc_output));
+ }
+ return map.join('|');
+ };
+
+ ns.mapEmojioneList = function (addToMapStorage) {
+ for (var shortname in ns.emojioneList) {
+ if (!ns.emojioneList.hasOwnProperty(shortname)) { continue; }
+ var unicode = ns.emojioneList[shortname].uc_base;
+ addToMapStorage(unicode, shortname);
+ }
+ };
+
+ ns.mapUnicodeToShort = function() {
+ if (!ns.memMapShortToUnicode) {
+ ns.memMapShortToUnicode = {};
+ ns.mapEmojioneList(function (unicode, shortname) {
+ ns.memMapShortToUnicode[unicode] = shortname;
+ });
+ }
+ return ns.memMapShortToUnicode;
+ };
+
+ ns.memorizeReplacement = function() {
+ if (!ns.unicodeReplacementRegEx || !ns.memMapShortToUnicodeCharacters) {
+ var unicodeList = [];
+ ns.memMapShortToUnicodeCharacters = {};
+ ns.mapEmojioneList(function (unicode, shortname) {
+ var emojiCharacter = ns.convert(unicode);
+ ns.memMapShortToUnicodeCharacters[emojiCharacter] = shortname;
+ unicodeList.push(emojiCharacter);
+ });
+ ns.unicodeReplacementRegEx = unicodeList.join('|');
+ }
+ };
+
+ ns.mapUnicodeCharactersToShort = function() {
+ ns.memorizeReplacement();
+ return ns.memMapShortToUnicodeCharacters;
+ };
+
+ //reverse an object
+ ns.objectFlip = function (obj) {
+ var key, tmp_obj = {};
+
+ for (key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ tmp_obj[obj[key]] = key;
+ }
+ }
+
+ return tmp_obj;
+ };
+
+ ns.escapeRegExp = function(string) {
+ return string.replace(/[-[\]{}()*+?.,;:&\\^$#\s]/g, "\\$&");
+ };
+
+ ns.replaceAll = function(string, find) {
+ var escapedFind = ns.escapeRegExp(find); //sorted largest output to smallest output
+ var search = new RegExp("<object[^>]*>.*?<\/object>|<span[^>]*>.*?<\/span>|<(?:object|embed|svg|img|div|span|p|a)[^>]*>|("+escapedFind+")", "gi");
+
+ // callback prevents replacing anything inside of these common html tags as well as between an <object></object> tag
+
+ var replace = function(entire, m1) {
+ return ((typeof m1 === 'undefined') || (m1 === '')) ? entire : ns.shortnameConversionMap()[m1];
+ };
+
+ return string.replace(search,replace);
+ };
+
+}(this.emojione = this.emojione || {}));
+if(true) module.exports = this.emojione;
+
+/***/ }),
+
+/***/ "./node_modules/emojionearea/dist/emojionearea.js":
+/*!********************************************************!*\
+ !*** ./node_modules/emojionearea/dist/emojionearea.js ***!
+ \********************************************************/
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+/* provided dependency */ var __webpack_provided_window_dot_emojione = __webpack_require__(/*! emojione */ "./node_modules/emojione/lib/js/emojione.js");
+/*!
+ * EmojioneArea v3.4.1
+ * https://github.com/mervick/emojionearea
+ * Copyright Andrey Izman and other contributors
+ * Released under the MIT license
+ * Date: 2018-04-27T09:03Z
+ */
+window = ( typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {} );
+document = window.document || {};
+
+; ( function ( factory, global ) {
+ if ( true ) {
+
+ // CommonJS
+ factory( __webpack_require__( /*! jquery */ "./node_modules/jquery/dist/jquery.js" ) );
+ } else {}
+}( function ( $ ) {
+ "use strict";
+
+ var unique = 0;
+ var eventStorage = {};
+ var possibleEvents = {};
+ var emojione = __webpack_provided_window_dot_emojione;
+ var readyCallbacks = [];
+ function emojioneReady (fn) {
+ if (emojione) {
+ fn();
+ } else {
+ readyCallbacks.push(fn);
+ }
+ };
+ var blankImg = 'data:image/gif;base64,R0lGODlhAQABAJH/AP///wAAAMDAwAAAACH5BAEAAAIALAAAAAABAAEAAAICVAEAOw==';
+ var slice = [].slice;
+ var css_class = "emojionearea";
+ var emojioneSupportMode = 0;
+ var invisibleChar = '​';
+ function trigger(self, event, args) {
+ var result = true, j = 1;
+ if (event) {
+ event = event.toLowerCase();
+ do {
+ var _event = j==1 ? '@' + event : event;
+ if (eventStorage[self.id][_event] && eventStorage[self.id][_event].length) {
+ $.each(eventStorage[self.id][_event], function (i, fn) {
+ return result = fn.apply(self, args|| []) !== false;
+ });
+ }
+ } while (result && !!j--);
+ }
+ return result;
+ }
+ function attach(self, element, events, target) {
+ target = target || function (event, callerEvent) { return $(callerEvent.currentTarget) };
+ $.each(events, function(event, link) {
+ event = $.isArray(events) ? link : event;
+ (possibleEvents[self.id][link] || (possibleEvents[self.id][link] = []))
+ .push([element, event, target]);
+ });
+ }
+ function getTemplate(template, unicode, shortname) {
+ var imageType = emojione.imageType, imagePath;
+ if (imageType=='svg'){
+ imagePath = emojione.imagePathSVG;
+ } else {
+ imagePath = emojione.imagePathPNG;
+ }
+ var friendlyName = '';
+ if (shortname) {
+ friendlyName = shortname.substr(1, shortname.length - 2).replace(/_/g, ' ').replace(/\w\S*/g, function(txt) { return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
+ }
+ var fname = '';
+ if (unicode.uc_base && emojioneSupportMode > 4) {
+ fname = unicode.uc_base;
+ unicode = unicode.uc_output.toUpperCase();
+ } else {
+ fname = unicode;
+ }
+ template = template.replace('{name}', shortname || '')
+ .replace('{friendlyName}', friendlyName)
+ .replace('{img}', imagePath + (emojioneSupportMode < 2 ? fname.toUpperCase() : fname) + '.' + imageType)
+ .replace('{uni}', unicode);
+
+ if(shortname) {
+ template = template.replace('{alt}', emojione.shortnameToUnicode(shortname));
+ } else {
+ template = template.replace('{alt}', emojione.convert(unicode));
+ }
+
+ return template;
+ };
+ function shortnameTo(str, template, clear) {
+ return str.replace(/:?\+?[\w_\-]+:?/g, function(shortname) {
+ shortname = ":" + shortname.replace(/:$/,'').replace(/^:/,'') + ":";
+ var unicode = emojione.emojioneList[shortname];
+ if (unicode) {
+ if (emojioneSupportMode > 4) {
+ return getTemplate(template, unicode, shortname);
+ } else {
+ if (emojioneSupportMode > 3) unicode = unicode.unicode;
+ return getTemplate(template, unicode[unicode.length-1], shortname);
+ }
+ }
+ return clear ? '' : shortname;
+ });
+ };
+ function pasteHtmlAtCaret(html) {
+ var sel, range;
+ if (window.getSelection) {
+ sel = window.getSelection();
+ if (sel.getRangeAt && sel.rangeCount) {
+ range = sel.getRangeAt(0);
+ range.deleteContents();
+ var el = document.createElement("div");
+ el.innerHTML = html;
+ var frag = document.createDocumentFragment(), node, lastNode;
+ while ( (node = el.firstChild) ) {
+ lastNode = frag.appendChild(node);
+ }
+ range.insertNode(frag);
+ if (lastNode) {
+ range = range.cloneRange();
+ range.setStartAfter(lastNode);
+ range.collapse(true);
+ sel.removeAllRanges();
+ sel.addRange(range);
+ }
+ }
+ } else if (document.selection && document.selection.type != "Control") {
+ document.selection.createRange().pasteHTML(html);
+ }
+ }
+ function getEmojioneVersion() {
+ return window.emojioneVersion || '3.1.2';
+ };
+ function isObject(variable) {
+ return typeof variable === 'object';
+ };
+ function detectVersion(emojione) {
+ var version;
+ if (emojione.cacheBustParam) {
+ version = emojione.cacheBustParam;
+ if (!isObject(emojione['jsEscapeMap'])) return '1.5.2';
+ if (version === "?v=1.2.4") return '2.0.0';
+ if (version === "?v=2.0.1") return '2.1.0'; // v2.0.1 || v2.1.0
+ if (version === "?v=2.1.1") return '2.1.1';
+ if (version === "?v=2.1.2") return '2.1.2';
+ if (version === "?v=2.1.3") return '2.1.3';
+ if (version === "?v=2.1.4") return '2.1.4';
+ if (version === "?v=2.2.7") return '2.2.7';
+ return '2.2.7';
+ } else {
+ return emojione.emojiVersion;
+ }
+ };
+ function getSupportMode(version) {
+ switch (version) {
+ case '1.5.2': return 0;
+ case '2.0.0': return 1;
+ case '2.1.0':
+ case '2.1.1': return 2;
+ case '2.1.2': return 3;
+ case '2.1.3':
+ case '2.1.4':
+ case '2.2.7': return 4;
+ case '3.0.1':
+ case '3.0.2':
+ case '3.0.3':
+ case '3.0': return 5;
+ case '3.1.0':
+ case '3.1.1':
+ case '3.1.2':
+ case '3.1':
+ default: return 6;
+ }
+ };
+ function getDefaultOptions () {
+ if ($.fn.emojioneArea && $.fn.emojioneArea.defaults) {
+ return $.fn.emojioneArea.defaults;
+ }
+
+ var defaultOptions = {
+ attributes: {
+ dir : "ltr",
+ spellcheck : false,
+ autocomplete : "off",
+ autocorrect : "off",
+ autocapitalize : "off",
+ },
+ search : true,
+ placeholder : null,
+ emojiPlaceholder : ":smiley:",
+ searchPlaceholder : "SEARCH",
+ container : null,
+ hideSource : true,
+ shortnames : true,
+ sprite : true,
+ pickerPosition : "top", // top | bottom | right
+ filtersPosition : "top", // top | bottom
+ searchPosition : "top", // top | bottom
+ hidePickerOnBlur : true,
+ buttonTitle : "Use the TAB key to insert emoji faster",
+ tones : true,
+ tonesStyle : "bullet", // bullet | radio | square | checkbox
+ inline : null, // null - auto
+ saveEmojisAs : "unicode", // unicode | shortname | image
+ shortcuts : true,
+ autocomplete : true,
+ autocompleteTones : false,
+ standalone : false,
+ useInternalCDN : true, // Use the self loading mechanism
+ imageType : "png", // Default image type used by internal CDN
+ recentEmojis : true,
+ textcomplete: {
+ maxCount : 15,
+ placement : null // null - default | top | absleft | absright
+ }
+ };
+
+ var supportMode = !emojione ? getSupportMode(getEmojioneVersion()) : getSupportMode(detectVersion(emojione));
+
+ if (supportMode > 4) {
+ defaultOptions.filters = {
+ tones: {
+ title: "Diversity",
+ emoji: "open_hands raised_hands palms_up_together clap pray thumbsup thumbsdown punch fist left_facing_fist right_facing_fist " +
+ "fingers_crossed v metal love_you_gesture ok_hand point_left point_right point_up_2 point_down point_up raised_hand " +
+ "raised_back_of_hand hand_splayed vulcan wave call_me muscle middle_finger writing_hand selfie nail_care ear " +
+ "nose baby boy girl man woman blond-haired_woman blond-haired_man older_man older_woman " +
+ "man_with_chinese_cap woman_wearing_turban man_wearing_turban woman_police_officer " +
+ "man_police_officer woman_construction_worker man_construction_worker " +
+ "woman_guard man_guard woman_detective man_detective woman_health_worker man_health_worker " +
+ "woman_farmer man_farmer woman_cook man_cook woman_student man_student woman_singer man_singer woman_teacher " +
+ "man_teacher woman_factory_worker man_factory_worker woman_technologist man_technologist woman_office_worker " +
+ "man_office_worker woman_mechanic man_mechanic woman_scientist man_scientist woman_artist man_artist " +
+ "woman_firefighter man_firefighter woman_pilot man_pilot woman_astronaut man_astronaut woman_judge " +
+ "man_judge mrs_claus santa princess prince bride_with_veil man_in_tuxedo angel pregnant_woman " +
+ "breast_feeding woman_bowing man_bowing man_tipping_hand woman_tipping_hand " +
+ "man_gesturing_no woman_gesturing_no man_gesturing_ok woman_gesturing_ok " +
+ "man_raising_hand woman_raising_hand woman_facepalming man_facepalming " +
+ "woman_shrugging man_shrugging man_pouting woman_pouting " +
+ "man_frowning woman_frowning man_getting_haircut woman_getting_haircut " +
+ "man_getting_face_massage woman_getting_face_massage man_in_business_suit_levitating dancer man_dancing " +
+ "woman_walking man_walking woman_running man_running adult child older_adult " +
+ "bearded_person woman_with_headscarf woman_mage man_mage " +
+ "woman_fairy man_fairy woman_vampire man_vampire mermaid merman woman_elf man_elf " +
+ "snowboarder woman_lifting_weights man_lifting_weights woman_cartwheeling " +
+ "man_cartwheeling woman_bouncing_ball man_bouncing_ball " +
+ "woman_playing_handball man_playing_handball woman_golfing man_golfing " +
+ "woman_surfing man_surfing woman_swimming man_swimming woman_playing_water_polo " +
+ "man_playing_water_polo woman_rowing_boat man_rowing_boat " +
+ "horse_racing woman_biking man_biking woman_mountain_biking " +
+ "man_mountain_biking woman_juggling man_juggling " +
+ "woman_in_steamy_room man_in_steamy_room woman_climbing " +
+ "man_climbing woman_in_lotus_position man_in_lotus_position bath person_in_bed"
+ },
+
+ recent: {
+ icon: "clock3",
+ title: "Recent",
+ emoji: ""
+ },
+
+ smileys_people: {
+ icon: "yum",
+ title: "Smileys & People",
+ emoji: "grinning smiley smile grin laughing sweat_smile joy rofl relaxed blush innocent slight_smile upside_down " +
+ "wink relieved crazy_face star_struck heart_eyes kissing_heart kissing kissing_smiling_eyes kissing_closed_eyes yum " +
+ "stuck_out_tongue_winking_eye stuck_out_tongue_closed_eyes stuck_out_tongue money_mouth hugging nerd sunglasses " +
+ "cowboy smirk unamused disappointed pensive worried face_with_raised_eyebrow face_with_monocle confused slight_frown " +
+ "frowning2 persevere confounded tired_face weary triumph angry rage face_with_symbols_over_mouth " +
+ "no_mouth neutral_face expressionless hushed frowning anguished open_mouth astonished dizzy_face exploding_head flushed scream " +
+ "fearful cold_sweat cry disappointed_relieved drooling_face sob sweat sleepy sleeping rolling_eyes thinking " +
+ "shushing_face face_with_hand_over_mouth lying_face grimacing zipper_mouth face_vomiting nauseated_face sneezing_face mask thermometer_face " +
+ "head_bandage smiling_imp imp japanese_ogre japanese_goblin poop ghost skull skull_crossbones alien space_invader " +
+ "robot jack_o_lantern clown smiley_cat smile_cat joy_cat heart_eyes_cat smirk_cat kissing_cat scream_cat crying_cat_face " +
+ "pouting_cat open_hands raised_hands palms_up_together clap pray handshake thumbsup thumbsdown punch fist left_facing_fist " +
+ "right_facing_fist fingers_crossed v metal love_you_gesture ok_hand point_left point_right point_up_2 point_down point_up " +
+ "raised_hand raised_back_of_hand hand_splayed vulcan wave call_me muscle middle_finger writing_hand selfie " +
+ "nail_care ring lipstick kiss lips tongue ear nose footprints eye eyes speaking_head bust_in_silhouette " +
+ "busts_in_silhouette baby boy girl man woman blond-haired_woman blond_haired_man older_man older_woman " +
+ "man_with_chinese_cap woman_wearing_turban man_wearing_turban woman_police_officer police_officer " +
+ "woman_construction_worker construction_worker woman_guard guard woman_detective detective woman_health_worker " +
+ "man_health_worker woman_farmer man_farmer woman_cook man_cook woman_student man_student woman_singer man_singer " +
+ "woman_teacher man_teacher woman_factory_worker man_factory_worker woman_technologist man_technologist " +
+ "woman_office_worker man_office_worker woman_mechanic man_mechanic woman_scientist man_scientist woman_artist " +
+ "man_artist woman_firefighter man_firefighter woman_pilot man_pilot woman_astronaut man_astronaut woman_judge " +
+ "man_judge mrs_claus santa princess prince bride_with_veil man_in_tuxedo angel pregnant_woman breast_feeding woman_bowing " +
+ "man_bowing woman_tipping_hand man_tipping_hand woman_gesturing_no man_gesturing_no woman_gesturing_ok " +
+ "man_gesturing_ok woman_raising_hand man_raising_hand woman_facepalming man_facepalming woman_shrugging " +
+ "man_shrugging woman_pouting man_pouting woman_frowning man_frowning woman_getting_haircut man_getting_haircut " +
+ "woman_getting_face_massage man_getting_face_massage man_in_business_suit_levitating dancer man_dancing women_with_bunny_ears_partying " +
+ "men_with_bunny_ears_partying woman_walking man_walking woman_running man_running couple two_women_holding_hands " +
+ "two_men_holding_hands couple_with_heart couple_ww couple_mm couplekiss kiss_ww kiss_mm family family_mwg family_mwgb " +
+ "family_mwbb family_mwgg family_wwb family_wwg family_wwgb family_wwbb family_wwgg family_mmb family_mmg family_mmgb " +
+ "family_mmbb family_mmgg family_woman_boy family_woman_girl family_woman_girl_boy family_woman_boy_boy " +
+ "family_woman_girl_girl family_man_boy family_man_girl family_man_girl_boy family_man_boy_boy family_man_girl_girl " +
+ "bearded_person woman_with_headscarf woman_mage man_mage woman_fairy man_fairy woman_vampire man_vampire " +
+ "mermaid merman woman_elf man_elf woman_genie man_genie woman_zombie man_zombie " +
+ "womans_clothes shirt jeans necktie dress bikini kimono high_heel sandal boot mans_shoe athletic_shoe womans_hat " +
+ "tophat mortar_board crown helmet_with_cross school_satchel pouch purse handbag briefcase eyeglasses dark_sunglasses " +
+ "closed_umbrella umbrella2 brain billed_cap scarf gloves coat socks "
+ },
+
+ animals_nature: {
+ icon: "hamster",
+ title: "Animals & Nature",
+ emoji: "dog cat mouse hamster rabbit fox bear panda_face koala tiger lion_face cow pig pig_nose frog monkey_face see_no_evil " +
+ "hear_no_evil speak_no_evil monkey chicken penguin bird baby_chick hatching_chick hatched_chick duck eagle owl bat wolf boar " +
+ "horse unicorn bee bug butterfly snail shell beetle ant spider spider_web turtle snake lizard scorpion crab squid octopus shrimp " +
+ "tropical_fish fish blowfish dolphin shark whale whale2 crocodile leopard tiger2 water_buffalo ox cow2 deer dromedary_camel camel " +
+ "elephant rhino gorilla racehorse pig2 goat ram sheep dog2 poodle cat2 rooster turkey dove rabbit2 mouse2 rat chipmunk dragon " +
+ "giraffe zebra hedgehog sauropod t_rex cricket dragon_face feet cactus christmas_tree evergreen_tree deciduous_tree palm_tree seedling herb shamrock four_leaf_clover " +
+ "bamboo tanabata_tree leaves fallen_leaf maple_leaf mushroom ear_of_rice bouquet tulip rose wilted_rose sunflower blossom " +
+ "cherry_blossom hibiscus earth_americas earth_africa earth_asia full_moon waning_gibbous_moon last_quarter_moon " +
+ "waning_crescent_moon new_moon waxing_crescent_moon first_quarter_moon waxing_gibbous_moon new_moon_with_face " +
+ "full_moon_with_face sun_with_face first_quarter_moon_with_face last_quarter_moon_with_face crescent_moon dizzy star star2 " +
+ "sparkles zap fire boom comet sunny white_sun_small_cloud partly_sunny white_sun_cloud white_sun_rain_cloud rainbow cloud " +
+ "cloud_rain thunder_cloud_rain cloud_lightning cloud_snow snowman2 snowman snowflake wind_blowing_face dash cloud_tornado " +
+ "fog ocean droplet sweat_drops umbrella "
+ },
+
+ food_drink: {
+ icon: "pizza",
+ title: "Food & Drink",
+ emoji: "green_apple apple pear tangerine lemon banana watermelon grapes strawberry melon cherries peach pineapple kiwi " +
+ "avocado tomato eggplant cucumber carrot corn hot_pepper potato sweet_potato chestnut peanuts honey_pot croissant " +
+ "bread french_bread cheese egg cooking bacon pancakes fried_shrimp poultry_leg meat_on_bone pizza hotdog hamburger " +
+ "fries stuffed_flatbread taco burrito salad shallow_pan_of_food spaghetti ramen stew fish_cake sushi bento curry " +
+ "rice_ball rice rice_cracker oden dango shaved_ice ice_cream icecream cake birthday custard lollipop candy " +
+ "chocolate_bar popcorn doughnut cookie milk baby_bottle coffee tea sake beer beers champagne_glass wine_glass " +
+ "tumbler_glass cocktail tropical_drink champagne spoon fork_and_knife fork_knife_plate dumpling fortune_cookie " +
+ "takeout_box chopsticks bowl_with_spoon cup_with_straw coconut broccoli pie pretzel cut_of_meat sandwich canned_food"
+ },
+
+ activity: {
+ icon: "basketball",
+ title: "Activity",
+ emoji: "soccer basketball football baseball tennis volleyball rugby_football 8ball ping_pong badminton goal hockey field_hockey " +
+ "cricket_game golf bow_and_arrow fishing_pole_and_fish boxing_glove martial_arts_uniform ice_skate ski skier snowboarder " +
+ "woman_lifting_weights man_lifting_weights person_fencing women_wrestling men_wrestling woman_cartwheeling " +
+ "man_cartwheeling woman_bouncing_ball man_bouncing_ball woman_playing_handball man_playing_handball woman_golfing " +
+ "man_golfing woman_surfing man_surfing woman_swimming man_swimming woman_playing_water_polo " +
+ "man_playing_water_polo woman_rowing_boat man_rowing_boat horse_racing woman_biking man_biking woman_mountain_biking man_mountain_biking " +
+ "woman_in_steamy_room man_in_steamy_room woman_climbing man_climbing woman_in_lotus_position man_in_lotus_position " +
+ "running_shirt_with_sash medal military_medal first_place second_place " +
+ "third_place trophy rosette reminder_ribbon ticket tickets circus_tent woman_juggling man_juggling performing_arts art " +
+ "clapper microphone headphones musical_score musical_keyboard drum saxophone trumpet guitar violin game_die dart bowling " +
+ "video_game slot_machine sled curling_stone "
+ },
+
+ travel_places: {
+ icon: "rocket",
+ title: "Travel & Places",
+ emoji: "red_car taxi blue_car bus trolleybus race_car police_car ambulance fire_engine minibus truck articulated_lorry tractor " +
+ "scooter bike motor_scooter motorcycle rotating_light oncoming_police_car oncoming_bus oncoming_automobile oncoming_taxi " +
+ "aerial_tramway mountain_cableway suspension_railway railway_car train mountain_railway monorail bullettrain_side " +
+ "bullettrain_front light_rail steam_locomotive train2 metro tram station helicopter airplane_small airplane " +
+ "airplane_departure airplane_arriving rocket satellite_orbital seat canoe sailboat motorboat speedboat cruise_ship " +
+ "ferry ship anchor construction fuelpump busstop vertical_traffic_light traffic_light map moyai statue_of_liberty " +
+ "fountain tokyo_tower european_castle japanese_castle stadium ferris_wheel roller_coaster carousel_horse beach_umbrella " +
+ "beach island mountain mountain_snow mount_fuji volcano desert camping tent railway_track motorway construction_site " +
+ "factory house house_with_garden homes house_abandoned office department_store post_office european_post_office hospital " +
+ "bank hotel convenience_store school love_hotel wedding classical_building church mosque synagogue kaaba shinto_shrine " +
+ "japan rice_scene park sunrise sunrise_over_mountains stars sparkler fireworks city_sunset city_dusk cityscape " +
+ "night_with_stars milky_way bridge_at_night foggy flying_saucer"
+ },
+
+ objects: {
+ icon: "bulb",
+ title: "Objects",
+ emoji: "watch iphone calling computer keyboard desktop printer mouse_three_button trackball joystick compression minidisc " +
+ "floppy_disk cd dvd vhs camera camera_with_flash video_camera movie_camera projector film_frames telephone_receiver " +
+ "telephone pager fax tv radio microphone2 level_slider control_knobs stopwatch timer alarm_clock clock hourglass " +
+ "hourglass_flowing_sand satellite battery electric_plug bulb flashlight candle wastebasket oil money_with_wings " +
+ "dollar yen euro pound moneybag credit_card gem scales wrench hammer hammer_pick tools pick nut_and_bolt gear " +
+ "chains gun bomb knife dagger crossed_swords shield smoking coffin urn amphora crystal_ball prayer_beads barber " +
+ "alembic telescope microscope hole pill syringe thermometer toilet potable_water shower bathtub bath bellhop key " +
+ "key2 door couch bed sleeping_accommodation frame_photo shopping_bags shopping_cart gift balloon flags ribbon " +
+ "confetti_ball tada dolls izakaya_lantern wind_chime envelope envelope_with_arrow incoming_envelope e-mail " +
+ "love_letter inbox_tray outbox_tray package label mailbox_closed mailbox mailbox_with_mail mailbox_with_no_mail " +
+ "postbox postal_horn scroll page_with_curl page_facing_up bookmark_tabs bar_chart chart_with_upwards_trend " +
+ "chart_with_downwards_trend notepad_spiral calendar_spiral calendar date card_index card_box ballot_box " +
+ "file_cabinet clipboard file_folder open_file_folder dividers newspaper2 newspaper notebook " +
+ "notebook_with_decorative_cover ledger closed_book green_book blue_book orange_book books book bookmark link " +
+ "paperclip paperclips triangular_ruler straight_ruler pushpin round_pushpin scissors pen_ballpoint pen_fountain " +
+ "black_nib paintbrush crayon pencil pencil2 mag mag_right lock_with_ink_pen closed_lock_with_key lock unlock"
+ },
+
+ symbols: {
+ icon: "heartpulse",
+ title: "Symbols",
+ emoji: "heart orange_heart yellow_heart green_heart blue_heart purple_heart black_heart broken_heart heart_exclamation two_hearts " +
+ "revolving_hearts heartbeat heartpulse sparkling_heart cupid gift_heart heart_decoration peace cross star_and_crescent " +
+ "om_symbol wheel_of_dharma star_of_david six_pointed_star menorah yin_yang orthodox_cross place_of_worship ophiuchus " +
+ "aries taurus gemini cancer leo virgo libra scorpius sagittarius capricorn aquarius pisces id atom accept radioactive " +
+ "biohazard mobile_phone_off vibration_mode u6709 u7121 u7533 u55b6 u6708 eight_pointed_black_star vs white_flower " +
+ "ideograph_advantage secret congratulations u5408 u6e80 u5272 u7981 a b ab cl o2 sos x o octagonal_sign no_entry " +
+ "name_badge no_entry_sign 100 anger hotsprings no_pedestrians do_not_litter no_bicycles non-potable_water underage " +
+ "no_mobile_phones no_smoking exclamation grey_exclamation question grey_question bangbang interrobang low_brightness " +
+ "high_brightness part_alternation_mark warning children_crossing trident fleur-de-lis beginner recycle " +
+ "white_check_mark u6307 chart sparkle eight_spoked_asterisk negative_squared_cross_mark globe_with_meridians " +
+ "diamond_shape_with_a_dot_inside m cyclone zzz atm wc wheelchair parking u7a7a sa passport_control customs " +
+ "baggage_claim left_luggage mens womens baby_symbol restroom put_litter_in_its_place cinema signal_strength koko " +
+ "symbols information_source abc abcd capital_abcd ng ok up cool new free zero one two three four five six seven " +
+ "eight nine keycap_ten 1234 hash asterisk arrow_forward pause_button play_pause stop_button record_button eject " +
+ "track_next track_previous fast_forward rewind arrow_double_up arrow_double_down arrow_backward arrow_up_small " +
+ "arrow_down_small arrow_right arrow_left arrow_up arrow_down arrow_upper_right arrow_lower_right arrow_lower_left " +
+ "arrow_upper_left arrow_up_down left_right_arrow arrow_right_hook leftwards_arrow_with_hook arrow_heading_up " +
+ "arrow_heading_down twisted_rightwards_arrows repeat repeat_one arrows_counterclockwise arrows_clockwise " +
+ "musical_note notes heavy_plus_sign heavy_minus_sign heavy_division_sign heavy_multiplication_x heavy_dollar_sign " +
+ "currency_exchange tm copyright registered wavy_dash curly_loop loop end back on top soon heavy_check_mark " +
+ "ballot_box_with_check radio_button white_circle black_circle red_circle blue_circle small_red_triangle " +
+ "small_red_triangle_down small_orange_diamond small_blue_diamond large_orange_diamond large_blue_diamond " +
+ "white_square_button black_square_button black_small_square white_small_square black_medium_small_square " +
+ "white_medium_small_square black_medium_square white_medium_square black_large_square white_large_square speaker " +
+ "mute sound loud_sound bell no_bell mega loudspeaker speech_left eye_in_speech_bubble speech_balloon thought_balloon " +
+ "anger_right spades clubs hearts diamonds black_joker flower_playing_cards mahjong clock1 clock2 clock3 clock4 clock5 " +
+ "clock6 clock7 clock8 clock9 clock10 clock11 clock12 clock130 clock230 clock330 clock430 clock530 clock630 " +
+ "clock730 clock830 clock930 clock1030 clock1130 clock1230"
+ },
+
+ flags: {
+ icon: "flag_gb",
+ title: "Flags",
+ emoji: "flag_white flag_black checkered_flag triangular_flag_on_post rainbow_flag flag_af flag_ax flag_al flag_dz flag_as " +
+ "flag_ad flag_ao flag_ai flag_aq flag_ag flag_ar flag_am flag_aw flag_au flag_at flag_az flag_bs flag_bh flag_bd flag_bb " +
+ "flag_by flag_be flag_bz flag_bj flag_bm flag_bt flag_bo flag_ba flag_bw flag_br flag_io flag_vg flag_bn flag_bg flag_bf " +
+ "flag_bi flag_kh flag_cm flag_ca flag_ic flag_cv flag_bq flag_ky flag_cf flag_td flag_cl flag_cn flag_cx flag_cc flag_co " +
+ "flag_km flag_cg flag_cd flag_ck flag_cr flag_ci flag_hr flag_cu flag_cw flag_cy flag_cz flag_dk flag_dj flag_dm flag_do " +
+ "flag_ec flag_eg flag_sv flag_gq flag_er flag_ee flag_et flag_eu flag_fk flag_fo flag_fj flag_fi flag_fr flag_gf flag_pf " +
+ "flag_tf flag_ga flag_gm flag_ge flag_de flag_gh flag_gi flag_gr flag_gl flag_gd flag_gp flag_gu flag_gt flag_gg flag_gn " +
+ "flag_gw flag_gy flag_ht flag_hn flag_hk flag_hu flag_is flag_in flag_id flag_ir flag_iq flag_ie flag_im flag_il flag_it " +
+ "flag_jm flag_jp crossed_flags flag_je flag_jo flag_kz flag_ke flag_ki flag_xk flag_kw flag_kg flag_la flag_lv flag_lb " +
+ "flag_ls flag_lr flag_ly flag_li flag_lt flag_lu flag_mo flag_mk flag_mg flag_mw flag_my flag_mv flag_ml flag_mt flag_mh " +
+ "flag_mq flag_mr flag_mu flag_yt flag_mx flag_fm flag_md flag_mc flag_mn flag_me flag_ms flag_ma flag_mz flag_mm flag_na " +
+ "flag_nr flag_np flag_nl flag_nc flag_nz flag_ni flag_ne flag_ng flag_nu flag_nf flag_kp flag_mp flag_no flag_om flag_pk " +
+ "flag_pw flag_ps flag_pa flag_pg flag_py flag_pe flag_ph flag_pn flag_pl flag_pt flag_pr flag_qa flag_re flag_ro flag_ru " +
+ "flag_rw flag_ws flag_sm flag_st flag_sa flag_sn flag_rs flag_sc flag_sl flag_sg flag_sx flag_sk flag_si flag_gs flag_sb " +
+ "flag_so flag_za flag_kr flag_ss flag_es flag_lk flag_bl flag_sh flag_kn flag_lc flag_pm flag_vc flag_sd flag_sr flag_sz " +
+ "flag_se flag_ch flag_sy flag_tw flag_tj flag_tz flag_th flag_tl flag_tg flag_tk flag_to flag_tt flag_tn flag_tr flag_tm " +
+ "flag_tc flag_tv flag_vi flag_ug flag_ua flag_ae flag_gb flag_us flag_uy flag_uz flag_vu flag_va flag_ve flag_vn flag_wf " +
+ "flag_eh flag_ye flag_zm flag_zw flag_ac flag_ta flag_bv flag_hm flag_sj flag_um flag_ea flag_cp flag_dg flag_mf " +
+ "united_nations england scotland wales"
+ }
+ };
+ } else {
+ defaultOptions.filters = {
+ tones: {
+ title: "Diversity",
+ emoji: "santa runner surfer swimmer lifter ear nose point_up_2 point_down point_left point_right punch " +
+ "wave ok_hand thumbsup thumbsdown clap open_hands boy girl man woman cop bride_with_veil person_with_blond_hair " +
+ "man_with_gua_pi_mao man_with_turban older_man grandma baby construction_worker princess angel " +
+ "information_desk_person guardsman dancer nail_care massage haircut muscle spy hand_splayed middle_finger " +
+ "vulcan no_good ok_woman bow raising_hand raised_hands person_frowning person_with_pouting_face pray rowboat " +
+ "bicyclist mountain_bicyclist walking bath metal point_up basketball_player fist raised_hand v writing_hand"
+ },
+
+ recent: {
+ icon: "clock3",
+ title: "Recent",
+ emoji: ""
+ },
+
+ smileys_people: {
+ icon: "yum",
+ title: "Smileys & People",
+ emoji: "grinning grimacing grin joy smiley smile sweat_smile laughing innocent wink blush slight_smile " +
+ "upside_down relaxed yum relieved heart_eyes kissing_heart kissing kissing_smiling_eyes " +
+ "kissing_closed_eyes stuck_out_tongue_winking_eye stuck_out_tongue_closed_eyes stuck_out_tongue " +
+ "money_mouth nerd sunglasses hugging smirk no_mouth neutral_face expressionless unamused rolling_eyes " +
+ "thinking flushed disappointed worried angry rage pensive confused slight_frown frowning2 persevere " +
+ "confounded tired_face weary triumph open_mouth scream fearful cold_sweat hushed frowning anguished " +
+ "cry disappointed_relieved sleepy sweat sob dizzy_face astonished zipper_mouth mask thermometer_face " +
+ "head_bandage sleeping zzz poop smiling_imp imp japanese_ogre japanese_goblin skull ghost alien robot " +
+ "smiley_cat smile_cat joy_cat heart_eyes_cat smirk_cat kissing_cat scream_cat crying_cat_face " +
+ "pouting_cat raised_hands clap wave thumbsup thumbsdown punch fist v ok_hand raised_hand open_hands " +
+ "muscle pray point_up point_up_2 point_down point_left point_right middle_finger hand_splayed metal " +
+ "vulcan writing_hand nail_care lips tongue ear nose eye eyes bust_in_silhouette busts_in_silhouette " +
+ "speaking_head baby boy girl man woman person_with_blond_hair older_man older_woman man_with_gua_pi_mao " +
+ "man_with_turban cop construction_worker guardsman spy santa angel princess bride_with_veil walking " +
+ "runner dancer dancers couple two_men_holding_hands two_women_holding_hands bow information_desk_person " +
+ "no_good ok_woman raising_hand person_with_pouting_face person_frowning haircut massage couple_with_heart " +
+ "couple_ww couple_mm couplekiss kiss_ww kiss_mm family family_mwg family_mwgb family_mwbb family_mwgg " +
+ "family_wwb family_wwg family_wwgb family_wwbb family_wwgg family_mmb family_mmg family_mmgb family_mmbb " +
+ "family_mmgg womans_clothes shirt jeans necktie dress bikini kimono lipstick kiss footprints high_heel " +
+ "sandal boot mans_shoe athletic_shoe womans_hat tophat helmet_with_cross mortar_board crown school_satchel " +
+ "pouch purse handbag briefcase eyeglasses dark_sunglasses ring closed_umbrella"
+ },
+
+ animals_nature: {
+ icon: "hamster",
+ title: "Animals & Nature",
+ emoji: "dog cat mouse hamster rabbit bear panda_face koala tiger lion_face cow pig pig_nose frog " +
+ "octopus monkey_face see_no_evil hear_no_evil speak_no_evil monkey chicken penguin bird baby_chick " +
+ "hatching_chick hatched_chick wolf boar horse unicorn bee bug snail beetle ant spider scorpion crab " +
+ "snake turtle tropical_fish fish blowfish dolphin whale whale2 crocodile leopard tiger2 water_buffalo " +
+ "ox cow2 dromedary_camel camel elephant goat ram sheep racehorse pig2 rat mouse2 rooster turkey dove " +
+ "dog2 poodle cat2 rabbit2 chipmunk feet dragon dragon_face cactus christmas_tree evergreen_tree " +
+ "deciduous_tree palm_tree seedling herb shamrock four_leaf_clover bamboo tanabata_tree leaves " +
+ "fallen_leaf maple_leaf ear_of_rice hibiscus sunflower rose tulip blossom cherry_blossom bouquet " +
+ "mushroom chestnut jack_o_lantern shell spider_web earth_americas earth_africa earth_asia full_moon " +
+ "waning_gibbous_moon last_quarter_moon waning_crescent_moon new_moon waxing_crescent_moon " +
+ "first_quarter_moon waxing_gibbous_moon new_moon_with_face full_moon_with_face first_quarter_moon_with_face " +
+ "last_quarter_moon_with_face sun_with_face crescent_moon star star2 dizzy sparkles comet sunny " +
+ "white_sun_small_cloud partly_sunny white_sun_cloud white_sun_rain_cloud cloud cloud_rain " +
+ "thunder_cloud_rain cloud_lightning zap fire boom snowflake cloud_snow snowman2 snowman wind_blowing_face " +
+ "dash cloud_tornado fog umbrella2 umbrella droplet sweat_drops ocean"
+ },
+
+ food_drink: {
+ icon: "pizza",
+ title: "Food & Drink",
+ emoji: "green_apple apple pear tangerine lemon banana watermelon grapes strawberry melon cherries peach " +
+ "pineapple tomato eggplant hot_pepper corn sweet_potato honey_pot bread cheese poultry_leg meat_on_bone " +
+ "fried_shrimp egg hamburger fries hotdog pizza spaghetti taco burrito ramen stew fish_cake sushi bento " +
+ "curry rice_ball rice rice_cracker oden dango shaved_ice ice_cream icecream cake birthday custard candy " +
+ "lollipop chocolate_bar popcorn doughnut cookie beer beers wine_glass cocktail tropical_drink champagne " +
+ "sake tea coffee baby_bottle fork_and_knife fork_knife_plate"
+ },
+
+ activity: {
+ icon: "basketball",
+ title: "Activity",
+ emoji: "soccer basketball football baseball tennis volleyball rugby_football 8ball golf golfer ping_pong " +
+ "badminton hockey field_hockey cricket ski skier snowboarder ice_skate bow_and_arrow fishing_pole_and_fish " +
+ "rowboat swimmer surfer bath basketball_player lifter bicyclist mountain_bicyclist horse_racing levitate " +
+ "trophy running_shirt_with_sash medal military_medal reminder_ribbon rosette ticket tickets performing_arts " +
+ "art circus_tent microphone headphones musical_score musical_keyboard saxophone trumpet guitar violin " +
+ "clapper video_game space_invader dart game_die slot_machine bowling"
+ },
+
+ travel_places: {
+ icon: "rocket",
+ title: "Travel & Places",
+ emoji: "red_car taxi blue_car bus trolleybus race_car police_car ambulance fire_engine minibus truck " +
+ "articulated_lorry tractor motorcycle bike rotating_light oncoming_police_car oncoming_bus " +
+ "oncoming_automobile oncoming_taxi aerial_tramway mountain_cableway suspension_railway railway_car " +
+ "train monorail bullettrain_side bullettrain_front light_rail mountain_railway steam_locomotive train2 " +
+ "metro tram station helicopter airplane_small airplane airplane_departure airplane_arriving sailboat " +
+ "motorboat speedboat ferry cruise_ship rocket satellite_orbital seat anchor construction fuelpump busstop " +
+ "vertical_traffic_light traffic_light checkered_flag ship ferris_wheel roller_coaster carousel_horse " +
+ "construction_site foggy tokyo_tower factory fountain rice_scene mountain mountain_snow mount_fuji volcano " +
+ "japan camping tent park motorway railway_track sunrise sunrise_over_mountains desert beach island " +
+ "city_sunset city_dusk cityscape night_with_stars bridge_at_night milky_way stars sparkler fireworks " +
+ "rainbow homes european_castle japanese_castle stadium statue_of_liberty house house_with_garden " +
+ "house_abandoned office department_store post_office european_post_office hospital bank hotel " +
+ "convenience_store school love_hotel wedding classical_building church mosque synagogue kaaba shinto_shrine"
+ },
+
+ objects: {
+ icon: "bulb",
+ title: "Objects",
+ emoji: "watch iphone calling computer keyboard desktop printer mouse_three_button trackball joystick " +
+ "compression minidisc floppy_disk cd dvd vhs camera camera_with_flash video_camera movie_camera projector " +
+ "film_frames telephone_receiver telephone pager fax tv radio microphone2 level_slider control_knobs " +
+ "stopwatch timer alarm_clock clock hourglass_flowing_sand hourglass satellite battery electric_plug bulb " +
+ "flashlight candle wastebasket oil money_with_wings dollar yen euro pound moneybag credit_card gem scales " +
+ "wrench hammer hammer_pick tools pick nut_and_bolt gear chains gun bomb knife dagger crossed_swords shield " +
+ "smoking skull_crossbones coffin urn amphora crystal_ball prayer_beads barber alembic telescope microscope " +
+ "hole pill syringe thermometer label bookmark toilet shower bathtub key key2 couch sleeping_accommodation " +
+ "bed door bellhop frame_photo map beach_umbrella moyai shopping_bags balloon flags ribbon gift confetti_ball " +
+ "tada dolls wind_chime crossed_flags izakaya_lantern envelope envelope_with_arrow incoming_envelope e-mail " +
+ "love_letter postbox mailbox_closed mailbox mailbox_with_mail mailbox_with_no_mail package postal_horn " +
+ "inbox_tray outbox_tray scroll page_with_curl bookmark_tabs bar_chart chart_with_upwards_trend " +
+ "chart_with_downwards_trend page_facing_up date calendar calendar_spiral card_index card_box ballot_box " +
+ "file_cabinet clipboard notepad_spiral file_folder open_file_folder dividers newspaper2 newspaper notebook " +
+ "closed_book green_book blue_book orange_book notebook_with_decorative_cover ledger books book link " +
+ "paperclip paperclips scissors triangular_ruler straight_ruler pushpin round_pushpin triangular_flag_on_post " +
+ "flag_white flag_black closed_lock_with_key lock unlock lock_with_ink_pen pen_ballpoint pen_fountain " +
+ "black_nib pencil pencil2 crayon paintbrush mag mag_right"
+ },
+
+ symbols: {
+ icon: "heartpulse",
+ title: "Symbols",
+ emoji: "heart yellow_heart green_heart blue_heart purple_heart broken_heart heart_exclamation two_hearts " +
+ "revolving_hearts heartbeat heartpulse sparkling_heart cupid gift_heart heart_decoration peace cross " +
+ "star_and_crescent om_symbol wheel_of_dharma star_of_david six_pointed_star menorah yin_yang orthodox_cross " +
+ "place_of_worship ophiuchus aries taurus gemini cancer leo virgo libra scorpius sagittarius capricorn " +
+ "aquarius pisces id atom u7a7a u5272 radioactive biohazard mobile_phone_off vibration_mode u6709 u7121 " +
+ "u7533 u55b6 u6708 eight_pointed_black_star vs accept white_flower ideograph_advantage secret congratulations " +
+ "u5408 u6e80 u7981 a b ab cl o2 sos no_entry name_badge no_entry_sign x o anger hotsprings no_pedestrians " +
+ "do_not_litter no_bicycles non-potable_water underage no_mobile_phones exclamation grey_exclamation question " +
+ "grey_question bangbang interrobang 100 low_brightness high_brightness trident fleur-de-lis part_alternation_mark " +
+ "warning children_crossing beginner recycle u6307 chart sparkle eight_spoked_asterisk negative_squared_cross_mark " +
+ "white_check_mark diamond_shape_with_a_dot_inside cyclone loop globe_with_meridians m atm sa passport_control " +
+ "customs baggage_claim left_luggage wheelchair no_smoking wc parking potable_water mens womens baby_symbol " +
+ "restroom put_litter_in_its_place cinema signal_strength koko ng ok up cool new free zero one two three four " +
+ "five six seven eight nine ten 1234 arrow_forward pause_button play_pause stop_button record_button track_next " +
+ "track_previous fast_forward rewind twisted_rightwards_arrows repeat repeat_one arrow_backward arrow_up_small " +
+ "arrow_down_small arrow_double_up arrow_double_down arrow_right arrow_left arrow_up arrow_down arrow_upper_right " +
+ "arrow_lower_right arrow_lower_left arrow_upper_left arrow_up_down left_right_arrow arrows_counterclockwise " +
+ "arrow_right_hook leftwards_arrow_with_hook arrow_heading_up arrow_heading_down hash asterisk information_source " +
+ "abc abcd capital_abcd symbols musical_note notes wavy_dash curly_loop heavy_check_mark arrows_clockwise " +
+ "heavy_plus_sign heavy_minus_sign heavy_division_sign heavy_multiplication_x heavy_dollar_sign currency_exchange " +
+ "copyright registered tm end back on top soon ballot_box_with_check radio_button white_circle black_circle " +
+ "red_circle large_blue_circle small_orange_diamond small_blue_diamond large_orange_diamond large_blue_diamond " +
+ "small_red_triangle black_small_square white_small_square black_large_square white_large_square small_red_triangle_down " +
+ "black_medium_square white_medium_square black_medium_small_square white_medium_small_square black_square_button " +
+ "white_square_button speaker sound loud_sound mute mega loudspeaker bell no_bell black_joker mahjong spades " +
+ "clubs hearts diamonds flower_playing_cards thought_balloon anger_right speech_balloon clock1 clock2 clock3 " +
+ "clock4 clock5 clock6 clock7 clock8 clock9 clock10 clock11 clock12 clock130 clock230 clock330 clock430 " +
+ "clock530 clock630 clock730 clock830 clock930 clock1030 clock1130 clock1230 eye_in_speech_bubble"
+ },
+
+ flags: {
+ icon: "flag_gb",
+ title: "Flags",
+ emoji: "ac af al dz ad ao ai ag ar am aw au at az bs bh bd bb by be bz bj bm bt bo ba bw br bn bg bf bi " +
+ "cv kh cm ca ky cf td flag_cl cn co km cg flag_cd cr hr cu cy cz dk dj dm do ec eg sv gq er ee et fk fo " +
+ "fj fi fr pf ga gm ge de gh gi gr gl gd gu gt gn gw gy ht hn hk hu is in flag_id ir iq ie il it ci jm jp " +
+ "je jo kz ke ki xk kw kg la lv lb ls lr ly li lt lu mo mk mg mw my mv ml mt mh mr mu mx fm md mc mn me " +
+ "ms ma mz mm na nr np nl nc nz ni ne flag_ng nu kp no om pk pw ps pa pg py pe ph pl pt pr qa ro ru rw " +
+ "sh kn lc vc ws sm st flag_sa sn rs sc sl sg sk si sb so za kr es lk sd sr sz se ch sy tw tj tz th tl " +
+ "tg to tt tn tr flag_tm flag_tm ug ua ae gb us vi uy uz vu va ve vn wf eh ye zm zw re ax ta io bq cx " +
+ "cc gg im yt nf pn bl pm gs tk bv hm sj um ic ea cp dg as aq vg ck cw eu gf tf gp mq mp sx ss tc "
+ }
+ };
+ };
+
+ return defaultOptions;
+ };
+ function getOptions(options) {
+ var default_options = getDefaultOptions();
+ if (options && options['filters']) {
+ var filters = default_options.filters;
+ $.each(options['filters'], function(filter, data) {
+ if (!isObject(data) || $.isEmptyObject(data)) {
+ delete filters[filter];
+ return;
+ }
+ $.each(data, function(key, val) {
+ filters[filter][key] = val;
+ });
+ });
+ options['filters'] = filters;
+ }
+ return $.extend({}, default_options, options);
+ };
+
+ var saveSelection, restoreSelection;
+ if (window.getSelection && document.createRange) {
+ saveSelection = function(el) {
+ var sel = window.getSelection && window.getSelection();
+ if (sel && sel.rangeCount > 0) {
+ return sel.getRangeAt(0);
+ }
+ };
+
+ restoreSelection = function(el, sel) {
+ var range = document.createRange();
+ range.setStart(sel.startContainer, sel.startOffset);
+ range.setEnd(sel.endContainer, sel.endOffset)
+
+ sel = window.getSelection();
+ sel.removeAllRanges();
+ sel.addRange(range);
+ }
+ } else if (document.selection && document.body.createTextRange) {
+ saveSelection = function(el) {
+ return document.selection.createRange();
+ };
+
+ restoreSelection = function(el, sel) {
+ var textRange = document.body.createTextRange();
+ textRange.moveToElementText(el);
+ textRange.setStart(sel.startContanier, sel.startOffset);
+ textRange.setEnd(sel.endContainer, sel.endOffset);
+ textRange.select();
+ };
+ }
+
+
+ var uniRegexp;
+ function unicodeTo(str, template) {
+ return str.replace(uniRegexp, function(unicodeChar) {
+ var map = emojione[(emojioneSupportMode === 0 ? 'jsecapeMap' : 'jsEscapeMap')];
+ if (typeof unicodeChar !== 'undefined' && unicodeChar in map) {
+ return getTemplate(template, map[unicodeChar], emojione.toShort(unicodeChar));
+ }
+ return unicodeChar;
+ });
+ }
+ function htmlFromText(str, self) {
+ str = str
+ .replace(/&/g, '&')
+ .replace(/</g, '<')
+ .replace(/>/g, '>')
+ .replace(/"/g, '"')
+ .replace(/'/g, ''')
+ .replace(/`/g, '`')
+ .replace(/(?:\r\n|\r|\n)/g, '\n')
+ .replace(/(\n+)/g, '<div>$1</div>')
+ .replace(/\n/g, '<br/>')
+ .replace(/<br\/><\/div>/g, '</div>');
+ if (self.shortnames) {
+ str = emojione.shortnameToUnicode(str);
+ }
+ return unicodeTo(str, self.emojiTemplate)
+ .replace(/\t/g, ' ')
+ .replace(/ /g, ' ');
+ }
+ function textFromHtml(str, self) {
+ str = str
+ .replace(/ /g, '\n')
+ .replace(/	/g, '\t')
+ .replace(/<img[^>]*alt="([^"]+)"[^>]*>/ig, '$1')
+ .replace(/\n|\r/g, '')
+ .replace(/<br[^>]*>/ig, '\n')
+ .replace(/(?:<(?:div|p|ol|ul|li|pre|code|object)[^>]*>)+/ig, '<div>')
+ .replace(/(?:<\/(?:div|p|ol|ul|li|pre|code|object)>)+/ig, '</div>')
+ .replace(/\n<div><\/div>/ig, '\n')
+ .replace(/<div><\/div>\n/ig, '\n')
+ .replace(/(?:<div>)+<\/div>/ig, '\n')
+ .replace(/([^\n])<\/div><div>/ig, '$1\n')
+ .replace(/(?:<\/div>)+/ig, '</div>')
+ .replace(/([^\n])<\/div>([^\n])/ig, '$1\n$2')
+ .replace(/<\/div>/ig, '')
+ .replace(/([^\n])<div>/ig, '$1\n')
+ .replace(/\n<div>/ig, '\n')
+ .replace(/<div>\n/ig, '\n\n')
+ .replace(/<(?:[^>]+)?>/g, '')
+ .replace(new RegExp(invisibleChar, 'g'), '')
+ .replace(/ /g, ' ')
+ .replace(/</g, '<')
+ .replace(/>/g, '>')
+ .replace(/"/g, '"')
+ .replace(/'/g, "'")
+ .replace(/`/g, '`')
+ .replace(/</g, '<')
+ .replace(/>/g, '>')
+ .replace(/&/g, '&');
+
+ switch (self.saveEmojisAs) {
+ case 'image':
+ str = unicodeTo(str, self.emojiTemplate);
+ break;
+ case 'shortname':
+ str = emojione.toShort(str);
+ }
+ return str;
+ }
+ function calcButtonPosition() {
+ var self = this,
+ offset = self.editor[0].offsetWidth - self.editor[0].clientWidth,
+ current = parseInt(self.button.css('marginRight'));
+ if (current !== offset) {
+ self.button.css({marginRight: offset});
+ if (self.floatingPicker) {
+ self.picker.css({right: parseInt(self.picker.css('right')) - current + offset});
+ }
+ }
+ }
+ function lazyLoading() {
+ var self = this;
+ if (!self.sprite && self.lasyEmoji[0] && self.lasyEmoji.eq(0).is(".lazy-emoji")) {
+ var pickerTop = self.picker.offset().top,
+ pickerBottom = pickerTop + self.picker.height() + 20;
+
+ self.lasyEmoji.each(function() {
+ var e = $(this), top = e.offset().top;
+
+ if (top > pickerTop && top < pickerBottom) {
+ e.attr("src", e.data("src")).removeClass("lazy-emoji");
+ }
+
+ if (top > pickerBottom) {
+ return false;
+ }
+ });
+ self.lasyEmoji = self.lasyEmoji.filter(".lazy-emoji");
+ }
+ };
+ function selector (prefix, skip_dot) {
+ return (skip_dot ? '' : '.') + css_class + (prefix ? ("-" + prefix) : "");
+ }
+ function div(prefix) {
+ var parent = $('<div/>', isObject(prefix) ? prefix : {"class" : selector(prefix, true)});
+ $.each(slice.call(arguments).slice(1), function(i, child) {
+ if ($.isFunction(child)) {
+ child = child.call(parent);
+ }
+ if (child) {
+ $(child).appendTo(parent);
+ }
+ });
+ return parent;
+ }
+ function getRecent () {
+ return localStorage.getItem("recent_emojis") || "";
+ }
+ function updateRecent(self, show) {
+ var emojis = getRecent();
+ if (!self.recent || self.recent !== emojis || show) {
+ if (emojis.length) {
+ var skinnable = self.scrollArea.is(".skinnable"),
+ scrollTop, height;
+
+ if (!skinnable) {
+ scrollTop = self.scrollArea.scrollTop();
+ if (show) {
+ self.recentCategory.show();
+ }
+ height = self.recentCategory.is(":visible") ? self.recentCategory.height() : 0;
+ }
+
+ var items = shortnameTo(emojis, self.emojiBtnTemplate, true).split('|').join('');
+ self.recentCategory.children(".emojibtn").remove();
+ $(items).insertAfter(self.recentCategory.children(".emojionearea-category-title"));
+
+
+ self.recentCategory.children(".emojibtn").on("click", function() {
+ self.trigger("emojibtn.click", $(this));
+ });
+
+ self.recentFilter.show();
+
+ if (!skinnable) {
+ self.recentCategory.show();
+
+ var height2 = self.recentCategory.height();
+
+ if (height !== height2) {
+ self.scrollArea.scrollTop(scrollTop + height2 - height);
+ }
+ }
+ } else {
+ if (self.recentFilter.hasClass("active")) {
+ self.recentFilter.removeClass("active").next().addClass("active");
+ }
+ self.recentCategory.hide();
+ self.recentFilter.hide();
+ }
+ self.recent = emojis;
+ }
+ };
+ function setRecent(self, emoji) {
+ var recent = getRecent();
+ var emojis = recent.split("|");
+
+ var index = emojis.indexOf(emoji);
+ if (index !== -1) {
+ emojis.splice(index, 1);
+ }
+ emojis.unshift(emoji);
+
+ if (emojis.length > 9) {
+ emojis.pop();
+ }
+
+ localStorage.setItem("recent_emojis", emojis.join("|"));
+
+ updateRecent(self);
+ };
+// see https://github.com/Modernizr/Modernizr/blob/master/feature-detects/storage/localstorage.js
+ function supportsLocalStorage () {
+ var test = 'test';
+ try {
+ localStorage.setItem(test, test);
+ localStorage.removeItem(test);
+ return true;
+ } catch(e) {
+ return false;
+ }
+ }
+ function init(self, source, options) {
+ //calcElapsedTime('init', function() {
+ self.options = options = getOptions(options);
+ self.sprite = options.sprite && emojioneSupportMode < 3;
+ self.inline = options.inline === null ? source.is("INPUT") : options.inline;
+ self.shortnames = options.shortnames;
+ self.saveEmojisAs = options.saveEmojisAs;
+ self.standalone = options.standalone;
+ self.emojiTemplate = '<img alt="{alt}" class="emojione' + (self.sprite ? '-{uni}" src="' + blankImg + '"/>' : 'emoji" src="{img}"/>');
+ self.emojiTemplateAlt = self.sprite ? '<i class="emojione-{uni}"/>' : '<img class="emojioneemoji" src="{img}"/>';
+ self.emojiBtnTemplate = '<i class="emojibtn" role="button" data-name="{name}" title="{friendlyName}">' + self.emojiTemplateAlt + '</i>';
+ self.recentEmojis = options.recentEmojis && supportsLocalStorage();
+
+ var pickerPosition = options.pickerPosition;
+ self.floatingPicker = pickerPosition === 'top' || pickerPosition === 'bottom';
+ self.source = source;
+
+ if (source.is(":disabled") || source.is(".disabled")) {
+ self.disable();
+ }
+
+ var sourceValFunc = source.is("TEXTAREA") || source.is("INPUT") ? "val" : "text",
+ editor, button, picker, filters, filtersBtns, searchPanel, emojisList, categories, categoryBlocks, scrollArea,
+ tones = div('tones',
+ options.tones ?
+ function() {
+ this.addClass(selector('tones-' + options.tonesStyle, true));
+ for (var i = 0; i <= 5; i++) {
+ this.append($("<i/>", {
+ "class": "btn-tone btn-tone-" + i + (!i ? " active" : ""),
+ "data-skin": i,
+ role: "button"
+ }));
+ }
+ } : null
+ ),
+ app = div({
+ "class" : css_class + ((self.standalone) ? " " + css_class + "-standalone " : " ") + (source.attr("class") || ""),
+ role: "application"
+ },
+ editor = self.editor = div("editor").attr({
+ contenteditable: (self.standalone) ? false : true,
+ placeholder: options.placeholder || source.data("placeholder") || source.attr("placeholder") || "",
+ tabindex: 0
+ }),
+ button = self.button = div('button',
+ div('button-open'),
+ div('button-close')
+ ).attr('title', options.buttonTitle),
+ picker = self.picker = div('picker',
+ div('wrapper',
+ filters = div('filters'),
+ (options.search ?
+ searchPanel = div('search-panel',
+ div('search',
+ options.search ?
+ function() {
+ self.search = $("<input/>", {
+ "placeholder": options.searchPlaceholder || "",
+ "type": "text",
+ "class": "search"
+ });
+ this.append(self.search);
+ } : null
+ ),
+ tones
+ ) : null
+ ),
+ scrollArea = div('scroll-area',
+ options.tones && !options.search ? div('tones-panel',
+ tones
+ ) : null,
+ emojisList = div('emojis-list')
+ )
+ )
+ ).addClass(selector('picker-position-' + options.pickerPosition, true))
+ .addClass(selector('filters-position-' + options.filtersPosition, true))
+ .addClass(selector('search-position-' + options.searchPosition, true))
+ .addClass('hidden')
+ );
+
+ if (options.search) {
+ searchPanel.addClass(selector('with-search', true));
+ }
+
+ self.searchSel = null;
+
+ editor.data(source.data());
+
+ $.each(options.attributes, function(attr, value) {
+ editor.attr(attr, value);
+ });
+
+ var mainBlock = div('category-block').attr({"data-tone": 0}).prependTo(emojisList);
+
+ $.each(options.filters, function(filter, params) {
+ var skin = 0;
+ if (filter === 'recent' && !self.recentEmojis) {
+ return;
+ }
+ if (filter !== 'tones') {
+ $("<i/>", {
+ "class": selector("filter", true) + " " + selector("filter-" + filter, true),
+ "data-filter": filter,
+ title: params.title
+ })
+ .wrapInner(shortnameTo(params.icon, self.emojiTemplateAlt))
+ .appendTo(filters);
+ } else if (options.tones) {
+ skin = 5;
+ } else {
+ return;
+ }
+
+ do {
+ var category,
+ items = params.emoji.replace(/[\s,;]+/g, '|');
+
+ if (skin === 0) {
+ category = div('category').attr({
+ name: filter,
+ "data-tone": skin
+ }).appendTo(mainBlock);
+ } else {
+ category = div('category-block').attr({
+ name: filter,
+ "data-tone": skin
+ }).appendTo(emojisList);
+ }
+
+ if (skin > 0) {
+ category.hide();
+ items = items.split('|').join('_tone' + skin + '|') + '_tone' + skin;
+ }
+
+ if (filter === 'recent') {
+ items = getRecent();
+ }
+
+ items = shortnameTo(items,
+ self.sprite ?
+ '<i class="emojibtn" role="button" data-name="{name}" title="{friendlyName}"><i class="emojione-{uni}"></i></i>' :
+ '<i class="emojibtn" role="button" data-name="{name}" title="{friendlyName}"><img class="emojioneemoji lazy-emoji" data-src="{img}"/></i>',
+ true).split('|').join('');
+
+ category.html(items);
+ $('<div class="emojionearea-category-title"/>').text(params.title).prependTo(category);
+ } while (--skin > 0);
+ });
+
+ options.filters = null;
+ if (!self.sprite) {
+ self.lasyEmoji = emojisList.find(".lazy-emoji");
+ }
+
+ filtersBtns = filters.find(selector("filter"));
+ filtersBtns.eq(0).addClass("active");
+ categoryBlocks = emojisList.find(selector("category-block"))
+ categories = emojisList.find(selector("category"))
+
+ self.recentFilter = filtersBtns.filter('[data-filter="recent"]');
+ self.recentCategory = categories.filter("[name=recent]");
+
+ self.scrollArea = scrollArea;
+
+ if (options.container) {
+ $(options.container).wrapInner(app);
+ } else {
+ app.insertAfter(source);
+ }
+
+ if (options.hideSource) {
+ source.hide();
+ }
+
+ self.setText(source[sourceValFunc]());
+ source[sourceValFunc](self.getText());
+ calcButtonPosition.apply(self);
+
+ // if in standalone mode and no value is set, initialise with a placeholder
+ if (self.standalone && !self.getText().length) {
+ var placeholder = $(source).data("emoji-placeholder") || options.emojiPlaceholder;
+ self.setText(placeholder);
+ editor.addClass("has-placeholder");
+ }
+
+ // attach() must be called before any .on() methods !!!
+ // 1) attach() stores events into possibleEvents{},
+ // 2) .on() calls bindEvent() and stores handlers into eventStorage{},
+ // 3) bindEvent() finds events in possibleEvents{} and bind founded via jQuery.on()
+ // 4) attached events via jQuery.on() calls trigger()
+ // 5) trigger() calls handlers stored into eventStorage{}
+
+ attach(self, emojisList.find(".emojibtn"), {click: "emojibtn.click"});
+ attach(self, window, {resize: "!resize"});
+ attach(self, tones.children(), {click: "tone.click"});
+ attach(self, [picker, button], {mousedown: "!mousedown"}, editor);
+ attach(self, button, {click: "button.click"});
+ attach(self, editor, {paste :"!paste"}, editor);
+ attach(self, editor, ["focus", "blur"], function() { return self.stayFocused ? false : editor; } );
+ attach(self, picker, {mousedown: "picker.mousedown", mouseup: "picker.mouseup", click: "picker.click",
+ keyup: "picker.keyup", keydown: "picker.keydown", keypress: "picker.keypress"});
+ attach(self, editor, ["mousedown", "mouseup", "click", "keyup", "keydown", "keypress"]);
+ attach(self, picker.find(".emojionearea-filter"), {click: "filter.click"});
+ attach(self, source, {change: "source.change"});
+
+ if (options.search) {
+ attach(self, self.search, {keyup: "search.keypress", focus: "search.focus", blur: "search.blur"});
+ }
+
+ var noListenScroll = false;
+ scrollArea.on('scroll', function () {
+ if (!noListenScroll) {
+ lazyLoading.call(self);
+ if (scrollArea.is(":not(.skinnable)")) {
+ var item = categories.eq(0), scrollTop = scrollArea.offset().top;
+ categories.each(function (i, e) {
+ if ($(e).offset().top - scrollTop >= 10) {
+ return false;
+ }
+ item = $(e);
+ });
+ var filter = filtersBtns.filter('[data-filter="' + item.attr("name") + '"]');
+ if (filter[0] && !filter.is(".active")) {
+ filtersBtns.removeClass("active");
+ filter.addClass("active");
+ }
+ }
+ }
+ });
+
+ self.on("@filter.click", function(filter) {
+ var isActive = filter.is(".active");
+ if (scrollArea.is(".skinnable")) {
+ if (isActive) return;
+ tones.children().eq(0).click();
+ }
+ noListenScroll = true;
+ if (!isActive) {
+ filtersBtns.filter(".active").removeClass("active");
+ filter.addClass("active");
+ }
+ var headerOffset = categories.filter('[name="' + filter.data('filter') + '"]').offset().top,
+ scroll = scrollArea.scrollTop(),
+ offsetTop = scrollArea.offset().top;
+
+ scrollArea.stop().animate({
+ scrollTop: headerOffset + scroll - offsetTop - 2
+ }, 200, 'swing', function () {
+ lazyLoading.call(self);
+ noListenScroll = false;
+ });
+ })
+
+ .on("@picker.show", function() {
+ if (self.recentEmojis) {
+ updateRecent(self);
+ }
+ lazyLoading.call(self);
+ })
+
+ .on("@tone.click", function(tone) {
+ tones.children().removeClass("active");
+ var skin = tone.addClass("active").data("skin");
+ if (skin) {
+ scrollArea.addClass("skinnable");
+ categoryBlocks.hide().filter("[data-tone=" + skin + "]").show();
+ filtersBtns.removeClass("active");//.not('[data-filter="recent"]').eq(0).addClass("active");
+ } else {
+ scrollArea.removeClass("skinnable");
+ categoryBlocks.hide().filter("[data-tone=0]").show();
+ filtersBtns.eq(0).click();
+ }
+ lazyLoading.call(self);
+ if (options.search) {
+ self.trigger('search.keypress');
+ }
+ })
+
+ .on("@button.click", function(button) {
+ if (button.is(".active")) {
+ self.hidePicker();
+ } else {
+ self.showPicker();
+ self.searchSel = null;
+ }
+ })
+
+ .on("@!paste", function(editor, event) {
+
+ var pasteText = function(text) {
+ var caretID = "caret-" + (new Date()).getTime();
+ var html = htmlFromText(text, self);
+ pasteHtmlAtCaret(html);
+ pasteHtmlAtCaret('<i id="' + caretID +'"></i>');
+ editor.scrollTop(editorScrollTop);
+ var caret = $("#" + caretID),
+ top = caret.offset().top - editor.offset().top,
+ height = editor.height();
+ if (editorScrollTop + top >= height || editorScrollTop > top) {
+ editor.scrollTop(editorScrollTop + top - 2 * height/3);
+ }
+ caret.remove();
+ self.stayFocused = false;
+ calcButtonPosition.apply(self);
+ trigger(self, 'paste', [editor, text, html]);
+ };
+
+ if (event.originalEvent.clipboardData) {
+ var text = event.originalEvent.clipboardData.getData('text/plain');
+ pasteText(text);
+
+ if (event.preventDefault){
+ event.preventDefault();
+ } else {
+ event.stop();
+ }
+
+ event.returnValue = false;
+ event.stopPropagation();
+ return false;
+ }
+
+ self.stayFocused = true;
+ // insert invisible character for fix caret position
+ pasteHtmlAtCaret('<span>' + invisibleChar + '</span>');
+
+ var sel = saveSelection(editor[0]),
+ editorScrollTop = editor.scrollTop(),
+ clipboard = $("<div/>", {contenteditable: true})
+ .css({position: "fixed", left: "-999px", width: "1px", height: "1px", top: "20px", overflow: "hidden"})
+ .appendTo($("BODY"))
+ .focus();
+
+ window.setTimeout(function() {
+ editor.focus();
+ restoreSelection(editor[0], sel);
+ var text = textFromHtml(clipboard.html().replace(/\r\n|\n|\r/g, '<br>'), self);
+ clipboard.remove();
+ pasteText(text);
+ }, 200);
+ })
+
+ .on("@emojibtn.click", function(emojibtn) {
+ editor.removeClass("has-placeholder");
+
+ if (self.searchSel !== null) {
+ editor.focus();
+ restoreSelection(editor[0], self.searchSel);
+ self.searchSel = null;
+ }
+
+ if (self.standalone) {
+ editor.html(shortnameTo(emojibtn.data("name"), self.emojiTemplate));
+ self.trigger("blur");
+ } else {
+ saveSelection(editor[0]);
+ pasteHtmlAtCaret(shortnameTo(emojibtn.data("name"), self.emojiTemplate));
+ }
+
+ if (self.recentEmojis) {
+ setRecent(self, emojibtn.data("name"));
+ }
+
+ // self.search.val('').trigger("change");
+ self.trigger('search.keypress');
+ })
+
+ .on("@!resize @keyup @emojibtn.click", calcButtonPosition)
+
+ .on("@!mousedown", function(editor, event) {
+ if ($(event.target).hasClass('search')) {
+ // Allow search clicks
+ self.stayFocused = true;
+ if (self.searchSel === null) {
+ self.searchSel = saveSelection(editor[0]);
+ }
+ } else {
+ if (!app.is(".focused")) {
+ editor.trigger("focus");
+ }
+ event.preventDefault();
+ }
+ return false;
+ })
+
+ .on("@change", function() {
+ var html = self.editor.html().replace(/<\/?(?:div|span|p)[^>]*>/ig, '');
+ // clear input: chrome adds <br> when contenteditable is empty
+ if (!html.length || /^<br[^>]*>$/i.test(html)) {
+ self.editor.html(self.content = '');
+ }
+ source[sourceValFunc](self.getText());
+ })
+
+ .on("@source.change", function() {
+ self.setText(source[sourceValFunc]());
+ trigger('change');
+ })
+
+ .on("@focus", function() {
+ app.addClass("focused");
+ })
+
+ .on("@blur", function() {
+ app.removeClass("focused");
+
+ if (options.hidePickerOnBlur) {
+ self.hidePicker();
+ }
+
+ var content = self.editor.html();
+ if (self.content !== content) {
+ self.content = content;
+ trigger(self, 'change', [self.editor]);
+ source.trigger("blur").trigger("change");
+ } else {
+ source.trigger("blur");
+ }
+
+ if (options.search) {
+ self.search.val('');
+ self.trigger('search.keypress', true);
+ }
+ });
+
+ if (options.search) {
+ self.on("@search.focus", function() {
+ self.stayFocused = true;
+ self.search.addClass("focused");
+ })
+
+ .on("@search.keypress", function(hide) {
+ var filterBtns = picker.find(".emojionearea-filter");
+ var activeTone = (options.tones ? tones.find("i.active").data("skin") : 0);
+ var term = self.search.val().replace( / /g, "_" ).replace(/"/g, "\\\"");
+
+ if (term && term.length) {
+ if (self.recentFilter.hasClass("active")) {
+ self.recentFilter.removeClass("active").next().addClass("active");
+ }
+
+ self.recentCategory.hide();
+ self.recentFilter.hide();
+
+ categoryBlocks.each(function() {
+ var matchEmojis = function(category, activeTone) {
+ var $matched = category.find('.emojibtn[data-name*="' + term + '"]');
+ if ($matched.length === 0) {
+ if (category.data('tone') === activeTone) {
+ category.hide();
+ }
+ filterBtns.filter('[data-filter="' + category.attr('name') + '"]').hide();
+ } else {
+ var $notMatched = category.find('.emojibtn:not([data-name*="' + term + '"])');
+ $notMatched.hide();
+
+ $matched.show();
+
+ if (category.data('tone') === activeTone) {
+ category.show();
+ }
+
+ filterBtns.filter('[data-filter="' + category.attr('name') + '"]').show();
+ }
+ }
+
+ var $block = $(this);
+ if ($block.data('tone') === 0) {
+ categories.filter(':not([name="recent"])').each(function() {
+ matchEmojis($(this), 0);
+ })
+ } else {
+ matchEmojis($block, activeTone);
+ }
+ });
+ if (!noListenScroll) {
+ scrollArea.trigger('scroll');
+ } else {
+ lazyLoading.call(self);
+ }
+ } else {
+ updateRecent(self, true);
+ categoryBlocks.filter('[data-tone="' + tones.find("i.active").data("skin") + '"]:not([name="recent"])').show();
+ $('.emojibtn', categoryBlocks).show();
+ filterBtns.show();
+ lazyLoading.call(self);
+ }
+ })
+
+ .on("@search.blur", function() {
+ self.stayFocused = false;
+ self.search.removeClass("focused");
+ self.trigger("blur");
+ });
+ }
+
+ if (options.shortcuts) {
+ self.on("@keydown", function(_, e) {
+ if (!e.ctrlKey) {
+ if (e.which == 9) {
+ e.preventDefault();
+ button.click();
+ }
+ else if (e.which == 27) {
+ e.preventDefault();
+ if (button.is(".active")) {
+ self.hidePicker();
+ }
+ }
+ }
+ });
+ }
+
+ if (isObject(options.events) && !$.isEmptyObject(options.events)) {
+ $.each(options.events, function(event, handler) {
+ self.on(event.replace(/_/g, '.'), handler);
+ });
+ }
+
+ if (options.autocomplete) {
+ var autocomplete = function() {
+ var textcompleteOptions = {
+ maxCount: options.textcomplete.maxCount,
+ placement: options.textcomplete.placement
+ };
+
+ if (options.shortcuts) {
+ textcompleteOptions.onKeydown = function (e, commands) {
+ if (!e.ctrlKey && e.which == 13) {
+ return commands.KEY_ENTER;
+ }
+ };
+ }
+
+ var map = $.map(emojione.emojioneList, function (_, emoji) {
+ return !options.autocompleteTones ? /_tone[12345]/.test(emoji) ? null : emoji : emoji;
+ });
+ map.sort();
+ editor.textcomplete([
+ {
+ id: css_class,
+ match: /\B(:[\-+\w]*)$/,
+ search: function (term, callback) {
+ callback($.map(map, function (emoji) {
+ return emoji.indexOf(term) === 0 ? emoji : null;
+ }));
+ },
+ template: function (value) {
+ return shortnameTo(value, self.emojiTemplate) + " " + value.replace(/:/g, '');
+ },
+ replace: function (value) {
+ return shortnameTo(value, self.emojiTemplate);
+ },
+ cache: true,
+ index: 1
+ }
+ ], textcompleteOptions);
+
+ if (options.textcomplete.placement) {
+ // Enable correct positioning for textcomplete
+ if ($(editor.data('textComplete').option.appendTo).css("position") == "static") {
+ $(editor.data('textComplete').option.appendTo).css("position", "relative");
+ }
+ }
+ };
+
+ var initAutocomplete = function() {
+ if (self.disabled) {
+ var enable = function () {
+ self.off('enabled', enable);
+ autocomplete();
+ };
+ self.on('enabled', enable);
+ } else {
+ autocomplete();
+ }
+ }
+
+ if ($.fn.textcomplete) {
+ initAutocomplete();
+ } else {
+ $.ajax({
+ url: "https://cdn.rawgit.com/yuku-t/jquery-textcomplete/v1.3.4/dist/jquery.textcomplete.js",
+ dataType: "script",
+ cache: true,
+ success: initAutocomplete
+ });
+ }
+ }
+
+ if (self.inline) {
+ app.addClass(selector('inline', true));
+ self.on("@keydown", function(_, e) {
+ if (e.which == 13) {
+ e.preventDefault();
+ }
+ });
+ }
+
+ if (/firefox/i.test(navigator.userAgent)) {
+ // disabling resize images on Firefox
+ document.execCommand("enableObjectResizing", false, false);
+ }
+
+ self.isReady = true;
+ self.trigger("onLoad", editor);
+ self.trigger("ready", editor);
+ //}, self.id === 1); // calcElapsedTime()
+ };
+ var cdn = {
+ defaultBase: "https://cdnjs.cloudflare.com/ajax/libs/emojione/",
+ defaultBase3: "https://cdn.jsdelivr.net/",
+ base: null,
+ isLoading: false
+ };
+ function loadEmojione(options) {
+ var emojioneVersion = getEmojioneVersion()
+ options = getOptions(options);
+
+ if (!cdn.isLoading) {
+ if (!emojione || getSupportMode(detectVersion(emojione)) < 2) {
+ cdn.isLoading = true;
+ var emojioneJsCdnUrlBase;
+ if (getSupportMode(emojioneVersion) > 5) {
+ emojioneJsCdnUrlBase = cdn.defaultBase3 + "npm/emojione@" + emojioneVersion;
+ } else if (getSupportMode(emojioneVersion) > 4) {
+ emojioneJsCdnUrlBase = cdn.defaultBase3 + "emojione/" + emojioneVersion;
+ } else {
+ emojioneJsCdnUrlBase = cdn.defaultBase + "/" + emojioneVersion;
+ }
+
+ $.ajax({
+ url: emojioneJsCdnUrlBase + "/lib/js/emojione.min.js",
+ dataType: "script",
+ cache: true,
+ success: function () {
+ emojione = __webpack_provided_window_dot_emojione;
+ emojioneVersion = detectVersion(emojione);
+ emojioneSupportMode = getSupportMode(emojioneVersion);
+ var sprite;
+ if (emojioneSupportMode > 4) {
+ cdn.base = cdn.defaultBase3 + "emojione/assets/" + emojioneVersion;
+ sprite = cdn.base + "/sprites/emojione-sprite-" + emojione.emojiSize + ".css";
+ } else {
+ cdn.base = cdn.defaultBase + emojioneVersion + "/assets";
+ sprite = cdn.base + "/sprites/emojione.sprites.css";
+ }
+ if (options.sprite) {
+ if (document.createStyleSheet) {
+ document.createStyleSheet(sprite);
+ } else {
+ $('<link/>', {rel: 'stylesheet', href: sprite}).appendTo('head');
+ }
+ }
+ while (readyCallbacks.length) {
+ readyCallbacks.shift().call();
+ }
+ cdn.isLoading = false;
+ }
+ });
+ } else {
+ emojioneVersion = detectVersion(emojione);
+ emojioneSupportMode = getSupportMode(emojioneVersion);
+ if (emojioneSupportMode > 4) {
+ cdn.base = cdn.defaultBase3 + "emojione/assets/" + emojioneVersion;
+ } else {
+ cdn.base = cdn.defaultBase + emojioneVersion + "/assets";
+ }
+ }
+ }
+
+ emojioneReady(function() {
+ var emojiSize = "";
+ if (options.useInternalCDN) {
+ if (emojioneSupportMode > 4) emojiSize = emojione.emojiSize + "/";
+
+ emojione.imagePathPNG = cdn.base + "/png/" + emojiSize;
+ emojione.imagePathSVG = cdn.base + "/svg/" + emojiSize;
+ emojione.imagePathSVGSprites = cdn.base + "/sprites/emojione.sprites.svg";
+ emojione.imageType = options.imageType;
+ }
+ if (getSupportMode(emojioneVersion) > 4) {
+ uniRegexp = emojione.regUnicode;
+ emojione.imageType = options.imageType || "png";
+ } else {
+ uniRegexp = new RegExp("<object[^>]*>.*?<\/object>|<span[^>]*>.*?<\/span>|<(?:object|embed|svg|img|div|span|p|a)[^>]*>|(" + emojione.unicodeRegexp + ")", "gi");
+ }
+ });
+ };
+ var EmojioneArea = function(element, options) {
+ var self = this;
+ loadEmojione(options);
+ eventStorage[self.id = ++unique] = {};
+ possibleEvents[self.id] = {};
+ emojioneReady(function() {
+ init(self, element, options);
+ });
+ };
+ function bindEvent(self, event) {
+ event = event.replace(/^@/, '');
+ var id = self.id;
+ if (possibleEvents[id][event]) {
+ $.each(possibleEvents[id][event], function(i, ev) {
+ // ev[0] = element
+ // ev[1] = event
+ // ev[2] = target
+ $.each($.isArray(ev[0]) ? ev[0] : [ev[0]], function(i, el) {
+ $(el).on(ev[1], function() {
+ var args = slice.call(arguments),
+ target = $.isFunction(ev[2]) ? ev[2].apply(self, [event].concat(args)) : ev[2];
+ if (target) {
+ trigger(self, event, [target].concat(args));
+ }
+ });
+ });
+ });
+ possibleEvents[id][event] = null;
+ }
+ }
+
+ EmojioneArea.prototype.on = function(events, handler) {
+ if (events && $.isFunction(handler)) {
+ var self = this;
+ $.each(events.toLowerCase().split(' '), function(i, event) {
+ bindEvent(self, event);
+ (eventStorage[self.id][event] || (eventStorage[self.id][event] = [])).push(handler);
+ });
+ }
+ return this;
+ };
+
+ EmojioneArea.prototype.off = function(events, handler) {
+ if (events) {
+ var id = this.id;
+ $.each(events.toLowerCase().replace(/_/g, '.').split(' '), function(i, event) {
+ if (eventStorage[id][event] && !/^@/.test(event)) {
+ if (handler) {
+ $.each(eventStorage[id][event], function(j, fn) {
+ if (fn === handler) {
+ eventStorage[id][event].splice(j, 1);
+ }
+ });
+ } else {
+ eventStorage[id][event] = [];
+ }
+ }
+ });
+ }
+ return this;
+ };
+
+ EmojioneArea.prototype.trigger = function() {
+ var args = slice.call(arguments),
+ call_args = [this].concat(args.slice(0,1));
+ call_args.push(args.slice(1));
+ return trigger.apply(this, call_args);
+ };
+
+ EmojioneArea.prototype.setFocus = function () {
+ var self = this;
+ emojioneReady(function () {
+ self.editor.focus();
+ });
+ return self;
+ };
+
+ EmojioneArea.prototype.setText = function (str) {
+ var self = this;
+ emojioneReady(function () {
+ self.editor.html(htmlFromText(str, self));
+ self.content = self.editor.html();
+ trigger(self, 'change', [self.editor]);
+ calcButtonPosition.apply(self);
+ });
+ return self;
+ }
+
+ EmojioneArea.prototype.getText = function() {
+ return textFromHtml(this.editor.html(), this);
+ }
+
+ EmojioneArea.prototype.showPicker = function () {
+ var self = this;
+ if (self._sh_timer) {
+ window.clearTimeout(self._sh_timer);
+ }
+ self.picker.removeClass("hidden");
+ self._sh_timer = window.setTimeout(function() {
+ self.button.addClass("active");
+ }, 50);
+ trigger(self, "picker.show", [self.picker]);
+ return self;
+ }
+
+ EmojioneArea.prototype.hidePicker = function () {
+ var self = this;
+ if (self._sh_timer) {
+ window.clearTimeout(self._sh_timer);
+ }
+ self.button.removeClass("active");
+ self._sh_timer = window.setTimeout(function() {
+ self.picker.addClass("hidden");
+ }, 500);
+ trigger(self, "picker.hide", [self.picker]);
+ return self;
+ }
+
+ EmojioneArea.prototype.enable = function () {
+ var self = this;
+ var next = function () {
+ self.disabled = false;
+ self.editor.prop('contenteditable', true);
+ self.button.show();
+ var editor = self[(self.standalone) ? "button" : "editor"];
+ editor.parent().removeClass('emojionearea-disable');
+ trigger(self, 'enabled', [editor]);
+ };
+ self.isReady ? next() : self.on("ready", next);
+ return self;
+ }
+
+ EmojioneArea.prototype.disable = function () {
+ var self = this;
+ self.disabled = true;
+ var next = function () {
+ self.editor.prop('contenteditable', false);
+ self.hidePicker();
+ self.button.hide();
+ var editor = self[(self.standalone) ? "button" : "editor"];
+ editor.parent().addClass('emojionearea-disable');
+ trigger(self, 'disabled', [editor]);
+ };
+ self.isReady ? next() : self.on("ready", next);
+ return self;
+ }
+
+ $.fn.emojioneArea = function(options) {
+ return this.each(function() {
+ if (!!this.emojioneArea) return this.emojioneArea;
+ $.data(this, 'emojioneArea', this.emojioneArea = new EmojioneArea($(this), options));
+ return this.emojioneArea;
+ });
+ };
+
+ $.fn.emojioneArea.defaults = getDefaultOptions();
+
+ $.fn.emojioneAreaText = function(options) {
+ options = getOptions(options);
+
+ var self = this, pseudoSelf = {
+ shortnames: (options && typeof options.shortnames !== 'undefined' ? options.shortnames : true),
+ emojiTemplate: '<img alt="{alt}" class="emojione' + (options && options.sprite && emojioneSupportMode < 3 ? '-{uni}" src="' + blankImg : 'emoji" src="{img}') + '"/>'
+ };
+
+ loadEmojione(options);
+ emojioneReady(function() {
+ self.each(function() {
+ var $this = $(this);
+ if (!$this.hasClass('emojionearea-text')) {
+ $this.addClass('emojionearea-text').html(htmlFromText(($this.is('TEXTAREA') || $this.is('INPUT') ? $this.val() : $this.text()), pseudoSelf));
+ }
+ return $this;
+ });
+ });
+
+ return this;
+ };
+
+}, window ) );
+
+
+/***/ }),
+
+/***/ "./node_modules/angular/index-exposed.js":
+/*!***********************************************!*\
+ !*** ./node_modules/angular/index-exposed.js ***!
+ \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var ___EXPOSE_LOADER_IMPORT___ = __webpack_require__(/*! -!./index.js */ "./node_modules/angular/index.js");
+var ___EXPOSE_LOADER_GET_GLOBAL_THIS___ = __webpack_require__(/*! ../expose-loader/dist/runtime/getGlobalThis.js */ "./node_modules/expose-loader/dist/runtime/getGlobalThis.js");
+var ___EXPOSE_LOADER_GLOBAL_THIS___ = ___EXPOSE_LOADER_GET_GLOBAL_THIS___;
+___EXPOSE_LOADER_GLOBAL_THIS___["angular"] = ___EXPOSE_LOADER_IMPORT___;
+module.exports = ___EXPOSE_LOADER_IMPORT___;
+
+
+/***/ }),
+
+/***/ "./node_modules/expose-loader/dist/runtime/getGlobalThis.js":
+/*!******************************************************************!*\
+ !*** ./node_modules/expose-loader/dist/runtime/getGlobalThis.js ***!
+ \******************************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+// eslint-disable-next-line func-names
+module.exports = function () {
+ if (typeof globalThis === "object") {
+ return globalThis;
+ }
+
+ var g;
+
+ try {
+ // This works if eval is allowed (see CSP)
+ // eslint-disable-next-line no-new-func
+ g = this || new Function("return this")();
+ } catch (e) {
+ // This works if the window reference is available
+ if (typeof window === "object") {
+ return window;
+ } // This works if the self reference is available
+
+
+ if (typeof self === "object") {
+ return self;
+ } // This works if the global reference is available
+
+
+ if (typeof __webpack_require__.g !== "undefined") {
+ return __webpack_require__.g;
+ }
+ }
+
+ return g;
+}();
+
+/***/ }),
+
+/***/ "./node_modules/jquery-textcomplete/dist/jquery.textcomplete.js":
+/*!**********************************************************************!*\
+ !*** ./node_modules/jquery-textcomplete/dist/jquery.textcomplete.js ***!
+ \**********************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (factory) {
+ if (true) {
+ // AMD. Register as an anonymous module.
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js")], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
+ __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+ (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+ } else { var $; }
+}(function (jQuery) {
+
+/*!
+ * jQuery.textcomplete
+ *
+ * Repository: https://github.com/yuku-t/jquery-textcomplete
+ * License: MIT (https://github.com/yuku-t/jquery-textcomplete/blob/master/LICENSE)
+ * Author: Yuku Takahashi
+ */
+
+if (typeof jQuery === 'undefined') {
+ throw new Error('jQuery.textcomplete requires jQuery');
+}
+
++function ($) {
+ 'use strict';
+
+ var warn = function (message) {
+ if (console.warn) { console.warn(message); }
+ };
+
+ var id = 1;
+
+ $.fn.textcomplete = function (strategies, option) {
+ var args = Array.prototype.slice.call(arguments);
+ return this.each(function () {
+ var self = this;
+ var $this = $(this);
+ var completer = $this.data('textComplete');
+ if (!completer) {
+ option || (option = {});
+ option._oid = id++; // unique object id
+ completer = new $.fn.textcomplete.Completer(this, option);
+ $this.data('textComplete', completer);
+ }
+ if (typeof strategies === 'string') {
+ if (!completer) return;
+ args.shift()
+ completer[strategies].apply(completer, args);
+ if (strategies === 'destroy') {
+ $this.removeData('textComplete');
+ }
+ } else {
+ // For backward compatibility.
+ // TODO: Remove at v0.4
+ $.each(strategies, function (obj) {
+ $.each(['header', 'footer', 'placement', 'maxCount'], function (name) {
+ if (obj[name]) {
+ completer.option[name] = obj[name];
+ warn(name + 'as a strategy param is deprecated. Use option.');
+ delete obj[name];
+ }
+ });
+ });
+ completer.register($.fn.textcomplete.Strategy.parse(strategies, {
+ el: self,
+ $el: $this
+ }));
+ }
+ });
+ };
+
+}(jQuery);
+
++function ($) {
+ 'use strict';
+
+ // Exclusive execution control utility.
+ //
+ // func - The function to be locked. It is executed with a function named
+ // `free` as the first argument. Once it is called, additional
+ // execution are ignored until the free is invoked. Then the last
+ // ignored execution will be replayed immediately.
+ //
+ // Examples
+ //
+ // var lockedFunc = lock(function (free) {
+ // setTimeout(function { free(); }, 1000); // It will be free in 1 sec.
+ // console.log('Hello, world');
+ // });
+ // lockedFunc(); // => 'Hello, world'
+ // lockedFunc(); // none
+ // lockedFunc(); // none
+ // // 1 sec past then
+ // // => 'Hello, world'
+ // lockedFunc(); // => 'Hello, world'
+ // lockedFunc(); // none
+ //
+ // Returns a wrapped function.
+ var lock = function (func) {
+ var locked, queuedArgsToReplay;
+
+ return function () {
+ // Convert arguments into a real array.
+ var args = Array.prototype.slice.call(arguments);
+ if (locked) {
+ // Keep a copy of this argument list to replay later.
+ // OK to overwrite a previous value because we only replay
+ // the last one.
+ queuedArgsToReplay = args;
+ return;
+ }
+ locked = true;
+ var self = this;
+ args.unshift(function replayOrFree() {
+ if (queuedArgsToReplay) {
+ // Other request(s) arrived while we were locked.
+ // Now that the lock is becoming available, replay
+ // the latest such request, then call back here to
+ // unlock (or replay another request that arrived
+ // while this one was in flight).
+ var replayArgs = queuedArgsToReplay;
+ queuedArgsToReplay = undefined;
+ replayArgs.unshift(replayOrFree);
+ func.apply(self, replayArgs);
+ } else {
+ locked = false;
+ }
+ });
+ func.apply(this, args);
+ };
+ };
+
+ var isString = function (obj) {
+ return Object.prototype.toString.call(obj) === '[object String]';
+ };
+
+ var uniqueId = 0;
+ var initializedEditors = [];
+
+ function Completer(element, option) {
+ this.$el = $(element);
+ this.id = 'textcomplete' + uniqueId++;
+ this.strategies = [];
+ this.views = [];
+ this.option = $.extend({}, Completer.defaults, option);
+
+ if (!this.$el.is('input[type=text]') && !this.$el.is('input[type=search]') && !this.$el.is('textarea') && !element.isContentEditable && element.contentEditable != 'true') {
+ throw new Error('textcomplete must be called on a Textarea or a ContentEditable.');
+ }
+
+ // use ownerDocument to fix iframe / IE issues
+ if (element === element.ownerDocument.activeElement) {
+ // element has already been focused. Initialize view objects immediately.
+ this.initialize()
+ } else {
+ // Initialize view objects lazily.
+ var self = this;
+ this.$el.one('focus.' + this.id, function () { self.initialize(); });
+
+ // Special handling for CKEditor: lazy init on instance load
+ if ((!this.option.adapter || this.option.adapter == 'CKEditor') && typeof CKEDITOR != 'undefined' && (this.$el.is('textarea'))) {
+ CKEDITOR.on("instanceReady", function(event) { //For multiple ckeditors on one page: this needs to be executed each time a ckeditor-instance is ready.
+
+ if($.inArray(event.editor.id, initializedEditors) == -1) { //For multiple ckeditors on one page: focus-eventhandler should only be added once for every editor.
+ initializedEditors.push(event.editor.id);
+
+ event.editor.on("focus", function(event2) {
+ //replace the element with the Iframe element and flag it as CKEditor
+ self.$el = $(event.editor.editable().$);
+ if (!self.option.adapter) {
+ self.option.adapter = $.fn.textcomplete['CKEditor'];
+ }
+ self.option.ckeditor_instance = event.editor; //For multiple ckeditors on one page: in the old code this was not executed when adapter was alread set. So we were ALWAYS working with the FIRST instance.
+ self.initialize();
+ });
+ }
+ });
+ }
+ }
+ }
+
+ Completer.defaults = {
+ appendTo: 'body',
+ className: '', // deprecated option
+ dropdownClassName: 'dropdown-menu textcomplete-dropdown',
+ maxCount: 10,
+ zIndex: '100',
+ rightEdgeOffset: 30
+ };
+
+ $.extend(Completer.prototype, {
+ // Public properties
+ // -----------------
+
+ id: null,
+ option: null,
+ strategies: null,
+ adapter: null,
+ dropdown: null,
+ $el: null,
+ $iframe: null,
+
+ // Public methods
+ // --------------
+
+ initialize: function () {
+ var element = this.$el.get(0);
+
+ // check if we are in an iframe
+ // we need to alter positioning logic if using an iframe
+ if (this.$el.prop('ownerDocument') !== document && window.frames.length) {
+ for (var iframeIndex = 0; iframeIndex < window.frames.length; iframeIndex++) {
+ if (this.$el.prop('ownerDocument') === window.frames[iframeIndex].document) {
+ this.$iframe = $(window.frames[iframeIndex].frameElement);
+ break;
+ }
+ }
+ }
+
+
+ // Initialize view objects.
+ this.dropdown = new $.fn.textcomplete.Dropdown(element, this, this.option);
+ var Adapter, viewName;
+ if (this.option.adapter) {
+ Adapter = this.option.adapter;
+ } else {
+ if (this.$el.is('textarea') || this.$el.is('input[type=text]') || this.$el.is('input[type=search]')) {
+ viewName = typeof element.selectionEnd === 'number' ? 'Textarea' : 'IETextarea';
+ } else {
+ viewName = 'ContentEditable';
+ }
+ Adapter = $.fn.textcomplete[viewName];
+ }
+ this.adapter = new Adapter(element, this, this.option);
+ },
+
+ destroy: function () {
+ this.$el.off('.' + this.id);
+ if (this.adapter) {
+ this.adapter.destroy();
+ }
+ if (this.dropdown) {
+ this.dropdown.destroy();
+ }
+ this.$el = this.adapter = this.dropdown = null;
+ },
+
+ deactivate: function () {
+ if (this.dropdown) {
+ this.dropdown.deactivate();
+ }
+ },
+
+ // Invoke textcomplete.
+ trigger: function (text, skipUnchangedTerm) {
+ if (!this.dropdown) { this.initialize(); }
+ text != null || (text = this.adapter.getTextFromHeadToCaret());
+ var searchQuery = this._extractSearchQuery(text);
+ if (searchQuery.length) {
+ var term = searchQuery[1];
+ // Ignore shift-key, ctrl-key and so on.
+ if (skipUnchangedTerm && this._term === term && term !== "") { return; }
+ this._term = term;
+ this._search.apply(this, searchQuery);
+ } else {
+ this._term = null;
+ this.dropdown.deactivate();
+ }
+ },
+
+ fire: function (eventName) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ this.$el.trigger(eventName, args);
+ return this;
+ },
+
+ register: function (strategies) {
+ Array.prototype.push.apply(this.strategies, strategies);
+ },
+
+ // Insert the value into adapter view. It is called when the dropdown is clicked
+ // or selected.
+ //
+ // value - The selected element of the array callbacked from search func.
+ // strategy - The Strategy object.
+ // e - Click or keydown event object.
+ select: function (value, strategy, e) {
+ this._term = null;
+ this.adapter.select(value, strategy, e);
+ this.fire('change').fire('textComplete:select', value, strategy);
+ this.adapter.focus();
+ },
+
+ // Private properties
+ // ------------------
+
+ _clearAtNext: true,
+ _term: null,
+
+ // Private methods
+ // ---------------
+
+ // Parse the given text and extract the first matching strategy.
+ //
+ // Returns an array including the strategy, the query term and the match
+ // object if the text matches an strategy; otherwise returns an empty array.
+ _extractSearchQuery: function (text) {
+ for (var i = 0; i < this.strategies.length; i++) {
+ var strategy = this.strategies[i];
+ var context = strategy.context(text);
+ if (context || context === '') {
+ var matchRegexp = $.isFunction(strategy.match) ? strategy.match(text) : strategy.match;
+ if (isString(context)) { text = context; }
+ var match = text.match(matchRegexp);
+ if (match) { return [strategy, match[strategy.index], match]; }
+ }
+ }
+ return []
+ },
+
+ // Call the search method of selected strategy..
+ _search: lock(function (free, strategy, term, match) {
+ var self = this;
+ strategy.search(term, function (data, stillSearching) {
+ if (!self.dropdown.shown) {
+ self.dropdown.activate();
+ }
+ if (self._clearAtNext) {
+ // The first callback in the current lock.
+ self.dropdown.clear();
+ self._clearAtNext = false;
+ }
+ self.dropdown.setPosition(self.adapter.getCaretPosition());
+ self.dropdown.render(self._zip(data, strategy, term));
+ if (!stillSearching) {
+ // The last callback in the current lock.
+ free();
+ self._clearAtNext = true; // Call dropdown.clear at the next time.
+ }
+ }, match);
+ }),
+
+ // Build a parameter for Dropdown#render.
+ //
+ // Examples
+ //
+ // this._zip(['a', 'b'], 's');
+ // //=> [{ value: 'a', strategy: 's' }, { value: 'b', strategy: 's' }]
+ _zip: function (data, strategy, term) {
+ return $.map(data, function (value) {
+ return { value: value, strategy: strategy, term: term };
+ });
+ }
+ });
+
+ $.fn.textcomplete.Completer = Completer;
+}(jQuery);
+
++function ($) {
+ 'use strict';
+
+ var $window = $(window);
+
+ var include = function (zippedData, datum) {
+ var i, elem;
+ var idProperty = datum.strategy.idProperty
+ for (i = 0; i < zippedData.length; i++) {
+ elem = zippedData[i];
+ if (elem.strategy !== datum.strategy) continue;
+ if (idProperty) {
+ if (elem.value[idProperty] === datum.value[idProperty]) return true;
+ } else {
+ if (elem.value === datum.value) return true;
+ }
+ }
+ return false;
+ };
+
+ var dropdownViews = {};
+ $(document).on('click', function (e) {
+ var id = e.originalEvent && e.originalEvent.keepTextCompleteDropdown;
+ $.each(dropdownViews, function (key, view) {
+ if (key !== id) { view.deactivate(); }
+ });
+ });
+
+ var commands = {
+ SKIP_DEFAULT: 0,
+ KEY_UP: 1,
+ KEY_DOWN: 2,
+ KEY_ENTER: 3,
+ KEY_PAGEUP: 4,
+ KEY_PAGEDOWN: 5,
+ KEY_ESCAPE: 6
+ };
+
+ // Dropdown view
+ // =============
+
+ // Construct Dropdown object.
+ //
+ // element - Textarea or contenteditable element.
+ function Dropdown(element, completer, option) {
+ this.$el = Dropdown.createElement(option);
+ this.completer = completer;
+ this.id = completer.id + 'dropdown';
+ this._data = []; // zipped data.
+ this.$inputEl = $(element);
+ this.option = option;
+
+ // Override setPosition method.
+ if (option.listPosition) { this.setPosition = option.listPosition; }
+ if (option.height) { this.$el.height(option.height); }
+ var self = this;
+ $.each(['maxCount', 'placement', 'footer', 'header', 'noResultsMessage', 'className'], function (_i, name) {
+ if (option[name] != null) { self[name] = option[name]; }
+ });
+ this._bindEvents(element);
+ dropdownViews[this.id] = this;
+ }
+
+ $.extend(Dropdown, {
+ // Class methods
+ // -------------
+
+ createElement: function (option) {
+ var $parent = option.appendTo;
+ if (!($parent instanceof $)) { $parent = $($parent); }
+ var $el = $('<ul></ul>')
+ .addClass(option.dropdownClassName)
+ .attr('id', 'textcomplete-dropdown-' + option._oid)
+ .css({
+ display: 'none',
+ left: 0,
+ position: 'absolute',
+ zIndex: option.zIndex
+ })
+ .appendTo($parent);
+ return $el;
+ }
+ });
+
+ $.extend(Dropdown.prototype, {
+ // Public properties
+ // -----------------
+
+ $el: null, // jQuery object of ul.dropdown-menu element.
+ $inputEl: null, // jQuery object of target textarea.
+ completer: null,
+ footer: null,
+ header: null,
+ id: null,
+ maxCount: null,
+ placement: '',
+ shown: false,
+ data: [], // Shown zipped data.
+ className: '',
+
+ // Public methods
+ // --------------
+
+ destroy: function () {
+ // Don't remove $el because it may be shared by several textcompletes.
+ this.deactivate();
+
+ this.$el.off('.' + this.id);
+ this.$inputEl.off('.' + this.id);
+ this.clear();
+ this.$el.remove();
+ this.$el = this.$inputEl = this.completer = null;
+ delete dropdownViews[this.id]
+ },
+
+ render: function (zippedData) {
+ var contentsHtml = this._buildContents(zippedData);
+ var unzippedData = $.map(zippedData, function (d) { return d.value; });
+ if (zippedData.length) {
+ var strategy = zippedData[0].strategy;
+ if (strategy.id) {
+ this.$el.attr('data-strategy', strategy.id);
+ } else {
+ this.$el.removeAttr('data-strategy');
+ }
+ this._renderHeader(unzippedData);
+ this._renderFooter(unzippedData);
+ if (contentsHtml) {
+ this._renderContents(contentsHtml);
+ this._fitToBottom();
+ this._fitToRight();
+ this._activateIndexedItem();
+ }
+ this._setScroll();
+ } else if (this.noResultsMessage) {
+ this._renderNoResultsMessage(unzippedData);
+ } else if (this.shown) {
+ this.deactivate();
+ }
+ },
+
+ setPosition: function (pos) {
+ // Make the dropdown fixed if the input is also fixed
+ // This can't be done during init, as textcomplete may be used on multiple elements on the same page
+ // Because the same dropdown is reused behind the scenes, we need to recheck every time the dropdown is showed
+ var position = 'absolute';
+ // Check if input or one of its parents has positioning we need to care about
+ this.$inputEl.add(this.$inputEl.parents()).each(function() {
+ if($(this).css('position') === 'absolute') // The element has absolute positioning, so it's all OK
+ return false;
+ if($(this).css('position') === 'fixed') {
+ pos.top -= $window.scrollTop();
+ pos.left -= $window.scrollLeft();
+ position = 'fixed';
+ return false;
+ }
+ });
+ this.$el.css(this._applyPlacement(pos));
+ this.$el.css({ position: position }); // Update positioning
+
+ return this;
+ },
+
+ clear: function () {
+ this.$el.html('');
+ this.data = [];
+ this._index = 0;
+ this._$header = this._$footer = this._$noResultsMessage = null;
+ },
+
+ activate: function () {
+ if (!this.shown) {
+ this.clear();
+ this.$el.show();
+ if (this.className) { this.$el.addClass(this.className); }
+ this.completer.fire('textComplete:show');
+ this.shown = true;
+ }
+ return this;
+ },
+
+ deactivate: function () {
+ if (this.shown) {
+ this.$el.hide();
+ if (this.className) { this.$el.removeClass(this.className); }
+ this.completer.fire('textComplete:hide');
+ this.shown = false;
+ }
+ return this;
+ },
+
+ isUp: function (e) {
+ return e.keyCode === 38 || (e.ctrlKey && e.keyCode === 80); // UP, Ctrl-P
+ },
+
+ isDown: function (e) {
+ return e.keyCode === 40 || (e.ctrlKey && e.keyCode === 78); // DOWN, Ctrl-N
+ },
+
+ isEnter: function (e) {
+ var modifiers = e.ctrlKey || e.altKey || e.metaKey || e.shiftKey;
+ return !modifiers && (e.keyCode === 13 || e.keyCode === 9 || (this.option.completeOnSpace === true && e.keyCode === 32)) // ENTER, TAB
+ },
+
+ isPageup: function (e) {
+ return e.keyCode === 33; // PAGEUP
+ },
+
+ isPagedown: function (e) {
+ return e.keyCode === 34; // PAGEDOWN
+ },
+
+ isEscape: function (e) {
+ return e.keyCode === 27; // ESCAPE
+ },
+
+ // Private properties
+ // ------------------
+
+ _data: null, // Currently shown zipped data.
+ _index: null,
+ _$header: null,
+ _$noResultsMessage: null,
+ _$footer: null,
+
+ // Private methods
+ // ---------------
+
+ _bindEvents: function () {
+ this.$el.on('mousedown.' + this.id, '.textcomplete-item', $.proxy(this._onClick, this));
+ this.$el.on('touchstart.' + this.id, '.textcomplete-item', $.proxy(this._onClick, this));
+ this.$el.on('mouseover.' + this.id, '.textcomplete-item', $.proxy(this._onMouseover, this));
+ this.$inputEl.on('keydown.' + this.id, $.proxy(this._onKeydown, this));
+ },
+
+ _onClick: function (e) {
+ var $el = $(e.target);
+ e.preventDefault();
+ e.originalEvent.keepTextCompleteDropdown = this.id;
+ if (!$el.hasClass('textcomplete-item')) {
+ $el = $el.closest('.textcomplete-item');
+ }
+ var datum = this.data[parseInt($el.data('index'), 10)];
+ this.completer.select(datum.value, datum.strategy, e);
+ var self = this;
+ // Deactive at next tick to allow other event handlers to know whether
+ // the dropdown has been shown or not.
+ setTimeout(function () {
+ self.deactivate();
+ if (e.type === 'touchstart') {
+ self.$inputEl.focus();
+ }
+ }, 0);
+ },
+
+ // Activate hovered item.
+ _onMouseover: function (e) {
+ var $el = $(e.target);
+ e.preventDefault();
+ if (!$el.hasClass('textcomplete-item')) {
+ $el = $el.closest('.textcomplete-item');
+ }
+ this._index = parseInt($el.data('index'), 10);
+ this._activateIndexedItem();
+ },
+
+ _onKeydown: function (e) {
+ if (!this.shown) { return; }
+
+ var command;
+
+ if ($.isFunction(this.option.onKeydown)) {
+ command = this.option.onKeydown(e, commands);
+ }
+
+ if (command == null) {
+ command = this._defaultKeydown(e);
+ }
+
+ switch (command) {
+ case commands.KEY_UP:
+ e.preventDefault();
+ this._up();
+ break;
+ case commands.KEY_DOWN:
+ e.preventDefault();
+ this._down();
+ break;
+ case commands.KEY_ENTER:
+ e.preventDefault();
+ this._enter(e);
+ break;
+ case commands.KEY_PAGEUP:
+ e.preventDefault();
+ this._pageup();
+ break;
+ case commands.KEY_PAGEDOWN:
+ e.preventDefault();
+ this._pagedown();
+ break;
+ case commands.KEY_ESCAPE:
+ e.preventDefault();
+ this.deactivate();
+ break;
+ }
+ },
+
+ _defaultKeydown: function (e) {
+ if (this.isUp(e)) {
+ return commands.KEY_UP;
+ } else if (this.isDown(e)) {
+ return commands.KEY_DOWN;
+ } else if (this.isEnter(e)) {
+ return commands.KEY_ENTER;
+ } else if (this.isPageup(e)) {
+ return commands.KEY_PAGEUP;
+ } else if (this.isPagedown(e)) {
+ return commands.KEY_PAGEDOWN;
+ } else if (this.isEscape(e)) {
+ return commands.KEY_ESCAPE;
+ }
+ },
+
+ _up: function () {
+ if (this._index === 0) {
+ this._index = this.data.length - 1;
+ } else {
+ this._index -= 1;
+ }
+ this._activateIndexedItem();
+ this._setScroll();
+ },
+
+ _down: function () {
+ if (this._index === this.data.length - 1) {
+ this._index = 0;
+ } else {
+ this._index += 1;
+ }
+ this._activateIndexedItem();
+ this._setScroll();
+ },
+
+ _enter: function (e) {
+ var datum = this.data[parseInt(this._getActiveElement().data('index'), 10)];
+ this.completer.select(datum.value, datum.strategy, e);
+ this.deactivate();
+ },
+
+ _pageup: function () {
+ var target = 0;
+ var threshold = this._getActiveElement().position().top - this.$el.innerHeight();
+ this.$el.children().each(function (i) {
+ if ($(this).position().top + $(this).outerHeight() > threshold) {
+ target = i;
+ return false;
+ }
+ });
+ this._index = target;
+ this._activateIndexedItem();
+ this._setScroll();
+ },
+
+ _pagedown: function () {
+ var target = this.data.length - 1;
+ var threshold = this._getActiveElement().position().top + this.$el.innerHeight();
+ this.$el.children().each(function (i) {
+ if ($(this).position().top > threshold) {
+ target = i;
+ return false
+ }
+ });
+ this._index = target;
+ this._activateIndexedItem();
+ this._setScroll();
+ },
+
+ _activateIndexedItem: function () {
+ this.$el.find('.textcomplete-item.active').removeClass('active');
+ this._getActiveElement().addClass('active');
+ },
+
+ _getActiveElement: function () {
+ return this.$el.children('.textcomplete-item:nth(' + this._index + ')');
+ },
+
+ _setScroll: function () {
+ var $activeEl = this._getActiveElement();
+ var itemTop = $activeEl.position().top;
+ var itemHeight = $activeEl.outerHeight();
+ var visibleHeight = this.$el.innerHeight();
+ var visibleTop = this.$el.scrollTop();
+ if (this._index === 0 || this._index == this.data.length - 1 || itemTop < 0) {
+ this.$el.scrollTop(itemTop + visibleTop);
+ } else if (itemTop + itemHeight > visibleHeight) {
+ this.$el.scrollTop(itemTop + itemHeight + visibleTop - visibleHeight);
+ }
+ },
+
+ _buildContents: function (zippedData) {
+ var datum, i, index;
+ var html = '';
+ for (i = 0; i < zippedData.length; i++) {
+ if (this.data.length === this.maxCount) break;
+ datum = zippedData[i];
+ if (include(this.data, datum)) { continue; }
+ index = this.data.length;
+ this.data.push(datum);
+ html += '<li class="textcomplete-item" data-index="' + index + '"><a>';
+ html += datum.strategy.template(datum.value, datum.term);
+ html += '</a></li>';
+ }
+ return html;
+ },
+
+ _renderHeader: function (unzippedData) {
+ if (this.header) {
+ if (!this._$header) {
+ this._$header = $('<li class="textcomplete-header"></li>').prependTo(this.$el);
+ }
+ var html = $.isFunction(this.header) ? this.header(unzippedData) : this.header;
+ this._$header.html(html);
+ }
+ },
+
+ _renderFooter: function (unzippedData) {
+ if (this.footer) {
+ if (!this._$footer) {
+ this._$footer = $('<li class="textcomplete-footer"></li>').appendTo(this.$el);
+ }
+ var html = $.isFunction(this.footer) ? this.footer(unzippedData) : this.footer;
+ this._$footer.html(html);
+ }
+ },
+
+ _renderNoResultsMessage: function (unzippedData) {
+ if (this.noResultsMessage) {
+ if (!this._$noResultsMessage) {
+ this._$noResultsMessage = $('<li class="textcomplete-no-results-message"></li>').appendTo(this.$el);
+ }
+ var html = $.isFunction(this.noResultsMessage) ? this.noResultsMessage(unzippedData) : this.noResultsMessage;
+ this._$noResultsMessage.html(html);
+ }
+ },
+
+ _renderContents: function (html) {
+ if (this._$footer) {
+ this._$footer.before(html);
+ } else {
+ this.$el.append(html);
+ }
+ },
+
+ _fitToBottom: function() {
+ var windowScrollBottom = $window.scrollTop() + $window.height();
+ var height = this.$el.height();
+ if ((this.$el.position().top + height) > windowScrollBottom) {
+ // only do this if we are not in an iframe
+ if (!this.completer.$iframe) {
+ this.$el.offset({top: windowScrollBottom - height});
+ }
+ }
+ },
+
+ _fitToRight: function() {
+ // We don't know how wide our content is until the browser positions us, and at that point it clips us
+ // to the document width so we don't know if we would have overrun it. As a heuristic to avoid that clipping
+ // (which makes our elements wrap onto the next line and corrupt the next item), if we're close to the right
+ // edge, move left. We don't know how far to move left, so just keep nudging a bit.
+ var tolerance = this.option.rightEdgeOffset; // pixels. Make wider than vertical scrollbar because we might not be able to use that space.
+ var lastOffset = this.$el.offset().left, offset;
+ var width = this.$el.width();
+ var maxLeft = $window.width() - tolerance;
+ while (lastOffset + width > maxLeft) {
+ this.$el.offset({left: lastOffset - tolerance});
+ offset = this.$el.offset().left;
+ if (offset >= lastOffset) { break; }
+ lastOffset = offset;
+ }
+ },
+
+ _applyPlacement: function (position) {
+ // If the 'placement' option set to 'top', move the position above the element.
+ if (this.placement.indexOf('top') !== -1) {
+ // Overwrite the position object to set the 'bottom' property instead of the top.
+ position = {
+ top: 'auto',
+ bottom: this.$el.parent().height() - position.top + position.lineHeight,
+ left: position.left
+ };
+ } else {
+ position.bottom = 'auto';
+ delete position.lineHeight;
+ }
+ if (this.placement.indexOf('absleft') !== -1) {
+ position.left = 0;
+ } else if (this.placement.indexOf('absright') !== -1) {
+ position.right = 0;
+ position.left = 'auto';
+ }
+ return position;
+ }
+ });
+
+ $.fn.textcomplete.Dropdown = Dropdown;
+ $.extend($.fn.textcomplete, commands);
+}(jQuery);
+
++function ($) {
+ 'use strict';
+
+ // Memoize a search function.
+ var memoize = function (func) {
+ var memo = {};
+ return function (term, callback) {
+ if (memo[term]) {
+ callback(memo[term]);
+ } else {
+ func.call(this, term, function (data) {
+ memo[term] = (memo[term] || []).concat(data);
+ callback.apply(null, arguments);
+ });
+ }
+ };
+ };
+
+ function Strategy(options) {
+ $.extend(this, options);
+ if (this.cache) { this.search = memoize(this.search); }
+ }
+
+ Strategy.parse = function (strategiesArray, params) {
+ return $.map(strategiesArray, function (strategy) {
+ var strategyObj = new Strategy(strategy);
+ strategyObj.el = params.el;
+ strategyObj.$el = params.$el;
+ return strategyObj;
+ });
+ };
+
+ $.extend(Strategy.prototype, {
+ // Public properties
+ // -----------------
+
+ // Required
+ match: null,
+ replace: null,
+ search: null,
+
+ // Optional
+ id: null,
+ cache: false,
+ context: function () { return true; },
+ index: 2,
+ template: function (obj) { return obj; },
+ idProperty: null
+ });
+
+ $.fn.textcomplete.Strategy = Strategy;
+
+}(jQuery);
+
++function ($) {
+ 'use strict';
+
+ var now = Date.now || function () { return new Date().getTime(); };
+
+ // Returns a function, that, as long as it continues to be invoked, will not
+ // be triggered. The function will be called after it stops being called for
+ // `wait` msec.
+ //
+ // This utility function was originally implemented at Underscore.js.
+ var debounce = function (func, wait) {
+ var timeout, args, context, timestamp, result;
+ var later = function () {
+ var last = now() - timestamp;
+ if (last < wait) {
+ timeout = setTimeout(later, wait - last);
+ } else {
+ timeout = null;
+ result = func.apply(context, args);
+ context = args = null;
+ }
+ };
+
+ return function () {
+ context = this;
+ args = arguments;
+ timestamp = now();
+ if (!timeout) {
+ timeout = setTimeout(later, wait);
+ }
+ return result;
+ };
+ };
+
+ function Adapter () {}
+
+ $.extend(Adapter.prototype, {
+ // Public properties
+ // -----------------
+
+ id: null, // Identity.
+ completer: null, // Completer object which creates it.
+ el: null, // Textarea element.
+ $el: null, // jQuery object of the textarea.
+ option: null,
+
+ // Public methods
+ // --------------
+
+ initialize: function (element, completer, option) {
+ this.el = element;
+ this.$el = $(element);
+ this.id = completer.id + this.constructor.name;
+ this.completer = completer;
+ this.option = option;
+
+ if (this.option.debounce) {
+ this._onKeyup = debounce(this._onKeyup, this.option.debounce);
+ }
+
+ this._bindEvents();
+ },
+
+ destroy: function () {
+ this.$el.off('.' + this.id); // Remove all event handlers.
+ this.$el = this.el = this.completer = null;
+ },
+
+ // Update the element with the given value and strategy.
+ //
+ // value - The selected object. It is one of the item of the array
+ // which was callbacked from the search function.
+ // strategy - The Strategy associated with the selected value.
+ select: function (/* value, strategy */) {
+ throw new Error('Not implemented');
+ },
+
+ // Returns the caret's relative coordinates from body's left top corner.
+ getCaretPosition: function () {
+ var position = this._getCaretRelativePosition();
+ var offset = this.$el.offset();
+
+ // Calculate the left top corner of `this.option.appendTo` element.
+ var $parent = this.option.appendTo;
+ if ($parent) {
+ if (!($parent instanceof $)) { $parent = $($parent); }
+ var parentOffset = $parent.offsetParent().offset();
+ offset.top -= parentOffset.top;
+ offset.left -= parentOffset.left;
+ }
+
+ position.top += offset.top;
+ position.left += offset.left;
+ return position;
+ },
+
+ // Focus on the element.
+ focus: function () {
+ this.$el.focus();
+ },
+
+ // Private methods
+ // ---------------
+
+ _bindEvents: function () {
+ this.$el.on('keyup.' + this.id, $.proxy(this._onKeyup, this));
+ },
+
+ _onKeyup: function (e) {
+ if (this._skipSearch(e)) { return; }
+ this.completer.trigger(this.getTextFromHeadToCaret(), true);
+ },
+
+ // Suppress searching if it returns true.
+ _skipSearch: function (clickEvent) {
+ switch (clickEvent.keyCode) {
+ case 9: // TAB
+ case 13: // ENTER
+ case 16: // SHIFT
+ case 17: // CTRL
+ case 18: // ALT
+ case 33: // PAGEUP
+ case 34: // PAGEDOWN
+ case 40: // DOWN
+ case 38: // UP
+ case 27: // ESC
+ return true;
+ }
+ if (clickEvent.ctrlKey) switch (clickEvent.keyCode) {
+ case 78: // Ctrl-N
+ case 80: // Ctrl-P
+ return true;
+ }
+ }
+ });
+
+ $.fn.textcomplete.Adapter = Adapter;
+}(jQuery);
+
++function ($) {
+ 'use strict';
+
+ // Textarea adapter
+ // ================
+ //
+ // Managing a textarea. It doesn't know a Dropdown.
+ function Textarea(element, completer, option) {
+ this.initialize(element, completer, option);
+ }
+
+ $.extend(Textarea.prototype, $.fn.textcomplete.Adapter.prototype, {
+ // Public methods
+ // --------------
+
+ // Update the textarea with the given value and strategy.
+ select: function (value, strategy, e) {
+ var pre = this.getTextFromHeadToCaret();
+ var post = this.el.value.substring(this.el.selectionEnd);
+ var newSubstr = strategy.replace(value, e);
+ var regExp;
+ if (typeof newSubstr !== 'undefined') {
+ if ($.isArray(newSubstr)) {
+ post = newSubstr[1] + post;
+ newSubstr = newSubstr[0];
+ }
+ regExp = $.isFunction(strategy.match) ? strategy.match(pre) : strategy.match;
+ pre = pre.replace(regExp, newSubstr);
+ this.$el.val(pre + post);
+ this.el.selectionStart = this.el.selectionEnd = pre.length;
+ }
+ },
+
+ getTextFromHeadToCaret: function () {
+ return this.el.value.substring(0, this.el.selectionEnd);
+ },
+
+ // Private methods
+ // ---------------
+
+ _getCaretRelativePosition: function () {
+ var p = $.fn.textcomplete.getCaretCoordinates(this.el, this.el.selectionStart);
+ return {
+ top: p.top + this._calculateLineHeight() - this.$el.scrollTop(),
+ left: p.left - this.$el.scrollLeft(),
+ lineHeight: this._calculateLineHeight()
+ };
+ },
+
+ _calculateLineHeight: function () {
+ var lineHeight = parseInt(this.$el.css('line-height'), 10);
+ if (isNaN(lineHeight)) {
+ // http://stackoverflow.com/a/4515470/1297336
+ var parentNode = this.el.parentNode;
+ var temp = document.createElement(this.el.nodeName);
+ var style = this.el.style;
+ temp.setAttribute(
+ 'style',
+ 'margin:0px;padding:0px;font-family:' + style.fontFamily + ';font-size:' + style.fontSize
+ );
+ temp.innerHTML = 'test';
+ parentNode.appendChild(temp);
+ lineHeight = temp.clientHeight;
+ parentNode.removeChild(temp);
+ }
+ return lineHeight;
+ }
+ });
+
+ $.fn.textcomplete.Textarea = Textarea;
+}(jQuery);
+
++function ($) {
+ 'use strict';
+
+ var sentinelChar = '吶';
+
+ function IETextarea(element, completer, option) {
+ this.initialize(element, completer, option);
+ $('<span>' + sentinelChar + '</span>').css({
+ position: 'absolute',
+ top: -9999,
+ left: -9999
+ }).insertBefore(element);
+ }
+
+ $.extend(IETextarea.prototype, $.fn.textcomplete.Textarea.prototype, {
+ // Public methods
+ // --------------
+
+ select: function (value, strategy, e) {
+ var pre = this.getTextFromHeadToCaret();
+ var post = this.el.value.substring(pre.length);
+ var newSubstr = strategy.replace(value, e);
+ var regExp;
+ if (typeof newSubstr !== 'undefined') {
+ if ($.isArray(newSubstr)) {
+ post = newSubstr[1] + post;
+ newSubstr = newSubstr[0];
+ }
+ regExp = $.isFunction(strategy.match) ? strategy.match(pre) : strategy.match;
+ pre = pre.replace(regExp, newSubstr);
+ this.$el.val(pre + post);
+ this.el.focus();
+ var range = this.el.createTextRange();
+ range.collapse(true);
+ range.moveEnd('character', pre.length);
+ range.moveStart('character', pre.length);
+ range.select();
+ }
+ },
+
+ getTextFromHeadToCaret: function () {
+ this.el.focus();
+ var range = document.selection.createRange();
+ range.moveStart('character', -this.el.value.length);
+ var arr = range.text.split(sentinelChar)
+ return arr.length === 1 ? arr[0] : arr[1];
+ }
+ });
+
+ $.fn.textcomplete.IETextarea = IETextarea;
+}(jQuery);
+
+// NOTE: TextComplete plugin has contenteditable support but it does not work
+// fine especially on old IEs.
+// Any pull requests are REALLY welcome.
+
++function ($) {
+ 'use strict';
+
+ // ContentEditable adapter
+ // =======================
+ //
+ // Adapter for contenteditable elements.
+ function ContentEditable (element, completer, option) {
+ this.initialize(element, completer, option);
+ }
+
+ $.extend(ContentEditable.prototype, $.fn.textcomplete.Adapter.prototype, {
+ // Public methods
+ // --------------
+
+ // Update the content with the given value and strategy.
+ // When an dropdown item is selected, it is executed.
+ select: function (value, strategy, e) {
+ var pre = this.getTextFromHeadToCaret();
+ // use ownerDocument instead of window to support iframes
+ var sel = this.el.ownerDocument.getSelection();
+
+ var range = sel.getRangeAt(0);
+ var selection = range.cloneRange();
+ selection.selectNodeContents(range.startContainer);
+ var content = selection.toString();
+ var post = content.substring(range.startOffset);
+ var newSubstr = strategy.replace(value, e);
+ var regExp;
+ if (typeof newSubstr !== 'undefined') {
+ if ($.isArray(newSubstr)) {
+ post = newSubstr[1] + post;
+ newSubstr = newSubstr[0];
+ }
+ regExp = $.isFunction(strategy.match) ? strategy.match(pre) : strategy.match;
+ pre = pre.replace(regExp, newSubstr)
+ .replace(/ $/, " "); //   necessary at least for CKeditor to not eat spaces
+ range.selectNodeContents(range.startContainer);
+ range.deleteContents();
+
+ // create temporary elements
+ var preWrapper = this.el.ownerDocument.createElement("div");
+ preWrapper.innerHTML = pre;
+ var postWrapper = this.el.ownerDocument.createElement("div");
+ postWrapper.innerHTML = post;
+
+ // create the fragment thats inserted
+ var fragment = this.el.ownerDocument.createDocumentFragment();
+ var childNode;
+ var lastOfPre;
+ while (childNode = preWrapper.firstChild) {
+ lastOfPre = fragment.appendChild(childNode);
+ }
+ while (childNode = postWrapper.firstChild) {
+ fragment.appendChild(childNode);
+ }
+
+ // insert the fragment & jump behind the last node in "pre"
+ range.insertNode(fragment);
+ range.setStartAfter(lastOfPre);
+
+ range.collapse(true);
+ sel.removeAllRanges();
+ sel.addRange(range);
+ }
+ },
+
+ // Private methods
+ // ---------------
+
+ // Returns the caret's relative position from the contenteditable's
+ // left top corner.
+ //
+ // Examples
+ //
+ // this._getCaretRelativePosition()
+ // //=> { top: 18, left: 200, lineHeight: 16 }
+ //
+ // Dropdown's position will be decided using the result.
+ _getCaretRelativePosition: function () {
+ var range = this.el.ownerDocument.getSelection().getRangeAt(0).cloneRange();
+ var wrapperNode = range.endContainer.parentNode;
+ var node = this.el.ownerDocument.createElement('span');
+ range.insertNode(node);
+ range.selectNodeContents(node);
+ range.deleteContents();
+ setTimeout(function() { wrapperNode.normalize(); }, 0);
+ var $node = $(node);
+ var position = $node.offset();
+ position.left -= this.$el.offset().left;
+ position.top += $node.height() - this.$el.offset().top;
+ position.lineHeight = $node.height();
+
+ // special positioning logic for iframes
+ // this is typically used for contenteditables such as tinymce or ckeditor
+ if (this.completer.$iframe) {
+ var iframePosition = this.completer.$iframe.offset();
+ position.top += iframePosition.top;
+ position.left += iframePosition.left;
+ // We need to get the scrollTop of the html-element inside the iframe and not of the body-element,
+ // because on IE the scrollTop of the body-element (this.$el) is always zero.
+ position.top -= $(this.completer.$iframe[0].contentWindow.document).scrollTop();
+ }
+
+ $node.remove();
+ return position;
+ },
+
+ // Returns the string between the first character and the caret.
+ // Completer will be triggered with the result for start autocompleting.
+ //
+ // Example
+ //
+ // // Suppose the html is '<b>hello</b> wor|ld' and | is the caret.
+ // this.getTextFromHeadToCaret()
+ // // => ' wor' // not '<b>hello</b> wor'
+ getTextFromHeadToCaret: function () {
+ var range = this.el.ownerDocument.getSelection().getRangeAt(0);
+ var selection = range.cloneRange();
+ selection.selectNodeContents(range.startContainer);
+ return selection.toString().substring(0, range.startOffset);
+ }
+ });
+
+ $.fn.textcomplete.ContentEditable = ContentEditable;
+}(jQuery);
+
+// NOTE: TextComplete plugin has contenteditable support but it does not work
+// fine especially on old IEs.
+// Any pull requests are REALLY welcome.
+
++function ($) {
+ 'use strict';
+
+ // CKEditor adapter
+ // =======================
+ //
+ // Adapter for CKEditor, based on contenteditable elements.
+ function CKEditor (element, completer, option) {
+ this.initialize(element, completer, option);
+ }
+
+ $.extend(CKEditor.prototype, $.fn.textcomplete.ContentEditable.prototype, {
+ _bindEvents: function () {
+ var $this = this;
+ this.option.ckeditor_instance.on('key', function(event) {
+ var domEvent = event.data;
+ $this._onKeyup(domEvent);
+ if ($this.completer.dropdown.shown && $this._skipSearch(domEvent)) {
+ return false;
+ }
+ }, null, null, 1); // 1 = Priority = Important!
+ // we actually also need the native event, as the CKEditor one is happening to late
+ this.$el.on('keyup.' + this.id, $.proxy(this._onKeyup, this));
+ },
+});
+
+ $.fn.textcomplete.CKEditor = CKEditor;
+}(jQuery);
+
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Jonathan Ong me@jongleberry.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+// associated documentation files (the "Software"), to deal in the Software without restriction,
+// including without limitation the rights to use, copy, modify, merge, publish, distribute,
+// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+// NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// https://github.com/component/textarea-caret-position
+
+(function ($) {
+
+// The properties that we copy into a mirrored div.
+// Note that some browsers, such as Firefox,
+// do not concatenate properties, i.e. padding-top, bottom etc. -> padding,
+// so we have to do every single property specifically.
+var properties = [
+ 'direction', // RTL support
+ 'boxSizing',
+ 'width', // on Chrome and IE, exclude the scrollbar, so the mirror div wraps exactly as the textarea does
+ 'height',
+ 'overflowX',
+ 'overflowY', // copy the scrollbar for IE
+
+ 'borderTopWidth',
+ 'borderRightWidth',
+ 'borderBottomWidth',
+ 'borderLeftWidth',
+ 'borderStyle',
+
+ 'paddingTop',
+ 'paddingRight',
+ 'paddingBottom',
+ 'paddingLeft',
+
+ // https://developer.mozilla.org/en-US/docs/Web/CSS/font
+ 'fontStyle',
+ 'fontVariant',
+ 'fontWeight',
+ 'fontStretch',
+ 'fontSize',
+ 'fontSizeAdjust',
+ 'lineHeight',
+ 'fontFamily',
+
+ 'textAlign',
+ 'textTransform',
+ 'textIndent',
+ 'textDecoration', // might not make a difference, but better be safe
+
+ 'letterSpacing',
+ 'wordSpacing',
+
+ 'tabSize',
+ 'MozTabSize'
+
+];
+
+var isBrowser = (typeof window !== 'undefined');
+var isFirefox = (isBrowser && window.mozInnerScreenX != null);
+
+function getCaretCoordinates(element, position, options) {
+ if(!isBrowser) {
+ throw new Error('textarea-caret-position#getCaretCoordinates should only be called in a browser');
+ }
+
+ var debug = options && options.debug || false;
+ if (debug) {
+ var el = document.querySelector('#input-textarea-caret-position-mirror-div');
+ if ( el ) { el.parentNode.removeChild(el); }
+ }
+
+ // mirrored div
+ var div = document.createElement('div');
+ div.id = 'input-textarea-caret-position-mirror-div';
+ document.body.appendChild(div);
+
+ var style = div.style;
+ var computed = window.getComputedStyle? getComputedStyle(element) : element.currentStyle; // currentStyle for IE < 9
+
+ // default textarea styles
+ style.whiteSpace = 'pre-wrap';
+ if (element.nodeName !== 'INPUT')
+ style.wordWrap = 'break-word'; // only for textarea-s
+
+ // position off-screen
+ style.position = 'absolute'; // required to return coordinates properly
+ if (!debug)
+ style.visibility = 'hidden'; // not 'display: none' because we want rendering
+
+ // transfer the element's properties to the div
+ properties.forEach(function (prop) {
+ style[prop] = computed[prop];
+ });
+
+ if (isFirefox) {
+ // Firefox lies about the overflow property for textareas: https://bugzilla.mozilla.org/show_bug.cgi?id=984275
+ if (element.scrollHeight > parseInt(computed.height))
+ style.overflowY = 'scroll';
+ } else {
+ style.overflow = 'hidden'; // for Chrome to not render a scrollbar; IE keeps overflowY = 'scroll'
+ }
+
+ div.textContent = element.value.substring(0, position);
+ // the second special handling for input type="text" vs textarea: spaces need to be replaced with non-breaking spaces - http://stackoverflow.com/a/13402035/1269037
+ if (element.nodeName === 'INPUT')
+ div.textContent = div.textContent.replace(/\s/g, '\u00a0');
+
+ var span = document.createElement('span');
+ // Wrapping must be replicated *exactly*, including when a long word gets
+ // onto the next line, with whitespace at the end of the line before (#7).
+ // The *only* reliable way to do that is to copy the *entire* rest of the
+ // textarea's content into the <span> created at the caret position.
+ // for inputs, just '.' would be enough, but why bother?
+ span.textContent = element.value.substring(position) || '.'; // || because a completely empty faux span doesn't render at all
+ div.appendChild(span);
+
+ var coordinates = {
+ top: span.offsetTop + parseInt(computed['borderTopWidth']),
+ left: span.offsetLeft + parseInt(computed['borderLeftWidth'])
+ };
+
+ if (debug) {
+ span.style.backgroundColor = '#aaa';
+ } else {
+ document.body.removeChild(div);
+ }
+
+ return coordinates;
+}
+
+$.fn.textcomplete.getCaretCoordinates = getCaretCoordinates;
+
+}(jQuery));
+
+return jQuery;
+}));
+
+
+/***/ }),
+
+/***/ "./node_modules/jquery/dist/jquery.js":
+/*!********************************************!*\
+ !*** ./node_modules/jquery/dist/jquery.js ***!
+ \********************************************/
+/***/ (function(module, exports) {
+
+var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
+ * jQuery JavaScript Library v3.6.0
+ * https://jquery.com/
+ *
+ * Includes Sizzle.js
+ * https://sizzlejs.com/
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2021-03-02T17:08Z
+ */
+( function( global, factory ) {
+
+ "use strict";
+
+ if ( true && typeof module.exports === "object" ) {
+
+ // For CommonJS and CommonJS-like environments where a proper `window`
+ // is present, execute the factory and get jQuery.
+ // For environments that do not have a `window` with a `document`
+ // (such as Node.js), expose a factory as module.exports.
+ // This accentuates the need for the creation of a real `window`.
+ // e.g. var jQuery = require("jquery")(window);
+ // See ticket #14549 for more info.
+ module.exports = global.document ?
+ factory( global, true ) :
+ function( w ) {
+ if ( !w.document ) {
+ throw new Error( "jQuery requires a window with a document" );
+ }
+ return factory( w );
+ };
+ } else {
+ factory( global );
+ }
+
+// Pass this if window is not defined yet
+} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
+
+// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
+// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
+// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
+// enough that all such attempts are guarded in a try block.
+"use strict";
+
+var arr = [];
+
+var getProto = Object.getPrototypeOf;
+
+var slice = arr.slice;
+
+var flat = arr.flat ? function( array ) {
+ return arr.flat.call( array );
+} : function( array ) {
+ return arr.concat.apply( [], array );
+};
+
+
+var push = arr.push;
+
+var indexOf = arr.indexOf;
+
+var class2type = {};
+
+var toString = class2type.toString;
+
+var hasOwn = class2type.hasOwnProperty;
+
+var fnToString = hasOwn.toString;
+
+var ObjectFunctionString = fnToString.call( Object );
+
+var support = {};
+
+var isFunction = function isFunction( obj ) {
+
+ // Support: Chrome <=57, Firefox <=52
+ // In some browsers, typeof returns "function" for HTML <object> elements
+ // (i.e., `typeof document.createElement( "object" ) === "function"`).
+ // We don't want to classify *any* DOM node as a function.
+ // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
+ // Plus for old WebKit, typeof returns "function" for HTML collections
+ // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
+ return typeof obj === "function" && typeof obj.nodeType !== "number" &&
+ typeof obj.item !== "function";
+ };
+
+
+var isWindow = function isWindow( obj ) {
+ return obj != null && obj === obj.window;
+ };
+
+
+var document = window.document;
+
+
+
+ var preservedScriptAttributes = {
+ type: true,
+ src: true,
+ nonce: true,
+ noModule: true
+ };
+
+ function DOMEval( code, node, doc ) {
+ doc = doc || document;
+
+ var i, val,
+ script = doc.createElement( "script" );
+
+ script.text = code;
+ if ( node ) {
+ for ( i in preservedScriptAttributes ) {
+
+ // Support: Firefox 64+, Edge 18+
+ // Some browsers don't support the "nonce" property on scripts.
+ // On the other hand, just using `getAttribute` is not enough as
+ // the `nonce` attribute is reset to an empty string whenever it
+ // becomes browsing-context connected.
+ // See https://github.com/whatwg/html/issues/2369
+ // See https://html.spec.whatwg.org/#nonce-attributes
+ // The `node.getAttribute` check was added for the sake of
+ // `jQuery.globalEval` so that it can fake a nonce-containing node
+ // via an object.
+ val = node[ i ] || node.getAttribute && node.getAttribute( i );
+ if ( val ) {
+ script.setAttribute( i, val );
+ }
+ }
+ }
+ doc.head.appendChild( script ).parentNode.removeChild( script );
+ }
+
+
+function toType( obj ) {
+ if ( obj == null ) {
+ return obj + "";
+ }
+
+ // Support: Android <=2.3 only (functionish RegExp)
+ return typeof obj === "object" || typeof obj === "function" ?
+ class2type[ toString.call( obj ) ] || "object" :
+ typeof obj;
+}
+/* global Symbol */
+// Defining this global in .eslintrc.json would create a danger of using the global
+// unguarded in another place, it seems safer to define global only for this module
+
+
+
+var
+ version = "3.6.0",
+
+ // Define a local copy of jQuery
+ jQuery = function( selector, context ) {
+
+ // The jQuery object is actually just the init constructor 'enhanced'
+ // Need init if jQuery is called (just allow error to be thrown if not included)
+ return new jQuery.fn.init( selector, context );
+ };
+
+jQuery.fn = jQuery.prototype = {
+
+ // The current version of jQuery being used
+ jquery: version,
+
+ constructor: jQuery,
+
+ // The default length of a jQuery object is 0
+ length: 0,
+
+ toArray: function() {
+ return slice.call( this );
+ },
+
+ // Get the Nth element in the matched element set OR
+ // Get the whole matched element set as a clean array
+ get: function( num ) {
+
+ // Return all the elements in a clean array
+ if ( num == null ) {
+ return slice.call( this );
+ }
+
+ // Return just the one element from the set
+ return num < 0 ? this[ num + this.length ] : this[ num ];
+ },
+
+ // Take an array of elements and push it onto the stack
+ // (returning the new matched element set)
+ pushStack: function( elems ) {
+
+ // Build a new jQuery matched element set
+ var ret = jQuery.merge( this.constructor(), elems );
+
+ // Add the old object onto the stack (as a reference)
+ ret.prevObject = this;
+
+ // Return the newly-formed element set
+ return ret;
+ },
+
+ // Execute a callback for every element in the matched set.
+ each: function( callback ) {
+ return jQuery.each( this, callback );
+ },
+
+ map: function( callback ) {
+ return this.pushStack( jQuery.map( this, function( elem, i ) {
+ return callback.call( elem, i, elem );
+ } ) );
+ },
+
+ slice: function() {
+ return this.pushStack( slice.apply( this, arguments ) );
+ },
+
+ first: function() {
+ return this.eq( 0 );
+ },
+
+ last: function() {
+ return this.eq( -1 );
+ },
+
+ even: function() {
+ return this.pushStack( jQuery.grep( this, function( _elem, i ) {
+ return ( i + 1 ) % 2;
+ } ) );
+ },
+
+ odd: function() {
+ return this.pushStack( jQuery.grep( this, function( _elem, i ) {
+ return i % 2;
+ } ) );
+ },
+
+ eq: function( i ) {
+ var len = this.length,
+ j = +i + ( i < 0 ? len : 0 );
+ return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
+ },
+
+ end: function() {
+ return this.prevObject || this.constructor();
+ },
+
+ // For internal use only.
+ // Behaves like an Array's method, not like a jQuery method.
+ push: push,
+ sort: arr.sort,
+ splice: arr.splice
+};
+
+jQuery.extend = jQuery.fn.extend = function() {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[ 0 ] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if ( typeof target === "boolean" ) {
+ deep = target;
+
+ // Skip the boolean and the target
+ target = arguments[ i ] || {};
+ i++;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if ( typeof target !== "object" && !isFunction( target ) ) {
+ target = {};
+ }
+
+ // Extend jQuery itself if only one argument is passed
+ if ( i === length ) {
+ target = this;
+ i--;
+ }
+
+ for ( ; i < length; i++ ) {
+
+ // Only deal with non-null/undefined values
+ if ( ( options = arguments[ i ] ) != null ) {
+
+ // Extend the base object
+ for ( name in options ) {
+ copy = options[ name ];
+
+ // Prevent Object.prototype pollution
+ // Prevent never-ending loop
+ if ( name === "__proto__" || target === copy ) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
+ ( copyIsArray = Array.isArray( copy ) ) ) ) {
+ src = target[ name ];
+
+ // Ensure proper type for the source value
+ if ( copyIsArray && !Array.isArray( src ) ) {
+ clone = [];
+ } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
+ clone = {};
+ } else {
+ clone = src;
+ }
+ copyIsArray = false;
+
+ // Never move original objects, clone them
+ target[ name ] = jQuery.extend( deep, clone, copy );
+
+ // Don't bring in undefined values
+ } else if ( copy !== undefined ) {
+ target[ name ] = copy;
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+};
+
+jQuery.extend( {
+
+ // Unique for each copy of jQuery on the page
+ expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
+
+ // Assume jQuery is ready without the ready module
+ isReady: true,
+
+ error: function( msg ) {
+ throw new Error( msg );
+ },
+
+ noop: function() {},
+
+ isPlainObject: function( obj ) {
+ var proto, Ctor;
+
+ // Detect obvious negatives
+ // Use toString instead of jQuery.type to catch host objects
+ if ( !obj || toString.call( obj ) !== "[object Object]" ) {
+ return false;
+ }
+
+ proto = getProto( obj );
+
+ // Objects with no prototype (e.g., `Object.create( null )`) are plain
+ if ( !proto ) {
+ return true;
+ }
+
+ // Objects with prototype are plain iff they were constructed by a global Object function
+ Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
+ return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
+ },
+
+ isEmptyObject: function( obj ) {
+ var name;
+
+ for ( name in obj ) {
+ return false;
+ }
+ return true;
+ },
+
+ // Evaluates a script in a provided context; falls back to the global one
+ // if not specified.
+ globalEval: function( code, options, doc ) {
+ DOMEval( code, { nonce: options && options.nonce }, doc );
+ },
+
+ each: function( obj, callback ) {
+ var length, i = 0;
+
+ if ( isArrayLike( obj ) ) {
+ length = obj.length;
+ for ( ; i < length; i++ ) {
+ if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
+ break;
+ }
+ }
+ } else {
+ for ( i in obj ) {
+ if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
+ break;
+ }
+ }
+ }
+
+ return obj;
+ },
+
+ // results is for internal usage only
+ makeArray: function( arr, results ) {
+ var ret = results || [];
+
+ if ( arr != null ) {
+ if ( isArrayLike( Object( arr ) ) ) {
+ jQuery.merge( ret,
+ typeof arr === "string" ?
+ [ arr ] : arr
+ );
+ } else {
+ push.call( ret, arr );
+ }
+ }
+
+ return ret;
+ },
+
+ inArray: function( elem, arr, i ) {
+ return arr == null ? -1 : indexOf.call( arr, elem, i );
+ },
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ merge: function( first, second ) {
+ var len = +second.length,
+ j = 0,
+ i = first.length;
+
+ for ( ; j < len; j++ ) {
+ first[ i++ ] = second[ j ];
+ }
+
+ first.length = i;
+
+ return first;
+ },
+
+ grep: function( elems, callback, invert ) {
+ var callbackInverse,
+ matches = [],
+ i = 0,
+ length = elems.length,
+ callbackExpect = !invert;
+
+ // Go through the array, only saving the items
+ // that pass the validator function
+ for ( ; i < length; i++ ) {
+ callbackInverse = !callback( elems[ i ], i );
+ if ( callbackInverse !== callbackExpect ) {
+ matches.push( elems[ i ] );
+ }
+ }
+
+ return matches;
+ },
+
+ // arg is for internal usage only
+ map: function( elems, callback, arg ) {
+ var length, value,
+ i = 0,
+ ret = [];
+
+ // Go through the array, translating each of the items to their new values
+ if ( isArrayLike( elems ) ) {
+ length = elems.length;
+ for ( ; i < length; i++ ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret.push( value );
+ }
+ }
+
+ // Go through every key on the object,
+ } else {
+ for ( i in elems ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret.push( value );
+ }
+ }
+ }
+
+ // Flatten any nested arrays
+ return flat( ret );
+ },
+
+ // A global GUID counter for objects
+ guid: 1,
+
+ // jQuery.support is not used in Core but other projects attach their
+ // properties to it so it needs to exist.
+ support: support
+} );
+
+if ( typeof Symbol === "function" ) {
+ jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
+}
+
+// Populate the class2type map
+jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
+ function( _i, name ) {
+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
+ } );
+
+function isArrayLike( obj ) {
+
+ // Support: real iOS 8.2 only (not reproducible in simulator)
+ // `in` check used to prevent JIT error (gh-2145)
+ // hasOwn isn't used here due to false negatives
+ // regarding Nodelist length in IE
+ var length = !!obj && "length" in obj && obj.length,
+ type = toType( obj );
+
+ if ( isFunction( obj ) || isWindow( obj ) ) {
+ return false;
+ }
+
+ return type === "array" || length === 0 ||
+ typeof length === "number" && length > 0 && ( length - 1 ) in obj;
+}
+var Sizzle =
+/*!
+ * Sizzle CSS Selector Engine v2.3.6
+ * https://sizzlejs.com/
+ *
+ * Copyright JS Foundation and other contributors
+ * Released under the MIT license
+ * https://js.foundation/
+ *
+ * Date: 2021-02-16
+ */
+( function( window ) {
+var i,
+ support,
+ Expr,
+ getText,
+ isXML,
+ tokenize,
+ compile,
+ select,
+ outermostContext,
+ sortInput,
+ hasDuplicate,
+
+ // Local document vars
+ setDocument,
+ document,
+ docElem,
+ documentIsHTML,
+ rbuggyQSA,
+ rbuggyMatches,
+ matches,
+ contains,
+
+ // Instance-specific data
+ expando = "sizzle" + 1 * new Date(),
+ preferredDoc = window.document,
+ dirruns = 0,
+ done = 0,
+ classCache = createCache(),
+ tokenCache = createCache(),
+ compilerCache = createCache(),
+ nonnativeSelectorCache = createCache(),
+ sortOrder = function( a, b ) {
+ if ( a === b ) {
+ hasDuplicate = true;
+ }
+ return 0;
+ },
+
+ // Instance methods
+ hasOwn = ( {} ).hasOwnProperty,
+ arr = [],
+ pop = arr.pop,
+ pushNative = arr.push,
+ push = arr.push,
+ slice = arr.slice,
+
+ // Use a stripped-down indexOf as it's faster than native
+ // https://jsperf.com/thor-indexof-vs-for/5
+ indexOf = function( list, elem ) {
+ var i = 0,
+ len = list.length;
+ for ( ; i < len; i++ ) {
+ if ( list[ i ] === elem ) {
+ return i;
+ }
+ }
+ return -1;
+ },
+
+ booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
+ "ismap|loop|multiple|open|readonly|required|scoped",
+
+ // Regular expressions
+
+ // http://www.w3.org/TR/css3-selectors/#whitespace
+ whitespace = "[\\x20\\t\\r\\n\\f]",
+
+ // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
+ identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
+ "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
+
+ // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
+ attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
+
+ // Operator (capture 2)
+ "*([*^$|!~]?=)" + whitespace +
+
+ // "Attribute values must be CSS identifiers [capture 5]
+ // or strings [capture 3 or capture 4]"
+ "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
+ whitespace + "*\\]",
+
+ pseudos = ":(" + identifier + ")(?:\\((" +
+
+ // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
+ // 1. quoted (capture 3; capture 4 or capture 5)
+ "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
+
+ // 2. simple (capture 6)
+ "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
+
+ // 3. anything else (capture 2)
+ ".*" +
+ ")\\)|)",
+
+ // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+ rwhitespace = new RegExp( whitespace + "+", "g" ),
+ rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
+ whitespace + "+$", "g" ),
+
+ rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
+ rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
+ "*" ),
+ rdescend = new RegExp( whitespace + "|>" ),
+
+ rpseudo = new RegExp( pseudos ),
+ ridentifier = new RegExp( "^" + identifier + "$" ),
+
+ matchExpr = {
+ "ID": new RegExp( "^#(" + identifier + ")" ),
+ "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
+ "TAG": new RegExp( "^(" + identifier + "|[*])" ),
+ "ATTR": new RegExp( "^" + attributes ),
+ "PSEUDO": new RegExp( "^" + pseudos ),
+ "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
+ whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
+ whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
+ "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
+
+ // For use in libraries implementing .is()
+ // We use this for POS matching in `select`
+ "needsContext": new RegExp( "^" + whitespace +
+ "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
+ "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
+ },
+
+ rhtml = /HTML$/i,
+ rinputs = /^(?:input|select|textarea|button)$/i,
+ rheader = /^h\d$/i,
+
+ rnative = /^[^{]+\{\s*\[native \w/,
+
+ // Easily-parseable/retrievable ID or TAG or CLASS selectors
+ rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
+
+ rsibling = /[+~]/,
+
+ // CSS escapes
+ // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
+ runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
+ funescape = function( escape, nonHex ) {
+ var high = "0x" + escape.slice( 1 ) - 0x10000;
+
+ return nonHex ?
+
+ // Strip the backslash prefix from a non-hex escape sequence
+ nonHex :
+
+ // Replace a hexadecimal escape sequence with the encoded Unicode code point
+ // Support: IE <=11+
+ // For values outside the Basic Multilingual Plane (BMP), manually construct a
+ // surrogate pair
+ high < 0 ?
+ String.fromCharCode( high + 0x10000 ) :
+ String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
+ },
+
+ // CSS string/identifier serialization
+ // https://drafts.csswg.org/cssom/#common-serializing-idioms
+ rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
+ fcssescape = function( ch, asCodePoint ) {
+ if ( asCodePoint ) {
+
+ // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
+ if ( ch === "\0" ) {
+ return "\uFFFD";
+ }
+
+ // Control characters and (dependent upon position) numbers get escaped as code points
+ return ch.slice( 0, -1 ) + "\\" +
+ ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
+ }
+
+ // Other potentially-special ASCII characters get backslash-escaped
+ return "\\" + ch;
+ },
+
+ // Used for iframes
+ // See setDocument()
+ // Removing the function wrapper causes a "Permission Denied"
+ // error in IE
+ unloadHandler = function() {
+ setDocument();
+ },
+
+ inDisabledFieldset = addCombinator(
+ function( elem ) {
+ return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
+ },
+ { dir: "parentNode", next: "legend" }
+ );
+
+// Optimize for push.apply( _, NodeList )
+try {
+ push.apply(
+ ( arr = slice.call( preferredDoc.childNodes ) ),
+ preferredDoc.childNodes
+ );
+
+ // Support: Android<4.0
+ // Detect silently failing push.apply
+ // eslint-disable-next-line no-unused-expressions
+ arr[ preferredDoc.childNodes.length ].nodeType;
+} catch ( e ) {
+ push = { apply: arr.length ?
+
+ // Leverage slice if possible
+ function( target, els ) {
+ pushNative.apply( target, slice.call( els ) );
+ } :
+
+ // Support: IE<9
+ // Otherwise append directly
+ function( target, els ) {
+ var j = target.length,
+ i = 0;
+
+ // Can't trust NodeList.length
+ while ( ( target[ j++ ] = els[ i++ ] ) ) {}
+ target.length = j - 1;
+ }
+ };
+}
+
+function Sizzle( selector, context, results, seed ) {
+ var m, i, elem, nid, match, groups, newSelector,
+ newContext = context && context.ownerDocument,
+
+ // nodeType defaults to 9, since context defaults to document
+ nodeType = context ? context.nodeType : 9;
+
+ results = results || [];
+
+ // Return early from calls with invalid selector or context
+ if ( typeof selector !== "string" || !selector ||
+ nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
+
+ return results;
+ }
+
+ // Try to shortcut find operations (as opposed to filters) in HTML documents
+ if ( !seed ) {
+ setDocument( context );
+ context = context || document;
+
+ if ( documentIsHTML ) {
+
+ // If the selector is sufficiently simple, try using a "get*By*" DOM method
+ // (excepting DocumentFragment context, where the methods don't exist)
+ if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
+
+ // ID selector
+ if ( ( m = match[ 1 ] ) ) {
+
+ // Document context
+ if ( nodeType === 9 ) {
+ if ( ( elem = context.getElementById( m ) ) ) {
+
+ // Support: IE, Opera, Webkit
+ // TODO: identify versions
+ // getElementById can match elements by name instead of ID
+ if ( elem.id === m ) {
+ results.push( elem );
+ return results;
+ }
+ } else {
+ return results;
+ }
+
+ // Element context
+ } else {
+
+ // Support: IE, Opera, Webkit
+ // TODO: identify versions
+ // getElementById can match elements by name instead of ID
+ if ( newContext && ( elem = newContext.getElementById( m ) ) &&
+ contains( context, elem ) &&
+ elem.id === m ) {
+
+ results.push( elem );
+ return results;
+ }
+ }
+
+ // Type selector
+ } else if ( match[ 2 ] ) {
+ push.apply( results, context.getElementsByTagName( selector ) );
+ return results;
+
+ // Class selector
+ } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
+ context.getElementsByClassName ) {
+
+ push.apply( results, context.getElementsByClassName( m ) );
+ return results;
+ }
+ }
+
+ // Take advantage of querySelectorAll
+ if ( support.qsa &&
+ !nonnativeSelectorCache[ selector + " " ] &&
+ ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
+
+ // Support: IE 8 only
+ // Exclude object elements
+ ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
+
+ newSelector = selector;
+ newContext = context;
+
+ // qSA considers elements outside a scoping root when evaluating child or
+ // descendant combinators, which is not what we want.
+ // In such cases, we work around the behavior by prefixing every selector in the
+ // list with an ID selector referencing the scope context.
+ // The technique has to be used as well when a leading combinator is used
+ // as such selectors are not recognized by querySelectorAll.
+ // Thanks to Andrew Dupont for this technique.
+ if ( nodeType === 1 &&
+ ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
+
+ // Expand context for sibling selectors
+ newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
+ context;
+
+ // We can use :scope instead of the ID hack if the browser
+ // supports it & if we're not changing the context.
+ if ( newContext !== context || !support.scope ) {
+
+ // Capture the context ID, setting it first if necessary
+ if ( ( nid = context.getAttribute( "id" ) ) ) {
+ nid = nid.replace( rcssescape, fcssescape );
+ } else {
+ context.setAttribute( "id", ( nid = expando ) );
+ }
+ }
+
+ // Prefix every selector in the list
+ groups = tokenize( selector );
+ i = groups.length;
+ while ( i-- ) {
+ groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
+ toSelector( groups[ i ] );
+ }
+ newSelector = groups.join( "," );
+ }
+
+ try {
+ push.apply( results,
+ newContext.querySelectorAll( newSelector )
+ );
+ return results;
+ } catch ( qsaError ) {
+ nonnativeSelectorCache( selector, true );
+ } finally {
+ if ( nid === expando ) {
+ context.removeAttribute( "id" );
+ }
+ }
+ }
+ }
+ }
+
+ // All others
+ return select( selector.replace( rtrim, "$1" ), context, results, seed );
+}
+
+/**
+ * Create key-value caches of limited size
+ * @returns {function(string, object)} Returns the Object data after storing it on itself with
+ * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
+ * deleting the oldest entry
+ */
+function createCache() {
+ var keys = [];
+
+ function cache( key, value ) {
+
+ // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
+ if ( keys.push( key + " " ) > Expr.cacheLength ) {
+
+ // Only keep the most recent entries
+ delete cache[ keys.shift() ];
+ }
+ return ( cache[ key + " " ] = value );
+ }
+ return cache;
+}
+
+/**
+ * Mark a function for special use by Sizzle
+ * @param {Function} fn The function to mark
+ */
+function markFunction( fn ) {
+ fn[ expando ] = true;
+ return fn;
+}
+
+/**
+ * Support testing using an element
+ * @param {Function} fn Passed the created element and returns a boolean result
+ */
+function assert( fn ) {
+ var el = document.createElement( "fieldset" );
+
+ try {
+ return !!fn( el );
+ } catch ( e ) {
+ return false;
+ } finally {
+
+ // Remove from its parent by default
+ if ( el.parentNode ) {
+ el.parentNode.removeChild( el );
+ }
+
+ // release memory in IE
+ el = null;
+ }
+}
+
+/**
+ * Adds the same handler for all of the specified attrs
+ * @param {String} attrs Pipe-separated list of attributes
+ * @param {Function} handler The method that will be applied
+ */
+function addHandle( attrs, handler ) {
+ var arr = attrs.split( "|" ),
+ i = arr.length;
+
+ while ( i-- ) {
+ Expr.attrHandle[ arr[ i ] ] = handler;
+ }
+}
+
+/**
+ * Checks document order of two siblings
+ * @param {Element} a
+ * @param {Element} b
+ * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
+ */
+function siblingCheck( a, b ) {
+ var cur = b && a,
+ diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
+ a.sourceIndex - b.sourceIndex;
+
+ // Use IE sourceIndex if available on both nodes
+ if ( diff ) {
+ return diff;
+ }
+
+ // Check if b follows a
+ if ( cur ) {
+ while ( ( cur = cur.nextSibling ) ) {
+ if ( cur === b ) {
+ return -1;
+ }
+ }
+ }
+
+ return a ? 1 : -1;
+}
+
+/**
+ * Returns a function to use in pseudos for input types
+ * @param {String} type
+ */
+function createInputPseudo( type ) {
+ return function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return name === "input" && elem.type === type;
+ };
+}
+
+/**
+ * Returns a function to use in pseudos for buttons
+ * @param {String} type
+ */
+function createButtonPseudo( type ) {
+ return function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return ( name === "input" || name === "button" ) && elem.type === type;
+ };
+}
+
+/**
+ * Returns a function to use in pseudos for :enabled/:disabled
+ * @param {Boolean} disabled true for :disabled; false for :enabled
+ */
+function createDisabledPseudo( disabled ) {
+
+ // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
+ return function( elem ) {
+
+ // Only certain elements can match :enabled or :disabled
+ // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
+ // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
+ if ( "form" in elem ) {
+
+ // Check for inherited disabledness on relevant non-disabled elements:
+ // * listed form-associated elements in a disabled fieldset
+ // https://html.spec.whatwg.org/multipage/forms.html#category-listed
+ // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
+ // * option elements in a disabled optgroup
+ // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
+ // All such elements have a "form" property.
+ if ( elem.parentNode && elem.disabled === false ) {
+
+ // Option elements defer to a parent optgroup if present
+ if ( "label" in elem ) {
+ if ( "label" in elem.parentNode ) {
+ return elem.parentNode.disabled === disabled;
+ } else {
+ return elem.disabled === disabled;
+ }
+ }
+
+ // Support: IE 6 - 11
+ // Use the isDisabled shortcut property to check for disabled fieldset ancestors
+ return elem.isDisabled === disabled ||
+
+ // Where there is no isDisabled, check manually
+ /* jshint -W018 */
+ elem.isDisabled !== !disabled &&
+ inDisabledFieldset( elem ) === disabled;
+ }
+
+ return elem.disabled === disabled;
+
+ // Try to winnow out elements that can't be disabled before trusting the disabled property.
+ // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
+ // even exist on them, let alone have a boolean value.
+ } else if ( "label" in elem ) {
+ return elem.disabled === disabled;
+ }
+
+ // Remaining elements are neither :enabled nor :disabled
+ return false;
+ };
+}
+
+/**
+ * Returns a function to use in pseudos for positionals
+ * @param {Function} fn
+ */
+function createPositionalPseudo( fn ) {
+ return markFunction( function( argument ) {
+ argument = +argument;
+ return markFunction( function( seed, matches ) {
+ var j,
+ matchIndexes = fn( [], seed.length, argument ),
+ i = matchIndexes.length;
+
+ // Match elements found at the specified indexes
+ while ( i-- ) {
+ if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
+ seed[ j ] = !( matches[ j ] = seed[ j ] );
+ }
+ }
+ } );
+ } );
+}
+
+/**
+ * Checks a node for validity as a Sizzle context
+ * @param {Element|Object=} context
+ * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
+ */
+function testContext( context ) {
+ return context && typeof context.getElementsByTagName !== "undefined" && context;
+}
+
+// Expose support vars for convenience
+support = Sizzle.support = {};
+
+/**
+ * Detects XML nodes
+ * @param {Element|Object} elem An element or a document
+ * @returns {Boolean} True iff elem is a non-HTML XML node
+ */
+isXML = Sizzle.isXML = function( elem ) {
+ var namespace = elem && elem.namespaceURI,
+ docElem = elem && ( elem.ownerDocument || elem ).documentElement;
+
+ // Support: IE <=8
+ // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
+ // https://bugs.jquery.com/ticket/4833
+ return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
+};
+
+/**
+ * Sets document-related variables once based on the current document
+ * @param {Element|Object} [doc] An element or document object to use to set the document
+ * @returns {Object} Returns the current document
+ */
+setDocument = Sizzle.setDocument = function( node ) {
+ var hasCompare, subWindow,
+ doc = node ? node.ownerDocument || node : preferredDoc;
+
+ // Return early if doc is invalid or already selected
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
+ return document;
+ }
+
+ // Update global variables
+ document = doc;
+ docElem = document.documentElement;
+ documentIsHTML = !isXML( document );
+
+ // Support: IE 9 - 11+, Edge 12 - 18+
+ // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( preferredDoc != document &&
+ ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
+
+ // Support: IE 11, Edge
+ if ( subWindow.addEventListener ) {
+ subWindow.addEventListener( "unload", unloadHandler, false );
+
+ // Support: IE 9 - 10 only
+ } else if ( subWindow.attachEvent ) {
+ subWindow.attachEvent( "onunload", unloadHandler );
+ }
+ }
+
+ // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
+ // Safari 4 - 5 only, Opera <=11.6 - 12.x only
+ // IE/Edge & older browsers don't support the :scope pseudo-class.
+ // Support: Safari 6.0 only
+ // Safari 6.0 supports :scope but it's an alias of :root there.
+ support.scope = assert( function( el ) {
+ docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
+ return typeof el.querySelectorAll !== "undefined" &&
+ !el.querySelectorAll( ":scope fieldset div" ).length;
+ } );
+
+ /* Attributes
+ ---------------------------------------------------------------------- */
+
+ // Support: IE<8
+ // Verify that getAttribute really returns attributes and not properties
+ // (excepting IE8 booleans)
+ support.attributes = assert( function( el ) {
+ el.className = "i";
+ return !el.getAttribute( "className" );
+ } );
+
+ /* getElement(s)By*
+ ---------------------------------------------------------------------- */
+
+ // Check if getElementsByTagName("*") returns only elements
+ support.getElementsByTagName = assert( function( el ) {
+ el.appendChild( document.createComment( "" ) );
+ return !el.getElementsByTagName( "*" ).length;
+ } );
+
+ // Support: IE<9
+ support.getElementsByClassName = rnative.test( document.getElementsByClassName );
+
+ // Support: IE<10
+ // Check if getElementById returns elements by name
+ // The broken getElementById methods don't pick up programmatically-set names,
+ // so use a roundabout getElementsByName test
+ support.getById = assert( function( el ) {
+ docElem.appendChild( el ).id = expando;
+ return !document.getElementsByName || !document.getElementsByName( expando ).length;
+ } );
+
+ // ID filter and find
+ if ( support.getById ) {
+ Expr.filter[ "ID" ] = function( id ) {
+ var attrId = id.replace( runescape, funescape );
+ return function( elem ) {
+ return elem.getAttribute( "id" ) === attrId;
+ };
+ };
+ Expr.find[ "ID" ] = function( id, context ) {
+ if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
+ var elem = context.getElementById( id );
+ return elem ? [ elem ] : [];
+ }
+ };
+ } else {
+ Expr.filter[ "ID" ] = function( id ) {
+ var attrId = id.replace( runescape, funescape );
+ return function( elem ) {
+ var node = typeof elem.getAttributeNode !== "undefined" &&
+ elem.getAttributeNode( "id" );
+ return node && node.value === attrId;
+ };
+ };
+
+ // Support: IE 6 - 7 only
+ // getElementById is not reliable as a find shortcut
+ Expr.find[ "ID" ] = function( id, context ) {
+ if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
+ var node, i, elems,
+ elem = context.getElementById( id );
+
+ if ( elem ) {
+
+ // Verify the id attribute
+ node = elem.getAttributeNode( "id" );
+ if ( node && node.value === id ) {
+ return [ elem ];
+ }
+
+ // Fall back on getElementsByName
+ elems = context.getElementsByName( id );
+ i = 0;
+ while ( ( elem = elems[ i++ ] ) ) {
+ node = elem.getAttributeNode( "id" );
+ if ( node && node.value === id ) {
+ return [ elem ];
+ }
+ }
+ }
+
+ return [];
+ }
+ };
+ }
+
+ // Tag
+ Expr.find[ "TAG" ] = support.getElementsByTagName ?
+ function( tag, context ) {
+ if ( typeof context.getElementsByTagName !== "undefined" ) {
+ return context.getElementsByTagName( tag );
+
+ // DocumentFragment nodes don't have gEBTN
+ } else if ( support.qsa ) {
+ return context.querySelectorAll( tag );
+ }
+ } :
+
+ function( tag, context ) {
+ var elem,
+ tmp = [],
+ i = 0,
+
+ // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
+ results = context.getElementsByTagName( tag );
+
+ // Filter out possible comments
+ if ( tag === "*" ) {
+ while ( ( elem = results[ i++ ] ) ) {
+ if ( elem.nodeType === 1 ) {
+ tmp.push( elem );
+ }
+ }
+
+ return tmp;
+ }
+ return results;
+ };
+
+ // Class
+ Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
+ if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
+ return context.getElementsByClassName( className );
+ }
+ };
+
+ /* QSA/matchesSelector
+ ---------------------------------------------------------------------- */
+
+ // QSA and matchesSelector support
+
+ // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
+ rbuggyMatches = [];
+
+ // qSa(:focus) reports false when true (Chrome 21)
+ // We allow this because of a bug in IE8/9 that throws an error
+ // whenever `document.activeElement` is accessed on an iframe
+ // So, we allow :focus to pass through QSA all the time to avoid the IE error
+ // See https://bugs.jquery.com/ticket/13378
+ rbuggyQSA = [];
+
+ if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
+
+ // Build QSA regex
+ // Regex strategy adopted from Diego Perini
+ assert( function( el ) {
+
+ var input;
+
+ // Select is set to empty string on purpose
+ // This is to test IE's treatment of not explicitly
+ // setting a boolean content attribute,
+ // since its presence should be enough
+ // https://bugs.jquery.com/ticket/12359
+ docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
+ "<select id='" + expando + "-\r\\' msallowcapture=''>" +
+ "<option selected=''></option></select>";
+
+ // Support: IE8, Opera 11-12.16
+ // Nothing should be selected when empty strings follow ^= or $= or *=
+ // The test attribute must be unknown in Opera but "safe" for WinRT
+ // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
+ if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
+ rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
+ }
+
+ // Support: IE8
+ // Boolean attributes and "value" are not treated correctly
+ if ( !el.querySelectorAll( "[selected]" ).length ) {
+ rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
+ }
+
+ // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
+ if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
+ rbuggyQSA.push( "~=" );
+ }
+
+ // Support: IE 11+, Edge 15 - 18+
+ // IE 11/Edge don't find elements on a `[name='']` query in some cases.
+ // Adding a temporary attribute to the document before the selection works
+ // around the issue.
+ // Interestingly, IE 10 & older don't seem to have the issue.
+ input = document.createElement( "input" );
+ input.setAttribute( "name", "" );
+ el.appendChild( input );
+ if ( !el.querySelectorAll( "[name='']" ).length ) {
+ rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
+ whitespace + "*(?:''|\"\")" );
+ }
+
+ // Webkit/Opera - :checked should return selected option elements
+ // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+ // IE8 throws error here and will not see later tests
+ if ( !el.querySelectorAll( ":checked" ).length ) {
+ rbuggyQSA.push( ":checked" );
+ }
+
+ // Support: Safari 8+, iOS 8+
+ // https://bugs.webkit.org/show_bug.cgi?id=136851
+ // In-page `selector#id sibling-combinator selector` fails
+ if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
+ rbuggyQSA.push( ".#.+[+~]" );
+ }
+
+ // Support: Firefox <=3.6 - 5 only
+ // Old Firefox doesn't throw on a badly-escaped identifier.
+ el.querySelectorAll( "\\\f" );
+ rbuggyQSA.push( "[\\r\\n\\f]" );
+ } );
+
+ assert( function( el ) {
+ el.innerHTML = "<a href='' disabled='disabled'></a>" +
+ "<select disabled='disabled'><option/></select>";
+
+ // Support: Windows 8 Native Apps
+ // The type and name attributes are restricted during .innerHTML assignment
+ var input = document.createElement( "input" );
+ input.setAttribute( "type", "hidden" );
+ el.appendChild( input ).setAttribute( "name", "D" );
+
+ // Support: IE8
+ // Enforce case-sensitivity of name attribute
+ if ( el.querySelectorAll( "[name=d]" ).length ) {
+ rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
+ }
+
+ // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
+ // IE8 throws error here and will not see later tests
+ if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
+ rbuggyQSA.push( ":enabled", ":disabled" );
+ }
+
+ // Support: IE9-11+
+ // IE's :disabled selector does not pick up the children of disabled fieldsets
+ docElem.appendChild( el ).disabled = true;
+ if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
+ rbuggyQSA.push( ":enabled", ":disabled" );
+ }
+
+ // Support: Opera 10 - 11 only
+ // Opera 10-11 does not throw on post-comma invalid pseudos
+ el.querySelectorAll( "*,:x" );
+ rbuggyQSA.push( ",.*:" );
+ } );
+ }
+
+ if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
+ docElem.webkitMatchesSelector ||
+ docElem.mozMatchesSelector ||
+ docElem.oMatchesSelector ||
+ docElem.msMatchesSelector ) ) ) ) {
+
+ assert( function( el ) {
+
+ // Check to see if it's possible to do matchesSelector
+ // on a disconnected node (IE 9)
+ support.disconnectedMatch = matches.call( el, "*" );
+
+ // This should fail with an exception
+ // Gecko does not error, returns false instead
+ matches.call( el, "[s!='']:x" );
+ rbuggyMatches.push( "!=", pseudos );
+ } );
+ }
+
+ rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
+ rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
+
+ /* Contains
+ ---------------------------------------------------------------------- */
+ hasCompare = rnative.test( docElem.compareDocumentPosition );
+
+ // Element contains another
+ // Purposefully self-exclusive
+ // As in, an element does not contain itself
+ contains = hasCompare || rnative.test( docElem.contains ) ?
+ function( a, b ) {
+ var adown = a.nodeType === 9 ? a.documentElement : a,
+ bup = b && b.parentNode;
+ return a === bup || !!( bup && bup.nodeType === 1 && (
+ adown.contains ?
+ adown.contains( bup ) :
+ a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
+ ) );
+ } :
+ function( a, b ) {
+ if ( b ) {
+ while ( ( b = b.parentNode ) ) {
+ if ( b === a ) {
+ return true;
+ }
+ }
+ }
+ return false;
+ };
+
+ /* Sorting
+ ---------------------------------------------------------------------- */
+
+ // Document order sorting
+ sortOrder = hasCompare ?
+ function( a, b ) {
+
+ // Flag for duplicate removal
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+ }
+
+ // Sort on method existence if only one input has compareDocumentPosition
+ var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
+ if ( compare ) {
+ return compare;
+ }
+
+ // Calculate position if both inputs belong to the same document
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
+ a.compareDocumentPosition( b ) :
+
+ // Otherwise we know they are disconnected
+ 1;
+
+ // Disconnected nodes
+ if ( compare & 1 ||
+ ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
+
+ // Choose the first element that is related to our preferred document
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( a == document || a.ownerDocument == preferredDoc &&
+ contains( preferredDoc, a ) ) {
+ return -1;
+ }
+
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( b == document || b.ownerDocument == preferredDoc &&
+ contains( preferredDoc, b ) ) {
+ return 1;
+ }
+
+ // Maintain original order
+ return sortInput ?
+ ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
+ 0;
+ }
+
+ return compare & 4 ? -1 : 1;
+ } :
+ function( a, b ) {
+
+ // Exit early if the nodes are identical
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+ }
+
+ var cur,
+ i = 0,
+ aup = a.parentNode,
+ bup = b.parentNode,
+ ap = [ a ],
+ bp = [ b ];
+
+ // Parentless nodes are either documents or disconnected
+ if ( !aup || !bup ) {
+
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ /* eslint-disable eqeqeq */
+ return a == document ? -1 :
+ b == document ? 1 :
+ /* eslint-enable eqeqeq */
+ aup ? -1 :
+ bup ? 1 :
+ sortInput ?
+ ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
+ 0;
+
+ // If the nodes are siblings, we can do a quick check
+ } else if ( aup === bup ) {
+ return siblingCheck( a, b );
+ }
+
+ // Otherwise we need full lists of their ancestors for comparison
+ cur = a;
+ while ( ( cur = cur.parentNode ) ) {
+ ap.unshift( cur );
+ }
+ cur = b;
+ while ( ( cur = cur.parentNode ) ) {
+ bp.unshift( cur );
+ }
+
+ // Walk down the tree looking for a discrepancy
+ while ( ap[ i ] === bp[ i ] ) {
+ i++;
+ }
+
+ return i ?
+
+ // Do a sibling check if the nodes have a common ancestor
+ siblingCheck( ap[ i ], bp[ i ] ) :
+
+ // Otherwise nodes in our document sort first
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ /* eslint-disable eqeqeq */
+ ap[ i ] == preferredDoc ? -1 :
+ bp[ i ] == preferredDoc ? 1 :
+ /* eslint-enable eqeqeq */
+ 0;
+ };
+
+ return document;
+};
+
+Sizzle.matches = function( expr, elements ) {
+ return Sizzle( expr, null, null, elements );
+};
+
+Sizzle.matchesSelector = function( elem, expr ) {
+ setDocument( elem );
+
+ if ( support.matchesSelector && documentIsHTML &&
+ !nonnativeSelectorCache[ expr + " " ] &&
+ ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
+ ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
+
+ try {
+ var ret = matches.call( elem, expr );
+
+ // IE 9's matchesSelector returns false on disconnected nodes
+ if ( ret || support.disconnectedMatch ||
+
+ // As well, disconnected nodes are said to be in a document
+ // fragment in IE 9
+ elem.document && elem.document.nodeType !== 11 ) {
+ return ret;
+ }
+ } catch ( e ) {
+ nonnativeSelectorCache( expr, true );
+ }
+ }
+
+ return Sizzle( expr, document, null, [ elem ] ).length > 0;
+};
+
+Sizzle.contains = function( context, elem ) {
+
+ // Set document vars if needed
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( ( context.ownerDocument || context ) != document ) {
+ setDocument( context );
+ }
+ return contains( context, elem );
+};
+
+Sizzle.attr = function( elem, name ) {
+
+ // Set document vars if needed
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( ( elem.ownerDocument || elem ) != document ) {
+ setDocument( elem );
+ }
+
+ var fn = Expr.attrHandle[ name.toLowerCase() ],
+
+ // Don't get fooled by Object.prototype properties (jQuery #13807)
+ val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
+ fn( elem, name, !documentIsHTML ) :
+ undefined;
+
+ return val !== undefined ?
+ val :
+ support.attributes || !documentIsHTML ?
+ elem.getAttribute( name ) :
+ ( val = elem.getAttributeNode( name ) ) && val.specified ?
+ val.value :
+ null;
+};
+
+Sizzle.escape = function( sel ) {
+ return ( sel + "" ).replace( rcssescape, fcssescape );
+};
+
+Sizzle.error = function( msg ) {
+ throw new Error( "Syntax error, unrecognized expression: " + msg );
+};
+
+/**
+ * Document sorting and removing duplicates
+ * @param {ArrayLike} results
+ */
+Sizzle.uniqueSort = function( results ) {
+ var elem,
+ duplicates = [],
+ j = 0,
+ i = 0;
+
+ // Unless we *know* we can detect duplicates, assume their presence
+ hasDuplicate = !support.detectDuplicates;
+ sortInput = !support.sortStable && results.slice( 0 );
+ results.sort( sortOrder );
+
+ if ( hasDuplicate ) {
+ while ( ( elem = results[ i++ ] ) ) {
+ if ( elem === results[ i ] ) {
+ j = duplicates.push( i );
+ }
+ }
+ while ( j-- ) {
+ results.splice( duplicates[ j ], 1 );
+ }
+ }
+
+ // Clear input after sorting to release objects
+ // See https://github.com/jquery/sizzle/pull/225
+ sortInput = null;
+
+ return results;
+};
+
+/**
+ * Utility function for retrieving the text value of an array of DOM nodes
+ * @param {Array|Element} elem
+ */
+getText = Sizzle.getText = function( elem ) {
+ var node,
+ ret = "",
+ i = 0,
+ nodeType = elem.nodeType;
+
+ if ( !nodeType ) {
+
+ // If no nodeType, this is expected to be an array
+ while ( ( node = elem[ i++ ] ) ) {
+
+ // Do not traverse comment nodes
+ ret += getText( node );
+ }
+ } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
+
+ // Use textContent for elements
+ // innerText usage removed for consistency of new lines (jQuery #11153)
+ if ( typeof elem.textContent === "string" ) {
+ return elem.textContent;
+ } else {
+
+ // Traverse its children
+ for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+ ret += getText( elem );
+ }
+ }
+ } else if ( nodeType === 3 || nodeType === 4 ) {
+ return elem.nodeValue;
+ }
+
+ // Do not include comment or processing instruction nodes
+
+ return ret;
+};
+
+Expr = Sizzle.selectors = {
+
+ // Can be adjusted by the user
+ cacheLength: 50,
+
+ createPseudo: markFunction,
+
+ match: matchExpr,
+
+ attrHandle: {},
+
+ find: {},
+
+ relative: {
+ ">": { dir: "parentNode", first: true },
+ " ": { dir: "parentNode" },
+ "+": { dir: "previousSibling", first: true },
+ "~": { dir: "previousSibling" }
+ },
+
+ preFilter: {
+ "ATTR": function( match ) {
+ match[ 1 ] = match[ 1 ].replace( runescape, funescape );
+
+ // Move the given value to match[3] whether quoted or unquoted
+ match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
+ match[ 5 ] || "" ).replace( runescape, funescape );
+
+ if ( match[ 2 ] === "~=" ) {
+ match[ 3 ] = " " + match[ 3 ] + " ";
+ }
+
+ return match.slice( 0, 4 );
+ },
+
+ "CHILD": function( match ) {
+
+ /* matches from matchExpr["CHILD"]
+ 1 type (only|nth|...)
+ 2 what (child|of-type)
+ 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
+ 4 xn-component of xn+y argument ([+-]?\d*n|)
+ 5 sign of xn-component
+ 6 x of xn-component
+ 7 sign of y-component
+ 8 y of y-component
+ */
+ match[ 1 ] = match[ 1 ].toLowerCase();
+
+ if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
+
+ // nth-* requires argument
+ if ( !match[ 3 ] ) {
+ Sizzle.error( match[ 0 ] );
+ }
+
+ // numeric x and y parameters for Expr.filter.CHILD
+ // remember that false/true cast respectively to 0/1
+ match[ 4 ] = +( match[ 4 ] ?
+ match[ 5 ] + ( match[ 6 ] || 1 ) :
+ 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
+ match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
+
+ // other types prohibit arguments
+ } else if ( match[ 3 ] ) {
+ Sizzle.error( match[ 0 ] );
+ }
+
+ return match;
+ },
+
+ "PSEUDO": function( match ) {
+ var excess,
+ unquoted = !match[ 6 ] && match[ 2 ];
+
+ if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
+ return null;
+ }
+
+ // Accept quoted arguments as-is
+ if ( match[ 3 ] ) {
+ match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
+
+ // Strip excess characters from unquoted arguments
+ } else if ( unquoted && rpseudo.test( unquoted ) &&
+
+ // Get excess from tokenize (recursively)
+ ( excess = tokenize( unquoted, true ) ) &&
+
+ // advance to the next closing parenthesis
+ ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
+
+ // excess is a negative index
+ match[ 0 ] = match[ 0 ].slice( 0, excess );
+ match[ 2 ] = unquoted.slice( 0, excess );
+ }
+
+ // Return only captures needed by the pseudo filter method (type and argument)
+ return match.slice( 0, 3 );
+ }
+ },
+
+ filter: {
+
+ "TAG": function( nodeNameSelector ) {
+ var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
+ return nodeNameSelector === "*" ?
+ function() {
+ return true;
+ } :
+ function( elem ) {
+ return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
+ };
+ },
+
+ "CLASS": function( className ) {
+ var pattern = classCache[ className + " " ];
+
+ return pattern ||
+ ( pattern = new RegExp( "(^|" + whitespace +
+ ")" + className + "(" + whitespace + "|$)" ) ) && classCache(
+ className, function( elem ) {
+ return pattern.test(
+ typeof elem.className === "string" && elem.className ||
+ typeof elem.getAttribute !== "undefined" &&
+ elem.getAttribute( "class" ) ||
+ ""
+ );
+ } );
+ },
+
+ "ATTR": function( name, operator, check ) {
+ return function( elem ) {
+ var result = Sizzle.attr( elem, name );
+
+ if ( result == null ) {
+ return operator === "!=";
+ }
+ if ( !operator ) {
+ return true;
+ }
+
+ result += "";
+
+ /* eslint-disable max-len */
+
+ return operator === "=" ? result === check :
+ operator === "!=" ? result !== check :
+ operator === "^=" ? check && result.indexOf( check ) === 0 :
+ operator === "*=" ? check && result.indexOf( check ) > -1 :
+ operator === "$=" ? check && result.slice( -check.length ) === check :
+ operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
+ operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
+ false;
+ /* eslint-enable max-len */
+
+ };
+ },
+
+ "CHILD": function( type, what, _argument, first, last ) {
+ var simple = type.slice( 0, 3 ) !== "nth",
+ forward = type.slice( -4 ) !== "last",
+ ofType = what === "of-type";
+
+ return first === 1 && last === 0 ?
+
+ // Shortcut for :nth-*(n)
+ function( elem ) {
+ return !!elem.parentNode;
+ } :
+
+ function( elem, _context, xml ) {
+ var cache, uniqueCache, outerCache, node, nodeIndex, start,
+ dir = simple !== forward ? "nextSibling" : "previousSibling",
+ parent = elem.parentNode,
+ name = ofType && elem.nodeName.toLowerCase(),
+ useCache = !xml && !ofType,
+ diff = false;
+
+ if ( parent ) {
+
+ // :(first|last|only)-(child|of-type)
+ if ( simple ) {
+ while ( dir ) {
+ node = elem;
+ while ( ( node = node[ dir ] ) ) {
+ if ( ofType ?
+ node.nodeName.toLowerCase() === name :
+ node.nodeType === 1 ) {
+
+ return false;
+ }
+ }
+
+ // Reverse direction for :only-* (if we haven't yet done so)
+ start = dir = type === "only" && !start && "nextSibling";
+ }
+ return true;
+ }
+
+ start = [ forward ? parent.firstChild : parent.lastChild ];
+
+ // non-xml :nth-child(...) stores cache data on `parent`
+ if ( forward && useCache ) {
+
+ // Seek `elem` from a previously-cached index
+
+ // ...in a gzip-friendly way
+ node = parent;
+ outerCache = node[ expando ] || ( node[ expando ] = {} );
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ node.uniqueID ] ||
+ ( outerCache[ node.uniqueID ] = {} );
+
+ cache = uniqueCache[ type ] || [];
+ nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
+ diff = nodeIndex && cache[ 2 ];
+ node = nodeIndex && parent.childNodes[ nodeIndex ];
+
+ while ( ( node = ++nodeIndex && node && node[ dir ] ||
+
+ // Fallback to seeking `elem` from the start
+ ( diff = nodeIndex = 0 ) || start.pop() ) ) {
+
+ // When found, cache indexes on `parent` and break
+ if ( node.nodeType === 1 && ++diff && node === elem ) {
+ uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
+ break;
+ }
+ }
+
+ } else {
+
+ // Use previously-cached element index if available
+ if ( useCache ) {
+
+ // ...in a gzip-friendly way
+ node = elem;
+ outerCache = node[ expando ] || ( node[ expando ] = {} );
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ node.uniqueID ] ||
+ ( outerCache[ node.uniqueID ] = {} );
+
+ cache = uniqueCache[ type ] || [];
+ nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
+ diff = nodeIndex;
+ }
+
+ // xml :nth-child(...)
+ // or :nth-last-child(...) or :nth(-last)?-of-type(...)
+ if ( diff === false ) {
+
+ // Use the same loop as above to seek `elem` from the start
+ while ( ( node = ++nodeIndex && node && node[ dir ] ||
+ ( diff = nodeIndex = 0 ) || start.pop() ) ) {
+
+ if ( ( ofType ?
+ node.nodeName.toLowerCase() === name :
+ node.nodeType === 1 ) &&
+ ++diff ) {
+
+ // Cache the index of each encountered element
+ if ( useCache ) {
+ outerCache = node[ expando ] ||
+ ( node[ expando ] = {} );
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ node.uniqueID ] ||
+ ( outerCache[ node.uniqueID ] = {} );
+
+ uniqueCache[ type ] = [ dirruns, diff ];
+ }
+
+ if ( node === elem ) {
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ // Incorporate the offset, then check against cycle size
+ diff -= last;
+ return diff === first || ( diff % first === 0 && diff / first >= 0 );
+ }
+ };
+ },
+
+ "PSEUDO": function( pseudo, argument ) {
+
+ // pseudo-class names are case-insensitive
+ // http://www.w3.org/TR/selectors/#pseudo-classes
+ // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
+ // Remember that setFilters inherits from pseudos
+ var args,
+ fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
+ Sizzle.error( "unsupported pseudo: " + pseudo );
+
+ // The user may use createPseudo to indicate that
+ // arguments are needed to create the filter function
+ // just as Sizzle does
+ if ( fn[ expando ] ) {
+ return fn( argument );
+ }
+
+ // But maintain support for old signatures
+ if ( fn.length > 1 ) {
+ args = [ pseudo, pseudo, "", argument ];
+ return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
+ markFunction( function( seed, matches ) {
+ var idx,
+ matched = fn( seed, argument ),
+ i = matched.length;
+ while ( i-- ) {
+ idx = indexOf( seed, matched[ i ] );
+ seed[ idx ] = !( matches[ idx ] = matched[ i ] );
+ }
+ } ) :
+ function( elem ) {
+ return fn( elem, 0, args );
+ };
+ }
+
+ return fn;
+ }
+ },
+
+ pseudos: {
+
+ // Potentially complex pseudos
+ "not": markFunction( function( selector ) {
+
+ // Trim the selector passed to compile
+ // to avoid treating leading and trailing
+ // spaces as combinators
+ var input = [],
+ results = [],
+ matcher = compile( selector.replace( rtrim, "$1" ) );
+
+ return matcher[ expando ] ?
+ markFunction( function( seed, matches, _context, xml ) {
+ var elem,
+ unmatched = matcher( seed, null, xml, [] ),
+ i = seed.length;
+
+ // Match elements unmatched by `matcher`
+ while ( i-- ) {
+ if ( ( elem = unmatched[ i ] ) ) {
+ seed[ i ] = !( matches[ i ] = elem );
+ }
+ }
+ } ) :
+ function( elem, _context, xml ) {
+ input[ 0 ] = elem;
+ matcher( input, null, xml, results );
+
+ // Don't keep the element (issue #299)
+ input[ 0 ] = null;
+ return !results.pop();
+ };
+ } ),
+
+ "has": markFunction( function( selector ) {
+ return function( elem ) {
+ return Sizzle( selector, elem ).length > 0;
+ };
+ } ),
+
+ "contains": markFunction( function( text ) {
+ text = text.replace( runescape, funescape );
+ return function( elem ) {
+ return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
+ };
+ } ),
+
+ // "Whether an element is represented by a :lang() selector
+ // is based solely on the element's language value
+ // being equal to the identifier C,
+ // or beginning with the identifier C immediately followed by "-".
+ // The matching of C against the element's language value is performed case-insensitively.
+ // The identifier C does not have to be a valid language name."
+ // http://www.w3.org/TR/selectors/#lang-pseudo
+ "lang": markFunction( function( lang ) {
+
+ // lang value must be a valid identifier
+ if ( !ridentifier.test( lang || "" ) ) {
+ Sizzle.error( "unsupported lang: " + lang );
+ }
+ lang = lang.replace( runescape, funescape ).toLowerCase();
+ return function( elem ) {
+ var elemLang;
+ do {
+ if ( ( elemLang = documentIsHTML ?
+ elem.lang :
+ elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
+
+ elemLang = elemLang.toLowerCase();
+ return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
+ }
+ } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
+ return false;
+ };
+ } ),
+
+ // Miscellaneous
+ "target": function( elem ) {
+ var hash = window.location && window.location.hash;
+ return hash && hash.slice( 1 ) === elem.id;
+ },
+
+ "root": function( elem ) {
+ return elem === docElem;
+ },
+
+ "focus": function( elem ) {
+ return elem === document.activeElement &&
+ ( !document.hasFocus || document.hasFocus() ) &&
+ !!( elem.type || elem.href || ~elem.tabIndex );
+ },
+
+ // Boolean properties
+ "enabled": createDisabledPseudo( false ),
+ "disabled": createDisabledPseudo( true ),
+
+ "checked": function( elem ) {
+
+ // In CSS3, :checked should return both checked and selected elements
+ // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+ var nodeName = elem.nodeName.toLowerCase();
+ return ( nodeName === "input" && !!elem.checked ) ||
+ ( nodeName === "option" && !!elem.selected );
+ },
+
+ "selected": function( elem ) {
+
+ // Accessing this property makes selected-by-default
+ // options in Safari work properly
+ if ( elem.parentNode ) {
+ // eslint-disable-next-line no-unused-expressions
+ elem.parentNode.selectedIndex;
+ }
+
+ return elem.selected === true;
+ },
+
+ // Contents
+ "empty": function( elem ) {
+
+ // http://www.w3.org/TR/selectors/#empty-pseudo
+ // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
+ // but not by others (comment: 8; processing instruction: 7; etc.)
+ // nodeType < 6 works because attributes (2) do not appear as children
+ for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+ if ( elem.nodeType < 6 ) {
+ return false;
+ }
+ }
+ return true;
+ },
+
+ "parent": function( elem ) {
+ return !Expr.pseudos[ "empty" ]( elem );
+ },
+
+ // Element/input types
+ "header": function( elem ) {
+ return rheader.test( elem.nodeName );
+ },
+
+ "input": function( elem ) {
+ return rinputs.test( elem.nodeName );
+ },
+
+ "button": function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return name === "input" && elem.type === "button" || name === "button";
+ },
+
+ "text": function( elem ) {
+ var attr;
+ return elem.nodeName.toLowerCase() === "input" &&
+ elem.type === "text" &&
+
+ // Support: IE<8
+ // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
+ ( ( attr = elem.getAttribute( "type" ) ) == null ||
+ attr.toLowerCase() === "text" );
+ },
+
+ // Position-in-collection
+ "first": createPositionalPseudo( function() {
+ return [ 0 ];
+ } ),
+
+ "last": createPositionalPseudo( function( _matchIndexes, length ) {
+ return [ length - 1 ];
+ } ),
+
+ "eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
+ return [ argument < 0 ? argument + length : argument ];
+ } ),
+
+ "even": createPositionalPseudo( function( matchIndexes, length ) {
+ var i = 0;
+ for ( ; i < length; i += 2 ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ } ),
+
+ "odd": createPositionalPseudo( function( matchIndexes, length ) {
+ var i = 1;
+ for ( ; i < length; i += 2 ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ } ),
+
+ "lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
+ var i = argument < 0 ?
+ argument + length :
+ argument > length ?
+ length :
+ argument;
+ for ( ; --i >= 0; ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ } ),
+
+ "gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
+ var i = argument < 0 ? argument + length : argument;
+ for ( ; ++i < length; ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ } )
+ }
+};
+
+Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
+
+// Add button/input type pseudos
+for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
+ Expr.pseudos[ i ] = createInputPseudo( i );
+}
+for ( i in { submit: true, reset: true } ) {
+ Expr.pseudos[ i ] = createButtonPseudo( i );
+}
+
+// Easy API for creating new setFilters
+function setFilters() {}
+setFilters.prototype = Expr.filters = Expr.pseudos;
+Expr.setFilters = new setFilters();
+
+tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
+ var matched, match, tokens, type,
+ soFar, groups, preFilters,
+ cached = tokenCache[ selector + " " ];
+
+ if ( cached ) {
+ return parseOnly ? 0 : cached.slice( 0 );
+ }
+
+ soFar = selector;
+ groups = [];
+ preFilters = Expr.preFilter;
+
+ while ( soFar ) {
+
+ // Comma and first run
+ if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
+ if ( match ) {
+
+ // Don't consume trailing commas as valid
+ soFar = soFar.slice( match[ 0 ].length ) || soFar;
+ }
+ groups.push( ( tokens = [] ) );
+ }
+
+ matched = false;
+
+ // Combinators
+ if ( ( match = rcombinators.exec( soFar ) ) ) {
+ matched = match.shift();
+ tokens.push( {
+ value: matched,
+
+ // Cast descendant combinators to space
+ type: match[ 0 ].replace( rtrim, " " )
+ } );
+ soFar = soFar.slice( matched.length );
+ }
+
+ // Filters
+ for ( type in Expr.filter ) {
+ if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
+ ( match = preFilters[ type ]( match ) ) ) ) {
+ matched = match.shift();
+ tokens.push( {
+ value: matched,
+ type: type,
+ matches: match
+ } );
+ soFar = soFar.slice( matched.length );
+ }
+ }
+
+ if ( !matched ) {
+ break;
+ }
+ }
+
+ // Return the length of the invalid excess
+ // if we're just parsing
+ // Otherwise, throw an error or return tokens
+ return parseOnly ?
+ soFar.length :
+ soFar ?
+ Sizzle.error( selector ) :
+
+ // Cache the tokens
+ tokenCache( selector, groups ).slice( 0 );
+};
+
+function toSelector( tokens ) {
+ var i = 0,
+ len = tokens.length,
+ selector = "";
+ for ( ; i < len; i++ ) {
+ selector += tokens[ i ].value;
+ }
+ return selector;
+}
+
+function addCombinator( matcher, combinator, base ) {
+ var dir = combinator.dir,
+ skip = combinator.next,
+ key = skip || dir,
+ checkNonElements = base && key === "parentNode",
+ doneName = done++;
+
+ return combinator.first ?
+
+ // Check against closest ancestor/preceding element
+ function( elem, context, xml ) {
+ while ( ( elem = elem[ dir ] ) ) {
+ if ( elem.nodeType === 1 || checkNonElements ) {
+ return matcher( elem, context, xml );
+ }
+ }
+ return false;
+ } :
+
+ // Check against all ancestor/preceding elements
+ function( elem, context, xml ) {
+ var oldCache, uniqueCache, outerCache,
+ newCache = [ dirruns, doneName ];
+
+ // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
+ if ( xml ) {
+ while ( ( elem = elem[ dir ] ) ) {
+ if ( elem.nodeType === 1 || checkNonElements ) {
+ if ( matcher( elem, context, xml ) ) {
+ return true;
+ }
+ }
+ }
+ } else {
+ while ( ( elem = elem[ dir ] ) ) {
+ if ( elem.nodeType === 1 || checkNonElements ) {
+ outerCache = elem[ expando ] || ( elem[ expando ] = {} );
+
+ // Support: IE <9 only
+ // Defend against cloned attroperties (jQuery gh-1709)
+ uniqueCache = outerCache[ elem.uniqueID ] ||
+ ( outerCache[ elem.uniqueID ] = {} );
+
+ if ( skip && skip === elem.nodeName.toLowerCase() ) {
+ elem = elem[ dir ] || elem;
+ } else if ( ( oldCache = uniqueCache[ key ] ) &&
+ oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
+
+ // Assign to newCache so results back-propagate to previous elements
+ return ( newCache[ 2 ] = oldCache[ 2 ] );
+ } else {
+
+ // Reuse newcache so results back-propagate to previous elements
+ uniqueCache[ key ] = newCache;
+
+ // A match means we're done; a fail means we have to keep checking
+ if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
+ return true;
+ }
+ }
+ }
+ }
+ }
+ return false;
+ };
+}
+
+function elementMatcher( matchers ) {
+ return matchers.length > 1 ?
+ function( elem, context, xml ) {
+ var i = matchers.length;
+ while ( i-- ) {
+ if ( !matchers[ i ]( elem, context, xml ) ) {
+ return false;
+ }
+ }
+ return true;
+ } :
+ matchers[ 0 ];
+}
+
+function multipleContexts( selector, contexts, results ) {
+ var i = 0,
+ len = contexts.length;
+ for ( ; i < len; i++ ) {
+ Sizzle( selector, contexts[ i ], results );
+ }
+ return results;
+}
+
+function condense( unmatched, map, filter, context, xml ) {
+ var elem,
+ newUnmatched = [],
+ i = 0,
+ len = unmatched.length,
+ mapped = map != null;
+
+ for ( ; i < len; i++ ) {
+ if ( ( elem = unmatched[ i ] ) ) {
+ if ( !filter || filter( elem, context, xml ) ) {
+ newUnmatched.push( elem );
+ if ( mapped ) {
+ map.push( i );
+ }
+ }
+ }
+ }
+
+ return newUnmatched;
+}
+
+function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
+ if ( postFilter && !postFilter[ expando ] ) {
+ postFilter = setMatcher( postFilter );
+ }
+ if ( postFinder && !postFinder[ expando ] ) {
+ postFinder = setMatcher( postFinder, postSelector );
+ }
+ return markFunction( function( seed, results, context, xml ) {
+ var temp, i, elem,
+ preMap = [],
+ postMap = [],
+ preexisting = results.length,
+
+ // Get initial elements from seed or context
+ elems = seed || multipleContexts(
+ selector || "*",
+ context.nodeType ? [ context ] : context,
+ []
+ ),
+
+ // Prefilter to get matcher input, preserving a map for seed-results synchronization
+ matcherIn = preFilter && ( seed || !selector ) ?
+ condense( elems, preMap, preFilter, context, xml ) :
+ elems,
+
+ matcherOut = matcher ?
+
+ // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
+ postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
+
+ // ...intermediate processing is necessary
+ [] :
+
+ // ...otherwise use results directly
+ results :
+ matcherIn;
+
+ // Find primary matches
+ if ( matcher ) {
+ matcher( matcherIn, matcherOut, context, xml );
+ }
+
+ // Apply postFilter
+ if ( postFilter ) {
+ temp = condense( matcherOut, postMap );
+ postFilter( temp, [], context, xml );
+
+ // Un-match failing elements by moving them back to matcherIn
+ i = temp.length;
+ while ( i-- ) {
+ if ( ( elem = temp[ i ] ) ) {
+ matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
+ }
+ }
+ }
+
+ if ( seed ) {
+ if ( postFinder || preFilter ) {
+ if ( postFinder ) {
+
+ // Get the final matcherOut by condensing this intermediate into postFinder contexts
+ temp = [];
+ i = matcherOut.length;
+ while ( i-- ) {
+ if ( ( elem = matcherOut[ i ] ) ) {
+
+ // Restore matcherIn since elem is not yet a final match
+ temp.push( ( matcherIn[ i ] = elem ) );
+ }
+ }
+ postFinder( null, ( matcherOut = [] ), temp, xml );
+ }
+
+ // Move matched elements from seed to results to keep them synchronized
+ i = matcherOut.length;
+ while ( i-- ) {
+ if ( ( elem = matcherOut[ i ] ) &&
+ ( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
+
+ seed[ temp ] = !( results[ temp ] = elem );
+ }
+ }
+ }
+
+ // Add elements to results, through postFinder if defined
+ } else {
+ matcherOut = condense(
+ matcherOut === results ?
+ matcherOut.splice( preexisting, matcherOut.length ) :
+ matcherOut
+ );
+ if ( postFinder ) {
+ postFinder( null, results, matcherOut, xml );
+ } else {
+ push.apply( results, matcherOut );
+ }
+ }
+ } );
+}
+
+function matcherFromTokens( tokens ) {
+ var checkContext, matcher, j,
+ len = tokens.length,
+ leadingRelative = Expr.relative[ tokens[ 0 ].type ],
+ implicitRelative = leadingRelative || Expr.relative[ " " ],
+ i = leadingRelative ? 1 : 0,
+
+ // The foundational matcher ensures that elements are reachable from top-level context(s)
+ matchContext = addCombinator( function( elem ) {
+ return elem === checkContext;
+ }, implicitRelative, true ),
+ matchAnyContext = addCombinator( function( elem ) {
+ return indexOf( checkContext, elem ) > -1;
+ }, implicitRelative, true ),
+ matchers = [ function( elem, context, xml ) {
+ var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
+ ( checkContext = context ).nodeType ?
+ matchContext( elem, context, xml ) :
+ matchAnyContext( elem, context, xml ) );
+
+ // Avoid hanging onto element (issue #299)
+ checkContext = null;
+ return ret;
+ } ];
+
+ for ( ; i < len; i++ ) {
+ if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
+ matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
+ } else {
+ matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
+
+ // Return special upon seeing a positional matcher
+ if ( matcher[ expando ] ) {
+
+ // Find the next relative operator (if any) for proper handling
+ j = ++i;
+ for ( ; j < len; j++ ) {
+ if ( Expr.relative[ tokens[ j ].type ] ) {
+ break;
+ }
+ }
+ return setMatcher(
+ i > 1 && elementMatcher( matchers ),
+ i > 1 && toSelector(
+
+ // If the preceding token was a descendant combinator, insert an implicit any-element `*`
+ tokens
+ .slice( 0, i - 1 )
+ .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
+ ).replace( rtrim, "$1" ),
+ matcher,
+ i < j && matcherFromTokens( tokens.slice( i, j ) ),
+ j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
+ j < len && toSelector( tokens )
+ );
+ }
+ matchers.push( matcher );
+ }
+ }
+
+ return elementMatcher( matchers );
+}
+
+function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
+ var bySet = setMatchers.length > 0,
+ byElement = elementMatchers.length > 0,
+ superMatcher = function( seed, context, xml, results, outermost ) {
+ var elem, j, matcher,
+ matchedCount = 0,
+ i = "0",
+ unmatched = seed && [],
+ setMatched = [],
+ contextBackup = outermostContext,
+
+ // We must always have either seed elements or outermost context
+ elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
+
+ // Use integer dirruns iff this is the outermost matcher
+ dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
+ len = elems.length;
+
+ if ( outermost ) {
+
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ outermostContext = context == document || context || outermost;
+ }
+
+ // Add elements passing elementMatchers directly to results
+ // Support: IE<9, Safari
+ // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
+ for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
+ if ( byElement && elem ) {
+ j = 0;
+
+ // Support: IE 11+, Edge 17 - 18+
+ // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+ // two documents; shallow comparisons work.
+ // eslint-disable-next-line eqeqeq
+ if ( !context && elem.ownerDocument != document ) {
+ setDocument( elem );
+ xml = !documentIsHTML;
+ }
+ while ( ( matcher = elementMatchers[ j++ ] ) ) {
+ if ( matcher( elem, context || document, xml ) ) {
+ results.push( elem );
+ break;
+ }
+ }
+ if ( outermost ) {
+ dirruns = dirrunsUnique;
+ }
+ }
+
+ // Track unmatched elements for set filters
+ if ( bySet ) {
+
+ // They will have gone through all possible matchers
+ if ( ( elem = !matcher && elem ) ) {
+ matchedCount--;
+ }
+
+ // Lengthen the array for every element, matched or not
+ if ( seed ) {
+ unmatched.push( elem );
+ }
+ }
+ }
+
+ // `i` is now the count of elements visited above, and adding it to `matchedCount`
+ // makes the latter nonnegative.
+ matchedCount += i;
+
+ // Apply set filters to unmatched elements
+ // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
+ // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
+ // no element matchers and no seed.
+ // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
+ // case, which will result in a "00" `matchedCount` that differs from `i` but is also
+ // numerically zero.
+ if ( bySet && i !== matchedCount ) {
+ j = 0;
+ while ( ( matcher = setMatchers[ j++ ] ) ) {
+ matcher( unmatched, setMatched, context, xml );
+ }
+
+ if ( seed ) {
+
+ // Reintegrate element matches to eliminate the need for sorting
+ if ( matchedCount > 0 ) {
+ while ( i-- ) {
+ if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
+ setMatched[ i ] = pop.call( results );
+ }
+ }
+ }
+
+ // Discard index placeholder values to get only actual matches
+ setMatched = condense( setMatched );
+ }
+
+ // Add matches to results
+ push.apply( results, setMatched );
+
+ // Seedless set matches succeeding multiple successful matchers stipulate sorting
+ if ( outermost && !seed && setMatched.length > 0 &&
+ ( matchedCount + setMatchers.length ) > 1 ) {
+
+ Sizzle.uniqueSort( results );
+ }
+ }
+
+ // Override manipulation of globals by nested matchers
+ if ( outermost ) {
+ dirruns = dirrunsUnique;
+ outermostContext = contextBackup;
+ }
+
+ return unmatched;
+ };
+
+ return bySet ?
+ markFunction( superMatcher ) :
+ superMatcher;
+}
+
+compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
+ var i,
+ setMatchers = [],
+ elementMatchers = [],
+ cached = compilerCache[ selector + " " ];
+
+ if ( !cached ) {
+
+ // Generate a function of recursive functions that can be used to check each element
+ if ( !match ) {
+ match = tokenize( selector );
+ }
+ i = match.length;
+ while ( i-- ) {
+ cached = matcherFromTokens( match[ i ] );
+ if ( cached[ expando ] ) {
+ setMatchers.push( cached );
+ } else {
+ elementMatchers.push( cached );
+ }
+ }
+
+ // Cache the compiled function
+ cached = compilerCache(
+ selector,
+ matcherFromGroupMatchers( elementMatchers, setMatchers )
+ );
+
+ // Save selector and tokenization
+ cached.selector = selector;
+ }
+ return cached;
+};
+
+/**
+ * A low-level selection function that works with Sizzle's compiled
+ * selector functions
+ * @param {String|Function} selector A selector or a pre-compiled
+ * selector function built with Sizzle.compile
+ * @param {Element} context
+ * @param {Array} [results]
+ * @param {Array} [seed] A set of elements to match against
+ */
+select = Sizzle.select = function( selector, context, results, seed ) {
+ var i, tokens, token, type, find,
+ compiled = typeof selector === "function" && selector,
+ match = !seed && tokenize( ( selector = compiled.selector || selector ) );
+
+ results = results || [];
+
+ // Try to minimize operations if there is only one selector in the list and no seed
+ // (the latter of which guarantees us context)
+ if ( match.length === 1 ) {
+
+ // Reduce context if the leading compound selector is an ID
+ tokens = match[ 0 ] = match[ 0 ].slice( 0 );
+ if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
+ context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
+
+ context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
+ .replace( runescape, funescape ), context ) || [] )[ 0 ];
+ if ( !context ) {
+ return results;
+
+ // Precompiled matchers will still verify ancestry, so step up a level
+ } else if ( compiled ) {
+ context = context.parentNode;
+ }
+
+ selector = selector.slice( tokens.shift().value.length );
+ }
+
+ // Fetch a seed set for right-to-left matching
+ i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
+ while ( i-- ) {
+ token = tokens[ i ];
+
+ // Abort if we hit a combinator
+ if ( Expr.relative[ ( type = token.type ) ] ) {
+ break;
+ }
+ if ( ( find = Expr.find[ type ] ) ) {
+
+ // Search, expanding context for leading sibling combinators
+ if ( ( seed = find(
+ token.matches[ 0 ].replace( runescape, funescape ),
+ rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
+ context
+ ) ) ) {
+
+ // If seed is empty or no tokens remain, we can return early
+ tokens.splice( i, 1 );
+ selector = seed.length && toSelector( tokens );
+ if ( !selector ) {
+ push.apply( results, seed );
+ return results;
+ }
+
+ break;
+ }
+ }
+ }
+ }
+
+ // Compile and execute a filtering function if one is not provided
+ // Provide `match` to avoid retokenization if we modified the selector above
+ ( compiled || compile( selector, match ) )(
+ seed,
+ context,
+ !documentIsHTML,
+ results,
+ !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
+ );
+ return results;
+};
+
+// One-time assignments
+
+// Sort stability
+support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
+
+// Support: Chrome 14-35+
+// Always assume duplicates if they aren't passed to the comparison function
+support.detectDuplicates = !!hasDuplicate;
+
+// Initialize against the default document
+setDocument();
+
+// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
+// Detached nodes confoundingly follow *each other*
+support.sortDetached = assert( function( el ) {
+
+ // Should return 1, but returns 4 (following)
+ return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
+} );
+
+// Support: IE<8
+// Prevent attribute/property "interpolation"
+// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
+if ( !assert( function( el ) {
+ el.innerHTML = "<a href='#'></a>";
+ return el.firstChild.getAttribute( "href" ) === "#";
+} ) ) {
+ addHandle( "type|href|height|width", function( elem, name, isXML ) {
+ if ( !isXML ) {
+ return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
+ }
+ } );
+}
+
+// Support: IE<9
+// Use defaultValue in place of getAttribute("value")
+if ( !support.attributes || !assert( function( el ) {
+ el.innerHTML = "<input/>";
+ el.firstChild.setAttribute( "value", "" );
+ return el.firstChild.getAttribute( "value" ) === "";
+} ) ) {
+ addHandle( "value", function( elem, _name, isXML ) {
+ if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
+ return elem.defaultValue;
+ }
+ } );
+}
+
+// Support: IE<9
+// Use getAttributeNode to fetch booleans when getAttribute lies
+if ( !assert( function( el ) {
+ return el.getAttribute( "disabled" ) == null;
+} ) ) {
+ addHandle( booleans, function( elem, name, isXML ) {
+ var val;
+ if ( !isXML ) {
+ return elem[ name ] === true ? name.toLowerCase() :
+ ( val = elem.getAttributeNode( name ) ) && val.specified ?
+ val.value :
+ null;
+ }
+ } );
+}
+
+return Sizzle;
+
+} )( window );
+
+
+
+jQuery.find = Sizzle;
+jQuery.expr = Sizzle.selectors;
+
+// Deprecated
+jQuery.expr[ ":" ] = jQuery.expr.pseudos;
+jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
+jQuery.text = Sizzle.getText;
+jQuery.isXMLDoc = Sizzle.isXML;
+jQuery.contains = Sizzle.contains;
+jQuery.escapeSelector = Sizzle.escape;
+
+
+
+
+var dir = function( elem, dir, until ) {
+ var matched = [],
+ truncate = until !== undefined;
+
+ while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
+ if ( elem.nodeType === 1 ) {
+ if ( truncate && jQuery( elem ).is( until ) ) {
+ break;
+ }
+ matched.push( elem );
+ }
+ }
+ return matched;
+};
+
+
+var siblings = function( n, elem ) {
+ var matched = [];
+
+ for ( ; n; n = n.nextSibling ) {
+ if ( n.nodeType === 1 && n !== elem ) {
+ matched.push( n );
+ }
+ }
+
+ return matched;
+};
+
+
+var rneedsContext = jQuery.expr.match.needsContext;
+
+
+
+function nodeName( elem, name ) {
+
+ return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+
+}
+var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
+
+
+
+// Implement the identical functionality for filter and not
+function winnow( elements, qualifier, not ) {
+ if ( isFunction( qualifier ) ) {
+ return jQuery.grep( elements, function( elem, i ) {
+ return !!qualifier.call( elem, i, elem ) !== not;
+ } );
+ }
+
+ // Single element
+ if ( qualifier.nodeType ) {
+ return jQuery.grep( elements, function( elem ) {
+ return ( elem === qualifier ) !== not;
+ } );
+ }
+
+ // Arraylike of elements (jQuery, arguments, Array)
+ if ( typeof qualifier !== "string" ) {
+ return jQuery.grep( elements, function( elem ) {
+ return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
+ } );
+ }
+
+ // Filtered directly for both simple and complex selectors
+ return jQuery.filter( qualifier, elements, not );
+}
+
+jQuery.filter = function( expr, elems, not ) {
+ var elem = elems[ 0 ];
+
+ if ( not ) {
+ expr = ":not(" + expr + ")";
+ }
+
+ if ( elems.length === 1 && elem.nodeType === 1 ) {
+ return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
+ }
+
+ return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
+ return elem.nodeType === 1;
+ } ) );
+};
+
+jQuery.fn.extend( {
+ find: function( selector ) {
+ var i, ret,
+ len = this.length,
+ self = this;
+
+ if ( typeof selector !== "string" ) {
+ return this.pushStack( jQuery( selector ).filter( function() {
+ for ( i = 0; i < len; i++ ) {
+ if ( jQuery.contains( self[ i ], this ) ) {
+ return true;
+ }
+ }
+ } ) );
+ }
+
+ ret = this.pushStack( [] );
+
+ for ( i = 0; i < len; i++ ) {
+ jQuery.find( selector, self[ i ], ret );
+ }
+
+ return len > 1 ? jQuery.uniqueSort( ret ) : ret;
+ },
+ filter: function( selector ) {
+ return this.pushStack( winnow( this, selector || [], false ) );
+ },
+ not: function( selector ) {
+ return this.pushStack( winnow( this, selector || [], true ) );
+ },
+ is: function( selector ) {
+ return !!winnow(
+ this,
+
+ // If this is a positional/relative selector, check membership in the returned set
+ // so $("p:first").is("p:last") won't return true for a doc with two "p".
+ typeof selector === "string" && rneedsContext.test( selector ) ?
+ jQuery( selector ) :
+ selector || [],
+ false
+ ).length;
+ }
+} );
+
+
+// Initialize a jQuery object
+
+
+// A central reference to the root jQuery(document)
+var rootjQuery,
+
+ // A simple way to check for HTML strings
+ // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
+ // Strict HTML recognition (#11290: must start with <)
+ // Shortcut simple #id case for speed
+ rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
+
+ init = jQuery.fn.init = function( selector, context, root ) {
+ var match, elem;
+
+ // HANDLE: $(""), $(null), $(undefined), $(false)
+ if ( !selector ) {
+ return this;
+ }
+
+ // Method init() accepts an alternate rootjQuery
+ // so migrate can support jQuery.sub (gh-2101)
+ root = root || rootjQuery;
+
+ // Handle HTML strings
+ if ( typeof selector === "string" ) {
+ if ( selector[ 0 ] === "<" &&
+ selector[ selector.length - 1 ] === ">" &&
+ selector.length >= 3 ) {
+
+ // Assume that strings that start and end with <> are HTML and skip the regex check
+ match = [ null, selector, null ];
+
+ } else {
+ match = rquickExpr.exec( selector );
+ }
+
+ // Match html or make sure no context is specified for #id
+ if ( match && ( match[ 1 ] || !context ) ) {
+
+ // HANDLE: $(html) -> $(array)
+ if ( match[ 1 ] ) {
+ context = context instanceof jQuery ? context[ 0 ] : context;
+
+ // Option to run scripts is true for back-compat
+ // Intentionally let the error be thrown if parseHTML is not present
+ jQuery.merge( this, jQuery.parseHTML(
+ match[ 1 ],
+ context && context.nodeType ? context.ownerDocument || context : document,
+ true
+ ) );
+
+ // HANDLE: $(html, props)
+ if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
+ for ( match in context ) {
+
+ // Properties of context are called as methods if possible
+ if ( isFunction( this[ match ] ) ) {
+ this[ match ]( context[ match ] );
+
+ // ...and otherwise set as attributes
+ } else {
+ this.attr( match, context[ match ] );
+ }
+ }
+ }
+
+ return this;
+
+ // HANDLE: $(#id)
+ } else {
+ elem = document.getElementById( match[ 2 ] );
+
+ if ( elem ) {
+
+ // Inject the element directly into the jQuery object
+ this[ 0 ] = elem;
+ this.length = 1;
+ }
+ return this;
+ }
+
+ // HANDLE: $(expr, $(...))
+ } else if ( !context || context.jquery ) {
+ return ( context || root ).find( selector );
+
+ // HANDLE: $(expr, context)
+ // (which is just equivalent to: $(context).find(expr)
+ } else {
+ return this.constructor( context ).find( selector );
+ }
+
+ // HANDLE: $(DOMElement)
+ } else if ( selector.nodeType ) {
+ this[ 0 ] = selector;
+ this.length = 1;
+ return this;
+
+ // HANDLE: $(function)
+ // Shortcut for document ready
+ } else if ( isFunction( selector ) ) {
+ return root.ready !== undefined ?
+ root.ready( selector ) :
+
+ // Execute immediately if ready is not present
+ selector( jQuery );
+ }
+
+ return jQuery.makeArray( selector, this );
+ };
+
+// Give the init function the jQuery prototype for later instantiation
+init.prototype = jQuery.fn;
+
+// Initialize central reference
+rootjQuery = jQuery( document );
+
+
+var rparentsprev = /^(?:parents|prev(?:Until|All))/,
+
+ // Methods guaranteed to produce a unique set when starting from a unique set
+ guaranteedUnique = {
+ children: true,
+ contents: true,
+ next: true,
+ prev: true
+ };
+
+jQuery.fn.extend( {
+ has: function( target ) {
+ var targets = jQuery( target, this ),
+ l = targets.length;
+
+ return this.filter( function() {
+ var i = 0;
+ for ( ; i < l; i++ ) {
+ if ( jQuery.contains( this, targets[ i ] ) ) {
+ return true;
+ }
+ }
+ } );
+ },
+
+ closest: function( selectors, context ) {
+ var cur,
+ i = 0,
+ l = this.length,
+ matched = [],
+ targets = typeof selectors !== "string" && jQuery( selectors );
+
+ // Positional selectors never match, since there's no _selection_ context
+ if ( !rneedsContext.test( selectors ) ) {
+ for ( ; i < l; i++ ) {
+ for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
+
+ // Always skip document fragments
+ if ( cur.nodeType < 11 && ( targets ?
+ targets.index( cur ) > -1 :
+
+ // Don't pass non-elements to Sizzle
+ cur.nodeType === 1 &&
+ jQuery.find.matchesSelector( cur, selectors ) ) ) {
+
+ matched.push( cur );
+ break;
+ }
+ }
+ }
+ }
+
+ return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
+ },
+
+ // Determine the position of an element within the set
+ index: function( elem ) {
+
+ // No argument, return index in parent
+ if ( !elem ) {
+ return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
+ }
+
+ // Index in selector
+ if ( typeof elem === "string" ) {
+ return indexOf.call( jQuery( elem ), this[ 0 ] );
+ }
+
+ // Locate the position of the desired element
+ return indexOf.call( this,
+
+ // If it receives a jQuery object, the first element is used
+ elem.jquery ? elem[ 0 ] : elem
+ );
+ },
+
+ add: function( selector, context ) {
+ return this.pushStack(
+ jQuery.uniqueSort(
+ jQuery.merge( this.get(), jQuery( selector, context ) )
+ )
+ );
+ },
+
+ addBack: function( selector ) {
+ return this.add( selector == null ?
+ this.prevObject : this.prevObject.filter( selector )
+ );
+ }
+} );
+
+function sibling( cur, dir ) {
+ while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
+ return cur;
+}
+
+jQuery.each( {
+ parent: function( elem ) {
+ var parent = elem.parentNode;
+ return parent && parent.nodeType !== 11 ? parent : null;
+ },
+ parents: function( elem ) {
+ return dir( elem, "parentNode" );
+ },
+ parentsUntil: function( elem, _i, until ) {
+ return dir( elem, "parentNode", until );
+ },
+ next: function( elem ) {
+ return sibling( elem, "nextSibling" );
+ },
+ prev: function( elem ) {
+ return sibling( elem, "previousSibling" );
+ },
+ nextAll: function( elem ) {
+ return dir( elem, "nextSibling" );
+ },
+ prevAll: function( elem ) {
+ return dir( elem, "previousSibling" );
+ },
+ nextUntil: function( elem, _i, until ) {
+ return dir( elem, "nextSibling", until );
+ },
+ prevUntil: function( elem, _i, until ) {
+ return dir( elem, "previousSibling", until );
+ },
+ siblings: function( elem ) {
+ return siblings( ( elem.parentNode || {} ).firstChild, elem );
+ },
+ children: function( elem ) {
+ return siblings( elem.firstChild );
+ },
+ contents: function( elem ) {
+ if ( elem.contentDocument != null &&
+
+ // Support: IE 11+
+ // <object> elements with no `data` attribute has an object
+ // `contentDocument` with a `null` prototype.
+ getProto( elem.contentDocument ) ) {
+
+ return elem.contentDocument;
+ }
+
+ // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
+ // Treat the template element as a regular one in browsers that
+ // don't support it.
+ if ( nodeName( elem, "template" ) ) {
+ elem = elem.content || elem;
+ }
+
+ return jQuery.merge( [], elem.childNodes );
+ }
+}, function( name, fn ) {
+ jQuery.fn[ name ] = function( until, selector ) {
+ var matched = jQuery.map( this, fn, until );
+
+ if ( name.slice( -5 ) !== "Until" ) {
+ selector = until;
+ }
+
+ if ( selector && typeof selector === "string" ) {
+ matched = jQuery.filter( selector, matched );
+ }
+
+ if ( this.length > 1 ) {
+
+ // Remove duplicates
+ if ( !guaranteedUnique[ name ] ) {
+ jQuery.uniqueSort( matched );
+ }
+
+ // Reverse order for parents* and prev-derivatives
+ if ( rparentsprev.test( name ) ) {
+ matched.reverse();
+ }
+ }
+
+ return this.pushStack( matched );
+ };
+} );
+var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
+
+
+
+// Convert String-formatted options into Object-formatted ones
+function createOptions( options ) {
+ var object = {};
+ jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
+ object[ flag ] = true;
+ } );
+ return object;
+}
+
+/*
+ * Create a callback list using the following parameters:
+ *
+ * options: an optional list of space-separated options that will change how
+ * the callback list behaves or a more traditional option object
+ *
+ * By default a callback list will act like an event callback list and can be
+ * "fired" multiple times.
+ *
+ * Possible options:
+ *
+ * once: will ensure the callback list can only be fired once (like a Deferred)
+ *
+ * memory: will keep track of previous values and will call any callback added
+ * after the list has been fired right away with the latest "memorized"
+ * values (like a Deferred)
+ *
+ * unique: will ensure a callback can only be added once (no duplicate in the list)
+ *
+ * stopOnFalse: interrupt callings when a callback returns false
+ *
+ */
+jQuery.Callbacks = function( options ) {
+
+ // Convert options from String-formatted to Object-formatted if needed
+ // (we check in cache first)
+ options = typeof options === "string" ?
+ createOptions( options ) :
+ jQuery.extend( {}, options );
+
+ var // Flag to know if list is currently firing
+ firing,
+
+ // Last fire value for non-forgettable lists
+ memory,
+
+ // Flag to know if list was already fired
+ fired,
+
+ // Flag to prevent firing
+ locked,
+
+ // Actual callback list
+ list = [],
+
+ // Queue of execution data for repeatable lists
+ queue = [],
+
+ // Index of currently firing callback (modified by add/remove as needed)
+ firingIndex = -1,
+
+ // Fire callbacks
+ fire = function() {
+
+ // Enforce single-firing
+ locked = locked || options.once;
+
+ // Execute callbacks for all pending executions,
+ // respecting firingIndex overrides and runtime changes
+ fired = firing = true;
+ for ( ; queue.length; firingIndex = -1 ) {
+ memory = queue.shift();
+ while ( ++firingIndex < list.length ) {
+
+ // Run callback and check for early termination
+ if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
+ options.stopOnFalse ) {
+
+ // Jump to end and forget the data so .add doesn't re-fire
+ firingIndex = list.length;
+ memory = false;
+ }
+ }
+ }
+
+ // Forget the data if we're done with it
+ if ( !options.memory ) {
+ memory = false;
+ }
+
+ firing = false;
+
+ // Clean up if we're done firing for good
+ if ( locked ) {
+
+ // Keep an empty list if we have data for future add calls
+ if ( memory ) {
+ list = [];
+
+ // Otherwise, this object is spent
+ } else {
+ list = "";
+ }
+ }
+ },
+
+ // Actual Callbacks object
+ self = {
+
+ // Add a callback or a collection of callbacks to the list
+ add: function() {
+ if ( list ) {
+
+ // If we have memory from a past run, we should fire after adding
+ if ( memory && !firing ) {
+ firingIndex = list.length - 1;
+ queue.push( memory );
+ }
+
+ ( function add( args ) {
+ jQuery.each( args, function( _, arg ) {
+ if ( isFunction( arg ) ) {
+ if ( !options.unique || !self.has( arg ) ) {
+ list.push( arg );
+ }
+ } else if ( arg && arg.length && toType( arg ) !== "string" ) {
+
+ // Inspect recursively
+ add( arg );
+ }
+ } );
+ } )( arguments );
+
+ if ( memory && !firing ) {
+ fire();
+ }
+ }
+ return this;
+ },
+
+ // Remove a callback from the list
+ remove: function() {
+ jQuery.each( arguments, function( _, arg ) {
+ var index;
+ while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
+ list.splice( index, 1 );
+
+ // Handle firing indexes
+ if ( index <= firingIndex ) {
+ firingIndex--;
+ }
+ }
+ } );
+ return this;
+ },
+
+ // Check if a given callback is in the list.
+ // If no argument is given, return whether or not list has callbacks attached.
+ has: function( fn ) {
+ return fn ?
+ jQuery.inArray( fn, list ) > -1 :
+ list.length > 0;
+ },
+
+ // Remove all callbacks from the list
+ empty: function() {
+ if ( list ) {
+ list = [];
+ }
+ return this;
+ },
+
+ // Disable .fire and .add
+ // Abort any current/pending executions
+ // Clear all callbacks and values
+ disable: function() {
+ locked = queue = [];
+ list = memory = "";
+ return this;
+ },
+ disabled: function() {
+ return !list;
+ },
+
+ // Disable .fire
+ // Also disable .add unless we have memory (since it would have no effect)
+ // Abort any pending executions
+ lock: function() {
+ locked = queue = [];
+ if ( !memory && !firing ) {
+ list = memory = "";
+ }
+ return this;
+ },
+ locked: function() {
+ return !!locked;
+ },
+
+ // Call all callbacks with the given context and arguments
+ fireWith: function( context, args ) {
+ if ( !locked ) {
+ args = args || [];
+ args = [ context, args.slice ? args.slice() : args ];
+ queue.push( args );
+ if ( !firing ) {
+ fire();
+ }
+ }
+ return this;
+ },
+
+ // Call all the callbacks with the given arguments
+ fire: function() {
+ self.fireWith( this, arguments );
+ return this;
+ },
+
+ // To know if the callbacks have already been called at least once
+ fired: function() {
+ return !!fired;
+ }
+ };
+
+ return self;
+};
+
+
+function Identity( v ) {
+ return v;
+}
+function Thrower( ex ) {
+ throw ex;
+}
+
+function adoptValue( value, resolve, reject, noValue ) {
+ var method;
+
+ try {
+
+ // Check for promise aspect first to privilege synchronous behavior
+ if ( value && isFunction( ( method = value.promise ) ) ) {
+ method.call( value ).done( resolve ).fail( reject );
+
+ // Other thenables
+ } else if ( value && isFunction( ( method = value.then ) ) ) {
+ method.call( value, resolve, reject );
+
+ // Other non-thenables
+ } else {
+
+ // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
+ // * false: [ value ].slice( 0 ) => resolve( value )
+ // * true: [ value ].slice( 1 ) => resolve()
+ resolve.apply( undefined, [ value ].slice( noValue ) );
+ }
+
+ // For Promises/A+, convert exceptions into rejections
+ // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
+ // Deferred#then to conditionally suppress rejection.
+ } catch ( value ) {
+
+ // Support: Android 4.0 only
+ // Strict mode functions invoked without .call/.apply get global-object context
+ reject.apply( undefined, [ value ] );
+ }
+}
+
+jQuery.extend( {
+
+ Deferred: function( func ) {
+ var tuples = [
+
+ // action, add listener, callbacks,
+ // ... .then handlers, argument index, [final state]
+ [ "notify", "progress", jQuery.Callbacks( "memory" ),
+ jQuery.Callbacks( "memory" ), 2 ],
+ [ "resolve", "done", jQuery.Callbacks( "once memory" ),
+ jQuery.Callbacks( "once memory" ), 0, "resolved" ],
+ [ "reject", "fail", jQuery.Callbacks( "once memory" ),
+ jQuery.Callbacks( "once memory" ), 1, "rejected" ]
+ ],
+ state = "pending",
+ promise = {
+ state: function() {
+ return state;
+ },
+ always: function() {
+ deferred.done( arguments ).fail( arguments );
+ return this;
+ },
+ "catch": function( fn ) {
+ return promise.then( null, fn );
+ },
+
+ // Keep pipe for back-compat
+ pipe: function( /* fnDone, fnFail, fnProgress */ ) {
+ var fns = arguments;
+
+ return jQuery.Deferred( function( newDefer ) {
+ jQuery.each( tuples, function( _i, tuple ) {
+
+ // Map tuples (progress, done, fail) to arguments (done, fail, progress)
+ var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
+
+ // deferred.progress(function() { bind to newDefer or newDefer.notify })
+ // deferred.done(function() { bind to newDefer or newDefer.resolve })
+ // deferred.fail(function() { bind to newDefer or newDefer.reject })
+ deferred[ tuple[ 1 ] ]( function() {
+ var returned = fn && fn.apply( this, arguments );
+ if ( returned && isFunction( returned.promise ) ) {
+ returned.promise()
+ .progress( newDefer.notify )
+ .done( newDefer.resolve )
+ .fail( newDefer.reject );
+ } else {
+ newDefer[ tuple[ 0 ] + "With" ](
+ this,
+ fn ? [ returned ] : arguments
+ );
+ }
+ } );
+ } );
+ fns = null;
+ } ).promise();
+ },
+ then: function( onFulfilled, onRejected, onProgress ) {
+ var maxDepth = 0;
+ function resolve( depth, deferred, handler, special ) {
+ return function() {
+ var that = this,
+ args = arguments,
+ mightThrow = function() {
+ var returned, then;
+
+ // Support: Promises/A+ section 2.3.3.3.3
+ // https://promisesaplus.com/#point-59
+ // Ignore double-resolution attempts
+ if ( depth < maxDepth ) {
+ return;
+ }
+
+ returned = handler.apply( that, args );
+
+ // Support: Promises/A+ section 2.3.1
+ // https://promisesaplus.com/#point-48
+ if ( returned === deferred.promise() ) {
+ throw new TypeError( "Thenable self-resolution" );
+ }
+
+ // Support: Promises/A+ sections 2.3.3.1, 3.5
+ // https://promisesaplus.com/#point-54
+ // https://promisesaplus.com/#point-75
+ // Retrieve `then` only once
+ then = returned &&
+
+ // Support: Promises/A+ section 2.3.4
+ // https://promisesaplus.com/#point-64
+ // Only check objects and functions for thenability
+ ( typeof returned === "object" ||
+ typeof returned === "function" ) &&
+ returned.then;
+
+ // Handle a returned thenable
+ if ( isFunction( then ) ) {
+
+ // Special processors (notify) just wait for resolution
+ if ( special ) {
+ then.call(
+ returned,
+ resolve( maxDepth, deferred, Identity, special ),
+ resolve( maxDepth, deferred, Thrower, special )
+ );
+
+ // Normal processors (resolve) also hook into progress
+ } else {
+
+ // ...and disregard older resolution values
+ maxDepth++;
+
+ then.call(
+ returned,
+ resolve( maxDepth, deferred, Identity, special ),
+ resolve( maxDepth, deferred, Thrower, special ),
+ resolve( maxDepth, deferred, Identity,
+ deferred.notifyWith )
+ );
+ }
+
+ // Handle all other returned values
+ } else {
+
+ // Only substitute handlers pass on context
+ // and multiple values (non-spec behavior)
+ if ( handler !== Identity ) {
+ that = undefined;
+ args = [ returned ];
+ }
+
+ // Process the value(s)
+ // Default process is resolve
+ ( special || deferred.resolveWith )( that, args );
+ }
+ },
+
+ // Only normal processors (resolve) catch and reject exceptions
+ process = special ?
+ mightThrow :
+ function() {
+ try {
+ mightThrow();
+ } catch ( e ) {
+
+ if ( jQuery.Deferred.exceptionHook ) {
+ jQuery.Deferred.exceptionHook( e,
+ process.stackTrace );
+ }
+
+ // Support: Promises/A+ section 2.3.3.3.4.1
+ // https://promisesaplus.com/#point-61
+ // Ignore post-resolution exceptions
+ if ( depth + 1 >= maxDepth ) {
+
+ // Only substitute handlers pass on context
+ // and multiple values (non-spec behavior)
+ if ( handler !== Thrower ) {
+ that = undefined;
+ args = [ e ];
+ }
+
+ deferred.rejectWith( that, args );
+ }
+ }
+ };
+
+ // Support: Promises/A+ section 2.3.3.3.1
+ // https://promisesaplus.com/#point-57
+ // Re-resolve promises immediately to dodge false rejection from
+ // subsequent errors
+ if ( depth ) {
+ process();
+ } else {
+
+ // Call an optional hook to record the stack, in case of exception
+ // since it's otherwise lost when execution goes async
+ if ( jQuery.Deferred.getStackHook ) {
+ process.stackTrace = jQuery.Deferred.getStackHook();
+ }
+ window.setTimeout( process );
+ }
+ };
+ }
+
+ return jQuery.Deferred( function( newDefer ) {
+
+ // progress_handlers.add( ... )
+ tuples[ 0 ][ 3 ].add(
+ resolve(
+ 0,
+ newDefer,
+ isFunction( onProgress ) ?
+ onProgress :
+ Identity,
+ newDefer.notifyWith
+ )
+ );
+
+ // fulfilled_handlers.add( ... )
+ tuples[ 1 ][ 3 ].add(
+ resolve(
+ 0,
+ newDefer,
+ isFunction( onFulfilled ) ?
+ onFulfilled :
+ Identity
+ )
+ );
+
+ // rejected_handlers.add( ... )
+ tuples[ 2 ][ 3 ].add(
+ resolve(
+ 0,
+ newDefer,
+ isFunction( onRejected ) ?
+ onRejected :
+ Thrower
+ )
+ );
+ } ).promise();
+ },
+
+ // Get a promise for this deferred
+ // If obj is provided, the promise aspect is added to the object
+ promise: function( obj ) {
+ return obj != null ? jQuery.extend( obj, promise ) : promise;
+ }
+ },
+ deferred = {};
+
+ // Add list-specific methods
+ jQuery.each( tuples, function( i, tuple ) {
+ var list = tuple[ 2 ],
+ stateString = tuple[ 5 ];
+
+ // promise.progress = list.add
+ // promise.done = list.add
+ // promise.fail = list.add
+ promise[ tuple[ 1 ] ] = list.add;
+
+ // Handle state
+ if ( stateString ) {
+ list.add(
+ function() {
+
+ // state = "resolved" (i.e., fulfilled)
+ // state = "rejected"
+ state = stateString;
+ },
+
+ // rejected_callbacks.disable
+ // fulfilled_callbacks.disable
+ tuples[ 3 - i ][ 2 ].disable,
+
+ // rejected_handlers.disable
+ // fulfilled_handlers.disable
+ tuples[ 3 - i ][ 3 ].disable,
+
+ // progress_callbacks.lock
+ tuples[ 0 ][ 2 ].lock,
+
+ // progress_handlers.lock
+ tuples[ 0 ][ 3 ].lock
+ );
+ }
+
+ // progress_handlers.fire
+ // fulfilled_handlers.fire
+ // rejected_handlers.fire
+ list.add( tuple[ 3 ].fire );
+
+ // deferred.notify = function() { deferred.notifyWith(...) }
+ // deferred.resolve = function() { deferred.resolveWith(...) }
+ // deferred.reject = function() { deferred.rejectWith(...) }
+ deferred[ tuple[ 0 ] ] = function() {
+ deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
+ return this;
+ };
+
+ // deferred.notifyWith = list.fireWith
+ // deferred.resolveWith = list.fireWith
+ // deferred.rejectWith = list.fireWith
+ deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
+ } );
+
+ // Make the deferred a promise
+ promise.promise( deferred );
+
+ // Call given func if any
+ if ( func ) {
+ func.call( deferred, deferred );
+ }
+
+ // All done!
+ return deferred;
+ },
+
+ // Deferred helper
+ when: function( singleValue ) {
+ var
+
+ // count of uncompleted subordinates
+ remaining = arguments.length,
+
+ // count of unprocessed arguments
+ i = remaining,
+
+ // subordinate fulfillment data
+ resolveContexts = Array( i ),
+ resolveValues = slice.call( arguments ),
+
+ // the primary Deferred
+ primary = jQuery.Deferred(),
+
+ // subordinate callback factory
+ updateFunc = function( i ) {
+ return function( value ) {
+ resolveContexts[ i ] = this;
+ resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
+ if ( !( --remaining ) ) {
+ primary.resolveWith( resolveContexts, resolveValues );
+ }
+ };
+ };
+
+ // Single- and empty arguments are adopted like Promise.resolve
+ if ( remaining <= 1 ) {
+ adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,
+ !remaining );
+
+ // Use .then() to unwrap secondary thenables (cf. gh-3000)
+ if ( primary.state() === "pending" ||
+ isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
+
+ return primary.then();
+ }
+ }
+
+ // Multiple arguments are aggregated like Promise.all array elements
+ while ( i-- ) {
+ adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );
+ }
+
+ return primary.promise();
+ }
+} );
+
+
+// These usually indicate a programmer mistake during development,
+// warn about them ASAP rather than swallowing them by default.
+var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
+
+jQuery.Deferred.exceptionHook = function( error, stack ) {
+
+ // Support: IE 8 - 9 only
+ // Console exists when dev tools are open, which can happen at any time
+ if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
+ window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
+ }
+};
+
+
+
+
+jQuery.readyException = function( error ) {
+ window.setTimeout( function() {
+ throw error;
+ } );
+};
+
+
+
+
+// The deferred used on DOM ready
+var readyList = jQuery.Deferred();
+
+jQuery.fn.ready = function( fn ) {
+
+ readyList
+ .then( fn )
+
+ // Wrap jQuery.readyException in a function so that the lookup
+ // happens at the time of error handling instead of callback
+ // registration.
+ .catch( function( error ) {
+ jQuery.readyException( error );
+ } );
+
+ return this;
+};
+
+jQuery.extend( {
+
+ // Is the DOM ready to be used? Set to true once it occurs.
+ isReady: false,
+
+ // A counter to track how many items to wait for before
+ // the ready event fires. See #6781
+ readyWait: 1,
+
+ // Handle when the DOM is ready
+ ready: function( wait ) {
+
+ // Abort if there are pending holds or we're already ready
+ if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
+ return;
+ }
+
+ // Remember that the DOM is ready
+ jQuery.isReady = true;
+
+ // If a normal DOM Ready event fired, decrement, and wait if need be
+ if ( wait !== true && --jQuery.readyWait > 0 ) {
+ return;
+ }
+
+ // If there are functions bound, to execute
+ readyList.resolveWith( document, [ jQuery ] );
+ }
+} );
+
+jQuery.ready.then = readyList.then;
+
+// The ready event handler and self cleanup method
+function completed() {
+ document.removeEventListener( "DOMContentLoaded", completed );
+ window.removeEventListener( "load", completed );
+ jQuery.ready();
+}
+
+// Catch cases where $(document).ready() is called
+// after the browser event has already occurred.
+// Support: IE <=9 - 10 only
+// Older IE sometimes signals "interactive" too soon
+if ( document.readyState === "complete" ||
+ ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
+
+ // Handle it asynchronously to allow scripts the opportunity to delay ready
+ window.setTimeout( jQuery.ready );
+
+} else {
+
+ // Use the handy event callback
+ document.addEventListener( "DOMContentLoaded", completed );
+
+ // A fallback to window.onload, that will always work
+ window.addEventListener( "load", completed );
+}
+
+
+
+
+// Multifunctional method to get and set values of a collection
+// The value/s can optionally be executed if it's a function
+var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
+ var i = 0,
+ len = elems.length,
+ bulk = key == null;
+
+ // Sets many values
+ if ( toType( key ) === "object" ) {
+ chainable = true;
+ for ( i in key ) {
+ access( elems, fn, i, key[ i ], true, emptyGet, raw );
+ }
+
+ // Sets one value
+ } else if ( value !== undefined ) {
+ chainable = true;
+
+ if ( !isFunction( value ) ) {
+ raw = true;
+ }
+
+ if ( bulk ) {
+
+ // Bulk operations run against the entire set
+ if ( raw ) {
+ fn.call( elems, value );
+ fn = null;
+
+ // ...except when executing function values
+ } else {
+ bulk = fn;
+ fn = function( elem, _key, value ) {
+ return bulk.call( jQuery( elem ), value );
+ };
+ }
+ }
+
+ if ( fn ) {
+ for ( ; i < len; i++ ) {
+ fn(
+ elems[ i ], key, raw ?
+ value :
+ value.call( elems[ i ], i, fn( elems[ i ], key ) )
+ );
+ }
+ }
+ }
+
+ if ( chainable ) {
+ return elems;
+ }
+
+ // Gets
+ if ( bulk ) {
+ return fn.call( elems );
+ }
+
+ return len ? fn( elems[ 0 ], key ) : emptyGet;
+};
+
+
+// Matches dashed string for camelizing
+var rmsPrefix = /^-ms-/,
+ rdashAlpha = /-([a-z])/g;
+
+// Used by camelCase as callback to replace()
+function fcamelCase( _all, letter ) {
+ return letter.toUpperCase();
+}
+
+// Convert dashed to camelCase; used by the css and data modules
+// Support: IE <=9 - 11, Edge 12 - 15
+// Microsoft forgot to hump their vendor prefix (#9572)
+function camelCase( string ) {
+ return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+}
+var acceptData = function( owner ) {
+
+ // Accepts only:
+ // - Node
+ // - Node.ELEMENT_NODE
+ // - Node.DOCUMENT_NODE
+ // - Object
+ // - Any
+ return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
+};
+
+
+
+
+function Data() {
+ this.expando = jQuery.expando + Data.uid++;
+}
+
+Data.uid = 1;
+
+Data.prototype = {
+
+ cache: function( owner ) {
+
+ // Check if the owner object already has a cache
+ var value = owner[ this.expando ];
+
+ // If not, create one
+ if ( !value ) {
+ value = {};
+
+ // We can accept data for non-element nodes in modern browsers,
+ // but we should not, see #8335.
+ // Always return an empty object.
+ if ( acceptData( owner ) ) {
+
+ // If it is a node unlikely to be stringify-ed or looped over
+ // use plain assignment
+ if ( owner.nodeType ) {
+ owner[ this.expando ] = value;
+
+ // Otherwise secure it in a non-enumerable property
+ // configurable must be true to allow the property to be
+ // deleted when data is removed
+ } else {
+ Object.defineProperty( owner, this.expando, {
+ value: value,
+ configurable: true
+ } );
+ }
+ }
+ }
+
+ return value;
+ },
+ set: function( owner, data, value ) {
+ var prop,
+ cache = this.cache( owner );
+
+ // Handle: [ owner, key, value ] args
+ // Always use camelCase key (gh-2257)
+ if ( typeof data === "string" ) {
+ cache[ camelCase( data ) ] = value;
+
+ // Handle: [ owner, { properties } ] args
+ } else {
+
+ // Copy the properties one-by-one to the cache object
+ for ( prop in data ) {
+ cache[ camelCase( prop ) ] = data[ prop ];
+ }
+ }
+ return cache;
+ },
+ get: function( owner, key ) {
+ return key === undefined ?
+ this.cache( owner ) :
+
+ // Always use camelCase key (gh-2257)
+ owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
+ },
+ access: function( owner, key, value ) {
+
+ // In cases where either:
+ //
+ // 1. No key was specified
+ // 2. A string key was specified, but no value provided
+ //
+ // Take the "read" path and allow the get method to determine
+ // which value to return, respectively either:
+ //
+ // 1. The entire cache object
+ // 2. The data stored at the key
+ //
+ if ( key === undefined ||
+ ( ( key && typeof key === "string" ) && value === undefined ) ) {
+
+ return this.get( owner, key );
+ }
+
+ // When the key is not a string, or both a key and value
+ // are specified, set or extend (existing objects) with either:
+ //
+ // 1. An object of properties
+ // 2. A key and value
+ //
+ this.set( owner, key, value );
+
+ // Since the "set" path can have two possible entry points
+ // return the expected data based on which path was taken[*]
+ return value !== undefined ? value : key;
+ },
+ remove: function( owner, key ) {
+ var i,
+ cache = owner[ this.expando ];
+
+ if ( cache === undefined ) {
+ return;
+ }
+
+ if ( key !== undefined ) {
+
+ // Support array or space separated string of keys
+ if ( Array.isArray( key ) ) {
+
+ // If key is an array of keys...
+ // We always set camelCase keys, so remove that.
+ key = key.map( camelCase );
+ } else {
+ key = camelCase( key );
+
+ // If a key with the spaces exists, use it.
+ // Otherwise, create an array by matching non-whitespace
+ key = key in cache ?
+ [ key ] :
+ ( key.match( rnothtmlwhite ) || [] );
+ }
+
+ i = key.length;
+
+ while ( i-- ) {
+ delete cache[ key[ i ] ];
+ }
+ }
+
+ // Remove the expando if there's no more data
+ if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
+
+ // Support: Chrome <=35 - 45
+ // Webkit & Blink performance suffers when deleting properties
+ // from DOM nodes, so set to undefined instead
+ // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
+ if ( owner.nodeType ) {
+ owner[ this.expando ] = undefined;
+ } else {
+ delete owner[ this.expando ];
+ }
+ }
+ },
+ hasData: function( owner ) {
+ var cache = owner[ this.expando ];
+ return cache !== undefined && !jQuery.isEmptyObject( cache );
+ }
+};
+var dataPriv = new Data();
+
+var dataUser = new Data();
+
+
+
+// Implementation Summary
+//
+// 1. Enforce API surface and semantic compatibility with 1.9.x branch
+// 2. Improve the module's maintainability by reducing the storage
+// paths to a single mechanism.
+// 3. Use the same single mechanism to support "private" and "user" data.
+// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
+// 5. Avoid exposing implementation details on user objects (eg. expando properties)
+// 6. Provide a clear path for implementation upgrade to WeakMap in 2014
+
+var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
+ rmultiDash = /[A-Z]/g;
+
+function getData( data ) {
+ if ( data === "true" ) {
+ return true;
+ }
+
+ if ( data === "false" ) {
+ return false;
+ }
+
+ if ( data === "null" ) {
+ return null;
+ }
+
+ // Only convert to a number if it doesn't change the string
+ if ( data === +data + "" ) {
+ return +data;
+ }
+
+ if ( rbrace.test( data ) ) {
+ return JSON.parse( data );
+ }
+
+ return data;
+}
+
+function dataAttr( elem, key, data ) {
+ var name;
+
+ // If nothing was found internally, try to fetch any
+ // data from the HTML5 data-* attribute
+ if ( data === undefined && elem.nodeType === 1 ) {
+ name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
+ data = elem.getAttribute( name );
+
+ if ( typeof data === "string" ) {
+ try {
+ data = getData( data );
+ } catch ( e ) {}
+
+ // Make sure we set the data so it isn't changed later
+ dataUser.set( elem, key, data );
+ } else {
+ data = undefined;
+ }
+ }
+ return data;
+}
+
+jQuery.extend( {
+ hasData: function( elem ) {
+ return dataUser.hasData( elem ) || dataPriv.hasData( elem );
+ },
+
+ data: function( elem, name, data ) {
+ return dataUser.access( elem, name, data );
+ },
+
+ removeData: function( elem, name ) {
+ dataUser.remove( elem, name );
+ },
+
+ // TODO: Now that all calls to _data and _removeData have been replaced
+ // with direct calls to dataPriv methods, these can be deprecated.
+ _data: function( elem, name, data ) {
+ return dataPriv.access( elem, name, data );
+ },
+
+ _removeData: function( elem, name ) {
+ dataPriv.remove( elem, name );
+ }
+} );
+
+jQuery.fn.extend( {
+ data: function( key, value ) {
+ var i, name, data,
+ elem = this[ 0 ],
+ attrs = elem && elem.attributes;
+
+ // Gets all values
+ if ( key === undefined ) {
+ if ( this.length ) {
+ data = dataUser.get( elem );
+
+ if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
+ i = attrs.length;
+ while ( i-- ) {
+
+ // Support: IE 11 only
+ // The attrs elements can be null (#14894)
+ if ( attrs[ i ] ) {
+ name = attrs[ i ].name;
+ if ( name.indexOf( "data-" ) === 0 ) {
+ name = camelCase( name.slice( 5 ) );
+ dataAttr( elem, name, data[ name ] );
+ }
+ }
+ }
+ dataPriv.set( elem, "hasDataAttrs", true );
+ }
+ }
+
+ return data;
+ }
+
+ // Sets multiple values
+ if ( typeof key === "object" ) {
+ return this.each( function() {
+ dataUser.set( this, key );
+ } );
+ }
+
+ return access( this, function( value ) {
+ var data;
+
+ // The calling jQuery object (element matches) is not empty
+ // (and therefore has an element appears at this[ 0 ]) and the
+ // `value` parameter was not undefined. An empty jQuery object
+ // will result in `undefined` for elem = this[ 0 ] which will
+ // throw an exception if an attempt to read a data cache is made.
+ if ( elem && value === undefined ) {
+
+ // Attempt to get data from the cache
+ // The key will always be camelCased in Data
+ data = dataUser.get( elem, key );
+ if ( data !== undefined ) {
+ return data;
+ }
+
+ // Attempt to "discover" the data in
+ // HTML5 custom data-* attrs
+ data = dataAttr( elem, key );
+ if ( data !== undefined ) {
+ return data;
+ }
+
+ // We tried really hard, but the data doesn't exist.
+ return;
+ }
+
+ // Set the data...
+ this.each( function() {
+
+ // We always store the camelCased key
+ dataUser.set( this, key, value );
+ } );
+ }, null, value, arguments.length > 1, null, true );
+ },
+
+ removeData: function( key ) {
+ return this.each( function() {
+ dataUser.remove( this, key );
+ } );
+ }
+} );
+
+
+jQuery.extend( {
+ queue: function( elem, type, data ) {
+ var queue;
+
+ if ( elem ) {
+ type = ( type || "fx" ) + "queue";
+ queue = dataPriv.get( elem, type );
+
+ // Speed up dequeue by getting out quickly if this is just a lookup
+ if ( data ) {
+ if ( !queue || Array.isArray( data ) ) {
+ queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
+ } else {
+ queue.push( data );
+ }
+ }
+ return queue || [];
+ }
+ },
+
+ dequeue: function( elem, type ) {
+ type = type || "fx";
+
+ var queue = jQuery.queue( elem, type ),
+ startLength = queue.length,
+ fn = queue.shift(),
+ hooks = jQuery._queueHooks( elem, type ),
+ next = function() {
+ jQuery.dequeue( elem, type );
+ };
+
+ // If the fx queue is dequeued, always remove the progress sentinel
+ if ( fn === "inprogress" ) {
+ fn = queue.shift();
+ startLength--;
+ }
+
+ if ( fn ) {
+
+ // Add a progress sentinel to prevent the fx queue from being
+ // automatically dequeued
+ if ( type === "fx" ) {
+ queue.unshift( "inprogress" );
+ }
+
+ // Clear up the last queue stop function
+ delete hooks.stop;
+ fn.call( elem, next, hooks );
+ }
+
+ if ( !startLength && hooks ) {
+ hooks.empty.fire();
+ }
+ },
+
+ // Not public - generate a queueHooks object, or return the current one
+ _queueHooks: function( elem, type ) {
+ var key = type + "queueHooks";
+ return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
+ empty: jQuery.Callbacks( "once memory" ).add( function() {
+ dataPriv.remove( elem, [ type + "queue", key ] );
+ } )
+ } );
+ }
+} );
+
+jQuery.fn.extend( {
+ queue: function( type, data ) {
+ var setter = 2;
+
+ if ( typeof type !== "string" ) {
+ data = type;
+ type = "fx";
+ setter--;
+ }
+
+ if ( arguments.length < setter ) {
+ return jQuery.queue( this[ 0 ], type );
+ }
+
+ return data === undefined ?
+ this :
+ this.each( function() {
+ var queue = jQuery.queue( this, type, data );
+
+ // Ensure a hooks for this queue
+ jQuery._queueHooks( this, type );
+
+ if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
+ jQuery.dequeue( this, type );
+ }
+ } );
+ },
+ dequeue: function( type ) {
+ return this.each( function() {
+ jQuery.dequeue( this, type );
+ } );
+ },
+ clearQueue: function( type ) {
+ return this.queue( type || "fx", [] );
+ },
+
+ // Get a promise resolved when queues of a certain type
+ // are emptied (fx is the type by default)
+ promise: function( type, obj ) {
+ var tmp,
+ count = 1,
+ defer = jQuery.Deferred(),
+ elements = this,
+ i = this.length,
+ resolve = function() {
+ if ( !( --count ) ) {
+ defer.resolveWith( elements, [ elements ] );
+ }
+ };
+
+ if ( typeof type !== "string" ) {
+ obj = type;
+ type = undefined;
+ }
+ type = type || "fx";
+
+ while ( i-- ) {
+ tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
+ if ( tmp && tmp.empty ) {
+ count++;
+ tmp.empty.add( resolve );
+ }
+ }
+ resolve();
+ return defer.promise( obj );
+ }
+} );
+var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
+
+var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
+
+
+var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
+
+var documentElement = document.documentElement;
+
+
+
+ var isAttached = function( elem ) {
+ return jQuery.contains( elem.ownerDocument, elem );
+ },
+ composed = { composed: true };
+
+ // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
+ // Check attachment across shadow DOM boundaries when possible (gh-3504)
+ // Support: iOS 10.0-10.2 only
+ // Early iOS 10 versions support `attachShadow` but not `getRootNode`,
+ // leading to errors. We need to check for `getRootNode`.
+ if ( documentElement.getRootNode ) {
+ isAttached = function( elem ) {
+ return jQuery.contains( elem.ownerDocument, elem ) ||
+ elem.getRootNode( composed ) === elem.ownerDocument;
+ };
+ }
+var isHiddenWithinTree = function( elem, el ) {
+
+ // isHiddenWithinTree might be called from jQuery#filter function;
+ // in that case, element will be second argument
+ elem = el || elem;
+
+ // Inline style trumps all
+ return elem.style.display === "none" ||
+ elem.style.display === "" &&
+
+ // Otherwise, check computed style
+ // Support: Firefox <=43 - 45
+ // Disconnected elements can have computed display: none, so first confirm that elem is
+ // in the document.
+ isAttached( elem ) &&
+
+ jQuery.css( elem, "display" ) === "none";
+ };
+
+
+
+function adjustCSS( elem, prop, valueParts, tween ) {
+ var adjusted, scale,
+ maxIterations = 20,
+ currentValue = tween ?
+ function() {
+ return tween.cur();
+ } :
+ function() {
+ return jQuery.css( elem, prop, "" );
+ },
+ initial = currentValue(),
+ unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
+
+ // Starting value computation is required for potential unit mismatches
+ initialInUnit = elem.nodeType &&
+ ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
+ rcssNum.exec( jQuery.css( elem, prop ) );
+
+ if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
+
+ // Support: Firefox <=54
+ // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
+ initial = initial / 2;
+
+ // Trust units reported by jQuery.css
+ unit = unit || initialInUnit[ 3 ];
+
+ // Iteratively approximate from a nonzero starting point
+ initialInUnit = +initial || 1;
+
+ while ( maxIterations-- ) {
+
+ // Evaluate and update our best guess (doubling guesses that zero out).
+ // Finish if the scale equals or crosses 1 (making the old*new product non-positive).
+ jQuery.style( elem, prop, initialInUnit + unit );
+ if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
+ maxIterations = 0;
+ }
+ initialInUnit = initialInUnit / scale;
+
+ }
+
+ initialInUnit = initialInUnit * 2;
+ jQuery.style( elem, prop, initialInUnit + unit );
+
+ // Make sure we update the tween properties later on
+ valueParts = valueParts || [];
+ }
+
+ if ( valueParts ) {
+ initialInUnit = +initialInUnit || +initial || 0;
+
+ // Apply relative offset (+=/-=) if specified
+ adjusted = valueParts[ 1 ] ?
+ initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
+ +valueParts[ 2 ];
+ if ( tween ) {
+ tween.unit = unit;
+ tween.start = initialInUnit;
+ tween.end = adjusted;
+ }
+ }
+ return adjusted;
+}
+
+
+var defaultDisplayMap = {};
+
+function getDefaultDisplay( elem ) {
+ var temp,
+ doc = elem.ownerDocument,
+ nodeName = elem.nodeName,
+ display = defaultDisplayMap[ nodeName ];
+
+ if ( display ) {
+ return display;
+ }
+
+ temp = doc.body.appendChild( doc.createElement( nodeName ) );
+ display = jQuery.css( temp, "display" );
+
+ temp.parentNode.removeChild( temp );
+
+ if ( display === "none" ) {
+ display = "block";
+ }
+ defaultDisplayMap[ nodeName ] = display;
+
+ return display;
+}
+
+function showHide( elements, show ) {
+ var display, elem,
+ values = [],
+ index = 0,
+ length = elements.length;
+
+ // Determine new display value for elements that need to change
+ for ( ; index < length; index++ ) {
+ elem = elements[ index ];
+ if ( !elem.style ) {
+ continue;
+ }
+
+ display = elem.style.display;
+ if ( show ) {
+
+ // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
+ // check is required in this first loop unless we have a nonempty display value (either
+ // inline or about-to-be-restored)
+ if ( display === "none" ) {
+ values[ index ] = dataPriv.get( elem, "display" ) || null;
+ if ( !values[ index ] ) {
+ elem.style.display = "";
+ }
+ }
+ if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
+ values[ index ] = getDefaultDisplay( elem );
+ }
+ } else {
+ if ( display !== "none" ) {
+ values[ index ] = "none";
+
+ // Remember what we're overwriting
+ dataPriv.set( elem, "display", display );
+ }
+ }
+ }
+
+ // Set the display of the elements in a second loop to avoid constant reflow
+ for ( index = 0; index < length; index++ ) {
+ if ( values[ index ] != null ) {
+ elements[ index ].style.display = values[ index ];
+ }
+ }
+
+ return elements;
+}
+
+jQuery.fn.extend( {
+ show: function() {
+ return showHide( this, true );
+ },
+ hide: function() {
+ return showHide( this );
+ },
+ toggle: function( state ) {
+ if ( typeof state === "boolean" ) {
+ return state ? this.show() : this.hide();
+ }
+
+ return this.each( function() {
+ if ( isHiddenWithinTree( this ) ) {
+ jQuery( this ).show();
+ } else {
+ jQuery( this ).hide();
+ }
+ } );
+ }
+} );
+var rcheckableType = ( /^(?:checkbox|radio)$/i );
+
+var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
+
+var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
+
+
+
+( function() {
+ var fragment = document.createDocumentFragment(),
+ div = fragment.appendChild( document.createElement( "div" ) ),
+ input = document.createElement( "input" );
+
+ // Support: Android 4.0 - 4.3 only
+ // Check state lost if the name is set (#11217)
+ // Support: Windows Web Apps (WWA)
+ // `name` and `type` must use .setAttribute for WWA (#14901)
+ input.setAttribute( "type", "radio" );
+ input.setAttribute( "checked", "checked" );
+ input.setAttribute( "name", "t" );
+
+ div.appendChild( input );
+
+ // Support: Android <=4.1 only
+ // Older WebKit doesn't clone checked state correctly in fragments
+ support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+ // Support: IE <=11 only
+ // Make sure textarea (and checkbox) defaultValue is properly cloned
+ div.innerHTML = "<textarea>x</textarea>";
+ support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
+
+ // Support: IE <=9 only
+ // IE <=9 replaces <option> tags with their contents when inserted outside of
+ // the select element.
+ div.innerHTML = "<option></option>";
+ support.option = !!div.lastChild;
+} )();
+
+
+// We have to close these tags to support XHTML (#13200)
+var wrapMap = {
+
+ // XHTML parsers do not magically insert elements in the
+ // same way that tag soup parsers do. So we cannot shorten
+ // this by omitting <tbody> or other required elements.
+ thead: [ 1, "<table>", "</table>" ],
+ col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
+ tr: [ 2, "<table><tbody>", "</tbody></table>" ],
+ td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
+
+ _default: [ 0, "", "" ]
+};
+
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+// Support: IE <=9 only
+if ( !support.option ) {
+ wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ];
+}
+
+
+function getAll( context, tag ) {
+
+ // Support: IE <=9 - 11 only
+ // Use typeof to avoid zero-argument method invocation on host objects (#15151)
+ var ret;
+
+ if ( typeof context.getElementsByTagName !== "undefined" ) {
+ ret = context.getElementsByTagName( tag || "*" );
+
+ } else if ( typeof context.querySelectorAll !== "undefined" ) {
+ ret = context.querySelectorAll( tag || "*" );
+
+ } else {
+ ret = [];
+ }
+
+ if ( tag === undefined || tag && nodeName( context, tag ) ) {
+ return jQuery.merge( [ context ], ret );
+ }
+
+ return ret;
+}
+
+
+// Mark scripts as having already been evaluated
+function setGlobalEval( elems, refElements ) {
+ var i = 0,
+ l = elems.length;
+
+ for ( ; i < l; i++ ) {
+ dataPriv.set(
+ elems[ i ],
+ "globalEval",
+ !refElements || dataPriv.get( refElements[ i ], "globalEval" )
+ );
+ }
+}
+
+
+var rhtml = /<|&#?\w+;/;
+
+function buildFragment( elems, context, scripts, selection, ignored ) {
+ var elem, tmp, tag, wrap, attached, j,
+ fragment = context.createDocumentFragment(),
+ nodes = [],
+ i = 0,
+ l = elems.length;
+
+ for ( ; i < l; i++ ) {
+ elem = elems[ i ];
+
+ if ( elem || elem === 0 ) {
+
+ // Add nodes directly
+ if ( toType( elem ) === "object" ) {
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
+
+ // Convert non-html into a text node
+ } else if ( !rhtml.test( elem ) ) {
+ nodes.push( context.createTextNode( elem ) );
+
+ // Convert html into DOM nodes
+ } else {
+ tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
+
+ // Deserialize a standard representation
+ tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
+ wrap = wrapMap[ tag ] || wrapMap._default;
+ tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
+
+ // Descend through wrappers to the right content
+ j = wrap[ 0 ];
+ while ( j-- ) {
+ tmp = tmp.lastChild;
+ }
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge( nodes, tmp.childNodes );
+
+ // Remember the top-level container
+ tmp = fragment.firstChild;
+
+ // Ensure the created nodes are orphaned (#12392)
+ tmp.textContent = "";
+ }
+ }
+ }
+
+ // Remove wrapper from fragment
+ fragment.textContent = "";
+
+ i = 0;
+ while ( ( elem = nodes[ i++ ] ) ) {
+
+ // Skip elements already in the context collection (trac-4087)
+ if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
+ if ( ignored ) {
+ ignored.push( elem );
+ }
+ continue;
+ }
+
+ attached = isAttached( elem );
+
+ // Append to fragment
+ tmp = getAll( fragment.appendChild( elem ), "script" );
+
+ // Preserve script evaluation history
+ if ( attached ) {
+ setGlobalEval( tmp );
+ }
+
+ // Capture executables
+ if ( scripts ) {
+ j = 0;
+ while ( ( elem = tmp[ j++ ] ) ) {
+ if ( rscriptType.test( elem.type || "" ) ) {
+ scripts.push( elem );
+ }
+ }
+ }
+ }
+
+ return fragment;
+}
+
+
+var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
+
+function returnTrue() {
+ return true;
+}
+
+function returnFalse() {
+ return false;
+}
+
+// Support: IE <=9 - 11+
+// focus() and blur() are asynchronous, except when they are no-op.
+// So expect focus to be synchronous when the element is already active,
+// and blur to be synchronous when the element is not already active.
+// (focus and blur are always synchronous in other supported browsers,
+// this just defines when we can count on it).
+function expectSync( elem, type ) {
+ return ( elem === safeActiveElement() ) === ( type === "focus" );
+}
+
+// Support: IE <=9 only
+// Accessing document.activeElement can throw unexpectedly
+// https://bugs.jquery.com/ticket/13393
+function safeActiveElement() {
+ try {
+ return document.activeElement;
+ } catch ( err ) { }
+}
+
+function on( elem, types, selector, data, fn, one ) {
+ var origFn, type;
+
+ // Types can be a map of types/handlers
+ if ( typeof types === "object" ) {
+
+ // ( types-Object, selector, data )
+ if ( typeof selector !== "string" ) {
+
+ // ( types-Object, data )
+ data = data || selector;
+ selector = undefined;
+ }
+ for ( type in types ) {
+ on( elem, type, selector, data, types[ type ], one );
+ }
+ return elem;
+ }
+
+ if ( data == null && fn == null ) {
+
+ // ( types, fn )
+ fn = selector;
+ data = selector = undefined;
+ } else if ( fn == null ) {
+ if ( typeof selector === "string" ) {
+
+ // ( types, selector, fn )
+ fn = data;
+ data = undefined;
+ } else {
+
+ // ( types, data, fn )
+ fn = data;
+ data = selector;
+ selector = undefined;
+ }
+ }
+ if ( fn === false ) {
+ fn = returnFalse;
+ } else if ( !fn ) {
+ return elem;
+ }
+
+ if ( one === 1 ) {
+ origFn = fn;
+ fn = function( event ) {
+
+ // Can use an empty set, since event contains the info
+ jQuery().off( event );
+ return origFn.apply( this, arguments );
+ };
+
+ // Use same guid so caller can remove using origFn
+ fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
+ }
+ return elem.each( function() {
+ jQuery.event.add( this, types, fn, data, selector );
+ } );
+}
+
+/*
+ * Helper functions for managing events -- not part of the public interface.
+ * Props to Dean Edwards' addEvent library for many of the ideas.
+ */
+jQuery.event = {
+
+ global: {},
+
+ add: function( elem, types, handler, data, selector ) {
+
+ var handleObjIn, eventHandle, tmp,
+ events, t, handleObj,
+ special, handlers, type, namespaces, origType,
+ elemData = dataPriv.get( elem );
+
+ // Only attach events to objects that accept data
+ if ( !acceptData( elem ) ) {
+ return;
+ }
+
+ // Caller can pass in an object of custom data in lieu of the handler
+ if ( handler.handler ) {
+ handleObjIn = handler;
+ handler = handleObjIn.handler;
+ selector = handleObjIn.selector;
+ }
+
+ // Ensure that invalid selectors throw exceptions at attach time
+ // Evaluate against documentElement in case elem is a non-element node (e.g., document)
+ if ( selector ) {
+ jQuery.find.matchesSelector( documentElement, selector );
+ }
+
+ // Make sure that the handler has a unique ID, used to find/remove it later
+ if ( !handler.guid ) {
+ handler.guid = jQuery.guid++;
+ }
+
+ // Init the element's event structure and main handler, if this is the first
+ if ( !( events = elemData.events ) ) {
+ events = elemData.events = Object.create( null );
+ }
+ if ( !( eventHandle = elemData.handle ) ) {
+ eventHandle = elemData.handle = function( e ) {
+
+ // Discard the second event of a jQuery.event.trigger() and
+ // when an event is called after a page has unloaded
+ return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
+ jQuery.event.dispatch.apply( elem, arguments ) : undefined;
+ };
+ }
+
+ // Handle multiple events separated by a space
+ types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
+ t = types.length;
+ while ( t-- ) {
+ tmp = rtypenamespace.exec( types[ t ] ) || [];
+ type = origType = tmp[ 1 ];
+ namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
+
+ // There *must* be a type, no attaching namespace-only handlers
+ if ( !type ) {
+ continue;
+ }
+
+ // If event changes its type, use the special event handlers for the changed type
+ special = jQuery.event.special[ type ] || {};
+
+ // If selector defined, determine special event api type, otherwise given type
+ type = ( selector ? special.delegateType : special.bindType ) || type;
+
+ // Update special based on newly reset type
+ special = jQuery.event.special[ type ] || {};
+
+ // handleObj is passed to all event handlers
+ handleObj = jQuery.extend( {
+ type: type,
+ origType: origType,
+ data: data,
+ handler: handler,
+ guid: handler.guid,
+ selector: selector,
+ needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
+ namespace: namespaces.join( "." )
+ }, handleObjIn );
+
+ // Init the event handler queue if we're the first
+ if ( !( handlers = events[ type ] ) ) {
+ handlers = events[ type ] = [];
+ handlers.delegateCount = 0;
+
+ // Only use addEventListener if the special events handler returns false
+ if ( !special.setup ||
+ special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+
+ if ( elem.addEventListener ) {
+ elem.addEventListener( type, eventHandle );
+ }
+ }
+ }
+
+ if ( special.add ) {
+ special.add.call( elem, handleObj );
+
+ if ( !handleObj.handler.guid ) {
+ handleObj.handler.guid = handler.guid;
+ }
+ }
+
+ // Add to the element's handler list, delegates in front
+ if ( selector ) {
+ handlers.splice( handlers.delegateCount++, 0, handleObj );
+ } else {
+ handlers.push( handleObj );
+ }
+
+ // Keep track of which events have ever been used, for event optimization
+ jQuery.event.global[ type ] = true;
+ }
+
+ },
+
+ // Detach an event or set of events from an element
+ remove: function( elem, types, handler, selector, mappedTypes ) {
+
+ var j, origCount, tmp,
+ events, t, handleObj,
+ special, handlers, type, namespaces, origType,
+ elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
+
+ if ( !elemData || !( events = elemData.events ) ) {
+ return;
+ }
+
+ // Once for each type.namespace in types; type may be omitted
+ types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
+ t = types.length;
+ while ( t-- ) {
+ tmp = rtypenamespace.exec( types[ t ] ) || [];
+ type = origType = tmp[ 1 ];
+ namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
+
+ // Unbind all events (on this namespace, if provided) for the element
+ if ( !type ) {
+ for ( type in events ) {
+ jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
+ }
+ continue;
+ }
+
+ special = jQuery.event.special[ type ] || {};
+ type = ( selector ? special.delegateType : special.bindType ) || type;
+ handlers = events[ type ] || [];
+ tmp = tmp[ 2 ] &&
+ new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
+
+ // Remove matching events
+ origCount = j = handlers.length;
+ while ( j-- ) {
+ handleObj = handlers[ j ];
+
+ if ( ( mappedTypes || origType === handleObj.origType ) &&
+ ( !handler || handler.guid === handleObj.guid ) &&
+ ( !tmp || tmp.test( handleObj.namespace ) ) &&
+ ( !selector || selector === handleObj.selector ||
+ selector === "**" && handleObj.selector ) ) {
+ handlers.splice( j, 1 );
+
+ if ( handleObj.selector ) {
+ handlers.delegateCount--;
+ }
+ if ( special.remove ) {
+ special.remove.call( elem, handleObj );
+ }
+ }
+ }
+
+ // Remove generic event handler if we removed something and no more handlers exist
+ // (avoids potential for endless recursion during removal of special event handlers)
+ if ( origCount && !handlers.length ) {
+ if ( !special.teardown ||
+ special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
+
+ jQuery.removeEvent( elem, type, elemData.handle );
+ }
+
+ delete events[ type ];
+ }
+ }
+
+ // Remove data and the expando if it's no longer used
+ if ( jQuery.isEmptyObject( events ) ) {
+ dataPriv.remove( elem, "handle events" );
+ }
+ },
+
+ dispatch: function( nativeEvent ) {
+
+ var i, j, ret, matched, handleObj, handlerQueue,
+ args = new Array( arguments.length ),
+
+ // Make a writable jQuery.Event from the native event object
+ event = jQuery.event.fix( nativeEvent ),
+
+ handlers = (
+ dataPriv.get( this, "events" ) || Object.create( null )
+ )[ event.type ] || [],
+ special = jQuery.event.special[ event.type ] || {};
+
+ // Use the fix-ed jQuery.Event rather than the (read-only) native event
+ args[ 0 ] = event;
+
+ for ( i = 1; i < arguments.length; i++ ) {
+ args[ i ] = arguments[ i ];
+ }
+
+ event.delegateTarget = this;
+
+ // Call the preDispatch hook for the mapped type, and let it bail if desired
+ if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
+ return;
+ }
+
+ // Determine handlers
+ handlerQueue = jQuery.event.handlers.call( this, event, handlers );
+
+ // Run delegates first; they may want to stop propagation beneath us
+ i = 0;
+ while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
+ event.currentTarget = matched.elem;
+
+ j = 0;
+ while ( ( handleObj = matched.handlers[ j++ ] ) &&
+ !event.isImmediatePropagationStopped() ) {
+
+ // If the event is namespaced, then each handler is only invoked if it is
+ // specially universal or its namespaces are a superset of the event's.
+ if ( !event.rnamespace || handleObj.namespace === false ||
+ event.rnamespace.test( handleObj.namespace ) ) {
+
+ event.handleObj = handleObj;
+ event.data = handleObj.data;
+
+ ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
+ handleObj.handler ).apply( matched.elem, args );
+
+ if ( ret !== undefined ) {
+ if ( ( event.result = ret ) === false ) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ }
+ }
+ }
+ }
+
+ // Call the postDispatch hook for the mapped type
+ if ( special.postDispatch ) {
+ special.postDispatch.call( this, event );
+ }
+
+ return event.result;
+ },
+
+ handlers: function( event, handlers ) {
+ var i, handleObj, sel, matchedHandlers, matchedSelectors,
+ handlerQueue = [],
+ delegateCount = handlers.delegateCount,
+ cur = event.target;
+
+ // Find delegate handlers
+ if ( delegateCount &&
+
+ // Support: IE <=9
+ // Black-hole SVG <use> instance trees (trac-13180)
+ cur.nodeType &&
+
+ // Support: Firefox <=42
+ // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
+ // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
+ // Support: IE 11 only
+ // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
+ !( event.type === "click" && event.button >= 1 ) ) {
+
+ for ( ; cur !== this; cur = cur.parentNode || this ) {
+
+ // Don't check non-elements (#13208)
+ // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
+ if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
+ matchedHandlers = [];
+ matchedSelectors = {};
+ for ( i = 0; i < delegateCount; i++ ) {
+ handleObj = handlers[ i ];
+
+ // Don't conflict with Object.prototype properties (#13203)
+ sel = handleObj.selector + " ";
+
+ if ( matchedSelectors[ sel ] === undefined ) {
+ matchedSelectors[ sel ] = handleObj.needsContext ?
+ jQuery( sel, this ).index( cur ) > -1 :
+ jQuery.find( sel, this, null, [ cur ] ).length;
+ }
+ if ( matchedSelectors[ sel ] ) {
+ matchedHandlers.push( handleObj );
+ }
+ }
+ if ( matchedHandlers.length ) {
+ handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
+ }
+ }
+ }
+ }
+
+ // Add the remaining (directly-bound) handlers
+ cur = this;
+ if ( delegateCount < handlers.length ) {
+ handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
+ }
+
+ return handlerQueue;
+ },
+
+ addProp: function( name, hook ) {
+ Object.defineProperty( jQuery.Event.prototype, name, {
+ enumerable: true,
+ configurable: true,
+
+ get: isFunction( hook ) ?
+ function() {
+ if ( this.originalEvent ) {
+ return hook( this.originalEvent );
+ }
+ } :
+ function() {
+ if ( this.originalEvent ) {
+ return this.originalEvent[ name ];
+ }
+ },
+
+ set: function( value ) {
+ Object.defineProperty( this, name, {
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ value: value
+ } );
+ }
+ } );
+ },
+
+ fix: function( originalEvent ) {
+ return originalEvent[ jQuery.expando ] ?
+ originalEvent :
+ new jQuery.Event( originalEvent );
+ },
+
+ special: {
+ load: {
+
+ // Prevent triggered image.load events from bubbling to window.load
+ noBubble: true
+ },
+ click: {
+
+ // Utilize native event to ensure correct state for checkable inputs
+ setup: function( data ) {
+
+ // For mutual compressibility with _default, replace `this` access with a local var.
+ // `|| data` is dead code meant only to preserve the variable through minification.
+ var el = this || data;
+
+ // Claim the first handler
+ if ( rcheckableType.test( el.type ) &&
+ el.click && nodeName( el, "input" ) ) {
+
+ // dataPriv.set( el, "click", ... )
+ leverageNative( el, "click", returnTrue );
+ }
+
+ // Return false to allow normal processing in the caller
+ return false;
+ },
+ trigger: function( data ) {
+
+ // For mutual compressibility with _default, replace `this` access with a local var.
+ // `|| data` is dead code meant only to preserve the variable through minification.
+ var el = this || data;
+
+ // Force setup before triggering a click
+ if ( rcheckableType.test( el.type ) &&
+ el.click && nodeName( el, "input" ) ) {
+
+ leverageNative( el, "click" );
+ }
+
+ // Return non-false to allow normal event-path propagation
+ return true;
+ },
+
+ // For cross-browser consistency, suppress native .click() on links
+ // Also prevent it if we're currently inside a leveraged native-event stack
+ _default: function( event ) {
+ var target = event.target;
+ return rcheckableType.test( target.type ) &&
+ target.click && nodeName( target, "input" ) &&
+ dataPriv.get( target, "click" ) ||
+ nodeName( target, "a" );
+ }
+ },
+
+ beforeunload: {
+ postDispatch: function( event ) {
+
+ // Support: Firefox 20+
+ // Firefox doesn't alert if the returnValue field is not set.
+ if ( event.result !== undefined && event.originalEvent ) {
+ event.originalEvent.returnValue = event.result;
+ }
+ }
+ }
+ }
+};
+
+// Ensure the presence of an event listener that handles manually-triggered
+// synthetic events by interrupting progress until reinvoked in response to
+// *native* events that it fires directly, ensuring that state changes have
+// already occurred before other listeners are invoked.
+function leverageNative( el, type, expectSync ) {
+
+ // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
+ if ( !expectSync ) {
+ if ( dataPriv.get( el, type ) === undefined ) {
+ jQuery.event.add( el, type, returnTrue );
+ }
+ return;
+ }
+
+ // Register the controller as a special universal handler for all event namespaces
+ dataPriv.set( el, type, false );
+ jQuery.event.add( el, type, {
+ namespace: false,
+ handler: function( event ) {
+ var notAsync, result,
+ saved = dataPriv.get( this, type );
+
+ if ( ( event.isTrigger & 1 ) && this[ type ] ) {
+
+ // Interrupt processing of the outer synthetic .trigger()ed event
+ // Saved data should be false in such cases, but might be a leftover capture object
+ // from an async native handler (gh-4350)
+ if ( !saved.length ) {
+
+ // Store arguments for use when handling the inner native event
+ // There will always be at least one argument (an event object), so this array
+ // will not be confused with a leftover capture object.
+ saved = slice.call( arguments );
+ dataPriv.set( this, type, saved );
+
+ // Trigger the native event and capture its result
+ // Support: IE <=9 - 11+
+ // focus() and blur() are asynchronous
+ notAsync = expectSync( this, type );
+ this[ type ]();
+ result = dataPriv.get( this, type );
+ if ( saved !== result || notAsync ) {
+ dataPriv.set( this, type, false );
+ } else {
+ result = {};
+ }
+ if ( saved !== result ) {
+
+ // Cancel the outer synthetic event
+ event.stopImmediatePropagation();
+ event.preventDefault();
+
+ // Support: Chrome 86+
+ // In Chrome, if an element having a focusout handler is blurred by
+ // clicking outside of it, it invokes the handler synchronously. If
+ // that handler calls `.remove()` on the element, the data is cleared,
+ // leaving `result` undefined. We need to guard against this.
+ return result && result.value;
+ }
+
+ // If this is an inner synthetic event for an event with a bubbling surrogate
+ // (focus or blur), assume that the surrogate already propagated from triggering the
+ // native event and prevent that from happening again here.
+ // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
+ // bubbling surrogate propagates *after* the non-bubbling base), but that seems
+ // less bad than duplication.
+ } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
+ event.stopPropagation();
+ }
+
+ // If this is a native event triggered above, everything is now in order
+ // Fire an inner synthetic event with the original arguments
+ } else if ( saved.length ) {
+
+ // ...and capture the result
+ dataPriv.set( this, type, {
+ value: jQuery.event.trigger(
+
+ // Support: IE <=9 - 11+
+ // Extend with the prototype to reset the above stopImmediatePropagation()
+ jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
+ saved.slice( 1 ),
+ this
+ )
+ } );
+
+ // Abort handling of the native event
+ event.stopImmediatePropagation();
+ }
+ }
+ } );
+}
+
+jQuery.removeEvent = function( elem, type, handle ) {
+
+ // This "if" is needed for plain objects
+ if ( elem.removeEventListener ) {
+ elem.removeEventListener( type, handle );
+ }
+};
+
+jQuery.Event = function( src, props ) {
+
+ // Allow instantiation without the 'new' keyword
+ if ( !( this instanceof jQuery.Event ) ) {
+ return new jQuery.Event( src, props );
+ }
+
+ // Event object
+ if ( src && src.type ) {
+ this.originalEvent = src;
+ this.type = src.type;
+
+ // Events bubbling up the document may have been marked as prevented
+ // by a handler lower down the tree; reflect the correct value.
+ this.isDefaultPrevented = src.defaultPrevented ||
+ src.defaultPrevented === undefined &&
+
+ // Support: Android <=2.3 only
+ src.returnValue === false ?
+ returnTrue :
+ returnFalse;
+
+ // Create target properties
+ // Support: Safari <=6 - 7 only
+ // Target should not be a text node (#504, #13143)
+ this.target = ( src.target && src.target.nodeType === 3 ) ?
+ src.target.parentNode :
+ src.target;
+
+ this.currentTarget = src.currentTarget;
+ this.relatedTarget = src.relatedTarget;
+
+ // Event type
+ } else {
+ this.type = src;
+ }
+
+ // Put explicitly provided properties onto the event object
+ if ( props ) {
+ jQuery.extend( this, props );
+ }
+
+ // Create a timestamp if incoming event doesn't have one
+ this.timeStamp = src && src.timeStamp || Date.now();
+
+ // Mark it as fixed
+ this[ jQuery.expando ] = true;
+};
+
+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+jQuery.Event.prototype = {
+ constructor: jQuery.Event,
+ isDefaultPrevented: returnFalse,
+ isPropagationStopped: returnFalse,
+ isImmediatePropagationStopped: returnFalse,
+ isSimulated: false,
+
+ preventDefault: function() {
+ var e = this.originalEvent;
+
+ this.isDefaultPrevented = returnTrue;
+
+ if ( e && !this.isSimulated ) {
+ e.preventDefault();
+ }
+ },
+ stopPropagation: function() {
+ var e = this.originalEvent;
+
+ this.isPropagationStopped = returnTrue;
+
+ if ( e && !this.isSimulated ) {
+ e.stopPropagation();
+ }
+ },
+ stopImmediatePropagation: function() {
+ var e = this.originalEvent;
+
+ this.isImmediatePropagationStopped = returnTrue;
+
+ if ( e && !this.isSimulated ) {
+ e.stopImmediatePropagation();
+ }
+
+ this.stopPropagation();
+ }
+};
+
+// Includes all common event props including KeyEvent and MouseEvent specific props
+jQuery.each( {
+ altKey: true,
+ bubbles: true,
+ cancelable: true,
+ changedTouches: true,
+ ctrlKey: true,
+ detail: true,
+ eventPhase: true,
+ metaKey: true,
+ pageX: true,
+ pageY: true,
+ shiftKey: true,
+ view: true,
+ "char": true,
+ code: true,
+ charCode: true,
+ key: true,
+ keyCode: true,
+ button: true,
+ buttons: true,
+ clientX: true,
+ clientY: true,
+ offsetX: true,
+ offsetY: true,
+ pointerId: true,
+ pointerType: true,
+ screenX: true,
+ screenY: true,
+ targetTouches: true,
+ toElement: true,
+ touches: true,
+ which: true
+}, jQuery.event.addProp );
+
+jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
+ jQuery.event.special[ type ] = {
+
+ // Utilize native event if possible so blur/focus sequence is correct
+ setup: function() {
+
+ // Claim the first handler
+ // dataPriv.set( this, "focus", ... )
+ // dataPriv.set( this, "blur", ... )
+ leverageNative( this, type, expectSync );
+
+ // Return false to allow normal processing in the caller
+ return false;
+ },
+ trigger: function() {
+
+ // Force setup before trigger
+ leverageNative( this, type );
+
+ // Return non-false to allow normal event-path propagation
+ return true;
+ },
+
+ // Suppress native focus or blur as it's already being fired
+ // in leverageNative.
+ _default: function() {
+ return true;
+ },
+
+ delegateType: delegateType
+ };
+} );
+
+// Create mouseenter/leave events using mouseover/out and event-time checks
+// so that event delegation works in jQuery.
+// Do the same for pointerenter/pointerleave and pointerover/pointerout
+//
+// Support: Safari 7 only
+// Safari sends mouseenter too often; see:
+// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
+// for the description of the bug (it existed in older Chrome versions as well).
+jQuery.each( {
+ mouseenter: "mouseover",
+ mouseleave: "mouseout",
+ pointerenter: "pointerover",
+ pointerleave: "pointerout"
+}, function( orig, fix ) {
+ jQuery.event.special[ orig ] = {
+ delegateType: fix,
+ bindType: fix,
+
+ handle: function( event ) {
+ var ret,
+ target = this,
+ related = event.relatedTarget,
+ handleObj = event.handleObj;
+
+ // For mouseenter/leave call the handler if related is outside the target.
+ // NB: No relatedTarget if the mouse left/entered the browser window
+ if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
+ event.type = handleObj.origType;
+ ret = handleObj.handler.apply( this, arguments );
+ event.type = fix;
+ }
+ return ret;
+ }
+ };
+} );
+
+jQuery.fn.extend( {
+
+ on: function( types, selector, data, fn ) {
+ return on( this, types, selector, data, fn );
+ },
+ one: function( types, selector, data, fn ) {
+ return on( this, types, selector, data, fn, 1 );
+ },
+ off: function( types, selector, fn ) {
+ var handleObj, type;
+ if ( types && types.preventDefault && types.handleObj ) {
+
+ // ( event ) dispatched jQuery.Event
+ handleObj = types.handleObj;
+ jQuery( types.delegateTarget ).off(
+ handleObj.namespace ?
+ handleObj.origType + "." + handleObj.namespace :
+ handleObj.origType,
+ handleObj.selector,
+ handleObj.handler
+ );
+ return this;
+ }
+ if ( typeof types === "object" ) {
+
+ // ( types-object [, selector] )
+ for ( type in types ) {
+ this.off( type, selector, types[ type ] );
+ }
+ return this;
+ }
+ if ( selector === false || typeof selector === "function" ) {
+
+ // ( types [, fn] )
+ fn = selector;
+ selector = undefined;
+ }
+ if ( fn === false ) {
+ fn = returnFalse;
+ }
+ return this.each( function() {
+ jQuery.event.remove( this, types, fn, selector );
+ } );
+ }
+} );
+
+
+var
+
+ // Support: IE <=10 - 11, Edge 12 - 13 only
+ // In IE/Edge using regex groups here causes severe slowdowns.
+ // See https://connect.microsoft.com/IE/feedback/details/1736512/
+ rnoInnerhtml = /<script|<style|<link/i,
+
+ // checked="checked" or checked
+ rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
+ rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
+
+// Prefer a tbody over its parent table for containing new rows
+function manipulationTarget( elem, content ) {
+ if ( nodeName( elem, "table" ) &&
+ nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
+
+ return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
+ }
+
+ return elem;
+}
+
+// Replace/restore the type attribute of script elements for safe DOM manipulation
+function disableScript( elem ) {
+ elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
+ return elem;
+}
+function restoreScript( elem ) {
+ if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
+ elem.type = elem.type.slice( 5 );
+ } else {
+ elem.removeAttribute( "type" );
+ }
+
+ return elem;
+}
+
+function cloneCopyEvent( src, dest ) {
+ var i, l, type, pdataOld, udataOld, udataCur, events;
+
+ if ( dest.nodeType !== 1 ) {
+ return;
+ }
+
+ // 1. Copy private data: events, handlers, etc.
+ if ( dataPriv.hasData( src ) ) {
+ pdataOld = dataPriv.get( src );
+ events = pdataOld.events;
+
+ if ( events ) {
+ dataPriv.remove( dest, "handle events" );
+
+ for ( type in events ) {
+ for ( i = 0, l = events[ type ].length; i < l; i++ ) {
+ jQuery.event.add( dest, type, events[ type ][ i ] );
+ }
+ }
+ }
+ }
+
+ // 2. Copy user data
+ if ( dataUser.hasData( src ) ) {
+ udataOld = dataUser.access( src );
+ udataCur = jQuery.extend( {}, udataOld );
+
+ dataUser.set( dest, udataCur );
+ }
+}
+
+// Fix IE bugs, see support tests
+function fixInput( src, dest ) {
+ var nodeName = dest.nodeName.toLowerCase();
+
+ // Fails to persist the checked state of a cloned checkbox or radio button.
+ if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
+ dest.checked = src.checked;
+
+ // Fails to return the selected option to the default selected state when cloning options
+ } else if ( nodeName === "input" || nodeName === "textarea" ) {
+ dest.defaultValue = src.defaultValue;
+ }
+}
+
+function domManip( collection, args, callback, ignored ) {
+
+ // Flatten any nested arrays
+ args = flat( args );
+
+ var fragment, first, scripts, hasScripts, node, doc,
+ i = 0,
+ l = collection.length,
+ iNoClone = l - 1,
+ value = args[ 0 ],
+ valueIsFunction = isFunction( value );
+
+ // We can't cloneNode fragments that contain checked, in WebKit
+ if ( valueIsFunction ||
+ ( l > 1 && typeof value === "string" &&
+ !support.checkClone && rchecked.test( value ) ) ) {
+ return collection.each( function( index ) {
+ var self = collection.eq( index );
+ if ( valueIsFunction ) {
+ args[ 0 ] = value.call( this, index, self.html() );
+ }
+ domManip( self, args, callback, ignored );
+ } );
+ }
+
+ if ( l ) {
+ fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
+ first = fragment.firstChild;
+
+ if ( fragment.childNodes.length === 1 ) {
+ fragment = first;
+ }
+
+ // Require either new content or an interest in ignored elements to invoke the callback
+ if ( first || ignored ) {
+ scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
+ hasScripts = scripts.length;
+
+ // Use the original fragment for the last item
+ // instead of the first because it can end up
+ // being emptied incorrectly in certain situations (#8070).
+ for ( ; i < l; i++ ) {
+ node = fragment;
+
+ if ( i !== iNoClone ) {
+ node = jQuery.clone( node, true, true );
+
+ // Keep references to cloned scripts for later restoration
+ if ( hasScripts ) {
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge( scripts, getAll( node, "script" ) );
+ }
+ }
+
+ callback.call( collection[ i ], node, i );
+ }
+
+ if ( hasScripts ) {
+ doc = scripts[ scripts.length - 1 ].ownerDocument;
+
+ // Reenable scripts
+ jQuery.map( scripts, restoreScript );
+
+ // Evaluate executable scripts on first document insertion
+ for ( i = 0; i < hasScripts; i++ ) {
+ node = scripts[ i ];
+ if ( rscriptType.test( node.type || "" ) &&
+ !dataPriv.access( node, "globalEval" ) &&
+ jQuery.contains( doc, node ) ) {
+
+ if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) {
+
+ // Optional AJAX dependency, but won't run scripts if not present
+ if ( jQuery._evalUrl && !node.noModule ) {
+ jQuery._evalUrl( node.src, {
+ nonce: node.nonce || node.getAttribute( "nonce" )
+ }, doc );
+ }
+ } else {
+ DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return collection;
+}
+
+function remove( elem, selector, keepData ) {
+ var node,
+ nodes = selector ? jQuery.filter( selector, elem ) : elem,
+ i = 0;
+
+ for ( ; ( node = nodes[ i ] ) != null; i++ ) {
+ if ( !keepData && node.nodeType === 1 ) {
+ jQuery.cleanData( getAll( node ) );
+ }
+
+ if ( node.parentNode ) {
+ if ( keepData && isAttached( node ) ) {
+ setGlobalEval( getAll( node, "script" ) );
+ }
+ node.parentNode.removeChild( node );
+ }
+ }
+
+ return elem;
+}
+
+jQuery.extend( {
+ htmlPrefilter: function( html ) {
+ return html;
+ },
+
+ clone: function( elem, dataAndEvents, deepDataAndEvents ) {
+ var i, l, srcElements, destElements,
+ clone = elem.cloneNode( true ),
+ inPage = isAttached( elem );
+
+ // Fix IE cloning issues
+ if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
+ !jQuery.isXMLDoc( elem ) ) {
+
+ // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
+ destElements = getAll( clone );
+ srcElements = getAll( elem );
+
+ for ( i = 0, l = srcElements.length; i < l; i++ ) {
+ fixInput( srcElements[ i ], destElements[ i ] );
+ }
+ }
+
+ // Copy the events from the original to the clone
+ if ( dataAndEvents ) {
+ if ( deepDataAndEvents ) {
+ srcElements = srcElements || getAll( elem );
+ destElements = destElements || getAll( clone );
+
+ for ( i = 0, l = srcElements.length; i < l; i++ ) {
+ cloneCopyEvent( srcElements[ i ], destElements[ i ] );
+ }
+ } else {
+ cloneCopyEvent( elem, clone );
+ }
+ }
+
+ // Preserve script evaluation history
+ destElements = getAll( clone, "script" );
+ if ( destElements.length > 0 ) {
+ setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
+ }
+
+ // Return the cloned set
+ return clone;
+ },
+
+ cleanData: function( elems ) {
+ var data, elem, type,
+ special = jQuery.event.special,
+ i = 0;
+
+ for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
+ if ( acceptData( elem ) ) {
+ if ( ( data = elem[ dataPriv.expando ] ) ) {
+ if ( data.events ) {
+ for ( type in data.events ) {
+ if ( special[ type ] ) {
+ jQuery.event.remove( elem, type );
+
+ // This is a shortcut to avoid jQuery.event.remove's overhead
+ } else {
+ jQuery.removeEvent( elem, type, data.handle );
+ }
+ }
+ }
+
+ // Support: Chrome <=35 - 45+
+ // Assign undefined instead of using delete, see Data#remove
+ elem[ dataPriv.expando ] = undefined;
+ }
+ if ( elem[ dataUser.expando ] ) {
+
+ // Support: Chrome <=35 - 45+
+ // Assign undefined instead of using delete, see Data#remove
+ elem[ dataUser.expando ] = undefined;
+ }
+ }
+ }
+ }
+} );
+
+jQuery.fn.extend( {
+ detach: function( selector ) {
+ return remove( this, selector, true );
+ },
+
+ remove: function( selector ) {
+ return remove( this, selector );
+ },
+
+ text: function( value ) {
+ return access( this, function( value ) {
+ return value === undefined ?
+ jQuery.text( this ) :
+ this.empty().each( function() {
+ if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+ this.textContent = value;
+ }
+ } );
+ }, null, value, arguments.length );
+ },
+
+ append: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+ var target = manipulationTarget( this, elem );
+ target.appendChild( elem );
+ }
+ } );
+ },
+
+ prepend: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+ var target = manipulationTarget( this, elem );
+ target.insertBefore( elem, target.firstChild );
+ }
+ } );
+ },
+
+ before: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.parentNode ) {
+ this.parentNode.insertBefore( elem, this );
+ }
+ } );
+ },
+
+ after: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.parentNode ) {
+ this.parentNode.insertBefore( elem, this.nextSibling );
+ }
+ } );
+ },
+
+ empty: function() {
+ var elem,
+ i = 0;
+
+ for ( ; ( elem = this[ i ] ) != null; i++ ) {
+ if ( elem.nodeType === 1 ) {
+
+ // Prevent memory leaks
+ jQuery.cleanData( getAll( elem, false ) );
+
+ // Remove any remaining nodes
+ elem.textContent = "";
+ }
+ }
+
+ return this;
+ },
+
+ clone: function( dataAndEvents, deepDataAndEvents ) {
+ dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+ deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+
+ return this.map( function() {
+ return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
+ } );
+ },
+
+ html: function( value ) {
+ return access( this, function( value ) {
+ var elem = this[ 0 ] || {},
+ i = 0,
+ l = this.length;
+
+ if ( value === undefined && elem.nodeType === 1 ) {
+ return elem.innerHTML;
+ }
+
+ // See if we can take a shortcut and just use innerHTML
+ if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
+ !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
+
+ value = jQuery.htmlPrefilter( value );
+
+ try {
+ for ( ; i < l; i++ ) {
+ elem = this[ i ] || {};
+
+ // Remove element nodes and prevent memory leaks
+ if ( elem.nodeType === 1 ) {
+ jQuery.cleanData( getAll( elem, false ) );
+ elem.innerHTML = value;
+ }
+ }
+
+ elem = 0;
+
+ // If using innerHTML throws an exception, use the fallback method
+ } catch ( e ) {}
+ }
+
+ if ( elem ) {
+ this.empty().append( value );
+ }
+ }, null, value, arguments.length );
+ },
+
+ replaceWith: function() {
+ var ignored = [];
+
+ // Make the changes, replacing each non-ignored context element with the new content
+ return domManip( this, arguments, function( elem ) {
+ var parent = this.parentNode;
+
+ if ( jQuery.inArray( this, ignored ) < 0 ) {
+ jQuery.cleanData( getAll( this ) );
+ if ( parent ) {
+ parent.replaceChild( elem, this );
+ }
+ }
+
+ // Force callback invocation
+ }, ignored );
+ }
+} );
+
+jQuery.each( {
+ appendTo: "append",
+ prependTo: "prepend",
+ insertBefore: "before",
+ insertAfter: "after",
+ replaceAll: "replaceWith"
+}, function( name, original ) {
+ jQuery.fn[ name ] = function( selector ) {
+ var elems,
+ ret = [],
+ insert = jQuery( selector ),
+ last = insert.length - 1,
+ i = 0;
+
+ for ( ; i <= last; i++ ) {
+ elems = i === last ? this : this.clone( true );
+ jQuery( insert[ i ] )[ original ]( elems );
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // .get() because push.apply(_, arraylike) throws on ancient WebKit
+ push.apply( ret, elems.get() );
+ }
+
+ return this.pushStack( ret );
+ };
+} );
+var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
+
+var getStyles = function( elem ) {
+
+ // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
+ // IE throws on elements created in popups
+ // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
+ var view = elem.ownerDocument.defaultView;
+
+ if ( !view || !view.opener ) {
+ view = window;
+ }
+
+ return view.getComputedStyle( elem );
+ };
+
+var swap = function( elem, options, callback ) {
+ var ret, name,
+ old = {};
+
+ // Remember the old values, and insert the new ones
+ for ( name in options ) {
+ old[ name ] = elem.style[ name ];
+ elem.style[ name ] = options[ name ];
+ }
+
+ ret = callback.call( elem );
+
+ // Revert the old values
+ for ( name in options ) {
+ elem.style[ name ] = old[ name ];
+ }
+
+ return ret;
+};
+
+
+var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
+
+
+
+( function() {
+
+ // Executing both pixelPosition & boxSizingReliable tests require only one layout
+ // so they're executed at the same time to save the second computation.
+ function computeStyleTests() {
+
+ // This is a singleton, we need to execute it only once
+ if ( !div ) {
+ return;
+ }
+
+ container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
+ "margin-top:1px;padding:0;border:0";
+ div.style.cssText =
+ "position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
+ "margin:auto;border:1px;padding:1px;" +
+ "width:60%;top:1%";
+ documentElement.appendChild( container ).appendChild( div );
+
+ var divStyle = window.getComputedStyle( div );
+ pixelPositionVal = divStyle.top !== "1%";
+
+ // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
+ reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
+
+ // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
+ // Some styles come back with percentage values, even though they shouldn't
+ div.style.right = "60%";
+ pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
+
+ // Support: IE 9 - 11 only
+ // Detect misreporting of content dimensions for box-sizing:border-box elements
+ boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
+
+ // Support: IE 9 only
+ // Detect overflow:scroll screwiness (gh-3699)
+ // Support: Chrome <=64
+ // Don't get tricked when zoom affects offsetWidth (gh-4029)
+ div.style.position = "absolute";
+ scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
+
+ documentElement.removeChild( container );
+
+ // Nullify the div so it wouldn't be stored in the memory and
+ // it will also be a sign that checks already performed
+ div = null;
+ }
+
+ function roundPixelMeasures( measure ) {
+ return Math.round( parseFloat( measure ) );
+ }
+
+ var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
+ reliableTrDimensionsVal, reliableMarginLeftVal,
+ container = document.createElement( "div" ),
+ div = document.createElement( "div" );
+
+ // Finish early in limited (non-browser) environments
+ if ( !div.style ) {
+ return;
+ }
+
+ // Support: IE <=9 - 11 only
+ // Style of cloned element affects source element cloned (#8908)
+ div.style.backgroundClip = "content-box";
+ div.cloneNode( true ).style.backgroundClip = "";
+ support.clearCloneStyle = div.style.backgroundClip === "content-box";
+
+ jQuery.extend( support, {
+ boxSizingReliable: function() {
+ computeStyleTests();
+ return boxSizingReliableVal;
+ },
+ pixelBoxStyles: function() {
+ computeStyleTests();
+ return pixelBoxStylesVal;
+ },
+ pixelPosition: function() {
+ computeStyleTests();
+ return pixelPositionVal;
+ },
+ reliableMarginLeft: function() {
+ computeStyleTests();
+ return reliableMarginLeftVal;
+ },
+ scrollboxSize: function() {
+ computeStyleTests();
+ return scrollboxSizeVal;
+ },
+
+ // Support: IE 9 - 11+, Edge 15 - 18+
+ // IE/Edge misreport `getComputedStyle` of table rows with width/height
+ // set in CSS while `offset*` properties report correct values.
+ // Behavior in IE 9 is more subtle than in newer versions & it passes
+ // some versions of this test; make sure not to make it pass there!
+ //
+ // Support: Firefox 70+
+ // Only Firefox includes border widths
+ // in computed dimensions. (gh-4529)
+ reliableTrDimensions: function() {
+ var table, tr, trChild, trStyle;
+ if ( reliableTrDimensionsVal == null ) {
+ table = document.createElement( "table" );
+ tr = document.createElement( "tr" );
+ trChild = document.createElement( "div" );
+
+ table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
+ tr.style.cssText = "border:1px solid";
+
+ // Support: Chrome 86+
+ // Height set through cssText does not get applied.
+ // Computed height then comes back as 0.
+ tr.style.height = "1px";
+ trChild.style.height = "9px";
+
+ // Support: Android 8 Chrome 86+
+ // In our bodyBackground.html iframe,
+ // display for all div elements is set to "inline",
+ // which causes a problem only in Android 8 Chrome 86.
+ // Ensuring the div is display: block
+ // gets around this issue.
+ trChild.style.display = "block";
+
+ documentElement
+ .appendChild( table )
+ .appendChild( tr )
+ .appendChild( trChild );
+
+ trStyle = window.getComputedStyle( tr );
+ reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +
+ parseInt( trStyle.borderTopWidth, 10 ) +
+ parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;
+
+ documentElement.removeChild( table );
+ }
+ return reliableTrDimensionsVal;
+ }
+ } );
+} )();
+
+
+function curCSS( elem, name, computed ) {
+ var width, minWidth, maxWidth, ret,
+
+ // Support: Firefox 51+
+ // Retrieving style before computed somehow
+ // fixes an issue with getting wrong values
+ // on detached elements
+ style = elem.style;
+
+ computed = computed || getStyles( elem );
+
+ // getPropertyValue is needed for:
+ // .css('filter') (IE 9 only, #12537)
+ // .css('--customProperty) (#3144)
+ if ( computed ) {
+ ret = computed.getPropertyValue( name ) || computed[ name ];
+
+ if ( ret === "" && !isAttached( elem ) ) {
+ ret = jQuery.style( elem, name );
+ }
+
+ // A tribute to the "awesome hack by Dean Edwards"
+ // Android Browser returns percentage for some values,
+ // but width seems to be reliably pixels.
+ // This is against the CSSOM draft spec:
+ // https://drafts.csswg.org/cssom/#resolved-values
+ if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
+
+ // Remember the original values
+ width = style.width;
+ minWidth = style.minWidth;
+ maxWidth = style.maxWidth;
+
+ // Put in the new values to get a computed value out
+ style.minWidth = style.maxWidth = style.width = ret;
+ ret = computed.width;
+
+ // Revert the changed values
+ style.width = width;
+ style.minWidth = minWidth;
+ style.maxWidth = maxWidth;
+ }
+ }
+
+ return ret !== undefined ?
+
+ // Support: IE <=9 - 11 only
+ // IE returns zIndex value as an integer.
+ ret + "" :
+ ret;
+}
+
+
+function addGetHookIf( conditionFn, hookFn ) {
+
+ // Define the hook, we'll check on the first run if it's really needed.
+ return {
+ get: function() {
+ if ( conditionFn() ) {
+
+ // Hook not needed (or it's not possible to use it due
+ // to missing dependency), remove it.
+ delete this.get;
+ return;
+ }
+
+ // Hook needed; redefine it so that the support test is not executed again.
+ return ( this.get = hookFn ).apply( this, arguments );
+ }
+ };
+}
+
+
+var cssPrefixes = [ "Webkit", "Moz", "ms" ],
+ emptyStyle = document.createElement( "div" ).style,
+ vendorProps = {};
+
+// Return a vendor-prefixed property or undefined
+function vendorPropName( name ) {
+
+ // Check for vendor prefixed names
+ var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
+ i = cssPrefixes.length;
+
+ while ( i-- ) {
+ name = cssPrefixes[ i ] + capName;
+ if ( name in emptyStyle ) {
+ return name;
+ }
+ }
+}
+
+// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
+function finalPropName( name ) {
+ var final = jQuery.cssProps[ name ] || vendorProps[ name ];
+
+ if ( final ) {
+ return final;
+ }
+ if ( name in emptyStyle ) {
+ return name;
+ }
+ return vendorProps[ name ] = vendorPropName( name ) || name;
+}
+
+
+var
+
+ // Swappable if display is none or starts with table
+ // except "table", "table-cell", or "table-caption"
+ // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
+ rdisplayswap = /^(none|table(?!-c[ea]).+)/,
+ rcustomProp = /^--/,
+ cssShow = { position: "absolute", visibility: "hidden", display: "block" },
+ cssNormalTransform = {
+ letterSpacing: "0",
+ fontWeight: "400"
+ };
+
+function setPositiveNumber( _elem, value, subtract ) {
+
+ // Any relative (+/-) values have already been
+ // normalized at this point
+ var matches = rcssNum.exec( value );
+ return matches ?
+
+ // Guard against undefined "subtract", e.g., when used as in cssHooks
+ Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
+ value;
+}
+
+function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
+ var i = dimension === "width" ? 1 : 0,
+ extra = 0,
+ delta = 0;
+
+ // Adjustment may not be necessary
+ if ( box === ( isBorderBox ? "border" : "content" ) ) {
+ return 0;
+ }
+
+ for ( ; i < 4; i += 2 ) {
+
+ // Both box models exclude margin
+ if ( box === "margin" ) {
+ delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
+ }
+
+ // If we get here with a content-box, we're seeking "padding" or "border" or "margin"
+ if ( !isBorderBox ) {
+
+ // Add padding
+ delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+
+ // For "border" or "margin", add border
+ if ( box !== "padding" ) {
+ delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+
+ // But still keep track of it otherwise
+ } else {
+ extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+ }
+
+ // If we get here with a border-box (content + padding + border), we're seeking "content" or
+ // "padding" or "margin"
+ } else {
+
+ // For "content", subtract padding
+ if ( box === "content" ) {
+ delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+ }
+
+ // For "content" or "padding", subtract border
+ if ( box !== "margin" ) {
+ delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+ }
+ }
+ }
+
+ // Account for positive content-box scroll gutter when requested by providing computedVal
+ if ( !isBorderBox && computedVal >= 0 ) {
+
+ // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
+ // Assuming integer scroll gutter, subtract the rest and round down
+ delta += Math.max( 0, Math.ceil(
+ elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
+ computedVal -
+ delta -
+ extra -
+ 0.5
+
+ // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
+ // Use an explicit zero to avoid NaN (gh-3964)
+ ) ) || 0;
+ }
+
+ return delta;
+}
+
+function getWidthOrHeight( elem, dimension, extra ) {
+
+ // Start with computed style
+ var styles = getStyles( elem ),
+
+ // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
+ // Fake content-box until we know it's needed to know the true value.
+ boxSizingNeeded = !support.boxSizingReliable() || extra,
+ isBorderBox = boxSizingNeeded &&
+ jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+ valueIsBorderBox = isBorderBox,
+
+ val = curCSS( elem, dimension, styles ),
+ offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
+
+ // Support: Firefox <=54
+ // Return a confounding non-pixel value or feign ignorance, as appropriate.
+ if ( rnumnonpx.test( val ) ) {
+ if ( !extra ) {
+ return val;
+ }
+ val = "auto";
+ }
+
+
+ // Support: IE 9 - 11 only
+ // Use offsetWidth/offsetHeight for when box sizing is unreliable.
+ // In those cases, the computed value can be trusted to be border-box.
+ if ( ( !support.boxSizingReliable() && isBorderBox ||
+
+ // Support: IE 10 - 11+, Edge 15 - 18+
+ // IE/Edge misreport `getComputedStyle` of table rows with width/height
+ // set in CSS while `offset*` properties report correct values.
+ // Interestingly, in some cases IE 9 doesn't suffer from this issue.
+ !support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
+
+ // Fall back to offsetWidth/offsetHeight when value is "auto"
+ // This happens for inline elements with no explicit setting (gh-3571)
+ val === "auto" ||
+
+ // Support: Android <=4.1 - 4.3 only
+ // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
+ !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
+
+ // Make sure the element is visible & connected
+ elem.getClientRects().length ) {
+
+ isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
+
+ // Where available, offsetWidth/offsetHeight approximate border box dimensions.
+ // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
+ // retrieved value as a content box dimension.
+ valueIsBorderBox = offsetProp in elem;
+ if ( valueIsBorderBox ) {
+ val = elem[ offsetProp ];
+ }
+ }
+
+ // Normalize "" and auto
+ val = parseFloat( val ) || 0;
+
+ // Adjust for the element's box model
+ return ( val +
+ boxModelAdjustment(
+ elem,
+ dimension,
+ extra || ( isBorderBox ? "border" : "content" ),
+ valueIsBorderBox,
+ styles,
+
+ // Provide the current computed size to request scroll gutter calculation (gh-3589)
+ val
+ )
+ ) + "px";
+}
+
+jQuery.extend( {
+
+ // Add in style property hooks for overriding the default
+ // behavior of getting and setting a style property
+ cssHooks: {
+ opacity: {
+ get: function( elem, computed ) {
+ if ( computed ) {
+
+ // We should always get a number back from opacity
+ var ret = curCSS( elem, "opacity" );
+ return ret === "" ? "1" : ret;
+ }
+ }
+ }
+ },
+
+ // Don't automatically add "px" to these possibly-unitless properties
+ cssNumber: {
+ "animationIterationCount": true,
+ "columnCount": true,
+ "fillOpacity": true,
+ "flexGrow": true,
+ "flexShrink": true,
+ "fontWeight": true,
+ "gridArea": true,
+ "gridColumn": true,
+ "gridColumnEnd": true,
+ "gridColumnStart": true,
+ "gridRow": true,
+ "gridRowEnd": true,
+ "gridRowStart": true,
+ "lineHeight": true,
+ "opacity": true,
+ "order": true,
+ "orphans": true,
+ "widows": true,
+ "zIndex": true,
+ "zoom": true
+ },
+
+ // Add in properties whose names you wish to fix before
+ // setting or getting the value
+ cssProps: {},
+
+ // Get and set the style property on a DOM Node
+ style: function( elem, name, value, extra ) {
+
+ // Don't set styles on text and comment nodes
+ if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
+ return;
+ }
+
+ // Make sure that we're working with the right name
+ var ret, type, hooks,
+ origName = camelCase( name ),
+ isCustomProp = rcustomProp.test( name ),
+ style = elem.style;
+
+ // Make sure that we're working with the right name. We don't
+ // want to query the value if it is a CSS custom property
+ // since they are user-defined.
+ if ( !isCustomProp ) {
+ name = finalPropName( origName );
+ }
+
+ // Gets hook for the prefixed version, then unprefixed version
+ hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+ // Check if we're setting a value
+ if ( value !== undefined ) {
+ type = typeof value;
+
+ // Convert "+=" or "-=" to relative numbers (#7345)
+ if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
+ value = adjustCSS( elem, name, ret );
+
+ // Fixes bug #9237
+ type = "number";
+ }
+
+ // Make sure that null and NaN values aren't set (#7116)
+ if ( value == null || value !== value ) {
+ return;
+ }
+
+ // If a number was passed in, add the unit (except for certain CSS properties)
+ // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
+ // "px" to a few hardcoded values.
+ if ( type === "number" && !isCustomProp ) {
+ value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
+ }
+
+ // background-* props affect original clone's values
+ if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
+ style[ name ] = "inherit";
+ }
+
+ // If a hook was provided, use that value, otherwise just set the specified value
+ if ( !hooks || !( "set" in hooks ) ||
+ ( value = hooks.set( elem, value, extra ) ) !== undefined ) {
+
+ if ( isCustomProp ) {
+ style.setProperty( name, value );
+ } else {
+ style[ name ] = value;
+ }
+ }
+
+ } else {
+
+ // If a hook was provided get the non-computed value from there
+ if ( hooks && "get" in hooks &&
+ ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
+
+ return ret;
+ }
+
+ // Otherwise just get the value from the style object
+ return style[ name ];
+ }
+ },
+
+ css: function( elem, name, extra, styles ) {
+ var val, num, hooks,
+ origName = camelCase( name ),
+ isCustomProp = rcustomProp.test( name );
+
+ // Make sure that we're working with the right name. We don't
+ // want to modify the value if it is a CSS custom property
+ // since they are user-defined.
+ if ( !isCustomProp ) {
+ name = finalPropName( origName );
+ }
+
+ // Try prefixed name followed by the unprefixed name
+ hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+ // If a hook was provided get the computed value from there
+ if ( hooks && "get" in hooks ) {
+ val = hooks.get( elem, true, extra );
+ }
+
+ // Otherwise, if a way to get the computed value exists, use that
+ if ( val === undefined ) {
+ val = curCSS( elem, name, styles );
+ }
+
+ // Convert "normal" to computed value
+ if ( val === "normal" && name in cssNormalTransform ) {
+ val = cssNormalTransform[ name ];
+ }
+
+ // Make numeric if forced or a qualifier was provided and val looks numeric
+ if ( extra === "" || extra ) {
+ num = parseFloat( val );
+ return extra === true || isFinite( num ) ? num || 0 : val;
+ }
+
+ return val;
+ }
+} );
+
+jQuery.each( [ "height", "width" ], function( _i, dimension ) {
+ jQuery.cssHooks[ dimension ] = {
+ get: function( elem, computed, extra ) {
+ if ( computed ) {
+
+ // Certain elements can have dimension info if we invisibly show them
+ // but it must have a current display style that would benefit
+ return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
+
+ // Support: Safari 8+
+ // Table columns in Safari have non-zero offsetWidth & zero
+ // getBoundingClientRect().width unless display is changed.
+ // Support: IE <=11 only
+ // Running getBoundingClientRect on a disconnected node
+ // in IE throws an error.
+ ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
+ swap( elem, cssShow, function() {
+ return getWidthOrHeight( elem, dimension, extra );
+ } ) :
+ getWidthOrHeight( elem, dimension, extra );
+ }
+ },
+
+ set: function( elem, value, extra ) {
+ var matches,
+ styles = getStyles( elem ),
+
+ // Only read styles.position if the test has a chance to fail
+ // to avoid forcing a reflow.
+ scrollboxSizeBuggy = !support.scrollboxSize() &&
+ styles.position === "absolute",
+
+ // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
+ boxSizingNeeded = scrollboxSizeBuggy || extra,
+ isBorderBox = boxSizingNeeded &&
+ jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+ subtract = extra ?
+ boxModelAdjustment(
+ elem,
+ dimension,
+ extra,
+ isBorderBox,
+ styles
+ ) :
+ 0;
+
+ // Account for unreliable border-box dimensions by comparing offset* to computed and
+ // faking a content-box to get border and padding (gh-3699)
+ if ( isBorderBox && scrollboxSizeBuggy ) {
+ subtract -= Math.ceil(
+ elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
+ parseFloat( styles[ dimension ] ) -
+ boxModelAdjustment( elem, dimension, "border", false, styles ) -
+ 0.5
+ );
+ }
+
+ // Convert to pixels if value adjustment is needed
+ if ( subtract && ( matches = rcssNum.exec( value ) ) &&
+ ( matches[ 3 ] || "px" ) !== "px" ) {
+
+ elem.style[ dimension ] = value;
+ value = jQuery.css( elem, dimension );
+ }
+
+ return setPositiveNumber( elem, value, subtract );
+ }
+ };
+} );
+
+jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
+ function( elem, computed ) {
+ if ( computed ) {
+ return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
+ elem.getBoundingClientRect().left -
+ swap( elem, { marginLeft: 0 }, function() {
+ return elem.getBoundingClientRect().left;
+ } )
+ ) + "px";
+ }
+ }
+);
+
+// These hooks are used by animate to expand properties
+jQuery.each( {
+ margin: "",
+ padding: "",
+ border: "Width"
+}, function( prefix, suffix ) {
+ jQuery.cssHooks[ prefix + suffix ] = {
+ expand: function( value ) {
+ var i = 0,
+ expanded = {},
+
+ // Assumes a single number if not a string
+ parts = typeof value === "string" ? value.split( " " ) : [ value ];
+
+ for ( ; i < 4; i++ ) {
+ expanded[ prefix + cssExpand[ i ] + suffix ] =
+ parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
+ }
+
+ return expanded;
+ }
+ };
+
+ if ( prefix !== "margin" ) {
+ jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
+ }
+} );
+
+jQuery.fn.extend( {
+ css: function( name, value ) {
+ return access( this, function( elem, name, value ) {
+ var styles, len,
+ map = {},
+ i = 0;
+
+ if ( Array.isArray( name ) ) {
+ styles = getStyles( elem );
+ len = name.length;
+
+ for ( ; i < len; i++ ) {
+ map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
+ }
+
+ return map;
+ }
+
+ return value !== undefined ?
+ jQuery.style( elem, name, value ) :
+ jQuery.css( elem, name );
+ }, name, value, arguments.length > 1 );
+ }
+} );
+
+
+function Tween( elem, options, prop, end, easing ) {
+ return new Tween.prototype.init( elem, options, prop, end, easing );
+}
+jQuery.Tween = Tween;
+
+Tween.prototype = {
+ constructor: Tween,
+ init: function( elem, options, prop, end, easing, unit ) {
+ this.elem = elem;
+ this.prop = prop;
+ this.easing = easing || jQuery.easing._default;
+ this.options = options;
+ this.start = this.now = this.cur();
+ this.end = end;
+ this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+ },
+ cur: function() {
+ var hooks = Tween.propHooks[ this.prop ];
+
+ return hooks && hooks.get ?
+ hooks.get( this ) :
+ Tween.propHooks._default.get( this );
+ },
+ run: function( percent ) {
+ var eased,
+ hooks = Tween.propHooks[ this.prop ];
+
+ if ( this.options.duration ) {
+ this.pos = eased = jQuery.easing[ this.easing ](
+ percent, this.options.duration * percent, 0, 1, this.options.duration
+ );
+ } else {
+ this.pos = eased = percent;
+ }
+ this.now = ( this.end - this.start ) * eased + this.start;
+
+ if ( this.options.step ) {
+ this.options.step.call( this.elem, this.now, this );
+ }
+
+ if ( hooks && hooks.set ) {
+ hooks.set( this );
+ } else {
+ Tween.propHooks._default.set( this );
+ }
+ return this;
+ }
+};
+
+Tween.prototype.init.prototype = Tween.prototype;
+
+Tween.propHooks = {
+ _default: {
+ get: function( tween ) {
+ var result;
+
+ // Use a property on the element directly when it is not a DOM element,
+ // or when there is no matching style property that exists.
+ if ( tween.elem.nodeType !== 1 ||
+ tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
+ return tween.elem[ tween.prop ];
+ }
+
+ // Passing an empty string as a 3rd parameter to .css will automatically
+ // attempt a parseFloat and fallback to a string if the parse fails.
+ // Simple values such as "10px" are parsed to Float;
+ // complex values such as "rotate(1rad)" are returned as-is.
+ result = jQuery.css( tween.elem, tween.prop, "" );
+
+ // Empty strings, null, undefined and "auto" are converted to 0.
+ return !result || result === "auto" ? 0 : result;
+ },
+ set: function( tween ) {
+
+ // Use step hook for back compat.
+ // Use cssHook if its there.
+ // Use .style if available and use plain properties where available.
+ if ( jQuery.fx.step[ tween.prop ] ) {
+ jQuery.fx.step[ tween.prop ]( tween );
+ } else if ( tween.elem.nodeType === 1 && (
+ jQuery.cssHooks[ tween.prop ] ||
+ tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
+ jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
+ } else {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+ }
+};
+
+// Support: IE <=9 only
+// Panic based approach to setting things on disconnected nodes
+Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
+ set: function( tween ) {
+ if ( tween.elem.nodeType && tween.elem.parentNode ) {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+};
+
+jQuery.easing = {
+ linear: function( p ) {
+ return p;
+ },
+ swing: function( p ) {
+ return 0.5 - Math.cos( p * Math.PI ) / 2;
+ },
+ _default: "swing"
+};
+
+jQuery.fx = Tween.prototype.init;
+
+// Back compat <1.8 extension point
+jQuery.fx.step = {};
+
+
+
+
+var
+ fxNow, inProgress,
+ rfxtypes = /^(?:toggle|show|hide)$/,
+ rrun = /queueHooks$/;
+
+function schedule() {
+ if ( inProgress ) {
+ if ( document.hidden === false && window.requestAnimationFrame ) {
+ window.requestAnimationFrame( schedule );
+ } else {
+ window.setTimeout( schedule, jQuery.fx.interval );
+ }
+
+ jQuery.fx.tick();
+ }
+}
+
+// Animations created synchronously will run synchronously
+function createFxNow() {
+ window.setTimeout( function() {
+ fxNow = undefined;
+ } );
+ return ( fxNow = Date.now() );
+}
+
+// Generate parameters to create a standard animation
+function genFx( type, includeWidth ) {
+ var which,
+ i = 0,
+ attrs = { height: type };
+
+ // If we include width, step value is 1 to do all cssExpand values,
+ // otherwise step value is 2 to skip over Left and Right
+ includeWidth = includeWidth ? 1 : 0;
+ for ( ; i < 4; i += 2 - includeWidth ) {
+ which = cssExpand[ i ];
+ attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
+ }
+
+ if ( includeWidth ) {
+ attrs.opacity = attrs.width = type;
+ }
+
+ return attrs;
+}
+
+function createTween( value, prop, animation ) {
+ var tween,
+ collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
+ index = 0,
+ length = collection.length;
+ for ( ; index < length; index++ ) {
+ if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
+
+ // We're done with this property
+ return tween;
+ }
+ }
+}
+
+function defaultPrefilter( elem, props, opts ) {
+ var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
+ isBox = "width" in props || "height" in props,
+ anim = this,
+ orig = {},
+ style = elem.style,
+ hidden = elem.nodeType && isHiddenWithinTree( elem ),
+ dataShow = dataPriv.get( elem, "fxshow" );
+
+ // Queue-skipping animations hijack the fx hooks
+ if ( !opts.queue ) {
+ hooks = jQuery._queueHooks( elem, "fx" );
+ if ( hooks.unqueued == null ) {
+ hooks.unqueued = 0;
+ oldfire = hooks.empty.fire;
+ hooks.empty.fire = function() {
+ if ( !hooks.unqueued ) {
+ oldfire();
+ }
+ };
+ }
+ hooks.unqueued++;
+
+ anim.always( function() {
+
+ // Ensure the complete handler is called before this completes
+ anim.always( function() {
+ hooks.unqueued--;
+ if ( !jQuery.queue( elem, "fx" ).length ) {
+ hooks.empty.fire();
+ }
+ } );
+ } );
+ }
+
+ // Detect show/hide animations
+ for ( prop in props ) {
+ value = props[ prop ];
+ if ( rfxtypes.test( value ) ) {
+ delete props[ prop ];
+ toggle = toggle || value === "toggle";
+ if ( value === ( hidden ? "hide" : "show" ) ) {
+
+ // Pretend to be hidden if this is a "show" and
+ // there is still data from a stopped show/hide
+ if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
+ hidden = true;
+
+ // Ignore all other no-op show/hide data
+ } else {
+ continue;
+ }
+ }
+ orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
+ }
+ }
+
+ // Bail out if this is a no-op like .hide().hide()
+ propTween = !jQuery.isEmptyObject( props );
+ if ( !propTween && jQuery.isEmptyObject( orig ) ) {
+ return;
+ }
+
+ // Restrict "overflow" and "display" styles during box animations
+ if ( isBox && elem.nodeType === 1 ) {
+
+ // Support: IE <=9 - 11, Edge 12 - 15
+ // Record all 3 overflow attributes because IE does not infer the shorthand
+ // from identically-valued overflowX and overflowY and Edge just mirrors
+ // the overflowX value there.
+ opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
+
+ // Identify a display type, preferring old show/hide data over the CSS cascade
+ restoreDisplay = dataShow && dataShow.display;
+ if ( restoreDisplay == null ) {
+ restoreDisplay = dataPriv.get( elem, "display" );
+ }
+ display = jQuery.css( elem, "display" );
+ if ( display === "none" ) {
+ if ( restoreDisplay ) {
+ display = restoreDisplay;
+ } else {
+
+ // Get nonempty value(s) by temporarily forcing visibility
+ showHide( [ elem ], true );
+ restoreDisplay = elem.style.display || restoreDisplay;
+ display = jQuery.css( elem, "display" );
+ showHide( [ elem ] );
+ }
+ }
+
+ // Animate inline elements as inline-block
+ if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
+ if ( jQuery.css( elem, "float" ) === "none" ) {
+
+ // Restore the original display value at the end of pure show/hide animations
+ if ( !propTween ) {
+ anim.done( function() {
+ style.display = restoreDisplay;
+ } );
+ if ( restoreDisplay == null ) {
+ display = style.display;
+ restoreDisplay = display === "none" ? "" : display;
+ }
+ }
+ style.display = "inline-block";
+ }
+ }
+ }
+
+ if ( opts.overflow ) {
+ style.overflow = "hidden";
+ anim.always( function() {
+ style.overflow = opts.overflow[ 0 ];
+ style.overflowX = opts.overflow[ 1 ];
+ style.overflowY = opts.overflow[ 2 ];
+ } );
+ }
+
+ // Implement show/hide animations
+ propTween = false;
+ for ( prop in orig ) {
+
+ // General show/hide setup for this element animation
+ if ( !propTween ) {
+ if ( dataShow ) {
+ if ( "hidden" in dataShow ) {
+ hidden = dataShow.hidden;
+ }
+ } else {
+ dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
+ }
+
+ // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
+ if ( toggle ) {
+ dataShow.hidden = !hidden;
+ }
+
+ // Show elements before animating them
+ if ( hidden ) {
+ showHide( [ elem ], true );
+ }
+
+ /* eslint-disable no-loop-func */
+
+ anim.done( function() {
+
+ /* eslint-enable no-loop-func */
+
+ // The final step of a "hide" animation is actually hiding the element
+ if ( !hidden ) {
+ showHide( [ elem ] );
+ }
+ dataPriv.remove( elem, "fxshow" );
+ for ( prop in orig ) {
+ jQuery.style( elem, prop, orig[ prop ] );
+ }
+ } );
+ }
+
+ // Per-property setup
+ propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
+ if ( !( prop in dataShow ) ) {
+ dataShow[ prop ] = propTween.start;
+ if ( hidden ) {
+ propTween.end = propTween.start;
+ propTween.start = 0;
+ }
+ }
+ }
+}
+
+function propFilter( props, specialEasing ) {
+ var index, name, easing, value, hooks;
+
+ // camelCase, specialEasing and expand cssHook pass
+ for ( index in props ) {
+ name = camelCase( index );
+ easing = specialEasing[ name ];
+ value = props[ index ];
+ if ( Array.isArray( value ) ) {
+ easing = value[ 1 ];
+ value = props[ index ] = value[ 0 ];
+ }
+
+ if ( index !== name ) {
+ props[ name ] = value;
+ delete props[ index ];
+ }
+
+ hooks = jQuery.cssHooks[ name ];
+ if ( hooks && "expand" in hooks ) {
+ value = hooks.expand( value );
+ delete props[ name ];
+
+ // Not quite $.extend, this won't overwrite existing keys.
+ // Reusing 'index' because we have the correct "name"
+ for ( index in value ) {
+ if ( !( index in props ) ) {
+ props[ index ] = value[ index ];
+ specialEasing[ index ] = easing;
+ }
+ }
+ } else {
+ specialEasing[ name ] = easing;
+ }
+ }
+}
+
+function Animation( elem, properties, options ) {
+ var result,
+ stopped,
+ index = 0,
+ length = Animation.prefilters.length,
+ deferred = jQuery.Deferred().always( function() {
+
+ // Don't match elem in the :animated selector
+ delete tick.elem;
+ } ),
+ tick = function() {
+ if ( stopped ) {
+ return false;
+ }
+ var currentTime = fxNow || createFxNow(),
+ remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
+
+ // Support: Android 2.3 only
+ // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
+ temp = remaining / animation.duration || 0,
+ percent = 1 - temp,
+ index = 0,
+ length = animation.tweens.length;
+
+ for ( ; index < length; index++ ) {
+ animation.tweens[ index ].run( percent );
+ }
+
+ deferred.notifyWith( elem, [ animation, percent, remaining ] );
+
+ // If there's more to do, yield
+ if ( percent < 1 && length ) {
+ return remaining;
+ }
+
+ // If this was an empty animation, synthesize a final progress notification
+ if ( !length ) {
+ deferred.notifyWith( elem, [ animation, 1, 0 ] );
+ }
+
+ // Resolve the animation and report its conclusion
+ deferred.resolveWith( elem, [ animation ] );
+ return false;
+ },
+ animation = deferred.promise( {
+ elem: elem,
+ props: jQuery.extend( {}, properties ),
+ opts: jQuery.extend( true, {
+ specialEasing: {},
+ easing: jQuery.easing._default
+ }, options ),
+ originalProperties: properties,
+ originalOptions: options,
+ startTime: fxNow || createFxNow(),
+ duration: options.duration,
+ tweens: [],
+ createTween: function( prop, end ) {
+ var tween = jQuery.Tween( elem, animation.opts, prop, end,
+ animation.opts.specialEasing[ prop ] || animation.opts.easing );
+ animation.tweens.push( tween );
+ return tween;
+ },
+ stop: function( gotoEnd ) {
+ var index = 0,
+
+ // If we are going to the end, we want to run all the tweens
+ // otherwise we skip this part
+ length = gotoEnd ? animation.tweens.length : 0;
+ if ( stopped ) {
+ return this;
+ }
+ stopped = true;
+ for ( ; index < length; index++ ) {
+ animation.tweens[ index ].run( 1 );
+ }
+
+ // Resolve when we played the last frame; otherwise, reject
+ if ( gotoEnd ) {
+ deferred.notifyWith( elem, [ animation, 1, 0 ] );
+ deferred.resolveWith( elem, [ animation, gotoEnd ] );
+ } else {
+ deferred.rejectWith( elem, [ animation, gotoEnd ] );
+ }
+ return this;
+ }
+ } ),
+ props = animation.props;
+
+ propFilter( props, animation.opts.specialEasing );
+
+ for ( ; index < length; index++ ) {
+ result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
+ if ( result ) {
+ if ( isFunction( result.stop ) ) {
+ jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
+ result.stop.bind( result );
+ }
+ return result;
+ }
+ }
+
+ jQuery.map( props, createTween, animation );
+
+ if ( isFunction( animation.opts.start ) ) {
+ animation.opts.start.call( elem, animation );
+ }
+
+ // Attach callbacks from options
+ animation
+ .progress( animation.opts.progress )
+ .done( animation.opts.done, animation.opts.complete )
+ .fail( animation.opts.fail )
+ .always( animation.opts.always );
+
+ jQuery.fx.timer(
+ jQuery.extend( tick, {
+ elem: elem,
+ anim: animation,
+ queue: animation.opts.queue
+ } )
+ );
+
+ return animation;
+}
+
+jQuery.Animation = jQuery.extend( Animation, {
+
+ tweeners: {
+ "*": [ function( prop, value ) {
+ var tween = this.createTween( prop, value );
+ adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
+ return tween;
+ } ]
+ },
+
+ tweener: function( props, callback ) {
+ if ( isFunction( props ) ) {
+ callback = props;
+ props = [ "*" ];
+ } else {
+ props = props.match( rnothtmlwhite );
+ }
+
+ var prop,
+ index = 0,
+ length = props.length;
+
+ for ( ; index < length; index++ ) {
+ prop = props[ index ];
+ Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
+ Animation.tweeners[ prop ].unshift( callback );
+ }
+ },
+
+ prefilters: [ defaultPrefilter ],
+
+ prefilter: function( callback, prepend ) {
+ if ( prepend ) {
+ Animation.prefilters.unshift( callback );
+ } else {
+ Animation.prefilters.push( callback );
+ }
+ }
+} );
+
+jQuery.speed = function( speed, easing, fn ) {
+ var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
+ complete: fn || !fn && easing ||
+ isFunction( speed ) && speed,
+ duration: speed,
+ easing: fn && easing || easing && !isFunction( easing ) && easing
+ };
+
+ // Go to the end state if fx are off
+ if ( jQuery.fx.off ) {
+ opt.duration = 0;
+
+ } else {
+ if ( typeof opt.duration !== "number" ) {
+ if ( opt.duration in jQuery.fx.speeds ) {
+ opt.duration = jQuery.fx.speeds[ opt.duration ];
+
+ } else {
+ opt.duration = jQuery.fx.speeds._default;
+ }
+ }
+ }
+
+ // Normalize opt.queue - true/undefined/null -> "fx"
+ if ( opt.queue == null || opt.queue === true ) {
+ opt.queue = "fx";
+ }
+
+ // Queueing
+ opt.old = opt.complete;
+
+ opt.complete = function() {
+ if ( isFunction( opt.old ) ) {
+ opt.old.call( this );
+ }
+
+ if ( opt.queue ) {
+ jQuery.dequeue( this, opt.queue );
+ }
+ };
+
+ return opt;
+};
+
+jQuery.fn.extend( {
+ fadeTo: function( speed, to, easing, callback ) {
+
+ // Show any hidden elements after setting opacity to 0
+ return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
+
+ // Animate to the value specified
+ .end().animate( { opacity: to }, speed, easing, callback );
+ },
+ animate: function( prop, speed, easing, callback ) {
+ var empty = jQuery.isEmptyObject( prop ),
+ optall = jQuery.speed( speed, easing, callback ),
+ doAnimation = function() {
+
+ // Operate on a copy of prop so per-property easing won't be lost
+ var anim = Animation( this, jQuery.extend( {}, prop ), optall );
+
+ // Empty animations, or finishing resolves immediately
+ if ( empty || dataPriv.get( this, "finish" ) ) {
+ anim.stop( true );
+ }
+ };
+
+ doAnimation.finish = doAnimation;
+
+ return empty || optall.queue === false ?
+ this.each( doAnimation ) :
+ this.queue( optall.queue, doAnimation );
+ },
+ stop: function( type, clearQueue, gotoEnd ) {
+ var stopQueue = function( hooks ) {
+ var stop = hooks.stop;
+ delete hooks.stop;
+ stop( gotoEnd );
+ };
+
+ if ( typeof type !== "string" ) {
+ gotoEnd = clearQueue;
+ clearQueue = type;
+ type = undefined;
+ }
+ if ( clearQueue ) {
+ this.queue( type || "fx", [] );
+ }
+
+ return this.each( function() {
+ var dequeue = true,
+ index = type != null && type + "queueHooks",
+ timers = jQuery.timers,
+ data = dataPriv.get( this );
+
+ if ( index ) {
+ if ( data[ index ] && data[ index ].stop ) {
+ stopQueue( data[ index ] );
+ }
+ } else {
+ for ( index in data ) {
+ if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
+ stopQueue( data[ index ] );
+ }
+ }
+ }
+
+ for ( index = timers.length; index--; ) {
+ if ( timers[ index ].elem === this &&
+ ( type == null || timers[ index ].queue === type ) ) {
+
+ timers[ index ].anim.stop( gotoEnd );
+ dequeue = false;
+ timers.splice( index, 1 );
+ }
+ }
+
+ // Start the next in the queue if the last step wasn't forced.
+ // Timers currently will call their complete callbacks, which
+ // will dequeue but only if they were gotoEnd.
+ if ( dequeue || !gotoEnd ) {
+ jQuery.dequeue( this, type );
+ }
+ } );
+ },
+ finish: function( type ) {
+ if ( type !== false ) {
+ type = type || "fx";
+ }
+ return this.each( function() {
+ var index,
+ data = dataPriv.get( this ),
+ queue = data[ type + "queue" ],
+ hooks = data[ type + "queueHooks" ],
+ timers = jQuery.timers,
+ length = queue ? queue.length : 0;
+
+ // Enable finishing flag on private data
+ data.finish = true;
+
+ // Empty the queue first
+ jQuery.queue( this, type, [] );
+
+ if ( hooks && hooks.stop ) {
+ hooks.stop.call( this, true );
+ }
+
+ // Look for any active animations, and finish them
+ for ( index = timers.length; index--; ) {
+ if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
+ timers[ index ].anim.stop( true );
+ timers.splice( index, 1 );
+ }
+ }
+
+ // Look for any animations in the old queue and finish them
+ for ( index = 0; index < length; index++ ) {
+ if ( queue[ index ] && queue[ index ].finish ) {
+ queue[ index ].finish.call( this );
+ }
+ }
+
+ // Turn off finishing flag
+ delete data.finish;
+ } );
+ }
+} );
+
+jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) {
+ var cssFn = jQuery.fn[ name ];
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return speed == null || typeof speed === "boolean" ?
+ cssFn.apply( this, arguments ) :
+ this.animate( genFx( name, true ), speed, easing, callback );
+ };
+} );
+
+// Generate shortcuts for custom animations
+jQuery.each( {
+ slideDown: genFx( "show" ),
+ slideUp: genFx( "hide" ),
+ slideToggle: genFx( "toggle" ),
+ fadeIn: { opacity: "show" },
+ fadeOut: { opacity: "hide" },
+ fadeToggle: { opacity: "toggle" }
+}, function( name, props ) {
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return this.animate( props, speed, easing, callback );
+ };
+} );
+
+jQuery.timers = [];
+jQuery.fx.tick = function() {
+ var timer,
+ i = 0,
+ timers = jQuery.timers;
+
+ fxNow = Date.now();
+
+ for ( ; i < timers.length; i++ ) {
+ timer = timers[ i ];
+
+ // Run the timer and safely remove it when done (allowing for external removal)
+ if ( !timer() && timers[ i ] === timer ) {
+ timers.splice( i--, 1 );
+ }
+ }
+
+ if ( !timers.length ) {
+ jQuery.fx.stop();
+ }
+ fxNow = undefined;
+};
+
+jQuery.fx.timer = function( timer ) {
+ jQuery.timers.push( timer );
+ jQuery.fx.start();
+};
+
+jQuery.fx.interval = 13;
+jQuery.fx.start = function() {
+ if ( inProgress ) {
+ return;
+ }
+
+ inProgress = true;
+ schedule();
+};
+
+jQuery.fx.stop = function() {
+ inProgress = null;
+};
+
+jQuery.fx.speeds = {
+ slow: 600,
+ fast: 200,
+
+ // Default speed
+ _default: 400
+};
+
+
+// Based off of the plugin by Clint Helfers, with permission.
+// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
+jQuery.fn.delay = function( time, type ) {
+ time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+ type = type || "fx";
+
+ return this.queue( type, function( next, hooks ) {
+ var timeout = window.setTimeout( next, time );
+ hooks.stop = function() {
+ window.clearTimeout( timeout );
+ };
+ } );
+};
+
+
+( function() {
+ var input = document.createElement( "input" ),
+ select = document.createElement( "select" ),
+ opt = select.appendChild( document.createElement( "option" ) );
+
+ input.type = "checkbox";
+
+ // Support: Android <=4.3 only
+ // Default value for a checkbox should be "on"
+ support.checkOn = input.value !== "";
+
+ // Support: IE <=11 only
+ // Must access selectedIndex to make default options select
+ support.optSelected = opt.selected;
+
+ // Support: IE <=11 only
+ // An input loses its value after becoming a radio
+ input = document.createElement( "input" );
+ input.value = "t";
+ input.type = "radio";
+ support.radioValue = input.value === "t";
+} )();
+
+
+var boolHook,
+ attrHandle = jQuery.expr.attrHandle;
+
+jQuery.fn.extend( {
+ attr: function( name, value ) {
+ return access( this, jQuery.attr, name, value, arguments.length > 1 );
+ },
+
+ removeAttr: function( name ) {
+ return this.each( function() {
+ jQuery.removeAttr( this, name );
+ } );
+ }
+} );
+
+jQuery.extend( {
+ attr: function( elem, name, value ) {
+ var ret, hooks,
+ nType = elem.nodeType;
+
+ // Don't get/set attributes on text, comment and attribute nodes
+ if ( nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ // Fallback to prop when attributes are not supported
+ if ( typeof elem.getAttribute === "undefined" ) {
+ return jQuery.prop( elem, name, value );
+ }
+
+ // Attribute hooks are determined by the lowercase version
+ // Grab necessary hook if one is defined
+ if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
+ hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
+ ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
+ }
+
+ if ( value !== undefined ) {
+ if ( value === null ) {
+ jQuery.removeAttr( elem, name );
+ return;
+ }
+
+ if ( hooks && "set" in hooks &&
+ ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
+ return ret;
+ }
+
+ elem.setAttribute( name, value + "" );
+ return value;
+ }
+
+ if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
+ return ret;
+ }
+
+ ret = jQuery.find.attr( elem, name );
+
+ // Non-existent attributes return null, we normalize to undefined
+ return ret == null ? undefined : ret;
+ },
+
+ attrHooks: {
+ type: {
+ set: function( elem, value ) {
+ if ( !support.radioValue && value === "radio" &&
+ nodeName( elem, "input" ) ) {
+ var val = elem.value;
+ elem.setAttribute( "type", value );
+ if ( val ) {
+ elem.value = val;
+ }
+ return value;
+ }
+ }
+ }
+ },
+
+ removeAttr: function( elem, value ) {
+ var name,
+ i = 0,
+
+ // Attribute names can contain non-HTML whitespace characters
+ // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+ attrNames = value && value.match( rnothtmlwhite );
+
+ if ( attrNames && elem.nodeType === 1 ) {
+ while ( ( name = attrNames[ i++ ] ) ) {
+ elem.removeAttribute( name );
+ }
+ }
+ }
+} );
+
+// Hooks for boolean attributes
+boolHook = {
+ set: function( elem, value, name ) {
+ if ( value === false ) {
+
+ // Remove boolean attributes when set to false
+ jQuery.removeAttr( elem, name );
+ } else {
+ elem.setAttribute( name, name );
+ }
+ return name;
+ }
+};
+
+jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
+ var getter = attrHandle[ name ] || jQuery.find.attr;
+
+ attrHandle[ name ] = function( elem, name, isXML ) {
+ var ret, handle,
+ lowercaseName = name.toLowerCase();
+
+ if ( !isXML ) {
+
+ // Avoid an infinite loop by temporarily removing this function from the getter
+ handle = attrHandle[ lowercaseName ];
+ attrHandle[ lowercaseName ] = ret;
+ ret = getter( elem, name, isXML ) != null ?
+ lowercaseName :
+ null;
+ attrHandle[ lowercaseName ] = handle;
+ }
+ return ret;
+ };
+} );
+
+
+
+
+var rfocusable = /^(?:input|select|textarea|button)$/i,
+ rclickable = /^(?:a|area)$/i;
+
+jQuery.fn.extend( {
+ prop: function( name, value ) {
+ return access( this, jQuery.prop, name, value, arguments.length > 1 );
+ },
+
+ removeProp: function( name ) {
+ return this.each( function() {
+ delete this[ jQuery.propFix[ name ] || name ];
+ } );
+ }
+} );
+
+jQuery.extend( {
+ prop: function( elem, name, value ) {
+ var ret, hooks,
+ nType = elem.nodeType;
+
+ // Don't get/set properties on text, comment and attribute nodes
+ if ( nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
+
+ // Fix name and attach hooks
+ name = jQuery.propFix[ name ] || name;
+ hooks = jQuery.propHooks[ name ];
+ }
+
+ if ( value !== undefined ) {
+ if ( hooks && "set" in hooks &&
+ ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
+ return ret;
+ }
+
+ return ( elem[ name ] = value );
+ }
+
+ if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
+ return ret;
+ }
+
+ return elem[ name ];
+ },
+
+ propHooks: {
+ tabIndex: {
+ get: function( elem ) {
+
+ // Support: IE <=9 - 11 only
+ // elem.tabIndex doesn't always return the
+ // correct value when it hasn't been explicitly set
+ // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+ // Use proper attribute retrieval(#12072)
+ var tabindex = jQuery.find.attr( elem, "tabindex" );
+
+ if ( tabindex ) {
+ return parseInt( tabindex, 10 );
+ }
+
+ if (
+ rfocusable.test( elem.nodeName ) ||
+ rclickable.test( elem.nodeName ) &&
+ elem.href
+ ) {
+ return 0;
+ }
+
+ return -1;
+ }
+ }
+ },
+
+ propFix: {
+ "for": "htmlFor",
+ "class": "className"
+ }
+} );
+
+// Support: IE <=11 only
+// Accessing the selectedIndex property
+// forces the browser to respect setting selected
+// on the option
+// The getter ensures a default option is selected
+// when in an optgroup
+// eslint rule "no-unused-expressions" is disabled for this code
+// since it considers such accessions noop
+if ( !support.optSelected ) {
+ jQuery.propHooks.selected = {
+ get: function( elem ) {
+
+ /* eslint no-unused-expressions: "off" */
+
+ var parent = elem.parentNode;
+ if ( parent && parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ return null;
+ },
+ set: function( elem ) {
+
+ /* eslint no-unused-expressions: "off" */
+
+ var parent = elem.parentNode;
+ if ( parent ) {
+ parent.selectedIndex;
+
+ if ( parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ }
+ }
+ };
+}
+
+jQuery.each( [
+ "tabIndex",
+ "readOnly",
+ "maxLength",
+ "cellSpacing",
+ "cellPadding",
+ "rowSpan",
+ "colSpan",
+ "useMap",
+ "frameBorder",
+ "contentEditable"
+], function() {
+ jQuery.propFix[ this.toLowerCase() ] = this;
+} );
+
+
+
+
+ // Strip and collapse whitespace according to HTML spec
+ // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
+ function stripAndCollapse( value ) {
+ var tokens = value.match( rnothtmlwhite ) || [];
+ return tokens.join( " " );
+ }
+
+
+function getClass( elem ) {
+ return elem.getAttribute && elem.getAttribute( "class" ) || "";
+}
+
+function classesToArray( value ) {
+ if ( Array.isArray( value ) ) {
+ return value;
+ }
+ if ( typeof value === "string" ) {
+ return value.match( rnothtmlwhite ) || [];
+ }
+ return [];
+}
+
+jQuery.fn.extend( {
+ addClass: function( value ) {
+ var classes, elem, cur, curValue, clazz, j, finalValue,
+ i = 0;
+
+ if ( isFunction( value ) ) {
+ return this.each( function( j ) {
+ jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
+ } );
+ }
+
+ classes = classesToArray( value );
+
+ if ( classes.length ) {
+ while ( ( elem = this[ i++ ] ) ) {
+ curValue = getClass( elem );
+ cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
+
+ if ( cur ) {
+ j = 0;
+ while ( ( clazz = classes[ j++ ] ) ) {
+ if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
+ cur += clazz + " ";
+ }
+ }
+
+ // Only assign if different to avoid unneeded rendering.
+ finalValue = stripAndCollapse( cur );
+ if ( curValue !== finalValue ) {
+ elem.setAttribute( "class", finalValue );
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ removeClass: function( value ) {
+ var classes, elem, cur, curValue, clazz, j, finalValue,
+ i = 0;
+
+ if ( isFunction( value ) ) {
+ return this.each( function( j ) {
+ jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
+ } );
+ }
+
+ if ( !arguments.length ) {
+ return this.attr( "class", "" );
+ }
+
+ classes = classesToArray( value );
+
+ if ( classes.length ) {
+ while ( ( elem = this[ i++ ] ) ) {
+ curValue = getClass( elem );
+
+ // This expression is here for better compressibility (see addClass)
+ cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
+
+ if ( cur ) {
+ j = 0;
+ while ( ( clazz = classes[ j++ ] ) ) {
+
+ // Remove *all* instances
+ while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
+ cur = cur.replace( " " + clazz + " ", " " );
+ }
+ }
+
+ // Only assign if different to avoid unneeded rendering.
+ finalValue = stripAndCollapse( cur );
+ if ( curValue !== finalValue ) {
+ elem.setAttribute( "class", finalValue );
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ toggleClass: function( value, stateVal ) {
+ var type = typeof value,
+ isValidValue = type === "string" || Array.isArray( value );
+
+ if ( typeof stateVal === "boolean" && isValidValue ) {
+ return stateVal ? this.addClass( value ) : this.removeClass( value );
+ }
+
+ if ( isFunction( value ) ) {
+ return this.each( function( i ) {
+ jQuery( this ).toggleClass(
+ value.call( this, i, getClass( this ), stateVal ),
+ stateVal
+ );
+ } );
+ }
+
+ return this.each( function() {
+ var className, i, self, classNames;
+
+ if ( isValidValue ) {
+
+ // Toggle individual class names
+ i = 0;
+ self = jQuery( this );
+ classNames = classesToArray( value );
+
+ while ( ( className = classNames[ i++ ] ) ) {
+
+ // Check each className given, space separated list
+ if ( self.hasClass( className ) ) {
+ self.removeClass( className );
+ } else {
+ self.addClass( className );
+ }
+ }
+
+ // Toggle whole class name
+ } else if ( value === undefined || type === "boolean" ) {
+ className = getClass( this );
+ if ( className ) {
+
+ // Store className if set
+ dataPriv.set( this, "__className__", className );
+ }
+
+ // If the element has a class name or if we're passed `false`,
+ // then remove the whole classname (if there was one, the above saved it).
+ // Otherwise bring back whatever was previously saved (if anything),
+ // falling back to the empty string if nothing was stored.
+ if ( this.setAttribute ) {
+ this.setAttribute( "class",
+ className || value === false ?
+ "" :
+ dataPriv.get( this, "__className__" ) || ""
+ );
+ }
+ }
+ } );
+ },
+
+ hasClass: function( selector ) {
+ var className, elem,
+ i = 0;
+
+ className = " " + selector + " ";
+ while ( ( elem = this[ i++ ] ) ) {
+ if ( elem.nodeType === 1 &&
+ ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+} );
+
+
+
+
+var rreturn = /\r/g;
+
+jQuery.fn.extend( {
+ val: function( value ) {
+ var hooks, ret, valueIsFunction,
+ elem = this[ 0 ];
+
+ if ( !arguments.length ) {
+ if ( elem ) {
+ hooks = jQuery.valHooks[ elem.type ] ||
+ jQuery.valHooks[ elem.nodeName.toLowerCase() ];
+
+ if ( hooks &&
+ "get" in hooks &&
+ ( ret = hooks.get( elem, "value" ) ) !== undefined
+ ) {
+ return ret;
+ }
+
+ ret = elem.value;
+
+ // Handle most common string cases
+ if ( typeof ret === "string" ) {
+ return ret.replace( rreturn, "" );
+ }
+
+ // Handle cases where value is null/undef or number
+ return ret == null ? "" : ret;
+ }
+
+ return;
+ }
+
+ valueIsFunction = isFunction( value );
+
+ return this.each( function( i ) {
+ var val;
+
+ if ( this.nodeType !== 1 ) {
+ return;
+ }
+
+ if ( valueIsFunction ) {
+ val = value.call( this, i, jQuery( this ).val() );
+ } else {
+ val = value;
+ }
+
+ // Treat null/undefined as ""; convert numbers to string
+ if ( val == null ) {
+ val = "";
+
+ } else if ( typeof val === "number" ) {
+ val += "";
+
+ } else if ( Array.isArray( val ) ) {
+ val = jQuery.map( val, function( value ) {
+ return value == null ? "" : value + "";
+ } );
+ }
+
+ hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
+
+ // If set returns undefined, fall back to normal setting
+ if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
+ this.value = val;
+ }
+ } );
+ }
+} );
+
+jQuery.extend( {
+ valHooks: {
+ option: {
+ get: function( elem ) {
+
+ var val = jQuery.find.attr( elem, "value" );
+ return val != null ?
+ val :
+
+ // Support: IE <=10 - 11 only
+ // option.text throws exceptions (#14686, #14858)
+ // Strip and collapse whitespace
+ // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
+ stripAndCollapse( jQuery.text( elem ) );
+ }
+ },
+ select: {
+ get: function( elem ) {
+ var value, option, i,
+ options = elem.options,
+ index = elem.selectedIndex,
+ one = elem.type === "select-one",
+ values = one ? null : [],
+ max = one ? index + 1 : options.length;
+
+ if ( index < 0 ) {
+ i = max;
+
+ } else {
+ i = one ? index : 0;
+ }
+
+ // Loop through all the selected options
+ for ( ; i < max; i++ ) {
+ option = options[ i ];
+
+ // Support: IE <=9 only
+ // IE8-9 doesn't update selected after form reset (#2551)
+ if ( ( option.selected || i === index ) &&
+
+ // Don't return options that are disabled or in a disabled optgroup
+ !option.disabled &&
+ ( !option.parentNode.disabled ||
+ !nodeName( option.parentNode, "optgroup" ) ) ) {
+
+ // Get the specific value for the option
+ value = jQuery( option ).val();
+
+ // We don't need an array for one selects
+ if ( one ) {
+ return value;
+ }
+
+ // Multi-Selects return an array
+ values.push( value );
+ }
+ }
+
+ return values;
+ },
+
+ set: function( elem, value ) {
+ var optionSet, option,
+ options = elem.options,
+ values = jQuery.makeArray( value ),
+ i = options.length;
+
+ while ( i-- ) {
+ option = options[ i ];
+
+ /* eslint-disable no-cond-assign */
+
+ if ( option.selected =
+ jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
+ ) {
+ optionSet = true;
+ }
+
+ /* eslint-enable no-cond-assign */
+ }
+
+ // Force browsers to behave consistently when non-matching value is set
+ if ( !optionSet ) {
+ elem.selectedIndex = -1;
+ }
+ return values;
+ }
+ }
+ }
+} );
+
+// Radios and checkboxes getter/setter
+jQuery.each( [ "radio", "checkbox" ], function() {
+ jQuery.valHooks[ this ] = {
+ set: function( elem, value ) {
+ if ( Array.isArray( value ) ) {
+ return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
+ }
+ }
+ };
+ if ( !support.checkOn ) {
+ jQuery.valHooks[ this ].get = function( elem ) {
+ return elem.getAttribute( "value" ) === null ? "on" : elem.value;
+ };
+ }
+} );
+
+
+
+
+// Return jQuery for attributes-only inclusion
+
+
+support.focusin = "onfocusin" in window;
+
+
+var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+ stopPropagationCallback = function( e ) {
+ e.stopPropagation();
+ };
+
+jQuery.extend( jQuery.event, {
+
+ trigger: function( event, data, elem, onlyHandlers ) {
+
+ var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
+ eventPath = [ elem || document ],
+ type = hasOwn.call( event, "type" ) ? event.type : event,
+ namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
+
+ cur = lastElement = tmp = elem = elem || document;
+
+ // Don't do events on text and comment nodes
+ if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
+ return;
+ }
+
+ // focus/blur morphs to focusin/out; ensure we're not firing them right now
+ if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
+ return;
+ }
+
+ if ( type.indexOf( "." ) > -1 ) {
+
+ // Namespaced trigger; create a regexp to match event type in handle()
+ namespaces = type.split( "." );
+ type = namespaces.shift();
+ namespaces.sort();
+ }
+ ontype = type.indexOf( ":" ) < 0 && "on" + type;
+
+ // Caller can pass in a jQuery.Event object, Object, or just an event type string
+ event = event[ jQuery.expando ] ?
+ event :
+ new jQuery.Event( type, typeof event === "object" && event );
+
+ // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
+ event.isTrigger = onlyHandlers ? 2 : 3;
+ event.namespace = namespaces.join( "." );
+ event.rnamespace = event.namespace ?
+ new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
+ null;
+
+ // Clean up the event in case it is being reused
+ event.result = undefined;
+ if ( !event.target ) {
+ event.target = elem;
+ }
+
+ // Clone any incoming data and prepend the event, creating the handler arg list
+ data = data == null ?
+ [ event ] :
+ jQuery.makeArray( data, [ event ] );
+
+ // Allow special events to draw outside the lines
+ special = jQuery.event.special[ type ] || {};
+ if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
+ return;
+ }
+
+ // Determine event propagation path in advance, per W3C events spec (#9951)
+ // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+ if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
+
+ bubbleType = special.delegateType || type;
+ if ( !rfocusMorph.test( bubbleType + type ) ) {
+ cur = cur.parentNode;
+ }
+ for ( ; cur; cur = cur.parentNode ) {
+ eventPath.push( cur );
+ tmp = cur;
+ }
+
+ // Only add window if we got to document (e.g., not plain obj or detached DOM)
+ if ( tmp === ( elem.ownerDocument || document ) ) {
+ eventPath.push( tmp.defaultView || tmp.parentWindow || window );
+ }
+ }
+
+ // Fire handlers on the event path
+ i = 0;
+ while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
+ lastElement = cur;
+ event.type = i > 1 ?
+ bubbleType :
+ special.bindType || type;
+
+ // jQuery handler
+ handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] &&
+ dataPriv.get( cur, "handle" );
+ if ( handle ) {
+ handle.apply( cur, data );
+ }
+
+ // Native handler
+ handle = ontype && cur[ ontype ];
+ if ( handle && handle.apply && acceptData( cur ) ) {
+ event.result = handle.apply( cur, data );
+ if ( event.result === false ) {
+ event.preventDefault();
+ }
+ }
+ }
+ event.type = type;
+
+ // If nobody prevented the default action, do it now
+ if ( !onlyHandlers && !event.isDefaultPrevented() ) {
+
+ if ( ( !special._default ||
+ special._default.apply( eventPath.pop(), data ) === false ) &&
+ acceptData( elem ) ) {
+
+ // Call a native DOM method on the target with the same name as the event.
+ // Don't do default actions on window, that's where global variables be (#6170)
+ if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
+
+ // Don't re-trigger an onFOO event when we call its FOO() method
+ tmp = elem[ ontype ];
+
+ if ( tmp ) {
+ elem[ ontype ] = null;
+ }
+
+ // Prevent re-triggering of the same event, since we already bubbled it above
+ jQuery.event.triggered = type;
+
+ if ( event.isPropagationStopped() ) {
+ lastElement.addEventListener( type, stopPropagationCallback );
+ }
+
+ elem[ type ]();
+
+ if ( event.isPropagationStopped() ) {
+ lastElement.removeEventListener( type, stopPropagationCallback );
+ }
+
+ jQuery.event.triggered = undefined;
+
+ if ( tmp ) {
+ elem[ ontype ] = tmp;
+ }
+ }
+ }
+ }
+
+ return event.result;
+ },
+
+ // Piggyback on a donor event to simulate a different one
+ // Used only for `focus(in | out)` events
+ simulate: function( type, elem, event ) {
+ var e = jQuery.extend(
+ new jQuery.Event(),
+ event,
+ {
+ type: type,
+ isSimulated: true
+ }
+ );
+
+ jQuery.event.trigger( e, null, elem );
+ }
+
+} );
+
+jQuery.fn.extend( {
+
+ trigger: function( type, data ) {
+ return this.each( function() {
+ jQuery.event.trigger( type, data, this );
+ } );
+ },
+ triggerHandler: function( type, data ) {
+ var elem = this[ 0 ];
+ if ( elem ) {
+ return jQuery.event.trigger( type, data, elem, true );
+ }
+ }
+} );
+
+
+// Support: Firefox <=44
+// Firefox doesn't have focus(in | out) events
+// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
+//
+// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
+// focus(in | out) events fire after focus & blur events,
+// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
+// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
+if ( !support.focusin ) {
+ jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
+
+ // Attach a single capturing handler on the document while someone wants focusin/focusout
+ var handler = function( event ) {
+ jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
+ };
+
+ jQuery.event.special[ fix ] = {
+ setup: function() {
+
+ // Handle: regular nodes (via `this.ownerDocument`), window
+ // (via `this.document`) & document (via `this`).
+ var doc = this.ownerDocument || this.document || this,
+ attaches = dataPriv.access( doc, fix );
+
+ if ( !attaches ) {
+ doc.addEventListener( orig, handler, true );
+ }
+ dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
+ },
+ teardown: function() {
+ var doc = this.ownerDocument || this.document || this,
+ attaches = dataPriv.access( doc, fix ) - 1;
+
+ if ( !attaches ) {
+ doc.removeEventListener( orig, handler, true );
+ dataPriv.remove( doc, fix );
+
+ } else {
+ dataPriv.access( doc, fix, attaches );
+ }
+ }
+ };
+ } );
+}
+var location = window.location;
+
+var nonce = { guid: Date.now() };
+
+var rquery = ( /\?/ );
+
+
+
+// Cross-browser xml parsing
+jQuery.parseXML = function( data ) {
+ var xml, parserErrorElem;
+ if ( !data || typeof data !== "string" ) {
+ return null;
+ }
+
+ // Support: IE 9 - 11 only
+ // IE throws on parseFromString with invalid input.
+ try {
+ xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
+ } catch ( e ) {}
+
+ parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ];
+ if ( !xml || parserErrorElem ) {
+ jQuery.error( "Invalid XML: " + (
+ parserErrorElem ?
+ jQuery.map( parserErrorElem.childNodes, function( el ) {
+ return el.textContent;
+ } ).join( "\n" ) :
+ data
+ ) );
+ }
+ return xml;
+};
+
+
+var
+ rbracket = /\[\]$/,
+ rCRLF = /\r?\n/g,
+ rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
+ rsubmittable = /^(?:input|select|textarea|keygen)/i;
+
+function buildParams( prefix, obj, traditional, add ) {
+ var name;
+
+ if ( Array.isArray( obj ) ) {
+
+ // Serialize array item.
+ jQuery.each( obj, function( i, v ) {
+ if ( traditional || rbracket.test( prefix ) ) {
+
+ // Treat each array item as a scalar.
+ add( prefix, v );
+
+ } else {
+
+ // Item is non-scalar (array or object), encode its numeric index.
+ buildParams(
+ prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
+ v,
+ traditional,
+ add
+ );
+ }
+ } );
+
+ } else if ( !traditional && toType( obj ) === "object" ) {
+
+ // Serialize object item.
+ for ( name in obj ) {
+ buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
+ }
+
+ } else {
+
+ // Serialize scalar item.
+ add( prefix, obj );
+ }
+}
+
+// Serialize an array of form elements or a set of
+// key/values into a query string
+jQuery.param = function( a, traditional ) {
+ var prefix,
+ s = [],
+ add = function( key, valueOrFunction ) {
+
+ // If value is a function, invoke it and use its return value
+ var value = isFunction( valueOrFunction ) ?
+ valueOrFunction() :
+ valueOrFunction;
+
+ s[ s.length ] = encodeURIComponent( key ) + "=" +
+ encodeURIComponent( value == null ? "" : value );
+ };
+
+ if ( a == null ) {
+ return "";
+ }
+
+ // If an array was passed in, assume that it is an array of form elements.
+ if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
+
+ // Serialize the form elements
+ jQuery.each( a, function() {
+ add( this.name, this.value );
+ } );
+
+ } else {
+
+ // If traditional, encode the "old" way (the way 1.3.2 or older
+ // did it), otherwise encode params recursively.
+ for ( prefix in a ) {
+ buildParams( prefix, a[ prefix ], traditional, add );
+ }
+ }
+
+ // Return the resulting serialization
+ return s.join( "&" );
+};
+
+jQuery.fn.extend( {
+ serialize: function() {
+ return jQuery.param( this.serializeArray() );
+ },
+ serializeArray: function() {
+ return this.map( function() {
+
+ // Can add propHook for "elements" to filter or add form elements
+ var elements = jQuery.prop( this, "elements" );
+ return elements ? jQuery.makeArray( elements ) : this;
+ } ).filter( function() {
+ var type = this.type;
+
+ // Use .is( ":disabled" ) so that fieldset[disabled] works
+ return this.name && !jQuery( this ).is( ":disabled" ) &&
+ rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
+ ( this.checked || !rcheckableType.test( type ) );
+ } ).map( function( _i, elem ) {
+ var val = jQuery( this ).val();
+
+ if ( val == null ) {
+ return null;
+ }
+
+ if ( Array.isArray( val ) ) {
+ return jQuery.map( val, function( val ) {
+ return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+ } );
+ }
+
+ return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+ } ).get();
+ }
+} );
+
+
+var
+ r20 = /%20/g,
+ rhash = /#.*$/,
+ rantiCache = /([?&])_=[^&]*/,
+ rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
+
+ // #7653, #8125, #8152: local protocol detection
+ rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
+ rnoContent = /^(?:GET|HEAD)$/,
+ rprotocol = /^\/\//,
+
+ /* Prefilters
+ * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
+ * 2) These are called:
+ * - BEFORE asking for a transport
+ * - AFTER param serialization (s.data is a string if s.processData is true)
+ * 3) key is the dataType
+ * 4) the catchall symbol "*" can be used
+ * 5) execution will start with transport dataType and THEN continue down to "*" if needed
+ */
+ prefilters = {},
+
+ /* Transports bindings
+ * 1) key is the dataType
+ * 2) the catchall symbol "*" can be used
+ * 3) selection will start with transport dataType and THEN go to "*" if needed
+ */
+ transports = {},
+
+ // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
+ allTypes = "*/".concat( "*" ),
+
+ // Anchor tag for parsing the document origin
+ originAnchor = document.createElement( "a" );
+
+originAnchor.href = location.href;
+
+// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
+function addToPrefiltersOrTransports( structure ) {
+
+ // dataTypeExpression is optional and defaults to "*"
+ return function( dataTypeExpression, func ) {
+
+ if ( typeof dataTypeExpression !== "string" ) {
+ func = dataTypeExpression;
+ dataTypeExpression = "*";
+ }
+
+ var dataType,
+ i = 0,
+ dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
+
+ if ( isFunction( func ) ) {
+
+ // For each dataType in the dataTypeExpression
+ while ( ( dataType = dataTypes[ i++ ] ) ) {
+
+ // Prepend if requested
+ if ( dataType[ 0 ] === "+" ) {
+ dataType = dataType.slice( 1 ) || "*";
+ ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
+
+ // Otherwise append
+ } else {
+ ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
+ }
+ }
+ }
+ };
+}
+
+// Base inspection function for prefilters and transports
+function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
+
+ var inspected = {},
+ seekingTransport = ( structure === transports );
+
+ function inspect( dataType ) {
+ var selected;
+ inspected[ dataType ] = true;
+ jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
+ var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
+ if ( typeof dataTypeOrTransport === "string" &&
+ !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
+
+ options.dataTypes.unshift( dataTypeOrTransport );
+ inspect( dataTypeOrTransport );
+ return false;
+ } else if ( seekingTransport ) {
+ return !( selected = dataTypeOrTransport );
+ }
+ } );
+ return selected;
+ }
+
+ return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
+}
+
+// A special extend for ajax options
+// that takes "flat" options (not to be deep extended)
+// Fixes #9887
+function ajaxExtend( target, src ) {
+ var key, deep,
+ flatOptions = jQuery.ajaxSettings.flatOptions || {};
+
+ for ( key in src ) {
+ if ( src[ key ] !== undefined ) {
+ ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
+ }
+ }
+ if ( deep ) {
+ jQuery.extend( true, target, deep );
+ }
+
+ return target;
+}
+
+/* Handles responses to an ajax request:
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+function ajaxHandleResponses( s, jqXHR, responses ) {
+
+ var ct, type, finalDataType, firstDataType,
+ contents = s.contents,
+ dataTypes = s.dataTypes;
+
+ // Remove auto dataType and get content-type in the process
+ while ( dataTypes[ 0 ] === "*" ) {
+ dataTypes.shift();
+ if ( ct === undefined ) {
+ ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
+ }
+ }
+
+ // Check if we're dealing with a known content-type
+ if ( ct ) {
+ for ( type in contents ) {
+ if ( contents[ type ] && contents[ type ].test( ct ) ) {
+ dataTypes.unshift( type );
+ break;
+ }
+ }
+ }
+
+ // Check to see if we have a response for the expected dataType
+ if ( dataTypes[ 0 ] in responses ) {
+ finalDataType = dataTypes[ 0 ];
+ } else {
+
+ // Try convertible dataTypes
+ for ( type in responses ) {
+ if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
+ finalDataType = type;
+ break;
+ }
+ if ( !firstDataType ) {
+ firstDataType = type;
+ }
+ }
+
+ // Or just use first one
+ finalDataType = finalDataType || firstDataType;
+ }
+
+ // If we found a dataType
+ // We add the dataType to the list if needed
+ // and return the corresponding response
+ if ( finalDataType ) {
+ if ( finalDataType !== dataTypes[ 0 ] ) {
+ dataTypes.unshift( finalDataType );
+ }
+ return responses[ finalDataType ];
+ }
+}
+
+/* Chain conversions given the request and the original response
+ * Also sets the responseXXX fields on the jqXHR instance
+ */
+function ajaxConvert( s, response, jqXHR, isSuccess ) {
+ var conv2, current, conv, tmp, prev,
+ converters = {},
+
+ // Work with a copy of dataTypes in case we need to modify it for conversion
+ dataTypes = s.dataTypes.slice();
+
+ // Create converters map with lowercased keys
+ if ( dataTypes[ 1 ] ) {
+ for ( conv in s.converters ) {
+ converters[ conv.toLowerCase() ] = s.converters[ conv ];
+ }
+ }
+
+ current = dataTypes.shift();
+
+ // Convert to each sequential dataType
+ while ( current ) {
+
+ if ( s.responseFields[ current ] ) {
+ jqXHR[ s.responseFields[ current ] ] = response;
+ }
+
+ // Apply the dataFilter if provided
+ if ( !prev && isSuccess && s.dataFilter ) {
+ response = s.dataFilter( response, s.dataType );
+ }
+
+ prev = current;
+ current = dataTypes.shift();
+
+ if ( current ) {
+
+ // There's only work to do if current dataType is non-auto
+ if ( current === "*" ) {
+
+ current = prev;
+
+ // Convert response if prev dataType is non-auto and differs from current
+ } else if ( prev !== "*" && prev !== current ) {
+
+ // Seek a direct converter
+ conv = converters[ prev + " " + current ] || converters[ "* " + current ];
+
+ // If none found, seek a pair
+ if ( !conv ) {
+ for ( conv2 in converters ) {
+
+ // If conv2 outputs current
+ tmp = conv2.split( " " );
+ if ( tmp[ 1 ] === current ) {
+
+ // If prev can be converted to accepted input
+ conv = converters[ prev + " " + tmp[ 0 ] ] ||
+ converters[ "* " + tmp[ 0 ] ];
+ if ( conv ) {
+
+ // Condense equivalence converters
+ if ( conv === true ) {
+ conv = converters[ conv2 ];
+
+ // Otherwise, insert the intermediate dataType
+ } else if ( converters[ conv2 ] !== true ) {
+ current = tmp[ 0 ];
+ dataTypes.unshift( tmp[ 1 ] );
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ // Apply converter (if not an equivalence)
+ if ( conv !== true ) {
+
+ // Unless errors are allowed to bubble, catch and return them
+ if ( conv && s.throws ) {
+ response = conv( response );
+ } else {
+ try {
+ response = conv( response );
+ } catch ( e ) {
+ return {
+ state: "parsererror",
+ error: conv ? e : "No conversion from " + prev + " to " + current
+ };
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return { state: "success", data: response };
+}
+
+jQuery.extend( {
+
+ // Counter for holding the number of active queries
+ active: 0,
+
+ // Last-Modified header cache for next request
+ lastModified: {},
+ etag: {},
+
+ ajaxSettings: {
+ url: location.href,
+ type: "GET",
+ isLocal: rlocalProtocol.test( location.protocol ),
+ global: true,
+ processData: true,
+ async: true,
+ contentType: "application/x-www-form-urlencoded; charset=UTF-8",
+
+ /*
+ timeout: 0,
+ data: null,
+ dataType: null,
+ username: null,
+ password: null,
+ cache: null,
+ throws: false,
+ traditional: false,
+ headers: {},
+ */
+
+ accepts: {
+ "*": allTypes,
+ text: "text/plain",
+ html: "text/html",
+ xml: "application/xml, text/xml",
+ json: "application/json, text/javascript"
+ },
+
+ contents: {
+ xml: /\bxml\b/,
+ html: /\bhtml/,
+ json: /\bjson\b/
+ },
+
+ responseFields: {
+ xml: "responseXML",
+ text: "responseText",
+ json: "responseJSON"
+ },
+
+ // Data converters
+ // Keys separate source (or catchall "*") and destination types with a single space
+ converters: {
+
+ // Convert anything to text
+ "* text": String,
+
+ // Text to html (true = no transformation)
+ "text html": true,
+
+ // Evaluate text as a json expression
+ "text json": JSON.parse,
+
+ // Parse text as xml
+ "text xml": jQuery.parseXML
+ },
+
+ // For options that shouldn't be deep extended:
+ // you can add your own custom options here if
+ // and when you create one that shouldn't be
+ // deep extended (see ajaxExtend)
+ flatOptions: {
+ url: true,
+ context: true
+ }
+ },
+
+ // Creates a full fledged settings object into target
+ // with both ajaxSettings and settings fields.
+ // If target is omitted, writes into ajaxSettings.
+ ajaxSetup: function( target, settings ) {
+ return settings ?
+
+ // Building a settings object
+ ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
+
+ // Extending ajaxSettings
+ ajaxExtend( jQuery.ajaxSettings, target );
+ },
+
+ ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
+ ajaxTransport: addToPrefiltersOrTransports( transports ),
+
+ // Main method
+ ajax: function( url, options ) {
+
+ // If url is an object, simulate pre-1.5 signature
+ if ( typeof url === "object" ) {
+ options = url;
+ url = undefined;
+ }
+
+ // Force options to be an object
+ options = options || {};
+
+ var transport,
+
+ // URL without anti-cache param
+ cacheURL,
+
+ // Response headers
+ responseHeadersString,
+ responseHeaders,
+
+ // timeout handle
+ timeoutTimer,
+
+ // Url cleanup var
+ urlAnchor,
+
+ // Request state (becomes false upon send and true upon completion)
+ completed,
+
+ // To know if global events are to be dispatched
+ fireGlobals,
+
+ // Loop variable
+ i,
+
+ // uncached part of the url
+ uncached,
+
+ // Create the final options object
+ s = jQuery.ajaxSetup( {}, options ),
+
+ // Callbacks context
+ callbackContext = s.context || s,
+
+ // Context for global events is callbackContext if it is a DOM node or jQuery collection
+ globalEventContext = s.context &&
+ ( callbackContext.nodeType || callbackContext.jquery ) ?
+ jQuery( callbackContext ) :
+ jQuery.event,
+
+ // Deferreds
+ deferred = jQuery.Deferred(),
+ completeDeferred = jQuery.Callbacks( "once memory" ),
+
+ // Status-dependent callbacks
+ statusCode = s.statusCode || {},
+
+ // Headers (they are sent all at once)
+ requestHeaders = {},
+ requestHeadersNames = {},
+
+ // Default abort message
+ strAbort = "canceled",
+
+ // Fake xhr
+ jqXHR = {
+ readyState: 0,
+
+ // Builds headers hashtable if needed
+ getResponseHeader: function( key ) {
+ var match;
+ if ( completed ) {
+ if ( !responseHeaders ) {
+ responseHeaders = {};
+ while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
+ responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
+ ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
+ .concat( match[ 2 ] );
+ }
+ }
+ match = responseHeaders[ key.toLowerCase() + " " ];
+ }
+ return match == null ? null : match.join( ", " );
+ },
+
+ // Raw string
+ getAllResponseHeaders: function() {
+ return completed ? responseHeadersString : null;
+ },
+
+ // Caches the header
+ setRequestHeader: function( name, value ) {
+ if ( completed == null ) {
+ name = requestHeadersNames[ name.toLowerCase() ] =
+ requestHeadersNames[ name.toLowerCase() ] || name;
+ requestHeaders[ name ] = value;
+ }
+ return this;
+ },
+
+ // Overrides response content-type header
+ overrideMimeType: function( type ) {
+ if ( completed == null ) {
+ s.mimeType = type;
+ }
+ return this;
+ },
+
+ // Status-dependent callbacks
+ statusCode: function( map ) {
+ var code;
+ if ( map ) {
+ if ( completed ) {
+
+ // Execute the appropriate callbacks
+ jqXHR.always( map[ jqXHR.status ] );
+ } else {
+
+ // Lazy-add the new callbacks in a way that preserves old ones
+ for ( code in map ) {
+ statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
+ }
+ }
+ }
+ return this;
+ },
+
+ // Cancel the request
+ abort: function( statusText ) {
+ var finalText = statusText || strAbort;
+ if ( transport ) {
+ transport.abort( finalText );
+ }
+ done( 0, finalText );
+ return this;
+ }
+ };
+
+ // Attach deferreds
+ deferred.promise( jqXHR );
+
+ // Add protocol if not provided (prefilters might expect it)
+ // Handle falsy url in the settings object (#10093: consistency with old signature)
+ // We also use the url parameter if available
+ s.url = ( ( url || s.url || location.href ) + "" )
+ .replace( rprotocol, location.protocol + "//" );
+
+ // Alias method option to type as per ticket #12004
+ s.type = options.method || options.type || s.method || s.type;
+
+ // Extract dataTypes list
+ s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
+
+ // A cross-domain request is in order when the origin doesn't match the current origin.
+ if ( s.crossDomain == null ) {
+ urlAnchor = document.createElement( "a" );
+
+ // Support: IE <=8 - 11, Edge 12 - 15
+ // IE throws exception on accessing the href property if url is malformed,
+ // e.g. http://example.com:80x/
+ try {
+ urlAnchor.href = s.url;
+
+ // Support: IE <=8 - 11 only
+ // Anchor's host property isn't correctly set when s.url is relative
+ urlAnchor.href = urlAnchor.href;
+ s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
+ urlAnchor.protocol + "//" + urlAnchor.host;
+ } catch ( e ) {
+
+ // If there is an error parsing the URL, assume it is crossDomain,
+ // it can be rejected by the transport if it is invalid
+ s.crossDomain = true;
+ }
+ }
+
+ // Convert data if not already a string
+ if ( s.data && s.processData && typeof s.data !== "string" ) {
+ s.data = jQuery.param( s.data, s.traditional );
+ }
+
+ // Apply prefilters
+ inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
+
+ // If request was aborted inside a prefilter, stop there
+ if ( completed ) {
+ return jqXHR;
+ }
+
+ // We can fire global events as of now if asked to
+ // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
+ fireGlobals = jQuery.event && s.global;
+
+ // Watch for a new set of requests
+ if ( fireGlobals && jQuery.active++ === 0 ) {
+ jQuery.event.trigger( "ajaxStart" );
+ }
+
+ // Uppercase the type
+ s.type = s.type.toUpperCase();
+
+ // Determine if request has content
+ s.hasContent = !rnoContent.test( s.type );
+
+ // Save the URL in case we're toying with the If-Modified-Since
+ // and/or If-None-Match header later on
+ // Remove hash to simplify url manipulation
+ cacheURL = s.url.replace( rhash, "" );
+
+ // More options handling for requests with no content
+ if ( !s.hasContent ) {
+
+ // Remember the hash so we can put it back
+ uncached = s.url.slice( cacheURL.length );
+
+ // If data is available and should be processed, append data to url
+ if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
+ cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
+
+ // #9682: remove data so that it's not used in an eventual retry
+ delete s.data;
+ }
+
+ // Add or update anti-cache param if needed
+ if ( s.cache === false ) {
+ cacheURL = cacheURL.replace( rantiCache, "$1" );
+ uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
+ uncached;
+ }
+
+ // Put hash and anti-cache on the URL that will be requested (gh-1732)
+ s.url = cacheURL + uncached;
+
+ // Change '%20' to '+' if this is encoded form body content (gh-2658)
+ } else if ( s.data && s.processData &&
+ ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
+ s.data = s.data.replace( r20, "+" );
+ }
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ if ( jQuery.lastModified[ cacheURL ] ) {
+ jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
+ }
+ if ( jQuery.etag[ cacheURL ] ) {
+ jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
+ }
+ }
+
+ // Set the correct header, if data is being sent
+ if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
+ jqXHR.setRequestHeader( "Content-Type", s.contentType );
+ }
+
+ // Set the Accepts header for the server, depending on the dataType
+ jqXHR.setRequestHeader(
+ "Accept",
+ s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
+ s.accepts[ s.dataTypes[ 0 ] ] +
+ ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
+ s.accepts[ "*" ]
+ );
+
+ // Check for headers option
+ for ( i in s.headers ) {
+ jqXHR.setRequestHeader( i, s.headers[ i ] );
+ }
+
+ // Allow custom headers/mimetypes and early abort
+ if ( s.beforeSend &&
+ ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
+
+ // Abort if not done already and return
+ return jqXHR.abort();
+ }
+
+ // Aborting is no longer a cancellation
+ strAbort = "abort";
+
+ // Install callbacks on deferreds
+ completeDeferred.add( s.complete );
+ jqXHR.done( s.success );
+ jqXHR.fail( s.error );
+
+ // Get transport
+ transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
+
+ // If no transport, we auto-abort
+ if ( !transport ) {
+ done( -1, "No Transport" );
+ } else {
+ jqXHR.readyState = 1;
+
+ // Send global event
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
+ }
+
+ // If request was aborted inside ajaxSend, stop there
+ if ( completed ) {
+ return jqXHR;
+ }
+
+ // Timeout
+ if ( s.async && s.timeout > 0 ) {
+ timeoutTimer = window.setTimeout( function() {
+ jqXHR.abort( "timeout" );
+ }, s.timeout );
+ }
+
+ try {
+ completed = false;
+ transport.send( requestHeaders, done );
+ } catch ( e ) {
+
+ // Rethrow post-completion exceptions
+ if ( completed ) {
+ throw e;
+ }
+
+ // Propagate others as results
+ done( -1, e );
+ }
+ }
+
+ // Callback for when everything is done
+ function done( status, nativeStatusText, responses, headers ) {
+ var isSuccess, success, error, response, modified,
+ statusText = nativeStatusText;
+
+ // Ignore repeat invocations
+ if ( completed ) {
+ return;
+ }
+
+ completed = true;
+
+ // Clear timeout if it exists
+ if ( timeoutTimer ) {
+ window.clearTimeout( timeoutTimer );
+ }
+
+ // Dereference transport for early garbage collection
+ // (no matter how long the jqXHR object will be used)
+ transport = undefined;
+
+ // Cache response headers
+ responseHeadersString = headers || "";
+
+ // Set readyState
+ jqXHR.readyState = status > 0 ? 4 : 0;
+
+ // Determine if successful
+ isSuccess = status >= 200 && status < 300 || status === 304;
+
+ // Get response data
+ if ( responses ) {
+ response = ajaxHandleResponses( s, jqXHR, responses );
+ }
+
+ // Use a noop converter for missing script but not if jsonp
+ if ( !isSuccess &&
+ jQuery.inArray( "script", s.dataTypes ) > -1 &&
+ jQuery.inArray( "json", s.dataTypes ) < 0 ) {
+ s.converters[ "text script" ] = function() {};
+ }
+
+ // Convert no matter what (that way responseXXX fields are always set)
+ response = ajaxConvert( s, response, jqXHR, isSuccess );
+
+ // If successful, handle type chaining
+ if ( isSuccess ) {
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ modified = jqXHR.getResponseHeader( "Last-Modified" );
+ if ( modified ) {
+ jQuery.lastModified[ cacheURL ] = modified;
+ }
+ modified = jqXHR.getResponseHeader( "etag" );
+ if ( modified ) {
+ jQuery.etag[ cacheURL ] = modified;
+ }
+ }
+
+ // if no content
+ if ( status === 204 || s.type === "HEAD" ) {
+ statusText = "nocontent";
+
+ // if not modified
+ } else if ( status === 304 ) {
+ statusText = "notmodified";
+
+ // If we have data, let's convert it
+ } else {
+ statusText = response.state;
+ success = response.data;
+ error = response.error;
+ isSuccess = !error;
+ }
+ } else {
+
+ // Extract error from statusText and normalize for non-aborts
+ error = statusText;
+ if ( status || !statusText ) {
+ statusText = "error";
+ if ( status < 0 ) {
+ status = 0;
+ }
+ }
+ }
+
+ // Set data for the fake xhr object
+ jqXHR.status = status;
+ jqXHR.statusText = ( nativeStatusText || statusText ) + "";
+
+ // Success/Error
+ if ( isSuccess ) {
+ deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
+ } else {
+ deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
+ }
+
+ // Status-dependent callbacks
+ jqXHR.statusCode( statusCode );
+ statusCode = undefined;
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
+ [ jqXHR, s, isSuccess ? success : error ] );
+ }
+
+ // Complete
+ completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
+
+ // Handle the global AJAX counter
+ if ( !( --jQuery.active ) ) {
+ jQuery.event.trigger( "ajaxStop" );
+ }
+ }
+ }
+
+ return jqXHR;
+ },
+
+ getJSON: function( url, data, callback ) {
+ return jQuery.get( url, data, callback, "json" );
+ },
+
+ getScript: function( url, callback ) {
+ return jQuery.get( url, undefined, callback, "script" );
+ }
+} );
+
+jQuery.each( [ "get", "post" ], function( _i, method ) {
+ jQuery[ method ] = function( url, data, callback, type ) {
+
+ // Shift arguments if data argument was omitted
+ if ( isFunction( data ) ) {
+ type = type || callback;
+ callback = data;
+ data = undefined;
+ }
+
+ // The url can be an options object (which then must have .url)
+ return jQuery.ajax( jQuery.extend( {
+ url: url,
+ type: method,
+ dataType: type,
+ data: data,
+ success: callback
+ }, jQuery.isPlainObject( url ) && url ) );
+ };
+} );
+
+jQuery.ajaxPrefilter( function( s ) {
+ var i;
+ for ( i in s.headers ) {
+ if ( i.toLowerCase() === "content-type" ) {
+ s.contentType = s.headers[ i ] || "";
+ }
+ }
+} );
+
+
+jQuery._evalUrl = function( url, options, doc ) {
+ return jQuery.ajax( {
+ url: url,
+
+ // Make this explicit, since user can override this through ajaxSetup (#11264)
+ type: "GET",
+ dataType: "script",
+ cache: true,
+ async: false,
+ global: false,
+
+ // Only evaluate the response if it is successful (gh-4126)
+ // dataFilter is not invoked for failure responses, so using it instead
+ // of the default converter is kludgy but it works.
+ converters: {
+ "text script": function() {}
+ },
+ dataFilter: function( response ) {
+ jQuery.globalEval( response, options, doc );
+ }
+ } );
+};
+
+
+jQuery.fn.extend( {
+ wrapAll: function( html ) {
+ var wrap;
+
+ if ( this[ 0 ] ) {
+ if ( isFunction( html ) ) {
+ html = html.call( this[ 0 ] );
+ }
+
+ // The elements to wrap the target around
+ wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
+
+ if ( this[ 0 ].parentNode ) {
+ wrap.insertBefore( this[ 0 ] );
+ }
+
+ wrap.map( function() {
+ var elem = this;
+
+ while ( elem.firstElementChild ) {
+ elem = elem.firstElementChild;
+ }
+
+ return elem;
+ } ).append( this );
+ }
+
+ return this;
+ },
+
+ wrapInner: function( html ) {
+ if ( isFunction( html ) ) {
+ return this.each( function( i ) {
+ jQuery( this ).wrapInner( html.call( this, i ) );
+ } );
+ }
+
+ return this.each( function() {
+ var self = jQuery( this ),
+ contents = self.contents();
+
+ if ( contents.length ) {
+ contents.wrapAll( html );
+
+ } else {
+ self.append( html );
+ }
+ } );
+ },
+
+ wrap: function( html ) {
+ var htmlIsFunction = isFunction( html );
+
+ return this.each( function( i ) {
+ jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
+ } );
+ },
+
+ unwrap: function( selector ) {
+ this.parent( selector ).not( "body" ).each( function() {
+ jQuery( this ).replaceWith( this.childNodes );
+ } );
+ return this;
+ }
+} );
+
+
+jQuery.expr.pseudos.hidden = function( elem ) {
+ return !jQuery.expr.pseudos.visible( elem );
+};
+jQuery.expr.pseudos.visible = function( elem ) {
+ return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
+};
+
+
+
+
+jQuery.ajaxSettings.xhr = function() {
+ try {
+ return new window.XMLHttpRequest();
+ } catch ( e ) {}
+};
+
+var xhrSuccessStatus = {
+
+ // File protocol always yields status code 0, assume 200
+ 0: 200,
+
+ // Support: IE <=9 only
+ // #1450: sometimes IE returns 1223 when it should be 204
+ 1223: 204
+ },
+ xhrSupported = jQuery.ajaxSettings.xhr();
+
+support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
+support.ajax = xhrSupported = !!xhrSupported;
+
+jQuery.ajaxTransport( function( options ) {
+ var callback, errorCallback;
+
+ // Cross domain only allowed if supported through XMLHttpRequest
+ if ( support.cors || xhrSupported && !options.crossDomain ) {
+ return {
+ send: function( headers, complete ) {
+ var i,
+ xhr = options.xhr();
+
+ xhr.open(
+ options.type,
+ options.url,
+ options.async,
+ options.username,
+ options.password
+ );
+
+ // Apply custom fields if provided
+ if ( options.xhrFields ) {
+ for ( i in options.xhrFields ) {
+ xhr[ i ] = options.xhrFields[ i ];
+ }
+ }
+
+ // Override mime type if needed
+ if ( options.mimeType && xhr.overrideMimeType ) {
+ xhr.overrideMimeType( options.mimeType );
+ }
+
+ // X-Requested-With header
+ // For cross-domain requests, seeing as conditions for a preflight are
+ // akin to a jigsaw puzzle, we simply never set it to be sure.
+ // (it can always be set on a per-request basis or even using ajaxSetup)
+ // For same-domain requests, won't change header if already provided.
+ if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
+ headers[ "X-Requested-With" ] = "XMLHttpRequest";
+ }
+
+ // Set headers
+ for ( i in headers ) {
+ xhr.setRequestHeader( i, headers[ i ] );
+ }
+
+ // Callback
+ callback = function( type ) {
+ return function() {
+ if ( callback ) {
+ callback = errorCallback = xhr.onload =
+ xhr.onerror = xhr.onabort = xhr.ontimeout =
+ xhr.onreadystatechange = null;
+
+ if ( type === "abort" ) {
+ xhr.abort();
+ } else if ( type === "error" ) {
+
+ // Support: IE <=9 only
+ // On a manual native abort, IE9 throws
+ // errors on any property access that is not readyState
+ if ( typeof xhr.status !== "number" ) {
+ complete( 0, "error" );
+ } else {
+ complete(
+
+ // File: protocol always yields status 0; see #8605, #14207
+ xhr.status,
+ xhr.statusText
+ );
+ }
+ } else {
+ complete(
+ xhrSuccessStatus[ xhr.status ] || xhr.status,
+ xhr.statusText,
+
+ // Support: IE <=9 only
+ // IE9 has no XHR2 but throws on binary (trac-11426)
+ // For XHR2 non-text, let the caller handle it (gh-2498)
+ ( xhr.responseType || "text" ) !== "text" ||
+ typeof xhr.responseText !== "string" ?
+ { binary: xhr.response } :
+ { text: xhr.responseText },
+ xhr.getAllResponseHeaders()
+ );
+ }
+ }
+ };
+ };
+
+ // Listen to events
+ xhr.onload = callback();
+ errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
+
+ // Support: IE 9 only
+ // Use onreadystatechange to replace onabort
+ // to handle uncaught aborts
+ if ( xhr.onabort !== undefined ) {
+ xhr.onabort = errorCallback;
+ } else {
+ xhr.onreadystatechange = function() {
+
+ // Check readyState before timeout as it changes
+ if ( xhr.readyState === 4 ) {
+
+ // Allow onerror to be called first,
+ // but that will not handle a native abort
+ // Also, save errorCallback to a variable
+ // as xhr.onerror cannot be accessed
+ window.setTimeout( function() {
+ if ( callback ) {
+ errorCallback();
+ }
+ } );
+ }
+ };
+ }
+
+ // Create the abort callback
+ callback = callback( "abort" );
+
+ try {
+
+ // Do send the request (this may raise an exception)
+ xhr.send( options.hasContent && options.data || null );
+ } catch ( e ) {
+
+ // #14683: Only rethrow if this hasn't been notified as an error yet
+ if ( callback ) {
+ throw e;
+ }
+ }
+ },
+
+ abort: function() {
+ if ( callback ) {
+ callback();
+ }
+ }
+ };
+ }
+} );
+
+
+
+
+// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
+jQuery.ajaxPrefilter( function( s ) {
+ if ( s.crossDomain ) {
+ s.contents.script = false;
+ }
+} );
+
+// Install script dataType
+jQuery.ajaxSetup( {
+ accepts: {
+ script: "text/javascript, application/javascript, " +
+ "application/ecmascript, application/x-ecmascript"
+ },
+ contents: {
+ script: /\b(?:java|ecma)script\b/
+ },
+ converters: {
+ "text script": function( text ) {
+ jQuery.globalEval( text );
+ return text;
+ }
+ }
+} );
+
+// Handle cache's special case and crossDomain
+jQuery.ajaxPrefilter( "script", function( s ) {
+ if ( s.cache === undefined ) {
+ s.cache = false;
+ }
+ if ( s.crossDomain ) {
+ s.type = "GET";
+ }
+} );
+
+// Bind script tag hack transport
+jQuery.ajaxTransport( "script", function( s ) {
+
+ // This transport only deals with cross domain or forced-by-attrs requests
+ if ( s.crossDomain || s.scriptAttrs ) {
+ var script, callback;
+ return {
+ send: function( _, complete ) {
+ script = jQuery( "<script>" )
+ .attr( s.scriptAttrs || {} )
+ .prop( { charset: s.scriptCharset, src: s.url } )
+ .on( "load error", callback = function( evt ) {
+ script.remove();
+ callback = null;
+ if ( evt ) {
+ complete( evt.type === "error" ? 404 : 200, evt.type );
+ }
+ } );
+
+ // Use native DOM manipulation to avoid our domManip AJAX trickery
+ document.head.appendChild( script[ 0 ] );
+ },
+ abort: function() {
+ if ( callback ) {
+ callback();
+ }
+ }
+ };
+ }
+} );
+
+
+
+
+var oldCallbacks = [],
+ rjsonp = /(=)\?(?=&|$)|\?\?/;
+
+// Default jsonp settings
+jQuery.ajaxSetup( {
+ jsonp: "callback",
+ jsonpCallback: function() {
+ var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) );
+ this[ callback ] = true;
+ return callback;
+ }
+} );
+
+// Detect, normalize options and install callbacks for jsonp requests
+jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
+
+ var callbackName, overwritten, responseContainer,
+ jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
+ "url" :
+ typeof s.data === "string" &&
+ ( s.contentType || "" )
+ .indexOf( "application/x-www-form-urlencoded" ) === 0 &&
+ rjsonp.test( s.data ) && "data"
+ );
+
+ // Handle iff the expected data type is "jsonp" or we have a parameter to set
+ if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
+
+ // Get callback name, remembering preexisting value associated with it
+ callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
+ s.jsonpCallback() :
+ s.jsonpCallback;
+
+ // Insert callback into url or form data
+ if ( jsonProp ) {
+ s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
+ } else if ( s.jsonp !== false ) {
+ s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
+ }
+
+ // Use data converter to retrieve json after script execution
+ s.converters[ "script json" ] = function() {
+ if ( !responseContainer ) {
+ jQuery.error( callbackName + " was not called" );
+ }
+ return responseContainer[ 0 ];
+ };
+
+ // Force json dataType
+ s.dataTypes[ 0 ] = "json";
+
+ // Install callback
+ overwritten = window[ callbackName ];
+ window[ callbackName ] = function() {
+ responseContainer = arguments;
+ };
+
+ // Clean-up function (fires after converters)
+ jqXHR.always( function() {
+
+ // If previous value didn't exist - remove it
+ if ( overwritten === undefined ) {
+ jQuery( window ).removeProp( callbackName );
+
+ // Otherwise restore preexisting value
+ } else {
+ window[ callbackName ] = overwritten;
+ }
+
+ // Save back as free
+ if ( s[ callbackName ] ) {
+
+ // Make sure that re-using the options doesn't screw things around
+ s.jsonpCallback = originalSettings.jsonpCallback;
+
+ // Save the callback name for future use
+ oldCallbacks.push( callbackName );
+ }
+
+ // Call if it was a function and we have a response
+ if ( responseContainer && isFunction( overwritten ) ) {
+ overwritten( responseContainer[ 0 ] );
+ }
+
+ responseContainer = overwritten = undefined;
+ } );
+
+ // Delegate to script
+ return "script";
+ }
+} );
+
+
+
+
+// Support: Safari 8 only
+// In Safari 8 documents created via document.implementation.createHTMLDocument
+// collapse sibling forms: the second one becomes a child of the first one.
+// Because of that, this security measure has to be disabled in Safari 8.
+// https://bugs.webkit.org/show_bug.cgi?id=137337
+support.createHTMLDocument = ( function() {
+ var body = document.implementation.createHTMLDocument( "" ).body;
+ body.innerHTML = "<form></form><form></form>";
+ return body.childNodes.length === 2;
+} )();
+
+
+// Argument "data" should be string of html
+// context (optional): If specified, the fragment will be created in this context,
+// defaults to document
+// keepScripts (optional): If true, will include scripts passed in the html string
+jQuery.parseHTML = function( data, context, keepScripts ) {
+ if ( typeof data !== "string" ) {
+ return [];
+ }
+ if ( typeof context === "boolean" ) {
+ keepScripts = context;
+ context = false;
+ }
+
+ var base, parsed, scripts;
+
+ if ( !context ) {
+
+ // Stop scripts or inline event handlers from being executed immediately
+ // by using document.implementation
+ if ( support.createHTMLDocument ) {
+ context = document.implementation.createHTMLDocument( "" );
+
+ // Set the base href for the created document
+ // so any parsed elements with URLs
+ // are based on the document's URL (gh-2965)
+ base = context.createElement( "base" );
+ base.href = document.location.href;
+ context.head.appendChild( base );
+ } else {
+ context = document;
+ }
+ }
+
+ parsed = rsingleTag.exec( data );
+ scripts = !keepScripts && [];
+
+ // Single tag
+ if ( parsed ) {
+ return [ context.createElement( parsed[ 1 ] ) ];
+ }
+
+ parsed = buildFragment( [ data ], context, scripts );
+
+ if ( scripts && scripts.length ) {
+ jQuery( scripts ).remove();
+ }
+
+ return jQuery.merge( [], parsed.childNodes );
+};
+
+
+/**
+ * Load a url into a page
+ */
+jQuery.fn.load = function( url, params, callback ) {
+ var selector, type, response,
+ self = this,
+ off = url.indexOf( " " );
+
+ if ( off > -1 ) {
+ selector = stripAndCollapse( url.slice( off ) );
+ url = url.slice( 0, off );
+ }
+
+ // If it's a function
+ if ( isFunction( params ) ) {
+
+ // We assume that it's the callback
+ callback = params;
+ params = undefined;
+
+ // Otherwise, build a param string
+ } else if ( params && typeof params === "object" ) {
+ type = "POST";
+ }
+
+ // If we have elements to modify, make the request
+ if ( self.length > 0 ) {
+ jQuery.ajax( {
+ url: url,
+
+ // If "type" variable is undefined, then "GET" method will be used.
+ // Make value of this field explicit since
+ // user can override it through ajaxSetup method
+ type: type || "GET",
+ dataType: "html",
+ data: params
+ } ).done( function( responseText ) {
+
+ // Save response for use in complete callback
+ response = arguments;
+
+ self.html( selector ?
+
+ // If a selector was specified, locate the right elements in a dummy div
+ // Exclude scripts to avoid IE 'Permission Denied' errors
+ jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
+
+ // Otherwise use the full result
+ responseText );
+
+ // If the request succeeds, this function gets "data", "status", "jqXHR"
+ // but they are ignored because response was set above.
+ // If it fails, this function gets "jqXHR", "status", "error"
+ } ).always( callback && function( jqXHR, status ) {
+ self.each( function() {
+ callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
+ } );
+ } );
+ }
+
+ return this;
+};
+
+
+
+
+jQuery.expr.pseudos.animated = function( elem ) {
+ return jQuery.grep( jQuery.timers, function( fn ) {
+ return elem === fn.elem;
+ } ).length;
+};
+
+
+
+
+jQuery.offset = {
+ setOffset: function( elem, options, i ) {
+ var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
+ position = jQuery.css( elem, "position" ),
+ curElem = jQuery( elem ),
+ props = {};
+
+ // Set position first, in-case top/left are set even on static elem
+ if ( position === "static" ) {
+ elem.style.position = "relative";
+ }
+
+ curOffset = curElem.offset();
+ curCSSTop = jQuery.css( elem, "top" );
+ curCSSLeft = jQuery.css( elem, "left" );
+ calculatePosition = ( position === "absolute" || position === "fixed" ) &&
+ ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
+
+ // Need to be able to calculate position if either
+ // top or left is auto and position is either absolute or fixed
+ if ( calculatePosition ) {
+ curPosition = curElem.position();
+ curTop = curPosition.top;
+ curLeft = curPosition.left;
+
+ } else {
+ curTop = parseFloat( curCSSTop ) || 0;
+ curLeft = parseFloat( curCSSLeft ) || 0;
+ }
+
+ if ( isFunction( options ) ) {
+
+ // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
+ options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
+ }
+
+ if ( options.top != null ) {
+ props.top = ( options.top - curOffset.top ) + curTop;
+ }
+ if ( options.left != null ) {
+ props.left = ( options.left - curOffset.left ) + curLeft;
+ }
+
+ if ( "using" in options ) {
+ options.using.call( elem, props );
+
+ } else {
+ curElem.css( props );
+ }
+ }
+};
+
+jQuery.fn.extend( {
+
+ // offset() relates an element's border box to the document origin
+ offset: function( options ) {
+
+ // Preserve chaining for setter
+ if ( arguments.length ) {
+ return options === undefined ?
+ this :
+ this.each( function( i ) {
+ jQuery.offset.setOffset( this, options, i );
+ } );
+ }
+
+ var rect, win,
+ elem = this[ 0 ];
+
+ if ( !elem ) {
+ return;
+ }
+
+ // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
+ // Support: IE <=11 only
+ // Running getBoundingClientRect on a
+ // disconnected node in IE throws an error
+ if ( !elem.getClientRects().length ) {
+ return { top: 0, left: 0 };
+ }
+
+ // Get document-relative position by adding viewport scroll to viewport-relative gBCR
+ rect = elem.getBoundingClientRect();
+ win = elem.ownerDocument.defaultView;
+ return {
+ top: rect.top + win.pageYOffset,
+ left: rect.left + win.pageXOffset
+ };
+ },
+
+ // position() relates an element's margin box to its offset parent's padding box
+ // This corresponds to the behavior of CSS absolute positioning
+ position: function() {
+ if ( !this[ 0 ] ) {
+ return;
+ }
+
+ var offsetParent, offset, doc,
+ elem = this[ 0 ],
+ parentOffset = { top: 0, left: 0 };
+
+ // position:fixed elements are offset from the viewport, which itself always has zero offset
+ if ( jQuery.css( elem, "position" ) === "fixed" ) {
+
+ // Assume position:fixed implies availability of getBoundingClientRect
+ offset = elem.getBoundingClientRect();
+
+ } else {
+ offset = this.offset();
+
+ // Account for the *real* offset parent, which can be the document or its root element
+ // when a statically positioned element is identified
+ doc = elem.ownerDocument;
+ offsetParent = elem.offsetParent || doc.documentElement;
+ while ( offsetParent &&
+ ( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
+ jQuery.css( offsetParent, "position" ) === "static" ) {
+
+ offsetParent = offsetParent.parentNode;
+ }
+ if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
+
+ // Incorporate borders into its offset, since they are outside its content origin
+ parentOffset = jQuery( offsetParent ).offset();
+ parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
+ parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
+ }
+ }
+
+ // Subtract parent offsets and element margins
+ return {
+ top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
+ left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
+ };
+ },
+
+ // This method will return documentElement in the following cases:
+ // 1) For the element inside the iframe without offsetParent, this method will return
+ // documentElement of the parent window
+ // 2) For the hidden or detached element
+ // 3) For body or html element, i.e. in case of the html node - it will return itself
+ //
+ // but those exceptions were never presented as a real life use-cases
+ // and might be considered as more preferable results.
+ //
+ // This logic, however, is not guaranteed and can change at any point in the future
+ offsetParent: function() {
+ return this.map( function() {
+ var offsetParent = this.offsetParent;
+
+ while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
+ offsetParent = offsetParent.offsetParent;
+ }
+
+ return offsetParent || documentElement;
+ } );
+ }
+} );
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
+ var top = "pageYOffset" === prop;
+
+ jQuery.fn[ method ] = function( val ) {
+ return access( this, function( elem, method, val ) {
+
+ // Coalesce documents and windows
+ var win;
+ if ( isWindow( elem ) ) {
+ win = elem;
+ } else if ( elem.nodeType === 9 ) {
+ win = elem.defaultView;
+ }
+
+ if ( val === undefined ) {
+ return win ? win[ prop ] : elem[ method ];
+ }
+
+ if ( win ) {
+ win.scrollTo(
+ !top ? val : win.pageXOffset,
+ top ? val : win.pageYOffset
+ );
+
+ } else {
+ elem[ method ] = val;
+ }
+ }, method, val, arguments.length );
+ };
+} );
+
+// Support: Safari <=7 - 9.1, Chrome <=37 - 49
+// Add the top/left cssHooks using jQuery.fn.position
+// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
+// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
+// getComputedStyle returns percent when specified for top/left/bottom/right;
+// rather than make the css module depend on the offset module, just check for it here
+jQuery.each( [ "top", "left" ], function( _i, prop ) {
+ jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
+ function( elem, computed ) {
+ if ( computed ) {
+ computed = curCSS( elem, prop );
+
+ // If curCSS returns percentage, fallback to offset
+ return rnumnonpx.test( computed ) ?
+ jQuery( elem ).position()[ prop ] + "px" :
+ computed;
+ }
+ }
+ );
+} );
+
+
+// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
+jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
+ jQuery.each( {
+ padding: "inner" + name,
+ content: type,
+ "": "outer" + name
+ }, function( defaultExtra, funcName ) {
+
+ // Margin is only for outerHeight, outerWidth
+ jQuery.fn[ funcName ] = function( margin, value ) {
+ var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
+ extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
+
+ return access( this, function( elem, type, value ) {
+ var doc;
+
+ if ( isWindow( elem ) ) {
+
+ // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
+ return funcName.indexOf( "outer" ) === 0 ?
+ elem[ "inner" + name ] :
+ elem.document.documentElement[ "client" + name ];
+ }
+
+ // Get document width or height
+ if ( elem.nodeType === 9 ) {
+ doc = elem.documentElement;
+
+ // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
+ // whichever is greatest
+ return Math.max(
+ elem.body[ "scroll" + name ], doc[ "scroll" + name ],
+ elem.body[ "offset" + name ], doc[ "offset" + name ],
+ doc[ "client" + name ]
+ );
+ }
+
+ return value === undefined ?
+
+ // Get width or height on the element, requesting but not forcing parseFloat
+ jQuery.css( elem, type, extra ) :
+
+ // Set width or height on the element
+ jQuery.style( elem, type, value, extra );
+ }, type, chainable ? margin : undefined, chainable );
+ };
+ } );
+} );
+
+
+jQuery.each( [
+ "ajaxStart",
+ "ajaxStop",
+ "ajaxComplete",
+ "ajaxError",
+ "ajaxSuccess",
+ "ajaxSend"
+], function( _i, type ) {
+ jQuery.fn[ type ] = function( fn ) {
+ return this.on( type, fn );
+ };
+} );
+
+
+
+
+jQuery.fn.extend( {
+
+ bind: function( types, data, fn ) {
+ return this.on( types, null, data, fn );
+ },
+ unbind: function( types, fn ) {
+ return this.off( types, null, fn );
+ },
+
+ delegate: function( selector, types, data, fn ) {
+ return this.on( types, selector, data, fn );
+ },
+ undelegate: function( selector, types, fn ) {
+
+ // ( namespace ) or ( selector, types [, fn] )
+ return arguments.length === 1 ?
+ this.off( selector, "**" ) :
+ this.off( types, selector || "**", fn );
+ },
+
+ hover: function( fnOver, fnOut ) {
+ return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+ }
+} );
+
+jQuery.each(
+ ( "blur focus focusin focusout resize scroll click dblclick " +
+ "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
+ "change select submit keydown keypress keyup contextmenu" ).split( " " ),
+ function( _i, name ) {
+
+ // Handle event binding
+ jQuery.fn[ name ] = function( data, fn ) {
+ return arguments.length > 0 ?
+ this.on( name, null, data, fn ) :
+ this.trigger( name );
+ };
+ }
+);
+
+
+
+
+// Support: Android <=4.0 only
+// Make sure we trim BOM and NBSP
+var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
+
+// Bind a function to a context, optionally partially applying any
+// arguments.
+// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
+// However, it is not slated for removal any time soon
+jQuery.proxy = function( fn, context ) {
+ var tmp, args, proxy;
+
+ if ( typeof context === "string" ) {
+ tmp = fn[ context ];
+ context = fn;
+ fn = tmp;
+ }
+
+ // Quick check to determine if target is callable, in the spec
+ // this throws a TypeError, but we will just return undefined.
+ if ( !isFunction( fn ) ) {
+ return undefined;
+ }
+
+ // Simulated bind
+ args = slice.call( arguments, 2 );
+ proxy = function() {
+ return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
+ };
+
+ // Set the guid of unique handler to the same of original handler, so it can be removed
+ proxy.guid = fn.guid = fn.guid || jQuery.guid++;
+
+ return proxy;
+};
+
+jQuery.holdReady = function( hold ) {
+ if ( hold ) {
+ jQuery.readyWait++;
+ } else {
+ jQuery.ready( true );
+ }
+};
+jQuery.isArray = Array.isArray;
+jQuery.parseJSON = JSON.parse;
+jQuery.nodeName = nodeName;
+jQuery.isFunction = isFunction;
+jQuery.isWindow = isWindow;
+jQuery.camelCase = camelCase;
+jQuery.type = toType;
+
+jQuery.now = Date.now;
+
+jQuery.isNumeric = function( obj ) {
+
+ // As of jQuery 3.0, isNumeric is limited to
+ // strings and numbers (primitives or objects)
+ // that can be coerced to finite numbers (gh-2662)
+ var type = jQuery.type( obj );
+ return ( type === "number" || type === "string" ) &&
+
+ // parseFloat NaNs numeric-cast false positives ("")
+ // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
+ // subtraction forces infinities to NaN
+ !isNaN( obj - parseFloat( obj ) );
+};
+
+jQuery.trim = function( text ) {
+ return text == null ?
+ "" :
+ ( text + "" ).replace( rtrim, "" );
+};
+
+
+
+// Register as a named AMD module, since jQuery can be concatenated with other
+// files that may use define, but not via a proper concatenation script that
+// understands anonymous AMD modules. A named AMD is safest and most robust
+// way to register. Lowercase jquery is used because AMD module names are
+// derived from file names, and jQuery is normally delivered in a lowercase
+// file name. Do this after creating the global so that if an AMD module wants
+// to call noConflict to hide this version of jQuery, it will work.
+
+// Note that for maximum portability, libraries that are not jQuery should
+// declare themselves as anonymous modules, and avoid setting a global if an
+// AMD loader is present. jQuery is a special case. For more information, see
+// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
+
+if ( true ) {
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() {
+ return jQuery;
+ }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+}
+
+
+
+
+var
+
+ // Map over jQuery in case of overwrite
+ _jQuery = window.jQuery,
+
+ // Map over the $ in case of overwrite
+ _$ = window.$;
+
+jQuery.noConflict = function( deep ) {
+ if ( window.$ === jQuery ) {
+ window.$ = _$;
+ }
+
+ if ( deep && window.jQuery === jQuery ) {
+ window.jQuery = _jQuery;
+ }
+
+ return jQuery;
+};
+
+// Expose jQuery and $ identifiers, even in AMD
+// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
+// and CommonJS for browser emulators (#13566)
+if ( typeof noGlobal === "undefined" ) {
+ window.jQuery = window.$ = jQuery;
+}
+
+
+
+
+return jQuery;
+} );
+
+
+/***/ }),
+
+/***/ "./node_modules/json-form-data/src/jsonToFormData.js":
+/*!***********************************************************!*\
+ !*** ./node_modules/json-form-data/src/jsonToFormData.js ***!
+ \***********************************************************/
+/***/ (function(module, exports) {
+
+var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (root, factory) {
+ // root is undefined in a Webpack bundle
+ if (!root) {
+ root = {};
+ }
+
+ if (true) {
+
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() {
+ return (root.jsonToFormData = factory());
+ }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+ } else {}
+}(this, function() {
+
+ function mergeObjects(object1, object2) {
+ return [object1, object2].reduce(function (carry, objectToMerge) {
+ Object.keys(objectToMerge).forEach(function (objectKey) {
+ carry[objectKey] = objectToMerge[objectKey];
+ });
+ return carry;
+ }, {});
+ }
+
+ function isArray(val) {
+
+ return ({}).toString.call(val) === '[object Array]';
+ }
+
+ function isJsonObject(val) {
+
+ return !isArray(val) && typeof val === 'object' && !!val && !(val instanceof Blob) && !(val instanceof Date);
+ }
+
+ function isAppendFunctionPresent(formData) {
+
+ return typeof formData.append === 'function';
+ }
+
+ function isGlobalFormDataPresent() {
+
+ return typeof FormData === 'function';
+ }
+
+ function getDefaultFormData() {
+
+ if (isGlobalFormDataPresent()) {
+ return new FormData();
+ }
+ }
+
+ function convert(jsonObject, options) {
+
+ if (options && options.initialFormData) {
+
+ if (!isAppendFunctionPresent(options.initialFormData)) {
+
+ throw 'initialFormData must have an append function.';
+ }
+ } else if (!isGlobalFormDataPresent()) {
+
+ throw 'This environment does not have global form data. options.initialFormData must be specified.';
+ }
+
+ var defaultOptions = {
+ initialFormData: getDefaultFormData(),
+ showLeafArrayIndexes: true,
+ includeNullValues: false,
+ mapping: function(value) {
+ if (typeof value === 'boolean') {
+ return +value ? '1': '0';
+ }
+ return value;
+ }
+ };
+
+ var mergedOptions = mergeObjects(defaultOptions, options || {});
+
+ return convertRecursively(jsonObject, mergedOptions, mergedOptions.initialFormData);
+ }
+
+ function convertRecursively(jsonObject, options, formData, parentKey) {
+
+ var index = 0;
+
+ for (var key in jsonObject) {
+
+ if (jsonObject.hasOwnProperty(key)) {
+
+ var propName = parentKey || key;
+ var value = options.mapping(jsonObject[key]);
+
+ if (parentKey && isJsonObject(jsonObject)) {
+ propName = parentKey + '[' + key + ']';
+ }
+
+ if (parentKey && isArray(jsonObject)) {
+
+ if (isArray(value) || options.showLeafArrayIndexes ) {
+ propName = parentKey + '[' + index + ']';
+ } else {
+ propName = parentKey + '[]';
+ }
+ }
+
+ if (isArray(value) || isJsonObject(value)) {
+
+ convertRecursively(value, options, formData, propName);
+
+ } else if (value instanceof FileList) {
+
+ for (var j = 0; j < value.length; j++) {
+ formData.append(propName + '[' + j + ']', value.item(j));
+ }
+ } else if (value instanceof Blob) {
+
+ formData.append(propName, value, value.name);
+
+ } else if (value instanceof Date) {
+
+ formData.append(propName, value.toISOString());
+
+ } else if (((value === null && options.includeNullValues) || value !== null) && value !== undefined) {
+
+ formData.append(propName, value);
+ }
+ }
+ index++;
+ }
+ return formData;
+ }
+ return convert;
+}));
+
+/***/ }),
+
+/***/ "./node_modules/lodash.clonedeep/index.js":
+/*!************************************************!*\
+ !*** ./node_modules/lodash.clonedeep/index.js ***!
+ \************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+ arrayTag = '[object Array]',
+ boolTag = '[object Boolean]',
+ dateTag = '[object Date]',
+ errorTag = '[object Error]',
+ funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]',
+ mapTag = '[object Map]',
+ numberTag = '[object Number]',
+ objectTag = '[object Object]',
+ promiseTag = '[object Promise]',
+ regexpTag = '[object RegExp]',
+ setTag = '[object Set]',
+ stringTag = '[object String]',
+ symbolTag = '[object Symbol]',
+ weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+ dataViewTag = '[object DataView]',
+ float32Tag = '[object Float32Array]',
+ float64Tag = '[object Float64Array]',
+ int8Tag = '[object Int8Array]',
+ int16Tag = '[object Int16Array]',
+ int32Tag = '[object Int32Array]',
+ uint8Tag = '[object Uint8Array]',
+ uint8ClampedTag = '[object Uint8ClampedArray]',
+ uint16Tag = '[object Uint16Array]',
+ uint32Tag = '[object Uint32Array]';
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to match `RegExp` flags from their coerced string values. */
+var reFlags = /\w*$/;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/** Used to identify `toStringTag` values supported by `_.clone`. */
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] =
+cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+cloneableTags[boolTag] = cloneableTags[dateTag] =
+cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+cloneableTags[int32Tag] = cloneableTags[mapTag] =
+cloneableTags[numberTag] = cloneableTags[objectTag] =
+cloneableTags[regexpTag] = cloneableTags[setTag] =
+cloneableTags[stringTag] = cloneableTags[symbolTag] =
+cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] =
+cloneableTags[weakMapTag] = false;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/** Detect free variable `exports`. */
+var freeExports = true && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/**
+ * Adds the key-value `pair` to `map`.
+ *
+ * @private
+ * @param {Object} map The map to modify.
+ * @param {Array} pair The key-value pair to add.
+ * @returns {Object} Returns `map`.
+ */
+function addMapEntry(map, pair) {
+ // Don't return `map.set` because it's not chainable in IE 11.
+ map.set(pair[0], pair[1]);
+ return map;
+}
+
+/**
+ * Adds `value` to `set`.
+ *
+ * @private
+ * @param {Object} set The set to modify.
+ * @param {*} value The value to add.
+ * @returns {Object} Returns `set`.
+ */
+function addSetEntry(set, value) {
+ // Don't return `set.add` because it's not chainable in IE 11.
+ set.add(value);
+ return set;
+}
+
+/**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEach(array, iteratee) {
+ var index = -1,
+ length = array ? array.length : 0;
+
+ while (++index < length) {
+ if (iteratee(array[index], index, array) === false) {
+ break;
+ }
+ }
+ return array;
+}
+
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+function arrayPush(array, values) {
+ var index = -1,
+ length = values.length,
+ offset = array.length;
+
+ while (++index < length) {
+ array[offset + index] = values[index];
+ }
+ return array;
+}
+
+/**
+ * A specialized version of `_.reduce` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the first element of `array` as
+ * the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+ var index = -1,
+ length = array ? array.length : 0;
+
+ if (initAccum && length) {
+ accumulator = array[++index];
+ }
+ while (++index < length) {
+ accumulator = iteratee(accumulator, array[index], index, array);
+ }
+ return accumulator;
+}
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+ var index = -1,
+ result = Array(n);
+
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+}
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+ return object == null ? undefined : object[key];
+}
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+ // Many host objects are `Object` objects that can coerce to strings
+ // despite having improperly defined `toString` methods.
+ var result = false;
+ if (value != null && typeof value.toString != 'function') {
+ try {
+ result = !!(value + '');
+ } catch (e) {}
+ }
+ return result;
+}
+
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+ var index = -1,
+ result = Array(map.size);
+
+ map.forEach(function(value, key) {
+ result[++index] = [key, value];
+ });
+ return result;
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+}
+
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+ var index = -1,
+ result = Array(set.size);
+
+ set.forEach(function(value) {
+ result[++index] = value;
+ });
+ return result;
+}
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype,
+ funcProto = Function.prototype,
+ objectProto = Object.prototype;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+ var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+ return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+ funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+ .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/** Built-in value references. */
+var Buffer = moduleExports ? root.Buffer : undefined,
+ Symbol = root.Symbol,
+ Uint8Array = root.Uint8Array,
+ getPrototype = overArg(Object.getPrototypeOf, Object),
+ objectCreate = Object.create,
+ propertyIsEnumerable = objectProto.propertyIsEnumerable,
+ splice = arrayProto.splice;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols,
+ nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
+ nativeKeys = overArg(Object.keys, Object);
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView'),
+ Map = getNative(root, 'Map'),
+ Promise = getNative(root, 'Promise'),
+ Set = getNative(root, 'Set'),
+ WeakMap = getNative(root, 'WeakMap'),
+ nativeCreate = getNative(Object, 'create');
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+ mapCtorString = toSource(Map),
+ promiseCtorString = toSource(Promise),
+ setCtorString = toSource(Set),
+ weakMapCtorString = toSource(WeakMap);
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+ symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+ this.__data__ = nativeCreate ? nativeCreate(null) : {};
+}
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+ return this.has(key) && delete this.__data__[key];
+}
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+ var data = this.__data__;
+ if (nativeCreate) {
+ var result = data[key];
+ return result === HASH_UNDEFINED ? undefined : result;
+ }
+ return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+ var data = this.__data__;
+ return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+}
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+ var data = this.__data__;
+ data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+ return this;
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+ this.__data__ = [];
+}
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ return false;
+ }
+ var lastIndex = data.length - 1;
+ if (index == lastIndex) {
+ data.pop();
+ } else {
+ splice.call(data, index, 1);
+ }
+ return true;
+}
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ return index < 0 ? undefined : data[index][1];
+}
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+ return assocIndexOf(this.__data__, key) > -1;
+}
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ data.push([key, value]);
+ } else {
+ data[index][1] = value;
+ }
+ return this;
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+ this.__data__ = {
+ 'hash': new Hash,
+ 'map': new (Map || ListCache),
+ 'string': new Hash
+ };
+}
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+ return getMapData(this, key)['delete'](key);
+}
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+ return getMapData(this, key).get(key);
+}
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+ return getMapData(this, key).has(key);
+}
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+ getMapData(this, key).set(key, value);
+ return this;
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+ this.__data__ = new ListCache(entries);
+}
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear() {
+ this.__data__ = new ListCache;
+}
+
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function stackDelete(key) {
+ return this.__data__['delete'](key);
+}
+
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function stackGet(key) {
+ return this.__data__.get(key);
+}
+
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function stackHas(key) {
+ return this.__data__.has(key);
+}
+
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+function stackSet(key, value) {
+ var cache = this.__data__;
+ if (cache instanceof ListCache) {
+ var pairs = cache.__data__;
+ if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+ pairs.push([key, value]);
+ return this;
+ }
+ cache = this.__data__ = new MapCache(pairs);
+ }
+ cache.set(key, value);
+ return this;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ // Safari 9 makes `arguments.length` enumerable in strict mode.
+ var result = (isArray(value) || isArguments(value))
+ ? baseTimes(value.length, String)
+ : [];
+
+ var length = result.length,
+ skipIndexes = !!length;
+
+ for (var key in value) {
+ if ((inherited || hasOwnProperty.call(value, key)) &&
+ !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * Assigns `value` to `key` of `object` if the existing value is not equivalent
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignValue(object, key, value) {
+ var objValue = object[key];
+ if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+ (value === undefined && !(key in object))) {
+ object[key] = value;
+ }
+}
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+ var length = array.length;
+ while (length--) {
+ if (eq(array[length][0], key)) {
+ return length;
+ }
+ }
+ return -1;
+}
+
+/**
+ * The base implementation of `_.assign` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssign(object, source) {
+ return object && copyObject(source, keys(source), object);
+}
+
+/**
+ * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+ * traversed objects.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @param {boolean} [isFull] Specify a clone including symbols.
+ * @param {Function} [customizer] The function to customize cloning.
+ * @param {string} [key] The key of `value`.
+ * @param {Object} [object] The parent object of `value`.
+ * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
+ var result;
+ if (customizer) {
+ result = object ? customizer(value, key, object, stack) : customizer(value);
+ }
+ if (result !== undefined) {
+ return result;
+ }
+ if (!isObject(value)) {
+ return value;
+ }
+ var isArr = isArray(value);
+ if (isArr) {
+ result = initCloneArray(value);
+ if (!isDeep) {
+ return copyArray(value, result);
+ }
+ } else {
+ var tag = getTag(value),
+ isFunc = tag == funcTag || tag == genTag;
+
+ if (isBuffer(value)) {
+ return cloneBuffer(value, isDeep);
+ }
+ if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+ if (isHostObject(value)) {
+ return object ? value : {};
+ }
+ result = initCloneObject(isFunc ? {} : value);
+ if (!isDeep) {
+ return copySymbols(value, baseAssign(result, value));
+ }
+ } else {
+ if (!cloneableTags[tag]) {
+ return object ? value : {};
+ }
+ result = initCloneByTag(value, tag, baseClone, isDeep);
+ }
+ }
+ // Check for circular references and return its corresponding clone.
+ stack || (stack = new Stack);
+ var stacked = stack.get(value);
+ if (stacked) {
+ return stacked;
+ }
+ stack.set(value, result);
+
+ if (!isArr) {
+ var props = isFull ? getAllKeys(value) : keys(value);
+ }
+ arrayEach(props || value, function(subValue, key) {
+ if (props) {
+ key = subValue;
+ subValue = value[key];
+ }
+ // Recursively populate clone (susceptible to call stack limits).
+ assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
+ });
+ return result;
+}
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} prototype The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+function baseCreate(proto) {
+ return isObject(proto) ? objectCreate(proto) : {};
+}
+
+/**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+ var result = keysFunc(object);
+ return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+
+/**
+ * The base implementation of `getTag`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+ return objectToString.call(value);
+}
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ * else `false`.
+ */
+function baseIsNative(value) {
+ if (!isObject(value) || isMasked(value)) {
+ return false;
+ }
+ var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+ return pattern.test(toSource(value));
+}
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+ if (!isPrototype(object)) {
+ return nativeKeys(object);
+ }
+ var result = [];
+ for (var key in Object(object)) {
+ if (hasOwnProperty.call(object, key) && key != 'constructor') {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * Creates a clone of `buffer`.
+ *
+ * @private
+ * @param {Buffer} buffer The buffer to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Buffer} Returns the cloned buffer.
+ */
+function cloneBuffer(buffer, isDeep) {
+ if (isDeep) {
+ return buffer.slice();
+ }
+ var result = new buffer.constructor(buffer.length);
+ buffer.copy(result);
+ return result;
+}
+
+/**
+ * Creates a clone of `arrayBuffer`.
+ *
+ * @private
+ * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+ * @returns {ArrayBuffer} Returns the cloned array buffer.
+ */
+function cloneArrayBuffer(arrayBuffer) {
+ var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+ new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+ return result;
+}
+
+/**
+ * Creates a clone of `dataView`.
+ *
+ * @private
+ * @param {Object} dataView The data view to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned data view.
+ */
+function cloneDataView(dataView, isDeep) {
+ var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+ return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+
+/**
+ * Creates a clone of `map`.
+ *
+ * @private
+ * @param {Object} map The map to clone.
+ * @param {Function} cloneFunc The function to clone values.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned map.
+ */
+function cloneMap(map, isDeep, cloneFunc) {
+ var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);
+ return arrayReduce(array, addMapEntry, new map.constructor);
+}
+
+/**
+ * Creates a clone of `regexp`.
+ *
+ * @private
+ * @param {Object} regexp The regexp to clone.
+ * @returns {Object} Returns the cloned regexp.
+ */
+function cloneRegExp(regexp) {
+ var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+ result.lastIndex = regexp.lastIndex;
+ return result;
+}
+
+/**
+ * Creates a clone of `set`.
+ *
+ * @private
+ * @param {Object} set The set to clone.
+ * @param {Function} cloneFunc The function to clone values.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned set.
+ */
+function cloneSet(set, isDeep, cloneFunc) {
+ var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);
+ return arrayReduce(array, addSetEntry, new set.constructor);
+}
+
+/**
+ * Creates a clone of the `symbol` object.
+ *
+ * @private
+ * @param {Object} symbol The symbol object to clone.
+ * @returns {Object} Returns the cloned symbol object.
+ */
+function cloneSymbol(symbol) {
+ return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+
+/**
+ * Creates a clone of `typedArray`.
+ *
+ * @private
+ * @param {Object} typedArray The typed array to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned typed array.
+ */
+function cloneTypedArray(typedArray, isDeep) {
+ var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+ return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+
+/**
+ * Copies the values of `source` to `array`.
+ *
+ * @private
+ * @param {Array} source The array to copy values from.
+ * @param {Array} [array=[]] The array to copy values to.
+ * @returns {Array} Returns `array`.
+ */
+function copyArray(source, array) {
+ var index = -1,
+ length = source.length;
+
+ array || (array = Array(length));
+ while (++index < length) {
+ array[index] = source[index];
+ }
+ return array;
+}
+
+/**
+ * Copies properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy properties from.
+ * @param {Array} props The property identifiers to copy.
+ * @param {Object} [object={}] The object to copy properties to.
+ * @param {Function} [customizer] The function to customize copied values.
+ * @returns {Object} Returns `object`.
+ */
+function copyObject(source, props, object, customizer) {
+ object || (object = {});
+
+ var index = -1,
+ length = props.length;
+
+ while (++index < length) {
+ var key = props[index];
+
+ var newValue = customizer
+ ? customizer(object[key], source[key], key, object, source)
+ : undefined;
+
+ assignValue(object, key, newValue === undefined ? source[key] : newValue);
+ }
+ return object;
+}
+
+/**
+ * Copies own symbol properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+function copySymbols(source, object) {
+ return copyObject(source, getSymbols(source), object);
+}
+
+/**
+ * Creates an array of own enumerable property names and symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeys(object) {
+ return baseGetAllKeys(object, keys, getSymbols);
+}
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+ var data = map.__data__;
+ return isKeyable(key)
+ ? data[typeof key == 'string' ? 'string' : 'hash']
+ : data.map;
+}
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+ var value = getValue(object, key);
+ return baseIsNative(value) ? value : undefined;
+}
+
+/**
+ * Creates an array of the own enumerable symbol properties of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+var getTag = baseGetTag;
+
+// Fallback for data views, maps, sets, and weak maps in IE 11,
+// for data views in Edge < 14, and promises in Node.js.
+if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+ (Map && getTag(new Map) != mapTag) ||
+ (Promise && getTag(Promise.resolve()) != promiseTag) ||
+ (Set && getTag(new Set) != setTag) ||
+ (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+ getTag = function(value) {
+ var result = objectToString.call(value),
+ Ctor = result == objectTag ? value.constructor : undefined,
+ ctorString = Ctor ? toSource(Ctor) : undefined;
+
+ if (ctorString) {
+ switch (ctorString) {
+ case dataViewCtorString: return dataViewTag;
+ case mapCtorString: return mapTag;
+ case promiseCtorString: return promiseTag;
+ case setCtorString: return setTag;
+ case weakMapCtorString: return weakMapTag;
+ }
+ }
+ return result;
+ };
+}
+
+/**
+ * Initializes an array clone.
+ *
+ * @private
+ * @param {Array} array The array to clone.
+ * @returns {Array} Returns the initialized clone.
+ */
+function initCloneArray(array) {
+ var length = array.length,
+ result = array.constructor(length);
+
+ // Add properties assigned by `RegExp#exec`.
+ if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+ result.index = array.index;
+ result.input = array.input;
+ }
+ return result;
+}
+
+/**
+ * Initializes an object clone.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneObject(object) {
+ return (typeof object.constructor == 'function' && !isPrototype(object))
+ ? baseCreate(getPrototype(object))
+ : {};
+}
+
+/**
+ * Initializes an object clone based on its `toStringTag`.
+ *
+ * **Note:** This function only supports cloning values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @param {string} tag The `toStringTag` of the object to clone.
+ * @param {Function} cloneFunc The function to clone values.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneByTag(object, tag, cloneFunc, isDeep) {
+ var Ctor = object.constructor;
+ switch (tag) {
+ case arrayBufferTag:
+ return cloneArrayBuffer(object);
+
+ case boolTag:
+ case dateTag:
+ return new Ctor(+object);
+
+ case dataViewTag:
+ return cloneDataView(object, isDeep);
+
+ case float32Tag: case float64Tag:
+ case int8Tag: case int16Tag: case int32Tag:
+ case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
+ return cloneTypedArray(object, isDeep);
+
+ case mapTag:
+ return cloneMap(object, isDeep, cloneFunc);
+
+ case numberTag:
+ case stringTag:
+ return new Ctor(object);
+
+ case regexpTag:
+ return cloneRegExp(object);
+
+ case setTag:
+ return cloneSet(object, isDeep, cloneFunc);
+
+ case symbolTag:
+ return cloneSymbol(object);
+ }
+}
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+ length = length == null ? MAX_SAFE_INTEGER : length;
+ return !!length &&
+ (typeof value == 'number' || reIsUint.test(value)) &&
+ (value > -1 && value % 1 == 0 && value < length);
+}
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+ var type = typeof value;
+ return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+ ? (value !== '__proto__')
+ : (value === null);
+}
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+ return !!maskSrcKey && (maskSrcKey in func);
+}
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+ var Ctor = value && value.constructor,
+ proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+ return value === proto;
+}
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to process.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+ if (func != null) {
+ try {
+ return funcToString.call(func);
+ } catch (e) {}
+ try {
+ return (func + '');
+ } catch (e) {}
+ }
+ return '';
+}
+
+/**
+ * This method is like `_.clone` except that it recursively clones `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Lang
+ * @param {*} value The value to recursively clone.
+ * @returns {*} Returns the deep cloned value.
+ * @see _.clone
+ * @example
+ *
+ * var objects = [{ 'a': 1 }, { 'b': 2 }];
+ *
+ * var deep = _.cloneDeep(objects);
+ * console.log(deep[0] === objects[0]);
+ * // => false
+ */
+function cloneDeep(value) {
+ return baseClone(value, true, true);
+}
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+ return value === other || (value !== value && other !== other);
+}
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ * else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+function isArguments(value) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
+ (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+}
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+ return value != null && isLength(value.length) && !isFunction(value);
+}
+
+/**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ * else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+function isArrayLikeObject(value) {
+ return isObjectLike(value) && isArrayLike(value);
+}
+
+/**
+ * Checks if `value` is a buffer.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+ * @example
+ *
+ * _.isBuffer(new Buffer(2));
+ * // => true
+ *
+ * _.isBuffer(new Uint8Array(2));
+ * // => false
+ */
+var isBuffer = nativeIsBuffer || stubFalse;
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+ // The use of `Object#toString` avoids issues with the `typeof` operator
+ // in Safari 8-9 which returns 'object' for typed array and other constructors.
+ var tag = isObject(value) ? objectToString.call(value) : '';
+ return tag == funcTag || tag == genTag;
+}
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+ return typeof value == 'number' &&
+ value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+ var type = typeof value;
+ return !!value && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+ return !!value && typeof value == 'object';
+}
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+/**
+ * This method returns a new empty array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Array} Returns the new empty array.
+ * @example
+ *
+ * var arrays = _.times(2, _.stubArray);
+ *
+ * console.log(arrays);
+ * // => [[], []]
+ *
+ * console.log(arrays[0] === arrays[1]);
+ * // => false
+ */
+function stubArray() {
+ return [];
+}
+
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+function stubFalse() {
+ return false;
+}
+
+module.exports = cloneDeep;
+
+
+/***/ }),
+
+/***/ "./node_modules/lodash.find/index.js":
+/*!*******************************************!*\
+ !*** ./node_modules/lodash.find/index.js ***!
+ \*******************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** Used to compose bitmasks for comparison styles. */
+var UNORDERED_COMPARE_FLAG = 1,
+ PARTIAL_COMPARE_FLAG = 2;
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0,
+ MAX_SAFE_INTEGER = 9007199254740991,
+ MAX_INTEGER = 1.7976931348623157e+308,
+ NAN = 0 / 0;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+ arrayTag = '[object Array]',
+ boolTag = '[object Boolean]',
+ dateTag = '[object Date]',
+ errorTag = '[object Error]',
+ funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]',
+ mapTag = '[object Map]',
+ numberTag = '[object Number]',
+ objectTag = '[object Object]',
+ promiseTag = '[object Promise]',
+ regexpTag = '[object RegExp]',
+ setTag = '[object Set]',
+ stringTag = '[object String]',
+ symbolTag = '[object Symbol]',
+ weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+ dataViewTag = '[object DataView]',
+ float32Tag = '[object Float32Array]',
+ float64Tag = '[object Float64Array]',
+ int8Tag = '[object Int8Array]',
+ int16Tag = '[object Int16Array]',
+ int32Tag = '[object Int32Array]',
+ uint8Tag = '[object Uint8Array]',
+ uint8ClampedTag = '[object Uint8ClampedArray]',
+ uint16Tag = '[object Uint16Array]',
+ uint32Tag = '[object Uint32Array]';
+
+/** Used to match property names within property paths. */
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+ reIsPlainProp = /^\w*$/,
+ reLeadingDot = /^\./,
+ rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to match leading and trailing whitespace. */
+var reTrim = /^\s+|\s+$/g;
+
+/** Used to match backslashes in property paths. */
+var reEscapeChar = /\\(\\)?/g;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/** Used to identify `toStringTag` values of typed arrays. */
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+typedArrayTags[setTag] = typedArrayTags[stringTag] =
+typedArrayTags[weakMapTag] = false;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/** Detect free variable `exports`. */
+var freeExports = true && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Detect free variable `process` from Node.js. */
+var freeProcess = moduleExports && freeGlobal.process;
+
+/** Used to access faster Node.js helpers. */
+var nodeUtil = (function() {
+ try {
+ return freeProcess && freeProcess.binding('util');
+ } catch (e) {}
+}());
+
+/* Node.js helper references. */
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ * else `false`.
+ */
+function arraySome(array, predicate) {
+ var index = -1,
+ length = array ? array.length : 0;
+
+ while (++index < length) {
+ if (predicate(array[index], index, array)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
+ * The base implementation of `_.findIndex` and `_.findLastIndex` without
+ * support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {number} fromIndex The index to search from.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+ var length = array.length,
+ index = fromIndex + (fromRight ? 1 : -1);
+
+ while ((fromRight ? index-- : ++index < length)) {
+ if (predicate(array[index], index, array)) {
+ return index;
+ }
+ }
+ return -1;
+}
+
+/**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function baseProperty(key) {
+ return function(object) {
+ return object == null ? undefined : object[key];
+ };
+}
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+ var index = -1,
+ result = Array(n);
+
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+function baseUnary(func) {
+ return function(value) {
+ return func(value);
+ };
+}
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+ return object == null ? undefined : object[key];
+}
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+ // Many host objects are `Object` objects that can coerce to strings
+ // despite having improperly defined `toString` methods.
+ var result = false;
+ if (value != null && typeof value.toString != 'function') {
+ try {
+ result = !!(value + '');
+ } catch (e) {}
+ }
+ return result;
+}
+
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+ var index = -1,
+ result = Array(map.size);
+
+ map.forEach(function(value, key) {
+ result[++index] = [key, value];
+ });
+ return result;
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+}
+
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+ var index = -1,
+ result = Array(set.size);
+
+ set.forEach(function(value) {
+ result[++index] = value;
+ });
+ return result;
+}
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype,
+ funcProto = Function.prototype,
+ objectProto = Object.prototype;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+ var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+ return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+ funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+ .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/** Built-in value references. */
+var Symbol = root.Symbol,
+ Uint8Array = root.Uint8Array,
+ propertyIsEnumerable = objectProto.propertyIsEnumerable,
+ splice = arrayProto.splice;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeKeys = overArg(Object.keys, Object),
+ nativeMax = Math.max;
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView'),
+ Map = getNative(root, 'Map'),
+ Promise = getNative(root, 'Promise'),
+ Set = getNative(root, 'Set'),
+ WeakMap = getNative(root, 'WeakMap'),
+ nativeCreate = getNative(Object, 'create');
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+ mapCtorString = toSource(Map),
+ promiseCtorString = toSource(Promise),
+ setCtorString = toSource(Set),
+ weakMapCtorString = toSource(WeakMap);
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+ symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
+ symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+ this.__data__ = nativeCreate ? nativeCreate(null) : {};
+}
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+ return this.has(key) && delete this.__data__[key];
+}
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+ var data = this.__data__;
+ if (nativeCreate) {
+ var result = data[key];
+ return result === HASH_UNDEFINED ? undefined : result;
+ }
+ return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+ var data = this.__data__;
+ return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+}
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+ var data = this.__data__;
+ data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+ return this;
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+ this.__data__ = [];
+}
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ return false;
+ }
+ var lastIndex = data.length - 1;
+ if (index == lastIndex) {
+ data.pop();
+ } else {
+ splice.call(data, index, 1);
+ }
+ return true;
+}
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ return index < 0 ? undefined : data[index][1];
+}
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+ return assocIndexOf(this.__data__, key) > -1;
+}
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ data.push([key, value]);
+ } else {
+ data[index][1] = value;
+ }
+ return this;
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+ this.__data__ = {
+ 'hash': new Hash,
+ 'map': new (Map || ListCache),
+ 'string': new Hash
+ };
+}
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+ return getMapData(this, key)['delete'](key);
+}
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+ return getMapData(this, key).get(key);
+}
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+ return getMapData(this, key).has(key);
+}
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+ getMapData(this, key).set(key, value);
+ return this;
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+ var index = -1,
+ length = values ? values.length : 0;
+
+ this.__data__ = new MapCache;
+ while (++index < length) {
+ this.add(values[index]);
+ }
+}
+
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+function setCacheAdd(value) {
+ this.__data__.set(value, HASH_UNDEFINED);
+ return this;
+}
+
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+function setCacheHas(value) {
+ return this.__data__.has(value);
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+ this.__data__ = new ListCache(entries);
+}
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear() {
+ this.__data__ = new ListCache;
+}
+
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function stackDelete(key) {
+ return this.__data__['delete'](key);
+}
+
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function stackGet(key) {
+ return this.__data__.get(key);
+}
+
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function stackHas(key) {
+ return this.__data__.has(key);
+}
+
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+function stackSet(key, value) {
+ var cache = this.__data__;
+ if (cache instanceof ListCache) {
+ var pairs = cache.__data__;
+ if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+ pairs.push([key, value]);
+ return this;
+ }
+ cache = this.__data__ = new MapCache(pairs);
+ }
+ cache.set(key, value);
+ return this;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ // Safari 9 makes `arguments.length` enumerable in strict mode.
+ var result = (isArray(value) || isArguments(value))
+ ? baseTimes(value.length, String)
+ : [];
+
+ var length = result.length,
+ skipIndexes = !!length;
+
+ for (var key in value) {
+ if ((inherited || hasOwnProperty.call(value, key)) &&
+ !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+ var length = array.length;
+ while (length--) {
+ if (eq(array[length][0], key)) {
+ return length;
+ }
+ }
+ return -1;
+}
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet(object, path) {
+ path = isKey(path, object) ? [path] : castPath(path);
+
+ var index = 0,
+ length = path.length;
+
+ while (object != null && index < length) {
+ object = object[toKey(path[index++])];
+ }
+ return (index && index == length) ? object : undefined;
+}
+
+/**
+ * The base implementation of `getTag`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+ return objectToString.call(value);
+}
+
+/**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHasIn(object, key) {
+ return object != null && key in Object(object);
+}
+
+/**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {boolean} [bitmask] The bitmask of comparison flags.
+ * The bitmask may be composed of the following flags:
+ * 1 - Unordered comparison
+ * 2 - Partial comparison
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+function baseIsEqual(value, other, customizer, bitmask, stack) {
+ if (value === other) {
+ return true;
+ }
+ if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
+ return value !== value && other !== other;
+ }
+ return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
+}
+
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual`
+ * for more details.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
+ var objIsArr = isArray(object),
+ othIsArr = isArray(other),
+ objTag = arrayTag,
+ othTag = arrayTag;
+
+ if (!objIsArr) {
+ objTag = getTag(object);
+ objTag = objTag == argsTag ? objectTag : objTag;
+ }
+ if (!othIsArr) {
+ othTag = getTag(other);
+ othTag = othTag == argsTag ? objectTag : othTag;
+ }
+ var objIsObj = objTag == objectTag && !isHostObject(object),
+ othIsObj = othTag == objectTag && !isHostObject(other),
+ isSameTag = objTag == othTag;
+
+ if (isSameTag && !objIsObj) {
+ stack || (stack = new Stack);
+ return (objIsArr || isTypedArray(object))
+ ? equalArrays(object, other, equalFunc, customizer, bitmask, stack)
+ : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
+ }
+ if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
+ var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+ othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+ if (objIsWrapped || othIsWrapped) {
+ var objUnwrapped = objIsWrapped ? object.value() : object,
+ othUnwrapped = othIsWrapped ? other.value() : other;
+
+ stack || (stack = new Stack);
+ return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
+ }
+ }
+ if (!isSameTag) {
+ return false;
+ }
+ stack || (stack = new Stack);
+ return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
+}
+
+/**
+ * The base implementation of `_.isMatch` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Array} matchData The property names, values, and compare flags to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+function baseIsMatch(object, source, matchData, customizer) {
+ var index = matchData.length,
+ length = index,
+ noCustomizer = !customizer;
+
+ if (object == null) {
+ return !length;
+ }
+ object = Object(object);
+ while (index--) {
+ var data = matchData[index];
+ if ((noCustomizer && data[2])
+ ? data[1] !== object[data[0]]
+ : !(data[0] in object)
+ ) {
+ return false;
+ }
+ }
+ while (++index < length) {
+ data = matchData[index];
+ var key = data[0],
+ objValue = object[key],
+ srcValue = data[1];
+
+ if (noCustomizer && data[2]) {
+ if (objValue === undefined && !(key in object)) {
+ return false;
+ }
+ } else {
+ var stack = new Stack;
+ if (customizer) {
+ var result = customizer(objValue, srcValue, key, object, source, stack);
+ }
+ if (!(result === undefined
+ ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
+ : result
+ )) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ * else `false`.
+ */
+function baseIsNative(value) {
+ if (!isObject(value) || isMasked(value)) {
+ return false;
+ }
+ var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+ return pattern.test(toSource(value));
+}
+
+/**
+ * The base implementation of `_.isTypedArray` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ */
+function baseIsTypedArray(value) {
+ return isObjectLike(value) &&
+ isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+}
+
+/**
+ * The base implementation of `_.iteratee`.
+ *
+ * @private
+ * @param {*} [value=_.identity] The value to convert to an iteratee.
+ * @returns {Function} Returns the iteratee.
+ */
+function baseIteratee(value) {
+ // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+ // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+ if (typeof value == 'function') {
+ return value;
+ }
+ if (value == null) {
+ return identity;
+ }
+ if (typeof value == 'object') {
+ return isArray(value)
+ ? baseMatchesProperty(value[0], value[1])
+ : baseMatches(value);
+ }
+ return property(value);
+}
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+ if (!isPrototype(object)) {
+ return nativeKeys(object);
+ }
+ var result = [];
+ for (var key in Object(object)) {
+ if (hasOwnProperty.call(object, key) && key != 'constructor') {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `_.matches` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatches(source) {
+ var matchData = getMatchData(source);
+ if (matchData.length == 1 && matchData[0][2]) {
+ return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+ }
+ return function(object) {
+ return object === source || baseIsMatch(object, source, matchData);
+ };
+}
+
+/**
+ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+ *
+ * @private
+ * @param {string} path The path of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatchesProperty(path, srcValue) {
+ if (isKey(path) && isStrictComparable(srcValue)) {
+ return matchesStrictComparable(toKey(path), srcValue);
+ }
+ return function(object) {
+ var objValue = get(object, path);
+ return (objValue === undefined && objValue === srcValue)
+ ? hasIn(object, path)
+ : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
+ };
+}
+
+/**
+ * A specialized version of `baseProperty` which supports deep paths.
+ *
+ * @private
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyDeep(path) {
+ return function(object) {
+ return baseGet(object, path);
+ };
+}
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+ // Exit early for strings to avoid a performance hit in some environments.
+ if (typeof value == 'string') {
+ return value;
+ }
+ if (isSymbol(value)) {
+ return symbolToString ? symbolToString.call(value) : '';
+ }
+ var result = (value + '');
+ return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath(value) {
+ return isArray(value) ? value : stringToPath(value);
+}
+
+/**
+ * Creates a `_.find` or `_.findLast` function.
+ *
+ * @private
+ * @param {Function} findIndexFunc The function to find the collection index.
+ * @returns {Function} Returns the new find function.
+ */
+function createFind(findIndexFunc) {
+ return function(collection, predicate, fromIndex) {
+ var iterable = Object(collection);
+ if (!isArrayLike(collection)) {
+ var iteratee = baseIteratee(predicate, 3);
+ collection = keys(collection);
+ predicate = function(key) { return iteratee(iterable[key], key, iterable); };
+ }
+ var index = findIndexFunc(collection, predicate, fromIndex);
+ return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
+ };
+}
+
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
+ * for more details.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
+ var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
+ arrLength = array.length,
+ othLength = other.length;
+
+ if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+ return false;
+ }
+ // Assume cyclic values are equal.
+ var stacked = stack.get(array);
+ if (stacked && stack.get(other)) {
+ return stacked == other;
+ }
+ var index = -1,
+ result = true,
+ seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
+
+ stack.set(array, other);
+ stack.set(other, array);
+
+ // Ignore non-index properties.
+ while (++index < arrLength) {
+ var arrValue = array[index],
+ othValue = other[index];
+
+ if (customizer) {
+ var compared = isPartial
+ ? customizer(othValue, arrValue, index, other, array, stack)
+ : customizer(arrValue, othValue, index, array, other, stack);
+ }
+ if (compared !== undefined) {
+ if (compared) {
+ continue;
+ }
+ result = false;
+ break;
+ }
+ // Recursively compare arrays (susceptible to call stack limits).
+ if (seen) {
+ if (!arraySome(other, function(othValue, othIndex) {
+ if (!seen.has(othIndex) &&
+ (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
+ return seen.add(othIndex);
+ }
+ })) {
+ result = false;
+ break;
+ }
+ } else if (!(
+ arrValue === othValue ||
+ equalFunc(arrValue, othValue, customizer, bitmask, stack)
+ )) {
+ result = false;
+ break;
+ }
+ }
+ stack['delete'](array);
+ stack['delete'](other);
+ return result;
+}
+
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
+ * for more details.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
+ switch (tag) {
+ case dataViewTag:
+ if ((object.byteLength != other.byteLength) ||
+ (object.byteOffset != other.byteOffset)) {
+ return false;
+ }
+ object = object.buffer;
+ other = other.buffer;
+
+ case arrayBufferTag:
+ if ((object.byteLength != other.byteLength) ||
+ !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+ return false;
+ }
+ return true;
+
+ case boolTag:
+ case dateTag:
+ case numberTag:
+ // Coerce booleans to `1` or `0` and dates to milliseconds.
+ // Invalid dates are coerced to `NaN`.
+ return eq(+object, +other);
+
+ case errorTag:
+ return object.name == other.name && object.message == other.message;
+
+ case regexpTag:
+ case stringTag:
+ // Coerce regexes to strings and treat strings, primitives and objects,
+ // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+ // for more details.
+ return object == (other + '');
+
+ case mapTag:
+ var convert = mapToArray;
+
+ case setTag:
+ var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
+ convert || (convert = setToArray);
+
+ if (object.size != other.size && !isPartial) {
+ return false;
+ }
+ // Assume cyclic values are equal.
+ var stacked = stack.get(object);
+ if (stacked) {
+ return stacked == other;
+ }
+ bitmask |= UNORDERED_COMPARE_FLAG;
+
+ // Recursively compare objects (susceptible to call stack limits).
+ stack.set(object, other);
+ var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+ stack['delete'](object);
+ return result;
+
+ case symbolTag:
+ if (symbolValueOf) {
+ return symbolValueOf.call(object) == symbolValueOf.call(other);
+ }
+ }
+ return false;
+}
+
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
+ * for more details.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
+ var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
+ objProps = keys(object),
+ objLength = objProps.length,
+ othProps = keys(other),
+ othLength = othProps.length;
+
+ if (objLength != othLength && !isPartial) {
+ return false;
+ }
+ var index = objLength;
+ while (index--) {
+ var key = objProps[index];
+ if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+ return false;
+ }
+ }
+ // Assume cyclic values are equal.
+ var stacked = stack.get(object);
+ if (stacked && stack.get(other)) {
+ return stacked == other;
+ }
+ var result = true;
+ stack.set(object, other);
+ stack.set(other, object);
+
+ var skipCtor = isPartial;
+ while (++index < objLength) {
+ key = objProps[index];
+ var objValue = object[key],
+ othValue = other[key];
+
+ if (customizer) {
+ var compared = isPartial
+ ? customizer(othValue, objValue, key, other, object, stack)
+ : customizer(objValue, othValue, key, object, other, stack);
+ }
+ // Recursively compare objects (susceptible to call stack limits).
+ if (!(compared === undefined
+ ? (objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack))
+ : compared
+ )) {
+ result = false;
+ break;
+ }
+ skipCtor || (skipCtor = key == 'constructor');
+ }
+ if (result && !skipCtor) {
+ var objCtor = object.constructor,
+ othCtor = other.constructor;
+
+ // Non `Object` object instances with different constructors are not equal.
+ if (objCtor != othCtor &&
+ ('constructor' in object && 'constructor' in other) &&
+ !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+ typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+ result = false;
+ }
+ }
+ stack['delete'](object);
+ stack['delete'](other);
+ return result;
+}
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+ var data = map.__data__;
+ return isKeyable(key)
+ ? data[typeof key == 'string' ? 'string' : 'hash']
+ : data.map;
+}
+
+/**
+ * Gets the property names, values, and compare flags of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the match data of `object`.
+ */
+function getMatchData(object) {
+ var result = keys(object),
+ length = result.length;
+
+ while (length--) {
+ var key = result[length],
+ value = object[key];
+
+ result[length] = [key, value, isStrictComparable(value)];
+ }
+ return result;
+}
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+ var value = getValue(object, key);
+ return baseIsNative(value) ? value : undefined;
+}
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+var getTag = baseGetTag;
+
+// Fallback for data views, maps, sets, and weak maps in IE 11,
+// for data views in Edge < 14, and promises in Node.js.
+if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+ (Map && getTag(new Map) != mapTag) ||
+ (Promise && getTag(Promise.resolve()) != promiseTag) ||
+ (Set && getTag(new Set) != setTag) ||
+ (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+ getTag = function(value) {
+ var result = objectToString.call(value),
+ Ctor = result == objectTag ? value.constructor : undefined,
+ ctorString = Ctor ? toSource(Ctor) : undefined;
+
+ if (ctorString) {
+ switch (ctorString) {
+ case dataViewCtorString: return dataViewTag;
+ case mapCtorString: return mapTag;
+ case promiseCtorString: return promiseTag;
+ case setCtorString: return setTag;
+ case weakMapCtorString: return weakMapTag;
+ }
+ }
+ return result;
+ };
+}
+
+/**
+ * Checks if `path` exists on `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @param {Function} hasFunc The function to check properties.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ */
+function hasPath(object, path, hasFunc) {
+ path = isKey(path, object) ? [path] : castPath(path);
+
+ var result,
+ index = -1,
+ length = path.length;
+
+ while (++index < length) {
+ var key = toKey(path[index]);
+ if (!(result = object != null && hasFunc(object, key))) {
+ break;
+ }
+ object = object[key];
+ }
+ if (result) {
+ return result;
+ }
+ var length = object ? object.length : 0;
+ return !!length && isLength(length) && isIndex(key, length) &&
+ (isArray(object) || isArguments(object));
+}
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+ length = length == null ? MAX_SAFE_INTEGER : length;
+ return !!length &&
+ (typeof value == 'number' || reIsUint.test(value)) &&
+ (value > -1 && value % 1 == 0 && value < length);
+}
+
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+function isKey(value, object) {
+ if (isArray(value)) {
+ return false;
+ }
+ var type = typeof value;
+ if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+ value == null || isSymbol(value)) {
+ return true;
+ }
+ return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+ (object != null && value in Object(object));
+}
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+ var type = typeof value;
+ return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+ ? (value !== '__proto__')
+ : (value === null);
+}
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+ return !!maskSrcKey && (maskSrcKey in func);
+}
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+ var Ctor = value && value.constructor,
+ proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+ return value === proto;
+}
+
+/**
+ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` if suitable for strict
+ * equality comparisons, else `false`.
+ */
+function isStrictComparable(value) {
+ return value === value && !isObject(value);
+}
+
+/**
+ * A specialized version of `matchesProperty` for source values suitable
+ * for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function matchesStrictComparable(key, srcValue) {
+ return function(object) {
+ if (object == null) {
+ return false;
+ }
+ return object[key] === srcValue &&
+ (srcValue !== undefined || (key in Object(object)));
+ };
+}
+
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+var stringToPath = memoize(function(string) {
+ string = toString(string);
+
+ var result = [];
+ if (reLeadingDot.test(string)) {
+ result.push('');
+ }
+ string.replace(rePropName, function(match, number, quote, string) {
+ result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
+ });
+ return result;
+});
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey(value) {
+ if (typeof value == 'string' || isSymbol(value)) {
+ return value;
+ }
+ var result = (value + '');
+ return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to process.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+ if (func != null) {
+ try {
+ return funcToString.call(func);
+ } catch (e) {}
+ try {
+ return (func + '');
+ } catch (e) {}
+ }
+ return '';
+}
+
+/**
+ * This method is like `_.find` except that it returns the index of the first
+ * element `predicate` returns truthy for instead of the element itself.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [predicate=_.identity]
+ * The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': false },
+ * { 'user': 'fred', 'active': false },
+ * { 'user': 'pebbles', 'active': true }
+ * ];
+ *
+ * _.findIndex(users, function(o) { return o.user == 'barney'; });
+ * // => 0
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.findIndex(users, { 'user': 'fred', 'active': false });
+ * // => 1
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.findIndex(users, ['active', false]);
+ * // => 0
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.findIndex(users, 'active');
+ * // => 2
+ */
+function findIndex(array, predicate, fromIndex) {
+ var length = array ? array.length : 0;
+ if (!length) {
+ return -1;
+ }
+ var index = fromIndex == null ? 0 : toInteger(fromIndex);
+ if (index < 0) {
+ index = nativeMax(length + index, 0);
+ }
+ return baseFindIndex(array, baseIteratee(predicate, 3), index);
+}
+
+/**
+ * Iterates over elements of `collection`, returning the first element
+ * `predicate` returns truthy for. The predicate is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to inspect.
+ * @param {Function} [predicate=_.identity]
+ * The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {*} Returns the matched element, else `undefined`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': true },
+ * { 'user': 'fred', 'age': 40, 'active': false },
+ * { 'user': 'pebbles', 'age': 1, 'active': true }
+ * ];
+ *
+ * _.find(users, function(o) { return o.age < 40; });
+ * // => object for 'barney'
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.find(users, { 'age': 1, 'active': true });
+ * // => object for 'pebbles'
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.find(users, ['active', false]);
+ * // => object for 'fred'
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.find(users, 'active');
+ * // => object for 'barney'
+ */
+var find = createFind(findIndex);
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize(func, resolver) {
+ if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ var memoized = function() {
+ var args = arguments,
+ key = resolver ? resolver.apply(this, args) : args[0],
+ cache = memoized.cache;
+
+ if (cache.has(key)) {
+ return cache.get(key);
+ }
+ var result = func.apply(this, args);
+ memoized.cache = cache.set(key, result);
+ return result;
+ };
+ memoized.cache = new (memoize.Cache || MapCache);
+ return memoized;
+}
+
+// Assign cache to `_.memoize`.
+memoize.Cache = MapCache;
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+ return value === other || (value !== value && other !== other);
+}
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ * else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+function isArguments(value) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
+ (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+}
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+ return value != null && isLength(value.length) && !isFunction(value);
+}
+
+/**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ * else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+function isArrayLikeObject(value) {
+ return isObjectLike(value) && isArrayLike(value);
+}
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+ // The use of `Object#toString` avoids issues with the `typeof` operator
+ // in Safari 8-9 which returns 'object' for typed array and other constructors.
+ var tag = isObject(value) ? objectToString.call(value) : '';
+ return tag == funcTag || tag == genTag;
+}
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+ return typeof value == 'number' &&
+ value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+ var type = typeof value;
+ return !!value && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+ return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+ return typeof value == 'symbol' ||
+ (isObjectLike(value) && objectToString.call(value) == symbolTag);
+}
+
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+/**
+ * Converts `value` to a finite number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.12.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted number.
+ * @example
+ *
+ * _.toFinite(3.2);
+ * // => 3.2
+ *
+ * _.toFinite(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toFinite(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toFinite('3.2');
+ * // => 3.2
+ */
+function toFinite(value) {
+ if (!value) {
+ return value === 0 ? value : 0;
+ }
+ value = toNumber(value);
+ if (value === INFINITY || value === -INFINITY) {
+ var sign = (value < 0 ? -1 : 1);
+ return sign * MAX_INTEGER;
+ }
+ return value === value ? value : 0;
+}
+
+/**
+ * Converts `value` to an integer.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toInteger(3.2);
+ * // => 3
+ *
+ * _.toInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toInteger(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toInteger('3.2');
+ * // => 3
+ */
+function toInteger(value) {
+ var result = toFinite(value),
+ remainder = result % 1;
+
+ return result === result ? (remainder ? result - remainder : result) : 0;
+}
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+ if (typeof value == 'number') {
+ return value;
+ }
+ if (isSymbol(value)) {
+ return NAN;
+ }
+ if (isObject(value)) {
+ var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+ value = isObject(other) ? (other + '') : other;
+ }
+ if (typeof value != 'string') {
+ return value === 0 ? value : +value;
+ }
+ value = value.replace(reTrim, '');
+ var isBinary = reIsBinary.test(value);
+ return (isBinary || reIsOctal.test(value))
+ ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+ : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString(value) {
+ return value == null ? '' : baseToString(value);
+}
+
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+function get(object, path, defaultValue) {
+ var result = object == null ? undefined : baseGet(object, path);
+ return result === undefined ? defaultValue : result;
+}
+
+/**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+function hasIn(object, path) {
+ return object != null && hasPath(object, path, baseHasIn);
+}
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+/**
+ * This method returns the first argument it receives.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ *
+ * console.log(_.identity(object) === object);
+ * // => true
+ */
+function identity(value) {
+ return value;
+}
+
+/**
+ * Creates a function that returns the value at `path` of a given object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ * @example
+ *
+ * var objects = [
+ * { 'a': { 'b': 2 } },
+ * { 'a': { 'b': 1 } }
+ * ];
+ *
+ * _.map(objects, _.property('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
+ * // => [1, 2]
+ */
+function property(path) {
+ return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+
+module.exports = find;
+
+
+/***/ }),
+
+/***/ "./node_modules/lodash.forin/index.js":
+/*!********************************************!*\
+ !*** ./node_modules/lodash.forin/index.js ***!
+ \********************************************/
+/***/ ((module) => {
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+ funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]';
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+ var index = -1,
+ result = Array(n);
+
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+}
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ // Safari 9 makes `arguments.length` enumerable in strict mode.
+ var result = (isArray(value) || isArguments(value))
+ ? baseTimes(value.length, String)
+ : [];
+
+ var length = result.length,
+ skipIndexes = !!length;
+
+ for (var key in value) {
+ if ((inherited || hasOwnProperty.call(value, key)) &&
+ !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseFor = createBaseFor();
+
+/**
+ * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeysIn(object) {
+ if (!isObject(object)) {
+ return nativeKeysIn(object);
+ }
+ var isProto = isPrototype(object),
+ result = [];
+
+ for (var key in object) {
+ if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * Creates a base function for methods like `_.forIn` and `_.forOwn`.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseFor(fromRight) {
+ return function(object, iteratee, keysFunc) {
+ var index = -1,
+ iterable = Object(object),
+ props = keysFunc(object),
+ length = props.length;
+
+ while (length--) {
+ var key = props[fromRight ? length : ++index];
+ if (iteratee(iterable[key], key, iterable) === false) {
+ break;
+ }
+ }
+ return object;
+ };
+}
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+ length = length == null ? MAX_SAFE_INTEGER : length;
+ return !!length &&
+ (typeof value == 'number' || reIsUint.test(value)) &&
+ (value > -1 && value % 1 == 0 && value < length);
+}
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+ var Ctor = value && value.constructor,
+ proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+ return value === proto;
+}
+
+/**
+ * This function is like
+ * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * except that it includes inherited enumerable properties.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function nativeKeysIn(object) {
+ var result = [];
+ if (object != null) {
+ for (var key in Object(object)) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ * else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+function isArguments(value) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
+ (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+}
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+ return value != null && isLength(value.length) && !isFunction(value);
+}
+
+/**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ * else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+function isArrayLikeObject(value) {
+ return isObjectLike(value) && isArrayLike(value);
+}
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+ // The use of `Object#toString` avoids issues with the `typeof` operator
+ // in Safari 8-9 which returns 'object' for typed array and other constructors.
+ var tag = isObject(value) ? objectToString.call(value) : '';
+ return tag == funcTag || tag == genTag;
+}
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+ return typeof value == 'number' &&
+ value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+ var type = typeof value;
+ return !!value && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+ return !!value && typeof value == 'object';
+}
+
+/**
+ * Iterates over own and inherited enumerable string keyed properties of an
+ * object and invokes `iteratee` for each property. The iteratee is invoked
+ * with three arguments: (value, key, object). Iteratee functions may exit
+ * iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.3.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ * @see _.forInRight
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.forIn(new Foo, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
+ */
+function forIn(object, iteratee) {
+ return object == null
+ ? object
+ : baseFor(object, typeof iteratee == 'function' ? iteratee : identity, keysIn);
+}
+
+/**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+function keysIn(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+
+/**
+ * This method returns the first argument it receives.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ *
+ * console.log(_.identity(object) === object);
+ * // => true
+ */
+function identity(value) {
+ return value;
+}
+
+module.exports = forIn;
+
+
+/***/ }),
+
+/***/ "./node_modules/lodash.isnil/index.js":
+/*!********************************************!*\
+ !*** ./node_modules/lodash.isnil/index.js ***!
+ \********************************************/
+/***/ ((module) => {
+
+/**
+ * lodash 4.0.0 (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <https://lodash.com/license>
+ */
+
+/**
+ * Checks if `value` is `null` or `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
+ * @example
+ *
+ * _.isNil(null);
+ * // => true
+ *
+ * _.isNil(void 0);
+ * // => true
+ *
+ * _.isNil(NaN);
+ * // => false
+ */
+function isNil(value) {
+ return value == null;
+}
+
+module.exports = isNil;
+
+
+/***/ }),
+
+/***/ "./node_modules/lodash.map/index.js":
+/*!******************************************!*\
+ !*** ./node_modules/lodash.map/index.js ***!
+ \******************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** Used to compose bitmasks for comparison styles. */
+var UNORDERED_COMPARE_FLAG = 1,
+ PARTIAL_COMPARE_FLAG = 2;
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0,
+ MAX_SAFE_INTEGER = 9007199254740991;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+ arrayTag = '[object Array]',
+ boolTag = '[object Boolean]',
+ dateTag = '[object Date]',
+ errorTag = '[object Error]',
+ funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]',
+ mapTag = '[object Map]',
+ numberTag = '[object Number]',
+ objectTag = '[object Object]',
+ promiseTag = '[object Promise]',
+ regexpTag = '[object RegExp]',
+ setTag = '[object Set]',
+ stringTag = '[object String]',
+ symbolTag = '[object Symbol]',
+ weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+ dataViewTag = '[object DataView]',
+ float32Tag = '[object Float32Array]',
+ float64Tag = '[object Float64Array]',
+ int8Tag = '[object Int8Array]',
+ int16Tag = '[object Int16Array]',
+ int32Tag = '[object Int32Array]',
+ uint8Tag = '[object Uint8Array]',
+ uint8ClampedTag = '[object Uint8ClampedArray]',
+ uint16Tag = '[object Uint16Array]',
+ uint32Tag = '[object Uint32Array]';
+
+/** Used to match property names within property paths. */
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+ reIsPlainProp = /^\w*$/,
+ reLeadingDot = /^\./,
+ rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to match backslashes in property paths. */
+var reEscapeChar = /\\(\\)?/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/** Used to identify `toStringTag` values of typed arrays. */
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+typedArrayTags[setTag] = typedArrayTags[stringTag] =
+typedArrayTags[weakMapTag] = false;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/** Detect free variable `exports`. */
+var freeExports = true && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Detect free variable `process` from Node.js. */
+var freeProcess = moduleExports && freeGlobal.process;
+
+/** Used to access faster Node.js helpers. */
+var nodeUtil = (function() {
+ try {
+ return freeProcess && freeProcess.binding('util');
+ } catch (e) {}
+}());
+
+/* Node.js helper references. */
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = iteratee(array[index], index, array);
+ }
+ return result;
+}
+
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ * else `false`.
+ */
+function arraySome(array, predicate) {
+ var index = -1,
+ length = array ? array.length : 0;
+
+ while (++index < length) {
+ if (predicate(array[index], index, array)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function baseProperty(key) {
+ return function(object) {
+ return object == null ? undefined : object[key];
+ };
+}
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+ var index = -1,
+ result = Array(n);
+
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+function baseUnary(func) {
+ return function(value) {
+ return func(value);
+ };
+}
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+ return object == null ? undefined : object[key];
+}
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+ // Many host objects are `Object` objects that can coerce to strings
+ // despite having improperly defined `toString` methods.
+ var result = false;
+ if (value != null && typeof value.toString != 'function') {
+ try {
+ result = !!(value + '');
+ } catch (e) {}
+ }
+ return result;
+}
+
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+ var index = -1,
+ result = Array(map.size);
+
+ map.forEach(function(value, key) {
+ result[++index] = [key, value];
+ });
+ return result;
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+}
+
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+ var index = -1,
+ result = Array(set.size);
+
+ set.forEach(function(value) {
+ result[++index] = value;
+ });
+ return result;
+}
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype,
+ funcProto = Function.prototype,
+ objectProto = Object.prototype;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+ var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+ return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+ funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+ .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/** Built-in value references. */
+var Symbol = root.Symbol,
+ Uint8Array = root.Uint8Array,
+ propertyIsEnumerable = objectProto.propertyIsEnumerable,
+ splice = arrayProto.splice;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeKeys = overArg(Object.keys, Object);
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView'),
+ Map = getNative(root, 'Map'),
+ Promise = getNative(root, 'Promise'),
+ Set = getNative(root, 'Set'),
+ WeakMap = getNative(root, 'WeakMap'),
+ nativeCreate = getNative(Object, 'create');
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+ mapCtorString = toSource(Map),
+ promiseCtorString = toSource(Promise),
+ setCtorString = toSource(Set),
+ weakMapCtorString = toSource(WeakMap);
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+ symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
+ symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+ this.__data__ = nativeCreate ? nativeCreate(null) : {};
+}
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+ return this.has(key) && delete this.__data__[key];
+}
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+ var data = this.__data__;
+ if (nativeCreate) {
+ var result = data[key];
+ return result === HASH_UNDEFINED ? undefined : result;
+ }
+ return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+ var data = this.__data__;
+ return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+}
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+ var data = this.__data__;
+ data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+ return this;
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+ this.__data__ = [];
+}
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ return false;
+ }
+ var lastIndex = data.length - 1;
+ if (index == lastIndex) {
+ data.pop();
+ } else {
+ splice.call(data, index, 1);
+ }
+ return true;
+}
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ return index < 0 ? undefined : data[index][1];
+}
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+ return assocIndexOf(this.__data__, key) > -1;
+}
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ data.push([key, value]);
+ } else {
+ data[index][1] = value;
+ }
+ return this;
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+ this.__data__ = {
+ 'hash': new Hash,
+ 'map': new (Map || ListCache),
+ 'string': new Hash
+ };
+}
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+ return getMapData(this, key)['delete'](key);
+}
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+ return getMapData(this, key).get(key);
+}
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+ return getMapData(this, key).has(key);
+}
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+ getMapData(this, key).set(key, value);
+ return this;
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+ var index = -1,
+ length = values ? values.length : 0;
+
+ this.__data__ = new MapCache;
+ while (++index < length) {
+ this.add(values[index]);
+ }
+}
+
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+function setCacheAdd(value) {
+ this.__data__.set(value, HASH_UNDEFINED);
+ return this;
+}
+
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+function setCacheHas(value) {
+ return this.__data__.has(value);
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+ this.__data__ = new ListCache(entries);
+}
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear() {
+ this.__data__ = new ListCache;
+}
+
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function stackDelete(key) {
+ return this.__data__['delete'](key);
+}
+
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function stackGet(key) {
+ return this.__data__.get(key);
+}
+
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function stackHas(key) {
+ return this.__data__.has(key);
+}
+
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+function stackSet(key, value) {
+ var cache = this.__data__;
+ if (cache instanceof ListCache) {
+ var pairs = cache.__data__;
+ if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+ pairs.push([key, value]);
+ return this;
+ }
+ cache = this.__data__ = new MapCache(pairs);
+ }
+ cache.set(key, value);
+ return this;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ // Safari 9 makes `arguments.length` enumerable in strict mode.
+ var result = (isArray(value) || isArguments(value))
+ ? baseTimes(value.length, String)
+ : [];
+
+ var length = result.length,
+ skipIndexes = !!length;
+
+ for (var key in value) {
+ if ((inherited || hasOwnProperty.call(value, key)) &&
+ !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+ var length = array.length;
+ while (length--) {
+ if (eq(array[length][0], key)) {
+ return length;
+ }
+ }
+ return -1;
+}
+
+/**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEach = createBaseEach(baseForOwn);
+
+/**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseFor = createBaseFor();
+
+/**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+ return object && baseFor(object, iteratee, keys);
+}
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet(object, path) {
+ path = isKey(path, object) ? [path] : castPath(path);
+
+ var index = 0,
+ length = path.length;
+
+ while (object != null && index < length) {
+ object = object[toKey(path[index++])];
+ }
+ return (index && index == length) ? object : undefined;
+}
+
+/**
+ * The base implementation of `getTag`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+ return objectToString.call(value);
+}
+
+/**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHasIn(object, key) {
+ return object != null && key in Object(object);
+}
+
+/**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {boolean} [bitmask] The bitmask of comparison flags.
+ * The bitmask may be composed of the following flags:
+ * 1 - Unordered comparison
+ * 2 - Partial comparison
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+function baseIsEqual(value, other, customizer, bitmask, stack) {
+ if (value === other) {
+ return true;
+ }
+ if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
+ return value !== value && other !== other;
+ }
+ return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
+}
+
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual`
+ * for more details.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
+ var objIsArr = isArray(object),
+ othIsArr = isArray(other),
+ objTag = arrayTag,
+ othTag = arrayTag;
+
+ if (!objIsArr) {
+ objTag = getTag(object);
+ objTag = objTag == argsTag ? objectTag : objTag;
+ }
+ if (!othIsArr) {
+ othTag = getTag(other);
+ othTag = othTag == argsTag ? objectTag : othTag;
+ }
+ var objIsObj = objTag == objectTag && !isHostObject(object),
+ othIsObj = othTag == objectTag && !isHostObject(other),
+ isSameTag = objTag == othTag;
+
+ if (isSameTag && !objIsObj) {
+ stack || (stack = new Stack);
+ return (objIsArr || isTypedArray(object))
+ ? equalArrays(object, other, equalFunc, customizer, bitmask, stack)
+ : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
+ }
+ if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
+ var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+ othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+ if (objIsWrapped || othIsWrapped) {
+ var objUnwrapped = objIsWrapped ? object.value() : object,
+ othUnwrapped = othIsWrapped ? other.value() : other;
+
+ stack || (stack = new Stack);
+ return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
+ }
+ }
+ if (!isSameTag) {
+ return false;
+ }
+ stack || (stack = new Stack);
+ return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
+}
+
+/**
+ * The base implementation of `_.isMatch` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Array} matchData The property names, values, and compare flags to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+function baseIsMatch(object, source, matchData, customizer) {
+ var index = matchData.length,
+ length = index,
+ noCustomizer = !customizer;
+
+ if (object == null) {
+ return !length;
+ }
+ object = Object(object);
+ while (index--) {
+ var data = matchData[index];
+ if ((noCustomizer && data[2])
+ ? data[1] !== object[data[0]]
+ : !(data[0] in object)
+ ) {
+ return false;
+ }
+ }
+ while (++index < length) {
+ data = matchData[index];
+ var key = data[0],
+ objValue = object[key],
+ srcValue = data[1];
+
+ if (noCustomizer && data[2]) {
+ if (objValue === undefined && !(key in object)) {
+ return false;
+ }
+ } else {
+ var stack = new Stack;
+ if (customizer) {
+ var result = customizer(objValue, srcValue, key, object, source, stack);
+ }
+ if (!(result === undefined
+ ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
+ : result
+ )) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ * else `false`.
+ */
+function baseIsNative(value) {
+ if (!isObject(value) || isMasked(value)) {
+ return false;
+ }
+ var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+ return pattern.test(toSource(value));
+}
+
+/**
+ * The base implementation of `_.isTypedArray` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ */
+function baseIsTypedArray(value) {
+ return isObjectLike(value) &&
+ isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
+}
+
+/**
+ * The base implementation of `_.iteratee`.
+ *
+ * @private
+ * @param {*} [value=_.identity] The value to convert to an iteratee.
+ * @returns {Function} Returns the iteratee.
+ */
+function baseIteratee(value) {
+ // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+ // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+ if (typeof value == 'function') {
+ return value;
+ }
+ if (value == null) {
+ return identity;
+ }
+ if (typeof value == 'object') {
+ return isArray(value)
+ ? baseMatchesProperty(value[0], value[1])
+ : baseMatches(value);
+ }
+ return property(value);
+}
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+ if (!isPrototype(object)) {
+ return nativeKeys(object);
+ }
+ var result = [];
+ for (var key in Object(object)) {
+ if (hasOwnProperty.call(object, key) && key != 'constructor') {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `_.map` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function baseMap(collection, iteratee) {
+ var index = -1,
+ result = isArrayLike(collection) ? Array(collection.length) : [];
+
+ baseEach(collection, function(value, key, collection) {
+ result[++index] = iteratee(value, key, collection);
+ });
+ return result;
+}
+
+/**
+ * The base implementation of `_.matches` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatches(source) {
+ var matchData = getMatchData(source);
+ if (matchData.length == 1 && matchData[0][2]) {
+ return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+ }
+ return function(object) {
+ return object === source || baseIsMatch(object, source, matchData);
+ };
+}
+
+/**
+ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+ *
+ * @private
+ * @param {string} path The path of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatchesProperty(path, srcValue) {
+ if (isKey(path) && isStrictComparable(srcValue)) {
+ return matchesStrictComparable(toKey(path), srcValue);
+ }
+ return function(object) {
+ var objValue = get(object, path);
+ return (objValue === undefined && objValue === srcValue)
+ ? hasIn(object, path)
+ : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
+ };
+}
+
+/**
+ * A specialized version of `baseProperty` which supports deep paths.
+ *
+ * @private
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyDeep(path) {
+ return function(object) {
+ return baseGet(object, path);
+ };
+}
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+ // Exit early for strings to avoid a performance hit in some environments.
+ if (typeof value == 'string') {
+ return value;
+ }
+ if (isSymbol(value)) {
+ return symbolToString ? symbolToString.call(value) : '';
+ }
+ var result = (value + '');
+ return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath(value) {
+ return isArray(value) ? value : stringToPath(value);
+}
+
+/**
+ * Creates a `baseEach` or `baseEachRight` function.
+ *
+ * @private
+ * @param {Function} eachFunc The function to iterate over a collection.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseEach(eachFunc, fromRight) {
+ return function(collection, iteratee) {
+ if (collection == null) {
+ return collection;
+ }
+ if (!isArrayLike(collection)) {
+ return eachFunc(collection, iteratee);
+ }
+ var length = collection.length,
+ index = fromRight ? length : -1,
+ iterable = Object(collection);
+
+ while ((fromRight ? index-- : ++index < length)) {
+ if (iteratee(iterable[index], index, iterable) === false) {
+ break;
+ }
+ }
+ return collection;
+ };
+}
+
+/**
+ * Creates a base function for methods like `_.forIn` and `_.forOwn`.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseFor(fromRight) {
+ return function(object, iteratee, keysFunc) {
+ var index = -1,
+ iterable = Object(object),
+ props = keysFunc(object),
+ length = props.length;
+
+ while (length--) {
+ var key = props[fromRight ? length : ++index];
+ if (iteratee(iterable[key], key, iterable) === false) {
+ break;
+ }
+ }
+ return object;
+ };
+}
+
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
+ * for more details.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
+ var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
+ arrLength = array.length,
+ othLength = other.length;
+
+ if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+ return false;
+ }
+ // Assume cyclic values are equal.
+ var stacked = stack.get(array);
+ if (stacked && stack.get(other)) {
+ return stacked == other;
+ }
+ var index = -1,
+ result = true,
+ seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
+
+ stack.set(array, other);
+ stack.set(other, array);
+
+ // Ignore non-index properties.
+ while (++index < arrLength) {
+ var arrValue = array[index],
+ othValue = other[index];
+
+ if (customizer) {
+ var compared = isPartial
+ ? customizer(othValue, arrValue, index, other, array, stack)
+ : customizer(arrValue, othValue, index, array, other, stack);
+ }
+ if (compared !== undefined) {
+ if (compared) {
+ continue;
+ }
+ result = false;
+ break;
+ }
+ // Recursively compare arrays (susceptible to call stack limits).
+ if (seen) {
+ if (!arraySome(other, function(othValue, othIndex) {
+ if (!seen.has(othIndex) &&
+ (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
+ return seen.add(othIndex);
+ }
+ })) {
+ result = false;
+ break;
+ }
+ } else if (!(
+ arrValue === othValue ||
+ equalFunc(arrValue, othValue, customizer, bitmask, stack)
+ )) {
+ result = false;
+ break;
+ }
+ }
+ stack['delete'](array);
+ stack['delete'](other);
+ return result;
+}
+
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
+ * for more details.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
+ switch (tag) {
+ case dataViewTag:
+ if ((object.byteLength != other.byteLength) ||
+ (object.byteOffset != other.byteOffset)) {
+ return false;
+ }
+ object = object.buffer;
+ other = other.buffer;
+
+ case arrayBufferTag:
+ if ((object.byteLength != other.byteLength) ||
+ !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+ return false;
+ }
+ return true;
+
+ case boolTag:
+ case dateTag:
+ case numberTag:
+ // Coerce booleans to `1` or `0` and dates to milliseconds.
+ // Invalid dates are coerced to `NaN`.
+ return eq(+object, +other);
+
+ case errorTag:
+ return object.name == other.name && object.message == other.message;
+
+ case regexpTag:
+ case stringTag:
+ // Coerce regexes to strings and treat strings, primitives and objects,
+ // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+ // for more details.
+ return object == (other + '');
+
+ case mapTag:
+ var convert = mapToArray;
+
+ case setTag:
+ var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
+ convert || (convert = setToArray);
+
+ if (object.size != other.size && !isPartial) {
+ return false;
+ }
+ // Assume cyclic values are equal.
+ var stacked = stack.get(object);
+ if (stacked) {
+ return stacked == other;
+ }
+ bitmask |= UNORDERED_COMPARE_FLAG;
+
+ // Recursively compare objects (susceptible to call stack limits).
+ stack.set(object, other);
+ var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+ stack['delete'](object);
+ return result;
+
+ case symbolTag:
+ if (symbolValueOf) {
+ return symbolValueOf.call(object) == symbolValueOf.call(other);
+ }
+ }
+ return false;
+}
+
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
+ * for more details.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
+ var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
+ objProps = keys(object),
+ objLength = objProps.length,
+ othProps = keys(other),
+ othLength = othProps.length;
+
+ if (objLength != othLength && !isPartial) {
+ return false;
+ }
+ var index = objLength;
+ while (index--) {
+ var key = objProps[index];
+ if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+ return false;
+ }
+ }
+ // Assume cyclic values are equal.
+ var stacked = stack.get(object);
+ if (stacked && stack.get(other)) {
+ return stacked == other;
+ }
+ var result = true;
+ stack.set(object, other);
+ stack.set(other, object);
+
+ var skipCtor = isPartial;
+ while (++index < objLength) {
+ key = objProps[index];
+ var objValue = object[key],
+ othValue = other[key];
+
+ if (customizer) {
+ var compared = isPartial
+ ? customizer(othValue, objValue, key, other, object, stack)
+ : customizer(objValue, othValue, key, object, other, stack);
+ }
+ // Recursively compare objects (susceptible to call stack limits).
+ if (!(compared === undefined
+ ? (objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack))
+ : compared
+ )) {
+ result = false;
+ break;
+ }
+ skipCtor || (skipCtor = key == 'constructor');
+ }
+ if (result && !skipCtor) {
+ var objCtor = object.constructor,
+ othCtor = other.constructor;
+
+ // Non `Object` object instances with different constructors are not equal.
+ if (objCtor != othCtor &&
+ ('constructor' in object && 'constructor' in other) &&
+ !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+ typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+ result = false;
+ }
+ }
+ stack['delete'](object);
+ stack['delete'](other);
+ return result;
+}
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+ var data = map.__data__;
+ return isKeyable(key)
+ ? data[typeof key == 'string' ? 'string' : 'hash']
+ : data.map;
+}
+
+/**
+ * Gets the property names, values, and compare flags of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the match data of `object`.
+ */
+function getMatchData(object) {
+ var result = keys(object),
+ length = result.length;
+
+ while (length--) {
+ var key = result[length],
+ value = object[key];
+
+ result[length] = [key, value, isStrictComparable(value)];
+ }
+ return result;
+}
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+ var value = getValue(object, key);
+ return baseIsNative(value) ? value : undefined;
+}
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+var getTag = baseGetTag;
+
+// Fallback for data views, maps, sets, and weak maps in IE 11,
+// for data views in Edge < 14, and promises in Node.js.
+if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+ (Map && getTag(new Map) != mapTag) ||
+ (Promise && getTag(Promise.resolve()) != promiseTag) ||
+ (Set && getTag(new Set) != setTag) ||
+ (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+ getTag = function(value) {
+ var result = objectToString.call(value),
+ Ctor = result == objectTag ? value.constructor : undefined,
+ ctorString = Ctor ? toSource(Ctor) : undefined;
+
+ if (ctorString) {
+ switch (ctorString) {
+ case dataViewCtorString: return dataViewTag;
+ case mapCtorString: return mapTag;
+ case promiseCtorString: return promiseTag;
+ case setCtorString: return setTag;
+ case weakMapCtorString: return weakMapTag;
+ }
+ }
+ return result;
+ };
+}
+
+/**
+ * Checks if `path` exists on `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @param {Function} hasFunc The function to check properties.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ */
+function hasPath(object, path, hasFunc) {
+ path = isKey(path, object) ? [path] : castPath(path);
+
+ var result,
+ index = -1,
+ length = path.length;
+
+ while (++index < length) {
+ var key = toKey(path[index]);
+ if (!(result = object != null && hasFunc(object, key))) {
+ break;
+ }
+ object = object[key];
+ }
+ if (result) {
+ return result;
+ }
+ var length = object ? object.length : 0;
+ return !!length && isLength(length) && isIndex(key, length) &&
+ (isArray(object) || isArguments(object));
+}
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+ length = length == null ? MAX_SAFE_INTEGER : length;
+ return !!length &&
+ (typeof value == 'number' || reIsUint.test(value)) &&
+ (value > -1 && value % 1 == 0 && value < length);
+}
+
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+function isKey(value, object) {
+ if (isArray(value)) {
+ return false;
+ }
+ var type = typeof value;
+ if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+ value == null || isSymbol(value)) {
+ return true;
+ }
+ return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+ (object != null && value in Object(object));
+}
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+ var type = typeof value;
+ return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+ ? (value !== '__proto__')
+ : (value === null);
+}
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+ return !!maskSrcKey && (maskSrcKey in func);
+}
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+ var Ctor = value && value.constructor,
+ proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+ return value === proto;
+}
+
+/**
+ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` if suitable for strict
+ * equality comparisons, else `false`.
+ */
+function isStrictComparable(value) {
+ return value === value && !isObject(value);
+}
+
+/**
+ * A specialized version of `matchesProperty` for source values suitable
+ * for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function matchesStrictComparable(key, srcValue) {
+ return function(object) {
+ if (object == null) {
+ return false;
+ }
+ return object[key] === srcValue &&
+ (srcValue !== undefined || (key in Object(object)));
+ };
+}
+
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+var stringToPath = memoize(function(string) {
+ string = toString(string);
+
+ var result = [];
+ if (reLeadingDot.test(string)) {
+ result.push('');
+ }
+ string.replace(rePropName, function(match, number, quote, string) {
+ result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
+ });
+ return result;
+});
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey(value) {
+ if (typeof value == 'string' || isSymbol(value)) {
+ return value;
+ }
+ var result = (value + '');
+ return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to process.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+ if (func != null) {
+ try {
+ return funcToString.call(func);
+ } catch (e) {}
+ try {
+ return (func + '');
+ } catch (e) {}
+ }
+ return '';
+}
+
+/**
+ * Creates an array of values by running each element in `collection` thru
+ * `iteratee`. The iteratee is invoked with three arguments:
+ * (value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like
+ * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
+ *
+ * The guarded methods are:
+ * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
+ * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
+ * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
+ * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ * @example
+ *
+ * function square(n) {
+ * return n * n;
+ * }
+ *
+ * _.map([4, 8], square);
+ * // => [16, 64]
+ *
+ * _.map({ 'a': 4, 'b': 8 }, square);
+ * // => [16, 64] (iteration order is not guaranteed)
+ *
+ * var users = [
+ * { 'user': 'barney' },
+ * { 'user': 'fred' }
+ * ];
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.map(users, 'user');
+ * // => ['barney', 'fred']
+ */
+function map(collection, iteratee) {
+ var func = isArray(collection) ? arrayMap : baseMap;
+ return func(collection, baseIteratee(iteratee, 3));
+}
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize(func, resolver) {
+ if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ var memoized = function() {
+ var args = arguments,
+ key = resolver ? resolver.apply(this, args) : args[0],
+ cache = memoized.cache;
+
+ if (cache.has(key)) {
+ return cache.get(key);
+ }
+ var result = func.apply(this, args);
+ memoized.cache = cache.set(key, result);
+ return result;
+ };
+ memoized.cache = new (memoize.Cache || MapCache);
+ return memoized;
+}
+
+// Assign cache to `_.memoize`.
+memoize.Cache = MapCache;
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+ return value === other || (value !== value && other !== other);
+}
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ * else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+function isArguments(value) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
+ (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+}
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+ return value != null && isLength(value.length) && !isFunction(value);
+}
+
+/**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ * else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+function isArrayLikeObject(value) {
+ return isObjectLike(value) && isArrayLike(value);
+}
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+ // The use of `Object#toString` avoids issues with the `typeof` operator
+ // in Safari 8-9 which returns 'object' for typed array and other constructors.
+ var tag = isObject(value) ? objectToString.call(value) : '';
+ return tag == funcTag || tag == genTag;
+}
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+ return typeof value == 'number' &&
+ value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+ var type = typeof value;
+ return !!value && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+ return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+ return typeof value == 'symbol' ||
+ (isObjectLike(value) && objectToString.call(value) == symbolTag);
+}
+
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString(value) {
+ return value == null ? '' : baseToString(value);
+}
+
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+function get(object, path, defaultValue) {
+ var result = object == null ? undefined : baseGet(object, path);
+ return result === undefined ? defaultValue : result;
+}
+
+/**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+function hasIn(object, path) {
+ return object != null && hasPath(object, path, baseHasIn);
+}
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+/**
+ * This method returns the first argument it receives.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ *
+ * console.log(_.identity(object) === object);
+ * // => true
+ */
+function identity(value) {
+ return value;
+}
+
+/**
+ * Creates a function that returns the value at `path` of a given object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ * @example
+ *
+ * var objects = [
+ * { 'a': { 'b': 2 } },
+ * { 'a': { 'b': 1 } }
+ * ];
+ *
+ * _.map(objects, _.property('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
+ * // => [1, 2]
+ */
+function property(path) {
+ return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+
+module.exports = map;
+
+
+/***/ }),
+
+/***/ "./node_modules/lodash.merge/index.js":
+/*!********************************************!*\
+ !*** ./node_modules/lodash.merge/index.js ***!
+ \********************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+/**
+ * Lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** Used to detect hot functions by number of calls within a span of milliseconds. */
+var HOT_COUNT = 800,
+ HOT_SPAN = 16;
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+ arrayTag = '[object Array]',
+ asyncTag = '[object AsyncFunction]',
+ boolTag = '[object Boolean]',
+ dateTag = '[object Date]',
+ errorTag = '[object Error]',
+ funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]',
+ mapTag = '[object Map]',
+ numberTag = '[object Number]',
+ nullTag = '[object Null]',
+ objectTag = '[object Object]',
+ proxyTag = '[object Proxy]',
+ regexpTag = '[object RegExp]',
+ setTag = '[object Set]',
+ stringTag = '[object String]',
+ undefinedTag = '[object Undefined]',
+ weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+ dataViewTag = '[object DataView]',
+ float32Tag = '[object Float32Array]',
+ float64Tag = '[object Float64Array]',
+ int8Tag = '[object Int8Array]',
+ int16Tag = '[object Int16Array]',
+ int32Tag = '[object Int32Array]',
+ uint8Tag = '[object Uint8Array]',
+ uint8ClampedTag = '[object Uint8ClampedArray]',
+ uint16Tag = '[object Uint16Array]',
+ uint32Tag = '[object Uint32Array]';
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/** Used to identify `toStringTag` values of typed arrays. */
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+typedArrayTags[setTag] = typedArrayTags[stringTag] =
+typedArrayTags[weakMapTag] = false;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/** Detect free variable `exports`. */
+var freeExports = true && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Detect free variable `process` from Node.js. */
+var freeProcess = moduleExports && freeGlobal.process;
+
+/** Used to access faster Node.js helpers. */
+var nodeUtil = (function() {
+ try {
+ // Use `util.types` for Node.js 10+.
+ var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+ if (types) {
+ return types;
+ }
+
+ // Legacy `process.binding('util')` for Node.js < 10.
+ return freeProcess && freeProcess.binding && freeProcess.binding('util');
+ } catch (e) {}
+}());
+
+/* Node.js helper references. */
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+/**
+ * A faster alternative to `Function#apply`, this function invokes `func`
+ * with the `this` binding of `thisArg` and the arguments of `args`.
+ *
+ * @private
+ * @param {Function} func The function to invoke.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {Array} args The arguments to invoke `func` with.
+ * @returns {*} Returns the result of `func`.
+ */
+function apply(func, thisArg, args) {
+ switch (args.length) {
+ case 0: return func.call(thisArg);
+ case 1: return func.call(thisArg, args[0]);
+ case 2: return func.call(thisArg, args[0], args[1]);
+ case 3: return func.call(thisArg, args[0], args[1], args[2]);
+ }
+ return func.apply(thisArg, args);
+}
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+ var index = -1,
+ result = Array(n);
+
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+function baseUnary(func) {
+ return function(value) {
+ return func(value);
+ };
+}
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+ return object == null ? undefined : object[key];
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+}
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype,
+ funcProto = Function.prototype,
+ objectProto = Object.prototype;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+ var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+ return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto.toString;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+ funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+ .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/** Built-in value references. */
+var Buffer = moduleExports ? root.Buffer : undefined,
+ Symbol = root.Symbol,
+ Uint8Array = root.Uint8Array,
+ allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
+ getPrototype = overArg(Object.getPrototypeOf, Object),
+ objectCreate = Object.create,
+ propertyIsEnumerable = objectProto.propertyIsEnumerable,
+ splice = arrayProto.splice,
+ symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+var defineProperty = (function() {
+ try {
+ var func = getNative(Object, 'defineProperty');
+ func({}, '', {});
+ return func;
+ } catch (e) {}
+}());
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
+ nativeMax = Math.max,
+ nativeNow = Date.now;
+
+/* Built-in method references that are verified to be native. */
+var Map = getNative(root, 'Map'),
+ nativeCreate = getNative(Object, 'create');
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} proto The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+var baseCreate = (function() {
+ function object() {}
+ return function(proto) {
+ if (!isObject(proto)) {
+ return {};
+ }
+ if (objectCreate) {
+ return objectCreate(proto);
+ }
+ object.prototype = proto;
+ var result = new object;
+ object.prototype = undefined;
+ return result;
+ };
+}());
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+ var index = -1,
+ length = entries == null ? 0 : entries.length;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+ this.__data__ = nativeCreate ? nativeCreate(null) : {};
+ this.size = 0;
+}
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+ var result = this.has(key) && delete this.__data__[key];
+ this.size -= result ? 1 : 0;
+ return result;
+}
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+ var data = this.__data__;
+ if (nativeCreate) {
+ var result = data[key];
+ return result === HASH_UNDEFINED ? undefined : result;
+ }
+ return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+ var data = this.__data__;
+ return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
+}
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+ var data = this.__data__;
+ this.size += this.has(key) ? 0 : 1;
+ data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+ return this;
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+ var index = -1,
+ length = entries == null ? 0 : entries.length;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+ this.__data__ = [];
+ this.size = 0;
+}
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ return false;
+ }
+ var lastIndex = data.length - 1;
+ if (index == lastIndex) {
+ data.pop();
+ } else {
+ splice.call(data, index, 1);
+ }
+ --this.size;
+ return true;
+}
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ return index < 0 ? undefined : data[index][1];
+}
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+ return assocIndexOf(this.__data__, key) > -1;
+}
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ ++this.size;
+ data.push([key, value]);
+ } else {
+ data[index][1] = value;
+ }
+ return this;
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+ var index = -1,
+ length = entries == null ? 0 : entries.length;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+ this.size = 0;
+ this.__data__ = {
+ 'hash': new Hash,
+ 'map': new (Map || ListCache),
+ 'string': new Hash
+ };
+}
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+ var result = getMapData(this, key)['delete'](key);
+ this.size -= result ? 1 : 0;
+ return result;
+}
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+ return getMapData(this, key).get(key);
+}
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+ return getMapData(this, key).has(key);
+}
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+ var data = getMapData(this, key),
+ size = data.size;
+
+ data.set(key, value);
+ this.size += data.size == size ? 0 : 1;
+ return this;
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+ var data = this.__data__ = new ListCache(entries);
+ this.size = data.size;
+}
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear() {
+ this.__data__ = new ListCache;
+ this.size = 0;
+}
+
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function stackDelete(key) {
+ var data = this.__data__,
+ result = data['delete'](key);
+
+ this.size = data.size;
+ return result;
+}
+
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function stackGet(key) {
+ return this.__data__.get(key);
+}
+
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function stackHas(key) {
+ return this.__data__.has(key);
+}
+
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+function stackSet(key, value) {
+ var data = this.__data__;
+ if (data instanceof ListCache) {
+ var pairs = data.__data__;
+ if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+ pairs.push([key, value]);
+ this.size = ++data.size;
+ return this;
+ }
+ data = this.__data__ = new MapCache(pairs);
+ }
+ data.set(key, value);
+ this.size = data.size;
+ return this;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+ var isArr = isArray(value),
+ isArg = !isArr && isArguments(value),
+ isBuff = !isArr && !isArg && isBuffer(value),
+ isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+ skipIndexes = isArr || isArg || isBuff || isType,
+ result = skipIndexes ? baseTimes(value.length, String) : [],
+ length = result.length;
+
+ for (var key in value) {
+ if ((inherited || hasOwnProperty.call(value, key)) &&
+ !(skipIndexes && (
+ // Safari 9 has enumerable `arguments.length` in strict mode.
+ key == 'length' ||
+ // Node.js 0.10 has enumerable non-index properties on buffers.
+ (isBuff && (key == 'offset' || key == 'parent')) ||
+ // PhantomJS 2 has enumerable non-index properties on typed arrays.
+ (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+ // Skip index properties.
+ isIndex(key, length)
+ ))) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * This function is like `assignValue` except that it doesn't assign
+ * `undefined` values.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignMergeValue(object, key, value) {
+ if ((value !== undefined && !eq(object[key], value)) ||
+ (value === undefined && !(key in object))) {
+ baseAssignValue(object, key, value);
+ }
+}
+
+/**
+ * Assigns `value` to `key` of `object` if the existing value is not equivalent
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignValue(object, key, value) {
+ var objValue = object[key];
+ if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+ (value === undefined && !(key in object))) {
+ baseAssignValue(object, key, value);
+ }
+}
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+ var length = array.length;
+ while (length--) {
+ if (eq(array[length][0], key)) {
+ return length;
+ }
+ }
+ return -1;
+}
+
+/**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function baseAssignValue(object, key, value) {
+ if (key == '__proto__' && defineProperty) {
+ defineProperty(object, key, {
+ 'configurable': true,
+ 'enumerable': true,
+ 'value': value,
+ 'writable': true
+ });
+ } else {
+ object[key] = value;
+ }
+}
+
+/**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseFor = createBaseFor();
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+ if (value == null) {
+ return value === undefined ? undefinedTag : nullTag;
+ }
+ return (symToStringTag && symToStringTag in Object(value))
+ ? getRawTag(value)
+ : objectToString(value);
+}
+
+/**
+ * The base implementation of `_.isArguments`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ */
+function baseIsArguments(value) {
+ return isObjectLike(value) && baseGetTag(value) == argsTag;
+}
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ * else `false`.
+ */
+function baseIsNative(value) {
+ if (!isObject(value) || isMasked(value)) {
+ return false;
+ }
+ var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+ return pattern.test(toSource(value));
+}
+
+/**
+ * The base implementation of `_.isTypedArray` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ */
+function baseIsTypedArray(value) {
+ return isObjectLike(value) &&
+ isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+
+/**
+ * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeysIn(object) {
+ if (!isObject(object)) {
+ return nativeKeysIn(object);
+ }
+ var isProto = isPrototype(object),
+ result = [];
+
+ for (var key in object) {
+ if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `_.merge` without support for multiple sources.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} [customizer] The function to customize merged values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ * counterparts.
+ */
+function baseMerge(object, source, srcIndex, customizer, stack) {
+ if (object === source) {
+ return;
+ }
+ baseFor(source, function(srcValue, key) {
+ stack || (stack = new Stack);
+ if (isObject(srcValue)) {
+ baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+ }
+ else {
+ var newValue = customizer
+ ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
+ : undefined;
+
+ if (newValue === undefined) {
+ newValue = srcValue;
+ }
+ assignMergeValue(object, key, newValue);
+ }
+ }, keysIn);
+}
+
+/**
+ * A specialized version of `baseMerge` for arrays and objects which performs
+ * deep merges and tracks traversed objects enabling objects with circular
+ * references to be merged.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {string} key The key of the value to merge.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} mergeFunc The function to merge values.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ * counterparts.
+ */
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+ var objValue = safeGet(object, key),
+ srcValue = safeGet(source, key),
+ stacked = stack.get(srcValue);
+
+ if (stacked) {
+ assignMergeValue(object, key, stacked);
+ return;
+ }
+ var newValue = customizer
+ ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+ : undefined;
+
+ var isCommon = newValue === undefined;
+
+ if (isCommon) {
+ var isArr = isArray(srcValue),
+ isBuff = !isArr && isBuffer(srcValue),
+ isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+
+ newValue = srcValue;
+ if (isArr || isBuff || isTyped) {
+ if (isArray(objValue)) {
+ newValue = objValue;
+ }
+ else if (isArrayLikeObject(objValue)) {
+ newValue = copyArray(objValue);
+ }
+ else if (isBuff) {
+ isCommon = false;
+ newValue = cloneBuffer(srcValue, true);
+ }
+ else if (isTyped) {
+ isCommon = false;
+ newValue = cloneTypedArray(srcValue, true);
+ }
+ else {
+ newValue = [];
+ }
+ }
+ else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+ newValue = objValue;
+ if (isArguments(objValue)) {
+ newValue = toPlainObject(objValue);
+ }
+ else if (!isObject(objValue) || isFunction(objValue)) {
+ newValue = initCloneObject(srcValue);
+ }
+ }
+ else {
+ isCommon = false;
+ }
+ }
+ if (isCommon) {
+ // Recursively merge objects and arrays (susceptible to call stack limits).
+ stack.set(srcValue, newValue);
+ mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+ stack['delete'](srcValue);
+ }
+ assignMergeValue(object, key, newValue);
+}
+
+/**
+ * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @returns {Function} Returns the new function.
+ */
+function baseRest(func, start) {
+ return setToString(overRest(func, start, identity), func + '');
+}
+
+/**
+ * The base implementation of `setToString` without support for hot loop shorting.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+var baseSetToString = !defineProperty ? identity : function(func, string) {
+ return defineProperty(func, 'toString', {
+ 'configurable': true,
+ 'enumerable': false,
+ 'value': constant(string),
+ 'writable': true
+ });
+};
+
+/**
+ * Creates a clone of `buffer`.
+ *
+ * @private
+ * @param {Buffer} buffer The buffer to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Buffer} Returns the cloned buffer.
+ */
+function cloneBuffer(buffer, isDeep) {
+ if (isDeep) {
+ return buffer.slice();
+ }
+ var length = buffer.length,
+ result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+
+ buffer.copy(result);
+ return result;
+}
+
+/**
+ * Creates a clone of `arrayBuffer`.
+ *
+ * @private
+ * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+ * @returns {ArrayBuffer} Returns the cloned array buffer.
+ */
+function cloneArrayBuffer(arrayBuffer) {
+ var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+ new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+ return result;
+}
+
+/**
+ * Creates a clone of `typedArray`.
+ *
+ * @private
+ * @param {Object} typedArray The typed array to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned typed array.
+ */
+function cloneTypedArray(typedArray, isDeep) {
+ var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+ return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+
+/**
+ * Copies the values of `source` to `array`.
+ *
+ * @private
+ * @param {Array} source The array to copy values from.
+ * @param {Array} [array=[]] The array to copy values to.
+ * @returns {Array} Returns `array`.
+ */
+function copyArray(source, array) {
+ var index = -1,
+ length = source.length;
+
+ array || (array = Array(length));
+ while (++index < length) {
+ array[index] = source[index];
+ }
+ return array;
+}
+
+/**
+ * Copies properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy properties from.
+ * @param {Array} props The property identifiers to copy.
+ * @param {Object} [object={}] The object to copy properties to.
+ * @param {Function} [customizer] The function to customize copied values.
+ * @returns {Object} Returns `object`.
+ */
+function copyObject(source, props, object, customizer) {
+ var isNew = !object;
+ object || (object = {});
+
+ var index = -1,
+ length = props.length;
+
+ while (++index < length) {
+ var key = props[index];
+
+ var newValue = customizer
+ ? customizer(object[key], source[key], key, object, source)
+ : undefined;
+
+ if (newValue === undefined) {
+ newValue = source[key];
+ }
+ if (isNew) {
+ baseAssignValue(object, key, newValue);
+ } else {
+ assignValue(object, key, newValue);
+ }
+ }
+ return object;
+}
+
+/**
+ * Creates a function like `_.assign`.
+ *
+ * @private
+ * @param {Function} assigner The function to assign values.
+ * @returns {Function} Returns the new assigner function.
+ */
+function createAssigner(assigner) {
+ return baseRest(function(object, sources) {
+ var index = -1,
+ length = sources.length,
+ customizer = length > 1 ? sources[length - 1] : undefined,
+ guard = length > 2 ? sources[2] : undefined;
+
+ customizer = (assigner.length > 3 && typeof customizer == 'function')
+ ? (length--, customizer)
+ : undefined;
+
+ if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+ customizer = length < 3 ? undefined : customizer;
+ length = 1;
+ }
+ object = Object(object);
+ while (++index < length) {
+ var source = sources[index];
+ if (source) {
+ assigner(object, source, index, customizer);
+ }
+ }
+ return object;
+ });
+}
+
+/**
+ * Creates a base function for methods like `_.forIn` and `_.forOwn`.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseFor(fromRight) {
+ return function(object, iteratee, keysFunc) {
+ var index = -1,
+ iterable = Object(object),
+ props = keysFunc(object),
+ length = props.length;
+
+ while (length--) {
+ var key = props[fromRight ? length : ++index];
+ if (iteratee(iterable[key], key, iterable) === false) {
+ break;
+ }
+ }
+ return object;
+ };
+}
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+ var data = map.__data__;
+ return isKeyable(key)
+ ? data[typeof key == 'string' ? 'string' : 'hash']
+ : data.map;
+}
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+ var value = getValue(object, key);
+ return baseIsNative(value) ? value : undefined;
+}
+
+/**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+function getRawTag(value) {
+ var isOwn = hasOwnProperty.call(value, symToStringTag),
+ tag = value[symToStringTag];
+
+ try {
+ value[symToStringTag] = undefined;
+ var unmasked = true;
+ } catch (e) {}
+
+ var result = nativeObjectToString.call(value);
+ if (unmasked) {
+ if (isOwn) {
+ value[symToStringTag] = tag;
+ } else {
+ delete value[symToStringTag];
+ }
+ }
+ return result;
+}
+
+/**
+ * Initializes an object clone.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneObject(object) {
+ return (typeof object.constructor == 'function' && !isPrototype(object))
+ ? baseCreate(getPrototype(object))
+ : {};
+}
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+ var type = typeof value;
+ length = length == null ? MAX_SAFE_INTEGER : length;
+
+ return !!length &&
+ (type == 'number' ||
+ (type != 'symbol' && reIsUint.test(value))) &&
+ (value > -1 && value % 1 == 0 && value < length);
+}
+
+/**
+ * Checks if the given arguments are from an iteratee call.
+ *
+ * @private
+ * @param {*} value The potential iteratee value argument.
+ * @param {*} index The potential iteratee index or key argument.
+ * @param {*} object The potential iteratee object argument.
+ * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+ * else `false`.
+ */
+function isIterateeCall(value, index, object) {
+ if (!isObject(object)) {
+ return false;
+ }
+ var type = typeof index;
+ if (type == 'number'
+ ? (isArrayLike(object) && isIndex(index, object.length))
+ : (type == 'string' && index in object)
+ ) {
+ return eq(object[index], value);
+ }
+ return false;
+}
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+ var type = typeof value;
+ return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+ ? (value !== '__proto__')
+ : (value === null);
+}
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+ return !!maskSrcKey && (maskSrcKey in func);
+}
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+ var Ctor = value && value.constructor,
+ proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+ return value === proto;
+}
+
+/**
+ * This function is like
+ * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * except that it includes inherited enumerable properties.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function nativeKeysIn(object) {
+ var result = [];
+ if (object != null) {
+ for (var key in Object(object)) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+function objectToString(value) {
+ return nativeObjectToString.call(value);
+}
+
+/**
+ * A specialized version of `baseRest` which transforms the rest array.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @param {Function} transform The rest array transform.
+ * @returns {Function} Returns the new function.
+ */
+function overRest(func, start, transform) {
+ start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
+ return function() {
+ var args = arguments,
+ index = -1,
+ length = nativeMax(args.length - start, 0),
+ array = Array(length);
+
+ while (++index < length) {
+ array[index] = args[start + index];
+ }
+ index = -1;
+ var otherArgs = Array(start + 1);
+ while (++index < start) {
+ otherArgs[index] = args[index];
+ }
+ otherArgs[start] = transform(array);
+ return apply(func, this, otherArgs);
+ };
+}
+
+/**
+ * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function safeGet(object, key) {
+ if (key === 'constructor' && typeof object[key] === 'function') {
+ return;
+ }
+
+ if (key == '__proto__') {
+ return;
+ }
+
+ return object[key];
+}
+
+/**
+ * Sets the `toString` method of `func` to return `string`.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+var setToString = shortOut(baseSetToString);
+
+/**
+ * Creates a function that'll short out and invoke `identity` instead
+ * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
+ * milliseconds.
+ *
+ * @private
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new shortable function.
+ */
+function shortOut(func) {
+ var count = 0,
+ lastCalled = 0;
+
+ return function() {
+ var stamp = nativeNow(),
+ remaining = HOT_SPAN - (stamp - lastCalled);
+
+ lastCalled = stamp;
+ if (remaining > 0) {
+ if (++count >= HOT_COUNT) {
+ return arguments[0];
+ }
+ } else {
+ count = 0;
+ }
+ return func.apply(undefined, arguments);
+ };
+}
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to convert.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+ if (func != null) {
+ try {
+ return funcToString.call(func);
+ } catch (e) {}
+ try {
+ return (func + '');
+ } catch (e) {}
+ }
+ return '';
+}
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+ return value === other || (value !== value && other !== other);
+}
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ * else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+ return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
+ !propertyIsEnumerable.call(value, 'callee');
+};
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+ return value != null && isLength(value.length) && !isFunction(value);
+}
+
+/**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ * else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+function isArrayLikeObject(value) {
+ return isObjectLike(value) && isArrayLike(value);
+}
+
+/**
+ * Checks if `value` is a buffer.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+ * @example
+ *
+ * _.isBuffer(new Buffer(2));
+ * // => true
+ *
+ * _.isBuffer(new Uint8Array(2));
+ * // => false
+ */
+var isBuffer = nativeIsBuffer || stubFalse;
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+ if (!isObject(value)) {
+ return false;
+ }
+ // The use of `Object#toString` avoids issues with the `typeof` operator
+ // in Safari 9 which returns 'object' for typed arrays and other constructors.
+ var tag = baseGetTag(value);
+ return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+ return typeof value == 'number' &&
+ value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+ var type = typeof value;
+ return value != null && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+ return value != null && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject(value) {
+ if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
+ return false;
+ }
+ var proto = getPrototype(value);
+ if (proto === null) {
+ return true;
+ }
+ var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+ return typeof Ctor == 'function' && Ctor instanceof Ctor &&
+ funcToString.call(Ctor) == objectCtorString;
+}
+
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+/**
+ * Converts `value` to a plain object flattening inherited enumerable string
+ * keyed properties of `value` to own properties of the plain object.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {Object} Returns the converted plain object.
+ * @example
+ *
+ * function Foo() {
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.assign({ 'a': 1 }, new Foo);
+ * // => { 'a': 1, 'b': 2 }
+ *
+ * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+ * // => { 'a': 1, 'b': 2, 'c': 3 }
+ */
+function toPlainObject(value) {
+ return copyObject(value, keysIn(value));
+}
+
+/**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+function keysIn(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+
+/**
+ * This method is like `_.assign` except that it recursively merges own and
+ * inherited enumerable string keyed properties of source objects into the
+ * destination object. Source properties that resolve to `undefined` are
+ * skipped if a destination value exists. Array and plain object properties
+ * are merged recursively. Other objects and value types are overridden by
+ * assignment. Source objects are applied from left to right. Subsequent
+ * sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.5.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {
+ * 'a': [{ 'b': 2 }, { 'd': 4 }]
+ * };
+ *
+ * var other = {
+ * 'a': [{ 'c': 3 }, { 'e': 5 }]
+ * };
+ *
+ * _.merge(object, other);
+ * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+ */
+var merge = createAssigner(function(object, source, srcIndex) {
+ baseMerge(object, source, srcIndex);
+});
+
+/**
+ * Creates a function that returns `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {*} value The value to return from the new function.
+ * @returns {Function} Returns the new constant function.
+ * @example
+ *
+ * var objects = _.times(2, _.constant({ 'a': 1 }));
+ *
+ * console.log(objects);
+ * // => [{ 'a': 1 }, { 'a': 1 }]
+ *
+ * console.log(objects[0] === objects[1]);
+ * // => true
+ */
+function constant(value) {
+ return function() {
+ return value;
+ };
+}
+
+/**
+ * This method returns the first argument it receives.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ *
+ * console.log(_.identity(object) === object);
+ * // => true
+ */
+function identity(value) {
+ return value;
+}
+
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+function stubFalse() {
+ return false;
+}
+
+module.exports = merge;
+
+
+/***/ }),
+
+/***/ "./node_modules/lodash.random/index.js":
+/*!*********************************************!*\
+ !*** ./node_modules/lodash.random/index.js ***!
+ \*********************************************/
+/***/ ((module) => {
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0,
+ MAX_SAFE_INTEGER = 9007199254740991,
+ MAX_INTEGER = 1.7976931348623157e+308,
+ NAN = 0 / 0;
+
+/** `Object#toString` result references. */
+var funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]',
+ symbolTag = '[object Symbol]';
+
+/** Used to match leading and trailing whitespace. */
+var reTrim = /^\s+|\s+$/g;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseFloat = parseFloat,
+ freeParseInt = parseInt;
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeFloor = Math.floor,
+ nativeMin = Math.min,
+ nativeRandom = Math.random;
+
+/**
+ * The base implementation of `_.random` without support for returning
+ * floating-point numbers.
+ *
+ * @private
+ * @param {number} lower The lower bound.
+ * @param {number} upper The upper bound.
+ * @returns {number} Returns the random number.
+ */
+function baseRandom(lower, upper) {
+ return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
+}
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+ length = length == null ? MAX_SAFE_INTEGER : length;
+ return !!length &&
+ (typeof value == 'number' || reIsUint.test(value)) &&
+ (value > -1 && value % 1 == 0 && value < length);
+}
+
+/**
+ * Checks if the given arguments are from an iteratee call.
+ *
+ * @private
+ * @param {*} value The potential iteratee value argument.
+ * @param {*} index The potential iteratee index or key argument.
+ * @param {*} object The potential iteratee object argument.
+ * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+ * else `false`.
+ */
+function isIterateeCall(value, index, object) {
+ if (!isObject(object)) {
+ return false;
+ }
+ var type = typeof index;
+ if (type == 'number'
+ ? (isArrayLike(object) && isIndex(index, object.length))
+ : (type == 'string' && index in object)
+ ) {
+ return eq(object[index], value);
+ }
+ return false;
+}
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+ return value === other || (value !== value && other !== other);
+}
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+ return value != null && isLength(value.length) && !isFunction(value);
+}
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+ // The use of `Object#toString` avoids issues with the `typeof` operator
+ // in Safari 8-9 which returns 'object' for typed array and other constructors.
+ var tag = isObject(value) ? objectToString.call(value) : '';
+ return tag == funcTag || tag == genTag;
+}
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+ return typeof value == 'number' &&
+ value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+ var type = typeof value;
+ return !!value && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+ return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+ return typeof value == 'symbol' ||
+ (isObjectLike(value) && objectToString.call(value) == symbolTag);
+}
+
+/**
+ * Converts `value` to a finite number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.12.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted number.
+ * @example
+ *
+ * _.toFinite(3.2);
+ * // => 3.2
+ *
+ * _.toFinite(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toFinite(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toFinite('3.2');
+ * // => 3.2
+ */
+function toFinite(value) {
+ if (!value) {
+ return value === 0 ? value : 0;
+ }
+ value = toNumber(value);
+ if (value === INFINITY || value === -INFINITY) {
+ var sign = (value < 0 ? -1 : 1);
+ return sign * MAX_INTEGER;
+ }
+ return value === value ? value : 0;
+}
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+ if (typeof value == 'number') {
+ return value;
+ }
+ if (isSymbol(value)) {
+ return NAN;
+ }
+ if (isObject(value)) {
+ var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+ value = isObject(other) ? (other + '') : other;
+ }
+ if (typeof value != 'string') {
+ return value === 0 ? value : +value;
+ }
+ value = value.replace(reTrim, '');
+ var isBinary = reIsBinary.test(value);
+ return (isBinary || reIsOctal.test(value))
+ ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+ : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+/**
+ * Produces a random number between the inclusive `lower` and `upper` bounds.
+ * If only one argument is provided a number between `0` and the given number
+ * is returned. If `floating` is `true`, or either `lower` or `upper` are
+ * floats, a floating-point number is returned instead of an integer.
+ *
+ * **Note:** JavaScript follows the IEEE-754 standard for resolving
+ * floating-point values which can produce unexpected results.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.7.0
+ * @category Number
+ * @param {number} [lower=0] The lower bound.
+ * @param {number} [upper=1] The upper bound.
+ * @param {boolean} [floating] Specify returning a floating-point number.
+ * @returns {number} Returns the random number.
+ * @example
+ *
+ * _.random(0, 5);
+ * // => an integer between 0 and 5
+ *
+ * _.random(5);
+ * // => also an integer between 0 and 5
+ *
+ * _.random(5, true);
+ * // => a floating-point number between 0 and 5
+ *
+ * _.random(1.2, 5.2);
+ * // => a floating-point number between 1.2 and 5.2
+ */
+function random(lower, upper, floating) {
+ if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
+ upper = floating = undefined;
+ }
+ if (floating === undefined) {
+ if (typeof upper == 'boolean') {
+ floating = upper;
+ upper = undefined;
+ }
+ else if (typeof lower == 'boolean') {
+ floating = lower;
+ lower = undefined;
+ }
+ }
+ if (lower === undefined && upper === undefined) {
+ lower = 0;
+ upper = 1;
+ }
+ else {
+ lower = toFinite(lower);
+ if (upper === undefined) {
+ upper = lower;
+ lower = 0;
+ } else {
+ upper = toFinite(upper);
+ }
+ }
+ if (lower > upper) {
+ var temp = lower;
+ lower = upper;
+ upper = temp;
+ }
+ if (floating || lower % 1 || upper % 1) {
+ var rand = nativeRandom();
+ return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
+ }
+ return baseRandom(lower, upper);
+}
+
+module.exports = random;
+
+
+/***/ }),
+
+/***/ "./node_modules/lodash.values/index.js":
+/*!*********************************************!*\
+ !*** ./node_modules/lodash.values/index.js ***!
+ \*********************************************/
+/***/ ((module) => {
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+ funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]';
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = iteratee(array[index], index, array);
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+ var index = -1,
+ result = Array(n);
+
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `_.values` and `_.valuesIn` which creates an
+ * array of `object` property values corresponding to the property names
+ * of `props`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array} props The property names to get values for.
+ * @returns {Object} Returns the array of property values.
+ */
+function baseValues(object, props) {
+ return arrayMap(props, function(key) {
+ return object[key];
+ });
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+}
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeKeys = overArg(Object.keys, Object);
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ // Safari 9 makes `arguments.length` enumerable in strict mode.
+ var result = (isArray(value) || isArguments(value))
+ ? baseTimes(value.length, String)
+ : [];
+
+ var length = result.length,
+ skipIndexes = !!length;
+
+ for (var key in value) {
+ if ((inherited || hasOwnProperty.call(value, key)) &&
+ !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+ if (!isPrototype(object)) {
+ return nativeKeys(object);
+ }
+ var result = [];
+ for (var key in Object(object)) {
+ if (hasOwnProperty.call(object, key) && key != 'constructor') {
+ result.push(key);
+ }
+ }
+ return result;
+}
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+ length = length == null ? MAX_SAFE_INTEGER : length;
+ return !!length &&
+ (typeof value == 'number' || reIsUint.test(value)) &&
+ (value > -1 && value % 1 == 0 && value < length);
+}
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+ var Ctor = value && value.constructor,
+ proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+ return value === proto;
+}
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ * else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+function isArguments(value) {
+ // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+ return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
+ (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+}
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+ return value != null && isLength(value.length) && !isFunction(value);
+}
+
+/**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ * else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+function isArrayLikeObject(value) {
+ return isObjectLike(value) && isArrayLike(value);
+}
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+ // The use of `Object#toString` avoids issues with the `typeof` operator
+ // in Safari 8-9 which returns 'object' for typed array and other constructors.
+ var tag = isObject(value) ? objectToString.call(value) : '';
+ return tag == funcTag || tag == genTag;
+}
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+ return typeof value == 'number' &&
+ value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+ var type = typeof value;
+ return !!value && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+ return !!value && typeof value == 'object';
+}
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+/**
+ * Creates an array of the own enumerable string keyed property values of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property values.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.values(new Foo);
+ * // => [1, 2] (iteration order is not guaranteed)
+ *
+ * _.values('hi');
+ * // => ['h', 'i']
+ */
+function values(object) {
+ return object ? baseValues(object, keys(object)) : [];
+}
+
+module.exports = values;
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/af.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/af.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Afrikaans [af]
+//! author : Werner Mollentze : https://github.com/wernerm
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var af = moment.defineLocale('af', {
+ months: 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
+ weekdays: 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split(
+ '_'
+ ),
+ weekdaysShort: 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
+ weekdaysMin: 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
+ meridiemParse: /vm|nm/i,
+ isPM: function (input) {
+ return /^nm$/i.test(input);
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours < 12) {
+ return isLower ? 'vm' : 'VM';
+ } else {
+ return isLower ? 'nm' : 'NM';
+ }
+ },
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Vandag om] LT',
+ nextDay: '[Môre om] LT',
+ nextWeek: 'dddd [om] LT',
+ lastDay: '[Gister om] LT',
+ lastWeek: '[Laas] dddd [om] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'oor %s',
+ past: '%s gelede',
+ s: "'n paar sekondes",
+ ss: '%d sekondes',
+ m: "'n minuut",
+ mm: '%d minute',
+ h: "'n uur",
+ hh: '%d ure',
+ d: "'n dag",
+ dd: '%d dae',
+ M: "'n maand",
+ MM: '%d maande',
+ y: "'n jaar",
+ yy: '%d jaar',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
+ ordinal: function (number) {
+ return (
+ number +
+ (number === 1 || number === 8 || number >= 20 ? 'ste' : 'de')
+ ); // Thanks to Joris Röling : https://github.com/jjupiter
+ },
+ week: {
+ dow: 1, // Maandag is die eerste dag van die week.
+ doy: 4, // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
+ },
+ });
+
+ return af;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ar-dz.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/ar-dz.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Arabic (Algeria) [ar-dz]
+//! author : Amine Roukh: https://github.com/Amine27
+//! author : Abdel Said: https://github.com/abdelsaid
+//! author : Ahmed Elkhatib
+//! author : forabi https://github.com/forabi
+//! author : Noureddine LOUAHEDJ : https://github.com/noureddinem
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var pluralForm = function (n) {
+ return n === 0
+ ? 0
+ : n === 1
+ ? 1
+ : n === 2
+ ? 2
+ : n % 100 >= 3 && n % 100 <= 10
+ ? 3
+ : n % 100 >= 11
+ ? 4
+ : 5;
+ },
+ plurals = {
+ s: [
+ 'أقل من ثانية',
+ 'ثانية واحدة',
+ ['ثانيتان', 'ثانيتين'],
+ '%d ثوان',
+ '%d ثانية',
+ '%d ثانية',
+ ],
+ m: [
+ 'أقل من دقيقة',
+ 'دقيقة واحدة',
+ ['دقيقتان', 'دقيقتين'],
+ '%d دقائق',
+ '%d دقيقة',
+ '%d دقيقة',
+ ],
+ h: [
+ 'أقل من ساعة',
+ 'ساعة واحدة',
+ ['ساعتان', 'ساعتين'],
+ '%d ساعات',
+ '%d ساعة',
+ '%d ساعة',
+ ],
+ d: [
+ 'أقل من يوم',
+ 'يوم واحد',
+ ['يومان', 'يومين'],
+ '%d أيام',
+ '%d يومًا',
+ '%d يوم',
+ ],
+ M: [
+ 'أقل من شهر',
+ 'شهر واحد',
+ ['شهران', 'شهرين'],
+ '%d أشهر',
+ '%d شهرا',
+ '%d شهر',
+ ],
+ y: [
+ 'أقل من عام',
+ 'عام واحد',
+ ['عامان', 'عامين'],
+ '%d أعوام',
+ '%d عامًا',
+ '%d عام',
+ ],
+ },
+ pluralize = function (u) {
+ return function (number, withoutSuffix, string, isFuture) {
+ var f = pluralForm(number),
+ str = plurals[u][pluralForm(number)];
+ if (f === 2) {
+ str = str[withoutSuffix ? 0 : 1];
+ }
+ return str.replace(/%d/i, number);
+ };
+ },
+ months = [
+ 'جانفي',
+ 'فيفري',
+ 'مارس',
+ 'أفريل',
+ 'ماي',
+ 'جوان',
+ 'جويلية',
+ 'أوت',
+ 'سبتمبر',
+ 'أكتوبر',
+ 'نوفمبر',
+ 'ديسمبر',
+ ];
+
+ var arDz = moment.defineLocale('ar-dz', {
+ months: months,
+ monthsShort: months,
+ weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+ weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
+ weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'D/\u200FM/\u200FYYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /ص|م/,
+ isPM: function (input) {
+ return 'م' === input;
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'ص';
+ } else {
+ return 'م';
+ }
+ },
+ calendar: {
+ sameDay: '[اليوم عند الساعة] LT',
+ nextDay: '[غدًا عند الساعة] LT',
+ nextWeek: 'dddd [عند الساعة] LT',
+ lastDay: '[أمس عند الساعة] LT',
+ lastWeek: 'dddd [عند الساعة] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'بعد %s',
+ past: 'منذ %s',
+ s: pluralize('s'),
+ ss: pluralize('s'),
+ m: pluralize('m'),
+ mm: pluralize('m'),
+ h: pluralize('h'),
+ hh: pluralize('h'),
+ d: pluralize('d'),
+ dd: pluralize('d'),
+ M: pluralize('M'),
+ MM: pluralize('M'),
+ y: pluralize('y'),
+ yy: pluralize('y'),
+ },
+ postformat: function (string) {
+ return string.replace(/,/g, '،');
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return arDz;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ar-kw.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/ar-kw.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Arabic (Kuwait) [ar-kw]
+//! author : Nusret Parlak: https://github.com/nusretparlak
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var arKw = moment.defineLocale('ar-kw', {
+ months: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split(
+ '_'
+ ),
+ monthsShort: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split(
+ '_'
+ ),
+ weekdays: 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+ weekdaysShort: 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
+ weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[اليوم على الساعة] LT',
+ nextDay: '[غدا على الساعة] LT',
+ nextWeek: 'dddd [على الساعة] LT',
+ lastDay: '[أمس على الساعة] LT',
+ lastWeek: 'dddd [على الساعة] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'في %s',
+ past: 'منذ %s',
+ s: 'ثوان',
+ ss: '%d ثانية',
+ m: 'دقيقة',
+ mm: '%d دقائق',
+ h: 'ساعة',
+ hh: '%d ساعات',
+ d: 'يوم',
+ dd: '%d أيام',
+ M: 'شهر',
+ MM: '%d أشهر',
+ y: 'سنة',
+ yy: '%d سنوات',
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 12, // The week that contains Jan 12th is the first week of the year.
+ },
+ });
+
+ return arKw;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ar-ly.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/ar-ly.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Arabic (Lybia) [ar-ly]
+//! author : Ali Hmer: https://github.com/kikoanis
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '1',
+ 2: '2',
+ 3: '3',
+ 4: '4',
+ 5: '5',
+ 6: '6',
+ 7: '7',
+ 8: '8',
+ 9: '9',
+ 0: '0',
+ },
+ pluralForm = function (n) {
+ return n === 0
+ ? 0
+ : n === 1
+ ? 1
+ : n === 2
+ ? 2
+ : n % 100 >= 3 && n % 100 <= 10
+ ? 3
+ : n % 100 >= 11
+ ? 4
+ : 5;
+ },
+ plurals = {
+ s: [
+ 'أقل من ثانية',
+ 'ثانية واحدة',
+ ['ثانيتان', 'ثانيتين'],
+ '%d ثوان',
+ '%d ثانية',
+ '%d ثانية',
+ ],
+ m: [
+ 'أقل من دقيقة',
+ 'دقيقة واحدة',
+ ['دقيقتان', 'دقيقتين'],
+ '%d دقائق',
+ '%d دقيقة',
+ '%d دقيقة',
+ ],
+ h: [
+ 'أقل من ساعة',
+ 'ساعة واحدة',
+ ['ساعتان', 'ساعتين'],
+ '%d ساعات',
+ '%d ساعة',
+ '%d ساعة',
+ ],
+ d: [
+ 'أقل من يوم',
+ 'يوم واحد',
+ ['يومان', 'يومين'],
+ '%d أيام',
+ '%d يومًا',
+ '%d يوم',
+ ],
+ M: [
+ 'أقل من شهر',
+ 'شهر واحد',
+ ['شهران', 'شهرين'],
+ '%d أشهر',
+ '%d شهرا',
+ '%d شهر',
+ ],
+ y: [
+ 'أقل من عام',
+ 'عام واحد',
+ ['عامان', 'عامين'],
+ '%d أعوام',
+ '%d عامًا',
+ '%d عام',
+ ],
+ },
+ pluralize = function (u) {
+ return function (number, withoutSuffix, string, isFuture) {
+ var f = pluralForm(number),
+ str = plurals[u][pluralForm(number)];
+ if (f === 2) {
+ str = str[withoutSuffix ? 0 : 1];
+ }
+ return str.replace(/%d/i, number);
+ };
+ },
+ months = [
+ 'يناير',
+ 'فبراير',
+ 'مارس',
+ 'أبريل',
+ 'مايو',
+ 'يونيو',
+ 'يوليو',
+ 'أغسطس',
+ 'سبتمبر',
+ 'أكتوبر',
+ 'نوفمبر',
+ 'ديسمبر',
+ ];
+
+ var arLy = moment.defineLocale('ar-ly', {
+ months: months,
+ monthsShort: months,
+ weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+ weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
+ weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'D/\u200FM/\u200FYYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /ص|م/,
+ isPM: function (input) {
+ return 'م' === input;
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'ص';
+ } else {
+ return 'م';
+ }
+ },
+ calendar: {
+ sameDay: '[اليوم عند الساعة] LT',
+ nextDay: '[غدًا عند الساعة] LT',
+ nextWeek: 'dddd [عند الساعة] LT',
+ lastDay: '[أمس عند الساعة] LT',
+ lastWeek: 'dddd [عند الساعة] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'بعد %s',
+ past: 'منذ %s',
+ s: pluralize('s'),
+ ss: pluralize('s'),
+ m: pluralize('m'),
+ mm: pluralize('m'),
+ h: pluralize('h'),
+ hh: pluralize('h'),
+ d: pluralize('d'),
+ dd: pluralize('d'),
+ M: pluralize('M'),
+ MM: pluralize('M'),
+ y: pluralize('y'),
+ yy: pluralize('y'),
+ },
+ preparse: function (string) {
+ return string.replace(/،/g, ',');
+ },
+ postformat: function (string) {
+ return string
+ .replace(/\d/g, function (match) {
+ return symbolMap[match];
+ })
+ .replace(/,/g, '،');
+ },
+ week: {
+ dow: 6, // Saturday is the first day of the week.
+ doy: 12, // The week that contains Jan 12th is the first week of the year.
+ },
+ });
+
+ return arLy;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ar-ma.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/ar-ma.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Arabic (Morocco) [ar-ma]
+//! author : ElFadili Yassine : https://github.com/ElFadiliY
+//! author : Abdel Said : https://github.com/abdelsaid
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var arMa = moment.defineLocale('ar-ma', {
+ months: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split(
+ '_'
+ ),
+ monthsShort: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split(
+ '_'
+ ),
+ weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+ weekdaysShort: 'احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
+ weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[اليوم على الساعة] LT',
+ nextDay: '[غدا على الساعة] LT',
+ nextWeek: 'dddd [على الساعة] LT',
+ lastDay: '[أمس على الساعة] LT',
+ lastWeek: 'dddd [على الساعة] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'في %s',
+ past: 'منذ %s',
+ s: 'ثوان',
+ ss: '%d ثانية',
+ m: 'دقيقة',
+ mm: '%d دقائق',
+ h: 'ساعة',
+ hh: '%d ساعات',
+ d: 'يوم',
+ dd: '%d أيام',
+ M: 'شهر',
+ MM: '%d أشهر',
+ y: 'سنة',
+ yy: '%d سنوات',
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return arMa;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ar-sa.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/ar-sa.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Arabic (Saudi Arabia) [ar-sa]
+//! author : Suhail Alkowaileet : https://github.com/xsoh
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '١',
+ 2: '٢',
+ 3: '٣',
+ 4: '٤',
+ 5: '٥',
+ 6: '٦',
+ 7: '٧',
+ 8: '٨',
+ 9: '٩',
+ 0: '٠',
+ },
+ numberMap = {
+ '١': '1',
+ '٢': '2',
+ '٣': '3',
+ '٤': '4',
+ '٥': '5',
+ '٦': '6',
+ '٧': '7',
+ '٨': '8',
+ '٩': '9',
+ '٠': '0',
+ };
+
+ var arSa = moment.defineLocale('ar-sa', {
+ months: 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split(
+ '_'
+ ),
+ monthsShort: 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split(
+ '_'
+ ),
+ weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+ weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
+ weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /ص|م/,
+ isPM: function (input) {
+ return 'م' === input;
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'ص';
+ } else {
+ return 'م';
+ }
+ },
+ calendar: {
+ sameDay: '[اليوم على الساعة] LT',
+ nextDay: '[غدا على الساعة] LT',
+ nextWeek: 'dddd [على الساعة] LT',
+ lastDay: '[أمس على الساعة] LT',
+ lastWeek: 'dddd [على الساعة] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'في %s',
+ past: 'منذ %s',
+ s: 'ثوان',
+ ss: '%d ثانية',
+ m: 'دقيقة',
+ mm: '%d دقائق',
+ h: 'ساعة',
+ hh: '%d ساعات',
+ d: 'يوم',
+ dd: '%d أيام',
+ M: 'شهر',
+ MM: '%d أشهر',
+ y: 'سنة',
+ yy: '%d سنوات',
+ },
+ preparse: function (string) {
+ return string
+ .replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
+ return numberMap[match];
+ })
+ .replace(/،/g, ',');
+ },
+ postformat: function (string) {
+ return string
+ .replace(/\d/g, function (match) {
+ return symbolMap[match];
+ })
+ .replace(/,/g, '،');
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return arSa;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ar-tn.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/ar-tn.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Arabic (Tunisia) [ar-tn]
+//! author : Nader Toukabri : https://github.com/naderio
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var arTn = moment.defineLocale('ar-tn', {
+ months: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split(
+ '_'
+ ),
+ monthsShort: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split(
+ '_'
+ ),
+ weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+ weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
+ weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[اليوم على الساعة] LT',
+ nextDay: '[غدا على الساعة] LT',
+ nextWeek: 'dddd [على الساعة] LT',
+ lastDay: '[أمس على الساعة] LT',
+ lastWeek: 'dddd [على الساعة] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'في %s',
+ past: 'منذ %s',
+ s: 'ثوان',
+ ss: '%d ثانية',
+ m: 'دقيقة',
+ mm: '%d دقائق',
+ h: 'ساعة',
+ hh: '%d ساعات',
+ d: 'يوم',
+ dd: '%d أيام',
+ M: 'شهر',
+ MM: '%d أشهر',
+ y: 'سنة',
+ yy: '%d سنوات',
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return arTn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ar.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ar.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Arabic [ar]
+//! author : Abdel Said: https://github.com/abdelsaid
+//! author : Ahmed Elkhatib
+//! author : forabi https://github.com/forabi
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '١',
+ 2: '٢',
+ 3: '٣',
+ 4: '٤',
+ 5: '٥',
+ 6: '٦',
+ 7: '٧',
+ 8: '٨',
+ 9: '٩',
+ 0: '٠',
+ },
+ numberMap = {
+ '١': '1',
+ '٢': '2',
+ '٣': '3',
+ '٤': '4',
+ '٥': '5',
+ '٦': '6',
+ '٧': '7',
+ '٨': '8',
+ '٩': '9',
+ '٠': '0',
+ },
+ pluralForm = function (n) {
+ return n === 0
+ ? 0
+ : n === 1
+ ? 1
+ : n === 2
+ ? 2
+ : n % 100 >= 3 && n % 100 <= 10
+ ? 3
+ : n % 100 >= 11
+ ? 4
+ : 5;
+ },
+ plurals = {
+ s: [
+ 'أقل من ثانية',
+ 'ثانية واحدة',
+ ['ثانيتان', 'ثانيتين'],
+ '%d ثوان',
+ '%d ثانية',
+ '%d ثانية',
+ ],
+ m: [
+ 'أقل من دقيقة',
+ 'دقيقة واحدة',
+ ['دقيقتان', 'دقيقتين'],
+ '%d دقائق',
+ '%d دقيقة',
+ '%d دقيقة',
+ ],
+ h: [
+ 'أقل من ساعة',
+ 'ساعة واحدة',
+ ['ساعتان', 'ساعتين'],
+ '%d ساعات',
+ '%d ساعة',
+ '%d ساعة',
+ ],
+ d: [
+ 'أقل من يوم',
+ 'يوم واحد',
+ ['يومان', 'يومين'],
+ '%d أيام',
+ '%d يومًا',
+ '%d يوم',
+ ],
+ M: [
+ 'أقل من شهر',
+ 'شهر واحد',
+ ['شهران', 'شهرين'],
+ '%d أشهر',
+ '%d شهرا',
+ '%d شهر',
+ ],
+ y: [
+ 'أقل من عام',
+ 'عام واحد',
+ ['عامان', 'عامين'],
+ '%d أعوام',
+ '%d عامًا',
+ '%d عام',
+ ],
+ },
+ pluralize = function (u) {
+ return function (number, withoutSuffix, string, isFuture) {
+ var f = pluralForm(number),
+ str = plurals[u][pluralForm(number)];
+ if (f === 2) {
+ str = str[withoutSuffix ? 0 : 1];
+ }
+ return str.replace(/%d/i, number);
+ };
+ },
+ months = [
+ 'يناير',
+ 'فبراير',
+ 'مارس',
+ 'أبريل',
+ 'مايو',
+ 'يونيو',
+ 'يوليو',
+ 'أغسطس',
+ 'سبتمبر',
+ 'أكتوبر',
+ 'نوفمبر',
+ 'ديسمبر',
+ ];
+
+ var ar = moment.defineLocale('ar', {
+ months: months,
+ monthsShort: months,
+ weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
+ weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
+ weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'D/\u200FM/\u200FYYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /ص|م/,
+ isPM: function (input) {
+ return 'م' === input;
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'ص';
+ } else {
+ return 'م';
+ }
+ },
+ calendar: {
+ sameDay: '[اليوم عند الساعة] LT',
+ nextDay: '[غدًا عند الساعة] LT',
+ nextWeek: 'dddd [عند الساعة] LT',
+ lastDay: '[أمس عند الساعة] LT',
+ lastWeek: 'dddd [عند الساعة] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'بعد %s',
+ past: 'منذ %s',
+ s: pluralize('s'),
+ ss: pluralize('s'),
+ m: pluralize('m'),
+ mm: pluralize('m'),
+ h: pluralize('h'),
+ hh: pluralize('h'),
+ d: pluralize('d'),
+ dd: pluralize('d'),
+ M: pluralize('M'),
+ MM: pluralize('M'),
+ y: pluralize('y'),
+ yy: pluralize('y'),
+ },
+ preparse: function (string) {
+ return string
+ .replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
+ return numberMap[match];
+ })
+ .replace(/،/g, ',');
+ },
+ postformat: function (string) {
+ return string
+ .replace(/\d/g, function (match) {
+ return symbolMap[match];
+ })
+ .replace(/,/g, '،');
+ },
+ week: {
+ dow: 6, // Saturday is the first day of the week.
+ doy: 12, // The week that contains Jan 12th is the first week of the year.
+ },
+ });
+
+ return ar;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/az.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/az.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Azerbaijani [az]
+//! author : topchiyev : https://github.com/topchiyev
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var suffixes = {
+ 1: '-inci',
+ 5: '-inci',
+ 8: '-inci',
+ 70: '-inci',
+ 80: '-inci',
+ 2: '-nci',
+ 7: '-nci',
+ 20: '-nci',
+ 50: '-nci',
+ 3: '-üncü',
+ 4: '-üncü',
+ 100: '-üncü',
+ 6: '-ncı',
+ 9: '-uncu',
+ 10: '-uncu',
+ 30: '-uncu',
+ 60: '-ıncı',
+ 90: '-ıncı',
+ };
+
+ var az = moment.defineLocale('az', {
+ months: 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split(
+ '_'
+ ),
+ monthsShort: 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
+ weekdays: 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split(
+ '_'
+ ),
+ weekdaysShort: 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
+ weekdaysMin: 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[bugün saat] LT',
+ nextDay: '[sabah saat] LT',
+ nextWeek: '[gələn həftə] dddd [saat] LT',
+ lastDay: '[dünən] LT',
+ lastWeek: '[keçən həftə] dddd [saat] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s sonra',
+ past: '%s əvvəl',
+ s: 'bir neçə saniyə',
+ ss: '%d saniyə',
+ m: 'bir dəqiqə',
+ mm: '%d dəqiqə',
+ h: 'bir saat',
+ hh: '%d saat',
+ d: 'bir gün',
+ dd: '%d gün',
+ M: 'bir ay',
+ MM: '%d ay',
+ y: 'bir il',
+ yy: '%d il',
+ },
+ meridiemParse: /gecə|səhər|gündüz|axşam/,
+ isPM: function (input) {
+ return /^(gündüz|axşam)$/.test(input);
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'gecə';
+ } else if (hour < 12) {
+ return 'səhər';
+ } else if (hour < 17) {
+ return 'gündüz';
+ } else {
+ return 'axşam';
+ }
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,
+ ordinal: function (number) {
+ if (number === 0) {
+ // special case for zero
+ return number + '-ıncı';
+ }
+ var a = number % 10,
+ b = (number % 100) - a,
+ c = number >= 100 ? 100 : null;
+ return number + (suffixes[a] || suffixes[b] || suffixes[c]);
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return az;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/be.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/be.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Belarusian [be]
+//! author : Dmitry Demidov : https://github.com/demidov91
+//! author: Praleska: http://praleska.pro/
+//! Author : Menelion Elensúle : https://github.com/Oire
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function plural(word, num) {
+ var forms = word.split('_');
+ return num % 10 === 1 && num % 100 !== 11
+ ? forms[0]
+ : num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20)
+ ? forms[1]
+ : forms[2];
+ }
+ function relativeTimeWithPlural(number, withoutSuffix, key) {
+ var format = {
+ ss: withoutSuffix ? 'секунда_секунды_секунд' : 'секунду_секунды_секунд',
+ mm: withoutSuffix ? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
+ hh: withoutSuffix ? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
+ dd: 'дзень_дні_дзён',
+ MM: 'месяц_месяцы_месяцаў',
+ yy: 'год_гады_гадоў',
+ };
+ if (key === 'm') {
+ return withoutSuffix ? 'хвіліна' : 'хвіліну';
+ } else if (key === 'h') {
+ return withoutSuffix ? 'гадзіна' : 'гадзіну';
+ } else {
+ return number + ' ' + plural(format[key], +number);
+ }
+ }
+
+ var be = moment.defineLocale('be', {
+ months: {
+ format: 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split(
+ '_'
+ ),
+ standalone: 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split(
+ '_'
+ ),
+ },
+ monthsShort: 'студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж'.split(
+ '_'
+ ),
+ weekdays: {
+ format: 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split(
+ '_'
+ ),
+ standalone: 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split(
+ '_'
+ ),
+ isFormat: /\[ ?[Ууў] ?(?:мінулую|наступную)? ?\] ?dddd/,
+ },
+ weekdaysShort: 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
+ weekdaysMin: 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY г.',
+ LLL: 'D MMMM YYYY г., HH:mm',
+ LLLL: 'dddd, D MMMM YYYY г., HH:mm',
+ },
+ calendar: {
+ sameDay: '[Сёння ў] LT',
+ nextDay: '[Заўтра ў] LT',
+ lastDay: '[Учора ў] LT',
+ nextWeek: function () {
+ return '[У] dddd [ў] LT';
+ },
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ case 3:
+ case 5:
+ case 6:
+ return '[У мінулую] dddd [ў] LT';
+ case 1:
+ case 2:
+ case 4:
+ return '[У мінулы] dddd [ў] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'праз %s',
+ past: '%s таму',
+ s: 'некалькі секунд',
+ m: relativeTimeWithPlural,
+ mm: relativeTimeWithPlural,
+ h: relativeTimeWithPlural,
+ hh: relativeTimeWithPlural,
+ d: 'дзень',
+ dd: relativeTimeWithPlural,
+ M: 'месяц',
+ MM: relativeTimeWithPlural,
+ y: 'год',
+ yy: relativeTimeWithPlural,
+ },
+ meridiemParse: /ночы|раніцы|дня|вечара/,
+ isPM: function (input) {
+ return /^(дня|вечара)$/.test(input);
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'ночы';
+ } else if (hour < 12) {
+ return 'раніцы';
+ } else if (hour < 17) {
+ return 'дня';
+ } else {
+ return 'вечара';
+ }
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-(і|ы|га)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'M':
+ case 'd':
+ case 'DDD':
+ case 'w':
+ case 'W':
+ return (number % 10 === 2 || number % 10 === 3) &&
+ number % 100 !== 12 &&
+ number % 100 !== 13
+ ? number + '-і'
+ : number + '-ы';
+ case 'D':
+ return number + '-га';
+ default:
+ return number;
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return be;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/bg.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/bg.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Bulgarian [bg]
+//! author : Krasen Borisov : https://github.com/kraz
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var bg = moment.defineLocale('bg', {
+ months: 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split(
+ '_'
+ ),
+ monthsShort: 'яну_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
+ weekdays: 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split(
+ '_'
+ ),
+ weekdaysShort: 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
+ weekdaysMin: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'D.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY H:mm',
+ LLLL: 'dddd, D MMMM YYYY H:mm',
+ },
+ calendar: {
+ sameDay: '[Днес в] LT',
+ nextDay: '[Утре в] LT',
+ nextWeek: 'dddd [в] LT',
+ lastDay: '[Вчера в] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ case 3:
+ case 6:
+ return '[Миналата] dddd [в] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[Миналия] dddd [в] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'след %s',
+ past: 'преди %s',
+ s: 'няколко секунди',
+ ss: '%d секунди',
+ m: 'минута',
+ mm: '%d минути',
+ h: 'час',
+ hh: '%d часа',
+ d: 'ден',
+ dd: '%d дена',
+ w: 'седмица',
+ ww: '%d седмици',
+ M: 'месец',
+ MM: '%d месеца',
+ y: 'година',
+ yy: '%d години',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
+ ordinal: function (number) {
+ var lastDigit = number % 10,
+ last2Digits = number % 100;
+ if (number === 0) {
+ return number + '-ев';
+ } else if (last2Digits === 0) {
+ return number + '-ен';
+ } else if (last2Digits > 10 && last2Digits < 20) {
+ return number + '-ти';
+ } else if (lastDigit === 1) {
+ return number + '-ви';
+ } else if (lastDigit === 2) {
+ return number + '-ри';
+ } else if (lastDigit === 7 || lastDigit === 8) {
+ return number + '-ми';
+ } else {
+ return number + '-ти';
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return bg;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/bm.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/bm.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Bambara [bm]
+//! author : Estelle Comment : https://github.com/estellecomment
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var bm = moment.defineLocale('bm', {
+ months: 'Zanwuyekalo_Fewuruyekalo_Marisikalo_Awirilikalo_Mɛkalo_Zuwɛnkalo_Zuluyekalo_Utikalo_Sɛtanburukalo_ɔkutɔburukalo_Nowanburukalo_Desanburukalo'.split(
+ '_'
+ ),
+ monthsShort: 'Zan_Few_Mar_Awi_Mɛ_Zuw_Zul_Uti_Sɛt_ɔku_Now_Des'.split('_'),
+ weekdays: 'Kari_Ntɛnɛn_Tarata_Araba_Alamisa_Juma_Sibiri'.split('_'),
+ weekdaysShort: 'Kar_Ntɛ_Tar_Ara_Ala_Jum_Sib'.split('_'),
+ weekdaysMin: 'Ka_Nt_Ta_Ar_Al_Ju_Si'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'MMMM [tile] D [san] YYYY',
+ LLL: 'MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm',
+ LLLL: 'dddd MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm',
+ },
+ calendar: {
+ sameDay: '[Bi lɛrɛ] LT',
+ nextDay: '[Sini lɛrɛ] LT',
+ nextWeek: 'dddd [don lɛrɛ] LT',
+ lastDay: '[Kunu lɛrɛ] LT',
+ lastWeek: 'dddd [tɛmɛnen lɛrɛ] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s kɔnɔ',
+ past: 'a bɛ %s bɔ',
+ s: 'sanga dama dama',
+ ss: 'sekondi %d',
+ m: 'miniti kelen',
+ mm: 'miniti %d',
+ h: 'lɛrɛ kelen',
+ hh: 'lɛrɛ %d',
+ d: 'tile kelen',
+ dd: 'tile %d',
+ M: 'kalo kelen',
+ MM: 'kalo %d',
+ y: 'san kelen',
+ yy: 'san %d',
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return bm;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/bn-bd.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/bn-bd.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Bengali (Bangladesh) [bn-bd]
+//! author : Asraf Hossain Patoary : https://github.com/ashwoolford
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '১',
+ 2: '২',
+ 3: '৩',
+ 4: '৪',
+ 5: '৫',
+ 6: '৬',
+ 7: '৭',
+ 8: '৮',
+ 9: '৯',
+ 0: '০',
+ },
+ numberMap = {
+ '১': '1',
+ '২': '2',
+ '৩': '3',
+ '৪': '4',
+ '৫': '5',
+ '৬': '6',
+ '৭': '7',
+ '৮': '8',
+ '৯': '9',
+ '০': '0',
+ };
+
+ var bnBd = moment.defineLocale('bn-bd', {
+ months: 'জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split(
+ '_'
+ ),
+ monthsShort: 'জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে'.split(
+ '_'
+ ),
+ weekdays: 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার'.split(
+ '_'
+ ),
+ weekdaysShort: 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি'.split('_'),
+ weekdaysMin: 'রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm সময়',
+ LTS: 'A h:mm:ss সময়',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm সময়',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm সময়',
+ },
+ calendar: {
+ sameDay: '[আজ] LT',
+ nextDay: '[আগামীকাল] LT',
+ nextWeek: 'dddd, LT',
+ lastDay: '[গতকাল] LT',
+ lastWeek: '[গত] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s পরে',
+ past: '%s আগে',
+ s: 'কয়েক সেকেন্ড',
+ ss: '%d সেকেন্ড',
+ m: 'এক মিনিট',
+ mm: '%d মিনিট',
+ h: 'এক ঘন্টা',
+ hh: '%d ঘন্টা',
+ d: 'এক দিন',
+ dd: '%d দিন',
+ M: 'এক মাস',
+ MM: '%d মাস',
+ y: 'এক বছর',
+ yy: '%d বছর',
+ },
+ preparse: function (string) {
+ return string.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+
+ meridiemParse: /রাত|ভোর|সকাল|দুপুর|বিকাল|সন্ধ্যা|রাত/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'রাত') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'ভোর') {
+ return hour;
+ } else if (meridiem === 'সকাল') {
+ return hour;
+ } else if (meridiem === 'দুপুর') {
+ return hour >= 3 ? hour : hour + 12;
+ } else if (meridiem === 'বিকাল') {
+ return hour + 12;
+ } else if (meridiem === 'সন্ধ্যা') {
+ return hour + 12;
+ }
+ },
+
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'রাত';
+ } else if (hour < 6) {
+ return 'ভোর';
+ } else if (hour < 12) {
+ return 'সকাল';
+ } else if (hour < 15) {
+ return 'দুপুর';
+ } else if (hour < 18) {
+ return 'বিকাল';
+ } else if (hour < 20) {
+ return 'সন্ধ্যা';
+ } else {
+ return 'রাত';
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return bnBd;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/bn.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/bn.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Bengali [bn]
+//! author : Kaushik Gandhi : https://github.com/kaushikgandhi
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '১',
+ 2: '২',
+ 3: '৩',
+ 4: '৪',
+ 5: '৫',
+ 6: '৬',
+ 7: '৭',
+ 8: '৮',
+ 9: '৯',
+ 0: '০',
+ },
+ numberMap = {
+ '১': '1',
+ '২': '2',
+ '৩': '3',
+ '৪': '4',
+ '৫': '5',
+ '৬': '6',
+ '৭': '7',
+ '৮': '8',
+ '৯': '9',
+ '০': '0',
+ };
+
+ var bn = moment.defineLocale('bn', {
+ months: 'জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split(
+ '_'
+ ),
+ monthsShort: 'জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে'.split(
+ '_'
+ ),
+ weekdays: 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার'.split(
+ '_'
+ ),
+ weekdaysShort: 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি'.split('_'),
+ weekdaysMin: 'রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm সময়',
+ LTS: 'A h:mm:ss সময়',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm সময়',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm সময়',
+ },
+ calendar: {
+ sameDay: '[আজ] LT',
+ nextDay: '[আগামীকাল] LT',
+ nextWeek: 'dddd, LT',
+ lastDay: '[গতকাল] LT',
+ lastWeek: '[গত] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s পরে',
+ past: '%s আগে',
+ s: 'কয়েক সেকেন্ড',
+ ss: '%d সেকেন্ড',
+ m: 'এক মিনিট',
+ mm: '%d মিনিট',
+ h: 'এক ঘন্টা',
+ hh: '%d ঘন্টা',
+ d: 'এক দিন',
+ dd: '%d দিন',
+ M: 'এক মাস',
+ MM: '%d মাস',
+ y: 'এক বছর',
+ yy: '%d বছর',
+ },
+ preparse: function (string) {
+ return string.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ meridiemParse: /রাত|সকাল|দুপুর|বিকাল|রাত/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (
+ (meridiem === 'রাত' && hour >= 4) ||
+ (meridiem === 'দুপুর' && hour < 5) ||
+ meridiem === 'বিকাল'
+ ) {
+ return hour + 12;
+ } else {
+ return hour;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'রাত';
+ } else if (hour < 10) {
+ return 'সকাল';
+ } else if (hour < 17) {
+ return 'দুপুর';
+ } else if (hour < 20) {
+ return 'বিকাল';
+ } else {
+ return 'রাত';
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return bn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/bo.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/bo.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Tibetan [bo]
+//! author : Thupten N. Chakrishar : https://github.com/vajradog
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '༡',
+ 2: '༢',
+ 3: '༣',
+ 4: '༤',
+ 5: '༥',
+ 6: '༦',
+ 7: '༧',
+ 8: '༨',
+ 9: '༩',
+ 0: '༠',
+ },
+ numberMap = {
+ '༡': '1',
+ '༢': '2',
+ '༣': '3',
+ '༤': '4',
+ '༥': '5',
+ '༦': '6',
+ '༧': '7',
+ '༨': '8',
+ '༩': '9',
+ '༠': '0',
+ };
+
+ var bo = moment.defineLocale('bo', {
+ months: 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split(
+ '_'
+ ),
+ monthsShort: 'ཟླ་1_ཟླ་2_ཟླ་3_ཟླ་4_ཟླ་5_ཟླ་6_ཟླ་7_ཟླ་8_ཟླ་9_ཟླ་10_ཟླ་11_ཟླ་12'.split(
+ '_'
+ ),
+ monthsShortRegex: /^(ཟླ་\d{1,2})/,
+ monthsParseExact: true,
+ weekdays: 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split(
+ '_'
+ ),
+ weekdaysShort: 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split(
+ '_'
+ ),
+ weekdaysMin: 'ཉི_ཟླ_མིག_ལྷག_ཕུར_སངས_སྤེན'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm',
+ LTS: 'A h:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm',
+ },
+ calendar: {
+ sameDay: '[དི་རིང] LT',
+ nextDay: '[སང་ཉིན] LT',
+ nextWeek: '[བདུན་ཕྲག་རྗེས་མ], LT',
+ lastDay: '[ཁ་སང] LT',
+ lastWeek: '[བདུན་ཕྲག་མཐའ་མ] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s ལ་',
+ past: '%s སྔན་ལ',
+ s: 'ལམ་སང',
+ ss: '%d སྐར་ཆ།',
+ m: 'སྐར་མ་གཅིག',
+ mm: '%d སྐར་མ',
+ h: 'ཆུ་ཚོད་གཅིག',
+ hh: '%d ཆུ་ཚོད',
+ d: 'ཉིན་གཅིག',
+ dd: '%d ཉིན་',
+ M: 'ཟླ་བ་གཅིག',
+ MM: '%d ཟླ་བ',
+ y: 'ལོ་གཅིག',
+ yy: '%d ལོ',
+ },
+ preparse: function (string) {
+ return string.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ meridiemParse: /མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (
+ (meridiem === 'མཚན་མོ' && hour >= 4) ||
+ (meridiem === 'ཉིན་གུང' && hour < 5) ||
+ meridiem === 'དགོང་དག'
+ ) {
+ return hour + 12;
+ } else {
+ return hour;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'མཚན་མོ';
+ } else if (hour < 10) {
+ return 'ཞོགས་ཀས';
+ } else if (hour < 17) {
+ return 'ཉིན་གུང';
+ } else if (hour < 20) {
+ return 'དགོང་དག';
+ } else {
+ return 'མཚན་མོ';
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return bo;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/br.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/br.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Breton [br]
+//! author : Jean-Baptiste Le Duigou : https://github.com/jbleduigou
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function relativeTimeWithMutation(number, withoutSuffix, key) {
+ var format = {
+ mm: 'munutenn',
+ MM: 'miz',
+ dd: 'devezh',
+ };
+ return number + ' ' + mutation(format[key], number);
+ }
+ function specialMutationForYears(number) {
+ switch (lastNumber(number)) {
+ case 1:
+ case 3:
+ case 4:
+ case 5:
+ case 9:
+ return number + ' bloaz';
+ default:
+ return number + ' vloaz';
+ }
+ }
+ function lastNumber(number) {
+ if (number > 9) {
+ return lastNumber(number % 10);
+ }
+ return number;
+ }
+ function mutation(text, number) {
+ if (number === 2) {
+ return softMutation(text);
+ }
+ return text;
+ }
+ function softMutation(text) {
+ var mutationTable = {
+ m: 'v',
+ b: 'v',
+ d: 'z',
+ };
+ if (mutationTable[text.charAt(0)] === undefined) {
+ return text;
+ }
+ return mutationTable[text.charAt(0)] + text.substring(1);
+ }
+
+ var monthsParse = [
+ /^gen/i,
+ /^c[ʼ\']hwe/i,
+ /^meu/i,
+ /^ebr/i,
+ /^mae/i,
+ /^(mez|eve)/i,
+ /^gou/i,
+ /^eos/i,
+ /^gwe/i,
+ /^her/i,
+ /^du/i,
+ /^ker/i,
+ ],
+ monthsRegex = /^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu|gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,
+ monthsStrictRegex = /^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu)/i,
+ monthsShortStrictRegex = /^(gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,
+ fullWeekdaysParse = [
+ /^sul/i,
+ /^lun/i,
+ /^meurzh/i,
+ /^merc[ʼ\']her/i,
+ /^yaou/i,
+ /^gwener/i,
+ /^sadorn/i,
+ ],
+ shortWeekdaysParse = [
+ /^Sul/i,
+ /^Lun/i,
+ /^Meu/i,
+ /^Mer/i,
+ /^Yao/i,
+ /^Gwe/i,
+ /^Sad/i,
+ ],
+ minWeekdaysParse = [
+ /^Su/i,
+ /^Lu/i,
+ /^Me([^r]|$)/i,
+ /^Mer/i,
+ /^Ya/i,
+ /^Gw/i,
+ /^Sa/i,
+ ];
+
+ var br = moment.defineLocale('br', {
+ months: 'Genver_Cʼhwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split(
+ '_'
+ ),
+ monthsShort: 'Gen_Cʼhwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
+ weekdays: 'Sul_Lun_Meurzh_Mercʼher_Yaou_Gwener_Sadorn'.split('_'),
+ weekdaysShort: 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
+ weekdaysMin: 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
+ weekdaysParse: minWeekdaysParse,
+ fullWeekdaysParse: fullWeekdaysParse,
+ shortWeekdaysParse: shortWeekdaysParse,
+ minWeekdaysParse: minWeekdaysParse,
+
+ monthsRegex: monthsRegex,
+ monthsShortRegex: monthsRegex,
+ monthsStrictRegex: monthsStrictRegex,
+ monthsShortStrictRegex: monthsShortStrictRegex,
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D [a viz] MMMM YYYY',
+ LLL: 'D [a viz] MMMM YYYY HH:mm',
+ LLLL: 'dddd, D [a viz] MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Hiziv da] LT',
+ nextDay: '[Warcʼhoazh da] LT',
+ nextWeek: 'dddd [da] LT',
+ lastDay: '[Decʼh da] LT',
+ lastWeek: 'dddd [paset da] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'a-benn %s',
+ past: '%s ʼzo',
+ s: 'un nebeud segondennoù',
+ ss: '%d eilenn',
+ m: 'ur vunutenn',
+ mm: relativeTimeWithMutation,
+ h: 'un eur',
+ hh: '%d eur',
+ d: 'un devezh',
+ dd: relativeTimeWithMutation,
+ M: 'ur miz',
+ MM: relativeTimeWithMutation,
+ y: 'ur bloaz',
+ yy: specialMutationForYears,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(añ|vet)/,
+ ordinal: function (number) {
+ var output = number === 1 ? 'añ' : 'vet';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ meridiemParse: /a.m.|g.m./, // goude merenn | a-raok merenn
+ isPM: function (token) {
+ return token === 'g.m.';
+ },
+ meridiem: function (hour, minute, isLower) {
+ return hour < 12 ? 'a.m.' : 'g.m.';
+ },
+ });
+
+ return br;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/bs.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/bs.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Bosnian [bs]
+//! author : Nedim Cholich : https://github.com/frontyard
+//! based on (hr) translation by Bojan Marković
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function translate(number, withoutSuffix, key) {
+ var result = number + ' ';
+ switch (key) {
+ case 'ss':
+ if (number === 1) {
+ result += 'sekunda';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'sekunde';
+ } else {
+ result += 'sekundi';
+ }
+ return result;
+ case 'm':
+ return withoutSuffix ? 'jedna minuta' : 'jedne minute';
+ case 'mm':
+ if (number === 1) {
+ result += 'minuta';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'minute';
+ } else {
+ result += 'minuta';
+ }
+ return result;
+ case 'h':
+ return withoutSuffix ? 'jedan sat' : 'jednog sata';
+ case 'hh':
+ if (number === 1) {
+ result += 'sat';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'sata';
+ } else {
+ result += 'sati';
+ }
+ return result;
+ case 'dd':
+ if (number === 1) {
+ result += 'dan';
+ } else {
+ result += 'dana';
+ }
+ return result;
+ case 'MM':
+ if (number === 1) {
+ result += 'mjesec';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'mjeseca';
+ } else {
+ result += 'mjeseci';
+ }
+ return result;
+ case 'yy':
+ if (number === 1) {
+ result += 'godina';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'godine';
+ } else {
+ result += 'godina';
+ }
+ return result;
+ }
+ }
+
+ var bs = moment.defineLocale('bs', {
+ months: 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split(
+ '_'
+ ),
+ monthsShort: 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split(
+ '_'
+ ),
+ weekdaysShort: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
+ weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY H:mm',
+ LLLL: 'dddd, D. MMMM YYYY H:mm',
+ },
+ calendar: {
+ sameDay: '[danas u] LT',
+ nextDay: '[sutra u] LT',
+ nextWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[u] [nedjelju] [u] LT';
+ case 3:
+ return '[u] [srijedu] [u] LT';
+ case 6:
+ return '[u] [subotu] [u] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[u] dddd [u] LT';
+ }
+ },
+ lastDay: '[jučer u] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ case 3:
+ return '[prošlu] dddd [u] LT';
+ case 6:
+ return '[prošle] [subote] [u] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[prošli] dddd [u] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'za %s',
+ past: 'prije %s',
+ s: 'par sekundi',
+ ss: translate,
+ m: translate,
+ mm: translate,
+ h: translate,
+ hh: translate,
+ d: 'dan',
+ dd: translate,
+ M: 'mjesec',
+ MM: translate,
+ y: 'godinu',
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return bs;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ca.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ca.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Catalan [ca]
+//! author : Juan G. Hurtado : https://github.com/juanghurtado
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ca = moment.defineLocale('ca', {
+ months: {
+ standalone: 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split(
+ '_'
+ ),
+ format: "de gener_de febrer_de març_d'abril_de maig_de juny_de juliol_d'agost_de setembre_d'octubre_de novembre_de desembre".split(
+ '_'
+ ),
+ isFormat: /D[oD]?(\s)+MMMM/,
+ },
+ monthsShort: 'gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split(
+ '_'
+ ),
+ weekdaysShort: 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
+ weekdaysMin: 'dg_dl_dt_dc_dj_dv_ds'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM [de] YYYY',
+ ll: 'D MMM YYYY',
+ LLL: 'D MMMM [de] YYYY [a les] H:mm',
+ lll: 'D MMM YYYY, H:mm',
+ LLLL: 'dddd D MMMM [de] YYYY [a les] H:mm',
+ llll: 'ddd D MMM YYYY, H:mm',
+ },
+ calendar: {
+ sameDay: function () {
+ return '[avui a ' + (this.hours() !== 1 ? 'les' : 'la') + '] LT';
+ },
+ nextDay: function () {
+ return '[demà a ' + (this.hours() !== 1 ? 'les' : 'la') + '] LT';
+ },
+ nextWeek: function () {
+ return 'dddd [a ' + (this.hours() !== 1 ? 'les' : 'la') + '] LT';
+ },
+ lastDay: function () {
+ return '[ahir a ' + (this.hours() !== 1 ? 'les' : 'la') + '] LT';
+ },
+ lastWeek: function () {
+ return (
+ '[el] dddd [passat a ' +
+ (this.hours() !== 1 ? 'les' : 'la') +
+ '] LT'
+ );
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: "d'aquí %s",
+ past: 'fa %s',
+ s: 'uns segons',
+ ss: '%d segons',
+ m: 'un minut',
+ mm: '%d minuts',
+ h: 'una hora',
+ hh: '%d hores',
+ d: 'un dia',
+ dd: '%d dies',
+ M: 'un mes',
+ MM: '%d mesos',
+ y: 'un any',
+ yy: '%d anys',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(r|n|t|è|a)/,
+ ordinal: function (number, period) {
+ var output =
+ number === 1
+ ? 'r'
+ : number === 2
+ ? 'n'
+ : number === 3
+ ? 'r'
+ : number === 4
+ ? 't'
+ : 'è';
+ if (period === 'w' || period === 'W') {
+ output = 'a';
+ }
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return ca;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/cs.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/cs.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Czech [cs]
+//! author : petrbela : https://github.com/petrbela
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var months = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split(
+ '_'
+ ),
+ monthsShort = 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_'),
+ monthsParse = [
+ /^led/i,
+ /^úno/i,
+ /^bře/i,
+ /^dub/i,
+ /^kvě/i,
+ /^(čvn|červen$|června)/i,
+ /^(čvc|červenec|července)/i,
+ /^srp/i,
+ /^zář/i,
+ /^říj/i,
+ /^lis/i,
+ /^pro/i,
+ ],
+ // NOTE: 'červen' is substring of 'červenec'; therefore 'červenec' must precede 'červen' in the regex to be fully matched.
+ // Otherwise parser matches '1. červenec' as '1. červen' + 'ec'.
+ monthsRegex = /^(leden|únor|březen|duben|květen|červenec|července|červen|června|srpen|září|říjen|listopad|prosinec|led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i;
+
+ function plural(n) {
+ return n > 1 && n < 5 && ~~(n / 10) !== 1;
+ }
+ function translate(number, withoutSuffix, key, isFuture) {
+ var result = number + ' ';
+ switch (key) {
+ case 's': // a few seconds / in a few seconds / a few seconds ago
+ return withoutSuffix || isFuture ? 'pár sekund' : 'pár sekundami';
+ case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'sekundy' : 'sekund');
+ } else {
+ return result + 'sekundami';
+ }
+ case 'm': // a minute / in a minute / a minute ago
+ return withoutSuffix ? 'minuta' : isFuture ? 'minutu' : 'minutou';
+ case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'minuty' : 'minut');
+ } else {
+ return result + 'minutami';
+ }
+ case 'h': // an hour / in an hour / an hour ago
+ return withoutSuffix ? 'hodina' : isFuture ? 'hodinu' : 'hodinou';
+ case 'hh': // 9 hours / in 9 hours / 9 hours ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'hodiny' : 'hodin');
+ } else {
+ return result + 'hodinami';
+ }
+ case 'd': // a day / in a day / a day ago
+ return withoutSuffix || isFuture ? 'den' : 'dnem';
+ case 'dd': // 9 days / in 9 days / 9 days ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'dny' : 'dní');
+ } else {
+ return result + 'dny';
+ }
+ case 'M': // a month / in a month / a month ago
+ return withoutSuffix || isFuture ? 'měsíc' : 'měsícem';
+ case 'MM': // 9 months / in 9 months / 9 months ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'měsíce' : 'měsíců');
+ } else {
+ return result + 'měsíci';
+ }
+ case 'y': // a year / in a year / a year ago
+ return withoutSuffix || isFuture ? 'rok' : 'rokem';
+ case 'yy': // 9 years / in 9 years / 9 years ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'roky' : 'let');
+ } else {
+ return result + 'lety';
+ }
+ }
+ }
+
+ var cs = moment.defineLocale('cs', {
+ months: months,
+ monthsShort: monthsShort,
+ monthsRegex: monthsRegex,
+ monthsShortRegex: monthsRegex,
+ // NOTE: 'červen' is substring of 'červenec'; therefore 'červenec' must precede 'červen' in the regex to be fully matched.
+ // Otherwise parser matches '1. červenec' as '1. červen' + 'ec'.
+ monthsStrictRegex: /^(leden|ledna|února|únor|březen|března|duben|dubna|květen|května|červenec|července|červen|června|srpen|srpna|září|říjen|října|listopadu|listopad|prosinec|prosince)/i,
+ monthsShortStrictRegex: /^(led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i,
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+ weekdays: 'neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota'.split('_'),
+ weekdaysShort: 'ne_po_út_st_čt_pá_so'.split('_'),
+ weekdaysMin: 'ne_po_út_st_čt_pá_so'.split('_'),
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY H:mm',
+ LLLL: 'dddd D. MMMM YYYY H:mm',
+ l: 'D. M. YYYY',
+ },
+ calendar: {
+ sameDay: '[dnes v] LT',
+ nextDay: '[zítra v] LT',
+ nextWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[v neděli v] LT';
+ case 1:
+ case 2:
+ return '[v] dddd [v] LT';
+ case 3:
+ return '[ve středu v] LT';
+ case 4:
+ return '[ve čtvrtek v] LT';
+ case 5:
+ return '[v pátek v] LT';
+ case 6:
+ return '[v sobotu v] LT';
+ }
+ },
+ lastDay: '[včera v] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[minulou neděli v] LT';
+ case 1:
+ case 2:
+ return '[minulé] dddd [v] LT';
+ case 3:
+ return '[minulou středu v] LT';
+ case 4:
+ case 5:
+ return '[minulý] dddd [v] LT';
+ case 6:
+ return '[minulou sobotu v] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'za %s',
+ past: 'před %s',
+ s: translate,
+ ss: translate,
+ m: translate,
+ mm: translate,
+ h: translate,
+ hh: translate,
+ d: translate,
+ dd: translate,
+ M: translate,
+ MM: translate,
+ y: translate,
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return cs;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/cv.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/cv.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Chuvash [cv]
+//! author : Anatoly Mironov : https://github.com/mirontoli
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var cv = moment.defineLocale('cv', {
+ months: 'кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав'.split(
+ '_'
+ ),
+ monthsShort: 'кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш'.split('_'),
+ weekdays: 'вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун'.split(
+ '_'
+ ),
+ weekdaysShort: 'выр_тун_ытл_юн_кӗҫ_эрн_шӑм'.split('_'),
+ weekdaysMin: 'вр_тн_ыт_юн_кҫ_эр_шм'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD-MM-YYYY',
+ LL: 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]',
+ LLL: 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
+ LLLL: 'dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
+ },
+ calendar: {
+ sameDay: '[Паян] LT [сехетре]',
+ nextDay: '[Ыран] LT [сехетре]',
+ lastDay: '[Ӗнер] LT [сехетре]',
+ nextWeek: '[Ҫитес] dddd LT [сехетре]',
+ lastWeek: '[Иртнӗ] dddd LT [сехетре]',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: function (output) {
+ var affix = /сехет$/i.exec(output)
+ ? 'рен'
+ : /ҫул$/i.exec(output)
+ ? 'тан'
+ : 'ран';
+ return output + affix;
+ },
+ past: '%s каялла',
+ s: 'пӗр-ик ҫеккунт',
+ ss: '%d ҫеккунт',
+ m: 'пӗр минут',
+ mm: '%d минут',
+ h: 'пӗр сехет',
+ hh: '%d сехет',
+ d: 'пӗр кун',
+ dd: '%d кун',
+ M: 'пӗр уйӑх',
+ MM: '%d уйӑх',
+ y: 'пӗр ҫул',
+ yy: '%d ҫул',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-мӗш/,
+ ordinal: '%d-мӗш',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return cv;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/cy.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/cy.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Welsh [cy]
+//! author : Robert Allen : https://github.com/robgallen
+//! author : https://github.com/ryangreaves
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var cy = moment.defineLocale('cy', {
+ months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split(
+ '_'
+ ),
+ monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split(
+ '_'
+ ),
+ weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
+ weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
+ weekdaysParseExact: true,
+ // time formats are the same as en-gb
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Heddiw am] LT',
+ nextDay: '[Yfory am] LT',
+ nextWeek: 'dddd [am] LT',
+ lastDay: '[Ddoe am] LT',
+ lastWeek: 'dddd [diwethaf am] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'mewn %s',
+ past: '%s yn ôl',
+ s: 'ychydig eiliadau',
+ ss: '%d eiliad',
+ m: 'munud',
+ mm: '%d munud',
+ h: 'awr',
+ hh: '%d awr',
+ d: 'diwrnod',
+ dd: '%d diwrnod',
+ M: 'mis',
+ MM: '%d mis',
+ y: 'blwyddyn',
+ yy: '%d flynedd',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
+ // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
+ ordinal: function (number) {
+ var b = number,
+ output = '',
+ lookup = [
+ '',
+ 'af',
+ 'il',
+ 'ydd',
+ 'ydd',
+ 'ed',
+ 'ed',
+ 'ed',
+ 'fed',
+ 'fed',
+ 'fed', // 1af to 10fed
+ 'eg',
+ 'fed',
+ 'eg',
+ 'eg',
+ 'fed',
+ 'eg',
+ 'eg',
+ 'fed',
+ 'eg',
+ 'fed', // 11eg to 20fed
+ ];
+ if (b > 20) {
+ if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) {
+ output = 'fed'; // not 30ain, 70ain or 90ain
+ } else {
+ output = 'ain';
+ }
+ } else if (b > 0) {
+ output = lookup[b];
+ }
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return cy;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/da.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/da.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Danish [da]
+//! author : Ulrik Nielsen : https://github.com/mrbase
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var da = moment.defineLocale('da', {
+ months: 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split(
+ '_'
+ ),
+ monthsShort: 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
+ weekdays: 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
+ weekdaysShort: 'søn_man_tir_ons_tor_fre_lør'.split('_'),
+ weekdaysMin: 'sø_ma_ti_on_to_fr_lø'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY HH:mm',
+ LLLL: 'dddd [d.] D. MMMM YYYY [kl.] HH:mm',
+ },
+ calendar: {
+ sameDay: '[i dag kl.] LT',
+ nextDay: '[i morgen kl.] LT',
+ nextWeek: 'på dddd [kl.] LT',
+ lastDay: '[i går kl.] LT',
+ lastWeek: '[i] dddd[s kl.] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'om %s',
+ past: '%s siden',
+ s: 'få sekunder',
+ ss: '%d sekunder',
+ m: 'et minut',
+ mm: '%d minutter',
+ h: 'en time',
+ hh: '%d timer',
+ d: 'en dag',
+ dd: '%d dage',
+ M: 'en måned',
+ MM: '%d måneder',
+ y: 'et år',
+ yy: '%d år',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return da;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/de-at.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/de-at.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : German (Austria) [de-at]
+//! author : lluchs : https://github.com/lluchs
+//! author: Menelion Elensúle: https://github.com/Oire
+//! author : Martin Groller : https://github.com/MadMG
+//! author : Mikolaj Dadela : https://github.com/mik01aj
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function processRelativeTime(number, withoutSuffix, key, isFuture) {
+ var format = {
+ m: ['eine Minute', 'einer Minute'],
+ h: ['eine Stunde', 'einer Stunde'],
+ d: ['ein Tag', 'einem Tag'],
+ dd: [number + ' Tage', number + ' Tagen'],
+ w: ['eine Woche', 'einer Woche'],
+ M: ['ein Monat', 'einem Monat'],
+ MM: [number + ' Monate', number + ' Monaten'],
+ y: ['ein Jahr', 'einem Jahr'],
+ yy: [number + ' Jahre', number + ' Jahren'],
+ };
+ return withoutSuffix ? format[key][0] : format[key][1];
+ }
+
+ var deAt = moment.defineLocale('de-at', {
+ months: 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split(
+ '_'
+ ),
+ monthsShort: 'Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split(
+ '_'
+ ),
+ weekdaysShort: 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
+ weekdaysMin: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY HH:mm',
+ LLLL: 'dddd, D. MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[heute um] LT [Uhr]',
+ sameElse: 'L',
+ nextDay: '[morgen um] LT [Uhr]',
+ nextWeek: 'dddd [um] LT [Uhr]',
+ lastDay: '[gestern um] LT [Uhr]',
+ lastWeek: '[letzten] dddd [um] LT [Uhr]',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: 'vor %s',
+ s: 'ein paar Sekunden',
+ ss: '%d Sekunden',
+ m: processRelativeTime,
+ mm: '%d Minuten',
+ h: processRelativeTime,
+ hh: '%d Stunden',
+ d: processRelativeTime,
+ dd: processRelativeTime,
+ w: processRelativeTime,
+ ww: '%d Wochen',
+ M: processRelativeTime,
+ MM: processRelativeTime,
+ y: processRelativeTime,
+ yy: processRelativeTime,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return deAt;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/de-ch.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/de-ch.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : German (Switzerland) [de-ch]
+//! author : sschueller : https://github.com/sschueller
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function processRelativeTime(number, withoutSuffix, key, isFuture) {
+ var format = {
+ m: ['eine Minute', 'einer Minute'],
+ h: ['eine Stunde', 'einer Stunde'],
+ d: ['ein Tag', 'einem Tag'],
+ dd: [number + ' Tage', number + ' Tagen'],
+ w: ['eine Woche', 'einer Woche'],
+ M: ['ein Monat', 'einem Monat'],
+ MM: [number + ' Monate', number + ' Monaten'],
+ y: ['ein Jahr', 'einem Jahr'],
+ yy: [number + ' Jahre', number + ' Jahren'],
+ };
+ return withoutSuffix ? format[key][0] : format[key][1];
+ }
+
+ var deCh = moment.defineLocale('de-ch', {
+ months: 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split(
+ '_'
+ ),
+ monthsShort: 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split(
+ '_'
+ ),
+ weekdaysShort: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
+ weekdaysMin: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY HH:mm',
+ LLLL: 'dddd, D. MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[heute um] LT [Uhr]',
+ sameElse: 'L',
+ nextDay: '[morgen um] LT [Uhr]',
+ nextWeek: 'dddd [um] LT [Uhr]',
+ lastDay: '[gestern um] LT [Uhr]',
+ lastWeek: '[letzten] dddd [um] LT [Uhr]',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: 'vor %s',
+ s: 'ein paar Sekunden',
+ ss: '%d Sekunden',
+ m: processRelativeTime,
+ mm: '%d Minuten',
+ h: processRelativeTime,
+ hh: '%d Stunden',
+ d: processRelativeTime,
+ dd: processRelativeTime,
+ w: processRelativeTime,
+ ww: '%d Wochen',
+ M: processRelativeTime,
+ MM: processRelativeTime,
+ y: processRelativeTime,
+ yy: processRelativeTime,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return deCh;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/de.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/de.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : German [de]
+//! author : lluchs : https://github.com/lluchs
+//! author: Menelion Elensúle: https://github.com/Oire
+//! author : Mikolaj Dadela : https://github.com/mik01aj
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function processRelativeTime(number, withoutSuffix, key, isFuture) {
+ var format = {
+ m: ['eine Minute', 'einer Minute'],
+ h: ['eine Stunde', 'einer Stunde'],
+ d: ['ein Tag', 'einem Tag'],
+ dd: [number + ' Tage', number + ' Tagen'],
+ w: ['eine Woche', 'einer Woche'],
+ M: ['ein Monat', 'einem Monat'],
+ MM: [number + ' Monate', number + ' Monaten'],
+ y: ['ein Jahr', 'einem Jahr'],
+ yy: [number + ' Jahre', number + ' Jahren'],
+ };
+ return withoutSuffix ? format[key][0] : format[key][1];
+ }
+
+ var de = moment.defineLocale('de', {
+ months: 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split(
+ '_'
+ ),
+ monthsShort: 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split(
+ '_'
+ ),
+ weekdaysShort: 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
+ weekdaysMin: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY HH:mm',
+ LLLL: 'dddd, D. MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[heute um] LT [Uhr]',
+ sameElse: 'L',
+ nextDay: '[morgen um] LT [Uhr]',
+ nextWeek: 'dddd [um] LT [Uhr]',
+ lastDay: '[gestern um] LT [Uhr]',
+ lastWeek: '[letzten] dddd [um] LT [Uhr]',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: 'vor %s',
+ s: 'ein paar Sekunden',
+ ss: '%d Sekunden',
+ m: processRelativeTime,
+ mm: '%d Minuten',
+ h: processRelativeTime,
+ hh: '%d Stunden',
+ d: processRelativeTime,
+ dd: processRelativeTime,
+ w: processRelativeTime,
+ ww: '%d Wochen',
+ M: processRelativeTime,
+ MM: processRelativeTime,
+ y: processRelativeTime,
+ yy: processRelativeTime,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return de;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/dv.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/dv.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Maldivian [dv]
+//! author : Jawish Hameed : https://github.com/jawish
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var months = [
+ 'ޖެނުއަރީ',
+ 'ފެބްރުއަރީ',
+ 'މާރިޗު',
+ 'އޭޕްރީލު',
+ 'މޭ',
+ 'ޖޫން',
+ 'ޖުލައި',
+ 'އޯގަސްޓު',
+ 'ސެޕްޓެމްބަރު',
+ 'އޮކްޓޯބަރު',
+ 'ނޮވެމްބަރު',
+ 'ޑިސެމްބަރު',
+ ],
+ weekdays = [
+ 'އާދިއްތަ',
+ 'ހޯމަ',
+ 'އަންގާރަ',
+ 'ބުދަ',
+ 'ބުރާސްފަތި',
+ 'ހުކުރު',
+ 'ހޮނިހިރު',
+ ];
+
+ var dv = moment.defineLocale('dv', {
+ months: months,
+ monthsShort: months,
+ weekdays: weekdays,
+ weekdaysShort: weekdays,
+ weekdaysMin: 'އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'D/M/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /މކ|މފ/,
+ isPM: function (input) {
+ return 'މފ' === input;
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'މކ';
+ } else {
+ return 'މފ';
+ }
+ },
+ calendar: {
+ sameDay: '[މިއަދު] LT',
+ nextDay: '[މާދަމާ] LT',
+ nextWeek: 'dddd LT',
+ lastDay: '[އިއްޔެ] LT',
+ lastWeek: '[ފާއިތުވި] dddd LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'ތެރޭގައި %s',
+ past: 'ކުރިން %s',
+ s: 'ސިކުންތުކޮޅެއް',
+ ss: 'd% ސިކުންތު',
+ m: 'މިނިޓެއް',
+ mm: 'މިނިޓު %d',
+ h: 'ގަޑިއިރެއް',
+ hh: 'ގަޑިއިރު %d',
+ d: 'ދުވަހެއް',
+ dd: 'ދުވަސް %d',
+ M: 'މަހެއް',
+ MM: 'މަސް %d',
+ y: 'އަހަރެއް',
+ yy: 'އަހަރު %d',
+ },
+ preparse: function (string) {
+ return string.replace(/،/g, ',');
+ },
+ postformat: function (string) {
+ return string.replace(/,/g, '،');
+ },
+ week: {
+ dow: 7, // Sunday is the first day of the week.
+ doy: 12, // The week that contains Jan 12th is the first week of the year.
+ },
+ });
+
+ return dv;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/el.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/el.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Greek [el]
+//! author : Aggelos Karalias : https://github.com/mehiel
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function isFunction(input) {
+ return (
+ (typeof Function !== 'undefined' && input instanceof Function) ||
+ Object.prototype.toString.call(input) === '[object Function]'
+ );
+ }
+
+ var el = moment.defineLocale('el', {
+ monthsNominativeEl: 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split(
+ '_'
+ ),
+ monthsGenitiveEl: 'Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου'.split(
+ '_'
+ ),
+ months: function (momentToFormat, format) {
+ if (!momentToFormat) {
+ return this._monthsNominativeEl;
+ } else if (
+ typeof format === 'string' &&
+ /D/.test(format.substring(0, format.indexOf('MMMM')))
+ ) {
+ // if there is a day number before 'MMMM'
+ return this._monthsGenitiveEl[momentToFormat.month()];
+ } else {
+ return this._monthsNominativeEl[momentToFormat.month()];
+ }
+ },
+ monthsShort: 'Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ'.split('_'),
+ weekdays: 'Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο'.split(
+ '_'
+ ),
+ weekdaysShort: 'Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ'.split('_'),
+ weekdaysMin: 'Κυ_Δε_Τρ_Τε_Πε_Πα_Σα'.split('_'),
+ meridiem: function (hours, minutes, isLower) {
+ if (hours > 11) {
+ return isLower ? 'μμ' : 'ΜΜ';
+ } else {
+ return isLower ? 'πμ' : 'ΠΜ';
+ }
+ },
+ isPM: function (input) {
+ return (input + '').toLowerCase()[0] === 'μ';
+ },
+ meridiemParse: /[ΠΜ]\.?Μ?\.?/i,
+ longDateFormat: {
+ LT: 'h:mm A',
+ LTS: 'h:mm:ss A',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY h:mm A',
+ LLLL: 'dddd, D MMMM YYYY h:mm A',
+ },
+ calendarEl: {
+ sameDay: '[Σήμερα {}] LT',
+ nextDay: '[Αύριο {}] LT',
+ nextWeek: 'dddd [{}] LT',
+ lastDay: '[Χθες {}] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 6:
+ return '[το προηγούμενο] dddd [{}] LT';
+ default:
+ return '[την προηγούμενη] dddd [{}] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ calendar: function (key, mom) {
+ var output = this._calendarEl[key],
+ hours = mom && mom.hours();
+ if (isFunction(output)) {
+ output = output.apply(mom);
+ }
+ return output.replace('{}', hours % 12 === 1 ? 'στη' : 'στις');
+ },
+ relativeTime: {
+ future: 'σε %s',
+ past: '%s πριν',
+ s: 'λίγα δευτερόλεπτα',
+ ss: '%d δευτερόλεπτα',
+ m: 'ένα λεπτό',
+ mm: '%d λεπτά',
+ h: 'μία ώρα',
+ hh: '%d ώρες',
+ d: 'μία μέρα',
+ dd: '%d μέρες',
+ M: 'ένας μήνας',
+ MM: '%d μήνες',
+ y: 'ένας χρόνος',
+ yy: '%d χρόνια',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}η/,
+ ordinal: '%dη',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4st is the first week of the year.
+ },
+ });
+
+ return el;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/en-au.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/en-au.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : English (Australia) [en-au]
+//! author : Jared Morse : https://github.com/jarcoal
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var enAu = moment.defineLocale('en-au', {
+ months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+ weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+ weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+ longDateFormat: {
+ LT: 'h:mm A',
+ LTS: 'h:mm:ss A',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY h:mm A',
+ LLLL: 'dddd, D MMMM YYYY h:mm A',
+ },
+ calendar: {
+ sameDay: '[Today at] LT',
+ nextDay: '[Tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ lastDay: '[Yesterday at] LT',
+ lastWeek: '[Last] dddd [at] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: '%s ago',
+ s: 'a few seconds',
+ ss: '%d seconds',
+ m: 'a minute',
+ mm: '%d minutes',
+ h: 'an hour',
+ hh: '%d hours',
+ d: 'a day',
+ dd: '%d days',
+ M: 'a month',
+ MM: '%d months',
+ y: 'a year',
+ yy: '%d years',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return enAu;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/en-ca.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/en-ca.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : English (Canada) [en-ca]
+//! author : Jonathan Abourbih : https://github.com/jonbca
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var enCa = moment.defineLocale('en-ca', {
+ months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+ weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+ weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+ longDateFormat: {
+ LT: 'h:mm A',
+ LTS: 'h:mm:ss A',
+ L: 'YYYY-MM-DD',
+ LL: 'MMMM D, YYYY',
+ LLL: 'MMMM D, YYYY h:mm A',
+ LLLL: 'dddd, MMMM D, YYYY h:mm A',
+ },
+ calendar: {
+ sameDay: '[Today at] LT',
+ nextDay: '[Tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ lastDay: '[Yesterday at] LT',
+ lastWeek: '[Last] dddd [at] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: '%s ago',
+ s: 'a few seconds',
+ ss: '%d seconds',
+ m: 'a minute',
+ mm: '%d minutes',
+ h: 'an hour',
+ hh: '%d hours',
+ d: 'a day',
+ dd: '%d days',
+ M: 'a month',
+ MM: '%d months',
+ y: 'a year',
+ yy: '%d years',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ });
+
+ return enCa;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/en-gb.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/en-gb.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : English (United Kingdom) [en-gb]
+//! author : Chris Gedrim : https://github.com/chrisgedrim
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var enGb = moment.defineLocale('en-gb', {
+ months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+ weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+ weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Today at] LT',
+ nextDay: '[Tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ lastDay: '[Yesterday at] LT',
+ lastWeek: '[Last] dddd [at] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: '%s ago',
+ s: 'a few seconds',
+ ss: '%d seconds',
+ m: 'a minute',
+ mm: '%d minutes',
+ h: 'an hour',
+ hh: '%d hours',
+ d: 'a day',
+ dd: '%d days',
+ M: 'a month',
+ MM: '%d months',
+ y: 'a year',
+ yy: '%d years',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return enGb;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/en-ie.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/en-ie.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : English (Ireland) [en-ie]
+//! author : Chris Cartlidge : https://github.com/chriscartlidge
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var enIe = moment.defineLocale('en-ie', {
+ months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+ weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+ weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Today at] LT',
+ nextDay: '[Tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ lastDay: '[Yesterday at] LT',
+ lastWeek: '[Last] dddd [at] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: '%s ago',
+ s: 'a few seconds',
+ ss: '%d seconds',
+ m: 'a minute',
+ mm: '%d minutes',
+ h: 'an hour',
+ hh: '%d hours',
+ d: 'a day',
+ dd: '%d days',
+ M: 'a month',
+ MM: '%d months',
+ y: 'a year',
+ yy: '%d years',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return enIe;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/en-il.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/en-il.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : English (Israel) [en-il]
+//! author : Chris Gedrim : https://github.com/chrisgedrim
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var enIl = moment.defineLocale('en-il', {
+ months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+ weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+ weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Today at] LT',
+ nextDay: '[Tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ lastDay: '[Yesterday at] LT',
+ lastWeek: '[Last] dddd [at] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: '%s ago',
+ s: 'a few seconds',
+ ss: '%d seconds',
+ m: 'a minute',
+ mm: '%d minutes',
+ h: 'an hour',
+ hh: '%d hours',
+ d: 'a day',
+ dd: '%d days',
+ M: 'a month',
+ MM: '%d months',
+ y: 'a year',
+ yy: '%d years',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ });
+
+ return enIl;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/en-in.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/en-in.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : English (India) [en-in]
+//! author : Jatin Agrawal : https://github.com/jatinag22
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var enIn = moment.defineLocale('en-in', {
+ months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+ weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+ weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+ longDateFormat: {
+ LT: 'h:mm A',
+ LTS: 'h:mm:ss A',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY h:mm A',
+ LLLL: 'dddd, D MMMM YYYY h:mm A',
+ },
+ calendar: {
+ sameDay: '[Today at] LT',
+ nextDay: '[Tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ lastDay: '[Yesterday at] LT',
+ lastWeek: '[Last] dddd [at] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: '%s ago',
+ s: 'a few seconds',
+ ss: '%d seconds',
+ m: 'a minute',
+ mm: '%d minutes',
+ h: 'an hour',
+ hh: '%d hours',
+ d: 'a day',
+ dd: '%d days',
+ M: 'a month',
+ MM: '%d months',
+ y: 'a year',
+ yy: '%d years',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 1st is the first week of the year.
+ },
+ });
+
+ return enIn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/en-nz.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/en-nz.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : English (New Zealand) [en-nz]
+//! author : Luke McGregor : https://github.com/lukemcgregor
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var enNz = moment.defineLocale('en-nz', {
+ months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+ weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+ weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+ longDateFormat: {
+ LT: 'h:mm A',
+ LTS: 'h:mm:ss A',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY h:mm A',
+ LLLL: 'dddd, D MMMM YYYY h:mm A',
+ },
+ calendar: {
+ sameDay: '[Today at] LT',
+ nextDay: '[Tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ lastDay: '[Yesterday at] LT',
+ lastWeek: '[Last] dddd [at] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: '%s ago',
+ s: 'a few seconds',
+ ss: '%d seconds',
+ m: 'a minute',
+ mm: '%d minutes',
+ h: 'an hour',
+ hh: '%d hours',
+ d: 'a day',
+ dd: '%d days',
+ M: 'a month',
+ MM: '%d months',
+ y: 'a year',
+ yy: '%d years',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return enNz;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/en-sg.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/en-sg.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : English (Singapore) [en-sg]
+//! author : Matthew Castrillon-Madrigal : https://github.com/techdimension
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var enSg = moment.defineLocale('en-sg', {
+ months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+ weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+ weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Today at] LT',
+ nextDay: '[Tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ lastDay: '[Yesterday at] LT',
+ lastWeek: '[Last] dddd [at] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'in %s',
+ past: '%s ago',
+ s: 'a few seconds',
+ ss: '%d seconds',
+ m: 'a minute',
+ mm: '%d minutes',
+ h: 'an hour',
+ hh: '%d hours',
+ d: 'a day',
+ dd: '%d days',
+ M: 'a month',
+ MM: '%d months',
+ y: 'a year',
+ yy: '%d years',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return enSg;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/eo.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/eo.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Esperanto [eo]
+//! author : Colin Dean : https://github.com/colindean
+//! author : Mia Nordentoft Imperatori : https://github.com/miestasmia
+//! comment : miestasmia corrected the translation by colindean
+//! comment : Vivakvo corrected the translation by colindean and miestasmia
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var eo = moment.defineLocale('eo', {
+ months: 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split(
+ '_'
+ ),
+ monthsShort: 'jan_feb_mart_apr_maj_jun_jul_aŭg_sept_okt_nov_dec'.split('_'),
+ weekdays: 'dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato'.split('_'),
+ weekdaysShort: 'dim_lun_mard_merk_ĵaŭ_ven_sab'.split('_'),
+ weekdaysMin: 'di_lu_ma_me_ĵa_ve_sa'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY-MM-DD',
+ LL: '[la] D[-an de] MMMM, YYYY',
+ LLL: '[la] D[-an de] MMMM, YYYY HH:mm',
+ LLLL: 'dddd[n], [la] D[-an de] MMMM, YYYY HH:mm',
+ llll: 'ddd, [la] D[-an de] MMM, YYYY HH:mm',
+ },
+ meridiemParse: /[ap]\.t\.m/i,
+ isPM: function (input) {
+ return input.charAt(0).toLowerCase() === 'p';
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours > 11) {
+ return isLower ? 'p.t.m.' : 'P.T.M.';
+ } else {
+ return isLower ? 'a.t.m.' : 'A.T.M.';
+ }
+ },
+ calendar: {
+ sameDay: '[Hodiaŭ je] LT',
+ nextDay: '[Morgaŭ je] LT',
+ nextWeek: 'dddd[n je] LT',
+ lastDay: '[Hieraŭ je] LT',
+ lastWeek: '[pasintan] dddd[n je] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'post %s',
+ past: 'antaŭ %s',
+ s: 'kelkaj sekundoj',
+ ss: '%d sekundoj',
+ m: 'unu minuto',
+ mm: '%d minutoj',
+ h: 'unu horo',
+ hh: '%d horoj',
+ d: 'unu tago', //ne 'diurno', ĉar estas uzita por proksimumo
+ dd: '%d tagoj',
+ M: 'unu monato',
+ MM: '%d monatoj',
+ y: 'unu jaro',
+ yy: '%d jaroj',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}a/,
+ ordinal: '%da',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return eo;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/es-do.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/es-do.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Spanish (Dominican Republic) [es-do]
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split(
+ '_'
+ ),
+ monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'),
+ monthsParse = [
+ /^ene/i,
+ /^feb/i,
+ /^mar/i,
+ /^abr/i,
+ /^may/i,
+ /^jun/i,
+ /^jul/i,
+ /^ago/i,
+ /^sep/i,
+ /^oct/i,
+ /^nov/i,
+ /^dic/i,
+ ],
+ monthsRegex = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
+
+ var esDo = moment.defineLocale('es-do', {
+ months: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split(
+ '_'
+ ),
+ monthsShort: function (m, format) {
+ if (!m) {
+ return monthsShortDot;
+ } else if (/-MMM-/.test(format)) {
+ return monthsShort[m.month()];
+ } else {
+ return monthsShortDot[m.month()];
+ }
+ },
+ monthsRegex: monthsRegex,
+ monthsShortRegex: monthsRegex,
+ monthsStrictRegex: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
+ monthsShortStrictRegex: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+ weekdays: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
+ weekdaysShort: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
+ weekdaysMin: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'h:mm A',
+ LTS: 'h:mm:ss A',
+ L: 'DD/MM/YYYY',
+ LL: 'D [de] MMMM [de] YYYY',
+ LLL: 'D [de] MMMM [de] YYYY h:mm A',
+ LLLL: 'dddd, D [de] MMMM [de] YYYY h:mm A',
+ },
+ calendar: {
+ sameDay: function () {
+ return '[hoy a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ nextDay: function () {
+ return '[mañana a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ nextWeek: function () {
+ return 'dddd [a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ lastDay: function () {
+ return '[ayer a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ lastWeek: function () {
+ return (
+ '[el] dddd [pasado a la' +
+ (this.hours() !== 1 ? 's' : '') +
+ '] LT'
+ );
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'en %s',
+ past: 'hace %s',
+ s: 'unos segundos',
+ ss: '%d segundos',
+ m: 'un minuto',
+ mm: '%d minutos',
+ h: 'una hora',
+ hh: '%d horas',
+ d: 'un día',
+ dd: '%d días',
+ w: 'una semana',
+ ww: '%d semanas',
+ M: 'un mes',
+ MM: '%d meses',
+ y: 'un año',
+ yy: '%d años',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return esDo;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/es-mx.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/es-mx.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Spanish (Mexico) [es-mx]
+//! author : JC Franco : https://github.com/jcfranco
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split(
+ '_'
+ ),
+ monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'),
+ monthsParse = [
+ /^ene/i,
+ /^feb/i,
+ /^mar/i,
+ /^abr/i,
+ /^may/i,
+ /^jun/i,
+ /^jul/i,
+ /^ago/i,
+ /^sep/i,
+ /^oct/i,
+ /^nov/i,
+ /^dic/i,
+ ],
+ monthsRegex = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
+
+ var esMx = moment.defineLocale('es-mx', {
+ months: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split(
+ '_'
+ ),
+ monthsShort: function (m, format) {
+ if (!m) {
+ return monthsShortDot;
+ } else if (/-MMM-/.test(format)) {
+ return monthsShort[m.month()];
+ } else {
+ return monthsShortDot[m.month()];
+ }
+ },
+ monthsRegex: monthsRegex,
+ monthsShortRegex: monthsRegex,
+ monthsStrictRegex: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
+ monthsShortStrictRegex: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+ weekdays: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
+ weekdaysShort: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
+ weekdaysMin: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D [de] MMMM [de] YYYY',
+ LLL: 'D [de] MMMM [de] YYYY H:mm',
+ LLLL: 'dddd, D [de] MMMM [de] YYYY H:mm',
+ },
+ calendar: {
+ sameDay: function () {
+ return '[hoy a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ nextDay: function () {
+ return '[mañana a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ nextWeek: function () {
+ return 'dddd [a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ lastDay: function () {
+ return '[ayer a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ lastWeek: function () {
+ return (
+ '[el] dddd [pasado a la' +
+ (this.hours() !== 1 ? 's' : '') +
+ '] LT'
+ );
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'en %s',
+ past: 'hace %s',
+ s: 'unos segundos',
+ ss: '%d segundos',
+ m: 'un minuto',
+ mm: '%d minutos',
+ h: 'una hora',
+ hh: '%d horas',
+ d: 'un día',
+ dd: '%d días',
+ w: 'una semana',
+ ww: '%d semanas',
+ M: 'un mes',
+ MM: '%d meses',
+ y: 'un año',
+ yy: '%d años',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ invalidDate: 'Fecha inválida',
+ });
+
+ return esMx;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/es-us.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/es-us.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Spanish (United States) [es-us]
+//! author : bustta : https://github.com/bustta
+//! author : chrisrodz : https://github.com/chrisrodz
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split(
+ '_'
+ ),
+ monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'),
+ monthsParse = [
+ /^ene/i,
+ /^feb/i,
+ /^mar/i,
+ /^abr/i,
+ /^may/i,
+ /^jun/i,
+ /^jul/i,
+ /^ago/i,
+ /^sep/i,
+ /^oct/i,
+ /^nov/i,
+ /^dic/i,
+ ],
+ monthsRegex = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
+
+ var esUs = moment.defineLocale('es-us', {
+ months: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split(
+ '_'
+ ),
+ monthsShort: function (m, format) {
+ if (!m) {
+ return monthsShortDot;
+ } else if (/-MMM-/.test(format)) {
+ return monthsShort[m.month()];
+ } else {
+ return monthsShortDot[m.month()];
+ }
+ },
+ monthsRegex: monthsRegex,
+ monthsShortRegex: monthsRegex,
+ monthsStrictRegex: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
+ monthsShortStrictRegex: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+ weekdays: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
+ weekdaysShort: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
+ weekdaysMin: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'h:mm A',
+ LTS: 'h:mm:ss A',
+ L: 'MM/DD/YYYY',
+ LL: 'D [de] MMMM [de] YYYY',
+ LLL: 'D [de] MMMM [de] YYYY h:mm A',
+ LLLL: 'dddd, D [de] MMMM [de] YYYY h:mm A',
+ },
+ calendar: {
+ sameDay: function () {
+ return '[hoy a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ nextDay: function () {
+ return '[mañana a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ nextWeek: function () {
+ return 'dddd [a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ lastDay: function () {
+ return '[ayer a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ lastWeek: function () {
+ return (
+ '[el] dddd [pasado a la' +
+ (this.hours() !== 1 ? 's' : '') +
+ '] LT'
+ );
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'en %s',
+ past: 'hace %s',
+ s: 'unos segundos',
+ ss: '%d segundos',
+ m: 'un minuto',
+ mm: '%d minutos',
+ h: 'una hora',
+ hh: '%d horas',
+ d: 'un día',
+ dd: '%d días',
+ w: 'una semana',
+ ww: '%d semanas',
+ M: 'un mes',
+ MM: '%d meses',
+ y: 'un año',
+ yy: '%d años',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return esUs;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/es.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/es.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Spanish [es]
+//! author : Julio Napurí : https://github.com/julionc
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split(
+ '_'
+ ),
+ monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'),
+ monthsParse = [
+ /^ene/i,
+ /^feb/i,
+ /^mar/i,
+ /^abr/i,
+ /^may/i,
+ /^jun/i,
+ /^jul/i,
+ /^ago/i,
+ /^sep/i,
+ /^oct/i,
+ /^nov/i,
+ /^dic/i,
+ ],
+ monthsRegex = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
+
+ var es = moment.defineLocale('es', {
+ months: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split(
+ '_'
+ ),
+ monthsShort: function (m, format) {
+ if (!m) {
+ return monthsShortDot;
+ } else if (/-MMM-/.test(format)) {
+ return monthsShort[m.month()];
+ } else {
+ return monthsShortDot[m.month()];
+ }
+ },
+ monthsRegex: monthsRegex,
+ monthsShortRegex: monthsRegex,
+ monthsStrictRegex: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
+ monthsShortStrictRegex: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+ weekdays: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
+ weekdaysShort: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
+ weekdaysMin: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D [de] MMMM [de] YYYY',
+ LLL: 'D [de] MMMM [de] YYYY H:mm',
+ LLLL: 'dddd, D [de] MMMM [de] YYYY H:mm',
+ },
+ calendar: {
+ sameDay: function () {
+ return '[hoy a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ nextDay: function () {
+ return '[mañana a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ nextWeek: function () {
+ return 'dddd [a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ lastDay: function () {
+ return '[ayer a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
+ },
+ lastWeek: function () {
+ return (
+ '[el] dddd [pasado a la' +
+ (this.hours() !== 1 ? 's' : '') +
+ '] LT'
+ );
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'en %s',
+ past: 'hace %s',
+ s: 'unos segundos',
+ ss: '%d segundos',
+ m: 'un minuto',
+ mm: '%d minutos',
+ h: 'una hora',
+ hh: '%d horas',
+ d: 'un día',
+ dd: '%d días',
+ w: 'una semana',
+ ww: '%d semanas',
+ M: 'un mes',
+ MM: '%d meses',
+ y: 'un año',
+ yy: '%d años',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ invalidDate: 'Fecha inválida',
+ });
+
+ return es;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/et.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/et.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Estonian [et]
+//! author : Henry Kehlmann : https://github.com/madhenry
+//! improvements : Illimar Tambek : https://github.com/ragulka
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function processRelativeTime(number, withoutSuffix, key, isFuture) {
+ var format = {
+ s: ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
+ ss: [number + 'sekundi', number + 'sekundit'],
+ m: ['ühe minuti', 'üks minut'],
+ mm: [number + ' minuti', number + ' minutit'],
+ h: ['ühe tunni', 'tund aega', 'üks tund'],
+ hh: [number + ' tunni', number + ' tundi'],
+ d: ['ühe päeva', 'üks päev'],
+ M: ['kuu aja', 'kuu aega', 'üks kuu'],
+ MM: [number + ' kuu', number + ' kuud'],
+ y: ['ühe aasta', 'aasta', 'üks aasta'],
+ yy: [number + ' aasta', number + ' aastat'],
+ };
+ if (withoutSuffix) {
+ return format[key][2] ? format[key][2] : format[key][1];
+ }
+ return isFuture ? format[key][0] : format[key][1];
+ }
+
+ var et = moment.defineLocale('et', {
+ months: 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split(
+ '_'
+ ),
+ monthsShort: 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split(
+ '_'
+ ),
+ weekdays: 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split(
+ '_'
+ ),
+ weekdaysShort: 'P_E_T_K_N_R_L'.split('_'),
+ weekdaysMin: 'P_E_T_K_N_R_L'.split('_'),
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY H:mm',
+ LLLL: 'dddd, D. MMMM YYYY H:mm',
+ },
+ calendar: {
+ sameDay: '[Täna,] LT',
+ nextDay: '[Homme,] LT',
+ nextWeek: '[Järgmine] dddd LT',
+ lastDay: '[Eile,] LT',
+ lastWeek: '[Eelmine] dddd LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s pärast',
+ past: '%s tagasi',
+ s: processRelativeTime,
+ ss: processRelativeTime,
+ m: processRelativeTime,
+ mm: processRelativeTime,
+ h: processRelativeTime,
+ hh: processRelativeTime,
+ d: processRelativeTime,
+ dd: '%d päeva',
+ M: processRelativeTime,
+ MM: processRelativeTime,
+ y: processRelativeTime,
+ yy: processRelativeTime,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return et;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/eu.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/eu.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Basque [eu]
+//! author : Eneko Illarramendi : https://github.com/eillarra
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var eu = moment.defineLocale('eu', {
+ months: 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split(
+ '_'
+ ),
+ monthsShort: 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split(
+ '_'
+ ),
+ weekdaysShort: 'ig._al._ar._az._og._ol._lr.'.split('_'),
+ weekdaysMin: 'ig_al_ar_az_og_ol_lr'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY-MM-DD',
+ LL: 'YYYY[ko] MMMM[ren] D[a]',
+ LLL: 'YYYY[ko] MMMM[ren] D[a] HH:mm',
+ LLLL: 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
+ l: 'YYYY-M-D',
+ ll: 'YYYY[ko] MMM D[a]',
+ lll: 'YYYY[ko] MMM D[a] HH:mm',
+ llll: 'ddd, YYYY[ko] MMM D[a] HH:mm',
+ },
+ calendar: {
+ sameDay: '[gaur] LT[etan]',
+ nextDay: '[bihar] LT[etan]',
+ nextWeek: 'dddd LT[etan]',
+ lastDay: '[atzo] LT[etan]',
+ lastWeek: '[aurreko] dddd LT[etan]',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s barru',
+ past: 'duela %s',
+ s: 'segundo batzuk',
+ ss: '%d segundo',
+ m: 'minutu bat',
+ mm: '%d minutu',
+ h: 'ordu bat',
+ hh: '%d ordu',
+ d: 'egun bat',
+ dd: '%d egun',
+ M: 'hilabete bat',
+ MM: '%d hilabete',
+ y: 'urte bat',
+ yy: '%d urte',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return eu;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/fa.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/fa.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Persian [fa]
+//! author : Ebrahim Byagowi : https://github.com/ebraminio
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '۱',
+ 2: '۲',
+ 3: '۳',
+ 4: '۴',
+ 5: '۵',
+ 6: '۶',
+ 7: '۷',
+ 8: '۸',
+ 9: '۹',
+ 0: '۰',
+ },
+ numberMap = {
+ '۱': '1',
+ '۲': '2',
+ '۳': '3',
+ '۴': '4',
+ '۵': '5',
+ '۶': '6',
+ '۷': '7',
+ '۸': '8',
+ '۹': '9',
+ '۰': '0',
+ };
+
+ var fa = moment.defineLocale('fa', {
+ months: 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split(
+ '_'
+ ),
+ monthsShort: 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split(
+ '_'
+ ),
+ weekdays: 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split(
+ '_'
+ ),
+ weekdaysShort: 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split(
+ '_'
+ ),
+ weekdaysMin: 'ی_د_س_چ_پ_ج_ش'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /قبل از ظهر|بعد از ظهر/,
+ isPM: function (input) {
+ return /بعد از ظهر/.test(input);
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'قبل از ظهر';
+ } else {
+ return 'بعد از ظهر';
+ }
+ },
+ calendar: {
+ sameDay: '[امروز ساعت] LT',
+ nextDay: '[فردا ساعت] LT',
+ nextWeek: 'dddd [ساعت] LT',
+ lastDay: '[دیروز ساعت] LT',
+ lastWeek: 'dddd [پیش] [ساعت] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'در %s',
+ past: '%s پیش',
+ s: 'چند ثانیه',
+ ss: '%d ثانیه',
+ m: 'یک دقیقه',
+ mm: '%d دقیقه',
+ h: 'یک ساعت',
+ hh: '%d ساعت',
+ d: 'یک روز',
+ dd: '%d روز',
+ M: 'یک ماه',
+ MM: '%d ماه',
+ y: 'یک سال',
+ yy: '%d سال',
+ },
+ preparse: function (string) {
+ return string
+ .replace(/[۰-۹]/g, function (match) {
+ return numberMap[match];
+ })
+ .replace(/،/g, ',');
+ },
+ postformat: function (string) {
+ return string
+ .replace(/\d/g, function (match) {
+ return symbolMap[match];
+ })
+ .replace(/,/g, '،');
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}م/,
+ ordinal: '%dم',
+ week: {
+ dow: 6, // Saturday is the first day of the week.
+ doy: 12, // The week that contains Jan 12th is the first week of the year.
+ },
+ });
+
+ return fa;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/fi.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/fi.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Finnish [fi]
+//! author : Tarmo Aidantausta : https://github.com/bleadof
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(
+ ' '
+ ),
+ numbersFuture = [
+ 'nolla',
+ 'yhden',
+ 'kahden',
+ 'kolmen',
+ 'neljän',
+ 'viiden',
+ 'kuuden',
+ numbersPast[7],
+ numbersPast[8],
+ numbersPast[9],
+ ];
+ function translate(number, withoutSuffix, key, isFuture) {
+ var result = '';
+ switch (key) {
+ case 's':
+ return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
+ case 'ss':
+ result = isFuture ? 'sekunnin' : 'sekuntia';
+ break;
+ case 'm':
+ return isFuture ? 'minuutin' : 'minuutti';
+ case 'mm':
+ result = isFuture ? 'minuutin' : 'minuuttia';
+ break;
+ case 'h':
+ return isFuture ? 'tunnin' : 'tunti';
+ case 'hh':
+ result = isFuture ? 'tunnin' : 'tuntia';
+ break;
+ case 'd':
+ return isFuture ? 'päivän' : 'päivä';
+ case 'dd':
+ result = isFuture ? 'päivän' : 'päivää';
+ break;
+ case 'M':
+ return isFuture ? 'kuukauden' : 'kuukausi';
+ case 'MM':
+ result = isFuture ? 'kuukauden' : 'kuukautta';
+ break;
+ case 'y':
+ return isFuture ? 'vuoden' : 'vuosi';
+ case 'yy':
+ result = isFuture ? 'vuoden' : 'vuotta';
+ break;
+ }
+ result = verbalNumber(number, isFuture) + ' ' + result;
+ return result;
+ }
+ function verbalNumber(number, isFuture) {
+ return number < 10
+ ? isFuture
+ ? numbersFuture[number]
+ : numbersPast[number]
+ : number;
+ }
+
+ var fi = moment.defineLocale('fi', {
+ months: 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split(
+ '_'
+ ),
+ monthsShort: 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split(
+ '_'
+ ),
+ weekdays: 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split(
+ '_'
+ ),
+ weekdaysShort: 'su_ma_ti_ke_to_pe_la'.split('_'),
+ weekdaysMin: 'su_ma_ti_ke_to_pe_la'.split('_'),
+ longDateFormat: {
+ LT: 'HH.mm',
+ LTS: 'HH.mm.ss',
+ L: 'DD.MM.YYYY',
+ LL: 'Do MMMM[ta] YYYY',
+ LLL: 'Do MMMM[ta] YYYY, [klo] HH.mm',
+ LLLL: 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
+ l: 'D.M.YYYY',
+ ll: 'Do MMM YYYY',
+ lll: 'Do MMM YYYY, [klo] HH.mm',
+ llll: 'ddd, Do MMM YYYY, [klo] HH.mm',
+ },
+ calendar: {
+ sameDay: '[tänään] [klo] LT',
+ nextDay: '[huomenna] [klo] LT',
+ nextWeek: 'dddd [klo] LT',
+ lastDay: '[eilen] [klo] LT',
+ lastWeek: '[viime] dddd[na] [klo] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s päästä',
+ past: '%s sitten',
+ s: translate,
+ ss: translate,
+ m: translate,
+ mm: translate,
+ h: translate,
+ hh: translate,
+ d: translate,
+ dd: translate,
+ M: translate,
+ MM: translate,
+ y: translate,
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return fi;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/fil.js":
+/*!*******************************************!*\
+ !*** ./node_modules/moment/locale/fil.js ***!
+ \*******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Filipino [fil]
+//! author : Dan Hagman : https://github.com/hagmandan
+//! author : Matthew Co : https://github.com/matthewdeeco
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var fil = moment.defineLocale('fil', {
+ months: 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split(
+ '_'
+ ),
+ monthsShort: 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
+ weekdays: 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split(
+ '_'
+ ),
+ weekdaysShort: 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
+ weekdaysMin: 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'MM/D/YYYY',
+ LL: 'MMMM D, YYYY',
+ LLL: 'MMMM D, YYYY HH:mm',
+ LLLL: 'dddd, MMMM DD, YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: 'LT [ngayong araw]',
+ nextDay: '[Bukas ng] LT',
+ nextWeek: 'LT [sa susunod na] dddd',
+ lastDay: 'LT [kahapon]',
+ lastWeek: 'LT [noong nakaraang] dddd',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'sa loob ng %s',
+ past: '%s ang nakalipas',
+ s: 'ilang segundo',
+ ss: '%d segundo',
+ m: 'isang minuto',
+ mm: '%d minuto',
+ h: 'isang oras',
+ hh: '%d oras',
+ d: 'isang araw',
+ dd: '%d araw',
+ M: 'isang buwan',
+ MM: '%d buwan',
+ y: 'isang taon',
+ yy: '%d taon',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}/,
+ ordinal: function (number) {
+ return number;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return fil;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/fo.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/fo.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Faroese [fo]
+//! author : Ragnar Johannesen : https://github.com/ragnar123
+//! author : Kristian Sakarisson : https://github.com/sakarisson
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var fo = moment.defineLocale('fo', {
+ months: 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split(
+ '_'
+ ),
+ monthsShort: 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
+ weekdays: 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split(
+ '_'
+ ),
+ weekdaysShort: 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
+ weekdaysMin: 'su_má_tý_mi_hó_fr_le'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D. MMMM, YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Í dag kl.] LT',
+ nextDay: '[Í morgin kl.] LT',
+ nextWeek: 'dddd [kl.] LT',
+ lastDay: '[Í gjár kl.] LT',
+ lastWeek: '[síðstu] dddd [kl] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'um %s',
+ past: '%s síðani',
+ s: 'fá sekund',
+ ss: '%d sekundir',
+ m: 'ein minuttur',
+ mm: '%d minuttir',
+ h: 'ein tími',
+ hh: '%d tímar',
+ d: 'ein dagur',
+ dd: '%d dagar',
+ M: 'ein mánaður',
+ MM: '%d mánaðir',
+ y: 'eitt ár',
+ yy: '%d ár',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return fo;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/fr-ca.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/fr-ca.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : French (Canada) [fr-ca]
+//! author : Jonathan Abourbih : https://github.com/jonbca
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var frCa = moment.defineLocale('fr-ca', {
+ months: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split(
+ '_'
+ ),
+ monthsShort: 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
+ weekdaysShort: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
+ weekdaysMin: 'di_lu_ma_me_je_ve_sa'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY-MM-DD',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Aujourd’hui à] LT',
+ nextDay: '[Demain à] LT',
+ nextWeek: 'dddd [à] LT',
+ lastDay: '[Hier à] LT',
+ lastWeek: 'dddd [dernier à] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'dans %s',
+ past: 'il y a %s',
+ s: 'quelques secondes',
+ ss: '%d secondes',
+ m: 'une minute',
+ mm: '%d minutes',
+ h: 'une heure',
+ hh: '%d heures',
+ d: 'un jour',
+ dd: '%d jours',
+ M: 'un mois',
+ MM: '%d mois',
+ y: 'un an',
+ yy: '%d ans',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ // Words with masculine grammatical gender: mois, trimestre, jour
+ default:
+ case 'M':
+ case 'Q':
+ case 'D':
+ case 'DDD':
+ case 'd':
+ return number + (number === 1 ? 'er' : 'e');
+
+ // Words with feminine grammatical gender: semaine
+ case 'w':
+ case 'W':
+ return number + (number === 1 ? 're' : 'e');
+ }
+ },
+ });
+
+ return frCa;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/fr-ch.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/fr-ch.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : French (Switzerland) [fr-ch]
+//! author : Gaspard Bucher : https://github.com/gaspard
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var frCh = moment.defineLocale('fr-ch', {
+ months: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split(
+ '_'
+ ),
+ monthsShort: 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
+ weekdaysShort: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
+ weekdaysMin: 'di_lu_ma_me_je_ve_sa'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Aujourd’hui à] LT',
+ nextDay: '[Demain à] LT',
+ nextWeek: 'dddd [à] LT',
+ lastDay: '[Hier à] LT',
+ lastWeek: 'dddd [dernier à] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'dans %s',
+ past: 'il y a %s',
+ s: 'quelques secondes',
+ ss: '%d secondes',
+ m: 'une minute',
+ mm: '%d minutes',
+ h: 'une heure',
+ hh: '%d heures',
+ d: 'un jour',
+ dd: '%d jours',
+ M: 'un mois',
+ MM: '%d mois',
+ y: 'un an',
+ yy: '%d ans',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ // Words with masculine grammatical gender: mois, trimestre, jour
+ default:
+ case 'M':
+ case 'Q':
+ case 'D':
+ case 'DDD':
+ case 'd':
+ return number + (number === 1 ? 'er' : 'e');
+
+ // Words with feminine grammatical gender: semaine
+ case 'w':
+ case 'W':
+ return number + (number === 1 ? 're' : 'e');
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return frCh;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/fr.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/fr.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : French [fr]
+//! author : John Fischer : https://github.com/jfroffice
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var monthsStrictRegex = /^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,
+ monthsShortStrictRegex = /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?)/i,
+ monthsRegex = /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?|janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,
+ monthsParse = [
+ /^janv/i,
+ /^févr/i,
+ /^mars/i,
+ /^avr/i,
+ /^mai/i,
+ /^juin/i,
+ /^juil/i,
+ /^août/i,
+ /^sept/i,
+ /^oct/i,
+ /^nov/i,
+ /^déc/i,
+ ];
+
+ var fr = moment.defineLocale('fr', {
+ months: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split(
+ '_'
+ ),
+ monthsShort: 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split(
+ '_'
+ ),
+ monthsRegex: monthsRegex,
+ monthsShortRegex: monthsRegex,
+ monthsStrictRegex: monthsStrictRegex,
+ monthsShortStrictRegex: monthsShortStrictRegex,
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+ weekdays: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
+ weekdaysShort: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
+ weekdaysMin: 'di_lu_ma_me_je_ve_sa'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Aujourd’hui à] LT',
+ nextDay: '[Demain à] LT',
+ nextWeek: 'dddd [à] LT',
+ lastDay: '[Hier à] LT',
+ lastWeek: 'dddd [dernier à] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'dans %s',
+ past: 'il y a %s',
+ s: 'quelques secondes',
+ ss: '%d secondes',
+ m: 'une minute',
+ mm: '%d minutes',
+ h: 'une heure',
+ hh: '%d heures',
+ d: 'un jour',
+ dd: '%d jours',
+ w: 'une semaine',
+ ww: '%d semaines',
+ M: 'un mois',
+ MM: '%d mois',
+ y: 'un an',
+ yy: '%d ans',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(er|)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ // TODO: Return 'e' when day of month > 1. Move this case inside
+ // block for masculine words below.
+ // See https://github.com/moment/moment/issues/3375
+ case 'D':
+ return number + (number === 1 ? 'er' : '');
+
+ // Words with masculine grammatical gender: mois, trimestre, jour
+ default:
+ case 'M':
+ case 'Q':
+ case 'DDD':
+ case 'd':
+ return number + (number === 1 ? 'er' : 'e');
+
+ // Words with feminine grammatical gender: semaine
+ case 'w':
+ case 'W':
+ return number + (number === 1 ? 're' : 'e');
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return fr;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/fy.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/fy.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Frisian [fy]
+//! author : Robin van der Vliet : https://github.com/robin0van0der0v
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split(
+ '_'
+ ),
+ monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split(
+ '_'
+ );
+
+ var fy = moment.defineLocale('fy', {
+ months: 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split(
+ '_'
+ ),
+ monthsShort: function (m, format) {
+ if (!m) {
+ return monthsShortWithDots;
+ } else if (/-MMM-/.test(format)) {
+ return monthsShortWithoutDots[m.month()];
+ } else {
+ return monthsShortWithDots[m.month()];
+ }
+ },
+ monthsParseExact: true,
+ weekdays: 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split(
+ '_'
+ ),
+ weekdaysShort: 'si._mo._ti._wo._to._fr._so.'.split('_'),
+ weekdaysMin: 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD-MM-YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[hjoed om] LT',
+ nextDay: '[moarn om] LT',
+ nextWeek: 'dddd [om] LT',
+ lastDay: '[juster om] LT',
+ lastWeek: '[ôfrûne] dddd [om] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'oer %s',
+ past: '%s lyn',
+ s: 'in pear sekonden',
+ ss: '%d sekonden',
+ m: 'ien minút',
+ mm: '%d minuten',
+ h: 'ien oere',
+ hh: '%d oeren',
+ d: 'ien dei',
+ dd: '%d dagen',
+ M: 'ien moanne',
+ MM: '%d moannen',
+ y: 'ien jier',
+ yy: '%d jierren',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
+ ordinal: function (number) {
+ return (
+ number +
+ (number === 1 || number === 8 || number >= 20 ? 'ste' : 'de')
+ );
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return fy;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ga.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ga.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Irish or Irish Gaelic [ga]
+//! author : André Silva : https://github.com/askpt
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var months = [
+ 'Eanáir',
+ 'Feabhra',
+ 'Márta',
+ 'Aibreán',
+ 'Bealtaine',
+ 'Meitheamh',
+ 'Iúil',
+ 'Lúnasa',
+ 'Meán Fómhair',
+ 'Deireadh Fómhair',
+ 'Samhain',
+ 'Nollaig',
+ ],
+ monthsShort = [
+ 'Ean',
+ 'Feabh',
+ 'Márt',
+ 'Aib',
+ 'Beal',
+ 'Meith',
+ 'Iúil',
+ 'Lún',
+ 'M.F.',
+ 'D.F.',
+ 'Samh',
+ 'Noll',
+ ],
+ weekdays = [
+ 'Dé Domhnaigh',
+ 'Dé Luain',
+ 'Dé Máirt',
+ 'Dé Céadaoin',
+ 'Déardaoin',
+ 'Dé hAoine',
+ 'Dé Sathairn',
+ ],
+ weekdaysShort = ['Domh', 'Luan', 'Máirt', 'Céad', 'Déar', 'Aoine', 'Sath'],
+ weekdaysMin = ['Do', 'Lu', 'Má', 'Cé', 'Dé', 'A', 'Sa'];
+
+ var ga = moment.defineLocale('ga', {
+ months: months,
+ monthsShort: monthsShort,
+ monthsParseExact: true,
+ weekdays: weekdays,
+ weekdaysShort: weekdaysShort,
+ weekdaysMin: weekdaysMin,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Inniu ag] LT',
+ nextDay: '[Amárach ag] LT',
+ nextWeek: 'dddd [ag] LT',
+ lastDay: '[Inné ag] LT',
+ lastWeek: 'dddd [seo caite] [ag] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'i %s',
+ past: '%s ó shin',
+ s: 'cúpla soicind',
+ ss: '%d soicind',
+ m: 'nóiméad',
+ mm: '%d nóiméad',
+ h: 'uair an chloig',
+ hh: '%d uair an chloig',
+ d: 'lá',
+ dd: '%d lá',
+ M: 'mí',
+ MM: '%d míonna',
+ y: 'bliain',
+ yy: '%d bliain',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(d|na|mh)/,
+ ordinal: function (number) {
+ var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return ga;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/gd.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/gd.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Scottish Gaelic [gd]
+//! author : Jon Ashdown : https://github.com/jonashdown
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var months = [
+ 'Am Faoilleach',
+ 'An Gearran',
+ 'Am Màrt',
+ 'An Giblean',
+ 'An Cèitean',
+ 'An t-Ògmhios',
+ 'An t-Iuchar',
+ 'An Lùnastal',
+ 'An t-Sultain',
+ 'An Dàmhair',
+ 'An t-Samhain',
+ 'An Dùbhlachd',
+ ],
+ monthsShort = [
+ 'Faoi',
+ 'Gear',
+ 'Màrt',
+ 'Gibl',
+ 'Cèit',
+ 'Ògmh',
+ 'Iuch',
+ 'Lùn',
+ 'Sult',
+ 'Dàmh',
+ 'Samh',
+ 'Dùbh',
+ ],
+ weekdays = [
+ 'Didòmhnaich',
+ 'Diluain',
+ 'Dimàirt',
+ 'Diciadain',
+ 'Diardaoin',
+ 'Dihaoine',
+ 'Disathairne',
+ ],
+ weekdaysShort = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'],
+ weekdaysMin = ['Dò', 'Lu', 'Mà', 'Ci', 'Ar', 'Ha', 'Sa'];
+
+ var gd = moment.defineLocale('gd', {
+ months: months,
+ monthsShort: monthsShort,
+ monthsParseExact: true,
+ weekdays: weekdays,
+ weekdaysShort: weekdaysShort,
+ weekdaysMin: weekdaysMin,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[An-diugh aig] LT',
+ nextDay: '[A-màireach aig] LT',
+ nextWeek: 'dddd [aig] LT',
+ lastDay: '[An-dè aig] LT',
+ lastWeek: 'dddd [seo chaidh] [aig] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'ann an %s',
+ past: 'bho chionn %s',
+ s: 'beagan diogan',
+ ss: '%d diogan',
+ m: 'mionaid',
+ mm: '%d mionaidean',
+ h: 'uair',
+ hh: '%d uairean',
+ d: 'latha',
+ dd: '%d latha',
+ M: 'mìos',
+ MM: '%d mìosan',
+ y: 'bliadhna',
+ yy: '%d bliadhna',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(d|na|mh)/,
+ ordinal: function (number) {
+ var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return gd;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/gl.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/gl.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Galician [gl]
+//! author : Juan G. Hurtado : https://github.com/juanghurtado
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var gl = moment.defineLocale('gl', {
+ months: 'xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro'.split(
+ '_'
+ ),
+ monthsShort: 'xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'domingo_luns_martes_mércores_xoves_venres_sábado'.split('_'),
+ weekdaysShort: 'dom._lun._mar._mér._xov._ven._sáb.'.split('_'),
+ weekdaysMin: 'do_lu_ma_mé_xo_ve_sá'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D [de] MMMM [de] YYYY',
+ LLL: 'D [de] MMMM [de] YYYY H:mm',
+ LLLL: 'dddd, D [de] MMMM [de] YYYY H:mm',
+ },
+ calendar: {
+ sameDay: function () {
+ return '[hoxe ' + (this.hours() !== 1 ? 'ás' : 'á') + '] LT';
+ },
+ nextDay: function () {
+ return '[mañá ' + (this.hours() !== 1 ? 'ás' : 'á') + '] LT';
+ },
+ nextWeek: function () {
+ return 'dddd [' + (this.hours() !== 1 ? 'ás' : 'a') + '] LT';
+ },
+ lastDay: function () {
+ return '[onte ' + (this.hours() !== 1 ? 'á' : 'a') + '] LT';
+ },
+ lastWeek: function () {
+ return (
+ '[o] dddd [pasado ' + (this.hours() !== 1 ? 'ás' : 'a') + '] LT'
+ );
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: function (str) {
+ if (str.indexOf('un') === 0) {
+ return 'n' + str;
+ }
+ return 'en ' + str;
+ },
+ past: 'hai %s',
+ s: 'uns segundos',
+ ss: '%d segundos',
+ m: 'un minuto',
+ mm: '%d minutos',
+ h: 'unha hora',
+ hh: '%d horas',
+ d: 'un día',
+ dd: '%d días',
+ M: 'un mes',
+ MM: '%d meses',
+ y: 'un ano',
+ yy: '%d anos',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return gl;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/gom-deva.js":
+/*!************************************************!*\
+ !*** ./node_modules/moment/locale/gom-deva.js ***!
+ \************************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Konkani Devanagari script [gom-deva]
+//! author : The Discoverer : https://github.com/WikiDiscoverer
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function processRelativeTime(number, withoutSuffix, key, isFuture) {
+ var format = {
+ s: ['थोडया सॅकंडांनी', 'थोडे सॅकंड'],
+ ss: [number + ' सॅकंडांनी', number + ' सॅकंड'],
+ m: ['एका मिणटान', 'एक मिनूट'],
+ mm: [number + ' मिणटांनी', number + ' मिणटां'],
+ h: ['एका वरान', 'एक वर'],
+ hh: [number + ' वरांनी', number + ' वरां'],
+ d: ['एका दिसान', 'एक दीस'],
+ dd: [number + ' दिसांनी', number + ' दीस'],
+ M: ['एका म्हयन्यान', 'एक म्हयनो'],
+ MM: [number + ' म्हयन्यानी', number + ' म्हयने'],
+ y: ['एका वर्सान', 'एक वर्स'],
+ yy: [number + ' वर्सांनी', number + ' वर्सां'],
+ };
+ return isFuture ? format[key][0] : format[key][1];
+ }
+
+ var gomDeva = moment.defineLocale('gom-deva', {
+ months: {
+ standalone: 'जानेवारी_फेब्रुवारी_मार्च_एप्रील_मे_जून_जुलय_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split(
+ '_'
+ ),
+ format: 'जानेवारीच्या_फेब्रुवारीच्या_मार्चाच्या_एप्रीलाच्या_मेयाच्या_जूनाच्या_जुलयाच्या_ऑगस्टाच्या_सप्टेंबराच्या_ऑक्टोबराच्या_नोव्हेंबराच्या_डिसेंबराच्या'.split(
+ '_'
+ ),
+ isFormat: /MMMM(\s)+D[oD]?/,
+ },
+ monthsShort: 'जाने._फेब्रु._मार्च_एप्री._मे_जून_जुल._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'आयतार_सोमार_मंगळार_बुधवार_बिरेस्तार_सुक्रार_शेनवार'.split('_'),
+ weekdaysShort: 'आयत._सोम._मंगळ._बुध._ब्रेस्त._सुक्र._शेन.'.split('_'),
+ weekdaysMin: 'आ_सो_मं_बु_ब्रे_सु_शे'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'A h:mm [वाजतां]',
+ LTS: 'A h:mm:ss [वाजतां]',
+ L: 'DD-MM-YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY A h:mm [वाजतां]',
+ LLLL: 'dddd, MMMM Do, YYYY, A h:mm [वाजतां]',
+ llll: 'ddd, D MMM YYYY, A h:mm [वाजतां]',
+ },
+ calendar: {
+ sameDay: '[आयज] LT',
+ nextDay: '[फाल्यां] LT',
+ nextWeek: '[फुडलो] dddd[,] LT',
+ lastDay: '[काल] LT',
+ lastWeek: '[फाटलो] dddd[,] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s',
+ past: '%s आदीं',
+ s: processRelativeTime,
+ ss: processRelativeTime,
+ m: processRelativeTime,
+ mm: processRelativeTime,
+ h: processRelativeTime,
+ hh: processRelativeTime,
+ d: processRelativeTime,
+ dd: processRelativeTime,
+ M: processRelativeTime,
+ MM: processRelativeTime,
+ y: processRelativeTime,
+ yy: processRelativeTime,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(वेर)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ // the ordinal 'वेर' only applies to day of the month
+ case 'D':
+ return number + 'वेर';
+ default:
+ case 'M':
+ case 'Q':
+ case 'DDD':
+ case 'd':
+ case 'w':
+ case 'W':
+ return number;
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week
+ doy: 3, // The week that contains Jan 4th is the first week of the year (7 + 0 - 4)
+ },
+ meridiemParse: /राती|सकाळीं|दनपारां|सांजे/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'राती') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'सकाळीं') {
+ return hour;
+ } else if (meridiem === 'दनपारां') {
+ return hour > 12 ? hour : hour + 12;
+ } else if (meridiem === 'सांजे') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'राती';
+ } else if (hour < 12) {
+ return 'सकाळीं';
+ } else if (hour < 16) {
+ return 'दनपारां';
+ } else if (hour < 20) {
+ return 'सांजे';
+ } else {
+ return 'राती';
+ }
+ },
+ });
+
+ return gomDeva;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/gom-latn.js":
+/*!************************************************!*\
+ !*** ./node_modules/moment/locale/gom-latn.js ***!
+ \************************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Konkani Latin script [gom-latn]
+//! author : The Discoverer : https://github.com/WikiDiscoverer
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function processRelativeTime(number, withoutSuffix, key, isFuture) {
+ var format = {
+ s: ['thoddea sekondamni', 'thodde sekond'],
+ ss: [number + ' sekondamni', number + ' sekond'],
+ m: ['eka mintan', 'ek minut'],
+ mm: [number + ' mintamni', number + ' mintam'],
+ h: ['eka voran', 'ek vor'],
+ hh: [number + ' voramni', number + ' voram'],
+ d: ['eka disan', 'ek dis'],
+ dd: [number + ' disamni', number + ' dis'],
+ M: ['eka mhoinean', 'ek mhoino'],
+ MM: [number + ' mhoineamni', number + ' mhoine'],
+ y: ['eka vorsan', 'ek voros'],
+ yy: [number + ' vorsamni', number + ' vorsam'],
+ };
+ return isFuture ? format[key][0] : format[key][1];
+ }
+
+ var gomLatn = moment.defineLocale('gom-latn', {
+ months: {
+ standalone: 'Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr'.split(
+ '_'
+ ),
+ format: 'Janerachea_Febrerachea_Marsachea_Abrilachea_Maiachea_Junachea_Julaiachea_Agostachea_Setembrachea_Otubrachea_Novembrachea_Dezembrachea'.split(
+ '_'
+ ),
+ isFormat: /MMMM(\s)+D[oD]?/,
+ },
+ monthsShort: 'Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: "Aitar_Somar_Mongllar_Budhvar_Birestar_Sukrar_Son'var".split('_'),
+ weekdaysShort: 'Ait._Som._Mon._Bud._Bre._Suk._Son.'.split('_'),
+ weekdaysMin: 'Ai_Sm_Mo_Bu_Br_Su_Sn'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'A h:mm [vazta]',
+ LTS: 'A h:mm:ss [vazta]',
+ L: 'DD-MM-YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY A h:mm [vazta]',
+ LLLL: 'dddd, MMMM Do, YYYY, A h:mm [vazta]',
+ llll: 'ddd, D MMM YYYY, A h:mm [vazta]',
+ },
+ calendar: {
+ sameDay: '[Aiz] LT',
+ nextDay: '[Faleam] LT',
+ nextWeek: '[Fuddlo] dddd[,] LT',
+ lastDay: '[Kal] LT',
+ lastWeek: '[Fattlo] dddd[,] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s',
+ past: '%s adim',
+ s: processRelativeTime,
+ ss: processRelativeTime,
+ m: processRelativeTime,
+ mm: processRelativeTime,
+ h: processRelativeTime,
+ hh: processRelativeTime,
+ d: processRelativeTime,
+ dd: processRelativeTime,
+ M: processRelativeTime,
+ MM: processRelativeTime,
+ y: processRelativeTime,
+ yy: processRelativeTime,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(er)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ // the ordinal 'er' only applies to day of the month
+ case 'D':
+ return number + 'er';
+ default:
+ case 'M':
+ case 'Q':
+ case 'DDD':
+ case 'd':
+ case 'w':
+ case 'W':
+ return number;
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week
+ doy: 3, // The week that contains Jan 4th is the first week of the year (7 + 0 - 4)
+ },
+ meridiemParse: /rati|sokallim|donparam|sanje/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'rati') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'sokallim') {
+ return hour;
+ } else if (meridiem === 'donparam') {
+ return hour > 12 ? hour : hour + 12;
+ } else if (meridiem === 'sanje') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'rati';
+ } else if (hour < 12) {
+ return 'sokallim';
+ } else if (hour < 16) {
+ return 'donparam';
+ } else if (hour < 20) {
+ return 'sanje';
+ } else {
+ return 'rati';
+ }
+ },
+ });
+
+ return gomLatn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/gu.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/gu.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Gujarati [gu]
+//! author : Kaushik Thanki : https://github.com/Kaushik1987
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '૧',
+ 2: '૨',
+ 3: '૩',
+ 4: '૪',
+ 5: '૫',
+ 6: '૬',
+ 7: '૭',
+ 8: '૮',
+ 9: '૯',
+ 0: '૦',
+ },
+ numberMap = {
+ '૧': '1',
+ '૨': '2',
+ '૩': '3',
+ '૪': '4',
+ '૫': '5',
+ '૬': '6',
+ '૭': '7',
+ '૮': '8',
+ '૯': '9',
+ '૦': '0',
+ };
+
+ var gu = moment.defineLocale('gu', {
+ months: 'જાન્યુઆરી_ફેબ્રુઆરી_માર્ચ_એપ્રિલ_મે_જૂન_જુલાઈ_ઑગસ્ટ_સપ્ટેમ્બર_ઑક્ટ્બર_નવેમ્બર_ડિસેમ્બર'.split(
+ '_'
+ ),
+ monthsShort: 'જાન્યુ._ફેબ્રુ._માર્ચ_એપ્રિ._મે_જૂન_જુલા._ઑગ._સપ્ટે._ઑક્ટ્._નવે._ડિસે.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'રવિવાર_સોમવાર_મંગળવાર_બુધ્વાર_ગુરુવાર_શુક્રવાર_શનિવાર'.split(
+ '_'
+ ),
+ weekdaysShort: 'રવિ_સોમ_મંગળ_બુધ્_ગુરુ_શુક્ર_શનિ'.split('_'),
+ weekdaysMin: 'ર_સો_મં_બુ_ગુ_શુ_શ'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm વાગ્યે',
+ LTS: 'A h:mm:ss વાગ્યે',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm વાગ્યે',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm વાગ્યે',
+ },
+ calendar: {
+ sameDay: '[આજ] LT',
+ nextDay: '[કાલે] LT',
+ nextWeek: 'dddd, LT',
+ lastDay: '[ગઇકાલે] LT',
+ lastWeek: '[પાછલા] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s મા',
+ past: '%s પહેલા',
+ s: 'અમુક પળો',
+ ss: '%d સેકંડ',
+ m: 'એક મિનિટ',
+ mm: '%d મિનિટ',
+ h: 'એક કલાક',
+ hh: '%d કલાક',
+ d: 'એક દિવસ',
+ dd: '%d દિવસ',
+ M: 'એક મહિનો',
+ MM: '%d મહિનો',
+ y: 'એક વર્ષ',
+ yy: '%d વર્ષ',
+ },
+ preparse: function (string) {
+ return string.replace(/[૧૨૩૪૫૬૭૮૯૦]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ // Gujarati notation for meridiems are quite fuzzy in practice. While there exists
+ // a rigid notion of a 'Pahar' it is not used as rigidly in modern Gujarati.
+ meridiemParse: /રાત|બપોર|સવાર|સાંજ/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'રાત') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'સવાર') {
+ return hour;
+ } else if (meridiem === 'બપોર') {
+ return hour >= 10 ? hour : hour + 12;
+ } else if (meridiem === 'સાંજ') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'રાત';
+ } else if (hour < 10) {
+ return 'સવાર';
+ } else if (hour < 17) {
+ return 'બપોર';
+ } else if (hour < 20) {
+ return 'સાંજ';
+ } else {
+ return 'રાત';
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return gu;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/he.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/he.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Hebrew [he]
+//! author : Tomer Cohen : https://github.com/tomer
+//! author : Moshe Simantov : https://github.com/DevelopmentIL
+//! author : Tal Ater : https://github.com/TalAter
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var he = moment.defineLocale('he', {
+ months: 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split(
+ '_'
+ ),
+ monthsShort: 'ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳'.split(
+ '_'
+ ),
+ weekdays: 'ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
+ weekdaysShort: 'א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
+ weekdaysMin: 'א_ב_ג_ד_ה_ו_ש'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D [ב]MMMM YYYY',
+ LLL: 'D [ב]MMMM YYYY HH:mm',
+ LLLL: 'dddd, D [ב]MMMM YYYY HH:mm',
+ l: 'D/M/YYYY',
+ ll: 'D MMM YYYY',
+ lll: 'D MMM YYYY HH:mm',
+ llll: 'ddd, D MMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[היום ב־]LT',
+ nextDay: '[מחר ב־]LT',
+ nextWeek: 'dddd [בשעה] LT',
+ lastDay: '[אתמול ב־]LT',
+ lastWeek: '[ביום] dddd [האחרון בשעה] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'בעוד %s',
+ past: 'לפני %s',
+ s: 'מספר שניות',
+ ss: '%d שניות',
+ m: 'דקה',
+ mm: '%d דקות',
+ h: 'שעה',
+ hh: function (number) {
+ if (number === 2) {
+ return 'שעתיים';
+ }
+ return number + ' שעות';
+ },
+ d: 'יום',
+ dd: function (number) {
+ if (number === 2) {
+ return 'יומיים';
+ }
+ return number + ' ימים';
+ },
+ M: 'חודש',
+ MM: function (number) {
+ if (number === 2) {
+ return 'חודשיים';
+ }
+ return number + ' חודשים';
+ },
+ y: 'שנה',
+ yy: function (number) {
+ if (number === 2) {
+ return 'שנתיים';
+ } else if (number % 10 === 0 && number !== 10) {
+ return number + ' שנה';
+ }
+ return number + ' שנים';
+ },
+ },
+ meridiemParse: /אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,
+ isPM: function (input) {
+ return /^(אחה"צ|אחרי הצהריים|בערב)$/.test(input);
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 5) {
+ return 'לפנות בוקר';
+ } else if (hour < 10) {
+ return 'בבוקר';
+ } else if (hour < 12) {
+ return isLower ? 'לפנה"צ' : 'לפני הצהריים';
+ } else if (hour < 18) {
+ return isLower ? 'אחה"צ' : 'אחרי הצהריים';
+ } else {
+ return 'בערב';
+ }
+ },
+ });
+
+ return he;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/hi.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/hi.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Hindi [hi]
+//! author : Mayank Singhal : https://github.com/mayanksinghal
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '१',
+ 2: '२',
+ 3: '३',
+ 4: '४',
+ 5: '५',
+ 6: '६',
+ 7: '७',
+ 8: '८',
+ 9: '९',
+ 0: '०',
+ },
+ numberMap = {
+ '१': '1',
+ '२': '2',
+ '३': '3',
+ '४': '4',
+ '५': '5',
+ '६': '6',
+ '७': '7',
+ '८': '8',
+ '९': '9',
+ '०': '0',
+ },
+ monthsParse = [
+ /^जन/i,
+ /^फ़र|फर/i,
+ /^मार्च/i,
+ /^अप्रै/i,
+ /^मई/i,
+ /^जून/i,
+ /^जुल/i,
+ /^अग/i,
+ /^सितं|सित/i,
+ /^अक्टू/i,
+ /^नव|नवं/i,
+ /^दिसं|दिस/i,
+ ],
+ shortMonthsParse = [
+ /^जन/i,
+ /^फ़र/i,
+ /^मार्च/i,
+ /^अप्रै/i,
+ /^मई/i,
+ /^जून/i,
+ /^जुल/i,
+ /^अग/i,
+ /^सित/i,
+ /^अक्टू/i,
+ /^नव/i,
+ /^दिस/i,
+ ];
+
+ var hi = moment.defineLocale('hi', {
+ months: {
+ format: 'जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर'.split(
+ '_'
+ ),
+ standalone: 'जनवरी_फरवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितंबर_अक्टूबर_नवंबर_दिसंबर'.split(
+ '_'
+ ),
+ },
+ monthsShort: 'जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.'.split(
+ '_'
+ ),
+ weekdays: 'रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
+ weekdaysShort: 'रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि'.split('_'),
+ weekdaysMin: 'र_सो_मं_बु_गु_शु_श'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm बजे',
+ LTS: 'A h:mm:ss बजे',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm बजे',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm बजे',
+ },
+
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: shortMonthsParse,
+
+ monthsRegex: /^(जनवरी|जन\.?|फ़रवरी|फरवरी|फ़र\.?|मार्च?|अप्रैल|अप्रै\.?|मई?|जून?|जुलाई|जुल\.?|अगस्त|अग\.?|सितम्बर|सितंबर|सित\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर|नव\.?|दिसम्बर|दिसंबर|दिस\.?)/i,
+
+ monthsShortRegex: /^(जनवरी|जन\.?|फ़रवरी|फरवरी|फ़र\.?|मार्च?|अप्रैल|अप्रै\.?|मई?|जून?|जुलाई|जुल\.?|अगस्त|अग\.?|सितम्बर|सितंबर|सित\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर|नव\.?|दिसम्बर|दिसंबर|दिस\.?)/i,
+
+ monthsStrictRegex: /^(जनवरी?|फ़रवरी|फरवरी?|मार्च?|अप्रैल?|मई?|जून?|जुलाई?|अगस्त?|सितम्बर|सितंबर|सित?\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर?|दिसम्बर|दिसंबर?)/i,
+
+ monthsShortStrictRegex: /^(जन\.?|फ़र\.?|मार्च?|अप्रै\.?|मई?|जून?|जुल\.?|अग\.?|सित\.?|अक्टू\.?|नव\.?|दिस\.?)/i,
+
+ calendar: {
+ sameDay: '[आज] LT',
+ nextDay: '[कल] LT',
+ nextWeek: 'dddd, LT',
+ lastDay: '[कल] LT',
+ lastWeek: '[पिछले] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s में',
+ past: '%s पहले',
+ s: 'कुछ ही क्षण',
+ ss: '%d सेकंड',
+ m: 'एक मिनट',
+ mm: '%d मिनट',
+ h: 'एक घंटा',
+ hh: '%d घंटे',
+ d: 'एक दिन',
+ dd: '%d दिन',
+ M: 'एक महीने',
+ MM: '%d महीने',
+ y: 'एक वर्ष',
+ yy: '%d वर्ष',
+ },
+ preparse: function (string) {
+ return string.replace(/[१२३४५६७८९०]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ // Hindi notation for meridiems are quite fuzzy in practice. While there exists
+ // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
+ meridiemParse: /रात|सुबह|दोपहर|शाम/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'रात') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'सुबह') {
+ return hour;
+ } else if (meridiem === 'दोपहर') {
+ return hour >= 10 ? hour : hour + 12;
+ } else if (meridiem === 'शाम') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'रात';
+ } else if (hour < 10) {
+ return 'सुबह';
+ } else if (hour < 17) {
+ return 'दोपहर';
+ } else if (hour < 20) {
+ return 'शाम';
+ } else {
+ return 'रात';
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return hi;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/hr.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/hr.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Croatian [hr]
+//! author : Bojan Marković : https://github.com/bmarkovic
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function translate(number, withoutSuffix, key) {
+ var result = number + ' ';
+ switch (key) {
+ case 'ss':
+ if (number === 1) {
+ result += 'sekunda';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'sekunde';
+ } else {
+ result += 'sekundi';
+ }
+ return result;
+ case 'm':
+ return withoutSuffix ? 'jedna minuta' : 'jedne minute';
+ case 'mm':
+ if (number === 1) {
+ result += 'minuta';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'minute';
+ } else {
+ result += 'minuta';
+ }
+ return result;
+ case 'h':
+ return withoutSuffix ? 'jedan sat' : 'jednog sata';
+ case 'hh':
+ if (number === 1) {
+ result += 'sat';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'sata';
+ } else {
+ result += 'sati';
+ }
+ return result;
+ case 'dd':
+ if (number === 1) {
+ result += 'dan';
+ } else {
+ result += 'dana';
+ }
+ return result;
+ case 'MM':
+ if (number === 1) {
+ result += 'mjesec';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'mjeseca';
+ } else {
+ result += 'mjeseci';
+ }
+ return result;
+ case 'yy':
+ if (number === 1) {
+ result += 'godina';
+ } else if (number === 2 || number === 3 || number === 4) {
+ result += 'godine';
+ } else {
+ result += 'godina';
+ }
+ return result;
+ }
+ }
+
+ var hr = moment.defineLocale('hr', {
+ months: {
+ format: 'siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split(
+ '_'
+ ),
+ standalone: 'siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split(
+ '_'
+ ),
+ },
+ monthsShort: 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split(
+ '_'
+ ),
+ weekdaysShort: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
+ weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'Do MMMM YYYY',
+ LLL: 'Do MMMM YYYY H:mm',
+ LLLL: 'dddd, Do MMMM YYYY H:mm',
+ },
+ calendar: {
+ sameDay: '[danas u] LT',
+ nextDay: '[sutra u] LT',
+ nextWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[u] [nedjelju] [u] LT';
+ case 3:
+ return '[u] [srijedu] [u] LT';
+ case 6:
+ return '[u] [subotu] [u] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[u] dddd [u] LT';
+ }
+ },
+ lastDay: '[jučer u] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[prošlu] [nedjelju] [u] LT';
+ case 3:
+ return '[prošlu] [srijedu] [u] LT';
+ case 6:
+ return '[prošle] [subote] [u] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[prošli] dddd [u] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'za %s',
+ past: 'prije %s',
+ s: 'par sekundi',
+ ss: translate,
+ m: translate,
+ mm: translate,
+ h: translate,
+ hh: translate,
+ d: 'dan',
+ dd: translate,
+ M: 'mjesec',
+ MM: translate,
+ y: 'godinu',
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return hr;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/hu.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/hu.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Hungarian [hu]
+//! author : Adam Brunner : https://github.com/adambrunner
+//! author : Peter Viszt : https://github.com/passatgt
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var weekEndings = 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(
+ ' '
+ );
+ function translate(number, withoutSuffix, key, isFuture) {
+ var num = number;
+ switch (key) {
+ case 's':
+ return isFuture || withoutSuffix
+ ? 'néhány másodperc'
+ : 'néhány másodperce';
+ case 'ss':
+ return num + (isFuture || withoutSuffix)
+ ? ' másodperc'
+ : ' másodperce';
+ case 'm':
+ return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce');
+ case 'mm':
+ return num + (isFuture || withoutSuffix ? ' perc' : ' perce');
+ case 'h':
+ return 'egy' + (isFuture || withoutSuffix ? ' óra' : ' órája');
+ case 'hh':
+ return num + (isFuture || withoutSuffix ? ' óra' : ' órája');
+ case 'd':
+ return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja');
+ case 'dd':
+ return num + (isFuture || withoutSuffix ? ' nap' : ' napja');
+ case 'M':
+ return 'egy' + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
+ case 'MM':
+ return num + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
+ case 'y':
+ return 'egy' + (isFuture || withoutSuffix ? ' év' : ' éve');
+ case 'yy':
+ return num + (isFuture || withoutSuffix ? ' év' : ' éve');
+ }
+ return '';
+ }
+ function week(isFuture) {
+ return (
+ (isFuture ? '' : '[múlt] ') +
+ '[' +
+ weekEndings[this.day()] +
+ '] LT[-kor]'
+ );
+ }
+
+ var hu = moment.defineLocale('hu', {
+ months: 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split(
+ '_'
+ ),
+ monthsShort: 'jan._feb._márc._ápr._máj._jún._júl._aug._szept._okt._nov._dec.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
+ weekdaysShort: 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
+ weekdaysMin: 'v_h_k_sze_cs_p_szo'.split('_'),
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'YYYY.MM.DD.',
+ LL: 'YYYY. MMMM D.',
+ LLL: 'YYYY. MMMM D. H:mm',
+ LLLL: 'YYYY. MMMM D., dddd H:mm',
+ },
+ meridiemParse: /de|du/i,
+ isPM: function (input) {
+ return input.charAt(1).toLowerCase() === 'u';
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours < 12) {
+ return isLower === true ? 'de' : 'DE';
+ } else {
+ return isLower === true ? 'du' : 'DU';
+ }
+ },
+ calendar: {
+ sameDay: '[ma] LT[-kor]',
+ nextDay: '[holnap] LT[-kor]',
+ nextWeek: function () {
+ return week.call(this, true);
+ },
+ lastDay: '[tegnap] LT[-kor]',
+ lastWeek: function () {
+ return week.call(this, false);
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s múlva',
+ past: '%s',
+ s: translate,
+ ss: translate,
+ m: translate,
+ mm: translate,
+ h: translate,
+ hh: translate,
+ d: translate,
+ dd: translate,
+ M: translate,
+ MM: translate,
+ y: translate,
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return hu;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/hy-am.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/hy-am.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Armenian [hy-am]
+//! author : Armendarabyan : https://github.com/armendarabyan
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var hyAm = moment.defineLocale('hy-am', {
+ months: {
+ format: 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split(
+ '_'
+ ),
+ standalone: 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split(
+ '_'
+ ),
+ },
+ monthsShort: 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
+ weekdays: 'կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ'.split(
+ '_'
+ ),
+ weekdaysShort: 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
+ weekdaysMin: 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY թ.',
+ LLL: 'D MMMM YYYY թ., HH:mm',
+ LLLL: 'dddd, D MMMM YYYY թ., HH:mm',
+ },
+ calendar: {
+ sameDay: '[այսօր] LT',
+ nextDay: '[վաղը] LT',
+ lastDay: '[երեկ] LT',
+ nextWeek: function () {
+ return 'dddd [օրը ժամը] LT';
+ },
+ lastWeek: function () {
+ return '[անցած] dddd [օրը ժամը] LT';
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s հետո',
+ past: '%s առաջ',
+ s: 'մի քանի վայրկյան',
+ ss: '%d վայրկյան',
+ m: 'րոպե',
+ mm: '%d րոպե',
+ h: 'ժամ',
+ hh: '%d ժամ',
+ d: 'օր',
+ dd: '%d օր',
+ M: 'ամիս',
+ MM: '%d ամիս',
+ y: 'տարի',
+ yy: '%d տարի',
+ },
+ meridiemParse: /գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,
+ isPM: function (input) {
+ return /^(ցերեկվա|երեկոյան)$/.test(input);
+ },
+ meridiem: function (hour) {
+ if (hour < 4) {
+ return 'գիշերվա';
+ } else if (hour < 12) {
+ return 'առավոտվա';
+ } else if (hour < 17) {
+ return 'ցերեկվա';
+ } else {
+ return 'երեկոյան';
+ }
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}|\d{1,2}-(ին|րդ)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'DDD':
+ case 'w':
+ case 'W':
+ case 'DDDo':
+ if (number === 1) {
+ return number + '-ին';
+ }
+ return number + '-րդ';
+ default:
+ return number;
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return hyAm;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/id.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/id.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Indonesian [id]
+//! author : Mohammad Satrio Utomo : https://github.com/tyok
+//! reference: http://id.wikisource.org/wiki/Pedoman_Umum_Ejaan_Bahasa_Indonesia_yang_Disempurnakan
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var id = moment.defineLocale('id', {
+ months: 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Agt_Sep_Okt_Nov_Des'.split('_'),
+ weekdays: 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
+ weekdaysShort: 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
+ weekdaysMin: 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
+ longDateFormat: {
+ LT: 'HH.mm',
+ LTS: 'HH.mm.ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY [pukul] HH.mm',
+ LLLL: 'dddd, D MMMM YYYY [pukul] HH.mm',
+ },
+ meridiemParse: /pagi|siang|sore|malam/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'pagi') {
+ return hour;
+ } else if (meridiem === 'siang') {
+ return hour >= 11 ? hour : hour + 12;
+ } else if (meridiem === 'sore' || meridiem === 'malam') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours < 11) {
+ return 'pagi';
+ } else if (hours < 15) {
+ return 'siang';
+ } else if (hours < 19) {
+ return 'sore';
+ } else {
+ return 'malam';
+ }
+ },
+ calendar: {
+ sameDay: '[Hari ini pukul] LT',
+ nextDay: '[Besok pukul] LT',
+ nextWeek: 'dddd [pukul] LT',
+ lastDay: '[Kemarin pukul] LT',
+ lastWeek: 'dddd [lalu pukul] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'dalam %s',
+ past: '%s yang lalu',
+ s: 'beberapa detik',
+ ss: '%d detik',
+ m: 'semenit',
+ mm: '%d menit',
+ h: 'sejam',
+ hh: '%d jam',
+ d: 'sehari',
+ dd: '%d hari',
+ M: 'sebulan',
+ MM: '%d bulan',
+ y: 'setahun',
+ yy: '%d tahun',
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return id;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/is.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/is.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Icelandic [is]
+//! author : Hinrik Örn Sigurðsson : https://github.com/hinrik
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function plural(n) {
+ if (n % 100 === 11) {
+ return true;
+ } else if (n % 10 === 1) {
+ return false;
+ }
+ return true;
+ }
+ function translate(number, withoutSuffix, key, isFuture) {
+ var result = number + ' ';
+ switch (key) {
+ case 's':
+ return withoutSuffix || isFuture
+ ? 'nokkrar sekúndur'
+ : 'nokkrum sekúndum';
+ case 'ss':
+ if (plural(number)) {
+ return (
+ result +
+ (withoutSuffix || isFuture ? 'sekúndur' : 'sekúndum')
+ );
+ }
+ return result + 'sekúnda';
+ case 'm':
+ return withoutSuffix ? 'mínúta' : 'mínútu';
+ case 'mm':
+ if (plural(number)) {
+ return (
+ result + (withoutSuffix || isFuture ? 'mínútur' : 'mínútum')
+ );
+ } else if (withoutSuffix) {
+ return result + 'mínúta';
+ }
+ return result + 'mínútu';
+ case 'hh':
+ if (plural(number)) {
+ return (
+ result +
+ (withoutSuffix || isFuture
+ ? 'klukkustundir'
+ : 'klukkustundum')
+ );
+ }
+ return result + 'klukkustund';
+ case 'd':
+ if (withoutSuffix) {
+ return 'dagur';
+ }
+ return isFuture ? 'dag' : 'degi';
+ case 'dd':
+ if (plural(number)) {
+ if (withoutSuffix) {
+ return result + 'dagar';
+ }
+ return result + (isFuture ? 'daga' : 'dögum');
+ } else if (withoutSuffix) {
+ return result + 'dagur';
+ }
+ return result + (isFuture ? 'dag' : 'degi');
+ case 'M':
+ if (withoutSuffix) {
+ return 'mánuður';
+ }
+ return isFuture ? 'mánuð' : 'mánuði';
+ case 'MM':
+ if (plural(number)) {
+ if (withoutSuffix) {
+ return result + 'mánuðir';
+ }
+ return result + (isFuture ? 'mánuði' : 'mánuðum');
+ } else if (withoutSuffix) {
+ return result + 'mánuður';
+ }
+ return result + (isFuture ? 'mánuð' : 'mánuði');
+ case 'y':
+ return withoutSuffix || isFuture ? 'ár' : 'ári';
+ case 'yy':
+ if (plural(number)) {
+ return result + (withoutSuffix || isFuture ? 'ár' : 'árum');
+ }
+ return result + (withoutSuffix || isFuture ? 'ár' : 'ári');
+ }
+ }
+
+ var is = moment.defineLocale('is', {
+ months: 'janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember'.split(
+ '_'
+ ),
+ monthsShort: 'jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
+ weekdays: 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split(
+ '_'
+ ),
+ weekdaysShort: 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
+ weekdaysMin: 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY [kl.] H:mm',
+ LLLL: 'dddd, D. MMMM YYYY [kl.] H:mm',
+ },
+ calendar: {
+ sameDay: '[í dag kl.] LT',
+ nextDay: '[á morgun kl.] LT',
+ nextWeek: 'dddd [kl.] LT',
+ lastDay: '[í gær kl.] LT',
+ lastWeek: '[síðasta] dddd [kl.] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'eftir %s',
+ past: 'fyrir %s síðan',
+ s: translate,
+ ss: translate,
+ m: translate,
+ mm: translate,
+ h: 'klukkustund',
+ hh: translate,
+ d: translate,
+ dd: translate,
+ M: translate,
+ MM: translate,
+ y: translate,
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return is;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/it-ch.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/it-ch.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Italian (Switzerland) [it-ch]
+//! author : xfh : https://github.com/xfh
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var itCh = moment.defineLocale('it-ch', {
+ months: 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split(
+ '_'
+ ),
+ monthsShort: 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
+ weekdays: 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split(
+ '_'
+ ),
+ weekdaysShort: 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
+ weekdaysMin: 'do_lu_ma_me_gi_ve_sa'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Oggi alle] LT',
+ nextDay: '[Domani alle] LT',
+ nextWeek: 'dddd [alle] LT',
+ lastDay: '[Ieri alle] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[la scorsa] dddd [alle] LT';
+ default:
+ return '[lo scorso] dddd [alle] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: function (s) {
+ return (/^[0-9].+$/.test(s) ? 'tra' : 'in') + ' ' + s;
+ },
+ past: '%s fa',
+ s: 'alcuni secondi',
+ ss: '%d secondi',
+ m: 'un minuto',
+ mm: '%d minuti',
+ h: "un'ora",
+ hh: '%d ore',
+ d: 'un giorno',
+ dd: '%d giorni',
+ M: 'un mese',
+ MM: '%d mesi',
+ y: 'un anno',
+ yy: '%d anni',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return itCh;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/it.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/it.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Italian [it]
+//! author : Lorenzo : https://github.com/aliem
+//! author: Mattia Larentis: https://github.com/nostalgiaz
+//! author: Marco : https://github.com/Manfre98
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var it = moment.defineLocale('it', {
+ months: 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split(
+ '_'
+ ),
+ monthsShort: 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
+ weekdays: 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split(
+ '_'
+ ),
+ weekdaysShort: 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
+ weekdaysMin: 'do_lu_ma_me_gi_ve_sa'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: function () {
+ return (
+ '[Oggi a' +
+ (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") +
+ ']LT'
+ );
+ },
+ nextDay: function () {
+ return (
+ '[Domani a' +
+ (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") +
+ ']LT'
+ );
+ },
+ nextWeek: function () {
+ return (
+ 'dddd [a' +
+ (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") +
+ ']LT'
+ );
+ },
+ lastDay: function () {
+ return (
+ '[Ieri a' +
+ (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") +
+ ']LT'
+ );
+ },
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return (
+ '[La scorsa] dddd [a' +
+ (this.hours() > 1
+ ? 'lle '
+ : this.hours() === 0
+ ? ' '
+ : "ll'") +
+ ']LT'
+ );
+ default:
+ return (
+ '[Lo scorso] dddd [a' +
+ (this.hours() > 1
+ ? 'lle '
+ : this.hours() === 0
+ ? ' '
+ : "ll'") +
+ ']LT'
+ );
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'tra %s',
+ past: '%s fa',
+ s: 'alcuni secondi',
+ ss: '%d secondi',
+ m: 'un minuto',
+ mm: '%d minuti',
+ h: "un'ora",
+ hh: '%d ore',
+ d: 'un giorno',
+ dd: '%d giorni',
+ w: 'una settimana',
+ ww: '%d settimane',
+ M: 'un mese',
+ MM: '%d mesi',
+ y: 'un anno',
+ yy: '%d anni',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return it;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ja.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ja.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Japanese [ja]
+//! author : LI Long : https://github.com/baryon
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ja = moment.defineLocale('ja', {
+ eras: [
+ {
+ since: '2019-05-01',
+ offset: 1,
+ name: '令和',
+ narrow: '㋿',
+ abbr: 'R',
+ },
+ {
+ since: '1989-01-08',
+ until: '2019-04-30',
+ offset: 1,
+ name: '平成',
+ narrow: '㍻',
+ abbr: 'H',
+ },
+ {
+ since: '1926-12-25',
+ until: '1989-01-07',
+ offset: 1,
+ name: '昭和',
+ narrow: '㍼',
+ abbr: 'S',
+ },
+ {
+ since: '1912-07-30',
+ until: '1926-12-24',
+ offset: 1,
+ name: '大正',
+ narrow: '㍽',
+ abbr: 'T',
+ },
+ {
+ since: '1873-01-01',
+ until: '1912-07-29',
+ offset: 6,
+ name: '明治',
+ narrow: '㍾',
+ abbr: 'M',
+ },
+ {
+ since: '0001-01-01',
+ until: '1873-12-31',
+ offset: 1,
+ name: '西暦',
+ narrow: 'AD',
+ abbr: 'AD',
+ },
+ {
+ since: '0000-12-31',
+ until: -Infinity,
+ offset: 1,
+ name: '紀元前',
+ narrow: 'BC',
+ abbr: 'BC',
+ },
+ ],
+ eraYearOrdinalRegex: /(元|\d+)年/,
+ eraYearOrdinalParse: function (input, match) {
+ return match[1] === '元' ? 1 : parseInt(match[1] || input, 10);
+ },
+ months: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
+ monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
+ '_'
+ ),
+ weekdays: '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
+ weekdaysShort: '日_月_火_水_木_金_土'.split('_'),
+ weekdaysMin: '日_月_火_水_木_金_土'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY/MM/DD',
+ LL: 'YYYY年M月D日',
+ LLL: 'YYYY年M月D日 HH:mm',
+ LLLL: 'YYYY年M月D日 dddd HH:mm',
+ l: 'YYYY/MM/DD',
+ ll: 'YYYY年M月D日',
+ lll: 'YYYY年M月D日 HH:mm',
+ llll: 'YYYY年M月D日(ddd) HH:mm',
+ },
+ meridiemParse: /午前|午後/i,
+ isPM: function (input) {
+ return input === '午後';
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return '午前';
+ } else {
+ return '午後';
+ }
+ },
+ calendar: {
+ sameDay: '[今日] LT',
+ nextDay: '[明日] LT',
+ nextWeek: function (now) {
+ if (now.week() !== this.week()) {
+ return '[来週]dddd LT';
+ } else {
+ return 'dddd LT';
+ }
+ },
+ lastDay: '[昨日] LT',
+ lastWeek: function (now) {
+ if (this.week() !== now.week()) {
+ return '[先週]dddd LT';
+ } else {
+ return 'dddd LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}日/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'y':
+ return number === 1 ? '元年' : number + '年';
+ case 'd':
+ case 'D':
+ case 'DDD':
+ return number + '日';
+ default:
+ return number;
+ }
+ },
+ relativeTime: {
+ future: '%s後',
+ past: '%s前',
+ s: '数秒',
+ ss: '%d秒',
+ m: '1分',
+ mm: '%d分',
+ h: '1時間',
+ hh: '%d時間',
+ d: '1日',
+ dd: '%d日',
+ M: '1ヶ月',
+ MM: '%dヶ月',
+ y: '1年',
+ yy: '%d年',
+ },
+ });
+
+ return ja;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/jv.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/jv.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Javanese [jv]
+//! author : Rony Lantip : https://github.com/lantip
+//! reference: http://jv.wikipedia.org/wiki/Basa_Jawa
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var jv = moment.defineLocale('jv', {
+ months: 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
+ weekdays: 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
+ weekdaysShort: 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
+ weekdaysMin: 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
+ longDateFormat: {
+ LT: 'HH.mm',
+ LTS: 'HH.mm.ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY [pukul] HH.mm',
+ LLLL: 'dddd, D MMMM YYYY [pukul] HH.mm',
+ },
+ meridiemParse: /enjing|siyang|sonten|ndalu/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'enjing') {
+ return hour;
+ } else if (meridiem === 'siyang') {
+ return hour >= 11 ? hour : hour + 12;
+ } else if (meridiem === 'sonten' || meridiem === 'ndalu') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours < 11) {
+ return 'enjing';
+ } else if (hours < 15) {
+ return 'siyang';
+ } else if (hours < 19) {
+ return 'sonten';
+ } else {
+ return 'ndalu';
+ }
+ },
+ calendar: {
+ sameDay: '[Dinten puniko pukul] LT',
+ nextDay: '[Mbenjang pukul] LT',
+ nextWeek: 'dddd [pukul] LT',
+ lastDay: '[Kala wingi pukul] LT',
+ lastWeek: 'dddd [kepengker pukul] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'wonten ing %s',
+ past: '%s ingkang kepengker',
+ s: 'sawetawis detik',
+ ss: '%d detik',
+ m: 'setunggal menit',
+ mm: '%d menit',
+ h: 'setunggal jam',
+ hh: '%d jam',
+ d: 'sedinten',
+ dd: '%d dinten',
+ M: 'sewulan',
+ MM: '%d wulan',
+ y: 'setaun',
+ yy: '%d taun',
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return jv;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ka.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ka.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Georgian [ka]
+//! author : Irakli Janiashvili : https://github.com/IrakliJani
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ka = moment.defineLocale('ka', {
+ months: 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split(
+ '_'
+ ),
+ monthsShort: 'იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ'.split('_'),
+ weekdays: {
+ standalone: 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split(
+ '_'
+ ),
+ format: 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split(
+ '_'
+ ),
+ isFormat: /(წინა|შემდეგ)/,
+ },
+ weekdaysShort: 'კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ'.split('_'),
+ weekdaysMin: 'კვ_ორ_სა_ოთ_ხუ_პა_შა'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[დღეს] LT[-ზე]',
+ nextDay: '[ხვალ] LT[-ზე]',
+ lastDay: '[გუშინ] LT[-ზე]',
+ nextWeek: '[შემდეგ] dddd LT[-ზე]',
+ lastWeek: '[წინა] dddd LT-ზე',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: function (s) {
+ return s.replace(/(წამ|წუთ|საათ|წელ|დღ|თვ)(ი|ე)/, function (
+ $0,
+ $1,
+ $2
+ ) {
+ return $2 === 'ი' ? $1 + 'ში' : $1 + $2 + 'ში';
+ });
+ },
+ past: function (s) {
+ if (/(წამი|წუთი|საათი|დღე|თვე)/.test(s)) {
+ return s.replace(/(ი|ე)$/, 'ის წინ');
+ }
+ if (/წელი/.test(s)) {
+ return s.replace(/წელი$/, 'წლის წინ');
+ }
+ return s;
+ },
+ s: 'რამდენიმე წამი',
+ ss: '%d წამი',
+ m: 'წუთი',
+ mm: '%d წუთი',
+ h: 'საათი',
+ hh: '%d საათი',
+ d: 'დღე',
+ dd: '%d დღე',
+ M: 'თვე',
+ MM: '%d თვე',
+ y: 'წელი',
+ yy: '%d წელი',
+ },
+ dayOfMonthOrdinalParse: /0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,
+ ordinal: function (number) {
+ if (number === 0) {
+ return number;
+ }
+ if (number === 1) {
+ return number + '-ლი';
+ }
+ if (
+ number < 20 ||
+ (number <= 100 && number % 20 === 0) ||
+ number % 100 === 0
+ ) {
+ return 'მე-' + number;
+ }
+ return number + '-ე';
+ },
+ week: {
+ dow: 1,
+ doy: 7,
+ },
+ });
+
+ return ka;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/kk.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/kk.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Kazakh [kk]
+//! authors : Nurlan Rakhimzhanov : https://github.com/nurlan
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var suffixes = {
+ 0: '-ші',
+ 1: '-ші',
+ 2: '-ші',
+ 3: '-ші',
+ 4: '-ші',
+ 5: '-ші',
+ 6: '-шы',
+ 7: '-ші',
+ 8: '-ші',
+ 9: '-шы',
+ 10: '-шы',
+ 20: '-шы',
+ 30: '-шы',
+ 40: '-шы',
+ 50: '-ші',
+ 60: '-шы',
+ 70: '-ші',
+ 80: '-ші',
+ 90: '-шы',
+ 100: '-ші',
+ };
+
+ var kk = moment.defineLocale('kk', {
+ months: 'қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан'.split(
+ '_'
+ ),
+ monthsShort: 'қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел'.split('_'),
+ weekdays: 'жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі'.split(
+ '_'
+ ),
+ weekdaysShort: 'жек_дүй_сей_сәр_бей_жұм_сен'.split('_'),
+ weekdaysMin: 'жк_дй_сй_ср_бй_жм_сн'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Бүгін сағат] LT',
+ nextDay: '[Ертең сағат] LT',
+ nextWeek: 'dddd [сағат] LT',
+ lastDay: '[Кеше сағат] LT',
+ lastWeek: '[Өткен аптаның] dddd [сағат] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s ішінде',
+ past: '%s бұрын',
+ s: 'бірнеше секунд',
+ ss: '%d секунд',
+ m: 'бір минут',
+ mm: '%d минут',
+ h: 'бір сағат',
+ hh: '%d сағат',
+ d: 'бір күн',
+ dd: '%d күн',
+ M: 'бір ай',
+ MM: '%d ай',
+ y: 'бір жыл',
+ yy: '%d жыл',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-(ші|шы)/,
+ ordinal: function (number) {
+ var a = number % 10,
+ b = number >= 100 ? 100 : null;
+ return number + (suffixes[number] || suffixes[a] || suffixes[b]);
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return kk;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/km.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/km.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Cambodian [km]
+//! author : Kruy Vanna : https://github.com/kruyvanna
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '១',
+ 2: '២',
+ 3: '៣',
+ 4: '៤',
+ 5: '៥',
+ 6: '៦',
+ 7: '៧',
+ 8: '៨',
+ 9: '៩',
+ 0: '០',
+ },
+ numberMap = {
+ '១': '1',
+ '២': '2',
+ '៣': '3',
+ '៤': '4',
+ '៥': '5',
+ '៦': '6',
+ '៧': '7',
+ '៨': '8',
+ '៩': '9',
+ '០': '0',
+ };
+
+ var km = moment.defineLocale('km', {
+ months: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split(
+ '_'
+ ),
+ monthsShort: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split(
+ '_'
+ ),
+ weekdays: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
+ weekdaysShort: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
+ weekdaysMin: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /ព្រឹក|ល្ងាច/,
+ isPM: function (input) {
+ return input === 'ល្ងាច';
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'ព្រឹក';
+ } else {
+ return 'ល្ងាច';
+ }
+ },
+ calendar: {
+ sameDay: '[ថ្ងៃនេះ ម៉ោង] LT',
+ nextDay: '[ស្អែក ម៉ោង] LT',
+ nextWeek: 'dddd [ម៉ោង] LT',
+ lastDay: '[ម្សិលមិញ ម៉ោង] LT',
+ lastWeek: 'dddd [សប្តាហ៍មុន] [ម៉ោង] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%sទៀត',
+ past: '%sមុន',
+ s: 'ប៉ុន្មានវិនាទី',
+ ss: '%d វិនាទី',
+ m: 'មួយនាទី',
+ mm: '%d នាទី',
+ h: 'មួយម៉ោង',
+ hh: '%d ម៉ោង',
+ d: 'មួយថ្ងៃ',
+ dd: '%d ថ្ងៃ',
+ M: 'មួយខែ',
+ MM: '%d ខែ',
+ y: 'មួយឆ្នាំ',
+ yy: '%d ឆ្នាំ',
+ },
+ dayOfMonthOrdinalParse: /ទី\d{1,2}/,
+ ordinal: 'ទី%d',
+ preparse: function (string) {
+ return string.replace(/[១២៣៤៥៦៧៨៩០]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return km;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/kn.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/kn.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Kannada [kn]
+//! author : Rajeev Naik : https://github.com/rajeevnaikte
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '೧',
+ 2: '೨',
+ 3: '೩',
+ 4: '೪',
+ 5: '೫',
+ 6: '೬',
+ 7: '೭',
+ 8: '೮',
+ 9: '೯',
+ 0: '೦',
+ },
+ numberMap = {
+ '೧': '1',
+ '೨': '2',
+ '೩': '3',
+ '೪': '4',
+ '೫': '5',
+ '೬': '6',
+ '೭': '7',
+ '೮': '8',
+ '೯': '9',
+ '೦': '0',
+ };
+
+ var kn = moment.defineLocale('kn', {
+ months: 'ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್'.split(
+ '_'
+ ),
+ monthsShort: 'ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂ_ಅಕ್ಟೋ_ನವೆಂ_ಡಿಸೆಂ'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ'.split(
+ '_'
+ ),
+ weekdaysShort: 'ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ'.split('_'),
+ weekdaysMin: 'ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm',
+ LTS: 'A h:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm',
+ },
+ calendar: {
+ sameDay: '[ಇಂದು] LT',
+ nextDay: '[ನಾಳೆ] LT',
+ nextWeek: 'dddd, LT',
+ lastDay: '[ನಿನ್ನೆ] LT',
+ lastWeek: '[ಕೊನೆಯ] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s ನಂತರ',
+ past: '%s ಹಿಂದೆ',
+ s: 'ಕೆಲವು ಕ್ಷಣಗಳು',
+ ss: '%d ಸೆಕೆಂಡುಗಳು',
+ m: 'ಒಂದು ನಿಮಿಷ',
+ mm: '%d ನಿಮಿಷ',
+ h: 'ಒಂದು ಗಂಟೆ',
+ hh: '%d ಗಂಟೆ',
+ d: 'ಒಂದು ದಿನ',
+ dd: '%d ದಿನ',
+ M: 'ಒಂದು ತಿಂಗಳು',
+ MM: '%d ತಿಂಗಳು',
+ y: 'ಒಂದು ವರ್ಷ',
+ yy: '%d ವರ್ಷ',
+ },
+ preparse: function (string) {
+ return string.replace(/[೧೨೩೪೫೬೭೮೯೦]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ meridiemParse: /ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'ರಾತ್ರಿ') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'ಬೆಳಿಗ್ಗೆ') {
+ return hour;
+ } else if (meridiem === 'ಮಧ್ಯಾಹ್ನ') {
+ return hour >= 10 ? hour : hour + 12;
+ } else if (meridiem === 'ಸಂಜೆ') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'ರಾತ್ರಿ';
+ } else if (hour < 10) {
+ return 'ಬೆಳಿಗ್ಗೆ';
+ } else if (hour < 17) {
+ return 'ಮಧ್ಯಾಹ್ನ';
+ } else if (hour < 20) {
+ return 'ಸಂಜೆ';
+ } else {
+ return 'ರಾತ್ರಿ';
+ }
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(ನೇ)/,
+ ordinal: function (number) {
+ return number + 'ನೇ';
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return kn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ko.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ko.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Korean [ko]
+//! author : Kyungwook, Park : https://github.com/kyungw00k
+//! author : Jeeeyul Lee <jeeeyul@gmail.com>
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ko = moment.defineLocale('ko', {
+ months: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
+ monthsShort: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split(
+ '_'
+ ),
+ weekdays: '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
+ weekdaysShort: '일_월_화_수_목_금_토'.split('_'),
+ weekdaysMin: '일_월_화_수_목_금_토'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm',
+ LTS: 'A h:mm:ss',
+ L: 'YYYY.MM.DD.',
+ LL: 'YYYY년 MMMM D일',
+ LLL: 'YYYY년 MMMM D일 A h:mm',
+ LLLL: 'YYYY년 MMMM D일 dddd A h:mm',
+ l: 'YYYY.MM.DD.',
+ ll: 'YYYY년 MMMM D일',
+ lll: 'YYYY년 MMMM D일 A h:mm',
+ llll: 'YYYY년 MMMM D일 dddd A h:mm',
+ },
+ calendar: {
+ sameDay: '오늘 LT',
+ nextDay: '내일 LT',
+ nextWeek: 'dddd LT',
+ lastDay: '어제 LT',
+ lastWeek: '지난주 dddd LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s 후',
+ past: '%s 전',
+ s: '몇 초',
+ ss: '%d초',
+ m: '1분',
+ mm: '%d분',
+ h: '한 시간',
+ hh: '%d시간',
+ d: '하루',
+ dd: '%d일',
+ M: '한 달',
+ MM: '%d달',
+ y: '일 년',
+ yy: '%d년',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(일|월|주)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'd':
+ case 'D':
+ case 'DDD':
+ return number + '일';
+ case 'M':
+ return number + '월';
+ case 'w':
+ case 'W':
+ return number + '주';
+ default:
+ return number;
+ }
+ },
+ meridiemParse: /오전|오후/,
+ isPM: function (token) {
+ return token === '오후';
+ },
+ meridiem: function (hour, minute, isUpper) {
+ return hour < 12 ? '오전' : '오후';
+ },
+ });
+
+ return ko;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ku.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ku.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Kurdish [ku]
+//! author : Shahram Mebashar : https://github.com/ShahramMebashar
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '١',
+ 2: '٢',
+ 3: '٣',
+ 4: '٤',
+ 5: '٥',
+ 6: '٦',
+ 7: '٧',
+ 8: '٨',
+ 9: '٩',
+ 0: '٠',
+ },
+ numberMap = {
+ '١': '1',
+ '٢': '2',
+ '٣': '3',
+ '٤': '4',
+ '٥': '5',
+ '٦': '6',
+ '٧': '7',
+ '٨': '8',
+ '٩': '9',
+ '٠': '0',
+ },
+ months = [
+ 'کانونی دووەم',
+ 'شوبات',
+ 'ئازار',
+ 'نیسان',
+ 'ئایار',
+ 'حوزەیران',
+ 'تەمموز',
+ 'ئاب',
+ 'ئەیلوول',
+ 'تشرینی یەكەم',
+ 'تشرینی دووەم',
+ 'كانونی یەکەم',
+ ];
+
+ var ku = moment.defineLocale('ku', {
+ months: months,
+ monthsShort: months,
+ weekdays: 'یه\200cكشه\200cممه\200c_دووشه\200cممه\200c_سێشه\200cممه\200c_چوارشه\200cممه\200c_پێنجشه\200cممه\200c_هه\200cینی_شه\200cممه\200c'.split(
+ '_'
+ ),
+ weekdaysShort: 'یه\200cكشه\200cم_دووشه\200cم_سێشه\200cم_چوارشه\200cم_پێنجشه\200cم_هه\200cینی_شه\200cممه\200c'.split(
+ '_'
+ ),
+ weekdaysMin: 'ی_د_س_چ_پ_ه_ش'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /ئێواره\200c|به\200cیانی/,
+ isPM: function (input) {
+ return /ئێواره\200c/.test(input);
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'به\200cیانی';
+ } else {
+ return 'ئێواره\200c';
+ }
+ },
+ calendar: {
+ sameDay: '[ئه\200cمرۆ كاتژمێر] LT',
+ nextDay: '[به\200cیانی كاتژمێر] LT',
+ nextWeek: 'dddd [كاتژمێر] LT',
+ lastDay: '[دوێنێ كاتژمێر] LT',
+ lastWeek: 'dddd [كاتژمێر] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'له\200c %s',
+ past: '%s',
+ s: 'چه\200cند چركه\200cیه\200cك',
+ ss: 'چركه\200c %d',
+ m: 'یه\200cك خوله\200cك',
+ mm: '%d خوله\200cك',
+ h: 'یه\200cك كاتژمێر',
+ hh: '%d كاتژمێر',
+ d: 'یه\200cك ڕۆژ',
+ dd: '%d ڕۆژ',
+ M: 'یه\200cك مانگ',
+ MM: '%d مانگ',
+ y: 'یه\200cك ساڵ',
+ yy: '%d ساڵ',
+ },
+ preparse: function (string) {
+ return string
+ .replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
+ return numberMap[match];
+ })
+ .replace(/،/g, ',');
+ },
+ postformat: function (string) {
+ return string
+ .replace(/\d/g, function (match) {
+ return symbolMap[match];
+ })
+ .replace(/,/g, '،');
+ },
+ week: {
+ dow: 6, // Saturday is the first day of the week.
+ doy: 12, // The week that contains Jan 12th is the first week of the year.
+ },
+ });
+
+ return ku;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ky.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ky.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Kyrgyz [ky]
+//! author : Chyngyz Arystan uulu : https://github.com/chyngyz
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var suffixes = {
+ 0: '-чү',
+ 1: '-чи',
+ 2: '-чи',
+ 3: '-чү',
+ 4: '-чү',
+ 5: '-чи',
+ 6: '-чы',
+ 7: '-чи',
+ 8: '-чи',
+ 9: '-чу',
+ 10: '-чу',
+ 20: '-чы',
+ 30: '-чу',
+ 40: '-чы',
+ 50: '-чү',
+ 60: '-чы',
+ 70: '-чи',
+ 80: '-чи',
+ 90: '-чу',
+ 100: '-чү',
+ };
+
+ var ky = moment.defineLocale('ky', {
+ months: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split(
+ '_'
+ ),
+ monthsShort: 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split(
+ '_'
+ ),
+ weekdays: 'Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби'.split(
+ '_'
+ ),
+ weekdaysShort: 'Жек_Дүй_Шей_Шар_Бей_Жум_Ише'.split('_'),
+ weekdaysMin: 'Жк_Дй_Шй_Шр_Бй_Жм_Иш'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Бүгүн саат] LT',
+ nextDay: '[Эртең саат] LT',
+ nextWeek: 'dddd [саат] LT',
+ lastDay: '[Кечээ саат] LT',
+ lastWeek: '[Өткөн аптанын] dddd [күнү] [саат] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s ичинде',
+ past: '%s мурун',
+ s: 'бирнече секунд',
+ ss: '%d секунд',
+ m: 'бир мүнөт',
+ mm: '%d мүнөт',
+ h: 'бир саат',
+ hh: '%d саат',
+ d: 'бир күн',
+ dd: '%d күн',
+ M: 'бир ай',
+ MM: '%d ай',
+ y: 'бир жыл',
+ yy: '%d жыл',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-(чи|чы|чү|чу)/,
+ ordinal: function (number) {
+ var a = number % 10,
+ b = number >= 100 ? 100 : null;
+ return number + (suffixes[number] || suffixes[a] || suffixes[b]);
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return ky;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/lb.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/lb.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Luxembourgish [lb]
+//! author : mweimerskirch : https://github.com/mweimerskirch
+//! author : David Raison : https://github.com/kwisatz
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function processRelativeTime(number, withoutSuffix, key, isFuture) {
+ var format = {
+ m: ['eng Minutt', 'enger Minutt'],
+ h: ['eng Stonn', 'enger Stonn'],
+ d: ['een Dag', 'engem Dag'],
+ M: ['ee Mount', 'engem Mount'],
+ y: ['ee Joer', 'engem Joer'],
+ };
+ return withoutSuffix ? format[key][0] : format[key][1];
+ }
+ function processFutureTime(string) {
+ var number = string.substr(0, string.indexOf(' '));
+ if (eifelerRegelAppliesToNumber(number)) {
+ return 'a ' + string;
+ }
+ return 'an ' + string;
+ }
+ function processPastTime(string) {
+ var number = string.substr(0, string.indexOf(' '));
+ if (eifelerRegelAppliesToNumber(number)) {
+ return 'viru ' + string;
+ }
+ return 'virun ' + string;
+ }
+ /**
+ * Returns true if the word before the given number loses the '-n' ending.
+ * e.g. 'an 10 Deeg' but 'a 5 Deeg'
+ *
+ * @param number {integer}
+ * @returns {boolean}
+ */
+ function eifelerRegelAppliesToNumber(number) {
+ number = parseInt(number, 10);
+ if (isNaN(number)) {
+ return false;
+ }
+ if (number < 0) {
+ // Negative Number --> always true
+ return true;
+ } else if (number < 10) {
+ // Only 1 digit
+ if (4 <= number && number <= 7) {
+ return true;
+ }
+ return false;
+ } else if (number < 100) {
+ // 2 digits
+ var lastDigit = number % 10,
+ firstDigit = number / 10;
+ if (lastDigit === 0) {
+ return eifelerRegelAppliesToNumber(firstDigit);
+ }
+ return eifelerRegelAppliesToNumber(lastDigit);
+ } else if (number < 10000) {
+ // 3 or 4 digits --> recursively check first digit
+ while (number >= 10) {
+ number = number / 10;
+ }
+ return eifelerRegelAppliesToNumber(number);
+ } else {
+ // Anything larger than 4 digits: recursively check first n-3 digits
+ number = number / 1000;
+ return eifelerRegelAppliesToNumber(number);
+ }
+ }
+
+ var lb = moment.defineLocale('lb', {
+ months: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split(
+ '_'
+ ),
+ monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split(
+ '_'
+ ),
+ weekdaysShort: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
+ weekdaysMin: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm [Auer]',
+ LTS: 'H:mm:ss [Auer]',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY H:mm [Auer]',
+ LLLL: 'dddd, D. MMMM YYYY H:mm [Auer]',
+ },
+ calendar: {
+ sameDay: '[Haut um] LT',
+ sameElse: 'L',
+ nextDay: '[Muer um] LT',
+ nextWeek: 'dddd [um] LT',
+ lastDay: '[Gëschter um] LT',
+ lastWeek: function () {
+ // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
+ switch (this.day()) {
+ case 2:
+ case 4:
+ return '[Leschten] dddd [um] LT';
+ default:
+ return '[Leschte] dddd [um] LT';
+ }
+ },
+ },
+ relativeTime: {
+ future: processFutureTime,
+ past: processPastTime,
+ s: 'e puer Sekonnen',
+ ss: '%d Sekonnen',
+ m: processRelativeTime,
+ mm: '%d Minutten',
+ h: processRelativeTime,
+ hh: '%d Stonnen',
+ d: processRelativeTime,
+ dd: '%d Deeg',
+ M: processRelativeTime,
+ MM: '%d Méint',
+ y: processRelativeTime,
+ yy: '%d Joer',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return lb;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/lo.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/lo.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Lao [lo]
+//! author : Ryan Hart : https://github.com/ryanhart2
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var lo = moment.defineLocale('lo', {
+ months: 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split(
+ '_'
+ ),
+ monthsShort: 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split(
+ '_'
+ ),
+ weekdays: 'ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
+ weekdaysShort: 'ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
+ weekdaysMin: 'ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'ວັນdddd D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /ຕອນເຊົ້າ|ຕອນແລງ/,
+ isPM: function (input) {
+ return input === 'ຕອນແລງ';
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'ຕອນເຊົ້າ';
+ } else {
+ return 'ຕອນແລງ';
+ }
+ },
+ calendar: {
+ sameDay: '[ມື້ນີ້ເວລາ] LT',
+ nextDay: '[ມື້ອື່ນເວລາ] LT',
+ nextWeek: '[ວັນ]dddd[ໜ້າເວລາ] LT',
+ lastDay: '[ມື້ວານນີ້ເວລາ] LT',
+ lastWeek: '[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'ອີກ %s',
+ past: '%sຜ່ານມາ',
+ s: 'ບໍ່ເທົ່າໃດວິນາທີ',
+ ss: '%d ວິນາທີ',
+ m: '1 ນາທີ',
+ mm: '%d ນາທີ',
+ h: '1 ຊົ່ວໂມງ',
+ hh: '%d ຊົ່ວໂມງ',
+ d: '1 ມື້',
+ dd: '%d ມື້',
+ M: '1 ເດືອນ',
+ MM: '%d ເດືອນ',
+ y: '1 ປີ',
+ yy: '%d ປີ',
+ },
+ dayOfMonthOrdinalParse: /(ທີ່)\d{1,2}/,
+ ordinal: function (number) {
+ return 'ທີ່' + number;
+ },
+ });
+
+ return lo;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/lt.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/lt.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Lithuanian [lt]
+//! author : Mindaugas Mozūras : https://github.com/mmozuras
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var units = {
+ ss: 'sekundė_sekundžių_sekundes',
+ m: 'minutė_minutės_minutę',
+ mm: 'minutės_minučių_minutes',
+ h: 'valanda_valandos_valandą',
+ hh: 'valandos_valandų_valandas',
+ d: 'diena_dienos_dieną',
+ dd: 'dienos_dienų_dienas',
+ M: 'mėnuo_mėnesio_mėnesį',
+ MM: 'mėnesiai_mėnesių_mėnesius',
+ y: 'metai_metų_metus',
+ yy: 'metai_metų_metus',
+ };
+ function translateSeconds(number, withoutSuffix, key, isFuture) {
+ if (withoutSuffix) {
+ return 'kelios sekundės';
+ } else {
+ return isFuture ? 'kelių sekundžių' : 'kelias sekundes';
+ }
+ }
+ function translateSingular(number, withoutSuffix, key, isFuture) {
+ return withoutSuffix
+ ? forms(key)[0]
+ : isFuture
+ ? forms(key)[1]
+ : forms(key)[2];
+ }
+ function special(number) {
+ return number % 10 === 0 || (number > 10 && number < 20);
+ }
+ function forms(key) {
+ return units[key].split('_');
+ }
+ function translate(number, withoutSuffix, key, isFuture) {
+ var result = number + ' ';
+ if (number === 1) {
+ return (
+ result + translateSingular(number, withoutSuffix, key[0], isFuture)
+ );
+ } else if (withoutSuffix) {
+ return result + (special(number) ? forms(key)[1] : forms(key)[0]);
+ } else {
+ if (isFuture) {
+ return result + forms(key)[1];
+ } else {
+ return result + (special(number) ? forms(key)[1] : forms(key)[2]);
+ }
+ }
+ }
+ var lt = moment.defineLocale('lt', {
+ months: {
+ format: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split(
+ '_'
+ ),
+ standalone: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split(
+ '_'
+ ),
+ isFormat: /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/,
+ },
+ monthsShort: 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
+ weekdays: {
+ format: 'sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį'.split(
+ '_'
+ ),
+ standalone: 'sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis'.split(
+ '_'
+ ),
+ isFormat: /dddd HH:mm/,
+ },
+ weekdaysShort: 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
+ weekdaysMin: 'S_P_A_T_K_Pn_Š'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY-MM-DD',
+ LL: 'YYYY [m.] MMMM D [d.]',
+ LLL: 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
+ LLLL: 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
+ l: 'YYYY-MM-DD',
+ ll: 'YYYY [m.] MMMM D [d.]',
+ lll: 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
+ llll: 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]',
+ },
+ calendar: {
+ sameDay: '[Šiandien] LT',
+ nextDay: '[Rytoj] LT',
+ nextWeek: 'dddd LT',
+ lastDay: '[Vakar] LT',
+ lastWeek: '[Praėjusį] dddd LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'po %s',
+ past: 'prieš %s',
+ s: translateSeconds,
+ ss: translate,
+ m: translateSingular,
+ mm: translate,
+ h: translateSingular,
+ hh: translate,
+ d: translateSingular,
+ dd: translate,
+ M: translateSingular,
+ MM: translate,
+ y: translateSingular,
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-oji/,
+ ordinal: function (number) {
+ return number + '-oji';
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return lt;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/lv.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/lv.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Latvian [lv]
+//! author : Kristaps Karlsons : https://github.com/skakri
+//! author : Jānis Elmeris : https://github.com/JanisE
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var units = {
+ ss: 'sekundes_sekundēm_sekunde_sekundes'.split('_'),
+ m: 'minūtes_minūtēm_minūte_minūtes'.split('_'),
+ mm: 'minūtes_minūtēm_minūte_minūtes'.split('_'),
+ h: 'stundas_stundām_stunda_stundas'.split('_'),
+ hh: 'stundas_stundām_stunda_stundas'.split('_'),
+ d: 'dienas_dienām_diena_dienas'.split('_'),
+ dd: 'dienas_dienām_diena_dienas'.split('_'),
+ M: 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
+ MM: 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
+ y: 'gada_gadiem_gads_gadi'.split('_'),
+ yy: 'gada_gadiem_gads_gadi'.split('_'),
+ };
+ /**
+ * @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
+ */
+ function format(forms, number, withoutSuffix) {
+ if (withoutSuffix) {
+ // E.g. "21 minūte", "3 minūtes".
+ return number % 10 === 1 && number % 100 !== 11 ? forms[2] : forms[3];
+ } else {
+ // E.g. "21 minūtes" as in "pēc 21 minūtes".
+ // E.g. "3 minūtēm" as in "pēc 3 minūtēm".
+ return number % 10 === 1 && number % 100 !== 11 ? forms[0] : forms[1];
+ }
+ }
+ function relativeTimeWithPlural(number, withoutSuffix, key) {
+ return number + ' ' + format(units[key], number, withoutSuffix);
+ }
+ function relativeTimeWithSingular(number, withoutSuffix, key) {
+ return format(units[key], number, withoutSuffix);
+ }
+ function relativeSeconds(number, withoutSuffix) {
+ return withoutSuffix ? 'dažas sekundes' : 'dažām sekundēm';
+ }
+
+ var lv = moment.defineLocale('lv', {
+ months: 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split(
+ '_'
+ ),
+ monthsShort: 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
+ weekdays: 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split(
+ '_'
+ ),
+ weekdaysShort: 'Sv_P_O_T_C_Pk_S'.split('_'),
+ weekdaysMin: 'Sv_P_O_T_C_Pk_S'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY.',
+ LL: 'YYYY. [gada] D. MMMM',
+ LLL: 'YYYY. [gada] D. MMMM, HH:mm',
+ LLLL: 'YYYY. [gada] D. MMMM, dddd, HH:mm',
+ },
+ calendar: {
+ sameDay: '[Šodien pulksten] LT',
+ nextDay: '[Rīt pulksten] LT',
+ nextWeek: 'dddd [pulksten] LT',
+ lastDay: '[Vakar pulksten] LT',
+ lastWeek: '[Pagājušā] dddd [pulksten] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'pēc %s',
+ past: 'pirms %s',
+ s: relativeSeconds,
+ ss: relativeTimeWithPlural,
+ m: relativeTimeWithSingular,
+ mm: relativeTimeWithPlural,
+ h: relativeTimeWithSingular,
+ hh: relativeTimeWithPlural,
+ d: relativeTimeWithSingular,
+ dd: relativeTimeWithPlural,
+ M: relativeTimeWithSingular,
+ MM: relativeTimeWithPlural,
+ y: relativeTimeWithSingular,
+ yy: relativeTimeWithPlural,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return lv;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/me.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/me.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Montenegrin [me]
+//! author : Miodrag Nikač <miodrag@restartit.me> : https://github.com/miodragnikac
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var translator = {
+ words: {
+ //Different grammatical cases
+ ss: ['sekund', 'sekunda', 'sekundi'],
+ m: ['jedan minut', 'jednog minuta'],
+ mm: ['minut', 'minuta', 'minuta'],
+ h: ['jedan sat', 'jednog sata'],
+ hh: ['sat', 'sata', 'sati'],
+ dd: ['dan', 'dana', 'dana'],
+ MM: ['mjesec', 'mjeseca', 'mjeseci'],
+ yy: ['godina', 'godine', 'godina'],
+ },
+ correctGrammaticalCase: function (number, wordKey) {
+ return number === 1
+ ? wordKey[0]
+ : number >= 2 && number <= 4
+ ? wordKey[1]
+ : wordKey[2];
+ },
+ translate: function (number, withoutSuffix, key) {
+ var wordKey = translator.words[key];
+ if (key.length === 1) {
+ return withoutSuffix ? wordKey[0] : wordKey[1];
+ } else {
+ return (
+ number +
+ ' ' +
+ translator.correctGrammaticalCase(number, wordKey)
+ );
+ }
+ },
+ };
+
+ var me = moment.defineLocale('me', {
+ months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split(
+ '_'
+ ),
+ monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split(
+ '_'
+ ),
+ weekdaysShort: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
+ weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY H:mm',
+ LLLL: 'dddd, D. MMMM YYYY H:mm',
+ },
+ calendar: {
+ sameDay: '[danas u] LT',
+ nextDay: '[sjutra u] LT',
+
+ nextWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[u] [nedjelju] [u] LT';
+ case 3:
+ return '[u] [srijedu] [u] LT';
+ case 6:
+ return '[u] [subotu] [u] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[u] dddd [u] LT';
+ }
+ },
+ lastDay: '[juče u] LT',
+ lastWeek: function () {
+ var lastWeekDays = [
+ '[prošle] [nedjelje] [u] LT',
+ '[prošlog] [ponedjeljka] [u] LT',
+ '[prošlog] [utorka] [u] LT',
+ '[prošle] [srijede] [u] LT',
+ '[prošlog] [četvrtka] [u] LT',
+ '[prošlog] [petka] [u] LT',
+ '[prošle] [subote] [u] LT',
+ ];
+ return lastWeekDays[this.day()];
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'za %s',
+ past: 'prije %s',
+ s: 'nekoliko sekundi',
+ ss: translator.translate,
+ m: translator.translate,
+ mm: translator.translate,
+ h: translator.translate,
+ hh: translator.translate,
+ d: 'dan',
+ dd: translator.translate,
+ M: 'mjesec',
+ MM: translator.translate,
+ y: 'godinu',
+ yy: translator.translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return me;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/mi.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/mi.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Maori [mi]
+//! author : John Corrigan <robbiecloset@gmail.com> : https://github.com/johnideal
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var mi = moment.defineLocale('mi', {
+ months: 'Kohi-tāte_Hui-tanguru_Poutū-te-rangi_Paenga-whāwhā_Haratua_Pipiri_Hōngoingoi_Here-turi-kōkā_Mahuru_Whiringa-ā-nuku_Whiringa-ā-rangi_Hakihea'.split(
+ '_'
+ ),
+ monthsShort: 'Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki'.split(
+ '_'
+ ),
+ monthsRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
+ monthsStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
+ monthsShortRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
+ monthsShortStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,
+ weekdays: 'Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei'.split('_'),
+ weekdaysShort: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
+ weekdaysMin: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY [i] HH:mm',
+ LLLL: 'dddd, D MMMM YYYY [i] HH:mm',
+ },
+ calendar: {
+ sameDay: '[i teie mahana, i] LT',
+ nextDay: '[apopo i] LT',
+ nextWeek: 'dddd [i] LT',
+ lastDay: '[inanahi i] LT',
+ lastWeek: 'dddd [whakamutunga i] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'i roto i %s',
+ past: '%s i mua',
+ s: 'te hēkona ruarua',
+ ss: '%d hēkona',
+ m: 'he meneti',
+ mm: '%d meneti',
+ h: 'te haora',
+ hh: '%d haora',
+ d: 'he ra',
+ dd: '%d ra',
+ M: 'he marama',
+ MM: '%d marama',
+ y: 'he tau',
+ yy: '%d tau',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return mi;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/mk.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/mk.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Macedonian [mk]
+//! author : Borislav Mickov : https://github.com/B0k0
+//! author : Sashko Todorov : https://github.com/bkyceh
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var mk = moment.defineLocale('mk', {
+ months: 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split(
+ '_'
+ ),
+ monthsShort: 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
+ weekdays: 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split(
+ '_'
+ ),
+ weekdaysShort: 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
+ weekdaysMin: 'нe_пo_вт_ср_че_пе_сa'.split('_'),
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'D.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY H:mm',
+ LLLL: 'dddd, D MMMM YYYY H:mm',
+ },
+ calendar: {
+ sameDay: '[Денес во] LT',
+ nextDay: '[Утре во] LT',
+ nextWeek: '[Во] dddd [во] LT',
+ lastDay: '[Вчера во] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ case 3:
+ case 6:
+ return '[Изминатата] dddd [во] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[Изминатиот] dddd [во] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'за %s',
+ past: 'пред %s',
+ s: 'неколку секунди',
+ ss: '%d секунди',
+ m: 'една минута',
+ mm: '%d минути',
+ h: 'еден час',
+ hh: '%d часа',
+ d: 'еден ден',
+ dd: '%d дена',
+ M: 'еден месец',
+ MM: '%d месеци',
+ y: 'една година',
+ yy: '%d години',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
+ ordinal: function (number) {
+ var lastDigit = number % 10,
+ last2Digits = number % 100;
+ if (number === 0) {
+ return number + '-ев';
+ } else if (last2Digits === 0) {
+ return number + '-ен';
+ } else if (last2Digits > 10 && last2Digits < 20) {
+ return number + '-ти';
+ } else if (lastDigit === 1) {
+ return number + '-ви';
+ } else if (lastDigit === 2) {
+ return number + '-ри';
+ } else if (lastDigit === 7 || lastDigit === 8) {
+ return number + '-ми';
+ } else {
+ return number + '-ти';
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return mk;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ml.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ml.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Malayalam [ml]
+//! author : Floyd Pink : https://github.com/floydpink
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ml = moment.defineLocale('ml', {
+ months: 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split(
+ '_'
+ ),
+ monthsShort: 'ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച'.split(
+ '_'
+ ),
+ weekdaysShort: 'ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി'.split('_'),
+ weekdaysMin: 'ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm -നു',
+ LTS: 'A h:mm:ss -നു',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm -നു',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm -നു',
+ },
+ calendar: {
+ sameDay: '[ഇന്ന്] LT',
+ nextDay: '[നാളെ] LT',
+ nextWeek: 'dddd, LT',
+ lastDay: '[ഇന്നലെ] LT',
+ lastWeek: '[കഴിഞ്ഞ] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s കഴിഞ്ഞ്',
+ past: '%s മുൻപ്',
+ s: 'അൽപ നിമിഷങ്ങൾ',
+ ss: '%d സെക്കൻഡ്',
+ m: 'ഒരു മിനിറ്റ്',
+ mm: '%d മിനിറ്റ്',
+ h: 'ഒരു മണിക്കൂർ',
+ hh: '%d മണിക്കൂർ',
+ d: 'ഒരു ദിവസം',
+ dd: '%d ദിവസം',
+ M: 'ഒരു മാസം',
+ MM: '%d മാസം',
+ y: 'ഒരു വർഷം',
+ yy: '%d വർഷം',
+ },
+ meridiemParse: /രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (
+ (meridiem === 'രാത്രി' && hour >= 4) ||
+ meridiem === 'ഉച്ച കഴിഞ്ഞ്' ||
+ meridiem === 'വൈകുന്നേരം'
+ ) {
+ return hour + 12;
+ } else {
+ return hour;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'രാത്രി';
+ } else if (hour < 12) {
+ return 'രാവിലെ';
+ } else if (hour < 17) {
+ return 'ഉച്ച കഴിഞ്ഞ്';
+ } else if (hour < 20) {
+ return 'വൈകുന്നേരം';
+ } else {
+ return 'രാത്രി';
+ }
+ },
+ });
+
+ return ml;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/mn.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/mn.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Mongolian [mn]
+//! author : Javkhlantugs Nyamdorj : https://github.com/javkhaanj7
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function translate(number, withoutSuffix, key, isFuture) {
+ switch (key) {
+ case 's':
+ return withoutSuffix ? 'хэдхэн секунд' : 'хэдхэн секундын';
+ case 'ss':
+ return number + (withoutSuffix ? ' секунд' : ' секундын');
+ case 'm':
+ case 'mm':
+ return number + (withoutSuffix ? ' минут' : ' минутын');
+ case 'h':
+ case 'hh':
+ return number + (withoutSuffix ? ' цаг' : ' цагийн');
+ case 'd':
+ case 'dd':
+ return number + (withoutSuffix ? ' өдөр' : ' өдрийн');
+ case 'M':
+ case 'MM':
+ return number + (withoutSuffix ? ' сар' : ' сарын');
+ case 'y':
+ case 'yy':
+ return number + (withoutSuffix ? ' жил' : ' жилийн');
+ default:
+ return number;
+ }
+ }
+
+ var mn = moment.defineLocale('mn', {
+ months: 'Нэгдүгээр сар_Хоёрдугаар сар_Гуравдугаар сар_Дөрөвдүгээр сар_Тавдугаар сар_Зургадугаар сар_Долдугаар сар_Наймдугаар сар_Есдүгээр сар_Аравдугаар сар_Арван нэгдүгээр сар_Арван хоёрдугаар сар'.split(
+ '_'
+ ),
+ monthsShort: '1 сар_2 сар_3 сар_4 сар_5 сар_6 сар_7 сар_8 сар_9 сар_10 сар_11 сар_12 сар'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'Ням_Даваа_Мягмар_Лхагва_Пүрэв_Баасан_Бямба'.split('_'),
+ weekdaysShort: 'Ням_Дав_Мяг_Лха_Пүр_Баа_Бям'.split('_'),
+ weekdaysMin: 'Ня_Да_Мя_Лх_Пү_Ба_Бя'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY-MM-DD',
+ LL: 'YYYY оны MMMMын D',
+ LLL: 'YYYY оны MMMMын D HH:mm',
+ LLLL: 'dddd, YYYY оны MMMMын D HH:mm',
+ },
+ meridiemParse: /ҮӨ|ҮХ/i,
+ isPM: function (input) {
+ return input === 'ҮХ';
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'ҮӨ';
+ } else {
+ return 'ҮХ';
+ }
+ },
+ calendar: {
+ sameDay: '[Өнөөдөр] LT',
+ nextDay: '[Маргааш] LT',
+ nextWeek: '[Ирэх] dddd LT',
+ lastDay: '[Өчигдөр] LT',
+ lastWeek: '[Өнгөрсөн] dddd LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s дараа',
+ past: '%s өмнө',
+ s: translate,
+ ss: translate,
+ m: translate,
+ mm: translate,
+ h: translate,
+ hh: translate,
+ d: translate,
+ dd: translate,
+ M: translate,
+ MM: translate,
+ y: translate,
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2} өдөр/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'd':
+ case 'D':
+ case 'DDD':
+ return number + ' өдөр';
+ default:
+ return number;
+ }
+ },
+ });
+
+ return mn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/mr.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/mr.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Marathi [mr]
+//! author : Harshad Kale : https://github.com/kalehv
+//! author : Vivek Athalye : https://github.com/vnathalye
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '१',
+ 2: '२',
+ 3: '३',
+ 4: '४',
+ 5: '५',
+ 6: '६',
+ 7: '७',
+ 8: '८',
+ 9: '९',
+ 0: '०',
+ },
+ numberMap = {
+ '१': '1',
+ '२': '2',
+ '३': '3',
+ '४': '4',
+ '५': '5',
+ '६': '6',
+ '७': '7',
+ '८': '8',
+ '९': '9',
+ '०': '0',
+ };
+
+ function relativeTimeMr(number, withoutSuffix, string, isFuture) {
+ var output = '';
+ if (withoutSuffix) {
+ switch (string) {
+ case 's':
+ output = 'काही सेकंद';
+ break;
+ case 'ss':
+ output = '%d सेकंद';
+ break;
+ case 'm':
+ output = 'एक मिनिट';
+ break;
+ case 'mm':
+ output = '%d मिनिटे';
+ break;
+ case 'h':
+ output = 'एक तास';
+ break;
+ case 'hh':
+ output = '%d तास';
+ break;
+ case 'd':
+ output = 'एक दिवस';
+ break;
+ case 'dd':
+ output = '%d दिवस';
+ break;
+ case 'M':
+ output = 'एक महिना';
+ break;
+ case 'MM':
+ output = '%d महिने';
+ break;
+ case 'y':
+ output = 'एक वर्ष';
+ break;
+ case 'yy':
+ output = '%d वर्षे';
+ break;
+ }
+ } else {
+ switch (string) {
+ case 's':
+ output = 'काही सेकंदां';
+ break;
+ case 'ss':
+ output = '%d सेकंदां';
+ break;
+ case 'm':
+ output = 'एका मिनिटा';
+ break;
+ case 'mm':
+ output = '%d मिनिटां';
+ break;
+ case 'h':
+ output = 'एका तासा';
+ break;
+ case 'hh':
+ output = '%d तासां';
+ break;
+ case 'd':
+ output = 'एका दिवसा';
+ break;
+ case 'dd':
+ output = '%d दिवसां';
+ break;
+ case 'M':
+ output = 'एका महिन्या';
+ break;
+ case 'MM':
+ output = '%d महिन्यां';
+ break;
+ case 'y':
+ output = 'एका वर्षा';
+ break;
+ case 'yy':
+ output = '%d वर्षां';
+ break;
+ }
+ }
+ return output.replace(/%d/i, number);
+ }
+
+ var mr = moment.defineLocale('mr', {
+ months: 'जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split(
+ '_'
+ ),
+ monthsShort: 'जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
+ weekdaysShort: 'रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि'.split('_'),
+ weekdaysMin: 'र_सो_मं_बु_गु_शु_श'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm वाजता',
+ LTS: 'A h:mm:ss वाजता',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm वाजता',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm वाजता',
+ },
+ calendar: {
+ sameDay: '[आज] LT',
+ nextDay: '[उद्या] LT',
+ nextWeek: 'dddd, LT',
+ lastDay: '[काल] LT',
+ lastWeek: '[मागील] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%sमध्ये',
+ past: '%sपूर्वी',
+ s: relativeTimeMr,
+ ss: relativeTimeMr,
+ m: relativeTimeMr,
+ mm: relativeTimeMr,
+ h: relativeTimeMr,
+ hh: relativeTimeMr,
+ d: relativeTimeMr,
+ dd: relativeTimeMr,
+ M: relativeTimeMr,
+ MM: relativeTimeMr,
+ y: relativeTimeMr,
+ yy: relativeTimeMr,
+ },
+ preparse: function (string) {
+ return string.replace(/[१२३४५६७८९०]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ meridiemParse: /पहाटे|सकाळी|दुपारी|सायंकाळी|रात्री/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'पहाटे' || meridiem === 'सकाळी') {
+ return hour;
+ } else if (
+ meridiem === 'दुपारी' ||
+ meridiem === 'सायंकाळी' ||
+ meridiem === 'रात्री'
+ ) {
+ return hour >= 12 ? hour : hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour >= 0 && hour < 6) {
+ return 'पहाटे';
+ } else if (hour < 12) {
+ return 'सकाळी';
+ } else if (hour < 17) {
+ return 'दुपारी';
+ } else if (hour < 20) {
+ return 'सायंकाळी';
+ } else {
+ return 'रात्री';
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return mr;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ms-my.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/ms-my.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Malay [ms-my]
+//! note : DEPRECATED, the correct one is [ms]
+//! author : Weldan Jamili : https://github.com/weldan
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var msMy = moment.defineLocale('ms-my', {
+ months: 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
+ weekdays: 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
+ weekdaysShort: 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
+ weekdaysMin: 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
+ longDateFormat: {
+ LT: 'HH.mm',
+ LTS: 'HH.mm.ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY [pukul] HH.mm',
+ LLLL: 'dddd, D MMMM YYYY [pukul] HH.mm',
+ },
+ meridiemParse: /pagi|tengahari|petang|malam/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'pagi') {
+ return hour;
+ } else if (meridiem === 'tengahari') {
+ return hour >= 11 ? hour : hour + 12;
+ } else if (meridiem === 'petang' || meridiem === 'malam') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours < 11) {
+ return 'pagi';
+ } else if (hours < 15) {
+ return 'tengahari';
+ } else if (hours < 19) {
+ return 'petang';
+ } else {
+ return 'malam';
+ }
+ },
+ calendar: {
+ sameDay: '[Hari ini pukul] LT',
+ nextDay: '[Esok pukul] LT',
+ nextWeek: 'dddd [pukul] LT',
+ lastDay: '[Kelmarin pukul] LT',
+ lastWeek: 'dddd [lepas pukul] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'dalam %s',
+ past: '%s yang lepas',
+ s: 'beberapa saat',
+ ss: '%d saat',
+ m: 'seminit',
+ mm: '%d minit',
+ h: 'sejam',
+ hh: '%d jam',
+ d: 'sehari',
+ dd: '%d hari',
+ M: 'sebulan',
+ MM: '%d bulan',
+ y: 'setahun',
+ yy: '%d tahun',
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return msMy;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ms.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ms.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Malay [ms]
+//! author : Weldan Jamili : https://github.com/weldan
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ms = moment.defineLocale('ms', {
+ months: 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
+ weekdays: 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
+ weekdaysShort: 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
+ weekdaysMin: 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
+ longDateFormat: {
+ LT: 'HH.mm',
+ LTS: 'HH.mm.ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY [pukul] HH.mm',
+ LLLL: 'dddd, D MMMM YYYY [pukul] HH.mm',
+ },
+ meridiemParse: /pagi|tengahari|petang|malam/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'pagi') {
+ return hour;
+ } else if (meridiem === 'tengahari') {
+ return hour >= 11 ? hour : hour + 12;
+ } else if (meridiem === 'petang' || meridiem === 'malam') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours < 11) {
+ return 'pagi';
+ } else if (hours < 15) {
+ return 'tengahari';
+ } else if (hours < 19) {
+ return 'petang';
+ } else {
+ return 'malam';
+ }
+ },
+ calendar: {
+ sameDay: '[Hari ini pukul] LT',
+ nextDay: '[Esok pukul] LT',
+ nextWeek: 'dddd [pukul] LT',
+ lastDay: '[Kelmarin pukul] LT',
+ lastWeek: 'dddd [lepas pukul] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'dalam %s',
+ past: '%s yang lepas',
+ s: 'beberapa saat',
+ ss: '%d saat',
+ m: 'seminit',
+ mm: '%d minit',
+ h: 'sejam',
+ hh: '%d jam',
+ d: 'sehari',
+ dd: '%d hari',
+ M: 'sebulan',
+ MM: '%d bulan',
+ y: 'setahun',
+ yy: '%d tahun',
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return ms;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/mt.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/mt.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Maltese (Malta) [mt]
+//! author : Alessandro Maruccia : https://github.com/alesma
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var mt = moment.defineLocale('mt', {
+ months: 'Jannar_Frar_Marzu_April_Mejju_Ġunju_Lulju_Awwissu_Settembru_Ottubru_Novembru_Diċembru'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Fra_Mar_Apr_Mej_Ġun_Lul_Aww_Set_Ott_Nov_Diċ'.split('_'),
+ weekdays: 'Il-Ħadd_It-Tnejn_It-Tlieta_L-Erbgħa_Il-Ħamis_Il-Ġimgħa_Is-Sibt'.split(
+ '_'
+ ),
+ weekdaysShort: 'Ħad_Tne_Tli_Erb_Ħam_Ġim_Sib'.split('_'),
+ weekdaysMin: 'Ħa_Tn_Tl_Er_Ħa_Ġi_Si'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Illum fil-]LT',
+ nextDay: '[Għada fil-]LT',
+ nextWeek: 'dddd [fil-]LT',
+ lastDay: '[Il-bieraħ fil-]LT',
+ lastWeek: 'dddd [li għadda] [fil-]LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'f’ %s',
+ past: '%s ilu',
+ s: 'ftit sekondi',
+ ss: '%d sekondi',
+ m: 'minuta',
+ mm: '%d minuti',
+ h: 'siegħa',
+ hh: '%d siegħat',
+ d: 'ġurnata',
+ dd: '%d ġranet',
+ M: 'xahar',
+ MM: '%d xhur',
+ y: 'sena',
+ yy: '%d sni',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return mt;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/my.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/my.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Burmese [my]
+//! author : Squar team, mysquar.com
+//! author : David Rossellat : https://github.com/gholadr
+//! author : Tin Aung Lin : https://github.com/thanyawzinmin
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '၁',
+ 2: '၂',
+ 3: '၃',
+ 4: '၄',
+ 5: '၅',
+ 6: '၆',
+ 7: '၇',
+ 8: '၈',
+ 9: '၉',
+ 0: '၀',
+ },
+ numberMap = {
+ '၁': '1',
+ '၂': '2',
+ '၃': '3',
+ '၄': '4',
+ '၅': '5',
+ '၆': '6',
+ '၇': '7',
+ '၈': '8',
+ '၉': '9',
+ '၀': '0',
+ };
+
+ var my = moment.defineLocale('my', {
+ months: 'ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ'.split(
+ '_'
+ ),
+ monthsShort: 'ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ'.split('_'),
+ weekdays: 'တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ'.split(
+ '_'
+ ),
+ weekdaysShort: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
+ weekdaysMin: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
+
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[ယနေ.] LT [မှာ]',
+ nextDay: '[မနက်ဖြန်] LT [မှာ]',
+ nextWeek: 'dddd LT [မှာ]',
+ lastDay: '[မနေ.က] LT [မှာ]',
+ lastWeek: '[ပြီးခဲ့သော] dddd LT [မှာ]',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'လာမည့် %s မှာ',
+ past: 'လွန်ခဲ့သော %s က',
+ s: 'စက္ကန်.အနည်းငယ်',
+ ss: '%d စက္ကန့်',
+ m: 'တစ်မိနစ်',
+ mm: '%d မိနစ်',
+ h: 'တစ်နာရီ',
+ hh: '%d နာရီ',
+ d: 'တစ်ရက်',
+ dd: '%d ရက်',
+ M: 'တစ်လ',
+ MM: '%d လ',
+ y: 'တစ်နှစ်',
+ yy: '%d နှစ်',
+ },
+ preparse: function (string) {
+ return string.replace(/[၁၂၃၄၅၆၇၈၉၀]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return my;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/nb.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/nb.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Norwegian Bokmål [nb]
+//! authors : Espen Hovlandsdal : https://github.com/rexxars
+//! Sigurd Gartmann : https://github.com/sigurdga
+//! Stephen Ramthun : https://github.com/stephenramthun
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var nb = moment.defineLocale('nb', {
+ months: 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split(
+ '_'
+ ),
+ monthsShort: 'jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
+ weekdaysShort: 'sø._ma._ti._on._to._fr._lø.'.split('_'),
+ weekdaysMin: 'sø_ma_ti_on_to_fr_lø'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY [kl.] HH:mm',
+ LLLL: 'dddd D. MMMM YYYY [kl.] HH:mm',
+ },
+ calendar: {
+ sameDay: '[i dag kl.] LT',
+ nextDay: '[i morgen kl.] LT',
+ nextWeek: 'dddd [kl.] LT',
+ lastDay: '[i går kl.] LT',
+ lastWeek: '[forrige] dddd [kl.] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'om %s',
+ past: '%s siden',
+ s: 'noen sekunder',
+ ss: '%d sekunder',
+ m: 'ett minutt',
+ mm: '%d minutter',
+ h: 'en time',
+ hh: '%d timer',
+ d: 'en dag',
+ dd: '%d dager',
+ w: 'en uke',
+ ww: '%d uker',
+ M: 'en måned',
+ MM: '%d måneder',
+ y: 'ett år',
+ yy: '%d år',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return nb;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ne.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ne.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Nepalese [ne]
+//! author : suvash : https://github.com/suvash
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '१',
+ 2: '२',
+ 3: '३',
+ 4: '४',
+ 5: '५',
+ 6: '६',
+ 7: '७',
+ 8: '८',
+ 9: '९',
+ 0: '०',
+ },
+ numberMap = {
+ '१': '1',
+ '२': '2',
+ '३': '3',
+ '४': '4',
+ '५': '5',
+ '६': '6',
+ '७': '7',
+ '८': '8',
+ '९': '9',
+ '०': '0',
+ };
+
+ var ne = moment.defineLocale('ne', {
+ months: 'जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर'.split(
+ '_'
+ ),
+ monthsShort: 'जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार'.split(
+ '_'
+ ),
+ weekdaysShort: 'आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.'.split('_'),
+ weekdaysMin: 'आ._सो._मं._बु._बि._शु._श.'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'Aको h:mm बजे',
+ LTS: 'Aको h:mm:ss बजे',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, Aको h:mm बजे',
+ LLLL: 'dddd, D MMMM YYYY, Aको h:mm बजे',
+ },
+ preparse: function (string) {
+ return string.replace(/[१२३४५६७८९०]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ meridiemParse: /राति|बिहान|दिउँसो|साँझ/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'राति') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'बिहान') {
+ return hour;
+ } else if (meridiem === 'दिउँसो') {
+ return hour >= 10 ? hour : hour + 12;
+ } else if (meridiem === 'साँझ') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 3) {
+ return 'राति';
+ } else if (hour < 12) {
+ return 'बिहान';
+ } else if (hour < 16) {
+ return 'दिउँसो';
+ } else if (hour < 20) {
+ return 'साँझ';
+ } else {
+ return 'राति';
+ }
+ },
+ calendar: {
+ sameDay: '[आज] LT',
+ nextDay: '[भोलि] LT',
+ nextWeek: '[आउँदो] dddd[,] LT',
+ lastDay: '[हिजो] LT',
+ lastWeek: '[गएको] dddd[,] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%sमा',
+ past: '%s अगाडि',
+ s: 'केही क्षण',
+ ss: '%d सेकेण्ड',
+ m: 'एक मिनेट',
+ mm: '%d मिनेट',
+ h: 'एक घण्टा',
+ hh: '%d घण्टा',
+ d: 'एक दिन',
+ dd: '%d दिन',
+ M: 'एक महिना',
+ MM: '%d महिना',
+ y: 'एक बर्ष',
+ yy: '%d बर्ष',
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return ne;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/nl-be.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/nl-be.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Dutch (Belgium) [nl-be]
+//! author : Joris Röling : https://github.com/jorisroling
+//! author : Jacob Middag : https://github.com/middagj
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split(
+ '_'
+ ),
+ monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split(
+ '_'
+ ),
+ monthsParse = [
+ /^jan/i,
+ /^feb/i,
+ /^maart|mrt.?$/i,
+ /^apr/i,
+ /^mei$/i,
+ /^jun[i.]?$/i,
+ /^jul[i.]?$/i,
+ /^aug/i,
+ /^sep/i,
+ /^okt/i,
+ /^nov/i,
+ /^dec/i,
+ ],
+ monthsRegex = /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
+
+ var nlBe = moment.defineLocale('nl-be', {
+ months: 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split(
+ '_'
+ ),
+ monthsShort: function (m, format) {
+ if (!m) {
+ return monthsShortWithDots;
+ } else if (/-MMM-/.test(format)) {
+ return monthsShortWithoutDots[m.month()];
+ } else {
+ return monthsShortWithDots[m.month()];
+ }
+ },
+
+ monthsRegex: monthsRegex,
+ monthsShortRegex: monthsRegex,
+ monthsStrictRegex: /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,
+ monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
+
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+
+ weekdays: 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split(
+ '_'
+ ),
+ weekdaysShort: 'zo._ma._di._wo._do._vr._za.'.split('_'),
+ weekdaysMin: 'zo_ma_di_wo_do_vr_za'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[vandaag om] LT',
+ nextDay: '[morgen om] LT',
+ nextWeek: 'dddd [om] LT',
+ lastDay: '[gisteren om] LT',
+ lastWeek: '[afgelopen] dddd [om] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'over %s',
+ past: '%s geleden',
+ s: 'een paar seconden',
+ ss: '%d seconden',
+ m: 'één minuut',
+ mm: '%d minuten',
+ h: 'één uur',
+ hh: '%d uur',
+ d: 'één dag',
+ dd: '%d dagen',
+ M: 'één maand',
+ MM: '%d maanden',
+ y: 'één jaar',
+ yy: '%d jaar',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
+ ordinal: function (number) {
+ return (
+ number +
+ (number === 1 || number === 8 || number >= 20 ? 'ste' : 'de')
+ );
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return nlBe;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/nl.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/nl.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Dutch [nl]
+//! author : Joris Röling : https://github.com/jorisroling
+//! author : Jacob Middag : https://github.com/middagj
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split(
+ '_'
+ ),
+ monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split(
+ '_'
+ ),
+ monthsParse = [
+ /^jan/i,
+ /^feb/i,
+ /^maart|mrt.?$/i,
+ /^apr/i,
+ /^mei$/i,
+ /^jun[i.]?$/i,
+ /^jul[i.]?$/i,
+ /^aug/i,
+ /^sep/i,
+ /^okt/i,
+ /^nov/i,
+ /^dec/i,
+ ],
+ monthsRegex = /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
+
+ var nl = moment.defineLocale('nl', {
+ months: 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split(
+ '_'
+ ),
+ monthsShort: function (m, format) {
+ if (!m) {
+ return monthsShortWithDots;
+ } else if (/-MMM-/.test(format)) {
+ return monthsShortWithoutDots[m.month()];
+ } else {
+ return monthsShortWithDots[m.month()];
+ }
+ },
+
+ monthsRegex: monthsRegex,
+ monthsShortRegex: monthsRegex,
+ monthsStrictRegex: /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,
+ monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
+
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+
+ weekdays: 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split(
+ '_'
+ ),
+ weekdaysShort: 'zo._ma._di._wo._do._vr._za.'.split('_'),
+ weekdaysMin: 'zo_ma_di_wo_do_vr_za'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD-MM-YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[vandaag om] LT',
+ nextDay: '[morgen om] LT',
+ nextWeek: 'dddd [om] LT',
+ lastDay: '[gisteren om] LT',
+ lastWeek: '[afgelopen] dddd [om] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'over %s',
+ past: '%s geleden',
+ s: 'een paar seconden',
+ ss: '%d seconden',
+ m: 'één minuut',
+ mm: '%d minuten',
+ h: 'één uur',
+ hh: '%d uur',
+ d: 'één dag',
+ dd: '%d dagen',
+ w: 'één week',
+ ww: '%d weken',
+ M: 'één maand',
+ MM: '%d maanden',
+ y: 'één jaar',
+ yy: '%d jaar',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
+ ordinal: function (number) {
+ return (
+ number +
+ (number === 1 || number === 8 || number >= 20 ? 'ste' : 'de')
+ );
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return nl;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/nn.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/nn.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Nynorsk [nn]
+//! authors : https://github.com/mechuwind
+//! Stephen Ramthun : https://github.com/stephenramthun
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var nn = moment.defineLocale('nn', {
+ months: 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split(
+ '_'
+ ),
+ monthsShort: 'jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
+ weekdaysShort: 'su._må._ty._on._to._fr._lau.'.split('_'),
+ weekdaysMin: 'su_må_ty_on_to_fr_la'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY [kl.] H:mm',
+ LLLL: 'dddd D. MMMM YYYY [kl.] HH:mm',
+ },
+ calendar: {
+ sameDay: '[I dag klokka] LT',
+ nextDay: '[I morgon klokka] LT',
+ nextWeek: 'dddd [klokka] LT',
+ lastDay: '[I går klokka] LT',
+ lastWeek: '[Føregåande] dddd [klokka] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'om %s',
+ past: '%s sidan',
+ s: 'nokre sekund',
+ ss: '%d sekund',
+ m: 'eit minutt',
+ mm: '%d minutt',
+ h: 'ein time',
+ hh: '%d timar',
+ d: 'ein dag',
+ dd: '%d dagar',
+ w: 'ei veke',
+ ww: '%d veker',
+ M: 'ein månad',
+ MM: '%d månader',
+ y: 'eit år',
+ yy: '%d år',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return nn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/oc-lnc.js":
+/*!**********************************************!*\
+ !*** ./node_modules/moment/locale/oc-lnc.js ***!
+ \**********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Occitan, lengadocian dialecte [oc-lnc]
+//! author : Quentin PAGÈS : https://github.com/Quenty31
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ocLnc = moment.defineLocale('oc-lnc', {
+ months: {
+ standalone: 'genièr_febrièr_març_abril_mai_junh_julhet_agost_setembre_octòbre_novembre_decembre'.split(
+ '_'
+ ),
+ format: "de genièr_de febrièr_de març_d'abril_de mai_de junh_de julhet_d'agost_de setembre_d'octòbre_de novembre_de decembre".split(
+ '_'
+ ),
+ isFormat: /D[oD]?(\s)+MMMM/,
+ },
+ monthsShort: 'gen._febr._març_abr._mai_junh_julh._ago._set._oct._nov._dec.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'dimenge_diluns_dimars_dimècres_dijòus_divendres_dissabte'.split(
+ '_'
+ ),
+ weekdaysShort: 'dg._dl._dm._dc._dj._dv._ds.'.split('_'),
+ weekdaysMin: 'dg_dl_dm_dc_dj_dv_ds'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM [de] YYYY',
+ ll: 'D MMM YYYY',
+ LLL: 'D MMMM [de] YYYY [a] H:mm',
+ lll: 'D MMM YYYY, H:mm',
+ LLLL: 'dddd D MMMM [de] YYYY [a] H:mm',
+ llll: 'ddd D MMM YYYY, H:mm',
+ },
+ calendar: {
+ sameDay: '[uèi a] LT',
+ nextDay: '[deman a] LT',
+ nextWeek: 'dddd [a] LT',
+ lastDay: '[ièr a] LT',
+ lastWeek: 'dddd [passat a] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: "d'aquí %s",
+ past: 'fa %s',
+ s: 'unas segondas',
+ ss: '%d segondas',
+ m: 'una minuta',
+ mm: '%d minutas',
+ h: 'una ora',
+ hh: '%d oras',
+ d: 'un jorn',
+ dd: '%d jorns',
+ M: 'un mes',
+ MM: '%d meses',
+ y: 'un an',
+ yy: '%d ans',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(r|n|t|è|a)/,
+ ordinal: function (number, period) {
+ var output =
+ number === 1
+ ? 'r'
+ : number === 2
+ ? 'n'
+ : number === 3
+ ? 'r'
+ : number === 4
+ ? 't'
+ : 'è';
+ if (period === 'w' || period === 'W') {
+ output = 'a';
+ }
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4,
+ },
+ });
+
+ return ocLnc;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/pa-in.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/pa-in.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Punjabi (India) [pa-in]
+//! author : Harpreet Singh : https://github.com/harpreetkhalsagtbit
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '੧',
+ 2: '੨',
+ 3: '੩',
+ 4: '੪',
+ 5: '੫',
+ 6: '੬',
+ 7: '੭',
+ 8: '੮',
+ 9: '੯',
+ 0: '੦',
+ },
+ numberMap = {
+ '੧': '1',
+ '੨': '2',
+ '੩': '3',
+ '੪': '4',
+ '੫': '5',
+ '੬': '6',
+ '੭': '7',
+ '੮': '8',
+ '੯': '9',
+ '੦': '0',
+ };
+
+ var paIn = moment.defineLocale('pa-in', {
+ // There are months name as per Nanakshahi Calendar but they are not used as rigidly in modern Punjabi.
+ months: 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split(
+ '_'
+ ),
+ monthsShort: 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split(
+ '_'
+ ),
+ weekdays: 'ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ'.split(
+ '_'
+ ),
+ weekdaysShort: 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
+ weekdaysMin: 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm ਵਜੇ',
+ LTS: 'A h:mm:ss ਵਜੇ',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm ਵਜੇ',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm ਵਜੇ',
+ },
+ calendar: {
+ sameDay: '[ਅਜ] LT',
+ nextDay: '[ਕਲ] LT',
+ nextWeek: '[ਅਗਲਾ] dddd, LT',
+ lastDay: '[ਕਲ] LT',
+ lastWeek: '[ਪਿਛਲੇ] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s ਵਿੱਚ',
+ past: '%s ਪਿਛਲੇ',
+ s: 'ਕੁਝ ਸਕਿੰਟ',
+ ss: '%d ਸਕਿੰਟ',
+ m: 'ਇਕ ਮਿੰਟ',
+ mm: '%d ਮਿੰਟ',
+ h: 'ਇੱਕ ਘੰਟਾ',
+ hh: '%d ਘੰਟੇ',
+ d: 'ਇੱਕ ਦਿਨ',
+ dd: '%d ਦਿਨ',
+ M: 'ਇੱਕ ਮਹੀਨਾ',
+ MM: '%d ਮਹੀਨੇ',
+ y: 'ਇੱਕ ਸਾਲ',
+ yy: '%d ਸਾਲ',
+ },
+ preparse: function (string) {
+ return string.replace(/[੧੨੩੪੫੬੭੮੯੦]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ // Punjabi notation for meridiems are quite fuzzy in practice. While there exists
+ // a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi.
+ meridiemParse: /ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'ਰਾਤ') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'ਸਵੇਰ') {
+ return hour;
+ } else if (meridiem === 'ਦੁਪਹਿਰ') {
+ return hour >= 10 ? hour : hour + 12;
+ } else if (meridiem === 'ਸ਼ਾਮ') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'ਰਾਤ';
+ } else if (hour < 10) {
+ return 'ਸਵੇਰ';
+ } else if (hour < 17) {
+ return 'ਦੁਪਹਿਰ';
+ } else if (hour < 20) {
+ return 'ਸ਼ਾਮ';
+ } else {
+ return 'ਰਾਤ';
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return paIn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/pl.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/pl.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Polish [pl]
+//! author : Rafal Hirsz : https://github.com/evoL
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var monthsNominative = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split(
+ '_'
+ ),
+ monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split(
+ '_'
+ ),
+ monthsParse = [
+ /^sty/i,
+ /^lut/i,
+ /^mar/i,
+ /^kwi/i,
+ /^maj/i,
+ /^cze/i,
+ /^lip/i,
+ /^sie/i,
+ /^wrz/i,
+ /^paź/i,
+ /^lis/i,
+ /^gru/i,
+ ];
+ function plural(n) {
+ return n % 10 < 5 && n % 10 > 1 && ~~(n / 10) % 10 !== 1;
+ }
+ function translate(number, withoutSuffix, key) {
+ var result = number + ' ';
+ switch (key) {
+ case 'ss':
+ return result + (plural(number) ? 'sekundy' : 'sekund');
+ case 'm':
+ return withoutSuffix ? 'minuta' : 'minutę';
+ case 'mm':
+ return result + (plural(number) ? 'minuty' : 'minut');
+ case 'h':
+ return withoutSuffix ? 'godzina' : 'godzinę';
+ case 'hh':
+ return result + (plural(number) ? 'godziny' : 'godzin');
+ case 'ww':
+ return result + (plural(number) ? 'tygodnie' : 'tygodni');
+ case 'MM':
+ return result + (plural(number) ? 'miesiące' : 'miesięcy');
+ case 'yy':
+ return result + (plural(number) ? 'lata' : 'lat');
+ }
+ }
+
+ var pl = moment.defineLocale('pl', {
+ months: function (momentToFormat, format) {
+ if (!momentToFormat) {
+ return monthsNominative;
+ } else if (/D MMMM/.test(format)) {
+ return monthsSubjective[momentToFormat.month()];
+ } else {
+ return monthsNominative[momentToFormat.month()];
+ }
+ },
+ monthsShort: 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+ weekdays: 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split(
+ '_'
+ ),
+ weekdaysShort: 'ndz_pon_wt_śr_czw_pt_sob'.split('_'),
+ weekdaysMin: 'Nd_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Dziś o] LT',
+ nextDay: '[Jutro o] LT',
+ nextWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[W niedzielę o] LT';
+
+ case 2:
+ return '[We wtorek o] LT';
+
+ case 3:
+ return '[W środę o] LT';
+
+ case 6:
+ return '[W sobotę o] LT';
+
+ default:
+ return '[W] dddd [o] LT';
+ }
+ },
+ lastDay: '[Wczoraj o] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[W zeszłą niedzielę o] LT';
+ case 3:
+ return '[W zeszłą środę o] LT';
+ case 6:
+ return '[W zeszłą sobotę o] LT';
+ default:
+ return '[W zeszły] dddd [o] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'za %s',
+ past: '%s temu',
+ s: 'kilka sekund',
+ ss: translate,
+ m: translate,
+ mm: translate,
+ h: translate,
+ hh: translate,
+ d: '1 dzień',
+ dd: '%d dni',
+ w: 'tydzień',
+ ww: translate,
+ M: 'miesiąc',
+ MM: translate,
+ y: 'rok',
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return pl;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/pt-br.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/pt-br.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Portuguese (Brazil) [pt-br]
+//! author : Caio Ribeiro Pereira : https://github.com/caio-ribeiro-pereira
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ptBr = moment.defineLocale('pt-br', {
+ months: 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split(
+ '_'
+ ),
+ monthsShort: 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
+ weekdays: 'domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado'.split(
+ '_'
+ ),
+ weekdaysShort: 'dom_seg_ter_qua_qui_sex_sáb'.split('_'),
+ weekdaysMin: 'do_2ª_3ª_4ª_5ª_6ª_sá'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D [de] MMMM [de] YYYY',
+ LLL: 'D [de] MMMM [de] YYYY [às] HH:mm',
+ LLLL: 'dddd, D [de] MMMM [de] YYYY [às] HH:mm',
+ },
+ calendar: {
+ sameDay: '[Hoje às] LT',
+ nextDay: '[Amanhã às] LT',
+ nextWeek: 'dddd [às] LT',
+ lastDay: '[Ontem às] LT',
+ lastWeek: function () {
+ return this.day() === 0 || this.day() === 6
+ ? '[Último] dddd [às] LT' // Saturday + Sunday
+ : '[Última] dddd [às] LT'; // Monday - Friday
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'em %s',
+ past: 'há %s',
+ s: 'poucos segundos',
+ ss: '%d segundos',
+ m: 'um minuto',
+ mm: '%d minutos',
+ h: 'uma hora',
+ hh: '%d horas',
+ d: 'um dia',
+ dd: '%d dias',
+ M: 'um mês',
+ MM: '%d meses',
+ y: 'um ano',
+ yy: '%d anos',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ invalidDate: 'Data inválida',
+ });
+
+ return ptBr;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/pt.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/pt.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Portuguese [pt]
+//! author : Jefferson : https://github.com/jalex79
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var pt = moment.defineLocale('pt', {
+ months: 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split(
+ '_'
+ ),
+ monthsShort: 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
+ weekdays: 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split(
+ '_'
+ ),
+ weekdaysShort: 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
+ weekdaysMin: 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D [de] MMMM [de] YYYY',
+ LLL: 'D [de] MMMM [de] YYYY HH:mm',
+ LLLL: 'dddd, D [de] MMMM [de] YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Hoje às] LT',
+ nextDay: '[Amanhã às] LT',
+ nextWeek: 'dddd [às] LT',
+ lastDay: '[Ontem às] LT',
+ lastWeek: function () {
+ return this.day() === 0 || this.day() === 6
+ ? '[Último] dddd [às] LT' // Saturday + Sunday
+ : '[Última] dddd [às] LT'; // Monday - Friday
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'em %s',
+ past: 'há %s',
+ s: 'segundos',
+ ss: '%d segundos',
+ m: 'um minuto',
+ mm: '%d minutos',
+ h: 'uma hora',
+ hh: '%d horas',
+ d: 'um dia',
+ dd: '%d dias',
+ w: 'uma semana',
+ ww: '%d semanas',
+ M: 'um mês',
+ MM: '%d meses',
+ y: 'um ano',
+ yy: '%d anos',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}º/,
+ ordinal: '%dº',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return pt;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ro.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ro.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Romanian [ro]
+//! author : Vlad Gurdiga : https://github.com/gurdiga
+//! author : Valentin Agachi : https://github.com/avaly
+//! author : Emanuel Cepoi : https://github.com/cepem
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function relativeTimeWithPlural(number, withoutSuffix, key) {
+ var format = {
+ ss: 'secunde',
+ mm: 'minute',
+ hh: 'ore',
+ dd: 'zile',
+ ww: 'săptămâni',
+ MM: 'luni',
+ yy: 'ani',
+ },
+ separator = ' ';
+ if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) {
+ separator = ' de ';
+ }
+ return number + separator + format[key];
+ }
+
+ var ro = moment.defineLocale('ro', {
+ months: 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split(
+ '_'
+ ),
+ monthsShort: 'ian._feb._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
+ weekdaysShort: 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
+ weekdaysMin: 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY H:mm',
+ LLLL: 'dddd, D MMMM YYYY H:mm',
+ },
+ calendar: {
+ sameDay: '[azi la] LT',
+ nextDay: '[mâine la] LT',
+ nextWeek: 'dddd [la] LT',
+ lastDay: '[ieri la] LT',
+ lastWeek: '[fosta] dddd [la] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'peste %s',
+ past: '%s în urmă',
+ s: 'câteva secunde',
+ ss: relativeTimeWithPlural,
+ m: 'un minut',
+ mm: relativeTimeWithPlural,
+ h: 'o oră',
+ hh: relativeTimeWithPlural,
+ d: 'o zi',
+ dd: relativeTimeWithPlural,
+ w: 'o săptămână',
+ ww: relativeTimeWithPlural,
+ M: 'o lună',
+ MM: relativeTimeWithPlural,
+ y: 'un an',
+ yy: relativeTimeWithPlural,
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return ro;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ru.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ru.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Russian [ru]
+//! author : Viktorminator : https://github.com/Viktorminator
+//! author : Menelion Elensúle : https://github.com/Oire
+//! author : Коренберг Марк : https://github.com/socketpair
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function plural(word, num) {
+ var forms = word.split('_');
+ return num % 10 === 1 && num % 100 !== 11
+ ? forms[0]
+ : num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20)
+ ? forms[1]
+ : forms[2];
+ }
+ function relativeTimeWithPlural(number, withoutSuffix, key) {
+ var format = {
+ ss: withoutSuffix ? 'секунда_секунды_секунд' : 'секунду_секунды_секунд',
+ mm: withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',
+ hh: 'час_часа_часов',
+ dd: 'день_дня_дней',
+ ww: 'неделя_недели_недель',
+ MM: 'месяц_месяца_месяцев',
+ yy: 'год_года_лет',
+ };
+ if (key === 'm') {
+ return withoutSuffix ? 'минута' : 'минуту';
+ } else {
+ return number + ' ' + plural(format[key], +number);
+ }
+ }
+ var monthsParse = [
+ /^янв/i,
+ /^фев/i,
+ /^мар/i,
+ /^апр/i,
+ /^ма[йя]/i,
+ /^июн/i,
+ /^июл/i,
+ /^авг/i,
+ /^сен/i,
+ /^окт/i,
+ /^ноя/i,
+ /^дек/i,
+ ];
+
+ // http://new.gramota.ru/spravka/rules/139-prop : § 103
+ // Сокращения месяцев: http://new.gramota.ru/spravka/buro/search-answer?s=242637
+ // CLDR data: http://www.unicode.org/cldr/charts/28/summary/ru.html#1753
+ var ru = moment.defineLocale('ru', {
+ months: {
+ format: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split(
+ '_'
+ ),
+ standalone: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split(
+ '_'
+ ),
+ },
+ monthsShort: {
+ // по CLDR именно "июл." и "июн.", но какой смысл менять букву на точку?
+ format: 'янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.'.split(
+ '_'
+ ),
+ standalone: 'янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.'.split(
+ '_'
+ ),
+ },
+ weekdays: {
+ standalone: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split(
+ '_'
+ ),
+ format: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split(
+ '_'
+ ),
+ isFormat: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?] ?dddd/,
+ },
+ weekdaysShort: 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
+ weekdaysMin: 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
+ monthsParse: monthsParse,
+ longMonthsParse: monthsParse,
+ shortMonthsParse: monthsParse,
+
+ // полные названия с падежами, по три буквы, для некоторых, по 4 буквы, сокращения с точкой и без точки
+ monthsRegex: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
+
+ // копия предыдущего
+ monthsShortRegex: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
+
+ // полные названия с падежами
+ monthsStrictRegex: /^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,
+
+ // Выражение, которое соответствует только сокращённым формам
+ monthsShortStrictRegex: /^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY г.',
+ LLL: 'D MMMM YYYY г., H:mm',
+ LLLL: 'dddd, D MMMM YYYY г., H:mm',
+ },
+ calendar: {
+ sameDay: '[Сегодня, в] LT',
+ nextDay: '[Завтра, в] LT',
+ lastDay: '[Вчера, в] LT',
+ nextWeek: function (now) {
+ if (now.week() !== this.week()) {
+ switch (this.day()) {
+ case 0:
+ return '[В следующее] dddd, [в] LT';
+ case 1:
+ case 2:
+ case 4:
+ return '[В следующий] dddd, [в] LT';
+ case 3:
+ case 5:
+ case 6:
+ return '[В следующую] dddd, [в] LT';
+ }
+ } else {
+ if (this.day() === 2) {
+ return '[Во] dddd, [в] LT';
+ } else {
+ return '[В] dddd, [в] LT';
+ }
+ }
+ },
+ lastWeek: function (now) {
+ if (now.week() !== this.week()) {
+ switch (this.day()) {
+ case 0:
+ return '[В прошлое] dddd, [в] LT';
+ case 1:
+ case 2:
+ case 4:
+ return '[В прошлый] dddd, [в] LT';
+ case 3:
+ case 5:
+ case 6:
+ return '[В прошлую] dddd, [в] LT';
+ }
+ } else {
+ if (this.day() === 2) {
+ return '[Во] dddd, [в] LT';
+ } else {
+ return '[В] dddd, [в] LT';
+ }
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'через %s',
+ past: '%s назад',
+ s: 'несколько секунд',
+ ss: relativeTimeWithPlural,
+ m: relativeTimeWithPlural,
+ mm: relativeTimeWithPlural,
+ h: 'час',
+ hh: relativeTimeWithPlural,
+ d: 'день',
+ dd: relativeTimeWithPlural,
+ w: 'неделя',
+ ww: relativeTimeWithPlural,
+ M: 'месяц',
+ MM: relativeTimeWithPlural,
+ y: 'год',
+ yy: relativeTimeWithPlural,
+ },
+ meridiemParse: /ночи|утра|дня|вечера/i,
+ isPM: function (input) {
+ return /^(дня|вечера)$/.test(input);
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'ночи';
+ } else if (hour < 12) {
+ return 'утра';
+ } else if (hour < 17) {
+ return 'дня';
+ } else {
+ return 'вечера';
+ }
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-(й|го|я)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'M':
+ case 'd':
+ case 'DDD':
+ return number + '-й';
+ case 'D':
+ return number + '-го';
+ case 'w':
+ case 'W':
+ return number + '-я';
+ default:
+ return number;
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return ru;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/sd.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/sd.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Sindhi [sd]
+//! author : Narain Sagar : https://github.com/narainsagar
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var months = [
+ 'جنوري',
+ 'فيبروري',
+ 'مارچ',
+ 'اپريل',
+ 'مئي',
+ 'جون',
+ 'جولاءِ',
+ 'آگسٽ',
+ 'سيپٽمبر',
+ 'آڪٽوبر',
+ 'نومبر',
+ 'ڊسمبر',
+ ],
+ days = ['آچر', 'سومر', 'اڱارو', 'اربع', 'خميس', 'جمع', 'ڇنڇر'];
+
+ var sd = moment.defineLocale('sd', {
+ months: months,
+ monthsShort: months,
+ weekdays: days,
+ weekdaysShort: days,
+ weekdaysMin: days,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd، D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /صبح|شام/,
+ isPM: function (input) {
+ return 'شام' === input;
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'صبح';
+ }
+ return 'شام';
+ },
+ calendar: {
+ sameDay: '[اڄ] LT',
+ nextDay: '[سڀاڻي] LT',
+ nextWeek: 'dddd [اڳين هفتي تي] LT',
+ lastDay: '[ڪالهه] LT',
+ lastWeek: '[گزريل هفتي] dddd [تي] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s پوء',
+ past: '%s اڳ',
+ s: 'چند سيڪنڊ',
+ ss: '%d سيڪنڊ',
+ m: 'هڪ منٽ',
+ mm: '%d منٽ',
+ h: 'هڪ ڪلاڪ',
+ hh: '%d ڪلاڪ',
+ d: 'هڪ ڏينهن',
+ dd: '%d ڏينهن',
+ M: 'هڪ مهينو',
+ MM: '%d مهينا',
+ y: 'هڪ سال',
+ yy: '%d سال',
+ },
+ preparse: function (string) {
+ return string.replace(/،/g, ',');
+ },
+ postformat: function (string) {
+ return string.replace(/,/g, '،');
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return sd;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/se.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/se.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Northern Sami [se]
+//! authors : Bård Rolstad Henriksen : https://github.com/karamell
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var se = moment.defineLocale('se', {
+ months: 'ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu'.split(
+ '_'
+ ),
+ monthsShort: 'ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov'.split(
+ '_'
+ ),
+ weekdays: 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split(
+ '_'
+ ),
+ weekdaysShort: 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),
+ weekdaysMin: 's_v_m_g_d_b_L'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'MMMM D. [b.] YYYY',
+ LLL: 'MMMM D. [b.] YYYY [ti.] HH:mm',
+ LLLL: 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm',
+ },
+ calendar: {
+ sameDay: '[otne ti] LT',
+ nextDay: '[ihttin ti] LT',
+ nextWeek: 'dddd [ti] LT',
+ lastDay: '[ikte ti] LT',
+ lastWeek: '[ovddit] dddd [ti] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s geažes',
+ past: 'maŋit %s',
+ s: 'moadde sekunddat',
+ ss: '%d sekunddat',
+ m: 'okta minuhta',
+ mm: '%d minuhtat',
+ h: 'okta diimmu',
+ hh: '%d diimmut',
+ d: 'okta beaivi',
+ dd: '%d beaivvit',
+ M: 'okta mánnu',
+ MM: '%d mánut',
+ y: 'okta jahki',
+ yy: '%d jagit',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return se;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/si.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/si.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Sinhalese [si]
+//! author : Sampath Sitinamaluwa : https://github.com/sampathsris
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ /*jshint -W100*/
+ var si = moment.defineLocale('si', {
+ months: 'ජනවාරි_පෙබරවාරි_මාර්තු_අප්\200dරේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්'.split(
+ '_'
+ ),
+ monthsShort: 'ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ'.split(
+ '_'
+ ),
+ weekdays: 'ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්\200dරහස්පතින්දා_සිකුරාදා_සෙනසුරාදා'.split(
+ '_'
+ ),
+ weekdaysShort: 'ඉරි_සඳු_අඟ_බදා_බ්\200dරහ_සිකු_සෙන'.split('_'),
+ weekdaysMin: 'ඉ_ස_අ_බ_බ්\200dර_සි_සෙ'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'a h:mm',
+ LTS: 'a h:mm:ss',
+ L: 'YYYY/MM/DD',
+ LL: 'YYYY MMMM D',
+ LLL: 'YYYY MMMM D, a h:mm',
+ LLLL: 'YYYY MMMM D [වැනි] dddd, a h:mm:ss',
+ },
+ calendar: {
+ sameDay: '[අද] LT[ට]',
+ nextDay: '[හෙට] LT[ට]',
+ nextWeek: 'dddd LT[ට]',
+ lastDay: '[ඊයේ] LT[ට]',
+ lastWeek: '[පසුගිය] dddd LT[ට]',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%sකින්',
+ past: '%sකට පෙර',
+ s: 'තත්පර කිහිපය',
+ ss: 'තත්පර %d',
+ m: 'මිනිත්තුව',
+ mm: 'මිනිත්තු %d',
+ h: 'පැය',
+ hh: 'පැය %d',
+ d: 'දිනය',
+ dd: 'දින %d',
+ M: 'මාසය',
+ MM: 'මාස %d',
+ y: 'වසර',
+ yy: 'වසර %d',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2} වැනි/,
+ ordinal: function (number) {
+ return number + ' වැනි';
+ },
+ meridiemParse: /පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,
+ isPM: function (input) {
+ return input === 'ප.ව.' || input === 'පස් වරු';
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours > 11) {
+ return isLower ? 'ප.ව.' : 'පස් වරු';
+ } else {
+ return isLower ? 'පෙ.ව.' : 'පෙර වරු';
+ }
+ },
+ });
+
+ return si;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/sk.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/sk.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Slovak [sk]
+//! author : Martin Minka : https://github.com/k2s
+//! based on work of petrbela : https://github.com/petrbela
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var months = 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split(
+ '_'
+ ),
+ monthsShort = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');
+ function plural(n) {
+ return n > 1 && n < 5;
+ }
+ function translate(number, withoutSuffix, key, isFuture) {
+ var result = number + ' ';
+ switch (key) {
+ case 's': // a few seconds / in a few seconds / a few seconds ago
+ return withoutSuffix || isFuture ? 'pár sekúnd' : 'pár sekundami';
+ case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'sekundy' : 'sekúnd');
+ } else {
+ return result + 'sekundami';
+ }
+ case 'm': // a minute / in a minute / a minute ago
+ return withoutSuffix ? 'minúta' : isFuture ? 'minútu' : 'minútou';
+ case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'minúty' : 'minút');
+ } else {
+ return result + 'minútami';
+ }
+ case 'h': // an hour / in an hour / an hour ago
+ return withoutSuffix ? 'hodina' : isFuture ? 'hodinu' : 'hodinou';
+ case 'hh': // 9 hours / in 9 hours / 9 hours ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'hodiny' : 'hodín');
+ } else {
+ return result + 'hodinami';
+ }
+ case 'd': // a day / in a day / a day ago
+ return withoutSuffix || isFuture ? 'deň' : 'dňom';
+ case 'dd': // 9 days / in 9 days / 9 days ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'dni' : 'dní');
+ } else {
+ return result + 'dňami';
+ }
+ case 'M': // a month / in a month / a month ago
+ return withoutSuffix || isFuture ? 'mesiac' : 'mesiacom';
+ case 'MM': // 9 months / in 9 months / 9 months ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'mesiace' : 'mesiacov');
+ } else {
+ return result + 'mesiacmi';
+ }
+ case 'y': // a year / in a year / a year ago
+ return withoutSuffix || isFuture ? 'rok' : 'rokom';
+ case 'yy': // 9 years / in 9 years / 9 years ago
+ if (withoutSuffix || isFuture) {
+ return result + (plural(number) ? 'roky' : 'rokov');
+ } else {
+ return result + 'rokmi';
+ }
+ }
+ }
+
+ var sk = moment.defineLocale('sk', {
+ months: months,
+ monthsShort: monthsShort,
+ weekdays: 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
+ weekdaysShort: 'ne_po_ut_st_št_pi_so'.split('_'),
+ weekdaysMin: 'ne_po_ut_st_št_pi_so'.split('_'),
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY H:mm',
+ LLLL: 'dddd D. MMMM YYYY H:mm',
+ },
+ calendar: {
+ sameDay: '[dnes o] LT',
+ nextDay: '[zajtra o] LT',
+ nextWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[v nedeľu o] LT';
+ case 1:
+ case 2:
+ return '[v] dddd [o] LT';
+ case 3:
+ return '[v stredu o] LT';
+ case 4:
+ return '[vo štvrtok o] LT';
+ case 5:
+ return '[v piatok o] LT';
+ case 6:
+ return '[v sobotu o] LT';
+ }
+ },
+ lastDay: '[včera o] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[minulú nedeľu o] LT';
+ case 1:
+ case 2:
+ return '[minulý] dddd [o] LT';
+ case 3:
+ return '[minulú stredu o] LT';
+ case 4:
+ case 5:
+ return '[minulý] dddd [o] LT';
+ case 6:
+ return '[minulú sobotu o] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'za %s',
+ past: 'pred %s',
+ s: translate,
+ ss: translate,
+ m: translate,
+ mm: translate,
+ h: translate,
+ hh: translate,
+ d: translate,
+ dd: translate,
+ M: translate,
+ MM: translate,
+ y: translate,
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return sk;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/sl.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/sl.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Slovenian [sl]
+//! author : Robert Sedovšek : https://github.com/sedovsek
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function processRelativeTime(number, withoutSuffix, key, isFuture) {
+ var result = number + ' ';
+ switch (key) {
+ case 's':
+ return withoutSuffix || isFuture
+ ? 'nekaj sekund'
+ : 'nekaj sekundami';
+ case 'ss':
+ if (number === 1) {
+ result += withoutSuffix ? 'sekundo' : 'sekundi';
+ } else if (number === 2) {
+ result += withoutSuffix || isFuture ? 'sekundi' : 'sekundah';
+ } else if (number < 5) {
+ result += withoutSuffix || isFuture ? 'sekunde' : 'sekundah';
+ } else {
+ result += 'sekund';
+ }
+ return result;
+ case 'm':
+ return withoutSuffix ? 'ena minuta' : 'eno minuto';
+ case 'mm':
+ if (number === 1) {
+ result += withoutSuffix ? 'minuta' : 'minuto';
+ } else if (number === 2) {
+ result += withoutSuffix || isFuture ? 'minuti' : 'minutama';
+ } else if (number < 5) {
+ result += withoutSuffix || isFuture ? 'minute' : 'minutami';
+ } else {
+ result += withoutSuffix || isFuture ? 'minut' : 'minutami';
+ }
+ return result;
+ case 'h':
+ return withoutSuffix ? 'ena ura' : 'eno uro';
+ case 'hh':
+ if (number === 1) {
+ result += withoutSuffix ? 'ura' : 'uro';
+ } else if (number === 2) {
+ result += withoutSuffix || isFuture ? 'uri' : 'urama';
+ } else if (number < 5) {
+ result += withoutSuffix || isFuture ? 'ure' : 'urami';
+ } else {
+ result += withoutSuffix || isFuture ? 'ur' : 'urami';
+ }
+ return result;
+ case 'd':
+ return withoutSuffix || isFuture ? 'en dan' : 'enim dnem';
+ case 'dd':
+ if (number === 1) {
+ result += withoutSuffix || isFuture ? 'dan' : 'dnem';
+ } else if (number === 2) {
+ result += withoutSuffix || isFuture ? 'dni' : 'dnevoma';
+ } else {
+ result += withoutSuffix || isFuture ? 'dni' : 'dnevi';
+ }
+ return result;
+ case 'M':
+ return withoutSuffix || isFuture ? 'en mesec' : 'enim mesecem';
+ case 'MM':
+ if (number === 1) {
+ result += withoutSuffix || isFuture ? 'mesec' : 'mesecem';
+ } else if (number === 2) {
+ result += withoutSuffix || isFuture ? 'meseca' : 'mesecema';
+ } else if (number < 5) {
+ result += withoutSuffix || isFuture ? 'mesece' : 'meseci';
+ } else {
+ result += withoutSuffix || isFuture ? 'mesecev' : 'meseci';
+ }
+ return result;
+ case 'y':
+ return withoutSuffix || isFuture ? 'eno leto' : 'enim letom';
+ case 'yy':
+ if (number === 1) {
+ result += withoutSuffix || isFuture ? 'leto' : 'letom';
+ } else if (number === 2) {
+ result += withoutSuffix || isFuture ? 'leti' : 'letoma';
+ } else if (number < 5) {
+ result += withoutSuffix || isFuture ? 'leta' : 'leti';
+ } else {
+ result += withoutSuffix || isFuture ? 'let' : 'leti';
+ }
+ return result;
+ }
+ }
+
+ var sl = moment.defineLocale('sl', {
+ months: 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split(
+ '_'
+ ),
+ monthsShort: 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota'.split('_'),
+ weekdaysShort: 'ned._pon._tor._sre._čet._pet._sob.'.split('_'),
+ weekdaysMin: 'ne_po_to_sr_če_pe_so'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD. MM. YYYY',
+ LL: 'D. MMMM YYYY',
+ LLL: 'D. MMMM YYYY H:mm',
+ LLLL: 'dddd, D. MMMM YYYY H:mm',
+ },
+ calendar: {
+ sameDay: '[danes ob] LT',
+ nextDay: '[jutri ob] LT',
+
+ nextWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[v] [nedeljo] [ob] LT';
+ case 3:
+ return '[v] [sredo] [ob] LT';
+ case 6:
+ return '[v] [soboto] [ob] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[v] dddd [ob] LT';
+ }
+ },
+ lastDay: '[včeraj ob] LT',
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[prejšnjo] [nedeljo] [ob] LT';
+ case 3:
+ return '[prejšnjo] [sredo] [ob] LT';
+ case 6:
+ return '[prejšnjo] [soboto] [ob] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[prejšnji] dddd [ob] LT';
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'čez %s',
+ past: 'pred %s',
+ s: processRelativeTime,
+ ss: processRelativeTime,
+ m: processRelativeTime,
+ mm: processRelativeTime,
+ h: processRelativeTime,
+ hh: processRelativeTime,
+ d: processRelativeTime,
+ dd: processRelativeTime,
+ M: processRelativeTime,
+ MM: processRelativeTime,
+ y: processRelativeTime,
+ yy: processRelativeTime,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return sl;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/sq.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/sq.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Albanian [sq]
+//! author : Flakërim Ismani : https://github.com/flakerimi
+//! author : Menelion Elensúle : https://github.com/Oire
+//! author : Oerd Cukalla : https://github.com/oerd
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var sq = moment.defineLocale('sq', {
+ months: 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
+ weekdays: 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split(
+ '_'
+ ),
+ weekdaysShort: 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
+ weekdaysMin: 'D_H_Ma_Më_E_P_Sh'.split('_'),
+ weekdaysParseExact: true,
+ meridiemParse: /PD|MD/,
+ isPM: function (input) {
+ return input.charAt(0) === 'M';
+ },
+ meridiem: function (hours, minutes, isLower) {
+ return hours < 12 ? 'PD' : 'MD';
+ },
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Sot në] LT',
+ nextDay: '[Nesër në] LT',
+ nextWeek: 'dddd [në] LT',
+ lastDay: '[Dje në] LT',
+ lastWeek: 'dddd [e kaluar në] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'në %s',
+ past: '%s më parë',
+ s: 'disa sekonda',
+ ss: '%d sekonda',
+ m: 'një minutë',
+ mm: '%d minuta',
+ h: 'një orë',
+ hh: '%d orë',
+ d: 'një ditë',
+ dd: '%d ditë',
+ M: 'një muaj',
+ MM: '%d muaj',
+ y: 'një vit',
+ yy: '%d vite',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return sq;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/sr-cyrl.js":
+/*!***********************************************!*\
+ !*** ./node_modules/moment/locale/sr-cyrl.js ***!
+ \***********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Serbian Cyrillic [sr-cyrl]
+//! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
+//! author : Stefan Crnjaković <stefan@hotmail.rs> : https://github.com/crnjakovic
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var translator = {
+ words: {
+ //Different grammatical cases
+ ss: ['секунда', 'секунде', 'секунди'],
+ m: ['један минут', 'једне минуте'],
+ mm: ['минут', 'минуте', 'минута'],
+ h: ['један сат', 'једног сата'],
+ hh: ['сат', 'сата', 'сати'],
+ dd: ['дан', 'дана', 'дана'],
+ MM: ['месец', 'месеца', 'месеци'],
+ yy: ['година', 'године', 'година'],
+ },
+ correctGrammaticalCase: function (number, wordKey) {
+ return number === 1
+ ? wordKey[0]
+ : number >= 2 && number <= 4
+ ? wordKey[1]
+ : wordKey[2];
+ },
+ translate: function (number, withoutSuffix, key) {
+ var wordKey = translator.words[key];
+ if (key.length === 1) {
+ return withoutSuffix ? wordKey[0] : wordKey[1];
+ } else {
+ return (
+ number +
+ ' ' +
+ translator.correctGrammaticalCase(number, wordKey)
+ );
+ }
+ },
+ };
+
+ var srCyrl = moment.defineLocale('sr-cyrl', {
+ months: 'јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар'.split(
+ '_'
+ ),
+ monthsShort: 'јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'недеља_понедељак_уторак_среда_четвртак_петак_субота'.split('_'),
+ weekdaysShort: 'нед._пон._уто._сре._чет._пет._суб.'.split('_'),
+ weekdaysMin: 'не_по_ут_ср_че_пе_су'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'D. M. YYYY.',
+ LL: 'D. MMMM YYYY.',
+ LLL: 'D. MMMM YYYY. H:mm',
+ LLLL: 'dddd, D. MMMM YYYY. H:mm',
+ },
+ calendar: {
+ sameDay: '[данас у] LT',
+ nextDay: '[сутра у] LT',
+ nextWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[у] [недељу] [у] LT';
+ case 3:
+ return '[у] [среду] [у] LT';
+ case 6:
+ return '[у] [суботу] [у] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[у] dddd [у] LT';
+ }
+ },
+ lastDay: '[јуче у] LT',
+ lastWeek: function () {
+ var lastWeekDays = [
+ '[прошле] [недеље] [у] LT',
+ '[прошлог] [понедељка] [у] LT',
+ '[прошлог] [уторка] [у] LT',
+ '[прошле] [среде] [у] LT',
+ '[прошлог] [четвртка] [у] LT',
+ '[прошлог] [петка] [у] LT',
+ '[прошле] [суботе] [у] LT',
+ ];
+ return lastWeekDays[this.day()];
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'за %s',
+ past: 'пре %s',
+ s: 'неколико секунди',
+ ss: translator.translate,
+ m: translator.translate,
+ mm: translator.translate,
+ h: translator.translate,
+ hh: translator.translate,
+ d: 'дан',
+ dd: translator.translate,
+ M: 'месец',
+ MM: translator.translate,
+ y: 'годину',
+ yy: translator.translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 1st is the first week of the year.
+ },
+ });
+
+ return srCyrl;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/sr.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/sr.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Serbian [sr]
+//! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
+//! author : Stefan Crnjaković <stefan@hotmail.rs> : https://github.com/crnjakovic
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var translator = {
+ words: {
+ //Different grammatical cases
+ ss: ['sekunda', 'sekunde', 'sekundi'],
+ m: ['jedan minut', 'jedne minute'],
+ mm: ['minut', 'minute', 'minuta'],
+ h: ['jedan sat', 'jednog sata'],
+ hh: ['sat', 'sata', 'sati'],
+ dd: ['dan', 'dana', 'dana'],
+ MM: ['mesec', 'meseca', 'meseci'],
+ yy: ['godina', 'godine', 'godina'],
+ },
+ correctGrammaticalCase: function (number, wordKey) {
+ return number === 1
+ ? wordKey[0]
+ : number >= 2 && number <= 4
+ ? wordKey[1]
+ : wordKey[2];
+ },
+ translate: function (number, withoutSuffix, key) {
+ var wordKey = translator.words[key];
+ if (key.length === 1) {
+ return withoutSuffix ? wordKey[0] : wordKey[1];
+ } else {
+ return (
+ number +
+ ' ' +
+ translator.correctGrammaticalCase(number, wordKey)
+ );
+ }
+ },
+ };
+
+ var sr = moment.defineLocale('sr', {
+ months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split(
+ '_'
+ ),
+ monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota'.split(
+ '_'
+ ),
+ weekdaysShort: 'ned._pon._uto._sre._čet._pet._sub.'.split('_'),
+ weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'D. M. YYYY.',
+ LL: 'D. MMMM YYYY.',
+ LLL: 'D. MMMM YYYY. H:mm',
+ LLLL: 'dddd, D. MMMM YYYY. H:mm',
+ },
+ calendar: {
+ sameDay: '[danas u] LT',
+ nextDay: '[sutra u] LT',
+ nextWeek: function () {
+ switch (this.day()) {
+ case 0:
+ return '[u] [nedelju] [u] LT';
+ case 3:
+ return '[u] [sredu] [u] LT';
+ case 6:
+ return '[u] [subotu] [u] LT';
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ return '[u] dddd [u] LT';
+ }
+ },
+ lastDay: '[juče u] LT',
+ lastWeek: function () {
+ var lastWeekDays = [
+ '[prošle] [nedelje] [u] LT',
+ '[prošlog] [ponedeljka] [u] LT',
+ '[prošlog] [utorka] [u] LT',
+ '[prošle] [srede] [u] LT',
+ '[prošlog] [četvrtka] [u] LT',
+ '[prošlog] [petka] [u] LT',
+ '[prošle] [subote] [u] LT',
+ ];
+ return lastWeekDays[this.day()];
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'za %s',
+ past: 'pre %s',
+ s: 'nekoliko sekundi',
+ ss: translator.translate,
+ m: translator.translate,
+ mm: translator.translate,
+ h: translator.translate,
+ hh: translator.translate,
+ d: 'dan',
+ dd: translator.translate,
+ M: 'mesec',
+ MM: translator.translate,
+ y: 'godinu',
+ yy: translator.translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return sr;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ss.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ss.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : siSwati [ss]
+//! author : Nicolai Davies<mail@nicolai.io> : https://github.com/nicolaidavies
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ss = moment.defineLocale('ss', {
+ months: "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split(
+ '_'
+ ),
+ monthsShort: 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'),
+ weekdays: 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split(
+ '_'
+ ),
+ weekdaysShort: 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'),
+ weekdaysMin: 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'h:mm A',
+ LTS: 'h:mm:ss A',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY h:mm A',
+ LLLL: 'dddd, D MMMM YYYY h:mm A',
+ },
+ calendar: {
+ sameDay: '[Namuhla nga] LT',
+ nextDay: '[Kusasa nga] LT',
+ nextWeek: 'dddd [nga] LT',
+ lastDay: '[Itolo nga] LT',
+ lastWeek: 'dddd [leliphelile] [nga] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'nga %s',
+ past: 'wenteka nga %s',
+ s: 'emizuzwana lomcane',
+ ss: '%d mzuzwana',
+ m: 'umzuzu',
+ mm: '%d emizuzu',
+ h: 'lihora',
+ hh: '%d emahora',
+ d: 'lilanga',
+ dd: '%d emalanga',
+ M: 'inyanga',
+ MM: '%d tinyanga',
+ y: 'umnyaka',
+ yy: '%d iminyaka',
+ },
+ meridiemParse: /ekuseni|emini|entsambama|ebusuku/,
+ meridiem: function (hours, minutes, isLower) {
+ if (hours < 11) {
+ return 'ekuseni';
+ } else if (hours < 15) {
+ return 'emini';
+ } else if (hours < 19) {
+ return 'entsambama';
+ } else {
+ return 'ebusuku';
+ }
+ },
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'ekuseni') {
+ return hour;
+ } else if (meridiem === 'emini') {
+ return hour >= 11 ? hour : hour + 12;
+ } else if (meridiem === 'entsambama' || meridiem === 'ebusuku') {
+ if (hour === 0) {
+ return 0;
+ }
+ return hour + 12;
+ }
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}/,
+ ordinal: '%d',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return ss;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/sv.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/sv.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Swedish [sv]
+//! author : Jens Alm : https://github.com/ulmus
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var sv = moment.defineLocale('sv', {
+ months: 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split(
+ '_'
+ ),
+ monthsShort: 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
+ weekdays: 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
+ weekdaysShort: 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
+ weekdaysMin: 'sö_må_ti_on_to_fr_lö'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY-MM-DD',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY [kl.] HH:mm',
+ LLLL: 'dddd D MMMM YYYY [kl.] HH:mm',
+ lll: 'D MMM YYYY HH:mm',
+ llll: 'ddd D MMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Idag] LT',
+ nextDay: '[Imorgon] LT',
+ lastDay: '[Igår] LT',
+ nextWeek: '[På] dddd LT',
+ lastWeek: '[I] dddd[s] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'om %s',
+ past: 'för %s sedan',
+ s: 'några sekunder',
+ ss: '%d sekunder',
+ m: 'en minut',
+ mm: '%d minuter',
+ h: 'en timme',
+ hh: '%d timmar',
+ d: 'en dag',
+ dd: '%d dagar',
+ M: 'en månad',
+ MM: '%d månader',
+ y: 'ett år',
+ yy: '%d år',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(\:e|\:a)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? ':e'
+ : b === 1
+ ? ':a'
+ : b === 2
+ ? ':a'
+ : b === 3
+ ? ':e'
+ : ':e';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return sv;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/sw.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/sw.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Swahili [sw]
+//! author : Fahad Kassim : https://github.com/fadsel
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var sw = moment.defineLocale('sw', {
+ months: 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
+ weekdays: 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split(
+ '_'
+ ),
+ weekdaysShort: 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
+ weekdaysMin: 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'hh:mm A',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[leo saa] LT',
+ nextDay: '[kesho saa] LT',
+ nextWeek: '[wiki ijayo] dddd [saat] LT',
+ lastDay: '[jana] LT',
+ lastWeek: '[wiki iliyopita] dddd [saat] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s baadaye',
+ past: 'tokea %s',
+ s: 'hivi punde',
+ ss: 'sekunde %d',
+ m: 'dakika moja',
+ mm: 'dakika %d',
+ h: 'saa limoja',
+ hh: 'masaa %d',
+ d: 'siku moja',
+ dd: 'siku %d',
+ M: 'mwezi mmoja',
+ MM: 'miezi %d',
+ y: 'mwaka mmoja',
+ yy: 'miaka %d',
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return sw;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ta.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ta.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Tamil [ta]
+//! author : Arjunkumar Krishnamoorthy : https://github.com/tk120404
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var symbolMap = {
+ 1: '௧',
+ 2: '௨',
+ 3: '௩',
+ 4: '௪',
+ 5: '௫',
+ 6: '௬',
+ 7: '௭',
+ 8: '௮',
+ 9: '௯',
+ 0: '௦',
+ },
+ numberMap = {
+ '௧': '1',
+ '௨': '2',
+ '௩': '3',
+ '௪': '4',
+ '௫': '5',
+ '௬': '6',
+ '௭': '7',
+ '௮': '8',
+ '௯': '9',
+ '௦': '0',
+ };
+
+ var ta = moment.defineLocale('ta', {
+ months: 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split(
+ '_'
+ ),
+ monthsShort: 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split(
+ '_'
+ ),
+ weekdays: 'ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை'.split(
+ '_'
+ ),
+ weekdaysShort: 'ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி'.split(
+ '_'
+ ),
+ weekdaysMin: 'ஞா_தி_செ_பு_வி_வெ_ச'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, HH:mm',
+ LLLL: 'dddd, D MMMM YYYY, HH:mm',
+ },
+ calendar: {
+ sameDay: '[இன்று] LT',
+ nextDay: '[நாளை] LT',
+ nextWeek: 'dddd, LT',
+ lastDay: '[நேற்று] LT',
+ lastWeek: '[கடந்த வாரம்] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s இல்',
+ past: '%s முன்',
+ s: 'ஒரு சில விநாடிகள்',
+ ss: '%d விநாடிகள்',
+ m: 'ஒரு நிமிடம்',
+ mm: '%d நிமிடங்கள்',
+ h: 'ஒரு மணி நேரம்',
+ hh: '%d மணி நேரம்',
+ d: 'ஒரு நாள்',
+ dd: '%d நாட்கள்',
+ M: 'ஒரு மாதம்',
+ MM: '%d மாதங்கள்',
+ y: 'ஒரு வருடம்',
+ yy: '%d ஆண்டுகள்',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}வது/,
+ ordinal: function (number) {
+ return number + 'வது';
+ },
+ preparse: function (string) {
+ return string.replace(/[௧௨௩௪௫௬௭௮௯௦]/g, function (match) {
+ return numberMap[match];
+ });
+ },
+ postformat: function (string) {
+ return string.replace(/\d/g, function (match) {
+ return symbolMap[match];
+ });
+ },
+ // refer http://ta.wikipedia.org/s/1er1
+ meridiemParse: /யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 2) {
+ return ' யாமம்';
+ } else if (hour < 6) {
+ return ' வைகறை'; // வைகறை
+ } else if (hour < 10) {
+ return ' காலை'; // காலை
+ } else if (hour < 14) {
+ return ' நண்பகல்'; // நண்பகல்
+ } else if (hour < 18) {
+ return ' எற்பாடு'; // எற்பாடு
+ } else if (hour < 22) {
+ return ' மாலை'; // மாலை
+ } else {
+ return ' யாமம்';
+ }
+ },
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'யாமம்') {
+ return hour < 2 ? hour : hour + 12;
+ } else if (meridiem === 'வைகறை' || meridiem === 'காலை') {
+ return hour;
+ } else if (meridiem === 'நண்பகல்') {
+ return hour >= 10 ? hour : hour + 12;
+ } else {
+ return hour + 12;
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return ta;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/te.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/te.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Telugu [te]
+//! author : Krishna Chaitanya Thota : https://github.com/kcthota
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var te = moment.defineLocale('te', {
+ months: 'జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జులై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్'.split(
+ '_'
+ ),
+ monthsShort: 'జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జులై_ఆగ._సెప్._అక్టో._నవ._డిసె.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం'.split(
+ '_'
+ ),
+ weekdaysShort: 'ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని'.split('_'),
+ weekdaysMin: 'ఆ_సో_మం_బు_గు_శు_శ'.split('_'),
+ longDateFormat: {
+ LT: 'A h:mm',
+ LTS: 'A h:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY, A h:mm',
+ LLLL: 'dddd, D MMMM YYYY, A h:mm',
+ },
+ calendar: {
+ sameDay: '[నేడు] LT',
+ nextDay: '[రేపు] LT',
+ nextWeek: 'dddd, LT',
+ lastDay: '[నిన్న] LT',
+ lastWeek: '[గత] dddd, LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s లో',
+ past: '%s క్రితం',
+ s: 'కొన్ని క్షణాలు',
+ ss: '%d సెకన్లు',
+ m: 'ఒక నిమిషం',
+ mm: '%d నిమిషాలు',
+ h: 'ఒక గంట',
+ hh: '%d గంటలు',
+ d: 'ఒక రోజు',
+ dd: '%d రోజులు',
+ M: 'ఒక నెల',
+ MM: '%d నెలలు',
+ y: 'ఒక సంవత్సరం',
+ yy: '%d సంవత్సరాలు',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}వ/,
+ ordinal: '%dవ',
+ meridiemParse: /రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'రాత్రి') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'ఉదయం') {
+ return hour;
+ } else if (meridiem === 'మధ్యాహ్నం') {
+ return hour >= 10 ? hour : hour + 12;
+ } else if (meridiem === 'సాయంత్రం') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'రాత్రి';
+ } else if (hour < 10) {
+ return 'ఉదయం';
+ } else if (hour < 17) {
+ return 'మధ్యాహ్నం';
+ } else if (hour < 20) {
+ return 'సాయంత్రం';
+ } else {
+ return 'రాత్రి';
+ }
+ },
+ week: {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ },
+ });
+
+ return te;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/tet.js":
+/*!*******************************************!*\
+ !*** ./node_modules/moment/locale/tet.js ***!
+ \*******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Tetun Dili (East Timor) [tet]
+//! author : Joshua Brooks : https://github.com/joshbrooks
+//! author : Onorio De J. Afonso : https://github.com/marobo
+//! author : Sonia Simoes : https://github.com/soniasimoes
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var tet = moment.defineLocale('tet', {
+ months: 'Janeiru_Fevereiru_Marsu_Abril_Maiu_Juñu_Jullu_Agustu_Setembru_Outubru_Novembru_Dezembru'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
+ weekdays: 'Domingu_Segunda_Tersa_Kuarta_Kinta_Sesta_Sabadu'.split('_'),
+ weekdaysShort: 'Dom_Seg_Ters_Kua_Kint_Sest_Sab'.split('_'),
+ weekdaysMin: 'Do_Seg_Te_Ku_Ki_Ses_Sa'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Ohin iha] LT',
+ nextDay: '[Aban iha] LT',
+ nextWeek: 'dddd [iha] LT',
+ lastDay: '[Horiseik iha] LT',
+ lastWeek: 'dddd [semana kotuk] [iha] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'iha %s',
+ past: '%s liuba',
+ s: 'segundu balun',
+ ss: 'segundu %d',
+ m: 'minutu ida',
+ mm: 'minutu %d',
+ h: 'oras ida',
+ hh: 'oras %d',
+ d: 'loron ida',
+ dd: 'loron %d',
+ M: 'fulan ida',
+ MM: 'fulan %d',
+ y: 'tinan ida',
+ yy: 'tinan %d',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return tet;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/tg.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/tg.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Tajik [tg]
+//! author : Orif N. Jr. : https://github.com/orif-jr
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var suffixes = {
+ 0: '-ум',
+ 1: '-ум',
+ 2: '-юм',
+ 3: '-юм',
+ 4: '-ум',
+ 5: '-ум',
+ 6: '-ум',
+ 7: '-ум',
+ 8: '-ум',
+ 9: '-ум',
+ 10: '-ум',
+ 12: '-ум',
+ 13: '-ум',
+ 20: '-ум',
+ 30: '-юм',
+ 40: '-ум',
+ 50: '-ум',
+ 60: '-ум',
+ 70: '-ум',
+ 80: '-ум',
+ 90: '-ум',
+ 100: '-ум',
+ };
+
+ var tg = moment.defineLocale('tg', {
+ months: {
+ format: 'январи_феврали_марти_апрели_майи_июни_июли_августи_сентябри_октябри_ноябри_декабри'.split(
+ '_'
+ ),
+ standalone: 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split(
+ '_'
+ ),
+ },
+ monthsShort: 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
+ weekdays: 'якшанбе_душанбе_сешанбе_чоршанбе_панҷшанбе_ҷумъа_шанбе'.split(
+ '_'
+ ),
+ weekdaysShort: 'яшб_дшб_сшб_чшб_пшб_ҷум_шнб'.split('_'),
+ weekdaysMin: 'яш_дш_сш_чш_пш_ҷм_шб'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Имрӯз соати] LT',
+ nextDay: '[Фардо соати] LT',
+ lastDay: '[Дирӯз соати] LT',
+ nextWeek: 'dddd[и] [ҳафтаи оянда соати] LT',
+ lastWeek: 'dddd[и] [ҳафтаи гузашта соати] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'баъди %s',
+ past: '%s пеш',
+ s: 'якчанд сония',
+ m: 'як дақиқа',
+ mm: '%d дақиқа',
+ h: 'як соат',
+ hh: '%d соат',
+ d: 'як рӯз',
+ dd: '%d рӯз',
+ M: 'як моҳ',
+ MM: '%d моҳ',
+ y: 'як сол',
+ yy: '%d сол',
+ },
+ meridiemParse: /шаб|субҳ|рӯз|бегоҳ/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === 'шаб') {
+ return hour < 4 ? hour : hour + 12;
+ } else if (meridiem === 'субҳ') {
+ return hour;
+ } else if (meridiem === 'рӯз') {
+ return hour >= 11 ? hour : hour + 12;
+ } else if (meridiem === 'бегоҳ') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'шаб';
+ } else if (hour < 11) {
+ return 'субҳ';
+ } else if (hour < 16) {
+ return 'рӯз';
+ } else if (hour < 19) {
+ return 'бегоҳ';
+ } else {
+ return 'шаб';
+ }
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-(ум|юм)/,
+ ordinal: function (number) {
+ var a = number % 10,
+ b = number >= 100 ? 100 : null;
+ return number + (suffixes[number] || suffixes[a] || suffixes[b]);
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 1th is the first week of the year.
+ },
+ });
+
+ return tg;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/th.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/th.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Thai [th]
+//! author : Kridsada Thanabulpong : https://github.com/sirn
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var th = moment.defineLocale('th', {
+ months: 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split(
+ '_'
+ ),
+ monthsShort: 'ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์'.split('_'),
+ weekdaysShort: 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์'.split('_'), // yes, three characters difference
+ weekdaysMin: 'อา._จ._อ._พ._พฤ._ศ._ส.'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'H:mm',
+ LTS: 'H:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY เวลา H:mm',
+ LLLL: 'วันddddที่ D MMMM YYYY เวลา H:mm',
+ },
+ meridiemParse: /ก่อนเที่ยง|หลังเที่ยง/,
+ isPM: function (input) {
+ return input === 'หลังเที่ยง';
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'ก่อนเที่ยง';
+ } else {
+ return 'หลังเที่ยง';
+ }
+ },
+ calendar: {
+ sameDay: '[วันนี้ เวลา] LT',
+ nextDay: '[พรุ่งนี้ เวลา] LT',
+ nextWeek: 'dddd[หน้า เวลา] LT',
+ lastDay: '[เมื่อวานนี้ เวลา] LT',
+ lastWeek: '[วัน]dddd[ที่แล้ว เวลา] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'อีก %s',
+ past: '%sที่แล้ว',
+ s: 'ไม่กี่วินาที',
+ ss: '%d วินาที',
+ m: '1 นาที',
+ mm: '%d นาที',
+ h: '1 ชั่วโมง',
+ hh: '%d ชั่วโมง',
+ d: '1 วัน',
+ dd: '%d วัน',
+ w: '1 สัปดาห์',
+ ww: '%d สัปดาห์',
+ M: '1 เดือน',
+ MM: '%d เดือน',
+ y: '1 ปี',
+ yy: '%d ปี',
+ },
+ });
+
+ return th;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/tk.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/tk.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Turkmen [tk]
+//! author : Atamyrat Abdyrahmanov : https://github.com/atamyratabdy
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var suffixes = {
+ 1: "'inji",
+ 5: "'inji",
+ 8: "'inji",
+ 70: "'inji",
+ 80: "'inji",
+ 2: "'nji",
+ 7: "'nji",
+ 20: "'nji",
+ 50: "'nji",
+ 3: "'ünji",
+ 4: "'ünji",
+ 100: "'ünji",
+ 6: "'njy",
+ 9: "'unjy",
+ 10: "'unjy",
+ 30: "'unjy",
+ 60: "'ynjy",
+ 90: "'ynjy",
+ };
+
+ var tk = moment.defineLocale('tk', {
+ months: 'Ýanwar_Fewral_Mart_Aprel_Maý_Iýun_Iýul_Awgust_Sentýabr_Oktýabr_Noýabr_Dekabr'.split(
+ '_'
+ ),
+ monthsShort: 'Ýan_Few_Mar_Apr_Maý_Iýn_Iýl_Awg_Sen_Okt_Noý_Dek'.split('_'),
+ weekdays: 'Ýekşenbe_Duşenbe_Sişenbe_Çarşenbe_Penşenbe_Anna_Şenbe'.split(
+ '_'
+ ),
+ weekdaysShort: 'Ýek_Duş_Siş_Çar_Pen_Ann_Şen'.split('_'),
+ weekdaysMin: 'Ýk_Dş_Sş_Çr_Pn_An_Şn'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[bugün sagat] LT',
+ nextDay: '[ertir sagat] LT',
+ nextWeek: '[indiki] dddd [sagat] LT',
+ lastDay: '[düýn] LT',
+ lastWeek: '[geçen] dddd [sagat] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s soň',
+ past: '%s öň',
+ s: 'birnäçe sekunt',
+ m: 'bir minut',
+ mm: '%d minut',
+ h: 'bir sagat',
+ hh: '%d sagat',
+ d: 'bir gün',
+ dd: '%d gün',
+ M: 'bir aý',
+ MM: '%d aý',
+ y: 'bir ýyl',
+ yy: '%d ýyl',
+ },
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'd':
+ case 'D':
+ case 'Do':
+ case 'DD':
+ return number;
+ default:
+ if (number === 0) {
+ // special case for zero
+ return number + "'unjy";
+ }
+ var a = number % 10,
+ b = (number % 100) - a,
+ c = number >= 100 ? 100 : null;
+ return number + (suffixes[a] || suffixes[b] || suffixes[c]);
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return tk;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/tl-ph.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/tl-ph.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Tagalog (Philippines) [tl-ph]
+//! author : Dan Hagman : https://github.com/hagmandan
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var tlPh = moment.defineLocale('tl-ph', {
+ months: 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split(
+ '_'
+ ),
+ monthsShort: 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
+ weekdays: 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split(
+ '_'
+ ),
+ weekdaysShort: 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
+ weekdaysMin: 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'MM/D/YYYY',
+ LL: 'MMMM D, YYYY',
+ LLL: 'MMMM D, YYYY HH:mm',
+ LLLL: 'dddd, MMMM DD, YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: 'LT [ngayong araw]',
+ nextDay: '[Bukas ng] LT',
+ nextWeek: 'LT [sa susunod na] dddd',
+ lastDay: 'LT [kahapon]',
+ lastWeek: 'LT [noong nakaraang] dddd',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'sa loob ng %s',
+ past: '%s ang nakalipas',
+ s: 'ilang segundo',
+ ss: '%d segundo',
+ m: 'isang minuto',
+ mm: '%d minuto',
+ h: 'isang oras',
+ hh: '%d oras',
+ d: 'isang araw',
+ dd: '%d araw',
+ M: 'isang buwan',
+ MM: '%d buwan',
+ y: 'isang taon',
+ yy: '%d taon',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}/,
+ ordinal: function (number) {
+ return number;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return tlPh;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/tlh.js":
+/*!*******************************************!*\
+ !*** ./node_modules/moment/locale/tlh.js ***!
+ \*******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Klingon [tlh]
+//! author : Dominika Kruk : https://github.com/amaranthrose
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var numbersNouns = 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');
+
+ function translateFuture(output) {
+ var time = output;
+ time =
+ output.indexOf('jaj') !== -1
+ ? time.slice(0, -3) + 'leS'
+ : output.indexOf('jar') !== -1
+ ? time.slice(0, -3) + 'waQ'
+ : output.indexOf('DIS') !== -1
+ ? time.slice(0, -3) + 'nem'
+ : time + ' pIq';
+ return time;
+ }
+
+ function translatePast(output) {
+ var time = output;
+ time =
+ output.indexOf('jaj') !== -1
+ ? time.slice(0, -3) + 'Hu’'
+ : output.indexOf('jar') !== -1
+ ? time.slice(0, -3) + 'wen'
+ : output.indexOf('DIS') !== -1
+ ? time.slice(0, -3) + 'ben'
+ : time + ' ret';
+ return time;
+ }
+
+ function translate(number, withoutSuffix, string, isFuture) {
+ var numberNoun = numberAsNoun(number);
+ switch (string) {
+ case 'ss':
+ return numberNoun + ' lup';
+ case 'mm':
+ return numberNoun + ' tup';
+ case 'hh':
+ return numberNoun + ' rep';
+ case 'dd':
+ return numberNoun + ' jaj';
+ case 'MM':
+ return numberNoun + ' jar';
+ case 'yy':
+ return numberNoun + ' DIS';
+ }
+ }
+
+ function numberAsNoun(number) {
+ var hundred = Math.floor((number % 1000) / 100),
+ ten = Math.floor((number % 100) / 10),
+ one = number % 10,
+ word = '';
+ if (hundred > 0) {
+ word += numbersNouns[hundred] + 'vatlh';
+ }
+ if (ten > 0) {
+ word += (word !== '' ? ' ' : '') + numbersNouns[ten] + 'maH';
+ }
+ if (one > 0) {
+ word += (word !== '' ? ' ' : '') + numbersNouns[one];
+ }
+ return word === '' ? 'pagh' : word;
+ }
+
+ var tlh = moment.defineLocale('tlh', {
+ months: 'tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’'.split(
+ '_'
+ ),
+ monthsShort: 'jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split(
+ '_'
+ ),
+ weekdaysShort: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split(
+ '_'
+ ),
+ weekdaysMin: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split(
+ '_'
+ ),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[DaHjaj] LT',
+ nextDay: '[wa’leS] LT',
+ nextWeek: 'LLL',
+ lastDay: '[wa’Hu’] LT',
+ lastWeek: 'LLL',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: translateFuture,
+ past: translatePast,
+ s: 'puS lup',
+ ss: translate,
+ m: 'wa’ tup',
+ mm: translate,
+ h: 'wa’ rep',
+ hh: translate,
+ d: 'wa’ jaj',
+ dd: translate,
+ M: 'wa’ jar',
+ MM: translate,
+ y: 'wa’ DIS',
+ yy: translate,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return tlh;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/tr.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/tr.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Turkish [tr]
+//! authors : Erhan Gundogan : https://github.com/erhangundogan,
+//! Burak Yiğit Kaya: https://github.com/BYK
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var suffixes = {
+ 1: "'inci",
+ 5: "'inci",
+ 8: "'inci",
+ 70: "'inci",
+ 80: "'inci",
+ 2: "'nci",
+ 7: "'nci",
+ 20: "'nci",
+ 50: "'nci",
+ 3: "'üncü",
+ 4: "'üncü",
+ 100: "'üncü",
+ 6: "'ncı",
+ 9: "'uncu",
+ 10: "'uncu",
+ 30: "'uncu",
+ 60: "'ıncı",
+ 90: "'ıncı",
+ };
+
+ var tr = moment.defineLocale('tr', {
+ months: 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split(
+ '_'
+ ),
+ monthsShort: 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split('_'),
+ weekdays: 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split(
+ '_'
+ ),
+ weekdaysShort: 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
+ weekdaysMin: 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
+ meridiem: function (hours, minutes, isLower) {
+ if (hours < 12) {
+ return isLower ? 'öö' : 'ÖÖ';
+ } else {
+ return isLower ? 'ös' : 'ÖS';
+ }
+ },
+ meridiemParse: /öö|ÖÖ|ös|ÖS/,
+ isPM: function (input) {
+ return input === 'ös' || input === 'ÖS';
+ },
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[bugün saat] LT',
+ nextDay: '[yarın saat] LT',
+ nextWeek: '[gelecek] dddd [saat] LT',
+ lastDay: '[dün] LT',
+ lastWeek: '[geçen] dddd [saat] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s sonra',
+ past: '%s önce',
+ s: 'birkaç saniye',
+ ss: '%d saniye',
+ m: 'bir dakika',
+ mm: '%d dakika',
+ h: 'bir saat',
+ hh: '%d saat',
+ d: 'bir gün',
+ dd: '%d gün',
+ w: 'bir hafta',
+ ww: '%d hafta',
+ M: 'bir ay',
+ MM: '%d ay',
+ y: 'bir yıl',
+ yy: '%d yıl',
+ },
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'd':
+ case 'D':
+ case 'Do':
+ case 'DD':
+ return number;
+ default:
+ if (number === 0) {
+ // special case for zero
+ return number + "'ıncı";
+ }
+ var a = number % 10,
+ b = (number % 100) - a,
+ c = number >= 100 ? 100 : null;
+ return number + (suffixes[a] || suffixes[b] || suffixes[c]);
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return tr;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/tzl.js":
+/*!*******************************************!*\
+ !*** ./node_modules/moment/locale/tzl.js ***!
+ \*******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Talossan [tzl]
+//! author : Robin van der Vliet : https://github.com/robin0van0der0v
+//! author : Iustì Canun
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ // After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.
+ // This is currently too difficult (maybe even impossible) to add.
+ var tzl = moment.defineLocale('tzl', {
+ months: 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split(
+ '_'
+ ),
+ monthsShort: 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
+ weekdays: 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),
+ weekdaysShort: 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),
+ weekdaysMin: 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),
+ longDateFormat: {
+ LT: 'HH.mm',
+ LTS: 'HH.mm.ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D. MMMM [dallas] YYYY',
+ LLL: 'D. MMMM [dallas] YYYY HH.mm',
+ LLLL: 'dddd, [li] D. MMMM [dallas] YYYY HH.mm',
+ },
+ meridiemParse: /d\'o|d\'a/i,
+ isPM: function (input) {
+ return "d'o" === input.toLowerCase();
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours > 11) {
+ return isLower ? "d'o" : "D'O";
+ } else {
+ return isLower ? "d'a" : "D'A";
+ }
+ },
+ calendar: {
+ sameDay: '[oxhi à] LT',
+ nextDay: '[demà à] LT',
+ nextWeek: 'dddd [à] LT',
+ lastDay: '[ieiri à] LT',
+ lastWeek: '[sür el] dddd [lasteu à] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'osprei %s',
+ past: 'ja%s',
+ s: processRelativeTime,
+ ss: processRelativeTime,
+ m: processRelativeTime,
+ mm: processRelativeTime,
+ h: processRelativeTime,
+ hh: processRelativeTime,
+ d: processRelativeTime,
+ dd: processRelativeTime,
+ M: processRelativeTime,
+ MM: processRelativeTime,
+ y: processRelativeTime,
+ yy: processRelativeTime,
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}\./,
+ ordinal: '%d.',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ function processRelativeTime(number, withoutSuffix, key, isFuture) {
+ var format = {
+ s: ['viensas secunds', "'iensas secunds"],
+ ss: [number + ' secunds', '' + number + ' secunds'],
+ m: ["'n míut", "'iens míut"],
+ mm: [number + ' míuts', '' + number + ' míuts'],
+ h: ["'n þora", "'iensa þora"],
+ hh: [number + ' þoras', '' + number + ' þoras'],
+ d: ["'n ziua", "'iensa ziua"],
+ dd: [number + ' ziuas', '' + number + ' ziuas'],
+ M: ["'n mes", "'iens mes"],
+ MM: [number + ' mesen', '' + number + ' mesen'],
+ y: ["'n ar", "'iens ar"],
+ yy: [number + ' ars', '' + number + ' ars'],
+ };
+ return isFuture
+ ? format[key][0]
+ : withoutSuffix
+ ? format[key][0]
+ : format[key][1];
+ }
+
+ return tzl;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/tzm-latn.js":
+/*!************************************************!*\
+ !*** ./node_modules/moment/locale/tzm-latn.js ***!
+ \************************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Central Atlas Tamazight Latin [tzm-latn]
+//! author : Abdel Said : https://github.com/abdelsaid
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var tzmLatn = moment.defineLocale('tzm-latn', {
+ months: 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split(
+ '_'
+ ),
+ monthsShort: 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split(
+ '_'
+ ),
+ weekdays: 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
+ weekdaysShort: 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
+ weekdaysMin: 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[asdkh g] LT',
+ nextDay: '[aska g] LT',
+ nextWeek: 'dddd [g] LT',
+ lastDay: '[assant g] LT',
+ lastWeek: 'dddd [g] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'dadkh s yan %s',
+ past: 'yan %s',
+ s: 'imik',
+ ss: '%d imik',
+ m: 'minuḍ',
+ mm: '%d minuḍ',
+ h: 'saɛa',
+ hh: '%d tassaɛin',
+ d: 'ass',
+ dd: '%d ossan',
+ M: 'ayowr',
+ MM: '%d iyyirn',
+ y: 'asgas',
+ yy: '%d isgasn',
+ },
+ week: {
+ dow: 6, // Saturday is the first day of the week.
+ doy: 12, // The week that contains Jan 12th is the first week of the year.
+ },
+ });
+
+ return tzmLatn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/tzm.js":
+/*!*******************************************!*\
+ !*** ./node_modules/moment/locale/tzm.js ***!
+ \*******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Central Atlas Tamazight [tzm]
+//! author : Abdel Said : https://github.com/abdelsaid
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var tzm = moment.defineLocale('tzm', {
+ months: 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split(
+ '_'
+ ),
+ monthsShort: 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split(
+ '_'
+ ),
+ weekdays: 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
+ weekdaysShort: 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
+ weekdaysMin: 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[ⴰⵙⴷⵅ ⴴ] LT',
+ nextDay: '[ⴰⵙⴽⴰ ⴴ] LT',
+ nextWeek: 'dddd [ⴴ] LT',
+ lastDay: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
+ lastWeek: 'dddd [ⴴ] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
+ past: 'ⵢⴰⵏ %s',
+ s: 'ⵉⵎⵉⴽ',
+ ss: '%d ⵉⵎⵉⴽ',
+ m: 'ⵎⵉⵏⵓⴺ',
+ mm: '%d ⵎⵉⵏⵓⴺ',
+ h: 'ⵙⴰⵄⴰ',
+ hh: '%d ⵜⴰⵙⵙⴰⵄⵉⵏ',
+ d: 'ⴰⵙⵙ',
+ dd: '%d oⵙⵙⴰⵏ',
+ M: 'ⴰⵢoⵓⵔ',
+ MM: '%d ⵉⵢⵢⵉⵔⵏ',
+ y: 'ⴰⵙⴳⴰⵙ',
+ yy: '%d ⵉⵙⴳⴰⵙⵏ',
+ },
+ week: {
+ dow: 6, // Saturday is the first day of the week.
+ doy: 12, // The week that contains Jan 12th is the first week of the year.
+ },
+ });
+
+ return tzm;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ug-cn.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/ug-cn.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Uyghur (China) [ug-cn]
+//! author: boyaq : https://github.com/boyaq
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var ugCn = moment.defineLocale('ug-cn', {
+ months: 'يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر'.split(
+ '_'
+ ),
+ monthsShort: 'يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر'.split(
+ '_'
+ ),
+ weekdays: 'يەكشەنبە_دۈشەنبە_سەيشەنبە_چارشەنبە_پەيشەنبە_جۈمە_شەنبە'.split(
+ '_'
+ ),
+ weekdaysShort: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
+ weekdaysMin: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY-MM-DD',
+ LL: 'YYYY-يىلىM-ئاينىڭD-كۈنى',
+ LLL: 'YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm',
+ LLLL: 'dddd، YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm',
+ },
+ meridiemParse: /يېرىم كېچە|سەھەر|چۈشتىن بۇرۇن|چۈش|چۈشتىن كېيىن|كەچ/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (
+ meridiem === 'يېرىم كېچە' ||
+ meridiem === 'سەھەر' ||
+ meridiem === 'چۈشتىن بۇرۇن'
+ ) {
+ return hour;
+ } else if (meridiem === 'چۈشتىن كېيىن' || meridiem === 'كەچ') {
+ return hour + 12;
+ } else {
+ return hour >= 11 ? hour : hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ var hm = hour * 100 + minute;
+ if (hm < 600) {
+ return 'يېرىم كېچە';
+ } else if (hm < 900) {
+ return 'سەھەر';
+ } else if (hm < 1130) {
+ return 'چۈشتىن بۇرۇن';
+ } else if (hm < 1230) {
+ return 'چۈش';
+ } else if (hm < 1800) {
+ return 'چۈشتىن كېيىن';
+ } else {
+ return 'كەچ';
+ }
+ },
+ calendar: {
+ sameDay: '[بۈگۈن سائەت] LT',
+ nextDay: '[ئەتە سائەت] LT',
+ nextWeek: '[كېلەركى] dddd [سائەت] LT',
+ lastDay: '[تۆنۈگۈن] LT',
+ lastWeek: '[ئالدىنقى] dddd [سائەت] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s كېيىن',
+ past: '%s بۇرۇن',
+ s: 'نەچچە سېكونت',
+ ss: '%d سېكونت',
+ m: 'بىر مىنۇت',
+ mm: '%d مىنۇت',
+ h: 'بىر سائەت',
+ hh: '%d سائەت',
+ d: 'بىر كۈن',
+ dd: '%d كۈن',
+ M: 'بىر ئاي',
+ MM: '%d ئاي',
+ y: 'بىر يىل',
+ yy: '%d يىل',
+ },
+
+ dayOfMonthOrdinalParse: /\d{1,2}(-كۈنى|-ئاي|-ھەپتە)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'd':
+ case 'D':
+ case 'DDD':
+ return number + '-كۈنى';
+ case 'w':
+ case 'W':
+ return number + '-ھەپتە';
+ default:
+ return number;
+ }
+ },
+ preparse: function (string) {
+ return string.replace(/،/g, ',');
+ },
+ postformat: function (string) {
+ return string.replace(/,/g, '،');
+ },
+ week: {
+ // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 1st is the first week of the year.
+ },
+ });
+
+ return ugCn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/uk.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/uk.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Ukrainian [uk]
+//! author : zemlanin : https://github.com/zemlanin
+//! Author : Menelion Elensúle : https://github.com/Oire
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ function plural(word, num) {
+ var forms = word.split('_');
+ return num % 10 === 1 && num % 100 !== 11
+ ? forms[0]
+ : num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20)
+ ? forms[1]
+ : forms[2];
+ }
+ function relativeTimeWithPlural(number, withoutSuffix, key) {
+ var format = {
+ ss: withoutSuffix ? 'секунда_секунди_секунд' : 'секунду_секунди_секунд',
+ mm: withoutSuffix ? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
+ hh: withoutSuffix ? 'година_години_годин' : 'годину_години_годин',
+ dd: 'день_дні_днів',
+ MM: 'місяць_місяці_місяців',
+ yy: 'рік_роки_років',
+ };
+ if (key === 'm') {
+ return withoutSuffix ? 'хвилина' : 'хвилину';
+ } else if (key === 'h') {
+ return withoutSuffix ? 'година' : 'годину';
+ } else {
+ return number + ' ' + plural(format[key], +number);
+ }
+ }
+ function weekdaysCaseReplace(m, format) {
+ var weekdays = {
+ nominative: 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split(
+ '_'
+ ),
+ accusative: 'неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу'.split(
+ '_'
+ ),
+ genitive: 'неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи'.split(
+ '_'
+ ),
+ },
+ nounCase;
+
+ if (m === true) {
+ return weekdays['nominative']
+ .slice(1, 7)
+ .concat(weekdays['nominative'].slice(0, 1));
+ }
+ if (!m) {
+ return weekdays['nominative'];
+ }
+
+ nounCase = /(\[[ВвУу]\]) ?dddd/.test(format)
+ ? 'accusative'
+ : /\[?(?:минулої|наступної)? ?\] ?dddd/.test(format)
+ ? 'genitive'
+ : 'nominative';
+ return weekdays[nounCase][m.day()];
+ }
+ function processHoursFunction(str) {
+ return function () {
+ return str + 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
+ };
+ }
+
+ var uk = moment.defineLocale('uk', {
+ months: {
+ format: 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split(
+ '_'
+ ),
+ standalone: 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split(
+ '_'
+ ),
+ },
+ monthsShort: 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split(
+ '_'
+ ),
+ weekdays: weekdaysCaseReplace,
+ weekdaysShort: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
+ weekdaysMin: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD.MM.YYYY',
+ LL: 'D MMMM YYYY р.',
+ LLL: 'D MMMM YYYY р., HH:mm',
+ LLLL: 'dddd, D MMMM YYYY р., HH:mm',
+ },
+ calendar: {
+ sameDay: processHoursFunction('[Сьогодні '),
+ nextDay: processHoursFunction('[Завтра '),
+ lastDay: processHoursFunction('[Вчора '),
+ nextWeek: processHoursFunction('[У] dddd ['),
+ lastWeek: function () {
+ switch (this.day()) {
+ case 0:
+ case 3:
+ case 5:
+ case 6:
+ return processHoursFunction('[Минулої] dddd [').call(this);
+ case 1:
+ case 2:
+ case 4:
+ return processHoursFunction('[Минулого] dddd [').call(this);
+ }
+ },
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'за %s',
+ past: '%s тому',
+ s: 'декілька секунд',
+ ss: relativeTimeWithPlural,
+ m: relativeTimeWithPlural,
+ mm: relativeTimeWithPlural,
+ h: 'годину',
+ hh: relativeTimeWithPlural,
+ d: 'день',
+ dd: relativeTimeWithPlural,
+ M: 'місяць',
+ MM: relativeTimeWithPlural,
+ y: 'рік',
+ yy: relativeTimeWithPlural,
+ },
+ // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
+ meridiemParse: /ночі|ранку|дня|вечора/,
+ isPM: function (input) {
+ return /^(дня|вечора)$/.test(input);
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 4) {
+ return 'ночі';
+ } else if (hour < 12) {
+ return 'ранку';
+ } else if (hour < 17) {
+ return 'дня';
+ } else {
+ return 'вечора';
+ }
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}-(й|го)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'M':
+ case 'd':
+ case 'DDD':
+ case 'w':
+ case 'W':
+ return number + '-й';
+ case 'D':
+ return number + '-го';
+ default:
+ return number;
+ }
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return uk;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/ur.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/ur.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Urdu [ur]
+//! author : Sawood Alam : https://github.com/ibnesayeed
+//! author : Zack : https://github.com/ZackVision
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var months = [
+ 'جنوری',
+ 'فروری',
+ 'مارچ',
+ 'اپریل',
+ 'مئی',
+ 'جون',
+ 'جولائی',
+ 'اگست',
+ 'ستمبر',
+ 'اکتوبر',
+ 'نومبر',
+ 'دسمبر',
+ ],
+ days = ['اتوار', 'پیر', 'منگل', 'بدھ', 'جمعرات', 'جمعہ', 'ہفتہ'];
+
+ var ur = moment.defineLocale('ur', {
+ months: months,
+ monthsShort: months,
+ weekdays: days,
+ weekdaysShort: days,
+ weekdaysMin: days,
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd، D MMMM YYYY HH:mm',
+ },
+ meridiemParse: /صبح|شام/,
+ isPM: function (input) {
+ return 'شام' === input;
+ },
+ meridiem: function (hour, minute, isLower) {
+ if (hour < 12) {
+ return 'صبح';
+ }
+ return 'شام';
+ },
+ calendar: {
+ sameDay: '[آج بوقت] LT',
+ nextDay: '[کل بوقت] LT',
+ nextWeek: 'dddd [بوقت] LT',
+ lastDay: '[گذشتہ روز بوقت] LT',
+ lastWeek: '[گذشتہ] dddd [بوقت] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s بعد',
+ past: '%s قبل',
+ s: 'چند سیکنڈ',
+ ss: '%d سیکنڈ',
+ m: 'ایک منٹ',
+ mm: '%d منٹ',
+ h: 'ایک گھنٹہ',
+ hh: '%d گھنٹے',
+ d: 'ایک دن',
+ dd: '%d دن',
+ M: 'ایک ماہ',
+ MM: '%d ماہ',
+ y: 'ایک سال',
+ yy: '%d سال',
+ },
+ preparse: function (string) {
+ return string.replace(/،/g, ',');
+ },
+ postformat: function (string) {
+ return string.replace(/,/g, '،');
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return ur;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/uz-latn.js":
+/*!***********************************************!*\
+ !*** ./node_modules/moment/locale/uz-latn.js ***!
+ \***********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Uzbek Latin [uz-latn]
+//! author : Rasulbek Mirzayev : github.com/Rasulbeeek
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var uzLatn = moment.defineLocale('uz-latn', {
+ months: 'Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr'.split(
+ '_'
+ ),
+ monthsShort: 'Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek'.split('_'),
+ weekdays: 'Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba'.split(
+ '_'
+ ),
+ weekdaysShort: 'Yak_Dush_Sesh_Chor_Pay_Jum_Shan'.split('_'),
+ weekdaysMin: 'Ya_Du_Se_Cho_Pa_Ju_Sha'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'D MMMM YYYY, dddd HH:mm',
+ },
+ calendar: {
+ sameDay: '[Bugun soat] LT [da]',
+ nextDay: '[Ertaga] LT [da]',
+ nextWeek: 'dddd [kuni soat] LT [da]',
+ lastDay: '[Kecha soat] LT [da]',
+ lastWeek: "[O'tgan] dddd [kuni soat] LT [da]",
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'Yaqin %s ichida',
+ past: 'Bir necha %s oldin',
+ s: 'soniya',
+ ss: '%d soniya',
+ m: 'bir daqiqa',
+ mm: '%d daqiqa',
+ h: 'bir soat',
+ hh: '%d soat',
+ d: 'bir kun',
+ dd: '%d kun',
+ M: 'bir oy',
+ MM: '%d oy',
+ y: 'bir yil',
+ yy: '%d yil',
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 7th is the first week of the year.
+ },
+ });
+
+ return uzLatn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/uz.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/uz.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Uzbek [uz]
+//! author : Sardor Muminov : https://github.com/muminoff
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var uz = moment.defineLocale('uz', {
+ months: 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split(
+ '_'
+ ),
+ monthsShort: 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
+ weekdays: 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
+ weekdaysShort: 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
+ weekdaysMin: 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'D MMMM YYYY, dddd HH:mm',
+ },
+ calendar: {
+ sameDay: '[Бугун соат] LT [да]',
+ nextDay: '[Эртага] LT [да]',
+ nextWeek: 'dddd [куни соат] LT [да]',
+ lastDay: '[Кеча соат] LT [да]',
+ lastWeek: '[Утган] dddd [куни соат] LT [да]',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'Якин %s ичида',
+ past: 'Бир неча %s олдин',
+ s: 'фурсат',
+ ss: '%d фурсат',
+ m: 'бир дакика',
+ mm: '%d дакика',
+ h: 'бир соат',
+ hh: '%d соат',
+ d: 'бир кун',
+ dd: '%d кун',
+ M: 'бир ой',
+ MM: '%d ой',
+ y: 'бир йил',
+ yy: '%d йил',
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 7, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return uz;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/vi.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/vi.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Vietnamese [vi]
+//! author : Bang Nguyen : https://github.com/bangnk
+//! author : Chien Kira : https://github.com/chienkira
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var vi = moment.defineLocale('vi', {
+ months: 'tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12'.split(
+ '_'
+ ),
+ monthsShort: 'Thg 01_Thg 02_Thg 03_Thg 04_Thg 05_Thg 06_Thg 07_Thg 08_Thg 09_Thg 10_Thg 11_Thg 12'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split(
+ '_'
+ ),
+ weekdaysShort: 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
+ weekdaysMin: 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
+ weekdaysParseExact: true,
+ meridiemParse: /sa|ch/i,
+ isPM: function (input) {
+ return /^ch$/i.test(input);
+ },
+ meridiem: function (hours, minutes, isLower) {
+ if (hours < 12) {
+ return isLower ? 'sa' : 'SA';
+ } else {
+ return isLower ? 'ch' : 'CH';
+ }
+ },
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM [năm] YYYY',
+ LLL: 'D MMMM [năm] YYYY HH:mm',
+ LLLL: 'dddd, D MMMM [năm] YYYY HH:mm',
+ l: 'DD/M/YYYY',
+ ll: 'D MMM YYYY',
+ lll: 'D MMM YYYY HH:mm',
+ llll: 'ddd, D MMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[Hôm nay lúc] LT',
+ nextDay: '[Ngày mai lúc] LT',
+ nextWeek: 'dddd [tuần tới lúc] LT',
+ lastDay: '[Hôm qua lúc] LT',
+ lastWeek: 'dddd [tuần trước lúc] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: '%s tới',
+ past: '%s trước',
+ s: 'vài giây',
+ ss: '%d giây',
+ m: 'một phút',
+ mm: '%d phút',
+ h: 'một giờ',
+ hh: '%d giờ',
+ d: 'một ngày',
+ dd: '%d ngày',
+ w: 'một tuần',
+ ww: '%d tuần',
+ M: 'một tháng',
+ MM: '%d tháng',
+ y: 'một năm',
+ yy: '%d năm',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}/,
+ ordinal: function (number) {
+ return number;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return vi;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/x-pseudo.js":
+/*!************************************************!*\
+ !*** ./node_modules/moment/locale/x-pseudo.js ***!
+ \************************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Pseudo [x-pseudo]
+//! author : Andrew Hood : https://github.com/andrewhood125
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var xPseudo = moment.defineLocale('x-pseudo', {
+ months: 'J~áñúá~rý_F~ébrú~árý_~Márc~h_Áp~ríl_~Máý_~Júñé~_Júl~ý_Áú~gúst~_Sép~témb~ér_Ó~ctób~ér_Ñ~óvém~bér_~Décé~mbér'.split(
+ '_'
+ ),
+ monthsShort: 'J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc'.split(
+ '_'
+ ),
+ monthsParseExact: true,
+ weekdays: 'S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý'.split(
+ '_'
+ ),
+ weekdaysShort: 'S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát'.split('_'),
+ weekdaysMin: 'S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá'.split('_'),
+ weekdaysParseExact: true,
+ longDateFormat: {
+ LT: 'HH:mm',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY HH:mm',
+ LLLL: 'dddd, D MMMM YYYY HH:mm',
+ },
+ calendar: {
+ sameDay: '[T~ódá~ý át] LT',
+ nextDay: '[T~ómó~rró~w át] LT',
+ nextWeek: 'dddd [át] LT',
+ lastDay: '[Ý~ést~érdá~ý át] LT',
+ lastWeek: '[L~ást] dddd [át] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'í~ñ %s',
+ past: '%s á~gó',
+ s: 'á ~féw ~sécó~ñds',
+ ss: '%d s~écóñ~ds',
+ m: 'á ~míñ~úté',
+ mm: '%d m~íñú~tés',
+ h: 'á~ñ hó~úr',
+ hh: '%d h~óúrs',
+ d: 'á ~dáý',
+ dd: '%d d~áýs',
+ M: 'á ~móñ~th',
+ MM: '%d m~óñt~hs',
+ y: 'á ~ýéár',
+ yy: '%d ý~éárs',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ ~~((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return xPseudo;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/yo.js":
+/*!******************************************!*\
+ !*** ./node_modules/moment/locale/yo.js ***!
+ \******************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Yoruba Nigeria [yo]
+//! author : Atolagbe Abisoye : https://github.com/andela-batolagbe
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var yo = moment.defineLocale('yo', {
+ months: 'Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀'.split(
+ '_'
+ ),
+ monthsShort: 'Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀'.split('_'),
+ weekdays: 'Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta'.split('_'),
+ weekdaysShort: 'Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá'.split('_'),
+ weekdaysMin: 'Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb'.split('_'),
+ longDateFormat: {
+ LT: 'h:mm A',
+ LTS: 'h:mm:ss A',
+ L: 'DD/MM/YYYY',
+ LL: 'D MMMM YYYY',
+ LLL: 'D MMMM YYYY h:mm A',
+ LLLL: 'dddd, D MMMM YYYY h:mm A',
+ },
+ calendar: {
+ sameDay: '[Ònì ni] LT',
+ nextDay: '[Ọ̀la ni] LT',
+ nextWeek: "dddd [Ọsẹ̀ tón'bọ] [ni] LT",
+ lastDay: '[Àna ni] LT',
+ lastWeek: 'dddd [Ọsẹ̀ tólọ́] [ni] LT',
+ sameElse: 'L',
+ },
+ relativeTime: {
+ future: 'ní %s',
+ past: '%s kọjá',
+ s: 'ìsẹjú aayá die',
+ ss: 'aayá %d',
+ m: 'ìsẹjú kan',
+ mm: 'ìsẹjú %d',
+ h: 'wákati kan',
+ hh: 'wákati %d',
+ d: 'ọjọ́ kan',
+ dd: 'ọjọ́ %d',
+ M: 'osù kan',
+ MM: 'osù %d',
+ y: 'ọdún kan',
+ yy: 'ọdún %d',
+ },
+ dayOfMonthOrdinalParse: /ọjọ́\s\d{1,2}/,
+ ordinal: 'ọjọ́ %d',
+ week: {
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return yo;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/zh-cn.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/zh-cn.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Chinese (China) [zh-cn]
+//! author : suupic : https://github.com/suupic
+//! author : Zeno Zeng : https://github.com/zenozeng
+//! author : uu109 : https://github.com/uu109
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var zhCn = moment.defineLocale('zh-cn', {
+ months: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split(
+ '_'
+ ),
+ monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
+ '_'
+ ),
+ weekdays: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
+ weekdaysShort: '周日_周一_周二_周三_周四_周五_周六'.split('_'),
+ weekdaysMin: '日_一_二_三_四_五_六'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY/MM/DD',
+ LL: 'YYYY年M月D日',
+ LLL: 'YYYY年M月D日Ah点mm分',
+ LLLL: 'YYYY年M月D日ddddAh点mm分',
+ l: 'YYYY/M/D',
+ ll: 'YYYY年M月D日',
+ lll: 'YYYY年M月D日 HH:mm',
+ llll: 'YYYY年M月D日dddd HH:mm',
+ },
+ meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
+ return hour;
+ } else if (meridiem === '下午' || meridiem === '晚上') {
+ return hour + 12;
+ } else {
+ // '中午'
+ return hour >= 11 ? hour : hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ var hm = hour * 100 + minute;
+ if (hm < 600) {
+ return '凌晨';
+ } else if (hm < 900) {
+ return '早上';
+ } else if (hm < 1130) {
+ return '上午';
+ } else if (hm < 1230) {
+ return '中午';
+ } else if (hm < 1800) {
+ return '下午';
+ } else {
+ return '晚上';
+ }
+ },
+ calendar: {
+ sameDay: '[今天]LT',
+ nextDay: '[明天]LT',
+ nextWeek: function (now) {
+ if (now.week() !== this.week()) {
+ return '[下]dddLT';
+ } else {
+ return '[本]dddLT';
+ }
+ },
+ lastDay: '[昨天]LT',
+ lastWeek: function (now) {
+ if (this.week() !== now.week()) {
+ return '[上]dddLT';
+ } else {
+ return '[本]dddLT';
+ }
+ },
+ sameElse: 'L',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(日|月|周)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'd':
+ case 'D':
+ case 'DDD':
+ return number + '日';
+ case 'M':
+ return number + '月';
+ case 'w':
+ case 'W':
+ return number + '周';
+ default:
+ return number;
+ }
+ },
+ relativeTime: {
+ future: '%s后',
+ past: '%s前',
+ s: '几秒',
+ ss: '%d 秒',
+ m: '1 分钟',
+ mm: '%d 分钟',
+ h: '1 小时',
+ hh: '%d 小时',
+ d: '1 天',
+ dd: '%d 天',
+ w: '1 周',
+ ww: '%d 周',
+ M: '1 个月',
+ MM: '%d 个月',
+ y: '1 年',
+ yy: '%d 年',
+ },
+ week: {
+ // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
+ dow: 1, // Monday is the first day of the week.
+ doy: 4, // The week that contains Jan 4th is the first week of the year.
+ },
+ });
+
+ return zhCn;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/zh-hk.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/zh-hk.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Chinese (Hong Kong) [zh-hk]
+//! author : Ben : https://github.com/ben-lin
+//! author : Chris Lam : https://github.com/hehachris
+//! author : Konstantin : https://github.com/skfd
+//! author : Anthony : https://github.com/anthonylau
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var zhHk = moment.defineLocale('zh-hk', {
+ months: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split(
+ '_'
+ ),
+ monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
+ '_'
+ ),
+ weekdays: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
+ weekdaysShort: '週日_週一_週二_週三_週四_週五_週六'.split('_'),
+ weekdaysMin: '日_一_二_三_四_五_六'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY/MM/DD',
+ LL: 'YYYY年M月D日',
+ LLL: 'YYYY年M月D日 HH:mm',
+ LLLL: 'YYYY年M月D日dddd HH:mm',
+ l: 'YYYY/M/D',
+ ll: 'YYYY年M月D日',
+ lll: 'YYYY年M月D日 HH:mm',
+ llll: 'YYYY年M月D日dddd HH:mm',
+ },
+ meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
+ return hour;
+ } else if (meridiem === '中午') {
+ return hour >= 11 ? hour : hour + 12;
+ } else if (meridiem === '下午' || meridiem === '晚上') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ var hm = hour * 100 + minute;
+ if (hm < 600) {
+ return '凌晨';
+ } else if (hm < 900) {
+ return '早上';
+ } else if (hm < 1200) {
+ return '上午';
+ } else if (hm === 1200) {
+ return '中午';
+ } else if (hm < 1800) {
+ return '下午';
+ } else {
+ return '晚上';
+ }
+ },
+ calendar: {
+ sameDay: '[今天]LT',
+ nextDay: '[明天]LT',
+ nextWeek: '[下]ddddLT',
+ lastDay: '[昨天]LT',
+ lastWeek: '[上]ddddLT',
+ sameElse: 'L',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'd':
+ case 'D':
+ case 'DDD':
+ return number + '日';
+ case 'M':
+ return number + '月';
+ case 'w':
+ case 'W':
+ return number + '週';
+ default:
+ return number;
+ }
+ },
+ relativeTime: {
+ future: '%s後',
+ past: '%s前',
+ s: '幾秒',
+ ss: '%d 秒',
+ m: '1 分鐘',
+ mm: '%d 分鐘',
+ h: '1 小時',
+ hh: '%d 小時',
+ d: '1 天',
+ dd: '%d 天',
+ M: '1 個月',
+ MM: '%d 個月',
+ y: '1 年',
+ yy: '%d 年',
+ },
+ });
+
+ return zhHk;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/zh-mo.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/zh-mo.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Chinese (Macau) [zh-mo]
+//! author : Ben : https://github.com/ben-lin
+//! author : Chris Lam : https://github.com/hehachris
+//! author : Tan Yuanhong : https://github.com/le0tan
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var zhMo = moment.defineLocale('zh-mo', {
+ months: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split(
+ '_'
+ ),
+ monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
+ '_'
+ ),
+ weekdays: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
+ weekdaysShort: '週日_週一_週二_週三_週四_週五_週六'.split('_'),
+ weekdaysMin: '日_一_二_三_四_五_六'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'DD/MM/YYYY',
+ LL: 'YYYY年M月D日',
+ LLL: 'YYYY年M月D日 HH:mm',
+ LLLL: 'YYYY年M月D日dddd HH:mm',
+ l: 'D/M/YYYY',
+ ll: 'YYYY年M月D日',
+ lll: 'YYYY年M月D日 HH:mm',
+ llll: 'YYYY年M月D日dddd HH:mm',
+ },
+ meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
+ return hour;
+ } else if (meridiem === '中午') {
+ return hour >= 11 ? hour : hour + 12;
+ } else if (meridiem === '下午' || meridiem === '晚上') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ var hm = hour * 100 + minute;
+ if (hm < 600) {
+ return '凌晨';
+ } else if (hm < 900) {
+ return '早上';
+ } else if (hm < 1130) {
+ return '上午';
+ } else if (hm < 1230) {
+ return '中午';
+ } else if (hm < 1800) {
+ return '下午';
+ } else {
+ return '晚上';
+ }
+ },
+ calendar: {
+ sameDay: '[今天] LT',
+ nextDay: '[明天] LT',
+ nextWeek: '[下]dddd LT',
+ lastDay: '[昨天] LT',
+ lastWeek: '[上]dddd LT',
+ sameElse: 'L',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'd':
+ case 'D':
+ case 'DDD':
+ return number + '日';
+ case 'M':
+ return number + '月';
+ case 'w':
+ case 'W':
+ return number + '週';
+ default:
+ return number;
+ }
+ },
+ relativeTime: {
+ future: '%s內',
+ past: '%s前',
+ s: '幾秒',
+ ss: '%d 秒',
+ m: '1 分鐘',
+ mm: '%d 分鐘',
+ h: '1 小時',
+ hh: '%d 小時',
+ d: '1 天',
+ dd: '%d 天',
+ M: '1 個月',
+ MM: '%d 個月',
+ y: '1 年',
+ yy: '%d 年',
+ },
+ });
+
+ return zhMo;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale/zh-tw.js":
+/*!*********************************************!*\
+ !*** ./node_modules/moment/locale/zh-tw.js ***!
+ \*********************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+//! moment.js locale configuration
+//! locale : Chinese (Taiwan) [zh-tw]
+//! author : Ben : https://github.com/ben-lin
+//! author : Chris Lam : https://github.com/hehachris
+
+;(function (global, factory) {
+ true ? factory(__webpack_require__(/*! ../moment */ "./node_modules/moment/moment.js")) :
+ 0
+}(this, (function (moment) { 'use strict';
+
+ //! moment.js locale configuration
+
+ var zhTw = moment.defineLocale('zh-tw', {
+ months: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split(
+ '_'
+ ),
+ monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
+ '_'
+ ),
+ weekdays: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
+ weekdaysShort: '週日_週一_週二_週三_週四_週五_週六'.split('_'),
+ weekdaysMin: '日_一_二_三_四_五_六'.split('_'),
+ longDateFormat: {
+ LT: 'HH:mm',
+ LTS: 'HH:mm:ss',
+ L: 'YYYY/MM/DD',
+ LL: 'YYYY年M月D日',
+ LLL: 'YYYY年M月D日 HH:mm',
+ LLLL: 'YYYY年M月D日dddd HH:mm',
+ l: 'YYYY/M/D',
+ ll: 'YYYY年M月D日',
+ lll: 'YYYY年M月D日 HH:mm',
+ llll: 'YYYY年M月D日dddd HH:mm',
+ },
+ meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
+ meridiemHour: function (hour, meridiem) {
+ if (hour === 12) {
+ hour = 0;
+ }
+ if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
+ return hour;
+ } else if (meridiem === '中午') {
+ return hour >= 11 ? hour : hour + 12;
+ } else if (meridiem === '下午' || meridiem === '晚上') {
+ return hour + 12;
+ }
+ },
+ meridiem: function (hour, minute, isLower) {
+ var hm = hour * 100 + minute;
+ if (hm < 600) {
+ return '凌晨';
+ } else if (hm < 900) {
+ return '早上';
+ } else if (hm < 1130) {
+ return '上午';
+ } else if (hm < 1230) {
+ return '中午';
+ } else if (hm < 1800) {
+ return '下午';
+ } else {
+ return '晚上';
+ }
+ },
+ calendar: {
+ sameDay: '[今天] LT',
+ nextDay: '[明天] LT',
+ nextWeek: '[下]dddd LT',
+ lastDay: '[昨天] LT',
+ lastWeek: '[上]dddd LT',
+ sameElse: 'L',
+ },
+ dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
+ ordinal: function (number, period) {
+ switch (period) {
+ case 'd':
+ case 'D':
+ case 'DDD':
+ return number + '日';
+ case 'M':
+ return number + '月';
+ case 'w':
+ case 'W':
+ return number + '週';
+ default:
+ return number;
+ }
+ },
+ relativeTime: {
+ future: '%s後',
+ past: '%s前',
+ s: '幾秒',
+ ss: '%d 秒',
+ m: '1 分鐘',
+ mm: '%d 分鐘',
+ h: '1 小時',
+ hh: '%d 小時',
+ d: '1 天',
+ dd: '%d 天',
+ M: '1 個月',
+ MM: '%d 個月',
+ y: '1 年',
+ yy: '%d 年',
+ },
+ });
+
+ return zhTw;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/moment/locale sync recursive ^\\.\\/.*$":
+/*!***************************************************!*\
+ !*** ./node_modules/moment/locale/ sync ^\.\/.*$ ***!
+ \***************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var map = {
+ "./af": "./node_modules/moment/locale/af.js",
+ "./af.js": "./node_modules/moment/locale/af.js",
+ "./ar": "./node_modules/moment/locale/ar.js",
+ "./ar-dz": "./node_modules/moment/locale/ar-dz.js",
+ "./ar-dz.js": "./node_modules/moment/locale/ar-dz.js",
+ "./ar-kw": "./node_modules/moment/locale/ar-kw.js",
+ "./ar-kw.js": "./node_modules/moment/locale/ar-kw.js",
+ "./ar-ly": "./node_modules/moment/locale/ar-ly.js",
+ "./ar-ly.js": "./node_modules/moment/locale/ar-ly.js",
+ "./ar-ma": "./node_modules/moment/locale/ar-ma.js",
+ "./ar-ma.js": "./node_modules/moment/locale/ar-ma.js",
+ "./ar-sa": "./node_modules/moment/locale/ar-sa.js",
+ "./ar-sa.js": "./node_modules/moment/locale/ar-sa.js",
+ "./ar-tn": "./node_modules/moment/locale/ar-tn.js",
+ "./ar-tn.js": "./node_modules/moment/locale/ar-tn.js",
+ "./ar.js": "./node_modules/moment/locale/ar.js",
+ "./az": "./node_modules/moment/locale/az.js",
+ "./az.js": "./node_modules/moment/locale/az.js",
+ "./be": "./node_modules/moment/locale/be.js",
+ "./be.js": "./node_modules/moment/locale/be.js",
+ "./bg": "./node_modules/moment/locale/bg.js",
+ "./bg.js": "./node_modules/moment/locale/bg.js",
+ "./bm": "./node_modules/moment/locale/bm.js",
+ "./bm.js": "./node_modules/moment/locale/bm.js",
+ "./bn": "./node_modules/moment/locale/bn.js",
+ "./bn-bd": "./node_modules/moment/locale/bn-bd.js",
+ "./bn-bd.js": "./node_modules/moment/locale/bn-bd.js",
+ "./bn.js": "./node_modules/moment/locale/bn.js",
+ "./bo": "./node_modules/moment/locale/bo.js",
+ "./bo.js": "./node_modules/moment/locale/bo.js",
+ "./br": "./node_modules/moment/locale/br.js",
+ "./br.js": "./node_modules/moment/locale/br.js",
+ "./bs": "./node_modules/moment/locale/bs.js",
+ "./bs.js": "./node_modules/moment/locale/bs.js",
+ "./ca": "./node_modules/moment/locale/ca.js",
+ "./ca.js": "./node_modules/moment/locale/ca.js",
+ "./cs": "./node_modules/moment/locale/cs.js",
+ "./cs.js": "./node_modules/moment/locale/cs.js",
+ "./cv": "./node_modules/moment/locale/cv.js",
+ "./cv.js": "./node_modules/moment/locale/cv.js",
+ "./cy": "./node_modules/moment/locale/cy.js",
+ "./cy.js": "./node_modules/moment/locale/cy.js",
+ "./da": "./node_modules/moment/locale/da.js",
+ "./da.js": "./node_modules/moment/locale/da.js",
+ "./de": "./node_modules/moment/locale/de.js",
+ "./de-at": "./node_modules/moment/locale/de-at.js",
+ "./de-at.js": "./node_modules/moment/locale/de-at.js",
+ "./de-ch": "./node_modules/moment/locale/de-ch.js",
+ "./de-ch.js": "./node_modules/moment/locale/de-ch.js",
+ "./de.js": "./node_modules/moment/locale/de.js",
+ "./dv": "./node_modules/moment/locale/dv.js",
+ "./dv.js": "./node_modules/moment/locale/dv.js",
+ "./el": "./node_modules/moment/locale/el.js",
+ "./el.js": "./node_modules/moment/locale/el.js",
+ "./en-au": "./node_modules/moment/locale/en-au.js",
+ "./en-au.js": "./node_modules/moment/locale/en-au.js",
+ "./en-ca": "./node_modules/moment/locale/en-ca.js",
+ "./en-ca.js": "./node_modules/moment/locale/en-ca.js",
+ "./en-gb": "./node_modules/moment/locale/en-gb.js",
+ "./en-gb.js": "./node_modules/moment/locale/en-gb.js",
+ "./en-ie": "./node_modules/moment/locale/en-ie.js",
+ "./en-ie.js": "./node_modules/moment/locale/en-ie.js",
+ "./en-il": "./node_modules/moment/locale/en-il.js",
+ "./en-il.js": "./node_modules/moment/locale/en-il.js",
+ "./en-in": "./node_modules/moment/locale/en-in.js",
+ "./en-in.js": "./node_modules/moment/locale/en-in.js",
+ "./en-nz": "./node_modules/moment/locale/en-nz.js",
+ "./en-nz.js": "./node_modules/moment/locale/en-nz.js",
+ "./en-sg": "./node_modules/moment/locale/en-sg.js",
+ "./en-sg.js": "./node_modules/moment/locale/en-sg.js",
+ "./eo": "./node_modules/moment/locale/eo.js",
+ "./eo.js": "./node_modules/moment/locale/eo.js",
+ "./es": "./node_modules/moment/locale/es.js",
+ "./es-do": "./node_modules/moment/locale/es-do.js",
+ "./es-do.js": "./node_modules/moment/locale/es-do.js",
+ "./es-mx": "./node_modules/moment/locale/es-mx.js",
+ "./es-mx.js": "./node_modules/moment/locale/es-mx.js",
+ "./es-us": "./node_modules/moment/locale/es-us.js",
+ "./es-us.js": "./node_modules/moment/locale/es-us.js",
+ "./es.js": "./node_modules/moment/locale/es.js",
+ "./et": "./node_modules/moment/locale/et.js",
+ "./et.js": "./node_modules/moment/locale/et.js",
+ "./eu": "./node_modules/moment/locale/eu.js",
+ "./eu.js": "./node_modules/moment/locale/eu.js",
+ "./fa": "./node_modules/moment/locale/fa.js",
+ "./fa.js": "./node_modules/moment/locale/fa.js",
+ "./fi": "./node_modules/moment/locale/fi.js",
+ "./fi.js": "./node_modules/moment/locale/fi.js",
+ "./fil": "./node_modules/moment/locale/fil.js",
+ "./fil.js": "./node_modules/moment/locale/fil.js",
+ "./fo": "./node_modules/moment/locale/fo.js",
+ "./fo.js": "./node_modules/moment/locale/fo.js",
+ "./fr": "./node_modules/moment/locale/fr.js",
+ "./fr-ca": "./node_modules/moment/locale/fr-ca.js",
+ "./fr-ca.js": "./node_modules/moment/locale/fr-ca.js",
+ "./fr-ch": "./node_modules/moment/locale/fr-ch.js",
+ "./fr-ch.js": "./node_modules/moment/locale/fr-ch.js",
+ "./fr.js": "./node_modules/moment/locale/fr.js",
+ "./fy": "./node_modules/moment/locale/fy.js",
+ "./fy.js": "./node_modules/moment/locale/fy.js",
+ "./ga": "./node_modules/moment/locale/ga.js",
+ "./ga.js": "./node_modules/moment/locale/ga.js",
+ "./gd": "./node_modules/moment/locale/gd.js",
+ "./gd.js": "./node_modules/moment/locale/gd.js",
+ "./gl": "./node_modules/moment/locale/gl.js",
+ "./gl.js": "./node_modules/moment/locale/gl.js",
+ "./gom-deva": "./node_modules/moment/locale/gom-deva.js",
+ "./gom-deva.js": "./node_modules/moment/locale/gom-deva.js",
+ "./gom-latn": "./node_modules/moment/locale/gom-latn.js",
+ "./gom-latn.js": "./node_modules/moment/locale/gom-latn.js",
+ "./gu": "./node_modules/moment/locale/gu.js",
+ "./gu.js": "./node_modules/moment/locale/gu.js",
+ "./he": "./node_modules/moment/locale/he.js",
+ "./he.js": "./node_modules/moment/locale/he.js",
+ "./hi": "./node_modules/moment/locale/hi.js",
+ "./hi.js": "./node_modules/moment/locale/hi.js",
+ "./hr": "./node_modules/moment/locale/hr.js",
+ "./hr.js": "./node_modules/moment/locale/hr.js",
+ "./hu": "./node_modules/moment/locale/hu.js",
+ "./hu.js": "./node_modules/moment/locale/hu.js",
+ "./hy-am": "./node_modules/moment/locale/hy-am.js",
+ "./hy-am.js": "./node_modules/moment/locale/hy-am.js",
+ "./id": "./node_modules/moment/locale/id.js",
+ "./id.js": "./node_modules/moment/locale/id.js",
+ "./is": "./node_modules/moment/locale/is.js",
+ "./is.js": "./node_modules/moment/locale/is.js",
+ "./it": "./node_modules/moment/locale/it.js",
+ "./it-ch": "./node_modules/moment/locale/it-ch.js",
+ "./it-ch.js": "./node_modules/moment/locale/it-ch.js",
+ "./it.js": "./node_modules/moment/locale/it.js",
+ "./ja": "./node_modules/moment/locale/ja.js",
+ "./ja.js": "./node_modules/moment/locale/ja.js",
+ "./jv": "./node_modules/moment/locale/jv.js",
+ "./jv.js": "./node_modules/moment/locale/jv.js",
+ "./ka": "./node_modules/moment/locale/ka.js",
+ "./ka.js": "./node_modules/moment/locale/ka.js",
+ "./kk": "./node_modules/moment/locale/kk.js",
+ "./kk.js": "./node_modules/moment/locale/kk.js",
+ "./km": "./node_modules/moment/locale/km.js",
+ "./km.js": "./node_modules/moment/locale/km.js",
+ "./kn": "./node_modules/moment/locale/kn.js",
+ "./kn.js": "./node_modules/moment/locale/kn.js",
+ "./ko": "./node_modules/moment/locale/ko.js",
+ "./ko.js": "./node_modules/moment/locale/ko.js",
+ "./ku": "./node_modules/moment/locale/ku.js",
+ "./ku.js": "./node_modules/moment/locale/ku.js",
+ "./ky": "./node_modules/moment/locale/ky.js",
+ "./ky.js": "./node_modules/moment/locale/ky.js",
+ "./lb": "./node_modules/moment/locale/lb.js",
+ "./lb.js": "./node_modules/moment/locale/lb.js",
+ "./lo": "./node_modules/moment/locale/lo.js",
+ "./lo.js": "./node_modules/moment/locale/lo.js",
+ "./lt": "./node_modules/moment/locale/lt.js",
+ "./lt.js": "./node_modules/moment/locale/lt.js",
+ "./lv": "./node_modules/moment/locale/lv.js",
+ "./lv.js": "./node_modules/moment/locale/lv.js",
+ "./me": "./node_modules/moment/locale/me.js",
+ "./me.js": "./node_modules/moment/locale/me.js",
+ "./mi": "./node_modules/moment/locale/mi.js",
+ "./mi.js": "./node_modules/moment/locale/mi.js",
+ "./mk": "./node_modules/moment/locale/mk.js",
+ "./mk.js": "./node_modules/moment/locale/mk.js",
+ "./ml": "./node_modules/moment/locale/ml.js",
+ "./ml.js": "./node_modules/moment/locale/ml.js",
+ "./mn": "./node_modules/moment/locale/mn.js",
+ "./mn.js": "./node_modules/moment/locale/mn.js",
+ "./mr": "./node_modules/moment/locale/mr.js",
+ "./mr.js": "./node_modules/moment/locale/mr.js",
+ "./ms": "./node_modules/moment/locale/ms.js",
+ "./ms-my": "./node_modules/moment/locale/ms-my.js",
+ "./ms-my.js": "./node_modules/moment/locale/ms-my.js",
+ "./ms.js": "./node_modules/moment/locale/ms.js",
+ "./mt": "./node_modules/moment/locale/mt.js",
+ "./mt.js": "./node_modules/moment/locale/mt.js",
+ "./my": "./node_modules/moment/locale/my.js",
+ "./my.js": "./node_modules/moment/locale/my.js",
+ "./nb": "./node_modules/moment/locale/nb.js",
+ "./nb.js": "./node_modules/moment/locale/nb.js",
+ "./ne": "./node_modules/moment/locale/ne.js",
+ "./ne.js": "./node_modules/moment/locale/ne.js",
+ "./nl": "./node_modules/moment/locale/nl.js",
+ "./nl-be": "./node_modules/moment/locale/nl-be.js",
+ "./nl-be.js": "./node_modules/moment/locale/nl-be.js",
+ "./nl.js": "./node_modules/moment/locale/nl.js",
+ "./nn": "./node_modules/moment/locale/nn.js",
+ "./nn.js": "./node_modules/moment/locale/nn.js",
+ "./oc-lnc": "./node_modules/moment/locale/oc-lnc.js",
+ "./oc-lnc.js": "./node_modules/moment/locale/oc-lnc.js",
+ "./pa-in": "./node_modules/moment/locale/pa-in.js",
+ "./pa-in.js": "./node_modules/moment/locale/pa-in.js",
+ "./pl": "./node_modules/moment/locale/pl.js",
+ "./pl.js": "./node_modules/moment/locale/pl.js",
+ "./pt": "./node_modules/moment/locale/pt.js",
+ "./pt-br": "./node_modules/moment/locale/pt-br.js",
+ "./pt-br.js": "./node_modules/moment/locale/pt-br.js",
+ "./pt.js": "./node_modules/moment/locale/pt.js",
+ "./ro": "./node_modules/moment/locale/ro.js",
+ "./ro.js": "./node_modules/moment/locale/ro.js",
+ "./ru": "./node_modules/moment/locale/ru.js",
+ "./ru.js": "./node_modules/moment/locale/ru.js",
+ "./sd": "./node_modules/moment/locale/sd.js",
+ "./sd.js": "./node_modules/moment/locale/sd.js",
+ "./se": "./node_modules/moment/locale/se.js",
+ "./se.js": "./node_modules/moment/locale/se.js",
+ "./si": "./node_modules/moment/locale/si.js",
+ "./si.js": "./node_modules/moment/locale/si.js",
+ "./sk": "./node_modules/moment/locale/sk.js",
+ "./sk.js": "./node_modules/moment/locale/sk.js",
+ "./sl": "./node_modules/moment/locale/sl.js",
+ "./sl.js": "./node_modules/moment/locale/sl.js",
+ "./sq": "./node_modules/moment/locale/sq.js",
+ "./sq.js": "./node_modules/moment/locale/sq.js",
+ "./sr": "./node_modules/moment/locale/sr.js",
+ "./sr-cyrl": "./node_modules/moment/locale/sr-cyrl.js",
+ "./sr-cyrl.js": "./node_modules/moment/locale/sr-cyrl.js",
+ "./sr.js": "./node_modules/moment/locale/sr.js",
+ "./ss": "./node_modules/moment/locale/ss.js",
+ "./ss.js": "./node_modules/moment/locale/ss.js",
+ "./sv": "./node_modules/moment/locale/sv.js",
+ "./sv.js": "./node_modules/moment/locale/sv.js",
+ "./sw": "./node_modules/moment/locale/sw.js",
+ "./sw.js": "./node_modules/moment/locale/sw.js",
+ "./ta": "./node_modules/moment/locale/ta.js",
+ "./ta.js": "./node_modules/moment/locale/ta.js",
+ "./te": "./node_modules/moment/locale/te.js",
+ "./te.js": "./node_modules/moment/locale/te.js",
+ "./tet": "./node_modules/moment/locale/tet.js",
+ "./tet.js": "./node_modules/moment/locale/tet.js",
+ "./tg": "./node_modules/moment/locale/tg.js",
+ "./tg.js": "./node_modules/moment/locale/tg.js",
+ "./th": "./node_modules/moment/locale/th.js",
+ "./th.js": "./node_modules/moment/locale/th.js",
+ "./tk": "./node_modules/moment/locale/tk.js",
+ "./tk.js": "./node_modules/moment/locale/tk.js",
+ "./tl-ph": "./node_modules/moment/locale/tl-ph.js",
+ "./tl-ph.js": "./node_modules/moment/locale/tl-ph.js",
+ "./tlh": "./node_modules/moment/locale/tlh.js",
+ "./tlh.js": "./node_modules/moment/locale/tlh.js",
+ "./tr": "./node_modules/moment/locale/tr.js",
+ "./tr.js": "./node_modules/moment/locale/tr.js",
+ "./tzl": "./node_modules/moment/locale/tzl.js",
+ "./tzl.js": "./node_modules/moment/locale/tzl.js",
+ "./tzm": "./node_modules/moment/locale/tzm.js",
+ "./tzm-latn": "./node_modules/moment/locale/tzm-latn.js",
+ "./tzm-latn.js": "./node_modules/moment/locale/tzm-latn.js",
+ "./tzm.js": "./node_modules/moment/locale/tzm.js",
+ "./ug-cn": "./node_modules/moment/locale/ug-cn.js",
+ "./ug-cn.js": "./node_modules/moment/locale/ug-cn.js",
+ "./uk": "./node_modules/moment/locale/uk.js",
+ "./uk.js": "./node_modules/moment/locale/uk.js",
+ "./ur": "./node_modules/moment/locale/ur.js",
+ "./ur.js": "./node_modules/moment/locale/ur.js",
+ "./uz": "./node_modules/moment/locale/uz.js",
+ "./uz-latn": "./node_modules/moment/locale/uz-latn.js",
+ "./uz-latn.js": "./node_modules/moment/locale/uz-latn.js",
+ "./uz.js": "./node_modules/moment/locale/uz.js",
+ "./vi": "./node_modules/moment/locale/vi.js",
+ "./vi.js": "./node_modules/moment/locale/vi.js",
+ "./x-pseudo": "./node_modules/moment/locale/x-pseudo.js",
+ "./x-pseudo.js": "./node_modules/moment/locale/x-pseudo.js",
+ "./yo": "./node_modules/moment/locale/yo.js",
+ "./yo.js": "./node_modules/moment/locale/yo.js",
+ "./zh-cn": "./node_modules/moment/locale/zh-cn.js",
+ "./zh-cn.js": "./node_modules/moment/locale/zh-cn.js",
+ "./zh-hk": "./node_modules/moment/locale/zh-hk.js",
+ "./zh-hk.js": "./node_modules/moment/locale/zh-hk.js",
+ "./zh-mo": "./node_modules/moment/locale/zh-mo.js",
+ "./zh-mo.js": "./node_modules/moment/locale/zh-mo.js",
+ "./zh-tw": "./node_modules/moment/locale/zh-tw.js",
+ "./zh-tw.js": "./node_modules/moment/locale/zh-tw.js"
+};
+
+
+function webpackContext(req) {
+ var id = webpackContextResolve(req);
+ return __webpack_require__(id);
+}
+function webpackContextResolve(req) {
+ if(!__webpack_require__.o(map, req)) {
+ var e = new Error("Cannot find module '" + req + "'");
+ e.code = 'MODULE_NOT_FOUND';
+ throw e;
+ }
+ return map[req];
+}
+webpackContext.keys = function webpackContextKeys() {
+ return Object.keys(map);
+};
+webpackContext.resolve = webpackContextResolve;
+module.exports = webpackContext;
+webpackContext.id = "./node_modules/moment/locale sync recursive ^\\.\\/.*$";
+
+/***/ }),
+
+/***/ "./node_modules/moment/moment.js":
+/*!***************************************!*\
+ !*** ./node_modules/moment/moment.js ***!
+ \***************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+//! moment.js
+//! version : 2.29.1
+//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
+//! license : MIT
+//! momentjs.com
+
+;(function (global, factory) {
+ true ? module.exports = factory() :
+ 0
+}(this, (function () { 'use strict';
+
+ var hookCallback;
+
+ function hooks() {
+ return hookCallback.apply(null, arguments);
+ }
+
+ // This is done to register the method called with moment()
+ // without creating circular dependencies.
+ function setHookCallback(callback) {
+ hookCallback = callback;
+ }
+
+ function isArray(input) {
+ return (
+ input instanceof Array ||
+ Object.prototype.toString.call(input) === '[object Array]'
+ );
+ }
+
+ function isObject(input) {
+ // IE8 will treat undefined and null as object if it wasn't for
+ // input != null
+ return (
+ input != null &&
+ Object.prototype.toString.call(input) === '[object Object]'
+ );
+ }
+
+ function hasOwnProp(a, b) {
+ return Object.prototype.hasOwnProperty.call(a, b);
+ }
+
+ function isObjectEmpty(obj) {
+ if (Object.getOwnPropertyNames) {
+ return Object.getOwnPropertyNames(obj).length === 0;
+ } else {
+ var k;
+ for (k in obj) {
+ if (hasOwnProp(obj, k)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ function isUndefined(input) {
+ return input === void 0;
+ }
+
+ function isNumber(input) {
+ return (
+ typeof input === 'number' ||
+ Object.prototype.toString.call(input) === '[object Number]'
+ );
+ }
+
+ function isDate(input) {
+ return (
+ input instanceof Date ||
+ Object.prototype.toString.call(input) === '[object Date]'
+ );
+ }
+
+ function map(arr, fn) {
+ var res = [],
+ i;
+ for (i = 0; i < arr.length; ++i) {
+ res.push(fn(arr[i], i));
+ }
+ return res;
+ }
+
+ function extend(a, b) {
+ for (var i in b) {
+ if (hasOwnProp(b, i)) {
+ a[i] = b[i];
+ }
+ }
+
+ if (hasOwnProp(b, 'toString')) {
+ a.toString = b.toString;
+ }
+
+ if (hasOwnProp(b, 'valueOf')) {
+ a.valueOf = b.valueOf;
+ }
+
+ return a;
+ }
+
+ function createUTC(input, format, locale, strict) {
+ return createLocalOrUTC(input, format, locale, strict, true).utc();
+ }
+
+ function defaultParsingFlags() {
+ // We need to deep clone this object.
+ return {
+ empty: false,
+ unusedTokens: [],
+ unusedInput: [],
+ overflow: -2,
+ charsLeftOver: 0,
+ nullInput: false,
+ invalidEra: null,
+ invalidMonth: null,
+ invalidFormat: false,
+ userInvalidated: false,
+ iso: false,
+ parsedDateParts: [],
+ era: null,
+ meridiem: null,
+ rfc2822: false,
+ weekdayMismatch: false,
+ };
+ }
+
+ function getParsingFlags(m) {
+ if (m._pf == null) {
+ m._pf = defaultParsingFlags();
+ }
+ return m._pf;
+ }
+
+ var some;
+ if (Array.prototype.some) {
+ some = Array.prototype.some;
+ } else {
+ some = function (fun) {
+ var t = Object(this),
+ len = t.length >>> 0,
+ i;
+
+ for (i = 0; i < len; i++) {
+ if (i in t && fun.call(this, t[i], i, t)) {
+ return true;
+ }
+ }
+
+ return false;
+ };
+ }
+
+ function isValid(m) {
+ if (m._isValid == null) {
+ var flags = getParsingFlags(m),
+ parsedParts = some.call(flags.parsedDateParts, function (i) {
+ return i != null;
+ }),
+ isNowValid =
+ !isNaN(m._d.getTime()) &&
+ flags.overflow < 0 &&
+ !flags.empty &&
+ !flags.invalidEra &&
+ !flags.invalidMonth &&
+ !flags.invalidWeekday &&
+ !flags.weekdayMismatch &&
+ !flags.nullInput &&
+ !flags.invalidFormat &&
+ !flags.userInvalidated &&
+ (!flags.meridiem || (flags.meridiem && parsedParts));
+
+ if (m._strict) {
+ isNowValid =
+ isNowValid &&
+ flags.charsLeftOver === 0 &&
+ flags.unusedTokens.length === 0 &&
+ flags.bigHour === undefined;
+ }
+
+ if (Object.isFrozen == null || !Object.isFrozen(m)) {
+ m._isValid = isNowValid;
+ } else {
+ return isNowValid;
+ }
+ }
+ return m._isValid;
+ }
+
+ function createInvalid(flags) {
+ var m = createUTC(NaN);
+ if (flags != null) {
+ extend(getParsingFlags(m), flags);
+ } else {
+ getParsingFlags(m).userInvalidated = true;
+ }
+
+ return m;
+ }
+
+ // Plugins that add properties should also add the key here (null value),
+ // so we can properly clone ourselves.
+ var momentProperties = (hooks.momentProperties = []),
+ updateInProgress = false;
+
+ function copyConfig(to, from) {
+ var i, prop, val;
+
+ if (!isUndefined(from._isAMomentObject)) {
+ to._isAMomentObject = from._isAMomentObject;
+ }
+ if (!isUndefined(from._i)) {
+ to._i = from._i;
+ }
+ if (!isUndefined(from._f)) {
+ to._f = from._f;
+ }
+ if (!isUndefined(from._l)) {
+ to._l = from._l;
+ }
+ if (!isUndefined(from._strict)) {
+ to._strict = from._strict;
+ }
+ if (!isUndefined(from._tzm)) {
+ to._tzm = from._tzm;
+ }
+ if (!isUndefined(from._isUTC)) {
+ to._isUTC = from._isUTC;
+ }
+ if (!isUndefined(from._offset)) {
+ to._offset = from._offset;
+ }
+ if (!isUndefined(from._pf)) {
+ to._pf = getParsingFlags(from);
+ }
+ if (!isUndefined(from._locale)) {
+ to._locale = from._locale;
+ }
+
+ if (momentProperties.length > 0) {
+ for (i = 0; i < momentProperties.length; i++) {
+ prop = momentProperties[i];
+ val = from[prop];
+ if (!isUndefined(val)) {
+ to[prop] = val;
+ }
+ }
+ }
+
+ return to;
+ }
+
+ // Moment prototype object
+ function Moment(config) {
+ copyConfig(this, config);
+ this._d = new Date(config._d != null ? config._d.getTime() : NaN);
+ if (!this.isValid()) {
+ this._d = new Date(NaN);
+ }
+ // Prevent infinite loop in case updateOffset creates new moment
+ // objects.
+ if (updateInProgress === false) {
+ updateInProgress = true;
+ hooks.updateOffset(this);
+ updateInProgress = false;
+ }
+ }
+
+ function isMoment(obj) {
+ return (
+ obj instanceof Moment || (obj != null && obj._isAMomentObject != null)
+ );
+ }
+
+ function warn(msg) {
+ if (
+ hooks.suppressDeprecationWarnings === false &&
+ typeof console !== 'undefined' &&
+ console.warn
+ ) {
+ console.warn('Deprecation warning: ' + msg);
+ }
+ }
+
+ function deprecate(msg, fn) {
+ var firstTime = true;
+
+ return extend(function () {
+ if (hooks.deprecationHandler != null) {
+ hooks.deprecationHandler(null, msg);
+ }
+ if (firstTime) {
+ var args = [],
+ arg,
+ i,
+ key;
+ for (i = 0; i < arguments.length; i++) {
+ arg = '';
+ if (typeof arguments[i] === 'object') {
+ arg += '\n[' + i + '] ';
+ for (key in arguments[0]) {
+ if (hasOwnProp(arguments[0], key)) {
+ arg += key + ': ' + arguments[0][key] + ', ';
+ }
+ }
+ arg = arg.slice(0, -2); // Remove trailing comma and space
+ } else {
+ arg = arguments[i];
+ }
+ args.push(arg);
+ }
+ warn(
+ msg +
+ '\nArguments: ' +
+ Array.prototype.slice.call(args).join('') +
+ '\n' +
+ new Error().stack
+ );
+ firstTime = false;
+ }
+ return fn.apply(this, arguments);
+ }, fn);
+ }
+
+ var deprecations = {};
+
+ function deprecateSimple(name, msg) {
+ if (hooks.deprecationHandler != null) {
+ hooks.deprecationHandler(name, msg);
+ }
+ if (!deprecations[name]) {
+ warn(msg);
+ deprecations[name] = true;
+ }
+ }
+
+ hooks.suppressDeprecationWarnings = false;
+ hooks.deprecationHandler = null;
+
+ function isFunction(input) {
+ return (
+ (typeof Function !== 'undefined' && input instanceof Function) ||
+ Object.prototype.toString.call(input) === '[object Function]'
+ );
+ }
+
+ function set(config) {
+ var prop, i;
+ for (i in config) {
+ if (hasOwnProp(config, i)) {
+ prop = config[i];
+ if (isFunction(prop)) {
+ this[i] = prop;
+ } else {
+ this['_' + i] = prop;
+ }
+ }
+ }
+ this._config = config;
+ // Lenient ordinal parsing accepts just a number in addition to
+ // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
+ // TODO: Remove "ordinalParse" fallback in next major release.
+ this._dayOfMonthOrdinalParseLenient = new RegExp(
+ (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
+ '|' +
+ /\d{1,2}/.source
+ );
+ }
+
+ function mergeConfigs(parentConfig, childConfig) {
+ var res = extend({}, parentConfig),
+ prop;
+ for (prop in childConfig) {
+ if (hasOwnProp(childConfig, prop)) {
+ if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
+ res[prop] = {};
+ extend(res[prop], parentConfig[prop]);
+ extend(res[prop], childConfig[prop]);
+ } else if (childConfig[prop] != null) {
+ res[prop] = childConfig[prop];
+ } else {
+ delete res[prop];
+ }
+ }
+ }
+ for (prop in parentConfig) {
+ if (
+ hasOwnProp(parentConfig, prop) &&
+ !hasOwnProp(childConfig, prop) &&
+ isObject(parentConfig[prop])
+ ) {
+ // make sure changes to properties don't modify parent config
+ res[prop] = extend({}, res[prop]);
+ }
+ }
+ return res;
+ }
+
+ function Locale(config) {
+ if (config != null) {
+ this.set(config);
+ }
+ }
+
+ var keys;
+
+ if (Object.keys) {
+ keys = Object.keys;
+ } else {
+ keys = function (obj) {
+ var i,
+ res = [];
+ for (i in obj) {
+ if (hasOwnProp(obj, i)) {
+ res.push(i);
+ }
+ }
+ return res;
+ };
+ }
+
+ var defaultCalendar = {
+ sameDay: '[Today at] LT',
+ nextDay: '[Tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ lastDay: '[Yesterday at] LT',
+ lastWeek: '[Last] dddd [at] LT',
+ sameElse: 'L',
+ };
+
+ function calendar(key, mom, now) {
+ var output = this._calendar[key] || this._calendar['sameElse'];
+ return isFunction(output) ? output.call(mom, now) : output;
+ }
+
+ function zeroFill(number, targetLength, forceSign) {
+ var absNumber = '' + Math.abs(number),
+ zerosToFill = targetLength - absNumber.length,
+ sign = number >= 0;
+ return (
+ (sign ? (forceSign ? '+' : '') : '-') +
+ Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) +
+ absNumber
+ );
+ }
+
+ var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
+ localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
+ formatFunctions = {},
+ formatTokenFunctions = {};
+
+ // token: 'M'
+ // padded: ['MM', 2]
+ // ordinal: 'Mo'
+ // callback: function () { this.month() + 1 }
+ function addFormatToken(token, padded, ordinal, callback) {
+ var func = callback;
+ if (typeof callback === 'string') {
+ func = function () {
+ return this[callback]();
+ };
+ }
+ if (token) {
+ formatTokenFunctions[token] = func;
+ }
+ if (padded) {
+ formatTokenFunctions[padded[0]] = function () {
+ return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
+ };
+ }
+ if (ordinal) {
+ formatTokenFunctions[ordinal] = function () {
+ return this.localeData().ordinal(
+ func.apply(this, arguments),
+ token
+ );
+ };
+ }
+ }
+
+ function removeFormattingTokens(input) {
+ if (input.match(/\[[\s\S]/)) {
+ return input.replace(/^\[|\]$/g, '');
+ }
+ return input.replace(/\\/g, '');
+ }
+
+ function makeFormatFunction(format) {
+ var array = format.match(formattingTokens),
+ i,
+ length;
+
+ for (i = 0, length = array.length; i < length; i++) {
+ if (formatTokenFunctions[array[i]]) {
+ array[i] = formatTokenFunctions[array[i]];
+ } else {
+ array[i] = removeFormattingTokens(array[i]);
+ }
+ }
+
+ return function (mom) {
+ var output = '',
+ i;
+ for (i = 0; i < length; i++) {
+ output += isFunction(array[i])
+ ? array[i].call(mom, format)
+ : array[i];
+ }
+ return output;
+ };
+ }
+
+ // format date using native date object
+ function formatMoment(m, format) {
+ if (!m.isValid()) {
+ return m.localeData().invalidDate();
+ }
+
+ format = expandFormat(format, m.localeData());
+ formatFunctions[format] =
+ formatFunctions[format] || makeFormatFunction(format);
+
+ return formatFunctions[format](m);
+ }
+
+ function expandFormat(format, locale) {
+ var i = 5;
+
+ function replaceLongDateFormatTokens(input) {
+ return locale.longDateFormat(input) || input;
+ }
+
+ localFormattingTokens.lastIndex = 0;
+ while (i >= 0 && localFormattingTokens.test(format)) {
+ format = format.replace(
+ localFormattingTokens,
+ replaceLongDateFormatTokens
+ );
+ localFormattingTokens.lastIndex = 0;
+ i -= 1;
+ }
+
+ return format;
+ }
+
+ var defaultLongDateFormat = {
+ LTS: 'h:mm:ss A',
+ LT: 'h:mm A',
+ L: 'MM/DD/YYYY',
+ LL: 'MMMM D, YYYY',
+ LLL: 'MMMM D, YYYY h:mm A',
+ LLLL: 'dddd, MMMM D, YYYY h:mm A',
+ };
+
+ function longDateFormat(key) {
+ var format = this._longDateFormat[key],
+ formatUpper = this._longDateFormat[key.toUpperCase()];
+
+ if (format || !formatUpper) {
+ return format;
+ }
+
+ this._longDateFormat[key] = formatUpper
+ .match(formattingTokens)
+ .map(function (tok) {
+ if (
+ tok === 'MMMM' ||
+ tok === 'MM' ||
+ tok === 'DD' ||
+ tok === 'dddd'
+ ) {
+ return tok.slice(1);
+ }
+ return tok;
+ })
+ .join('');
+
+ return this._longDateFormat[key];
+ }
+
+ var defaultInvalidDate = 'Invalid date';
+
+ function invalidDate() {
+ return this._invalidDate;
+ }
+
+ var defaultOrdinal = '%d',
+ defaultDayOfMonthOrdinalParse = /\d{1,2}/;
+
+ function ordinal(number) {
+ return this._ordinal.replace('%d', number);
+ }
+
+ var defaultRelativeTime = {
+ future: 'in %s',
+ past: '%s ago',
+ s: 'a few seconds',
+ ss: '%d seconds',
+ m: 'a minute',
+ mm: '%d minutes',
+ h: 'an hour',
+ hh: '%d hours',
+ d: 'a day',
+ dd: '%d days',
+ w: 'a week',
+ ww: '%d weeks',
+ M: 'a month',
+ MM: '%d months',
+ y: 'a year',
+ yy: '%d years',
+ };
+
+ function relativeTime(number, withoutSuffix, string, isFuture) {
+ var output = this._relativeTime[string];
+ return isFunction(output)
+ ? output(number, withoutSuffix, string, isFuture)
+ : output.replace(/%d/i, number);
+ }
+
+ function pastFuture(diff, output) {
+ var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+ return isFunction(format) ? format(output) : format.replace(/%s/i, output);
+ }
+
+ var aliases = {};
+
+ function addUnitAlias(unit, shorthand) {
+ var lowerCase = unit.toLowerCase();
+ aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+ }
+
+ function normalizeUnits(units) {
+ return typeof units === 'string'
+ ? aliases[units] || aliases[units.toLowerCase()]
+ : undefined;
+ }
+
+ function normalizeObjectUnits(inputObject) {
+ var normalizedInput = {},
+ normalizedProp,
+ prop;
+
+ for (prop in inputObject) {
+ if (hasOwnProp(inputObject, prop)) {
+ normalizedProp = normalizeUnits(prop);
+ if (normalizedProp) {
+ normalizedInput[normalizedProp] = inputObject[prop];
+ }
+ }
+ }
+
+ return normalizedInput;
+ }
+
+ var priorities = {};
+
+ function addUnitPriority(unit, priority) {
+ priorities[unit] = priority;
+ }
+
+ function getPrioritizedUnits(unitsObj) {
+ var units = [],
+ u;
+ for (u in unitsObj) {
+ if (hasOwnProp(unitsObj, u)) {
+ units.push({ unit: u, priority: priorities[u] });
+ }
+ }
+ units.sort(function (a, b) {
+ return a.priority - b.priority;
+ });
+ return units;
+ }
+
+ function isLeapYear(year) {
+ return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+ }
+
+ function absFloor(number) {
+ if (number < 0) {
+ // -0 -> 0
+ return Math.ceil(number) || 0;
+ } else {
+ return Math.floor(number);
+ }
+ }
+
+ function toInt(argumentForCoercion) {
+ var coercedNumber = +argumentForCoercion,
+ value = 0;
+
+ if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+ value = absFloor(coercedNumber);
+ }
+
+ return value;
+ }
+
+ function makeGetSet(unit, keepTime) {
+ return function (value) {
+ if (value != null) {
+ set$1(this, unit, value);
+ hooks.updateOffset(this, keepTime);
+ return this;
+ } else {
+ return get(this, unit);
+ }
+ };
+ }
+
+ function get(mom, unit) {
+ return mom.isValid()
+ ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]()
+ : NaN;
+ }
+
+ function set$1(mom, unit, value) {
+ if (mom.isValid() && !isNaN(value)) {
+ if (
+ unit === 'FullYear' &&
+ isLeapYear(mom.year()) &&
+ mom.month() === 1 &&
+ mom.date() === 29
+ ) {
+ value = toInt(value);
+ mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](
+ value,
+ mom.month(),
+ daysInMonth(value, mom.month())
+ );
+ } else {
+ mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
+ }
+ }
+ }
+
+ // MOMENTS
+
+ function stringGet(units) {
+ units = normalizeUnits(units);
+ if (isFunction(this[units])) {
+ return this[units]();
+ }
+ return this;
+ }
+
+ function stringSet(units, value) {
+ if (typeof units === 'object') {
+ units = normalizeObjectUnits(units);
+ var prioritized = getPrioritizedUnits(units),
+ i;
+ for (i = 0; i < prioritized.length; i++) {
+ this[prioritized[i].unit](units[prioritized[i].unit]);
+ }
+ } else {
+ units = normalizeUnits(units);
+ if (isFunction(this[units])) {
+ return this[units](value);
+ }
+ }
+ return this;
+ }
+
+ var match1 = /\d/, // 0 - 9
+ match2 = /\d\d/, // 00 - 99
+ match3 = /\d{3}/, // 000 - 999
+ match4 = /\d{4}/, // 0000 - 9999
+ match6 = /[+-]?\d{6}/, // -999999 - 999999
+ match1to2 = /\d\d?/, // 0 - 99
+ match3to4 = /\d\d\d\d?/, // 999 - 9999
+ match5to6 = /\d\d\d\d\d\d?/, // 99999 - 999999
+ match1to3 = /\d{1,3}/, // 0 - 999
+ match1to4 = /\d{1,4}/, // 0 - 9999
+ match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999
+ matchUnsigned = /\d+/, // 0 - inf
+ matchSigned = /[+-]?\d+/, // -inf - inf
+ matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
+ matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
+ matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
+ // any word (or two) characters or numbers including two/three word month in arabic.
+ // includes scottish gaelic two word and hyphenated months
+ matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
+ regexes;
+
+ regexes = {};
+
+ function addRegexToken(token, regex, strictRegex) {
+ regexes[token] = isFunction(regex)
+ ? regex
+ : function (isStrict, localeData) {
+ return isStrict && strictRegex ? strictRegex : regex;
+ };
+ }
+
+ function getParseRegexForToken(token, config) {
+ if (!hasOwnProp(regexes, token)) {
+ return new RegExp(unescapeFormat(token));
+ }
+
+ return regexes[token](config._strict, config._locale);
+ }
+
+ // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+ function unescapeFormat(s) {
+ return regexEscape(
+ s
+ .replace('\\', '')
+ .replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (
+ matched,
+ p1,
+ p2,
+ p3,
+ p4
+ ) {
+ return p1 || p2 || p3 || p4;
+ })
+ );
+ }
+
+ function regexEscape(s) {
+ return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+ }
+
+ var tokens = {};
+
+ function addParseToken(token, callback) {
+ var i,
+ func = callback;
+ if (typeof token === 'string') {
+ token = [token];
+ }
+ if (isNumber(callback)) {
+ func = function (input, array) {
+ array[callback] = toInt(input);
+ };
+ }
+ for (i = 0; i < token.length; i++) {
+ tokens[token[i]] = func;
+ }
+ }
+
+ function addWeekParseToken(token, callback) {
+ addParseToken(token, function (input, array, config, token) {
+ config._w = config._w || {};
+ callback(input, config._w, config, token);
+ });
+ }
+
+ function addTimeToArrayFromToken(token, input, config) {
+ if (input != null && hasOwnProp(tokens, token)) {
+ tokens[token](input, config._a, config, token);
+ }
+ }
+
+ var YEAR = 0,
+ MONTH = 1,
+ DATE = 2,
+ HOUR = 3,
+ MINUTE = 4,
+ SECOND = 5,
+ MILLISECOND = 6,
+ WEEK = 7,
+ WEEKDAY = 8;
+
+ function mod(n, x) {
+ return ((n % x) + x) % x;
+ }
+
+ var indexOf;
+
+ if (Array.prototype.indexOf) {
+ indexOf = Array.prototype.indexOf;
+ } else {
+ indexOf = function (o) {
+ // I know
+ var i;
+ for (i = 0; i < this.length; ++i) {
+ if (this[i] === o) {
+ return i;
+ }
+ }
+ return -1;
+ };
+ }
+
+ function daysInMonth(year, month) {
+ if (isNaN(year) || isNaN(month)) {
+ return NaN;
+ }
+ var modMonth = mod(month, 12);
+ year += (month - modMonth) / 12;
+ return modMonth === 1
+ ? isLeapYear(year)
+ ? 29
+ : 28
+ : 31 - ((modMonth % 7) % 2);
+ }
+
+ // FORMATTING
+
+ addFormatToken('M', ['MM', 2], 'Mo', function () {
+ return this.month() + 1;
+ });
+
+ addFormatToken('MMM', 0, 0, function (format) {
+ return this.localeData().monthsShort(this, format);
+ });
+
+ addFormatToken('MMMM', 0, 0, function (format) {
+ return this.localeData().months(this, format);
+ });
+
+ // ALIASES
+
+ addUnitAlias('month', 'M');
+
+ // PRIORITY
+
+ addUnitPriority('month', 8);
+
+ // PARSING
+
+ addRegexToken('M', match1to2);
+ addRegexToken('MM', match1to2, match2);
+ addRegexToken('MMM', function (isStrict, locale) {
+ return locale.monthsShortRegex(isStrict);
+ });
+ addRegexToken('MMMM', function (isStrict, locale) {
+ return locale.monthsRegex(isStrict);
+ });
+
+ addParseToken(['M', 'MM'], function (input, array) {
+ array[MONTH] = toInt(input) - 1;
+ });
+
+ addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
+ var month = config._locale.monthsParse(input, token, config._strict);
+ // if we didn't find a month name, mark the date as invalid.
+ if (month != null) {
+ array[MONTH] = month;
+ } else {
+ getParsingFlags(config).invalidMonth = input;
+ }
+ });
+
+ // LOCALES
+
+ var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+ '_'
+ ),
+ defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split(
+ '_'
+ ),
+ MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
+ defaultMonthsShortRegex = matchWord,
+ defaultMonthsRegex = matchWord;
+
+ function localeMonths(m, format) {
+ if (!m) {
+ return isArray(this._months)
+ ? this._months
+ : this._months['standalone'];
+ }
+ return isArray(this._months)
+ ? this._months[m.month()]
+ : this._months[
+ (this._months.isFormat || MONTHS_IN_FORMAT).test(format)
+ ? 'format'
+ : 'standalone'
+ ][m.month()];
+ }
+
+ function localeMonthsShort(m, format) {
+ if (!m) {
+ return isArray(this._monthsShort)
+ ? this._monthsShort
+ : this._monthsShort['standalone'];
+ }
+ return isArray(this._monthsShort)
+ ? this._monthsShort[m.month()]
+ : this._monthsShort[
+ MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'
+ ][m.month()];
+ }
+
+ function handleStrictParse(monthName, format, strict) {
+ var i,
+ ii,
+ mom,
+ llc = monthName.toLocaleLowerCase();
+ if (!this._monthsParse) {
+ // this is not used
+ this._monthsParse = [];
+ this._longMonthsParse = [];
+ this._shortMonthsParse = [];
+ for (i = 0; i < 12; ++i) {
+ mom = createUTC([2000, i]);
+ this._shortMonthsParse[i] = this.monthsShort(
+ mom,
+ ''
+ ).toLocaleLowerCase();
+ this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
+ }
+ }
+
+ if (strict) {
+ if (format === 'MMM') {
+ ii = indexOf.call(this._shortMonthsParse, llc);
+ return ii !== -1 ? ii : null;
+ } else {
+ ii = indexOf.call(this._longMonthsParse, llc);
+ return ii !== -1 ? ii : null;
+ }
+ } else {
+ if (format === 'MMM') {
+ ii = indexOf.call(this._shortMonthsParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._longMonthsParse, llc);
+ return ii !== -1 ? ii : null;
+ } else {
+ ii = indexOf.call(this._longMonthsParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._shortMonthsParse, llc);
+ return ii !== -1 ? ii : null;
+ }
+ }
+ }
+
+ function localeMonthsParse(monthName, format, strict) {
+ var i, mom, regex;
+
+ if (this._monthsParseExact) {
+ return handleStrictParse.call(this, monthName, format, strict);
+ }
+
+ if (!this._monthsParse) {
+ this._monthsParse = [];
+ this._longMonthsParse = [];
+ this._shortMonthsParse = [];
+ }
+
+ // TODO: add sorting
+ // Sorting makes sure if one month (or abbr) is a prefix of another
+ // see sorting in computeMonthsParse
+ for (i = 0; i < 12; i++) {
+ // make the regex if we don't have it already
+ mom = createUTC([2000, i]);
+ if (strict && !this._longMonthsParse[i]) {
+ this._longMonthsParse[i] = new RegExp(
+ '^' + this.months(mom, '').replace('.', '') + '$',
+ 'i'
+ );
+ this._shortMonthsParse[i] = new RegExp(
+ '^' + this.monthsShort(mom, '').replace('.', '') + '$',
+ 'i'
+ );
+ }
+ if (!strict && !this._monthsParse[i]) {
+ regex =
+ '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
+ this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
+ }
+ // test the regex
+ if (
+ strict &&
+ format === 'MMMM' &&
+ this._longMonthsParse[i].test(monthName)
+ ) {
+ return i;
+ } else if (
+ strict &&
+ format === 'MMM' &&
+ this._shortMonthsParse[i].test(monthName)
+ ) {
+ return i;
+ } else if (!strict && this._monthsParse[i].test(monthName)) {
+ return i;
+ }
+ }
+ }
+
+ // MOMENTS
+
+ function setMonth(mom, value) {
+ var dayOfMonth;
+
+ if (!mom.isValid()) {
+ // No op
+ return mom;
+ }
+
+ if (typeof value === 'string') {
+ if (/^\d+$/.test(value)) {
+ value = toInt(value);
+ } else {
+ value = mom.localeData().monthsParse(value);
+ // TODO: Another silent failure?
+ if (!isNumber(value)) {
+ return mom;
+ }
+ }
+ }
+
+ dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
+ mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
+ return mom;
+ }
+
+ function getSetMonth(value) {
+ if (value != null) {
+ setMonth(this, value);
+ hooks.updateOffset(this, true);
+ return this;
+ } else {
+ return get(this, 'Month');
+ }
+ }
+
+ function getDaysInMonth() {
+ return daysInMonth(this.year(), this.month());
+ }
+
+ function monthsShortRegex(isStrict) {
+ if (this._monthsParseExact) {
+ if (!hasOwnProp(this, '_monthsRegex')) {
+ computeMonthsParse.call(this);
+ }
+ if (isStrict) {
+ return this._monthsShortStrictRegex;
+ } else {
+ return this._monthsShortRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_monthsShortRegex')) {
+ this._monthsShortRegex = defaultMonthsShortRegex;
+ }
+ return this._monthsShortStrictRegex && isStrict
+ ? this._monthsShortStrictRegex
+ : this._monthsShortRegex;
+ }
+ }
+
+ function monthsRegex(isStrict) {
+ if (this._monthsParseExact) {
+ if (!hasOwnProp(this, '_monthsRegex')) {
+ computeMonthsParse.call(this);
+ }
+ if (isStrict) {
+ return this._monthsStrictRegex;
+ } else {
+ return this._monthsRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_monthsRegex')) {
+ this._monthsRegex = defaultMonthsRegex;
+ }
+ return this._monthsStrictRegex && isStrict
+ ? this._monthsStrictRegex
+ : this._monthsRegex;
+ }
+ }
+
+ function computeMonthsParse() {
+ function cmpLenRev(a, b) {
+ return b.length - a.length;
+ }
+
+ var shortPieces = [],
+ longPieces = [],
+ mixedPieces = [],
+ i,
+ mom;
+ for (i = 0; i < 12; i++) {
+ // make the regex if we don't have it already
+ mom = createUTC([2000, i]);
+ shortPieces.push(this.monthsShort(mom, ''));
+ longPieces.push(this.months(mom, ''));
+ mixedPieces.push(this.months(mom, ''));
+ mixedPieces.push(this.monthsShort(mom, ''));
+ }
+ // Sorting makes sure if one month (or abbr) is a prefix of another it
+ // will match the longer piece.
+ shortPieces.sort(cmpLenRev);
+ longPieces.sort(cmpLenRev);
+ mixedPieces.sort(cmpLenRev);
+ for (i = 0; i < 12; i++) {
+ shortPieces[i] = regexEscape(shortPieces[i]);
+ longPieces[i] = regexEscape(longPieces[i]);
+ }
+ for (i = 0; i < 24; i++) {
+ mixedPieces[i] = regexEscape(mixedPieces[i]);
+ }
+
+ this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+ this._monthsShortRegex = this._monthsRegex;
+ this._monthsStrictRegex = new RegExp(
+ '^(' + longPieces.join('|') + ')',
+ 'i'
+ );
+ this._monthsShortStrictRegex = new RegExp(
+ '^(' + shortPieces.join('|') + ')',
+ 'i'
+ );
+ }
+
+ // FORMATTING
+
+ addFormatToken('Y', 0, 0, function () {
+ var y = this.year();
+ return y <= 9999 ? zeroFill(y, 4) : '+' + y;
+ });
+
+ addFormatToken(0, ['YY', 2], 0, function () {
+ return this.year() % 100;
+ });
+
+ addFormatToken(0, ['YYYY', 4], 0, 'year');
+ addFormatToken(0, ['YYYYY', 5], 0, 'year');
+ addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
+
+ // ALIASES
+
+ addUnitAlias('year', 'y');
+
+ // PRIORITIES
+
+ addUnitPriority('year', 1);
+
+ // PARSING
+
+ addRegexToken('Y', matchSigned);
+ addRegexToken('YY', match1to2, match2);
+ addRegexToken('YYYY', match1to4, match4);
+ addRegexToken('YYYYY', match1to6, match6);
+ addRegexToken('YYYYYY', match1to6, match6);
+
+ addParseToken(['YYYYY', 'YYYYYY'], YEAR);
+ addParseToken('YYYY', function (input, array) {
+ array[YEAR] =
+ input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
+ });
+ addParseToken('YY', function (input, array) {
+ array[YEAR] = hooks.parseTwoDigitYear(input);
+ });
+ addParseToken('Y', function (input, array) {
+ array[YEAR] = parseInt(input, 10);
+ });
+
+ // HELPERS
+
+ function daysInYear(year) {
+ return isLeapYear(year) ? 366 : 365;
+ }
+
+ // HOOKS
+
+ hooks.parseTwoDigitYear = function (input) {
+ return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+ };
+
+ // MOMENTS
+
+ var getSetYear = makeGetSet('FullYear', true);
+
+ function getIsLeapYear() {
+ return isLeapYear(this.year());
+ }
+
+ function createDate(y, m, d, h, M, s, ms) {
+ // can't just apply() to create a date:
+ // https://stackoverflow.com/q/181348
+ var date;
+ // the date constructor remaps years 0-99 to 1900-1999
+ if (y < 100 && y >= 0) {
+ // preserve leap years using a full 400 year cycle, then reset
+ date = new Date(y + 400, m, d, h, M, s, ms);
+ if (isFinite(date.getFullYear())) {
+ date.setFullYear(y);
+ }
+ } else {
+ date = new Date(y, m, d, h, M, s, ms);
+ }
+
+ return date;
+ }
+
+ function createUTCDate(y) {
+ var date, args;
+ // the Date.UTC function remaps years 0-99 to 1900-1999
+ if (y < 100 && y >= 0) {
+ args = Array.prototype.slice.call(arguments);
+ // preserve leap years using a full 400 year cycle, then reset
+ args[0] = y + 400;
+ date = new Date(Date.UTC.apply(null, args));
+ if (isFinite(date.getUTCFullYear())) {
+ date.setUTCFullYear(y);
+ }
+ } else {
+ date = new Date(Date.UTC.apply(null, arguments));
+ }
+
+ return date;
+ }
+
+ // start-of-first-week - start-of-year
+ function firstWeekOffset(year, dow, doy) {
+ var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
+ fwd = 7 + dow - doy,
+ // first-week day local weekday -- which local weekday is fwd
+ fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
+
+ return -fwdlw + fwd - 1;
+ }
+
+ // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+ function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
+ var localWeekday = (7 + weekday - dow) % 7,
+ weekOffset = firstWeekOffset(year, dow, doy),
+ dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
+ resYear,
+ resDayOfYear;
+
+ if (dayOfYear <= 0) {
+ resYear = year - 1;
+ resDayOfYear = daysInYear(resYear) + dayOfYear;
+ } else if (dayOfYear > daysInYear(year)) {
+ resYear = year + 1;
+ resDayOfYear = dayOfYear - daysInYear(year);
+ } else {
+ resYear = year;
+ resDayOfYear = dayOfYear;
+ }
+
+ return {
+ year: resYear,
+ dayOfYear: resDayOfYear,
+ };
+ }
+
+ function weekOfYear(mom, dow, doy) {
+ var weekOffset = firstWeekOffset(mom.year(), dow, doy),
+ week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
+ resWeek,
+ resYear;
+
+ if (week < 1) {
+ resYear = mom.year() - 1;
+ resWeek = week + weeksInYear(resYear, dow, doy);
+ } else if (week > weeksInYear(mom.year(), dow, doy)) {
+ resWeek = week - weeksInYear(mom.year(), dow, doy);
+ resYear = mom.year() + 1;
+ } else {
+ resYear = mom.year();
+ resWeek = week;
+ }
+
+ return {
+ week: resWeek,
+ year: resYear,
+ };
+ }
+
+ function weeksInYear(year, dow, doy) {
+ var weekOffset = firstWeekOffset(year, dow, doy),
+ weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
+ return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
+ }
+
+ // FORMATTING
+
+ addFormatToken('w', ['ww', 2], 'wo', 'week');
+ addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
+
+ // ALIASES
+
+ addUnitAlias('week', 'w');
+ addUnitAlias('isoWeek', 'W');
+
+ // PRIORITIES
+
+ addUnitPriority('week', 5);
+ addUnitPriority('isoWeek', 5);
+
+ // PARSING
+
+ addRegexToken('w', match1to2);
+ addRegexToken('ww', match1to2, match2);
+ addRegexToken('W', match1to2);
+ addRegexToken('WW', match1to2, match2);
+
+ addWeekParseToken(['w', 'ww', 'W', 'WW'], function (
+ input,
+ week,
+ config,
+ token
+ ) {
+ week[token.substr(0, 1)] = toInt(input);
+ });
+
+ // HELPERS
+
+ // LOCALES
+
+ function localeWeek(mom) {
+ return weekOfYear(mom, this._week.dow, this._week.doy).week;
+ }
+
+ var defaultLocaleWeek = {
+ dow: 0, // Sunday is the first day of the week.
+ doy: 6, // The week that contains Jan 6th is the first week of the year.
+ };
+
+ function localeFirstDayOfWeek() {
+ return this._week.dow;
+ }
+
+ function localeFirstDayOfYear() {
+ return this._week.doy;
+ }
+
+ // MOMENTS
+
+ function getSetWeek(input) {
+ var week = this.localeData().week(this);
+ return input == null ? week : this.add((input - week) * 7, 'd');
+ }
+
+ function getSetISOWeek(input) {
+ var week = weekOfYear(this, 1, 4).week;
+ return input == null ? week : this.add((input - week) * 7, 'd');
+ }
+
+ // FORMATTING
+
+ addFormatToken('d', 0, 'do', 'day');
+
+ addFormatToken('dd', 0, 0, function (format) {
+ return this.localeData().weekdaysMin(this, format);
+ });
+
+ addFormatToken('ddd', 0, 0, function (format) {
+ return this.localeData().weekdaysShort(this, format);
+ });
+
+ addFormatToken('dddd', 0, 0, function (format) {
+ return this.localeData().weekdays(this, format);
+ });
+
+ addFormatToken('e', 0, 0, 'weekday');
+ addFormatToken('E', 0, 0, 'isoWeekday');
+
+ // ALIASES
+
+ addUnitAlias('day', 'd');
+ addUnitAlias('weekday', 'e');
+ addUnitAlias('isoWeekday', 'E');
+
+ // PRIORITY
+ addUnitPriority('day', 11);
+ addUnitPriority('weekday', 11);
+ addUnitPriority('isoWeekday', 11);
+
+ // PARSING
+
+ addRegexToken('d', match1to2);
+ addRegexToken('e', match1to2);
+ addRegexToken('E', match1to2);
+ addRegexToken('dd', function (isStrict, locale) {
+ return locale.weekdaysMinRegex(isStrict);
+ });
+ addRegexToken('ddd', function (isStrict, locale) {
+ return locale.weekdaysShortRegex(isStrict);
+ });
+ addRegexToken('dddd', function (isStrict, locale) {
+ return locale.weekdaysRegex(isStrict);
+ });
+
+ addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
+ var weekday = config._locale.weekdaysParse(input, token, config._strict);
+ // if we didn't get a weekday name, mark the date as invalid
+ if (weekday != null) {
+ week.d = weekday;
+ } else {
+ getParsingFlags(config).invalidWeekday = input;
+ }
+ });
+
+ addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
+ week[token] = toInt(input);
+ });
+
+ // HELPERS
+
+ function parseWeekday(input, locale) {
+ if (typeof input !== 'string') {
+ return input;
+ }
+
+ if (!isNaN(input)) {
+ return parseInt(input, 10);
+ }
+
+ input = locale.weekdaysParse(input);
+ if (typeof input === 'number') {
+ return input;
+ }
+
+ return null;
+ }
+
+ function parseIsoWeekday(input, locale) {
+ if (typeof input === 'string') {
+ return locale.weekdaysParse(input) % 7 || 7;
+ }
+ return isNaN(input) ? null : input;
+ }
+
+ // LOCALES
+ function shiftWeekdays(ws, n) {
+ return ws.slice(n, 7).concat(ws.slice(0, n));
+ }
+
+ var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
+ '_'
+ ),
+ defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+ defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+ defaultWeekdaysRegex = matchWord,
+ defaultWeekdaysShortRegex = matchWord,
+ defaultWeekdaysMinRegex = matchWord;
+
+ function localeWeekdays(m, format) {
+ var weekdays = isArray(this._weekdays)
+ ? this._weekdays
+ : this._weekdays[
+ m && m !== true && this._weekdays.isFormat.test(format)
+ ? 'format'
+ : 'standalone'
+ ];
+ return m === true
+ ? shiftWeekdays(weekdays, this._week.dow)
+ : m
+ ? weekdays[m.day()]
+ : weekdays;
+ }
+
+ function localeWeekdaysShort(m) {
+ return m === true
+ ? shiftWeekdays(this._weekdaysShort, this._week.dow)
+ : m
+ ? this._weekdaysShort[m.day()]
+ : this._weekdaysShort;
+ }
+
+ function localeWeekdaysMin(m) {
+ return m === true
+ ? shiftWeekdays(this._weekdaysMin, this._week.dow)
+ : m
+ ? this._weekdaysMin[m.day()]
+ : this._weekdaysMin;
+ }
+
+ function handleStrictParse$1(weekdayName, format, strict) {
+ var i,
+ ii,
+ mom,
+ llc = weekdayName.toLocaleLowerCase();
+ if (!this._weekdaysParse) {
+ this._weekdaysParse = [];
+ this._shortWeekdaysParse = [];
+ this._minWeekdaysParse = [];
+
+ for (i = 0; i < 7; ++i) {
+ mom = createUTC([2000, 1]).day(i);
+ this._minWeekdaysParse[i] = this.weekdaysMin(
+ mom,
+ ''
+ ).toLocaleLowerCase();
+ this._shortWeekdaysParse[i] = this.weekdaysShort(
+ mom,
+ ''
+ ).toLocaleLowerCase();
+ this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
+ }
+ }
+
+ if (strict) {
+ if (format === 'dddd') {
+ ii = indexOf.call(this._weekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ } else if (format === 'ddd') {
+ ii = indexOf.call(this._shortWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ } else {
+ ii = indexOf.call(this._minWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ }
+ } else {
+ if (format === 'dddd') {
+ ii = indexOf.call(this._weekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._shortWeekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._minWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ } else if (format === 'ddd') {
+ ii = indexOf.call(this._shortWeekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._weekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._minWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ } else {
+ ii = indexOf.call(this._minWeekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._weekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._shortWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ }
+ }
+ }
+
+ function localeWeekdaysParse(weekdayName, format, strict) {
+ var i, mom, regex;
+
+ if (this._weekdaysParseExact) {
+ return handleStrictParse$1.call(this, weekdayName, format, strict);
+ }
+
+ if (!this._weekdaysParse) {
+ this._weekdaysParse = [];
+ this._minWeekdaysParse = [];
+ this._shortWeekdaysParse = [];
+ this._fullWeekdaysParse = [];
+ }
+
+ for (i = 0; i < 7; i++) {
+ // make the regex if we don't have it already
+
+ mom = createUTC([2000, 1]).day(i);
+ if (strict && !this._fullWeekdaysParse[i]) {
+ this._fullWeekdaysParse[i] = new RegExp(
+ '^' + this.weekdays(mom, '').replace('.', '\\.?') + '$',
+ 'i'
+ );
+ this._shortWeekdaysParse[i] = new RegExp(
+ '^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$',
+ 'i'
+ );
+ this._minWeekdaysParse[i] = new RegExp(
+ '^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$',
+ 'i'
+ );
+ }
+ if (!this._weekdaysParse[i]) {
+ regex =
+ '^' +
+ this.weekdays(mom, '') +
+ '|^' +
+ this.weekdaysShort(mom, '') +
+ '|^' +
+ this.weekdaysMin(mom, '');
+ this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
+ }
+ // test the regex
+ if (
+ strict &&
+ format === 'dddd' &&
+ this._fullWeekdaysParse[i].test(weekdayName)
+ ) {
+ return i;
+ } else if (
+ strict &&
+ format === 'ddd' &&
+ this._shortWeekdaysParse[i].test(weekdayName)
+ ) {
+ return i;
+ } else if (
+ strict &&
+ format === 'dd' &&
+ this._minWeekdaysParse[i].test(weekdayName)
+ ) {
+ return i;
+ } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
+ return i;
+ }
+ }
+ }
+
+ // MOMENTS
+
+ function getSetDayOfWeek(input) {
+ if (!this.isValid()) {
+ return input != null ? this : NaN;
+ }
+ var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+ if (input != null) {
+ input = parseWeekday(input, this.localeData());
+ return this.add(input - day, 'd');
+ } else {
+ return day;
+ }
+ }
+
+ function getSetLocaleDayOfWeek(input) {
+ if (!this.isValid()) {
+ return input != null ? this : NaN;
+ }
+ var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
+ return input == null ? weekday : this.add(input - weekday, 'd');
+ }
+
+ function getSetISODayOfWeek(input) {
+ if (!this.isValid()) {
+ return input != null ? this : NaN;
+ }
+
+ // behaves the same as moment#day except
+ // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
+ // as a setter, sunday should belong to the previous week.
+
+ if (input != null) {
+ var weekday = parseIsoWeekday(input, this.localeData());
+ return this.day(this.day() % 7 ? weekday : weekday - 7);
+ } else {
+ return this.day() || 7;
+ }
+ }
+
+ function weekdaysRegex(isStrict) {
+ if (this._weekdaysParseExact) {
+ if (!hasOwnProp(this, '_weekdaysRegex')) {
+ computeWeekdaysParse.call(this);
+ }
+ if (isStrict) {
+ return this._weekdaysStrictRegex;
+ } else {
+ return this._weekdaysRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_weekdaysRegex')) {
+ this._weekdaysRegex = defaultWeekdaysRegex;
+ }
+ return this._weekdaysStrictRegex && isStrict
+ ? this._weekdaysStrictRegex
+ : this._weekdaysRegex;
+ }
+ }
+
+ function weekdaysShortRegex(isStrict) {
+ if (this._weekdaysParseExact) {
+ if (!hasOwnProp(this, '_weekdaysRegex')) {
+ computeWeekdaysParse.call(this);
+ }
+ if (isStrict) {
+ return this._weekdaysShortStrictRegex;
+ } else {
+ return this._weekdaysShortRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_weekdaysShortRegex')) {
+ this._weekdaysShortRegex = defaultWeekdaysShortRegex;
+ }
+ return this._weekdaysShortStrictRegex && isStrict
+ ? this._weekdaysShortStrictRegex
+ : this._weekdaysShortRegex;
+ }
+ }
+
+ function weekdaysMinRegex(isStrict) {
+ if (this._weekdaysParseExact) {
+ if (!hasOwnProp(this, '_weekdaysRegex')) {
+ computeWeekdaysParse.call(this);
+ }
+ if (isStrict) {
+ return this._weekdaysMinStrictRegex;
+ } else {
+ return this._weekdaysMinRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_weekdaysMinRegex')) {
+ this._weekdaysMinRegex = defaultWeekdaysMinRegex;
+ }
+ return this._weekdaysMinStrictRegex && isStrict
+ ? this._weekdaysMinStrictRegex
+ : this._weekdaysMinRegex;
+ }
+ }
+
+ function computeWeekdaysParse() {
+ function cmpLenRev(a, b) {
+ return b.length - a.length;
+ }
+
+ var minPieces = [],
+ shortPieces = [],
+ longPieces = [],
+ mixedPieces = [],
+ i,
+ mom,
+ minp,
+ shortp,
+ longp;
+ for (i = 0; i < 7; i++) {
+ // make the regex if we don't have it already
+ mom = createUTC([2000, 1]).day(i);
+ minp = regexEscape(this.weekdaysMin(mom, ''));
+ shortp = regexEscape(this.weekdaysShort(mom, ''));
+ longp = regexEscape(this.weekdays(mom, ''));
+ minPieces.push(minp);
+ shortPieces.push(shortp);
+ longPieces.push(longp);
+ mixedPieces.push(minp);
+ mixedPieces.push(shortp);
+ mixedPieces.push(longp);
+ }
+ // Sorting makes sure if one weekday (or abbr) is a prefix of another it
+ // will match the longer piece.
+ minPieces.sort(cmpLenRev);
+ shortPieces.sort(cmpLenRev);
+ longPieces.sort(cmpLenRev);
+ mixedPieces.sort(cmpLenRev);
+
+ this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+ this._weekdaysShortRegex = this._weekdaysRegex;
+ this._weekdaysMinRegex = this._weekdaysRegex;
+
+ this._weekdaysStrictRegex = new RegExp(
+ '^(' + longPieces.join('|') + ')',
+ 'i'
+ );
+ this._weekdaysShortStrictRegex = new RegExp(
+ '^(' + shortPieces.join('|') + ')',
+ 'i'
+ );
+ this._weekdaysMinStrictRegex = new RegExp(
+ '^(' + minPieces.join('|') + ')',
+ 'i'
+ );
+ }
+
+ // FORMATTING
+
+ function hFormat() {
+ return this.hours() % 12 || 12;
+ }
+
+ function kFormat() {
+ return this.hours() || 24;
+ }
+
+ addFormatToken('H', ['HH', 2], 0, 'hour');
+ addFormatToken('h', ['hh', 2], 0, hFormat);
+ addFormatToken('k', ['kk', 2], 0, kFormat);
+
+ addFormatToken('hmm', 0, 0, function () {
+ return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
+ });
+
+ addFormatToken('hmmss', 0, 0, function () {
+ return (
+ '' +
+ hFormat.apply(this) +
+ zeroFill(this.minutes(), 2) +
+ zeroFill(this.seconds(), 2)
+ );
+ });
+
+ addFormatToken('Hmm', 0, 0, function () {
+ return '' + this.hours() + zeroFill(this.minutes(), 2);
+ });
+
+ addFormatToken('Hmmss', 0, 0, function () {
+ return (
+ '' +
+ this.hours() +
+ zeroFill(this.minutes(), 2) +
+ zeroFill(this.seconds(), 2)
+ );
+ });
+
+ function meridiem(token, lowercase) {
+ addFormatToken(token, 0, 0, function () {
+ return this.localeData().meridiem(
+ this.hours(),
+ this.minutes(),
+ lowercase
+ );
+ });
+ }
+
+ meridiem('a', true);
+ meridiem('A', false);
+
+ // ALIASES
+
+ addUnitAlias('hour', 'h');
+
+ // PRIORITY
+ addUnitPriority('hour', 13);
+
+ // PARSING
+
+ function matchMeridiem(isStrict, locale) {
+ return locale._meridiemParse;
+ }
+
+ addRegexToken('a', matchMeridiem);
+ addRegexToken('A', matchMeridiem);
+ addRegexToken('H', match1to2);
+ addRegexToken('h', match1to2);
+ addRegexToken('k', match1to2);
+ addRegexToken('HH', match1to2, match2);
+ addRegexToken('hh', match1to2, match2);
+ addRegexToken('kk', match1to2, match2);
+
+ addRegexToken('hmm', match3to4);
+ addRegexToken('hmmss', match5to6);
+ addRegexToken('Hmm', match3to4);
+ addRegexToken('Hmmss', match5to6);
+
+ addParseToken(['H', 'HH'], HOUR);
+ addParseToken(['k', 'kk'], function (input, array, config) {
+ var kInput = toInt(input);
+ array[HOUR] = kInput === 24 ? 0 : kInput;
+ });
+ addParseToken(['a', 'A'], function (input, array, config) {
+ config._isPm = config._locale.isPM(input);
+ config._meridiem = input;
+ });
+ addParseToken(['h', 'hh'], function (input, array, config) {
+ array[HOUR] = toInt(input);
+ getParsingFlags(config).bigHour = true;
+ });
+ addParseToken('hmm', function (input, array, config) {
+ var pos = input.length - 2;
+ array[HOUR] = toInt(input.substr(0, pos));
+ array[MINUTE] = toInt(input.substr(pos));
+ getParsingFlags(config).bigHour = true;
+ });
+ addParseToken('hmmss', function (input, array, config) {
+ var pos1 = input.length - 4,
+ pos2 = input.length - 2;
+ array[HOUR] = toInt(input.substr(0, pos1));
+ array[MINUTE] = toInt(input.substr(pos1, 2));
+ array[SECOND] = toInt(input.substr(pos2));
+ getParsingFlags(config).bigHour = true;
+ });
+ addParseToken('Hmm', function (input, array, config) {
+ var pos = input.length - 2;
+ array[HOUR] = toInt(input.substr(0, pos));
+ array[MINUTE] = toInt(input.substr(pos));
+ });
+ addParseToken('Hmmss', function (input, array, config) {
+ var pos1 = input.length - 4,
+ pos2 = input.length - 2;
+ array[HOUR] = toInt(input.substr(0, pos1));
+ array[MINUTE] = toInt(input.substr(pos1, 2));
+ array[SECOND] = toInt(input.substr(pos2));
+ });
+
+ // LOCALES
+
+ function localeIsPM(input) {
+ // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
+ // Using charAt should be more compatible.
+ return (input + '').toLowerCase().charAt(0) === 'p';
+ }
+
+ var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i,
+ // Setting the hour should keep the time, because the user explicitly
+ // specified which hour they want. So trying to maintain the same hour (in
+ // a new timezone) makes sense. Adding/subtracting hours does not follow
+ // this rule.
+ getSetHour = makeGetSet('Hours', true);
+
+ function localeMeridiem(hours, minutes, isLower) {
+ if (hours > 11) {
+ return isLower ? 'pm' : 'PM';
+ } else {
+ return isLower ? 'am' : 'AM';
+ }
+ }
+
+ var baseConfig = {
+ calendar: defaultCalendar,
+ longDateFormat: defaultLongDateFormat,
+ invalidDate: defaultInvalidDate,
+ ordinal: defaultOrdinal,
+ dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
+ relativeTime: defaultRelativeTime,
+
+ months: defaultLocaleMonths,
+ monthsShort: defaultLocaleMonthsShort,
+
+ week: defaultLocaleWeek,
+
+ weekdays: defaultLocaleWeekdays,
+ weekdaysMin: defaultLocaleWeekdaysMin,
+ weekdaysShort: defaultLocaleWeekdaysShort,
+
+ meridiemParse: defaultLocaleMeridiemParse,
+ };
+
+ // internal storage for locale config files
+ var locales = {},
+ localeFamilies = {},
+ globalLocale;
+
+ function commonPrefix(arr1, arr2) {
+ var i,
+ minl = Math.min(arr1.length, arr2.length);
+ for (i = 0; i < minl; i += 1) {
+ if (arr1[i] !== arr2[i]) {
+ return i;
+ }
+ }
+ return minl;
+ }
+
+ function normalizeLocale(key) {
+ return key ? key.toLowerCase().replace('_', '-') : key;
+ }
+
+ // pick the locale from the array
+ // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
+ // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
+ function chooseLocale(names) {
+ var i = 0,
+ j,
+ next,
+ locale,
+ split;
+
+ while (i < names.length) {
+ split = normalizeLocale(names[i]).split('-');
+ j = split.length;
+ next = normalizeLocale(names[i + 1]);
+ next = next ? next.split('-') : null;
+ while (j > 0) {
+ locale = loadLocale(split.slice(0, j).join('-'));
+ if (locale) {
+ return locale;
+ }
+ if (
+ next &&
+ next.length >= j &&
+ commonPrefix(split, next) >= j - 1
+ ) {
+ //the next array item is better than a shallower substring of this one
+ break;
+ }
+ j--;
+ }
+ i++;
+ }
+ return globalLocale;
+ }
+
+ function loadLocale(name) {
+ var oldLocale = null,
+ aliasedRequire;
+ // TODO: Find a better way to register and load all the locales in Node
+ if (
+ locales[name] === undefined &&
+ "object" !== 'undefined' &&
+ module &&
+ module.exports
+ ) {
+ try {
+ oldLocale = globalLocale._abbr;
+ aliasedRequire = undefined;
+ __webpack_require__("./node_modules/moment/locale sync recursive ^\\.\\/.*$")("./" + name);
+ getSetGlobalLocale(oldLocale);
+ } catch (e) {
+ // mark as not found to avoid repeating expensive file require call causing high CPU
+ // when trying to find en-US, en_US, en-us for every format call
+ locales[name] = null; // null means not found
+ }
+ }
+ return locales[name];
+ }
+
+ // This function will load locale and then set the global locale. If
+ // no arguments are passed in, it will simply return the current global
+ // locale key.
+ function getSetGlobalLocale(key, values) {
+ var data;
+ if (key) {
+ if (isUndefined(values)) {
+ data = getLocale(key);
+ } else {
+ data = defineLocale(key, values);
+ }
+
+ if (data) {
+ // moment.duration._locale = moment._locale = data;
+ globalLocale = data;
+ } else {
+ if (typeof console !== 'undefined' && console.warn) {
+ //warn user if arguments are passed but the locale could not be set
+ console.warn(
+ 'Locale ' + key + ' not found. Did you forget to load it?'
+ );
+ }
+ }
+ }
+
+ return globalLocale._abbr;
+ }
+
+ function defineLocale(name, config) {
+ if (config !== null) {
+ var locale,
+ parentConfig = baseConfig;
+ config.abbr = name;
+ if (locales[name] != null) {
+ deprecateSimple(
+ 'defineLocaleOverride',
+ 'use moment.updateLocale(localeName, config) to change ' +
+ 'an existing locale. moment.defineLocale(localeName, ' +
+ 'config) should only be used for creating a new locale ' +
+ 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'
+ );
+ parentConfig = locales[name]._config;
+ } else if (config.parentLocale != null) {
+ if (locales[config.parentLocale] != null) {
+ parentConfig = locales[config.parentLocale]._config;
+ } else {
+ locale = loadLocale(config.parentLocale);
+ if (locale != null) {
+ parentConfig = locale._config;
+ } else {
+ if (!localeFamilies[config.parentLocale]) {
+ localeFamilies[config.parentLocale] = [];
+ }
+ localeFamilies[config.parentLocale].push({
+ name: name,
+ config: config,
+ });
+ return null;
+ }
+ }
+ }
+ locales[name] = new Locale(mergeConfigs(parentConfig, config));
+
+ if (localeFamilies[name]) {
+ localeFamilies[name].forEach(function (x) {
+ defineLocale(x.name, x.config);
+ });
+ }
+
+ // backwards compat for now: also set the locale
+ // make sure we set the locale AFTER all child locales have been
+ // created, so we won't end up with the child locale set.
+ getSetGlobalLocale(name);
+
+ return locales[name];
+ } else {
+ // useful for testing
+ delete locales[name];
+ return null;
+ }
+ }
+
+ function updateLocale(name, config) {
+ if (config != null) {
+ var locale,
+ tmpLocale,
+ parentConfig = baseConfig;
+
+ if (locales[name] != null && locales[name].parentLocale != null) {
+ // Update existing child locale in-place to avoid memory-leaks
+ locales[name].set(mergeConfigs(locales[name]._config, config));
+ } else {
+ // MERGE
+ tmpLocale = loadLocale(name);
+ if (tmpLocale != null) {
+ parentConfig = tmpLocale._config;
+ }
+ config = mergeConfigs(parentConfig, config);
+ if (tmpLocale == null) {
+ // updateLocale is called for creating a new locale
+ // Set abbr so it will have a name (getters return
+ // undefined otherwise).
+ config.abbr = name;
+ }
+ locale = new Locale(config);
+ locale.parentLocale = locales[name];
+ locales[name] = locale;
+ }
+
+ // backwards compat for now: also set the locale
+ getSetGlobalLocale(name);
+ } else {
+ // pass null for config to unupdate, useful for tests
+ if (locales[name] != null) {
+ if (locales[name].parentLocale != null) {
+ locales[name] = locales[name].parentLocale;
+ if (name === getSetGlobalLocale()) {
+ getSetGlobalLocale(name);
+ }
+ } else if (locales[name] != null) {
+ delete locales[name];
+ }
+ }
+ }
+ return locales[name];
+ }
+
+ // returns locale data
+ function getLocale(key) {
+ var locale;
+
+ if (key && key._locale && key._locale._abbr) {
+ key = key._locale._abbr;
+ }
+
+ if (!key) {
+ return globalLocale;
+ }
+
+ if (!isArray(key)) {
+ //short-circuit everything else
+ locale = loadLocale(key);
+ if (locale) {
+ return locale;
+ }
+ key = [key];
+ }
+
+ return chooseLocale(key);
+ }
+
+ function listLocales() {
+ return keys(locales);
+ }
+
+ function checkOverflow(m) {
+ var overflow,
+ a = m._a;
+
+ if (a && getParsingFlags(m).overflow === -2) {
+ overflow =
+ a[MONTH] < 0 || a[MONTH] > 11
+ ? MONTH
+ : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])
+ ? DATE
+ : a[HOUR] < 0 ||
+ a[HOUR] > 24 ||
+ (a[HOUR] === 24 &&
+ (a[MINUTE] !== 0 ||
+ a[SECOND] !== 0 ||
+ a[MILLISECOND] !== 0))
+ ? HOUR
+ : a[MINUTE] < 0 || a[MINUTE] > 59
+ ? MINUTE
+ : a[SECOND] < 0 || a[SECOND] > 59
+ ? SECOND
+ : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
+ ? MILLISECOND
+ : -1;
+
+ if (
+ getParsingFlags(m)._overflowDayOfYear &&
+ (overflow < YEAR || overflow > DATE)
+ ) {
+ overflow = DATE;
+ }
+ if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
+ overflow = WEEK;
+ }
+ if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
+ overflow = WEEKDAY;
+ }
+
+ getParsingFlags(m).overflow = overflow;
+ }
+
+ return m;
+ }
+
+ // iso 8601 regex
+ // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
+ var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
+ basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
+ tzRegex = /Z|[+-]\d\d(?::?\d\d)?/,
+ isoDates = [
+ ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
+ ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
+ ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
+ ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
+ ['YYYY-DDD', /\d{4}-\d{3}/],
+ ['YYYY-MM', /\d{4}-\d\d/, false],
+ ['YYYYYYMMDD', /[+-]\d{10}/],
+ ['YYYYMMDD', /\d{8}/],
+ ['GGGG[W]WWE', /\d{4}W\d{3}/],
+ ['GGGG[W]WW', /\d{4}W\d{2}/, false],
+ ['YYYYDDD', /\d{7}/],
+ ['YYYYMM', /\d{6}/, false],
+ ['YYYY', /\d{4}/, false],
+ ],
+ // iso time formats and regexes
+ isoTimes = [
+ ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
+ ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
+ ['HH:mm:ss', /\d\d:\d\d:\d\d/],
+ ['HH:mm', /\d\d:\d\d/],
+ ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
+ ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
+ ['HHmmss', /\d\d\d\d\d\d/],
+ ['HHmm', /\d\d\d\d/],
+ ['HH', /\d\d/],
+ ],
+ aspNetJsonRegex = /^\/?Date\((-?\d+)/i,
+ // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
+ rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,
+ obsOffsets = {
+ UT: 0,
+ GMT: 0,
+ EDT: -4 * 60,
+ EST: -5 * 60,
+ CDT: -5 * 60,
+ CST: -6 * 60,
+ MDT: -6 * 60,
+ MST: -7 * 60,
+ PDT: -7 * 60,
+ PST: -8 * 60,
+ };
+
+ // date from iso format
+ function configFromISO(config) {
+ var i,
+ l,
+ string = config._i,
+ match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
+ allowTime,
+ dateFormat,
+ timeFormat,
+ tzFormat;
+
+ if (match) {
+ getParsingFlags(config).iso = true;
+
+ for (i = 0, l = isoDates.length; i < l; i++) {
+ if (isoDates[i][1].exec(match[1])) {
+ dateFormat = isoDates[i][0];
+ allowTime = isoDates[i][2] !== false;
+ break;
+ }
+ }
+ if (dateFormat == null) {
+ config._isValid = false;
+ return;
+ }
+ if (match[3]) {
+ for (i = 0, l = isoTimes.length; i < l; i++) {
+ if (isoTimes[i][1].exec(match[3])) {
+ // match[2] should be 'T' or space
+ timeFormat = (match[2] || ' ') + isoTimes[i][0];
+ break;
+ }
+ }
+ if (timeFormat == null) {
+ config._isValid = false;
+ return;
+ }
+ }
+ if (!allowTime && timeFormat != null) {
+ config._isValid = false;
+ return;
+ }
+ if (match[4]) {
+ if (tzRegex.exec(match[4])) {
+ tzFormat = 'Z';
+ } else {
+ config._isValid = false;
+ return;
+ }
+ }
+ config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
+ configFromStringAndFormat(config);
+ } else {
+ config._isValid = false;
+ }
+ }
+
+ function extractFromRFC2822Strings(
+ yearStr,
+ monthStr,
+ dayStr,
+ hourStr,
+ minuteStr,
+ secondStr
+ ) {
+ var result = [
+ untruncateYear(yearStr),
+ defaultLocaleMonthsShort.indexOf(monthStr),
+ parseInt(dayStr, 10),
+ parseInt(hourStr, 10),
+ parseInt(minuteStr, 10),
+ ];
+
+ if (secondStr) {
+ result.push(parseInt(secondStr, 10));
+ }
+
+ return result;
+ }
+
+ function untruncateYear(yearStr) {
+ var year = parseInt(yearStr, 10);
+ if (year <= 49) {
+ return 2000 + year;
+ } else if (year <= 999) {
+ return 1900 + year;
+ }
+ return year;
+ }
+
+ function preprocessRFC2822(s) {
+ // Remove comments and folding whitespace and replace multiple-spaces with a single space
+ return s
+ .replace(/\([^)]*\)|[\n\t]/g, ' ')
+ .replace(/(\s\s+)/g, ' ')
+ .replace(/^\s\s*/, '')
+ .replace(/\s\s*$/, '');
+ }
+
+ function checkWeekday(weekdayStr, parsedInput, config) {
+ if (weekdayStr) {
+ // TODO: Replace the vanilla JS Date object with an independent day-of-week check.
+ var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
+ weekdayActual = new Date(
+ parsedInput[0],
+ parsedInput[1],
+ parsedInput[2]
+ ).getDay();
+ if (weekdayProvided !== weekdayActual) {
+ getParsingFlags(config).weekdayMismatch = true;
+ config._isValid = false;
+ return false;
+ }
+ }
+ return true;
+ }
+
+ function calculateOffset(obsOffset, militaryOffset, numOffset) {
+ if (obsOffset) {
+ return obsOffsets[obsOffset];
+ } else if (militaryOffset) {
+ // the only allowed military tz is Z
+ return 0;
+ } else {
+ var hm = parseInt(numOffset, 10),
+ m = hm % 100,
+ h = (hm - m) / 100;
+ return h * 60 + m;
+ }
+ }
+
+ // date and time from ref 2822 format
+ function configFromRFC2822(config) {
+ var match = rfc2822.exec(preprocessRFC2822(config._i)),
+ parsedArray;
+ if (match) {
+ parsedArray = extractFromRFC2822Strings(
+ match[4],
+ match[3],
+ match[2],
+ match[5],
+ match[6],
+ match[7]
+ );
+ if (!checkWeekday(match[1], parsedArray, config)) {
+ return;
+ }
+
+ config._a = parsedArray;
+ config._tzm = calculateOffset(match[8], match[9], match[10]);
+
+ config._d = createUTCDate.apply(null, config._a);
+ config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+
+ getParsingFlags(config).rfc2822 = true;
+ } else {
+ config._isValid = false;
+ }
+ }
+
+ // date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict
+ function configFromString(config) {
+ var matched = aspNetJsonRegex.exec(config._i);
+ if (matched !== null) {
+ config._d = new Date(+matched[1]);
+ return;
+ }
+
+ configFromISO(config);
+ if (config._isValid === false) {
+ delete config._isValid;
+ } else {
+ return;
+ }
+
+ configFromRFC2822(config);
+ if (config._isValid === false) {
+ delete config._isValid;
+ } else {
+ return;
+ }
+
+ if (config._strict) {
+ config._isValid = false;
+ } else {
+ // Final attempt, use Input Fallback
+ hooks.createFromInputFallback(config);
+ }
+ }
+
+ hooks.createFromInputFallback = deprecate(
+ 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
+ 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
+ 'discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.',
+ function (config) {
+ config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
+ }
+ );
+
+ // Pick the first defined of two or three arguments.
+ function defaults(a, b, c) {
+ if (a != null) {
+ return a;
+ }
+ if (b != null) {
+ return b;
+ }
+ return c;
+ }
+
+ function currentDateArray(config) {
+ // hooks is actually the exported moment object
+ var nowValue = new Date(hooks.now());
+ if (config._useUTC) {
+ return [
+ nowValue.getUTCFullYear(),
+ nowValue.getUTCMonth(),
+ nowValue.getUTCDate(),
+ ];
+ }
+ return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
+ }
+
+ // convert an array to a date.
+ // the array should mirror the parameters below
+ // note: all values past the year are optional and will default to the lowest possible value.
+ // [year, month, day , hour, minute, second, millisecond]
+ function configFromArray(config) {
+ var i,
+ date,
+ input = [],
+ currentDate,
+ expectedWeekday,
+ yearToUse;
+
+ if (config._d) {
+ return;
+ }
+
+ currentDate = currentDateArray(config);
+
+ //compute day of the year from weeks and weekdays
+ if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
+ dayOfYearFromWeekInfo(config);
+ }
+
+ //if the day of the year is set, figure out what it is
+ if (config._dayOfYear != null) {
+ yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+
+ if (
+ config._dayOfYear > daysInYear(yearToUse) ||
+ config._dayOfYear === 0
+ ) {
+ getParsingFlags(config)._overflowDayOfYear = true;
+ }
+
+ date = createUTCDate(yearToUse, 0, config._dayOfYear);
+ config._a[MONTH] = date.getUTCMonth();
+ config._a[DATE] = date.getUTCDate();
+ }
+
+ // Default to current date.
+ // * if no year, month, day of month are given, default to today
+ // * if day of month is given, default month and year
+ // * if month is given, default only year
+ // * if year is given, don't default anything
+ for (i = 0; i < 3 && config._a[i] == null; ++i) {
+ config._a[i] = input[i] = currentDate[i];
+ }
+
+ // Zero out whatever was not defaulted, including time
+ for (; i < 7; i++) {
+ config._a[i] = input[i] =
+ config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i];
+ }
+
+ // Check for 24:00:00.000
+ if (
+ config._a[HOUR] === 24 &&
+ config._a[MINUTE] === 0 &&
+ config._a[SECOND] === 0 &&
+ config._a[MILLISECOND] === 0
+ ) {
+ config._nextDay = true;
+ config._a[HOUR] = 0;
+ }
+
+ config._d = (config._useUTC ? createUTCDate : createDate).apply(
+ null,
+ input
+ );
+ expectedWeekday = config._useUTC
+ ? config._d.getUTCDay()
+ : config._d.getDay();
+
+ // Apply timezone offset from input. The actual utcOffset can be changed
+ // with parseZone.
+ if (config._tzm != null) {
+ config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+ }
+
+ if (config._nextDay) {
+ config._a[HOUR] = 24;
+ }
+
+ // check for mismatching day of week
+ if (
+ config._w &&
+ typeof config._w.d !== 'undefined' &&
+ config._w.d !== expectedWeekday
+ ) {
+ getParsingFlags(config).weekdayMismatch = true;
+ }
+ }
+
+ function dayOfYearFromWeekInfo(config) {
+ var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
+
+ w = config._w;
+ if (w.GG != null || w.W != null || w.E != null) {
+ dow = 1;
+ doy = 4;
+
+ // TODO: We need to take the current isoWeekYear, but that depends on
+ // how we interpret now (local, utc, fixed offset). So create
+ // a now version of current config (take local/utc/offset flags, and
+ // create now).
+ weekYear = defaults(
+ w.GG,
+ config._a[YEAR],
+ weekOfYear(createLocal(), 1, 4).year
+ );
+ week = defaults(w.W, 1);
+ weekday = defaults(w.E, 1);
+ if (weekday < 1 || weekday > 7) {
+ weekdayOverflow = true;
+ }
+ } else {
+ dow = config._locale._week.dow;
+ doy = config._locale._week.doy;
+
+ curWeek = weekOfYear(createLocal(), dow, doy);
+
+ weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
+
+ // Default to current week.
+ week = defaults(w.w, curWeek.week);
+
+ if (w.d != null) {
+ // weekday -- low day numbers are considered next week
+ weekday = w.d;
+ if (weekday < 0 || weekday > 6) {
+ weekdayOverflow = true;
+ }
+ } else if (w.e != null) {
+ // local weekday -- counting starts from beginning of week
+ weekday = w.e + dow;
+ if (w.e < 0 || w.e > 6) {
+ weekdayOverflow = true;
+ }
+ } else {
+ // default to beginning of week
+ weekday = dow;
+ }
+ }
+ if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
+ getParsingFlags(config)._overflowWeeks = true;
+ } else if (weekdayOverflow != null) {
+ getParsingFlags(config)._overflowWeekday = true;
+ } else {
+ temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
+ config._a[YEAR] = temp.year;
+ config._dayOfYear = temp.dayOfYear;
+ }
+ }
+
+ // constant that refers to the ISO standard
+ hooks.ISO_8601 = function () {};
+
+ // constant that refers to the RFC 2822 form
+ hooks.RFC_2822 = function () {};
+
+ // date from string and format string
+ function configFromStringAndFormat(config) {
+ // TODO: Move this to another part of the creation flow to prevent circular deps
+ if (config._f === hooks.ISO_8601) {
+ configFromISO(config);
+ return;
+ }
+ if (config._f === hooks.RFC_2822) {
+ configFromRFC2822(config);
+ return;
+ }
+ config._a = [];
+ getParsingFlags(config).empty = true;
+
+ // This array is used to make a Date, either with `new Date` or `Date.UTC`
+ var string = '' + config._i,
+ i,
+ parsedInput,
+ tokens,
+ token,
+ skipped,
+ stringLength = string.length,
+ totalParsedInputLength = 0,
+ era;
+
+ tokens =
+ expandFormat(config._f, config._locale).match(formattingTokens) || [];
+
+ for (i = 0; i < tokens.length; i++) {
+ token = tokens[i];
+ parsedInput = (string.match(getParseRegexForToken(token, config)) ||
+ [])[0];
+ if (parsedInput) {
+ skipped = string.substr(0, string.indexOf(parsedInput));
+ if (skipped.length > 0) {
+ getParsingFlags(config).unusedInput.push(skipped);
+ }
+ string = string.slice(
+ string.indexOf(parsedInput) + parsedInput.length
+ );
+ totalParsedInputLength += parsedInput.length;
+ }
+ // don't parse if it's not a known token
+ if (formatTokenFunctions[token]) {
+ if (parsedInput) {
+ getParsingFlags(config).empty = false;
+ } else {
+ getParsingFlags(config).unusedTokens.push(token);
+ }
+ addTimeToArrayFromToken(token, parsedInput, config);
+ } else if (config._strict && !parsedInput) {
+ getParsingFlags(config).unusedTokens.push(token);
+ }
+ }
+
+ // add remaining unparsed input length to the string
+ getParsingFlags(config).charsLeftOver =
+ stringLength - totalParsedInputLength;
+ if (string.length > 0) {
+ getParsingFlags(config).unusedInput.push(string);
+ }
+
+ // clear _12h flag if hour is <= 12
+ if (
+ config._a[HOUR] <= 12 &&
+ getParsingFlags(config).bigHour === true &&
+ config._a[HOUR] > 0
+ ) {
+ getParsingFlags(config).bigHour = undefined;
+ }
+
+ getParsingFlags(config).parsedDateParts = config._a.slice(0);
+ getParsingFlags(config).meridiem = config._meridiem;
+ // handle meridiem
+ config._a[HOUR] = meridiemFixWrap(
+ config._locale,
+ config._a[HOUR],
+ config._meridiem
+ );
+
+ // handle era
+ era = getParsingFlags(config).era;
+ if (era !== null) {
+ config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
+ }
+
+ configFromArray(config);
+ checkOverflow(config);
+ }
+
+ function meridiemFixWrap(locale, hour, meridiem) {
+ var isPm;
+
+ if (meridiem == null) {
+ // nothing to do
+ return hour;
+ }
+ if (locale.meridiemHour != null) {
+ return locale.meridiemHour(hour, meridiem);
+ } else if (locale.isPM != null) {
+ // Fallback
+ isPm = locale.isPM(meridiem);
+ if (isPm && hour < 12) {
+ hour += 12;
+ }
+ if (!isPm && hour === 12) {
+ hour = 0;
+ }
+ return hour;
+ } else {
+ // this is not supposed to happen
+ return hour;
+ }
+ }
+
+ // date from string and array of format strings
+ function configFromStringAndArray(config) {
+ var tempConfig,
+ bestMoment,
+ scoreToBeat,
+ i,
+ currentScore,
+ validFormatFound,
+ bestFormatIsValid = false;
+
+ if (config._f.length === 0) {
+ getParsingFlags(config).invalidFormat = true;
+ config._d = new Date(NaN);
+ return;
+ }
+
+ for (i = 0; i < config._f.length; i++) {
+ currentScore = 0;
+ validFormatFound = false;
+ tempConfig = copyConfig({}, config);
+ if (config._useUTC != null) {
+ tempConfig._useUTC = config._useUTC;
+ }
+ tempConfig._f = config._f[i];
+ configFromStringAndFormat(tempConfig);
+
+ if (isValid(tempConfig)) {
+ validFormatFound = true;
+ }
+
+ // if there is any input that was not parsed add a penalty for that format
+ currentScore += getParsingFlags(tempConfig).charsLeftOver;
+
+ //or tokens
+ currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
+
+ getParsingFlags(tempConfig).score = currentScore;
+
+ if (!bestFormatIsValid) {
+ if (
+ scoreToBeat == null ||
+ currentScore < scoreToBeat ||
+ validFormatFound
+ ) {
+ scoreToBeat = currentScore;
+ bestMoment = tempConfig;
+ if (validFormatFound) {
+ bestFormatIsValid = true;
+ }
+ }
+ } else {
+ if (currentScore < scoreToBeat) {
+ scoreToBeat = currentScore;
+ bestMoment = tempConfig;
+ }
+ }
+ }
+
+ extend(config, bestMoment || tempConfig);
+ }
+
+ function configFromObject(config) {
+ if (config._d) {
+ return;
+ }
+
+ var i = normalizeObjectUnits(config._i),
+ dayOrDate = i.day === undefined ? i.date : i.day;
+ config._a = map(
+ [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],
+ function (obj) {
+ return obj && parseInt(obj, 10);
+ }
+ );
+
+ configFromArray(config);
+ }
+
+ function createFromConfig(config) {
+ var res = new Moment(checkOverflow(prepareConfig(config)));
+ if (res._nextDay) {
+ // Adding is smart enough around DST
+ res.add(1, 'd');
+ res._nextDay = undefined;
+ }
+
+ return res;
+ }
+
+ function prepareConfig(config) {
+ var input = config._i,
+ format = config._f;
+
+ config._locale = config._locale || getLocale(config._l);
+
+ if (input === null || (format === undefined && input === '')) {
+ return createInvalid({ nullInput: true });
+ }
+
+ if (typeof input === 'string') {
+ config._i = input = config._locale.preparse(input);
+ }
+
+ if (isMoment(input)) {
+ return new Moment(checkOverflow(input));
+ } else if (isDate(input)) {
+ config._d = input;
+ } else if (isArray(format)) {
+ configFromStringAndArray(config);
+ } else if (format) {
+ configFromStringAndFormat(config);
+ } else {
+ configFromInput(config);
+ }
+
+ if (!isValid(config)) {
+ config._d = null;
+ }
+
+ return config;
+ }
+
+ function configFromInput(config) {
+ var input = config._i;
+ if (isUndefined(input)) {
+ config._d = new Date(hooks.now());
+ } else if (isDate(input)) {
+ config._d = new Date(input.valueOf());
+ } else if (typeof input === 'string') {
+ configFromString(config);
+ } else if (isArray(input)) {
+ config._a = map(input.slice(0), function (obj) {
+ return parseInt(obj, 10);
+ });
+ configFromArray(config);
+ } else if (isObject(input)) {
+ configFromObject(config);
+ } else if (isNumber(input)) {
+ // from milliseconds
+ config._d = new Date(input);
+ } else {
+ hooks.createFromInputFallback(config);
+ }
+ }
+
+ function createLocalOrUTC(input, format, locale, strict, isUTC) {
+ var c = {};
+
+ if (format === true || format === false) {
+ strict = format;
+ format = undefined;
+ }
+
+ if (locale === true || locale === false) {
+ strict = locale;
+ locale = undefined;
+ }
+
+ if (
+ (isObject(input) && isObjectEmpty(input)) ||
+ (isArray(input) && input.length === 0)
+ ) {
+ input = undefined;
+ }
+ // object construction must be done this way.
+ // https://github.com/moment/moment/issues/1423
+ c._isAMomentObject = true;
+ c._useUTC = c._isUTC = isUTC;
+ c._l = locale;
+ c._i = input;
+ c._f = format;
+ c._strict = strict;
+
+ return createFromConfig(c);
+ }
+
+ function createLocal(input, format, locale, strict) {
+ return createLocalOrUTC(input, format, locale, strict, false);
+ }
+
+ var prototypeMin = deprecate(
+ 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
+ function () {
+ var other = createLocal.apply(null, arguments);
+ if (this.isValid() && other.isValid()) {
+ return other < this ? this : other;
+ } else {
+ return createInvalid();
+ }
+ }
+ ),
+ prototypeMax = deprecate(
+ 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
+ function () {
+ var other = createLocal.apply(null, arguments);
+ if (this.isValid() && other.isValid()) {
+ return other > this ? this : other;
+ } else {
+ return createInvalid();
+ }
+ }
+ );
+
+ // Pick a moment m from moments so that m[fn](other) is true for all
+ // other. This relies on the function fn to be transitive.
+ //
+ // moments should either be an array of moment objects or an array, whose
+ // first element is an array of moment objects.
+ function pickBy(fn, moments) {
+ var res, i;
+ if (moments.length === 1 && isArray(moments[0])) {
+ moments = moments[0];
+ }
+ if (!moments.length) {
+ return createLocal();
+ }
+ res = moments[0];
+ for (i = 1; i < moments.length; ++i) {
+ if (!moments[i].isValid() || moments[i][fn](res)) {
+ res = moments[i];
+ }
+ }
+ return res;
+ }
+
+ // TODO: Use [].sort instead?
+ function min() {
+ var args = [].slice.call(arguments, 0);
+
+ return pickBy('isBefore', args);
+ }
+
+ function max() {
+ var args = [].slice.call(arguments, 0);
+
+ return pickBy('isAfter', args);
+ }
+
+ var now = function () {
+ return Date.now ? Date.now() : +new Date();
+ };
+
+ var ordering = [
+ 'year',
+ 'quarter',
+ 'month',
+ 'week',
+ 'day',
+ 'hour',
+ 'minute',
+ 'second',
+ 'millisecond',
+ ];
+
+ function isDurationValid(m) {
+ var key,
+ unitHasDecimal = false,
+ i;
+ for (key in m) {
+ if (
+ hasOwnProp(m, key) &&
+ !(
+ indexOf.call(ordering, key) !== -1 &&
+ (m[key] == null || !isNaN(m[key]))
+ )
+ ) {
+ return false;
+ }
+ }
+
+ for (i = 0; i < ordering.length; ++i) {
+ if (m[ordering[i]]) {
+ if (unitHasDecimal) {
+ return false; // only allow non-integers for smallest unit
+ }
+ if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
+ unitHasDecimal = true;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ function isValid$1() {
+ return this._isValid;
+ }
+
+ function createInvalid$1() {
+ return createDuration(NaN);
+ }
+
+ function Duration(duration) {
+ var normalizedInput = normalizeObjectUnits(duration),
+ years = normalizedInput.year || 0,
+ quarters = normalizedInput.quarter || 0,
+ months = normalizedInput.month || 0,
+ weeks = normalizedInput.week || normalizedInput.isoWeek || 0,
+ days = normalizedInput.day || 0,
+ hours = normalizedInput.hour || 0,
+ minutes = normalizedInput.minute || 0,
+ seconds = normalizedInput.second || 0,
+ milliseconds = normalizedInput.millisecond || 0;
+
+ this._isValid = isDurationValid(normalizedInput);
+
+ // representation for dateAddRemove
+ this._milliseconds =
+ +milliseconds +
+ seconds * 1e3 + // 1000
+ minutes * 6e4 + // 1000 * 60
+ hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
+ // Because of dateAddRemove treats 24 hours as different from a
+ // day when working around DST, we need to store them separately
+ this._days = +days + weeks * 7;
+ // It is impossible to translate months into days without knowing
+ // which months you are are talking about, so we have to store
+ // it separately.
+ this._months = +months + quarters * 3 + years * 12;
+
+ this._data = {};
+
+ this._locale = getLocale();
+
+ this._bubble();
+ }
+
+ function isDuration(obj) {
+ return obj instanceof Duration;
+ }
+
+ function absRound(number) {
+ if (number < 0) {
+ return Math.round(-1 * number) * -1;
+ } else {
+ return Math.round(number);
+ }
+ }
+
+ // compare two arrays, return the number of differences
+ function compareArrays(array1, array2, dontConvert) {
+ var len = Math.min(array1.length, array2.length),
+ lengthDiff = Math.abs(array1.length - array2.length),
+ diffs = 0,
+ i;
+ for (i = 0; i < len; i++) {
+ if (
+ (dontConvert && array1[i] !== array2[i]) ||
+ (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))
+ ) {
+ diffs++;
+ }
+ }
+ return diffs + lengthDiff;
+ }
+
+ // FORMATTING
+
+ function offset(token, separator) {
+ addFormatToken(token, 0, 0, function () {
+ var offset = this.utcOffset(),
+ sign = '+';
+ if (offset < 0) {
+ offset = -offset;
+ sign = '-';
+ }
+ return (
+ sign +
+ zeroFill(~~(offset / 60), 2) +
+ separator +
+ zeroFill(~~offset % 60, 2)
+ );
+ });
+ }
+
+ offset('Z', ':');
+ offset('ZZ', '');
+
+ // PARSING
+
+ addRegexToken('Z', matchShortOffset);
+ addRegexToken('ZZ', matchShortOffset);
+ addParseToken(['Z', 'ZZ'], function (input, array, config) {
+ config._useUTC = true;
+ config._tzm = offsetFromString(matchShortOffset, input);
+ });
+
+ // HELPERS
+
+ // timezone chunker
+ // '+10:00' > ['10', '00']
+ // '-1530' > ['-15', '30']
+ var chunkOffset = /([\+\-]|\d\d)/gi;
+
+ function offsetFromString(matcher, string) {
+ var matches = (string || '').match(matcher),
+ chunk,
+ parts,
+ minutes;
+
+ if (matches === null) {
+ return null;
+ }
+
+ chunk = matches[matches.length - 1] || [];
+ parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
+ minutes = +(parts[1] * 60) + toInt(parts[2]);
+
+ return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;
+ }
+
+ // Return a moment from input, that is local/utc/zone equivalent to model.
+ function cloneWithOffset(input, model) {
+ var res, diff;
+ if (model._isUTC) {
+ res = model.clone();
+ diff =
+ (isMoment(input) || isDate(input)
+ ? input.valueOf()
+ : createLocal(input).valueOf()) - res.valueOf();
+ // Use low-level api, because this fn is low-level api.
+ res._d.setTime(res._d.valueOf() + diff);
+ hooks.updateOffset(res, false);
+ return res;
+ } else {
+ return createLocal(input).local();
+ }
+ }
+
+ function getDateOffset(m) {
+ // On Firefox.24 Date#getTimezoneOffset returns a floating point.
+ // https://github.com/moment/moment/pull/1871
+ return -Math.round(m._d.getTimezoneOffset());
+ }
+
+ // HOOKS
+
+ // This function will be called whenever a moment is mutated.
+ // It is intended to keep the offset in sync with the timezone.
+ hooks.updateOffset = function () {};
+
+ // MOMENTS
+
+ // keepLocalTime = true means only change the timezone, without
+ // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
+ // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
+ // +0200, so we adjust the time as needed, to be valid.
+ //
+ // Keeping the time actually adds/subtracts (one hour)
+ // from the actual represented time. That is why we call updateOffset
+ // a second time. In case it wants us to change the offset again
+ // _changeInProgress == true case, then we have to adjust, because
+ // there is no such time in the given timezone.
+ function getSetOffset(input, keepLocalTime, keepMinutes) {
+ var offset = this._offset || 0,
+ localAdjust;
+ if (!this.isValid()) {
+ return input != null ? this : NaN;
+ }
+ if (input != null) {
+ if (typeof input === 'string') {
+ input = offsetFromString(matchShortOffset, input);
+ if (input === null) {
+ return this;
+ }
+ } else if (Math.abs(input) < 16 && !keepMinutes) {
+ input = input * 60;
+ }
+ if (!this._isUTC && keepLocalTime) {
+ localAdjust = getDateOffset(this);
+ }
+ this._offset = input;
+ this._isUTC = true;
+ if (localAdjust != null) {
+ this.add(localAdjust, 'm');
+ }
+ if (offset !== input) {
+ if (!keepLocalTime || this._changeInProgress) {
+ addSubtract(
+ this,
+ createDuration(input - offset, 'm'),
+ 1,
+ false
+ );
+ } else if (!this._changeInProgress) {
+ this._changeInProgress = true;
+ hooks.updateOffset(this, true);
+ this._changeInProgress = null;
+ }
+ }
+ return this;
+ } else {
+ return this._isUTC ? offset : getDateOffset(this);
+ }
+ }
+
+ function getSetZone(input, keepLocalTime) {
+ if (input != null) {
+ if (typeof input !== 'string') {
+ input = -input;
+ }
+
+ this.utcOffset(input, keepLocalTime);
+
+ return this;
+ } else {
+ return -this.utcOffset();
+ }
+ }
+
+ function setOffsetToUTC(keepLocalTime) {
+ return this.utcOffset(0, keepLocalTime);
+ }
+
+ function setOffsetToLocal(keepLocalTime) {
+ if (this._isUTC) {
+ this.utcOffset(0, keepLocalTime);
+ this._isUTC = false;
+
+ if (keepLocalTime) {
+ this.subtract(getDateOffset(this), 'm');
+ }
+ }
+ return this;
+ }
+
+ function setOffsetToParsedOffset() {
+ if (this._tzm != null) {
+ this.utcOffset(this._tzm, false, true);
+ } else if (typeof this._i === 'string') {
+ var tZone = offsetFromString(matchOffset, this._i);
+ if (tZone != null) {
+ this.utcOffset(tZone);
+ } else {
+ this.utcOffset(0, true);
+ }
+ }
+ return this;
+ }
+
+ function hasAlignedHourOffset(input) {
+ if (!this.isValid()) {
+ return false;
+ }
+ input = input ? createLocal(input).utcOffset() : 0;
+
+ return (this.utcOffset() - input) % 60 === 0;
+ }
+
+ function isDaylightSavingTime() {
+ return (
+ this.utcOffset() > this.clone().month(0).utcOffset() ||
+ this.utcOffset() > this.clone().month(5).utcOffset()
+ );
+ }
+
+ function isDaylightSavingTimeShifted() {
+ if (!isUndefined(this._isDSTShifted)) {
+ return this._isDSTShifted;
+ }
+
+ var c = {},
+ other;
+
+ copyConfig(c, this);
+ c = prepareConfig(c);
+
+ if (c._a) {
+ other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
+ this._isDSTShifted =
+ this.isValid() && compareArrays(c._a, other.toArray()) > 0;
+ } else {
+ this._isDSTShifted = false;
+ }
+
+ return this._isDSTShifted;
+ }
+
+ function isLocal() {
+ return this.isValid() ? !this._isUTC : false;
+ }
+
+ function isUtcOffset() {
+ return this.isValid() ? this._isUTC : false;
+ }
+
+ function isUtc() {
+ return this.isValid() ? this._isUTC && this._offset === 0 : false;
+ }
+
+ // ASP.NET json date format regex
+ var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,
+ // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
+ // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
+ // and further modified to allow for strings containing both week and day
+ isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
+
+ function createDuration(input, key) {
+ var duration = input,
+ // matching against regexp is expensive, do it on demand
+ match = null,
+ sign,
+ ret,
+ diffRes;
+
+ if (isDuration(input)) {
+ duration = {
+ ms: input._milliseconds,
+ d: input._days,
+ M: input._months,
+ };
+ } else if (isNumber(input) || !isNaN(+input)) {
+ duration = {};
+ if (key) {
+ duration[key] = +input;
+ } else {
+ duration.milliseconds = +input;
+ }
+ } else if ((match = aspNetRegex.exec(input))) {
+ sign = match[1] === '-' ? -1 : 1;
+ duration = {
+ y: 0,
+ d: toInt(match[DATE]) * sign,
+ h: toInt(match[HOUR]) * sign,
+ m: toInt(match[MINUTE]) * sign,
+ s: toInt(match[SECOND]) * sign,
+ ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign, // the millisecond decimal point is included in the match
+ };
+ } else if ((match = isoRegex.exec(input))) {
+ sign = match[1] === '-' ? -1 : 1;
+ duration = {
+ y: parseIso(match[2], sign),
+ M: parseIso(match[3], sign),
+ w: parseIso(match[4], sign),
+ d: parseIso(match[5], sign),
+ h: parseIso(match[6], sign),
+ m: parseIso(match[7], sign),
+ s: parseIso(match[8], sign),
+ };
+ } else if (duration == null) {
+ // checks for null or undefined
+ duration = {};
+ } else if (
+ typeof duration === 'object' &&
+ ('from' in duration || 'to' in duration)
+ ) {
+ diffRes = momentsDifference(
+ createLocal(duration.from),
+ createLocal(duration.to)
+ );
+
+ duration = {};
+ duration.ms = diffRes.milliseconds;
+ duration.M = diffRes.months;
+ }
+
+ ret = new Duration(duration);
+
+ if (isDuration(input) && hasOwnProp(input, '_locale')) {
+ ret._locale = input._locale;
+ }
+
+ if (isDuration(input) && hasOwnProp(input, '_isValid')) {
+ ret._isValid = input._isValid;
+ }
+
+ return ret;
+ }
+
+ createDuration.fn = Duration.prototype;
+ createDuration.invalid = createInvalid$1;
+
+ function parseIso(inp, sign) {
+ // We'd normally use ~~inp for this, but unfortunately it also
+ // converts floats to ints.
+ // inp may be undefined, so careful calling replace on it.
+ var res = inp && parseFloat(inp.replace(',', '.'));
+ // apply sign while we're at it
+ return (isNaN(res) ? 0 : res) * sign;
+ }
+
+ function positiveMomentsDifference(base, other) {
+ var res = {};
+
+ res.months =
+ other.month() - base.month() + (other.year() - base.year()) * 12;
+ if (base.clone().add(res.months, 'M').isAfter(other)) {
+ --res.months;
+ }
+
+ res.milliseconds = +other - +base.clone().add(res.months, 'M');
+
+ return res;
+ }
+
+ function momentsDifference(base, other) {
+ var res;
+ if (!(base.isValid() && other.isValid())) {
+ return { milliseconds: 0, months: 0 };
+ }
+
+ other = cloneWithOffset(other, base);
+ if (base.isBefore(other)) {
+ res = positiveMomentsDifference(base, other);
+ } else {
+ res = positiveMomentsDifference(other, base);
+ res.milliseconds = -res.milliseconds;
+ res.months = -res.months;
+ }
+
+ return res;
+ }
+
+ // TODO: remove 'name' arg after deprecation is removed
+ function createAdder(direction, name) {
+ return function (val, period) {
+ var dur, tmp;
+ //invert the arguments, but complain about it
+ if (period !== null && !isNaN(+period)) {
+ deprecateSimple(
+ name,
+ 'moment().' +
+ name +
+ '(period, number) is deprecated. Please use moment().' +
+ name +
+ '(number, period). ' +
+ 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'
+ );
+ tmp = val;
+ val = period;
+ period = tmp;
+ }
+
+ dur = createDuration(val, period);
+ addSubtract(this, dur, direction);
+ return this;
+ };
+ }
+
+ function addSubtract(mom, duration, isAdding, updateOffset) {
+ var milliseconds = duration._milliseconds,
+ days = absRound(duration._days),
+ months = absRound(duration._months);
+
+ if (!mom.isValid()) {
+ // No op
+ return;
+ }
+
+ updateOffset = updateOffset == null ? true : updateOffset;
+
+ if (months) {
+ setMonth(mom, get(mom, 'Month') + months * isAdding);
+ }
+ if (days) {
+ set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
+ }
+ if (milliseconds) {
+ mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
+ }
+ if (updateOffset) {
+ hooks.updateOffset(mom, days || months);
+ }
+ }
+
+ var add = createAdder(1, 'add'),
+ subtract = createAdder(-1, 'subtract');
+
+ function isString(input) {
+ return typeof input === 'string' || input instanceof String;
+ }
+
+ // type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined
+ function isMomentInput(input) {
+ return (
+ isMoment(input) ||
+ isDate(input) ||
+ isString(input) ||
+ isNumber(input) ||
+ isNumberOrStringArray(input) ||
+ isMomentInputObject(input) ||
+ input === null ||
+ input === undefined
+ );
+ }
+
+ function isMomentInputObject(input) {
+ var objectTest = isObject(input) && !isObjectEmpty(input),
+ propertyTest = false,
+ properties = [
+ 'years',
+ 'year',
+ 'y',
+ 'months',
+ 'month',
+ 'M',
+ 'days',
+ 'day',
+ 'd',
+ 'dates',
+ 'date',
+ 'D',
+ 'hours',
+ 'hour',
+ 'h',
+ 'minutes',
+ 'minute',
+ 'm',
+ 'seconds',
+ 'second',
+ 's',
+ 'milliseconds',
+ 'millisecond',
+ 'ms',
+ ],
+ i,
+ property;
+
+ for (i = 0; i < properties.length; i += 1) {
+ property = properties[i];
+ propertyTest = propertyTest || hasOwnProp(input, property);
+ }
+
+ return objectTest && propertyTest;
+ }
+
+ function isNumberOrStringArray(input) {
+ var arrayTest = isArray(input),
+ dataTypeTest = false;
+ if (arrayTest) {
+ dataTypeTest =
+ input.filter(function (item) {
+ return !isNumber(item) && isString(input);
+ }).length === 0;
+ }
+ return arrayTest && dataTypeTest;
+ }
+
+ function isCalendarSpec(input) {
+ var objectTest = isObject(input) && !isObjectEmpty(input),
+ propertyTest = false,
+ properties = [
+ 'sameDay',
+ 'nextDay',
+ 'lastDay',
+ 'nextWeek',
+ 'lastWeek',
+ 'sameElse',
+ ],
+ i,
+ property;
+
+ for (i = 0; i < properties.length; i += 1) {
+ property = properties[i];
+ propertyTest = propertyTest || hasOwnProp(input, property);
+ }
+
+ return objectTest && propertyTest;
+ }
+
+ function getCalendarFormat(myMoment, now) {
+ var diff = myMoment.diff(now, 'days', true);
+ return diff < -6
+ ? 'sameElse'
+ : diff < -1
+ ? 'lastWeek'
+ : diff < 0
+ ? 'lastDay'
+ : diff < 1
+ ? 'sameDay'
+ : diff < 2
+ ? 'nextDay'
+ : diff < 7
+ ? 'nextWeek'
+ : 'sameElse';
+ }
+
+ function calendar$1(time, formats) {
+ // Support for single parameter, formats only overload to the calendar function
+ if (arguments.length === 1) {
+ if (!arguments[0]) {
+ time = undefined;
+ formats = undefined;
+ } else if (isMomentInput(arguments[0])) {
+ time = arguments[0];
+ formats = undefined;
+ } else if (isCalendarSpec(arguments[0])) {
+ formats = arguments[0];
+ time = undefined;
+ }
+ }
+ // We want to compare the start of today, vs this.
+ // Getting start-of-today depends on whether we're local/utc/offset or not.
+ var now = time || createLocal(),
+ sod = cloneWithOffset(now, this).startOf('day'),
+ format = hooks.calendarFormat(this, sod) || 'sameElse',
+ output =
+ formats &&
+ (isFunction(formats[format])
+ ? formats[format].call(this, now)
+ : formats[format]);
+
+ return this.format(
+ output || this.localeData().calendar(format, this, createLocal(now))
+ );
+ }
+
+ function clone() {
+ return new Moment(this);
+ }
+
+ function isAfter(input, units) {
+ var localInput = isMoment(input) ? input : createLocal(input);
+ if (!(this.isValid() && localInput.isValid())) {
+ return false;
+ }
+ units = normalizeUnits(units) || 'millisecond';
+ if (units === 'millisecond') {
+ return this.valueOf() > localInput.valueOf();
+ } else {
+ return localInput.valueOf() < this.clone().startOf(units).valueOf();
+ }
+ }
+
+ function isBefore(input, units) {
+ var localInput = isMoment(input) ? input : createLocal(input);
+ if (!(this.isValid() && localInput.isValid())) {
+ return false;
+ }
+ units = normalizeUnits(units) || 'millisecond';
+ if (units === 'millisecond') {
+ return this.valueOf() < localInput.valueOf();
+ } else {
+ return this.clone().endOf(units).valueOf() < localInput.valueOf();
+ }
+ }
+
+ function isBetween(from, to, units, inclusivity) {
+ var localFrom = isMoment(from) ? from : createLocal(from),
+ localTo = isMoment(to) ? to : createLocal(to);
+ if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
+ return false;
+ }
+ inclusivity = inclusivity || '()';
+ return (
+ (inclusivity[0] === '('
+ ? this.isAfter(localFrom, units)
+ : !this.isBefore(localFrom, units)) &&
+ (inclusivity[1] === ')'
+ ? this.isBefore(localTo, units)
+ : !this.isAfter(localTo, units))
+ );
+ }
+
+ function isSame(input, units) {
+ var localInput = isMoment(input) ? input : createLocal(input),
+ inputMs;
+ if (!(this.isValid() && localInput.isValid())) {
+ return false;
+ }
+ units = normalizeUnits(units) || 'millisecond';
+ if (units === 'millisecond') {
+ return this.valueOf() === localInput.valueOf();
+ } else {
+ inputMs = localInput.valueOf();
+ return (
+ this.clone().startOf(units).valueOf() <= inputMs &&
+ inputMs <= this.clone().endOf(units).valueOf()
+ );
+ }
+ }
+
+ function isSameOrAfter(input, units) {
+ return this.isSame(input, units) || this.isAfter(input, units);
+ }
+
+ function isSameOrBefore(input, units) {
+ return this.isSame(input, units) || this.isBefore(input, units);
+ }
+
+ function diff(input, units, asFloat) {
+ var that, zoneDelta, output;
+
+ if (!this.isValid()) {
+ return NaN;
+ }
+
+ that = cloneWithOffset(input, this);
+
+ if (!that.isValid()) {
+ return NaN;
+ }
+
+ zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
+
+ units = normalizeUnits(units);
+
+ switch (units) {
+ case 'year':
+ output = monthDiff(this, that) / 12;
+ break;
+ case 'month':
+ output = monthDiff(this, that);
+ break;
+ case 'quarter':
+ output = monthDiff(this, that) / 3;
+ break;
+ case 'second':
+ output = (this - that) / 1e3;
+ break; // 1000
+ case 'minute':
+ output = (this - that) / 6e4;
+ break; // 1000 * 60
+ case 'hour':
+ output = (this - that) / 36e5;
+ break; // 1000 * 60 * 60
+ case 'day':
+ output = (this - that - zoneDelta) / 864e5;
+ break; // 1000 * 60 * 60 * 24, negate dst
+ case 'week':
+ output = (this - that - zoneDelta) / 6048e5;
+ break; // 1000 * 60 * 60 * 24 * 7, negate dst
+ default:
+ output = this - that;
+ }
+
+ return asFloat ? output : absFloor(output);
+ }
+
+ function monthDiff(a, b) {
+ if (a.date() < b.date()) {
+ // end-of-month calculations work correct when the start month has more
+ // days than the end month.
+ return -monthDiff(b, a);
+ }
+ // difference in months
+ var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()),
+ // b is in (anchor - 1 month, anchor + 1 month)
+ anchor = a.clone().add(wholeMonthDiff, 'months'),
+ anchor2,
+ adjust;
+
+ if (b - anchor < 0) {
+ anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
+ // linear across the month
+ adjust = (b - anchor) / (anchor - anchor2);
+ } else {
+ anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
+ // linear across the month
+ adjust = (b - anchor) / (anchor2 - anchor);
+ }
+
+ //check for negative zero, return zero if negative zero
+ return -(wholeMonthDiff + adjust) || 0;
+ }
+
+ hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
+ hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
+
+ function toString() {
+ return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
+ }
+
+ function toISOString(keepOffset) {
+ if (!this.isValid()) {
+ return null;
+ }
+ var utc = keepOffset !== true,
+ m = utc ? this.clone().utc() : this;
+ if (m.year() < 0 || m.year() > 9999) {
+ return formatMoment(
+ m,
+ utc
+ ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'
+ : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ'
+ );
+ }
+ if (isFunction(Date.prototype.toISOString)) {
+ // native implementation is ~50x faster, use it when we can
+ if (utc) {
+ return this.toDate().toISOString();
+ } else {
+ return new Date(this.valueOf() + this.utcOffset() * 60 * 1000)
+ .toISOString()
+ .replace('Z', formatMoment(m, 'Z'));
+ }
+ }
+ return formatMoment(
+ m,
+ utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ'
+ );
+ }
+
+ /**
+ * Return a human readable representation of a moment that can
+ * also be evaluated to get a new moment which is the same
+ *
+ * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
+ */
+ function inspect() {
+ if (!this.isValid()) {
+ return 'moment.invalid(/* ' + this._i + ' */)';
+ }
+ var func = 'moment',
+ zone = '',
+ prefix,
+ year,
+ datetime,
+ suffix;
+ if (!this.isLocal()) {
+ func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
+ zone = 'Z';
+ }
+ prefix = '[' + func + '("]';
+ year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY';
+ datetime = '-MM-DD[T]HH:mm:ss.SSS';
+ suffix = zone + '[")]';
+
+ return this.format(prefix + year + datetime + suffix);
+ }
+
+ function format(inputString) {
+ if (!inputString) {
+ inputString = this.isUtc()
+ ? hooks.defaultFormatUtc
+ : hooks.defaultFormat;
+ }
+ var output = formatMoment(this, inputString);
+ return this.localeData().postformat(output);
+ }
+
+ function from(time, withoutSuffix) {
+ if (
+ this.isValid() &&
+ ((isMoment(time) && time.isValid()) || createLocal(time).isValid())
+ ) {
+ return createDuration({ to: this, from: time })
+ .locale(this.locale())
+ .humanize(!withoutSuffix);
+ } else {
+ return this.localeData().invalidDate();
+ }
+ }
+
+ function fromNow(withoutSuffix) {
+ return this.from(createLocal(), withoutSuffix);
+ }
+
+ function to(time, withoutSuffix) {
+ if (
+ this.isValid() &&
+ ((isMoment(time) && time.isValid()) || createLocal(time).isValid())
+ ) {
+ return createDuration({ from: this, to: time })
+ .locale(this.locale())
+ .humanize(!withoutSuffix);
+ } else {
+ return this.localeData().invalidDate();
+ }
+ }
+
+ function toNow(withoutSuffix) {
+ return this.to(createLocal(), withoutSuffix);
+ }
+
+ // If passed a locale key, it will set the locale for this
+ // instance. Otherwise, it will return the locale configuration
+ // variables for this instance.
+ function locale(key) {
+ var newLocaleData;
+
+ if (key === undefined) {
+ return this._locale._abbr;
+ } else {
+ newLocaleData = getLocale(key);
+ if (newLocaleData != null) {
+ this._locale = newLocaleData;
+ }
+ return this;
+ }
+ }
+
+ var lang = deprecate(
+ 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
+ function (key) {
+ if (key === undefined) {
+ return this.localeData();
+ } else {
+ return this.locale(key);
+ }
+ }
+ );
+
+ function localeData() {
+ return this._locale;
+ }
+
+ var MS_PER_SECOND = 1000,
+ MS_PER_MINUTE = 60 * MS_PER_SECOND,
+ MS_PER_HOUR = 60 * MS_PER_MINUTE,
+ MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
+
+ // actual modulo - handles negative numbers (for dates before 1970):
+ function mod$1(dividend, divisor) {
+ return ((dividend % divisor) + divisor) % divisor;
+ }
+
+ function localStartOfDate(y, m, d) {
+ // the date constructor remaps years 0-99 to 1900-1999
+ if (y < 100 && y >= 0) {
+ // preserve leap years using a full 400 year cycle, then reset
+ return new Date(y + 400, m, d) - MS_PER_400_YEARS;
+ } else {
+ return new Date(y, m, d).valueOf();
+ }
+ }
+
+ function utcStartOfDate(y, m, d) {
+ // Date.UTC remaps years 0-99 to 1900-1999
+ if (y < 100 && y >= 0) {
+ // preserve leap years using a full 400 year cycle, then reset
+ return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
+ } else {
+ return Date.UTC(y, m, d);
+ }
+ }
+
+ function startOf(units) {
+ var time, startOfDate;
+ units = normalizeUnits(units);
+ if (units === undefined || units === 'millisecond' || !this.isValid()) {
+ return this;
+ }
+
+ startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
+
+ switch (units) {
+ case 'year':
+ time = startOfDate(this.year(), 0, 1);
+ break;
+ case 'quarter':
+ time = startOfDate(
+ this.year(),
+ this.month() - (this.month() % 3),
+ 1
+ );
+ break;
+ case 'month':
+ time = startOfDate(this.year(), this.month(), 1);
+ break;
+ case 'week':
+ time = startOfDate(
+ this.year(),
+ this.month(),
+ this.date() - this.weekday()
+ );
+ break;
+ case 'isoWeek':
+ time = startOfDate(
+ this.year(),
+ this.month(),
+ this.date() - (this.isoWeekday() - 1)
+ );
+ break;
+ case 'day':
+ case 'date':
+ time = startOfDate(this.year(), this.month(), this.date());
+ break;
+ case 'hour':
+ time = this._d.valueOf();
+ time -= mod$1(
+ time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
+ MS_PER_HOUR
+ );
+ break;
+ case 'minute':
+ time = this._d.valueOf();
+ time -= mod$1(time, MS_PER_MINUTE);
+ break;
+ case 'second':
+ time = this._d.valueOf();
+ time -= mod$1(time, MS_PER_SECOND);
+ break;
+ }
+
+ this._d.setTime(time);
+ hooks.updateOffset(this, true);
+ return this;
+ }
+
+ function endOf(units) {
+ var time, startOfDate;
+ units = normalizeUnits(units);
+ if (units === undefined || units === 'millisecond' || !this.isValid()) {
+ return this;
+ }
+
+ startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
+
+ switch (units) {
+ case 'year':
+ time = startOfDate(this.year() + 1, 0, 1) - 1;
+ break;
+ case 'quarter':
+ time =
+ startOfDate(
+ this.year(),
+ this.month() - (this.month() % 3) + 3,
+ 1
+ ) - 1;
+ break;
+ case 'month':
+ time = startOfDate(this.year(), this.month() + 1, 1) - 1;
+ break;
+ case 'week':
+ time =
+ startOfDate(
+ this.year(),
+ this.month(),
+ this.date() - this.weekday() + 7
+ ) - 1;
+ break;
+ case 'isoWeek':
+ time =
+ startOfDate(
+ this.year(),
+ this.month(),
+ this.date() - (this.isoWeekday() - 1) + 7
+ ) - 1;
+ break;
+ case 'day':
+ case 'date':
+ time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
+ break;
+ case 'hour':
+ time = this._d.valueOf();
+ time +=
+ MS_PER_HOUR -
+ mod$1(
+ time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
+ MS_PER_HOUR
+ ) -
+ 1;
+ break;
+ case 'minute':
+ time = this._d.valueOf();
+ time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
+ break;
+ case 'second':
+ time = this._d.valueOf();
+ time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
+ break;
+ }
+
+ this._d.setTime(time);
+ hooks.updateOffset(this, true);
+ return this;
+ }
+
+ function valueOf() {
+ return this._d.valueOf() - (this._offset || 0) * 60000;
+ }
+
+ function unix() {
+ return Math.floor(this.valueOf() / 1000);
+ }
+
+ function toDate() {
+ return new Date(this.valueOf());
+ }
+
+ function toArray() {
+ var m = this;
+ return [
+ m.year(),
+ m.month(),
+ m.date(),
+ m.hour(),
+ m.minute(),
+ m.second(),
+ m.millisecond(),
+ ];
+ }
+
+ function toObject() {
+ var m = this;
+ return {
+ years: m.year(),
+ months: m.month(),
+ date: m.date(),
+ hours: m.hours(),
+ minutes: m.minutes(),
+ seconds: m.seconds(),
+ milliseconds: m.milliseconds(),
+ };
+ }
+
+ function toJSON() {
+ // new Date(NaN).toJSON() === null
+ return this.isValid() ? this.toISOString() : null;
+ }
+
+ function isValid$2() {
+ return isValid(this);
+ }
+
+ function parsingFlags() {
+ return extend({}, getParsingFlags(this));
+ }
+
+ function invalidAt() {
+ return getParsingFlags(this).overflow;
+ }
+
+ function creationData() {
+ return {
+ input: this._i,
+ format: this._f,
+ locale: this._locale,
+ isUTC: this._isUTC,
+ strict: this._strict,
+ };
+ }
+
+ addFormatToken('N', 0, 0, 'eraAbbr');
+ addFormatToken('NN', 0, 0, 'eraAbbr');
+ addFormatToken('NNN', 0, 0, 'eraAbbr');
+ addFormatToken('NNNN', 0, 0, 'eraName');
+ addFormatToken('NNNNN', 0, 0, 'eraNarrow');
+
+ addFormatToken('y', ['y', 1], 'yo', 'eraYear');
+ addFormatToken('y', ['yy', 2], 0, 'eraYear');
+ addFormatToken('y', ['yyy', 3], 0, 'eraYear');
+ addFormatToken('y', ['yyyy', 4], 0, 'eraYear');
+
+ addRegexToken('N', matchEraAbbr);
+ addRegexToken('NN', matchEraAbbr);
+ addRegexToken('NNN', matchEraAbbr);
+ addRegexToken('NNNN', matchEraName);
+ addRegexToken('NNNNN', matchEraNarrow);
+
+ addParseToken(['N', 'NN', 'NNN', 'NNNN', 'NNNNN'], function (
+ input,
+ array,
+ config,
+ token
+ ) {
+ var era = config._locale.erasParse(input, token, config._strict);
+ if (era) {
+ getParsingFlags(config).era = era;
+ } else {
+ getParsingFlags(config).invalidEra = input;
+ }
+ });
+
+ addRegexToken('y', matchUnsigned);
+ addRegexToken('yy', matchUnsigned);
+ addRegexToken('yyy', matchUnsigned);
+ addRegexToken('yyyy', matchUnsigned);
+ addRegexToken('yo', matchEraYearOrdinal);
+
+ addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR);
+ addParseToken(['yo'], function (input, array, config, token) {
+ var match;
+ if (config._locale._eraYearOrdinalRegex) {
+ match = input.match(config._locale._eraYearOrdinalRegex);
+ }
+
+ if (config._locale.eraYearOrdinalParse) {
+ array[YEAR] = config._locale.eraYearOrdinalParse(input, match);
+ } else {
+ array[YEAR] = parseInt(input, 10);
+ }
+ });
+
+ function localeEras(m, format) {
+ var i,
+ l,
+ date,
+ eras = this._eras || getLocale('en')._eras;
+ for (i = 0, l = eras.length; i < l; ++i) {
+ switch (typeof eras[i].since) {
+ case 'string':
+ // truncate time
+ date = hooks(eras[i].since).startOf('day');
+ eras[i].since = date.valueOf();
+ break;
+ }
+
+ switch (typeof eras[i].until) {
+ case 'undefined':
+ eras[i].until = +Infinity;
+ break;
+ case 'string':
+ // truncate time
+ date = hooks(eras[i].until).startOf('day').valueOf();
+ eras[i].until = date.valueOf();
+ break;
+ }
+ }
+ return eras;
+ }
+
+ function localeErasParse(eraName, format, strict) {
+ var i,
+ l,
+ eras = this.eras(),
+ name,
+ abbr,
+ narrow;
+ eraName = eraName.toUpperCase();
+
+ for (i = 0, l = eras.length; i < l; ++i) {
+ name = eras[i].name.toUpperCase();
+ abbr = eras[i].abbr.toUpperCase();
+ narrow = eras[i].narrow.toUpperCase();
+
+ if (strict) {
+ switch (format) {
+ case 'N':
+ case 'NN':
+ case 'NNN':
+ if (abbr === eraName) {
+ return eras[i];
+ }
+ break;
+
+ case 'NNNN':
+ if (name === eraName) {
+ return eras[i];
+ }
+ break;
+
+ case 'NNNNN':
+ if (narrow === eraName) {
+ return eras[i];
+ }
+ break;
+ }
+ } else if ([name, abbr, narrow].indexOf(eraName) >= 0) {
+ return eras[i];
+ }
+ }
+ }
+
+ function localeErasConvertYear(era, year) {
+ var dir = era.since <= era.until ? +1 : -1;
+ if (year === undefined) {
+ return hooks(era.since).year();
+ } else {
+ return hooks(era.since).year() + (year - era.offset) * dir;
+ }
+ }
+
+ function getEraName() {
+ var i,
+ l,
+ val,
+ eras = this.localeData().eras();
+ for (i = 0, l = eras.length; i < l; ++i) {
+ // truncate time
+ val = this.clone().startOf('day').valueOf();
+
+ if (eras[i].since <= val && val <= eras[i].until) {
+ return eras[i].name;
+ }
+ if (eras[i].until <= val && val <= eras[i].since) {
+ return eras[i].name;
+ }
+ }
+
+ return '';
+ }
+
+ function getEraNarrow() {
+ var i,
+ l,
+ val,
+ eras = this.localeData().eras();
+ for (i = 0, l = eras.length; i < l; ++i) {
+ // truncate time
+ val = this.clone().startOf('day').valueOf();
+
+ if (eras[i].since <= val && val <= eras[i].until) {
+ return eras[i].narrow;
+ }
+ if (eras[i].until <= val && val <= eras[i].since) {
+ return eras[i].narrow;
+ }
+ }
+
+ return '';
+ }
+
+ function getEraAbbr() {
+ var i,
+ l,
+ val,
+ eras = this.localeData().eras();
+ for (i = 0, l = eras.length; i < l; ++i) {
+ // truncate time
+ val = this.clone().startOf('day').valueOf();
+
+ if (eras[i].since <= val && val <= eras[i].until) {
+ return eras[i].abbr;
+ }
+ if (eras[i].until <= val && val <= eras[i].since) {
+ return eras[i].abbr;
+ }
+ }
+
+ return '';
+ }
+
+ function getEraYear() {
+ var i,
+ l,
+ dir,
+ val,
+ eras = this.localeData().eras();
+ for (i = 0, l = eras.length; i < l; ++i) {
+ dir = eras[i].since <= eras[i].until ? +1 : -1;
+
+ // truncate time
+ val = this.clone().startOf('day').valueOf();
+
+ if (
+ (eras[i].since <= val && val <= eras[i].until) ||
+ (eras[i].until <= val && val <= eras[i].since)
+ ) {
+ return (
+ (this.year() - hooks(eras[i].since).year()) * dir +
+ eras[i].offset
+ );
+ }
+ }
+
+ return this.year();
+ }
+
+ function erasNameRegex(isStrict) {
+ if (!hasOwnProp(this, '_erasNameRegex')) {
+ computeErasParse.call(this);
+ }
+ return isStrict ? this._erasNameRegex : this._erasRegex;
+ }
+
+ function erasAbbrRegex(isStrict) {
+ if (!hasOwnProp(this, '_erasAbbrRegex')) {
+ computeErasParse.call(this);
+ }
+ return isStrict ? this._erasAbbrRegex : this._erasRegex;
+ }
+
+ function erasNarrowRegex(isStrict) {
+ if (!hasOwnProp(this, '_erasNarrowRegex')) {
+ computeErasParse.call(this);
+ }
+ return isStrict ? this._erasNarrowRegex : this._erasRegex;
+ }
+
+ function matchEraAbbr(isStrict, locale) {
+ return locale.erasAbbrRegex(isStrict);
+ }
+
+ function matchEraName(isStrict, locale) {
+ return locale.erasNameRegex(isStrict);
+ }
+
+ function matchEraNarrow(isStrict, locale) {
+ return locale.erasNarrowRegex(isStrict);
+ }
+
+ function matchEraYearOrdinal(isStrict, locale) {
+ return locale._eraYearOrdinalRegex || matchUnsigned;
+ }
+
+ function computeErasParse() {
+ var abbrPieces = [],
+ namePieces = [],
+ narrowPieces = [],
+ mixedPieces = [],
+ i,
+ l,
+ eras = this.eras();
+
+ for (i = 0, l = eras.length; i < l; ++i) {
+ namePieces.push(regexEscape(eras[i].name));
+ abbrPieces.push(regexEscape(eras[i].abbr));
+ narrowPieces.push(regexEscape(eras[i].narrow));
+
+ mixedPieces.push(regexEscape(eras[i].name));
+ mixedPieces.push(regexEscape(eras[i].abbr));
+ mixedPieces.push(regexEscape(eras[i].narrow));
+ }
+
+ this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+ this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i');
+ this._erasAbbrRegex = new RegExp('^(' + abbrPieces.join('|') + ')', 'i');
+ this._erasNarrowRegex = new RegExp(
+ '^(' + narrowPieces.join('|') + ')',
+ 'i'
+ );
+ }
+
+ // FORMATTING
+
+ addFormatToken(0, ['gg', 2], 0, function () {
+ return this.weekYear() % 100;
+ });
+
+ addFormatToken(0, ['GG', 2], 0, function () {
+ return this.isoWeekYear() % 100;
+ });
+
+ function addWeekYearFormatToken(token, getter) {
+ addFormatToken(0, [token, token.length], 0, getter);
+ }
+
+ addWeekYearFormatToken('gggg', 'weekYear');
+ addWeekYearFormatToken('ggggg', 'weekYear');
+ addWeekYearFormatToken('GGGG', 'isoWeekYear');
+ addWeekYearFormatToken('GGGGG', 'isoWeekYear');
+
+ // ALIASES
+
+ addUnitAlias('weekYear', 'gg');
+ addUnitAlias('isoWeekYear', 'GG');
+
+ // PRIORITY
+
+ addUnitPriority('weekYear', 1);
+ addUnitPriority('isoWeekYear', 1);
+
+ // PARSING
+
+ addRegexToken('G', matchSigned);
+ addRegexToken('g', matchSigned);
+ addRegexToken('GG', match1to2, match2);
+ addRegexToken('gg', match1to2, match2);
+ addRegexToken('GGGG', match1to4, match4);
+ addRegexToken('gggg', match1to4, match4);
+ addRegexToken('GGGGG', match1to6, match6);
+ addRegexToken('ggggg', match1to6, match6);
+
+ addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (
+ input,
+ week,
+ config,
+ token
+ ) {
+ week[token.substr(0, 2)] = toInt(input);
+ });
+
+ addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
+ week[token] = hooks.parseTwoDigitYear(input);
+ });
+
+ // MOMENTS
+
+ function getSetWeekYear(input) {
+ return getSetWeekYearHelper.call(
+ this,
+ input,
+ this.week(),
+ this.weekday(),
+ this.localeData()._week.dow,
+ this.localeData()._week.doy
+ );
+ }
+
+ function getSetISOWeekYear(input) {
+ return getSetWeekYearHelper.call(
+ this,
+ input,
+ this.isoWeek(),
+ this.isoWeekday(),
+ 1,
+ 4
+ );
+ }
+
+ function getISOWeeksInYear() {
+ return weeksInYear(this.year(), 1, 4);
+ }
+
+ function getISOWeeksInISOWeekYear() {
+ return weeksInYear(this.isoWeekYear(), 1, 4);
+ }
+
+ function getWeeksInYear() {
+ var weekInfo = this.localeData()._week;
+ return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
+ }
+
+ function getWeeksInWeekYear() {
+ var weekInfo = this.localeData()._week;
+ return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
+ }
+
+ function getSetWeekYearHelper(input, week, weekday, dow, doy) {
+ var weeksTarget;
+ if (input == null) {
+ return weekOfYear(this, dow, doy).year;
+ } else {
+ weeksTarget = weeksInYear(input, dow, doy);
+ if (week > weeksTarget) {
+ week = weeksTarget;
+ }
+ return setWeekAll.call(this, input, week, weekday, dow, doy);
+ }
+ }
+
+ function setWeekAll(weekYear, week, weekday, dow, doy) {
+ var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
+ date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
+
+ this.year(date.getUTCFullYear());
+ this.month(date.getUTCMonth());
+ this.date(date.getUTCDate());
+ return this;
+ }
+
+ // FORMATTING
+
+ addFormatToken('Q', 0, 'Qo', 'quarter');
+
+ // ALIASES
+
+ addUnitAlias('quarter', 'Q');
+
+ // PRIORITY
+
+ addUnitPriority('quarter', 7);
+
+ // PARSING
+
+ addRegexToken('Q', match1);
+ addParseToken('Q', function (input, array) {
+ array[MONTH] = (toInt(input) - 1) * 3;
+ });
+
+ // MOMENTS
+
+ function getSetQuarter(input) {
+ return input == null
+ ? Math.ceil((this.month() + 1) / 3)
+ : this.month((input - 1) * 3 + (this.month() % 3));
+ }
+
+ // FORMATTING
+
+ addFormatToken('D', ['DD', 2], 'Do', 'date');
+
+ // ALIASES
+
+ addUnitAlias('date', 'D');
+
+ // PRIORITY
+ addUnitPriority('date', 9);
+
+ // PARSING
+
+ addRegexToken('D', match1to2);
+ addRegexToken('DD', match1to2, match2);
+ addRegexToken('Do', function (isStrict, locale) {
+ // TODO: Remove "ordinalParse" fallback in next major release.
+ return isStrict
+ ? locale._dayOfMonthOrdinalParse || locale._ordinalParse
+ : locale._dayOfMonthOrdinalParseLenient;
+ });
+
+ addParseToken(['D', 'DD'], DATE);
+ addParseToken('Do', function (input, array) {
+ array[DATE] = toInt(input.match(match1to2)[0]);
+ });
+
+ // MOMENTS
+
+ var getSetDayOfMonth = makeGetSet('Date', true);
+
+ // FORMATTING
+
+ addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
+
+ // ALIASES
+
+ addUnitAlias('dayOfYear', 'DDD');
+
+ // PRIORITY
+ addUnitPriority('dayOfYear', 4);
+
+ // PARSING
+
+ addRegexToken('DDD', match1to3);
+ addRegexToken('DDDD', match3);
+ addParseToken(['DDD', 'DDDD'], function (input, array, config) {
+ config._dayOfYear = toInt(input);
+ });
+
+ // HELPERS
+
+ // MOMENTS
+
+ function getSetDayOfYear(input) {
+ var dayOfYear =
+ Math.round(
+ (this.clone().startOf('day') - this.clone().startOf('year')) / 864e5
+ ) + 1;
+ return input == null ? dayOfYear : this.add(input - dayOfYear, 'd');
+ }
+
+ // FORMATTING
+
+ addFormatToken('m', ['mm', 2], 0, 'minute');
+
+ // ALIASES
+
+ addUnitAlias('minute', 'm');
+
+ // PRIORITY
+
+ addUnitPriority('minute', 14);
+
+ // PARSING
+
+ addRegexToken('m', match1to2);
+ addRegexToken('mm', match1to2, match2);
+ addParseToken(['m', 'mm'], MINUTE);
+
+ // MOMENTS
+
+ var getSetMinute = makeGetSet('Minutes', false);
+
+ // FORMATTING
+
+ addFormatToken('s', ['ss', 2], 0, 'second');
+
+ // ALIASES
+
+ addUnitAlias('second', 's');
+
+ // PRIORITY
+
+ addUnitPriority('second', 15);
+
+ // PARSING
+
+ addRegexToken('s', match1to2);
+ addRegexToken('ss', match1to2, match2);
+ addParseToken(['s', 'ss'], SECOND);
+
+ // MOMENTS
+
+ var getSetSecond = makeGetSet('Seconds', false);
+
+ // FORMATTING
+
+ addFormatToken('S', 0, 0, function () {
+ return ~~(this.millisecond() / 100);
+ });
+
+ addFormatToken(0, ['SS', 2], 0, function () {
+ return ~~(this.millisecond() / 10);
+ });
+
+ addFormatToken(0, ['SSS', 3], 0, 'millisecond');
+ addFormatToken(0, ['SSSS', 4], 0, function () {
+ return this.millisecond() * 10;
+ });
+ addFormatToken(0, ['SSSSS', 5], 0, function () {
+ return this.millisecond() * 100;
+ });
+ addFormatToken(0, ['SSSSSS', 6], 0, function () {
+ return this.millisecond() * 1000;
+ });
+ addFormatToken(0, ['SSSSSSS', 7], 0, function () {
+ return this.millisecond() * 10000;
+ });
+ addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
+ return this.millisecond() * 100000;
+ });
+ addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
+ return this.millisecond() * 1000000;
+ });
+
+ // ALIASES
+
+ addUnitAlias('millisecond', 'ms');
+
+ // PRIORITY
+
+ addUnitPriority('millisecond', 16);
+
+ // PARSING
+
+ addRegexToken('S', match1to3, match1);
+ addRegexToken('SS', match1to3, match2);
+ addRegexToken('SSS', match1to3, match3);
+
+ var token, getSetMillisecond;
+ for (token = 'SSSS'; token.length <= 9; token += 'S') {
+ addRegexToken(token, matchUnsigned);
+ }
+
+ function parseMs(input, array) {
+ array[MILLISECOND] = toInt(('0.' + input) * 1000);
+ }
+
+ for (token = 'S'; token.length <= 9; token += 'S') {
+ addParseToken(token, parseMs);
+ }
+
+ getSetMillisecond = makeGetSet('Milliseconds', false);
+
+ // FORMATTING
+
+ addFormatToken('z', 0, 0, 'zoneAbbr');
+ addFormatToken('zz', 0, 0, 'zoneName');
+
+ // MOMENTS
+
+ function getZoneAbbr() {
+ return this._isUTC ? 'UTC' : '';
+ }
+
+ function getZoneName() {
+ return this._isUTC ? 'Coordinated Universal Time' : '';
+ }
+
+ var proto = Moment.prototype;
+
+ proto.add = add;
+ proto.calendar = calendar$1;
+ proto.clone = clone;
+ proto.diff = diff;
+ proto.endOf = endOf;
+ proto.format = format;
+ proto.from = from;
+ proto.fromNow = fromNow;
+ proto.to = to;
+ proto.toNow = toNow;
+ proto.get = stringGet;
+ proto.invalidAt = invalidAt;
+ proto.isAfter = isAfter;
+ proto.isBefore = isBefore;
+ proto.isBetween = isBetween;
+ proto.isSame = isSame;
+ proto.isSameOrAfter = isSameOrAfter;
+ proto.isSameOrBefore = isSameOrBefore;
+ proto.isValid = isValid$2;
+ proto.lang = lang;
+ proto.locale = locale;
+ proto.localeData = localeData;
+ proto.max = prototypeMax;
+ proto.min = prototypeMin;
+ proto.parsingFlags = parsingFlags;
+ proto.set = stringSet;
+ proto.startOf = startOf;
+ proto.subtract = subtract;
+ proto.toArray = toArray;
+ proto.toObject = toObject;
+ proto.toDate = toDate;
+ proto.toISOString = toISOString;
+ proto.inspect = inspect;
+ if (typeof Symbol !== 'undefined' && Symbol.for != null) {
+ proto[Symbol.for('nodejs.util.inspect.custom')] = function () {
+ return 'Moment<' + this.format() + '>';
+ };
+ }
+ proto.toJSON = toJSON;
+ proto.toString = toString;
+ proto.unix = unix;
+ proto.valueOf = valueOf;
+ proto.creationData = creationData;
+ proto.eraName = getEraName;
+ proto.eraNarrow = getEraNarrow;
+ proto.eraAbbr = getEraAbbr;
+ proto.eraYear = getEraYear;
+ proto.year = getSetYear;
+ proto.isLeapYear = getIsLeapYear;
+ proto.weekYear = getSetWeekYear;
+ proto.isoWeekYear = getSetISOWeekYear;
+ proto.quarter = proto.quarters = getSetQuarter;
+ proto.month = getSetMonth;
+ proto.daysInMonth = getDaysInMonth;
+ proto.week = proto.weeks = getSetWeek;
+ proto.isoWeek = proto.isoWeeks = getSetISOWeek;
+ proto.weeksInYear = getWeeksInYear;
+ proto.weeksInWeekYear = getWeeksInWeekYear;
+ proto.isoWeeksInYear = getISOWeeksInYear;
+ proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
+ proto.date = getSetDayOfMonth;
+ proto.day = proto.days = getSetDayOfWeek;
+ proto.weekday = getSetLocaleDayOfWeek;
+ proto.isoWeekday = getSetISODayOfWeek;
+ proto.dayOfYear = getSetDayOfYear;
+ proto.hour = proto.hours = getSetHour;
+ proto.minute = proto.minutes = getSetMinute;
+ proto.second = proto.seconds = getSetSecond;
+ proto.millisecond = proto.milliseconds = getSetMillisecond;
+ proto.utcOffset = getSetOffset;
+ proto.utc = setOffsetToUTC;
+ proto.local = setOffsetToLocal;
+ proto.parseZone = setOffsetToParsedOffset;
+ proto.hasAlignedHourOffset = hasAlignedHourOffset;
+ proto.isDST = isDaylightSavingTime;
+ proto.isLocal = isLocal;
+ proto.isUtcOffset = isUtcOffset;
+ proto.isUtc = isUtc;
+ proto.isUTC = isUtc;
+ proto.zoneAbbr = getZoneAbbr;
+ proto.zoneName = getZoneName;
+ proto.dates = deprecate(
+ 'dates accessor is deprecated. Use date instead.',
+ getSetDayOfMonth
+ );
+ proto.months = deprecate(
+ 'months accessor is deprecated. Use month instead',
+ getSetMonth
+ );
+ proto.years = deprecate(
+ 'years accessor is deprecated. Use year instead',
+ getSetYear
+ );
+ proto.zone = deprecate(
+ 'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',
+ getSetZone
+ );
+ proto.isDSTShifted = deprecate(
+ 'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',
+ isDaylightSavingTimeShifted
+ );
+
+ function createUnix(input) {
+ return createLocal(input * 1000);
+ }
+
+ function createInZone() {
+ return createLocal.apply(null, arguments).parseZone();
+ }
+
+ function preParsePostFormat(string) {
+ return string;
+ }
+
+ var proto$1 = Locale.prototype;
+
+ proto$1.calendar = calendar;
+ proto$1.longDateFormat = longDateFormat;
+ proto$1.invalidDate = invalidDate;
+ proto$1.ordinal = ordinal;
+ proto$1.preparse = preParsePostFormat;
+ proto$1.postformat = preParsePostFormat;
+ proto$1.relativeTime = relativeTime;
+ proto$1.pastFuture = pastFuture;
+ proto$1.set = set;
+ proto$1.eras = localeEras;
+ proto$1.erasParse = localeErasParse;
+ proto$1.erasConvertYear = localeErasConvertYear;
+ proto$1.erasAbbrRegex = erasAbbrRegex;
+ proto$1.erasNameRegex = erasNameRegex;
+ proto$1.erasNarrowRegex = erasNarrowRegex;
+
+ proto$1.months = localeMonths;
+ proto$1.monthsShort = localeMonthsShort;
+ proto$1.monthsParse = localeMonthsParse;
+ proto$1.monthsRegex = monthsRegex;
+ proto$1.monthsShortRegex = monthsShortRegex;
+ proto$1.week = localeWeek;
+ proto$1.firstDayOfYear = localeFirstDayOfYear;
+ proto$1.firstDayOfWeek = localeFirstDayOfWeek;
+
+ proto$1.weekdays = localeWeekdays;
+ proto$1.weekdaysMin = localeWeekdaysMin;
+ proto$1.weekdaysShort = localeWeekdaysShort;
+ proto$1.weekdaysParse = localeWeekdaysParse;
+
+ proto$1.weekdaysRegex = weekdaysRegex;
+ proto$1.weekdaysShortRegex = weekdaysShortRegex;
+ proto$1.weekdaysMinRegex = weekdaysMinRegex;
+
+ proto$1.isPM = localeIsPM;
+ proto$1.meridiem = localeMeridiem;
+
+ function get$1(format, index, field, setter) {
+ var locale = getLocale(),
+ utc = createUTC().set(setter, index);
+ return locale[field](utc, format);
+ }
+
+ function listMonthsImpl(format, index, field) {
+ if (isNumber(format)) {
+ index = format;
+ format = undefined;
+ }
+
+ format = format || '';
+
+ if (index != null) {
+ return get$1(format, index, field, 'month');
+ }
+
+ var i,
+ out = [];
+ for (i = 0; i < 12; i++) {
+ out[i] = get$1(format, i, field, 'month');
+ }
+ return out;
+ }
+
+ // ()
+ // (5)
+ // (fmt, 5)
+ // (fmt)
+ // (true)
+ // (true, 5)
+ // (true, fmt, 5)
+ // (true, fmt)
+ function listWeekdaysImpl(localeSorted, format, index, field) {
+ if (typeof localeSorted === 'boolean') {
+ if (isNumber(format)) {
+ index = format;
+ format = undefined;
+ }
+
+ format = format || '';
+ } else {
+ format = localeSorted;
+ index = format;
+ localeSorted = false;
+
+ if (isNumber(format)) {
+ index = format;
+ format = undefined;
+ }
+
+ format = format || '';
+ }
+
+ var locale = getLocale(),
+ shift = localeSorted ? locale._week.dow : 0,
+ i,
+ out = [];
+
+ if (index != null) {
+ return get$1(format, (index + shift) % 7, field, 'day');
+ }
+
+ for (i = 0; i < 7; i++) {
+ out[i] = get$1(format, (i + shift) % 7, field, 'day');
+ }
+ return out;
+ }
+
+ function listMonths(format, index) {
+ return listMonthsImpl(format, index, 'months');
+ }
+
+ function listMonthsShort(format, index) {
+ return listMonthsImpl(format, index, 'monthsShort');
+ }
+
+ function listWeekdays(localeSorted, format, index) {
+ return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
+ }
+
+ function listWeekdaysShort(localeSorted, format, index) {
+ return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
+ }
+
+ function listWeekdaysMin(localeSorted, format, index) {
+ return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
+ }
+
+ getSetGlobalLocale('en', {
+ eras: [
+ {
+ since: '0001-01-01',
+ until: +Infinity,
+ offset: 1,
+ name: 'Anno Domini',
+ narrow: 'AD',
+ abbr: 'AD',
+ },
+ {
+ since: '0000-12-31',
+ until: -Infinity,
+ offset: 1,
+ name: 'Before Christ',
+ narrow: 'BC',
+ abbr: 'BC',
+ },
+ ],
+ dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+ ordinal: function (number) {
+ var b = number % 10,
+ output =
+ toInt((number % 100) / 10) === 1
+ ? 'th'
+ : b === 1
+ ? 'st'
+ : b === 2
+ ? 'nd'
+ : b === 3
+ ? 'rd'
+ : 'th';
+ return number + output;
+ },
+ });
+
+ // Side effect imports
+
+ hooks.lang = deprecate(
+ 'moment.lang is deprecated. Use moment.locale instead.',
+ getSetGlobalLocale
+ );
+ hooks.langData = deprecate(
+ 'moment.langData is deprecated. Use moment.localeData instead.',
+ getLocale
+ );
+
+ var mathAbs = Math.abs;
+
+ function abs() {
+ var data = this._data;
+
+ this._milliseconds = mathAbs(this._milliseconds);
+ this._days = mathAbs(this._days);
+ this._months = mathAbs(this._months);
+
+ data.milliseconds = mathAbs(data.milliseconds);
+ data.seconds = mathAbs(data.seconds);
+ data.minutes = mathAbs(data.minutes);
+ data.hours = mathAbs(data.hours);
+ data.months = mathAbs(data.months);
+ data.years = mathAbs(data.years);
+
+ return this;
+ }
+
+ function addSubtract$1(duration, input, value, direction) {
+ var other = createDuration(input, value);
+
+ duration._milliseconds += direction * other._milliseconds;
+ duration._days += direction * other._days;
+ duration._months += direction * other._months;
+
+ return duration._bubble();
+ }
+
+ // supports only 2.0-style add(1, 's') or add(duration)
+ function add$1(input, value) {
+ return addSubtract$1(this, input, value, 1);
+ }
+
+ // supports only 2.0-style subtract(1, 's') or subtract(duration)
+ function subtract$1(input, value) {
+ return addSubtract$1(this, input, value, -1);
+ }
+
+ function absCeil(number) {
+ if (number < 0) {
+ return Math.floor(number);
+ } else {
+ return Math.ceil(number);
+ }
+ }
+
+ function bubble() {
+ var milliseconds = this._milliseconds,
+ days = this._days,
+ months = this._months,
+ data = this._data,
+ seconds,
+ minutes,
+ hours,
+ years,
+ monthsFromDays;
+
+ // if we have a mix of positive and negative values, bubble down first
+ // check: https://github.com/moment/moment/issues/2166
+ if (
+ !(
+ (milliseconds >= 0 && days >= 0 && months >= 0) ||
+ (milliseconds <= 0 && days <= 0 && months <= 0)
+ )
+ ) {
+ milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
+ days = 0;
+ months = 0;
+ }
+
+ // The following code bubbles up values, see the tests for
+ // examples of what that means.
+ data.milliseconds = milliseconds % 1000;
+
+ seconds = absFloor(milliseconds / 1000);
+ data.seconds = seconds % 60;
+
+ minutes = absFloor(seconds / 60);
+ data.minutes = minutes % 60;
+
+ hours = absFloor(minutes / 60);
+ data.hours = hours % 24;
+
+ days += absFloor(hours / 24);
+
+ // convert days to months
+ monthsFromDays = absFloor(daysToMonths(days));
+ months += monthsFromDays;
+ days -= absCeil(monthsToDays(monthsFromDays));
+
+ // 12 months -> 1 year
+ years = absFloor(months / 12);
+ months %= 12;
+
+ data.days = days;
+ data.months = months;
+ data.years = years;
+
+ return this;
+ }
+
+ function daysToMonths(days) {
+ // 400 years have 146097 days (taking into account leap year rules)
+ // 400 years have 12 months === 4800
+ return (days * 4800) / 146097;
+ }
+
+ function monthsToDays(months) {
+ // the reverse of daysToMonths
+ return (months * 146097) / 4800;
+ }
+
+ function as(units) {
+ if (!this.isValid()) {
+ return NaN;
+ }
+ var days,
+ months,
+ milliseconds = this._milliseconds;
+
+ units = normalizeUnits(units);
+
+ if (units === 'month' || units === 'quarter' || units === 'year') {
+ days = this._days + milliseconds / 864e5;
+ months = this._months + daysToMonths(days);
+ switch (units) {
+ case 'month':
+ return months;
+ case 'quarter':
+ return months / 3;
+ case 'year':
+ return months / 12;
+ }
+ } else {
+ // handle milliseconds separately because of floating point math errors (issue #1867)
+ days = this._days + Math.round(monthsToDays(this._months));
+ switch (units) {
+ case 'week':
+ return days / 7 + milliseconds / 6048e5;
+ case 'day':
+ return days + milliseconds / 864e5;
+ case 'hour':
+ return days * 24 + milliseconds / 36e5;
+ case 'minute':
+ return days * 1440 + milliseconds / 6e4;
+ case 'second':
+ return days * 86400 + milliseconds / 1000;
+ // Math.floor prevents floating point math errors here
+ case 'millisecond':
+ return Math.floor(days * 864e5) + milliseconds;
+ default:
+ throw new Error('Unknown unit ' + units);
+ }
+ }
+ }
+
+ // TODO: Use this.as('ms')?
+ function valueOf$1() {
+ if (!this.isValid()) {
+ return NaN;
+ }
+ return (
+ this._milliseconds +
+ this._days * 864e5 +
+ (this._months % 12) * 2592e6 +
+ toInt(this._months / 12) * 31536e6
+ );
+ }
+
+ function makeAs(alias) {
+ return function () {
+ return this.as(alias);
+ };
+ }
+
+ var asMilliseconds = makeAs('ms'),
+ asSeconds = makeAs('s'),
+ asMinutes = makeAs('m'),
+ asHours = makeAs('h'),
+ asDays = makeAs('d'),
+ asWeeks = makeAs('w'),
+ asMonths = makeAs('M'),
+ asQuarters = makeAs('Q'),
+ asYears = makeAs('y');
+
+ function clone$1() {
+ return createDuration(this);
+ }
+
+ function get$2(units) {
+ units = normalizeUnits(units);
+ return this.isValid() ? this[units + 's']() : NaN;
+ }
+
+ function makeGetter(name) {
+ return function () {
+ return this.isValid() ? this._data[name] : NaN;
+ };
+ }
+
+ var milliseconds = makeGetter('milliseconds'),
+ seconds = makeGetter('seconds'),
+ minutes = makeGetter('minutes'),
+ hours = makeGetter('hours'),
+ days = makeGetter('days'),
+ months = makeGetter('months'),
+ years = makeGetter('years');
+
+ function weeks() {
+ return absFloor(this.days() / 7);
+ }
+
+ var round = Math.round,
+ thresholds = {
+ ss: 44, // a few seconds to seconds
+ s: 45, // seconds to minute
+ m: 45, // minutes to hour
+ h: 22, // hours to day
+ d: 26, // days to month/week
+ w: null, // weeks to month
+ M: 11, // months to year
+ };
+
+ // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
+ function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
+ return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
+ }
+
+ function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) {
+ var duration = createDuration(posNegDuration).abs(),
+ seconds = round(duration.as('s')),
+ minutes = round(duration.as('m')),
+ hours = round(duration.as('h')),
+ days = round(duration.as('d')),
+ months = round(duration.as('M')),
+ weeks = round(duration.as('w')),
+ years = round(duration.as('y')),
+ a =
+ (seconds <= thresholds.ss && ['s', seconds]) ||
+ (seconds < thresholds.s && ['ss', seconds]) ||
+ (minutes <= 1 && ['m']) ||
+ (minutes < thresholds.m && ['mm', minutes]) ||
+ (hours <= 1 && ['h']) ||
+ (hours < thresholds.h && ['hh', hours]) ||
+ (days <= 1 && ['d']) ||
+ (days < thresholds.d && ['dd', days]);
+
+ if (thresholds.w != null) {
+ a =
+ a ||
+ (weeks <= 1 && ['w']) ||
+ (weeks < thresholds.w && ['ww', weeks]);
+ }
+ a = a ||
+ (months <= 1 && ['M']) ||
+ (months < thresholds.M && ['MM', months]) ||
+ (years <= 1 && ['y']) || ['yy', years];
+
+ a[2] = withoutSuffix;
+ a[3] = +posNegDuration > 0;
+ a[4] = locale;
+ return substituteTimeAgo.apply(null, a);
+ }
+
+ // This function allows you to set the rounding function for relative time strings
+ function getSetRelativeTimeRounding(roundingFunction) {
+ if (roundingFunction === undefined) {
+ return round;
+ }
+ if (typeof roundingFunction === 'function') {
+ round = roundingFunction;
+ return true;
+ }
+ return false;
+ }
+
+ // This function allows you to set a threshold for relative time strings
+ function getSetRelativeTimeThreshold(threshold, limit) {
+ if (thresholds[threshold] === undefined) {
+ return false;
+ }
+ if (limit === undefined) {
+ return thresholds[threshold];
+ }
+ thresholds[threshold] = limit;
+ if (threshold === 's') {
+ thresholds.ss = limit - 1;
+ }
+ return true;
+ }
+
+ function humanize(argWithSuffix, argThresholds) {
+ if (!this.isValid()) {
+ return this.localeData().invalidDate();
+ }
+
+ var withSuffix = false,
+ th = thresholds,
+ locale,
+ output;
+
+ if (typeof argWithSuffix === 'object') {
+ argThresholds = argWithSuffix;
+ argWithSuffix = false;
+ }
+ if (typeof argWithSuffix === 'boolean') {
+ withSuffix = argWithSuffix;
+ }
+ if (typeof argThresholds === 'object') {
+ th = Object.assign({}, thresholds, argThresholds);
+ if (argThresholds.s != null && argThresholds.ss == null) {
+ th.ss = argThresholds.s - 1;
+ }
+ }
+
+ locale = this.localeData();
+ output = relativeTime$1(this, !withSuffix, th, locale);
+
+ if (withSuffix) {
+ output = locale.pastFuture(+this, output);
+ }
+
+ return locale.postformat(output);
+ }
+
+ var abs$1 = Math.abs;
+
+ function sign(x) {
+ return (x > 0) - (x < 0) || +x;
+ }
+
+ function toISOString$1() {
+ // for ISO strings we do not use the normal bubbling rules:
+ // * milliseconds bubble up until they become hours
+ // * days do not bubble at all
+ // * months bubble up until they become years
+ // This is because there is no context-free conversion between hours and days
+ // (think of clock changes)
+ // and also not between days and months (28-31 days per month)
+ if (!this.isValid()) {
+ return this.localeData().invalidDate();
+ }
+
+ var seconds = abs$1(this._milliseconds) / 1000,
+ days = abs$1(this._days),
+ months = abs$1(this._months),
+ minutes,
+ hours,
+ years,
+ s,
+ total = this.asSeconds(),
+ totalSign,
+ ymSign,
+ daysSign,
+ hmsSign;
+
+ if (!total) {
+ // this is the same as C#'s (Noda) and python (isodate)...
+ // but not other JS (goog.date)
+ return 'P0D';
+ }
+
+ // 3600 seconds -> 60 minutes -> 1 hour
+ minutes = absFloor(seconds / 60);
+ hours = absFloor(minutes / 60);
+ seconds %= 60;
+ minutes %= 60;
+
+ // 12 months -> 1 year
+ years = absFloor(months / 12);
+ months %= 12;
+
+ // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
+ s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
+
+ totalSign = total < 0 ? '-' : '';
+ ymSign = sign(this._months) !== sign(total) ? '-' : '';
+ daysSign = sign(this._days) !== sign(total) ? '-' : '';
+ hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
+
+ return (
+ totalSign +
+ 'P' +
+ (years ? ymSign + years + 'Y' : '') +
+ (months ? ymSign + months + 'M' : '') +
+ (days ? daysSign + days + 'D' : '') +
+ (hours || minutes || seconds ? 'T' : '') +
+ (hours ? hmsSign + hours + 'H' : '') +
+ (minutes ? hmsSign + minutes + 'M' : '') +
+ (seconds ? hmsSign + s + 'S' : '')
+ );
+ }
+
+ var proto$2 = Duration.prototype;
+
+ proto$2.isValid = isValid$1;
+ proto$2.abs = abs;
+ proto$2.add = add$1;
+ proto$2.subtract = subtract$1;
+ proto$2.as = as;
+ proto$2.asMilliseconds = asMilliseconds;
+ proto$2.asSeconds = asSeconds;
+ proto$2.asMinutes = asMinutes;
+ proto$2.asHours = asHours;
+ proto$2.asDays = asDays;
+ proto$2.asWeeks = asWeeks;
+ proto$2.asMonths = asMonths;
+ proto$2.asQuarters = asQuarters;
+ proto$2.asYears = asYears;
+ proto$2.valueOf = valueOf$1;
+ proto$2._bubble = bubble;
+ proto$2.clone = clone$1;
+ proto$2.get = get$2;
+ proto$2.milliseconds = milliseconds;
+ proto$2.seconds = seconds;
+ proto$2.minutes = minutes;
+ proto$2.hours = hours;
+ proto$2.days = days;
+ proto$2.weeks = weeks;
+ proto$2.months = months;
+ proto$2.years = years;
+ proto$2.humanize = humanize;
+ proto$2.toISOString = toISOString$1;
+ proto$2.toString = toISOString$1;
+ proto$2.toJSON = toISOString$1;
+ proto$2.locale = locale;
+ proto$2.localeData = localeData;
+
+ proto$2.toIsoString = deprecate(
+ 'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',
+ toISOString$1
+ );
+ proto$2.lang = lang;
+
+ // FORMATTING
+
+ addFormatToken('X', 0, 0, 'unix');
+ addFormatToken('x', 0, 0, 'valueOf');
+
+ // PARSING
+
+ addRegexToken('x', matchSigned);
+ addRegexToken('X', matchTimestamp);
+ addParseToken('X', function (input, array, config) {
+ config._d = new Date(parseFloat(input) * 1000);
+ });
+ addParseToken('x', function (input, array, config) {
+ config._d = new Date(toInt(input));
+ });
+
+ //! moment.js
+
+ hooks.version = '2.29.1';
+
+ setHookCallback(createLocal);
+
+ hooks.fn = proto;
+ hooks.min = min;
+ hooks.max = max;
+ hooks.now = now;
+ hooks.utc = createUTC;
+ hooks.unix = createUnix;
+ hooks.months = listMonths;
+ hooks.isDate = isDate;
+ hooks.locale = getSetGlobalLocale;
+ hooks.invalid = createInvalid;
+ hooks.duration = createDuration;
+ hooks.isMoment = isMoment;
+ hooks.weekdays = listWeekdays;
+ hooks.parseZone = createInZone;
+ hooks.localeData = getLocale;
+ hooks.isDuration = isDuration;
+ hooks.monthsShort = listMonthsShort;
+ hooks.weekdaysMin = listWeekdaysMin;
+ hooks.defineLocale = defineLocale;
+ hooks.updateLocale = updateLocale;
+ hooks.locales = listLocales;
+ hooks.weekdaysShort = listWeekdaysShort;
+ hooks.normalizeUnits = normalizeUnits;
+ hooks.relativeTimeRounding = getSetRelativeTimeRounding;
+ hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
+ hooks.calendarFormat = getCalendarFormat;
+ hooks.prototype = proto;
+
+ // currently HTML5 input type only supports 24-hour formats
+ hooks.HTML5_FMT = {
+ DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" />
+ DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" />
+ DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" />
+ DATE: 'YYYY-MM-DD', // <input type="date" />
+ TIME: 'HH:mm', // <input type="time" />
+ TIME_SECONDS: 'HH:mm:ss', // <input type="time" step="1" />
+ TIME_MS: 'HH:mm:ss.SSS', // <input type="time" step="0.001" />
+ WEEK: 'GGGG-[W]WW', // <input type="week" />
+ MONTH: 'YYYY-MM', // <input type="month" />
+ };
+
+ return hooks;
+
+})));
+
+
+/***/ }),
+
+/***/ "./node_modules/ng-csv/build/ng-csv.min.js":
+/*!*************************************************!*\
+ !*** ./node_modules/ng-csv/build/ng-csv.min.js ***!
+ \*************************************************/
+/***/ ((module, exports) => {
+
+/*! ng-csv 10-10-2015 */
+!function(a){angular.module("ngCsv.config",[]).value("ngCsv.config",{debug:!0}).config(["$compileProvider",function(a){angular.isDefined(a.urlSanitizationWhitelist)?a.urlSanitizationWhitelist(/^\s*(https?|ftp|mailto|file|data):/):a.aHrefSanitizationWhitelist(/^\s*(https?|ftp|mailto|file|data):/)}]),angular.module("ngCsv.directives",["ngCsv.services"]),angular.module("ngCsv.services",[]),angular.module("ngCsv",["ngCsv.config","ngCsv.services","ngCsv.directives","ngSanitize"]), true&&module.exports===exports&&(module.exports="ngCsv"),angular.module("ngCsv.services").service("CSV",["$q",function(a){var b="\r\n",c="
\feff",d={"\\t":" ","\\b":"\b","\\v":"
\v","\\f":"\f","\\r":"\r"};this.stringifyField=function(a,b){return"locale"===b.decimalSep&&this.isFloat(a)?a.toLocaleString():"."!==b.decimalSep&&this.isFloat(a)?a.toString().replace(".",b.decimalSep):"string"==typeof a?(a=a.replace(/"/g,'""'),(b.quoteStrings||a.indexOf(",")>-1||a.indexOf("\n")>-1||a.indexOf("\r")>-1)&&(a=b.txtDelim+a+b.txtDelim),a):"boolean"==typeof a?a?"TRUE":"FALSE":a},this.isFloat=function(a){return+a===a&&(!isFinite(a)||Boolean(a%1))},this.stringify=function(d,e){var f=a.defer(),g=this,h="",i="",j=a.when(d).then(function(a){if(angular.isDefined(e.header)&&e.header){var d,j;d=[],angular.forEach(e.header,function(a){this.push(g.stringifyField(a,e))},d),j=d.join(e.fieldSep?e.fieldSep:","),i+=j+b}var k=[];if(angular.isArray(a)?k=a:angular.isFunction(a)&&(k=a()),angular.isDefined(e.label)&&e.label&&"boolean"==typeof e.label){var l,m;l=[],angular.forEach(k[0],function(a,b){this.push(g.stringifyField(b,e))},l),m=l.join(e.fieldSep?e.fieldSep:","),i+=m+b}angular.forEach(k,function(a,c){var d,f,h=angular.copy(k[c]);f=[];var j=e.columnOrder?e.columnOrder:h;angular.forEach(j,function(a){var b=e.columnOrder?h[a]:a;this.push(g.stringifyField(b,e))},f),d=f.join(e.fieldSep?e.fieldSep:","),i+=c<k.length?d+b:d}),e.addByteOrderMarker&&(h+=c),h+=i,f.resolve(h)});return"function"==typeof j["catch"]&&j["catch"](function(a){f.reject(a)}),f.promise},this.isSpecialChar=function(a){return void 0!==d[a]},this.getSpecialChar=function(a){return d[a]}}]),angular.module("ngCsv.directives").directive("ngCsv",["$parse","$q","CSV","$document","$timeout",function(b,c,d,e,f){return{restrict:"AC",scope:{data:"&ngCsv",filename:"@filename",header:"&csvHeader",columnOrder:"&csvColumnOrder",txtDelim:"@textDelimiter",decimalSep:"@decimalSeparator",quoteStrings:"@quoteStrings",fieldSep:"@fieldSeparator",lazyLoad:"@lazyLoad",addByteOrderMarker:"@addBom",ngClick:"&",charset:"@charset",label:"&csvLabel"},controller:["$scope","$element","$attrs","$transclude",function(a,b,e){function f(){var b={txtDelim:a.txtDelim?a.txtDelim:'"',decimalSep:a.decimalSep?a.decimalSep:".",quoteStrings:a.quoteStrings,addByteOrderMarker:a.addByteOrderMarker};return angular.isDefined(e.csvHeader)&&(b.header=a.$eval(a.header)),angular.isDefined(e.csvColumnOrder)&&(b.columnOrder=a.$eval(a.columnOrder)),angular.isDefined(e.csvLabel)&&(b.label=a.$eval(a.label)),b.fieldSep=a.fieldSep?a.fieldSep:",",b.fieldSep=d.isSpecialChar(b.fieldSep)?d.getSpecialChar(b.fieldSep):b.fieldSep,b}a.csv="",angular.isDefined(a.lazyLoad)&&"true"==a.lazyLoad||angular.isArray(a.data)&&a.$watch("data",function(){a.buildCSV()},!0),a.getFilename=function(){return a.filename||"download.csv"},a.buildCSV=function(){var g=c.defer();return b.addClass(e.ngCsvLoadingClass||"ng-csv-loading"),d.stringify(a.data(),f()).then(function(c){a.csv=c,b.removeClass(e.ngCsvLoadingClass||"ng-csv-loading"),g.resolve(c)}),a.$apply(),g.promise}}],link:function(b,c){function d(){var c=b.charset||"utf-8",d=new Blob([b.csv],{type:"text/csv;charset="+c+";"});if(a.navigator.msSaveOrOpenBlob)navigator.msSaveBlob(d,b.getFilename());else{var g=angular.element('<div data-tap-disabled="true"><a></a></div>'),h=angular.element(g.children()[0]);h.attr("href",a.URL.createObjectURL(d)),h.attr("download",b.getFilename()),h.attr("target","_blank"),e.find("body").append(g),f(function(){h[0].click(),h.remove()},null)}}c.bind("click",function(){b.buildCSV().then(function(){d()}),b.$apply()})}}}])}(window,document);
+
+/***/ }),
+
+/***/ "./node_modules/ng-embed/src/ng-embed.js":
+/*!***********************************************!*\
+ !*** ./node_modules/ng-embed/src/ng-embed.js ***!
+ \***********************************************/
+/***/ (() => {
+
+(function () {
+
+ 'use strict';
+
+ angular.module('ngEmbed', ['ngSanitize'])
+ .constant('NG_EMBED_BASIC_EMOTICONS', {
+ ":)" : {text: ":)", 'class': "smiley", code: "e60a"},
+ ":D" : {text: ":D", 'class': "happy", code: "e608"},
+ ":d" : {text: ":d", 'class': "happy", code: "e608"},
+ ":(" : {text: ":(", 'class': "sad", code: "e60e"},
+ ":/" : {text: ":/", 'class': "wondering", code: "e620"},
+ ":P" : {text: ":P", 'class': "tongue", code: "e60c"},
+ ":p" : {text: ":p", 'class': "tongue", code: "e60c"},
+ "3:)" : {text: "3:)", 'class': "evil", code: "e618"},
+ "(^)" : {text: "(^)", 'class': "thumbsup2", code: "e607"},
+ ";)" : {text: ";)", 'class': "wink", code: "e610"},
+ ":o" : {text: ":o", 'class': "shocked", code: "e61a"},
+ "-_-" : {text: "-_-", 'class': "neutral", code: "e61e"},
+ "(y)" : {text: "(y)", 'class': "thumbs-up", code: "e606"},
+ ":*" : {text: ":*", 'class': "heart", code: "e604"},
+ "<3" : {text: "<3", 'class': "heart", code: "e604"},
+ "<3" : {text: "<3", 'class': "heart", code: "e604"},
+ "</3": {text: "</3", 'class': "heart-broken", code: "e605"},
+ "</3" : {text: "</3", 'class': "heart-broken", code: "e605"},
+ "^_^" : {text: "^_^", 'class': "grin", code: "e612"},
+ "8-)" : {text: "8-)", 'class': "cool", code: "e614"},
+ "8|" : {text: "8|", 'class': "cool", code: "e614"},
+ ":S" : {text: ":S", 'class': "confused", code: "e61c"},
+ ":s" : {text: ":s", 'class': "confused", code: "e61c"}
+ })
+ .constant('NG_EMBED_EMOJI_LIST', [
+ "bowtie", "smile", "laughing", "blush", "smiley", "relaxed", "smirk", "heart_eyes", "kissing_heart", "kissing_closed_eyes", "flushed", "relieved", "satisfied", "grin", "wink", "stuck_out_tongue_winking_eye", "stuck_out_tongue_closed_eyes", "grinning", "kissing", "winky_face", "kissing_smiling_eyes", "stuck_out_tongue", "sleeping", "worried", "frowning", "anguished", "open_mouth", "grimacing", "confused", "hushed", "expressionless", "unamused", "sweat_smile", "sweat", "wow", "disappointed_relieved", "weary", "pensive", "disappointed", "confounded", "fearful", "cold_sweat", "persevere", "cry", "sob", "joy", "astonished", "scream", "neckbeard", "tired_face", "angry", "rage", "triumph", "sleepy", "yum", "mask", "sunglasses", "dizzy_face", "imp", "smiling_imp", "neutral_face", "no_mouth", "innocent", "alien", "yellow_heart", "blue_heart", "purple_heart", "heart", "green_heart", "broken_heart", "heartbeat", "heartpulse", "two_hearts", "revolving_hearts", "cupid", "sparkling_heart", "sparkles", "star", "star2", "dizzy", "boom", "collision", "anger", "exclamation", "question", "grey_exclamation", "grey_question", "zzz", "dash", "sweat_drops", "notes", "musical_note", "fire", "hankey", "poop", "shit", "\\+1", "thumbsup", "-1", "thumbsdown", "ok_hand", "punch", "facepunch", "fist", "v", "wave", "hand", "raised_hand", "open_hands", "point_up", "point_down", "point_left", "point_right", "raised_hands", "pray", "point_up_2", "clap", "muscle", "metal", "fu", "walking", "runner", "running", "couple", "family", "two_men_holding_hands", "two_women_holding_hands", "dancer", "dancers", "ok_woman", "no_good", "information_desk_person", "raising_hand", "bride_with_veil", "person_with_pouting_face", "person_frowning", "bow", "couplekiss", "couple_with_heart", "massage", "haircut", "nail_care", "boy", "girl", "woman", "man", "baby", "older_woman", "older_man", "person_with_blond_hair", "man_with_gua_pi_mao", "man_with_turban", "construction_worker", "cop", "angel", "princess", "smiley_cat", "smile_cat", "heart_eyes_cat", "kissing_cat", "smirk_cat", "scream_cat", "crying_cat_face", "joy_cat", "pouting_cat", "japanese_ogre", "japanese_goblin", "see_no_evil", "hear_no_evil", "speak_no_evil", "guardsman", "skull", "feet", "lips", "kiss", "droplet", "ear", "eyes", "nose", "tongue", "love_letter", "bust_in_silhouette", "busts_in_silhouette", "speech_balloon", "thought_balloon", "feelsgood", "finnadie", "goberserk", "godmode", "hurtrealbad", "rage1", "rage2", "rage3", "rage4", "suspect", "trollface", "sunny", "umbrella", "cloud", "snowflake", "snowman", "zap", "cyclone", "foggy", "ocean", "cat", "dog", "mouse", "hamster", "rabbit", "wolf", "frog", "tiger", "koala", "bear", "pig", "pig_nose", "cow", "boar", "monkey_face", "monkey", "horse", "racehorse", "camel", "sheep", "elephant", "panda_face", "snake", "bird", "baby_chick", "hatched_chick", "hatching_chick", "chicken", "penguin", "turtle", "bug", "honeybee", "ant", "beetle", "snail", "octopus", "tropical_fish", "fish", "whale", "whale2", "dolphin", "cow2", "ram", "rat", "water_buffalo", "tiger2", "rabbit2", "dragon", "goat", "rooster", "dog2", "pig2", "mouse2", "ox", "dragon_face", "blowfish", "crocodile", "dromedary_camel", "leopard", "cat2", "poodle", "paw_prints", "bouquet", "cherry_blossom", "tulip", "four_leaf_clover", "rose", "sunflower", "hibiscus", "maple_leaf", "leaves", "fallen_leaf", "herb", "mushroom", "cactus", "palm_tree", "evergreen_tree", "deciduous_tree", "chestnut", "seedling", "blossom", "ear_of_rice", "shell", "globe_with_meridians", "sun_with_face", "full_moon_with_face", "new_moon_with_face", "new_moon", "waxing_crescent_moon", "first_quarter_moon", "waxing_gibbous_moon", "full_moon", "waning_gibbous_moon", "last_quarter_moon", "waning_crescent_moon", "last_quarter_moon_with_face", "first_quarter_moon_with_face", "moon", "earth_africa", "earth_americas", "earth_asia", "volcano", "milky_way", "partly_sunny", "octocat", "squirrel", "bamboo", "gift_heart", "dolls", "school_satchel", "mortar_board", "flags", "fireworks", "sparkler", "wind_chime", "rice_scene", "jack_o_lantern", "ghost", "santa", "christmas_tree", "gift", "bell", "no_bell", "tanabata_tree", "tada", "confetti_ball", "balloon", "crystal_ball", "cd", "dvd", "floppy_disk", "camera", "video_camera", "movie_camera", "computer", "tv", "iphone", "phone", "telephone", "telephone_receiver", "pager", "fax", "minidisc", "vhs", "sound", "speaker", "mute", "loudspeaker", "mega", "hourglass", "hourglass_flowing_sand", "alarm_clock", "watch", "radio", "satellite", "loop", "mag", "mag_right", "unlock", "lock", "lock_with_ink_pen", "closed_lock_with_key", "key", "bulb", "flashlight", "high_brightness", "low_brightness", "electric_plug", "battery", "calling", "email", "mailbox", "postbox", "bath", "bathtub", "shower", "toilet", "wrench", "nut_and_bolt", "hammer", "seat", "moneybag", "yen", "dollar", "pound", "euro", "credit_card", "money_with_wings", "e-mail", "inbox_tray", "outbox_tray", "envelope", "incoming_envelope", "postal_horn", "mailbox_closed", "mailbox_with_mail", "mailbox_with_no_mail", "door", "smoking", "bomb", "gun", "hocho", "pill", "syringe", "page_facing_up", "page_with_curl", "bookmark_tabs", "bar_chart", "chart_with_upwards_trend", "chart_with_downwards_trend", "scroll", "clipboard", "calendar", "date", "card_index", "file_folder", "open_file_folder", "scissors", "pushpin", "paperclip", "black_nib", "pencil2", "straight_ruler", "triangular_ruler", "closed_book", "green_book", "blue_book", "orange_book", "notebook", "notebook_with_decorative_cover", "ledger", "books", "bookmark", "name_badge", "microscope", "telescope", "newspaper", "football", "basketball", "soccer", "baseball", "tennis", "8ball", "rugby_football", "bowling", "golf", "mountain_bicyclist", "bicyclist", "horse_racing", "snowboarder", "swimmer", "surfer", "ski", "spades", "hearts", "clubs", "diamonds", "gem", "ring", "trophy", "musical_score", "musical_keyboard", "violin", "space_invader", "video_game", "black_joker", "flower_playing_cards", "game_die", "dart", "mahjong", "clapper", "memo", "pencil", "book", "art", "microphone", "headphones", "trumpet", "saxophone", "guitar", "shoe", "sandal", "high_heel", "lipstick", "boot", "shirt", "tshirt", "necktie", "womans_clothes", "dress", "running_shirt_with_sash", "jeans", "kimono", "bikini", "ribbon", "tophat", "crown", "womans_hat", "mans_shoe", "closed_umbrella", "briefcase", "handbag", "pouch", "purse", "eyeglasses", "fishing_pole_and_fish", "coffee", "tea", "sake", "baby_bottle", "beer", "beers", "cocktail", "tropical_drink", "wine_glass", "fork_and_knife", "pizza", "hamburger", "fries", "poultry_leg", "meat_on_bone", "spaghetti", "curry", "fried_shrimp", "bento", "sushi", "fish_cake", "rice_ball", "rice_cracker", "rice", "ramen", "stew", "oden", "dango", "egg", "bread", "doughnut", "custard", "icecream", "ice_cream", "shaved_ice", "birthday", "cake", "cookie", "chocolate_bar", "candy", "lollipop", "honey_pot", "apple", "green_apple", "tangerine", "lemon", "cherries", "grapes", "watermelon", "strawberry", "peach", "melon", "banana", "pear", "pineapple", "sweet_potato", "eggplant", "tomato", "corn", "house", "house_with_garden", "school", "office", "post_office", "hospital", "bank", "convenience_store", "love_hotel", "hotel", "wedding", "church", "department_store", "european_post_office", "city_sunrise", "city_sunset", "japanese_castle", "european_castle", "tent", "factory", "tokyo_tower", "japan", "mount_fuji", "sunrise_over_mountains", "sunrise", "stars", "themoreyouknow", "tmyk", "statue_of_liberty", "bridge_at_night", "carousel_horse", "rainbow", "ferris_wheel", "fountain", "roller_coaster", "ship", "speedboat", "boat", "sailboat", "rowboat", "anchor", "rocket", "airplane", "helicopter", "steam_locomotive", "tram", "mountain_railway", "bike", "aerial_tramway", "suspension_railway", "mountain_cableway", "tractor", "blue_car", "oncoming_automobile", "car", "red_car", "taxi", "oncoming_taxi", "articulated_lorry", "bus", "oncoming_bus", "rotating_light", "police_car", "oncoming_police_car", "fire_engine", "ambulance", "minibus", "truck", "train", "station", "train2", "bullettrain_front", "bullettrain_side", "light_rail", "monorail", "railway_car", "trolleybus", "ticket", "fuelpump", "vertical_traffic_light", "traffic_light", "warning", "construction", "beginner", "atm", "slot_machine", "busstop", "barber", "hotsprings", "checkered_flag", "crossed_flags", "izakaya_lantern", "moyai", "circus_tent", "performing_arts", "round_pushpin", "triangular_flag_on_post", "jp", "kr", "cn", "us", "fr", "es", "it", "ru", "gb", "uk", "de", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "keycap_ten", "1234", "zero", "hash", "symbols", "arrow_backward", "arrow_down", "arrow_forward", "arrow_left", "capital_abcd", "abcd", "abc", "arrow_lower_left", "arrow_lower_right", "arrow_right", "arrow_up", "arrow_upper_left", "arrow_upper_right", "arrow_double_down", "arrow_double_up", "arrow_down_small", "arrow_heading_down", "arrow_heading_up", "leftwards_arrow_with_hook", "arrow_right_hook", "left_right_arrow", "arrow_up_down", "arrow_up_small", "arrows_clockwise", "arrows_counterclockwise", "rewind", "fast_forward", "information_source", "ok", "twisted_rightwards_arrows", "repeat", "repeat_one", "new", "top", "up", "cool", "free", "ng", "cinema", "koko", "signal_strength", "u5272", "u5408", "u55b6", "u6307", "u6708", "u6709", "u6e80", "u7121", "u7533", "u7a7a", "u7981", "sa", "restroom", "mens", "womens", "baby_symbol", "no_smoking", "parking", "wheelchair", "metro", "baggage_claim", "accept", "wc", "potable_water", "put_litter_in_its_place", "secret", "congratulations", "m", "passport_control", "left_luggage", "customs", "ideograph_advantage", "cl", "sos", "id", "no_entry_sign", "underage", "no_mobile_phones", "do_not_litter", "non-potable_water", "no_bicycles", "no_pedestrians", "children_crossing", "no_entry", "eight_spoked_asterisk", "eight_pointed_black_star", "heart_decoration", "vs", "vibration_mode", "mobile_phone_off", "chart", "currency_exchange", "aries", "taurus", "gemini", "cancer", "leo", "virgo", "libra", "scorpius", "sagittarius", "capricorn", "aquarius", "pisces", "ophiuchus", "six_pointed_star", "negative_squared_cross_mark", "a", "b", "ab", "o2", "diamond_shape_with_a_dot_inside", "recycle", "end", "on", "soon", "clock1", "clock130", "clock10", "clock1030", "clock11", "clock1130", "clock12", "clock1230", "clock2", "clock230", "clock3", "clock330", "clock4", "clock430", "clock5", "clock530", "clock6", "clock630", "clock7", "clock730", "clock8", "clock830", "clock9", "clock930", "heavy_dollar_sign", "copyright", "registered", "tm", "x", "heavy_exclamation_mark", "bangbang", "interrobang", "o", "heavy_multiplication_x", "heavy_plus_sign", "heavy_minus_sign", "heavy_division_sign", "white_flower", "100", "heavy_check_mark", "ballot_box_with_check", "radio_button", "link", "curly_loop", "wavy_dash", "part_alternation_mark", "trident", "black_square", "white_square", "white_check_mark", "black_square_button", "white_square_button", "black_circle", "white_circle", "red_circle", "large_blue_circle", "large_blue_diamond", "large_orange_diamond", "small_blue_diamond", "small_orange_diamond", "small_red_triangle", "small_red_triangle_down", "shipit"
+ ])
+ .constant('NG_EMBED_REGEXP_PATTERNS', {
+ // url
+ protocol : /^[a-z]+:\/\//i,
+ url : /\b(?:(https?|ftp|file):\/\/|www\.)[-A-Z0-9+()&@$#\/%?=~_|!:,.;]*[-A-Z0-9+&@#\/%=~_|]/gi,
+ // files
+ basicVideo : /((?:https?|ftp|file):\/\/\S*\.(?:ogv|webm|mp4)(\?([\w=&_%\-]*))?)/gi,
+ basicAudio : /((?:https?|ftp|file):\/\/\S*\.(?:wav|mp3|ogg)(\?([\w=&_%\-]*))?)/gi,
+ basicImage : /((?:https?|ftp|file):\/\/\S*\.(?:gif|jpg|jpeg|tiff|png|svg|webp)(\?([\w=&_%\-]*))?)/gi,
+ pdf : /((?:https?|ftp|file):\/\/\S*\.(?:pdf)(\?([\w=&_%\-]*))?)/gi,
+ // audio
+ soundCloud : /soundcloud.com\/[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_]+/gi,
+ spotify : /spotify.com\/track\/[a-zA-Z0-9_]+/gi,
+ // code
+ highlightCode: /(`{3})(\s|[a-z]+)\s*([\s\S]*?[^`])\s*\1(?!`)/gm,
+ codepen : /http:\/\/codepen.io\/([A-Za-z0-9_]+)\/pen\/([A-Za-z0-9_]+)/gi,
+ gist : /gist.github.com\/[a-zA-Z0-9_-]+\/([a-zA-Z0-9]+)/gi,
+ ideone : /ideone.com\/[a-zA-Z0-9]{6}/gi,
+ jsbin : /jsbin.com\/[a-zA-Z0-9_]+\/[0-9_]+/gi,
+ jsfiddle : /jsfiddle.net\/[a-zA-Z0-9_]+\/[a-zA-Z0-9_]+/gi,
+ plunker : /plnkr.co\/edit\/[a-zA-Z0-9?=]+/gi,
+ // video
+ dotsub : /dotsub.com\/view\/[a-zA-Z0-9-]+/gi,
+ dailymotion : /dailymotion.com\/video\/[a-zA-Z0-9-_]+/gi,
+ liveleak : /liveleak.com\/view\?i=[a-zA-Z0-9_]+/gi,
+ ted : /ted.com\/talks\/[a-zA-Z0-9_]+/gi,
+ vimeo : /vimeo.com\/(?:channels\/(?:\w+\/)?|groups\/([^\/]*)\/videos\/|album\/(\d+)\/video\/|)(\d+)(?:$|\/|\?)*/gi,
+ youtube : /(?:[0-9A-Z-]+\.)?(?:youtu\.be\/|youtube\.com(?:\/embed\/|\/v\/|\/watch\?v=|\/ytscreeningroom\?v=|\/feeds\/api\/videos\/|\/user\S*[^\w\-\s]|\S*[^\w\-\s]))([\w\-]{11})[?=&+%\w-]*/gi,
+ twitchtv : /twitch.tv\/[a-zA_Z0-9_]+/gi,
+ ustream : /ustream.tv\/[a-z\/0-9]*/gi,
+ // social media
+ twitter : /https:\/\/twitter\.com\/\w+\/\w+\/\d+/gi
+ })
+ .constant('NG_EMBED_FILTER_DEFAULT_OPTIONS', {
+ sanitizeHtml: true,
+ fontSmiley: true,
+ emoji: true,
+ link: true,
+ linkTarget: '_self'
+ })
+ .constant('NG_EMBED_DEFAULT_OPTIONS', {
+ watchEmbedData : false,
+ sanitizeHtml : true,
+ fontSmiley : true,
+ emoji : true,
+ link : true,
+ linkTarget : '_self',
+ pdf : {
+ embed: true
+ },
+ image : {
+ embed: false
+ },
+ audio : {
+ embed: true
+ },
+ code : {
+ highlight : true,
+ lineNumbers: false
+ },
+ basicVideo : false,
+ gdevAuth:null,
+ video : {
+ embed : false,
+ width : null,
+ height : null,
+ ytTheme : 'dark',
+ details : false,
+ thumbnailQuality: 'medium'
+ },
+ tweetEmbed : true,
+ tweetOptions : {
+ //The maximum width of a rendered Tweet in whole pixels. Must be between 220 and 550 inclusive.
+ maxWidth : 550,
+ //When set to true or 1 links in a Tweet are not expanded to photo, video, or link previews.
+ hideMedia : false,
+ //When set to true or 1 a collapsed version of the previous Tweet in a conversation thread
+ //will not be displayed when the requested Tweet is in reply to another Tweet.
+ hideThread: false,
+ //Specifies whether the embedded Tweet should be floated left, right, or center in
+ //the page relative to the parent element.Valid values are left, right, center, and none.
+ //Defaults to none, meaning no alignment styles are specified for the Tweet.
+ align : 'none',
+ //Request returned HTML and a rendered Tweet in the specified.
+ //Supported Languages listed here (https://dev.twitter.com/web/overview/languages)
+ lang : 'en'
+ },
+ twitchtvEmbed : true,
+ dailymotionEmbed : true,
+ tedEmbed : true,
+ dotsubEmbed : true,
+ liveleakEmbed : true,
+ ustreamEmbed : true,
+ soundCloudEmbed : true,
+ soundCloudOptions: {
+ height : 160, themeColor: 'f50000', //Hex Code of the player theme color
+ autoPlay : false,
+ hideRelated : false,
+ showComments: true,
+ showUser : true,
+ showReposts : false,
+ visual : false, //Show/hide the big preview image
+ download : false //Show/Hide download buttons
+ },
+ spotifyEmbed : true,
+ codepenEmbed : true,
+ codepenHeight : 300,
+ jsfiddleEmbed : true,
+ jsfiddleHeight : 300,
+ jsbinEmbed : true,
+ jsbinHeight : 300,
+ plunkerEmbed : true,
+ githubgistEmbed : true,
+ ideoneEmbed : true,
+ ideoneHeight:300
+ })
+
+ .filter('embed', EmbedFilter)
+
+ .constant('NG_DEFAULT_TEMPLATE_URL', 'ng-embed-default-template.html')
+ .run(['$templateCache', 'NG_DEFAULT_TEMPLATE_URL', function($templateCache, NG_DEFAULT_TEMPLATE_URL) {
+
+ var template = '<div ng-bind-html="neText"></div> <div class="ne-video" ng-if="video.host" class="fade"> <div class="ne-video-preview" ng-hide="nePlayVideo || !options.video.details"> <div class="ne-video-thumb" ng-click="nePlayVideo=!nePlayVideo"> <img ng-src="{{video.thumbnail}}" alt=""/> <i class="fa fa-play-circle-o"></i> </div> <div class="ne-video-detail"> <div class="ne-video-title"> <a ng-href="{{video.url}}">{{video.title}}</a> </div> <div class="ne-video-desc"> {{video.description}} </div> <div class="ne-video-stats"> <span><i class="fa fa-eye"></i> {{video.views}}</span> <span><i class="fa fa-heart"></i> {{video.likes}}</span> </div> </div> </div> <div class="ne-video-player" ng-if="nePlayVideo || !(options.video.details)"> <iframe ng-src="{{video.embedSrc}}" frameBorder="0" width="{{video.width}}" height="{{video.height}}" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe> </div> </div> <div class="ne-video" ng-if="video.basic"> <div class="ne-video-player"> <div class="player"> <video ng-src="{{video.basic}}" controls></video> </div> </div> </div> <div ng-init="neImageLong=false" ng-class="{false:\'ne-image\', true:\'ne-image ne-image-long\'}[neImageLong]" ng-if="image.url"> <div class="ne-image-wrapper"> <img ng-src="{{image.url}}" ng-click="neImageLong=!neImageLong" alt=""/> </div> </div> <div class="ne-pdf" ng-if="pdf.url"> <div class="ne-pdf-preview" ng-hide="neShowPdf"> <div class="ne-pdf-icon"> <i class="fa fa-file-pdf-o"></i> </div> <div class="ne-pdf-detail" > <div class="ne-pdf-title"> <a href="">{{pdf.url}}</a> </div> <div class="ne-pdf-view"> <button><i class="fa fa-download"></i> <a ng-href="{{pdf.url}}" target="_blank">Download</a></button> <button ng-click="neShowPdf=!neShowPdf"><i class="fa fa-eye"></i> View PDF</button> </div> </div> </div> <div class="ne-pdf-viewer" ng-if="neShowPdf" ng-show="neShowPdf"> <iframe ng-src="{{pdf.url}}" frameBorder="0"></iframe> </div> </div> <div class="ne-audio" ng-if="audio.url"> <audio ng-src="{{audio.url}}" controls></audio> </div> <div ng-if="tweets" ng-repeat="tweet in tweets"> <div ng-bind-html="tweet"></div> </div> <div ng-if="videoServices" class="ne-video" ng-repeat="v in videoServices"> <div class="ne-video-player"> <div class="player"> <div ng-bind-html="v"></div> </div> </div> </div> <div ng-if="audioServices" class="ne-audio" ng-repeat="a in audioServices"> <div ng-bind-html="a"></div> </div> <div ng-if="codeServices" class="ne-embed" ng-repeat="c in codeServices"> <div ng-bind-html="c"></div> </div> <div ng-if="gist" class="ne-gist" ng-repeat="g in gist"> <ne-gist id="{{g}}"></ne-gist> </div>';
+
+ $templateCache.put(NG_DEFAULT_TEMPLATE_URL, template);
+ }])
+
+ .directive('ngEmbed', ngEmbedDirective)
+
+ //This directive is a modification of a module developed by Scott Corgan.
+ //present at scottcorgan/angular-gist
+ .directive('neGist', function () {
+ return {
+ restrict: 'EA',
+ replace : true,
+ template: '<div></div>',
+ link : function (scope, element, attrs) {
+ appendGistToElement(element[0], attrs.id);
+ }
+ };
+ });
+
+ ngEmbedDirective.$inject = ['$filter', '$sce', '$http', '$timeout', '$q', 'NG_DEFAULT_TEMPLATE_URL', 'NG_EMBED_REGEXP_PATTERNS', 'NG_EMBED_DEFAULT_OPTIONS'];
+ function ngEmbedDirective($filter, $sce, $http, $timeout, $q, NG_DEFAULT_TEMPLATE_URL, NG_EMBED_REGEXP_PATTERNS, NG_EMBED_DEFAULT_OPTIONS) {
+
+ return {
+ restrict : 'AE',
+ scope : true,
+ templateUrl: function (element, attributes) {
+ return (attributes.embedTemplateUrl || NG_DEFAULT_TEMPLATE_URL);
+ },
+ link : function (scope, elements, attributes) {
+ var embedFilter = $filter('embed');
+ var httpProtocol = getHttpProtocol();
+
+ var userOptions = scope.$eval(attributes.embedOptions);
+
+ var options = {};
+ angular.copy(NG_EMBED_DEFAULT_OPTIONS, options);
+
+ extendDeep(options, userOptions);
+
+ var videoProcess = {
+ calcDimensions: function (options) {
+ var dimensions = {
+ 'width' : null,
+ 'height': null
+ };
+ dimensions.width = options.video.width;
+ dimensions.height = options.video.height;
+
+ if (options.video.height && options.video.width) {
+ return dimensions;
+ }
+ else if (options.video.height) {
+ dimensions.width = ((options.video.height) / 390) * 640;
+ return dimensions;
+ }
+ else if (options.video.width) {
+ dimensions.height = ((dimensions.width) / 640) * 390;
+ return dimensions;
+ }
+ else {
+ dimensions.width = 640;
+ dimensions.height = 390;
+ return dimensions;
+ }
+ },
+ getRequestConfig: function() {
+ // clear existing headers if present for this http request
+ return {
+ headers: {
+ 'Authorization': undefined
+ }
+ };
+ },
+
+ youtubeEmbed: function(data, options) {
+ var promise, video;
+
+ if (data.match(NG_EMBED_REGEXP_PATTERNS.youtube)) {
+ var dimensions = videoProcess.calcDimensions(options);
+
+ video = {
+ id: RegExp.$1,
+ host: 'youtube',
+ width: dimensions.width,
+ height: dimensions.height
+ };
+
+ if (options.video.details) {
+
+ promise = $http.get('https://www.googleapis.com/youtube/v3/videos?id=' + video.id + '&key=' + options.gdevAuth + '&part=snippet,statistics', videoProcess.getRequestConfig())
+ .then(function (r) {
+ var autoPlay = ((options.video.autoPlay === undefined) || (options.video.autoPlay === true)) ? '?autoplay=1' : '?autoplay=0';
+ var ytData = r.data.items[0];
+
+ video.title = ytData.snippet.title;
+ video.thumbnail = ytData.snippet.thumbnails.medium.url;
+ video.description = trunc(ytData.snippet.description, 250, true)
+ .replace(/\n/g, ' ')
+ .replace(/ /g, ' ');
+ video.rawDescription = ytData.snippet.description;
+ video.views = ytData.statistics.viewCount;
+ video.likes = ytData.statistics.likeCount;
+ video.uploader = ytData.snippet.channelTitle;
+ video.uploaderPage = 'https://www.youtube.com/channel/' + ytData.snippet.channelId;
+ video.uploadDate = ytData.snippet.publishedAt;
+ video.url = $sce.trustAsResourceUrl("https://www.youtube.com/watch?v=" + ytData.id);
+ video.embedSrc = $sce.trustAsResourceUrl('https://www.youtube.com/embed/' + video.id + autoPlay);
+
+ return video;
+ });
+ }
+ else {
+ video.embedSrc = $sce.trustAsResourceUrl('https://www.youtube.com/embed/' + video.id + '?autoplay=0');
+ promise = $q.resolve(video);
+ }
+ }
+ else {
+ promise = $q.reject();
+ }
+
+ return promise;
+ },
+
+ vimeoEmbed: function (data, options) {
+ var promise, video;
+
+ if (data.match(NG_EMBED_REGEXP_PATTERNS.vimeo)) {
+ var dimensions = videoProcess.calcDimensions(options);
+
+ video = {
+ id: RegExp.$3,
+ host: 'vimeo',
+ width: dimensions.width,
+ height: dimensions.height
+ };
+
+ if (options.video.details) {
+
+ promise = $http.get('https://vimeo.com/api/v2/video/' + video.id + '.json', videoProcess.getRequestConfig())
+ .then(function (r) {
+ var d = r.data;
+ var autoPlay = ((options.video.autoPlay === undefined) || (options.video.autoPlay === true)) ? '&autoplay=1' : '&autoplay=0';
+ video.title = d[0].title;
+ video.rawDescription = (d[0].description)
+ .replace(/\n/g, '<br/>')
+ .replace(/ /g, '<br/>');
+ video.description = trunc((d[0].description)
+ .replace(/((<|<)br\s*\/*(>|>)\r\n)/g, ' '), 250, true);
+ video.thumbnail = d[0].thumbnail_medium;
+ video.views = d[0].stats_number_of_plays;
+ video.likes = d[0].stats_number_of_likes;
+ video.uploader = d[0].user_name;
+ video.uploaderPage = d[0].user_url;
+ video.uploadDate = d[0].uploadDate;
+ video.url = d[0].url;
+ video.embedSrc = $sce.trustAsResourceUrl('//player.vimeo.com/video/' + d[0].id + '?title=0&byline=0&portrait=0' + autoPlay);
+
+ return video;
+ });
+ }
+ else {
+ video.embedSrc = $sce.trustAsResourceUrl('//player.vimeo.com/video/' + video.id + '?title=0&byline=0&portrait=0&autoplay=0');
+
+ promise = $q.resolve(video);
+ }
+ }
+ else {
+ promise = $q.reject();
+ }
+
+ return promise;
+ },
+
+ embed: function (data, options) {
+ // show only youtube video if both vimeo and youtube videos are present.
+ return videoProcess.youtubeEmbed(data, options)
+ .catch(function() {
+ return videoProcess.vimeoEmbed(data, options);
+ });
+ },
+
+ embedBasic: function (data) {
+ if (data.match(NG_EMBED_REGEXP_PATTERNS.basicVideo)) {
+ scope.video.basic = $sce.trustAsResourceUrl(RegExp.$1);
+ }
+
+ return data;
+ },
+
+ twitchtvEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.twitchtv);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ var videoDimensions = videoProcess.calcDimensions(opts);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe ' +
+ 'src="https://player.twitch.tv/?channel=' + match.split('/')[1] +'&!autoplay" ' +
+ 'height="' + videoDimensions.height + '" ' +
+ 'width="' + videoDimensions.width + '" ' +
+ 'autoplay="false" ' +
+ 'frameborder="0" ' +
+ 'scrolling="no" ' +
+ 'allowfullscreen="true">' +
+ '</iframe>');
+ scope.videoServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ dailymotionEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.dailymotion);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ var videoDimensions = videoProcess.calcDimensions(opts);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe src="' + httpProtocol + '//www.dailymotion.com/embed/video/' + match.split('/')[2] + '" height="' + videoDimensions.height + '" width="' + videoDimensions.width + '"></iframe>');
+ scope.videoServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ tedEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.ted);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ var videoDimensions = videoProcess.calcDimensions(opts);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe src="https://embed.ted.com/talks/' + match.split('/')[2] + '.html" ' +
+ 'height="' + videoDimensions.height + '" width="' + videoDimensions.width + '"></iframe>');
+ scope.videoServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ dotsubEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.dotsub);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ var videoDimensions = videoProcess.calcDimensions(opts);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe src="https://dotsub.com/media/' + match.split('/')[2] + '/embed/" width="' + videoDimensions.width + '" height="' + videoDimensions.height + '"></iframe>');
+ scope.videoServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ liveleakEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.liveleak);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ var videoDimensions = videoProcess.calcDimensions(opts);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe src="' + httpProtocol + '//www.liveleak.com/e/' + match.split('=')[1] + '" height="' + videoDimensions.height + '" width="' + videoDimensions.width + '"></iframe>');
+ scope.videoServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ ustreamEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.ustream);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ var videoDimensions = videoProcess.calcDimensions(opts);
+ angular.forEach(uniqueMatches, function(match) {
+ var id = match.split('/');
+ if( id.indexOf('embed') < 0) {
+ id.splice(1, 0, 'embed');
+ }
+ var frame = $sce.trustAsHtml('<iframe src="' + httpProtocol + '//www.' + id.join('/') + '" height="' + videoDimensions.height + '" width="' + videoDimensions.width + '"></iframe>');
+ scope.videoServices.push(frame);
+ });
+ }
+ return str;
+ }
+ };
+
+ var audioProcess = {
+ embed: function (str) {
+ if (str.match(NG_EMBED_REGEXP_PATTERNS.basicAudio)) {
+ scope.audio.url = $sce.trustAsResourceUrl(RegExp.$1);
+ }
+ return str;
+ },
+
+ soundcloudEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.soundCloud);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe height="160" scrolling="no" ' + 'src="https://w.soundcloud.com/player/?url=https://' + match + '&auto_play=' + opts.soundCloudOptions.autoPlay + '&hide_related=' + opts.soundCloudOptions.hideRelated + '&show_comments=' + opts.soundCloudOptions.showComments + '&show_user=' + opts.soundCloudOptions.showUser + '&show_reposts=' + opts.soundCloudOptions.showReposts + '&visual=' + opts.soundCloudOptions.visual + '&download=' + opts.soundCloudOptions.download + '&color=' + opts.soundCloudOptions.themeColor + '&theme_color=' + opts.soundCloudOptions.themeColor + '"></iframe>');
+ scope.videoServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ spotifyEmbed: function (str) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.spotify);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe src="https://embed.spotify.com/?uri=spotify:track:' + match.split('/')[2] + '" height="80"></iframe>');
+ scope.audioServices.push(frame);
+ });
+ }
+ return str;
+ }
+ };
+
+ var imageProcess = {
+ embed: function (data) {
+ if (data.match(NG_EMBED_REGEXP_PATTERNS.basicImage)) {
+ scope.image.url = RegExp.$1;
+ }
+ return data;
+ }
+ };
+
+ var codeProcess = {
+
+ /**
+ * Encodes the characters like <, > and space and replaces them with
+ * <, > and > respectively.
+ * @param {string} code The string that has to be encoded.
+ * @return {string} The encoded string
+ */
+ encode: function(code) {
+ var encoded = htmlEncode(code);
+ encoded = encoded.replace(/&/gm, '');
+ return encoded;
+ },
+
+ getCode: function (text) {
+ return (text + '').replace(NG_EMBED_REGEXP_PATTERNS.highlightCode,
+ function (wholeMatch, group1, group2, group3) {
+ var code = group3;
+ code = trimSpace(code);
+ code = codeProcess.encode(code);
+
+ code = code.replace(/:\/\//g, "~P"); // to prevent auto-linking. Not necessary in code
+ // *blocks*, but in code spans. Will be converted
+ // back after the auto-linker runs.
+
+ var language = group2.split('\n')[0];
+
+ var highlightedCode;
+ if ( language ) {
+ highlightedCode = hljs.highlightAuto(code, [language]);
+ } else {
+ highlightedCode = hljs.highlightAuto(code);
+ language = highlightedCode.language;
+ }
+
+ return '<pre><code class="ne-code hljs ' + language + '">' + highlightedCode.value + '</code></pre>';
+ /*
+ var codeBlock = $sce.trustAsHtml('<pre><code class="ne-code hljs ' + language + '">' + highlightedCode.value + '</code></pre>');
+ scope.codeServices.push(codeBlock);
+ return '';
+ */
+ }
+ );
+ }
+ };
+
+ var pdfProcess = {
+ embed: function (str) {
+ if (str.match(NG_EMBED_REGEXP_PATTERNS.pdf)) {
+ scope.pdf.url = $sce.trustAsResourceUrl(RegExp.$1);
+ }
+
+ return str;
+ }
+ };
+
+ var tweetProcess = {
+ embed: function (str, opts) {
+ if (!window.twttr) {
+ console.error(new ReferenceError('twttr is not defined. Load http://platform.twitter.com/widgets.js'));
+ return data;
+ }
+ function renderTweet() {
+ $timeout(function () {
+ twttr.widgets.load();
+ }, 10);
+ }
+
+ scope.tweets = [];
+
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.twitter);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ angular.forEach(uniqueMatches, function(match) {
+ var url = 'https://api.twitter.com/1/statuses/oembed.json?omit_script=true&&url=' + match + '&maxwidth=' + opts.tweetOptions.maxWidth + '&hide_media=' + opts.tweetOptions.hideMedia + '&hide_thread=' + opts.tweetOptions.hideThread + '&align=' + opts.tweetOptions.align + '&lang=' + opts.tweetOptions.lang;
+ var request;
+ if( parseInt(angular.version.major) >= 1 && parseInt(angular.version.minor) >= 6 ) {
+ request = $http.jsonp($sce.trustAsResourceUrl(url), { callbackParam: 'JSON_CALLBACK' });
+ }
+ else {
+ /**
+ * callback=JSON_CALLBACK is an angular fix to make sure we get the correct mime type of the
+ * received data.
+ */
+ request = $http.jsonp(url + '&callback=JSON_CALLBACK');
+ }
+
+ request.then(function (r) {
+ scope.tweets.push(r.data.html);
+ if (scope.tweets.length == uniqueMatches.length) {
+ renderTweet();
+ }
+ }).catch(function(err) {
+ console.error(err);
+ });
+ });
+ }
+ return str;
+ }
+ };
+
+ var codeEmbedProcess = {
+ codepenEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.codepen);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe scrolling="no" height="' + opts.codepenHeight + '" src="' + match.replace(/\/pen\//, '/embed/') + '/?height=' + opts.codepenHeight + '" frameborder="no" allowtransparency="true" allowfullscreen="true"></iframe>');
+ scope.codeServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ jsfiddleEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.jsfiddle);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe height="' + opts.jsfiddleHeight + '" src="' + httpProtocol + '//' + match + '/embedded"></iframe>');
+ scope.codeServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ jsbinEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.jsbin);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame = $sce.trustAsHtml('<iframe height="' + opts.jsbinHeight + '" class="jsbin-embed foo" src="' + httpProtocol + '//' + match + '/embed?html,js,output">Simple Animation Tests</iframe>');
+ scope.codeServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ plunkerEmbed: function (str, opts) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.plunker);
+ if (matches) {
+ var uniqueMatches = getUniqueArray(matches);
+ angular.forEach(uniqueMatches, function(match) {
+ var path = match.split('/')[2];
+ var idMatch = (match.indexOf('?') === -1) ? path : path.split('?')[0];
+ var frame = $sce.trustAsHtml('<iframe class="ne-plunker" src="' + httpProtocol + '//embed.plnkr.co/' + idMatch + '" height="' + opts.jsbinHeight + '"></iframe>');
+ scope.codeServices.push(frame);
+ });
+ }
+ return str;
+ },
+
+ githubgistEmbed: function (str) {
+ var matches = str.match(NG_EMBED_REGEXP_PATTERNS.gist);
+ if (matches) {
+ var gists = [];
+ angular.forEach(matches, function(match) {
+ gists.push(match.split('/')[2]);
+ });
+ scope.gist = getUniqueArray(gists);
+ }
+
+ return str;
+ },
+
+ ideoneEmbed:function(str,opts){
+ var matches=str.match(NG_EMBED_REGEXP_PATTERNS.ideone);
+ if(matches){
+ var uniqueMatches = getUniqueArray(matches);
+ angular.forEach(uniqueMatches, function(match) {
+ var frame=$sce.trustAsHtml('<iframe src="' + httpProtocol + '//ideone.com/embed/'+match.split('/')[1]+'" height="'+opts.ideoneHeight+'"></iframe>');
+ scope.codeServices.push(frame);
+ });
+ }
+ return str;
+ },
+ highlightEmbed: function(data, options) {
+ if (!window.hljs) {
+ console.error(new ReferenceError('hlsj (Highlight JS is not defined.'));
+ return data;
+ }
+ else {
+ data = codeProcess.getCode(data);
+
+ /**
+ * Adding line numbers to code
+ */
+ $timeout(function () {
+ // wrapped in timeout to allow code elements to be added to DOM
+ if (options.code.lineNumbers) {
+ var codeBlocks = elements.find('.ne-code');
+ if( codeBlocks.length > 0 ) {
+ angular.forEach(codeBlocks, function(block) {
+ var codeElement = angular.element(block)
+ .addClass('has-numbering');
+ var content = codeElement.text();
+ var lineCount = content.split('\n').length;
+ var lineNbrList = angular.element('<ul/>').addClass('pre-numbering');
+ for (var i = 1; i <= lineCount; i++) {
+ var lineNbr = angular.element('<li/>').text(i);
+ lineNbrList.append(lineNbr);
+ }
+
+ codeElement
+ .parent()
+ .append(lineNbrList);
+ });
+ }
+ }
+
+ }, 20);
+ }
+
+ return data;
+ }
+ };
+
+ function processEmbed(input){
+ // clear scope
+ scope.video = {};
+ scope.image = {};
+ scope.pdf = {};
+ scope.audio = {};
+ scope.videoServices = [];
+ scope.audioServices = [];
+ scope.codeServices = [];
+ scope.gist = [];
+
+ // make sure that input is string
+ if( !angular.isString(input) || input.length === 0 ) {
+ input = ' ';
+ }
+ var x = embedFilter(input, options).$$unwrapTrustedValue();
+
+ if (options.video.embed) {
+ if (!options.gdevAuth) {
+ console.error('Youtube authentication key is required to get data from youtube.');
+ }
+ else {
+ videoProcess.embed(x, options)
+ .then(function(video) {
+ scope.video = video;
+ });
+ }
+
+ }
+
+ x = options.basicVideo ? videoProcess.embedBasic(x) : x;
+ x = options.audio.embed ? audioProcess.embed(x) : x;
+ x = options.image.embed ? imageProcess.embed(x) : x;
+ x = options.pdf.embed ? pdfProcess.embed(x) : x;
+ x = options.tweetEmbed ? tweetProcess.embed(x, options) : x;
+ x = options.twitchtvEmbed ? videoProcess.twitchtvEmbed(x, options) : x;
+ x = options.dailymotionEmbed ? videoProcess.dailymotionEmbed(x, options) : x;
+ x = options.tedEmbed ? videoProcess.tedEmbed(x, options) : x;
+ x = options.dotsubEmbed ? videoProcess.dotsubEmbed(x, options) : x;
+ x = options.liveleakEmbed ? videoProcess.liveleakEmbed(x, options) : x;
+ x = options.ustreamEmbed ? videoProcess.ustreamEmbed(x, options) : x;
+ x = options.soundCloudEmbed ? audioProcess.soundcloudEmbed(x, options) : x;
+ x = options.spotifyEmbed ? audioProcess.spotifyEmbed(x) : x;
+ x = options.code.highlight ? codeEmbedProcess.highlightEmbed(x, options) : x;
+ x = options.codepenEmbed ? codeEmbedProcess.codepenEmbed(x, options) : x;
+ x = options.jsfiddleEmbed ? codeEmbedProcess.jsfiddleEmbed(x, options) : x;
+ x = options.jsbinEmbed ? codeEmbedProcess.jsbinEmbed(x, options) : x;
+ x = options.plunkerEmbed ? codeEmbedProcess.plunkerEmbed(x, options) : x;
+ x = options.githubgistEmbed ? codeEmbedProcess.githubgistEmbed(x, options) : x;
+ x = options.ideoneEmbed ? codeEmbedProcess.ideoneEmbed(x, options) : x;
+
+
+ $timeout(function(html){
+ scope.neText = $sce.trustAsHtml(html);
+ }, 0, true, x);
+ }
+
+ if( !options.watchEmbedData ) {
+ var newData = scope.$eval(attributes.embedData);
+ processEmbed(newData);
+ }
+ else {
+ scope.$watch(attributes.embedData, processEmbed);
+ }
+ }
+ };
+ }
+
+ EmbedFilter.$inject = ['$sce', 'NG_EMBED_BASIC_EMOTICONS', 'NG_EMBED_EMOJI_LIST', 'NG_EMBED_REGEXP_PATTERNS', 'NG_EMBED_FILTER_DEFAULT_OPTIONS'];
+ function EmbedFilter($sce, NG_EMBED_BASIC_EMOTICONS, NG_EMBED_EMOJI_LIST, NG_EMBED_REGEXP_PATTERNS, NG_EMBED_FILTER_DEFAULT_OPTIONS) {
+
+ var EMOIJ_REGEX = new RegExp(":(" + NG_EMBED_EMOJI_LIST.join("|") + "):", "gi");
+
+ return function (input, userOptions) {
+
+ var options = {};
+ angular.copy(NG_EMBED_FILTER_DEFAULT_OPTIONS, options);
+
+ extendDeep(options, userOptions);
+
+ if (input === undefined || input === null) {
+ return;
+ }
+ if (typeof input === "object") {
+ return input;
+ }
+
+ if (!angular.isNumber(input)) {
+ input = input.toString();
+ }
+
+ // sanitize - needs to be called before other functions are called. If not it would sanitize
+ // the emojis and the links and break the whole ng-embed functionality
+
+ if (options.sanitizeHtml) {
+ input = sanitizeHtml(input);
+
+ }
+
+ if (options.fontSmiley) {
+ input = insertfontSmiley(input, NG_EMBED_BASIC_EMOTICONS);
+ }
+
+ if (options.emoji) {
+ input = insertEmoji(input, EMOIJ_REGEX);
+ }
+
+ if (options.link) {
+ input = urlEmbed(input, options.linkTarget, NG_EMBED_REGEXP_PATTERNS.url, NG_EMBED_REGEXP_PATTERNS.protocol);
+ }
+
+ return $sce.trustAsHtml(input);
+
+ };
+ }
+
+ function appendGistToElement(element, gistId) {
+ var iframe = document.createElement('iframe');
+ iframe.setAttribute('width', '100%');
+ iframe.setAttribute('frameborder', '0');
+ iframe.id = "gist-" + gistId;
+element.appendChild(iframe);
+
+ var iframeHtml = '<html><head><base target="_parent"><style>table{font-size:12px;}</style>' +
+ '</head><body onload="parent.document.getElementById(\'' + iframe.id + '\').style.height=' +
+ 'document.body.scrollHeight + \'px\'" style="margin:10px 0;"><script type="text/javascript">' +
+ '!function(){"use strict";window.retargetLinks=function(){ var gists=' +
+ 'document.getElementsByClassName("gist");for(var i=0,links;i<gists.length;i++){' +
+ 'links=gists[i].getElementsByTagName("a");for(var j=0;j<links.length;j++){ ' +
+ 'links[j].setAttribute("target","_blank");}}}}();</script><script type="text/javascript" ' +
+ 'src="https://gist.github.com/' + gistId + '.js" onload="retargetLinks()"></script></body></html>';
+
+ var doc = iframe.document;
+ if (iframe.contentDocument) {
+ doc = iframe.contentDocument;
+ }
+ else if (iframe.contentWindow) {
+ doc = iframe.contentWindow.document;
+ }
+
+ doc.open();
+ doc.writeln(iframeHtml);
+ doc.close();
+ }
+
+ function getUniqueArray(list) {
+ //*
+ // fast way using hashmap
+ // inspired by http://jszen.com/best-way-to-get-unique-values-of-an-array-in-javascript.7.html
+ var n = {},r=[];
+ for(var i = 0; i < list.length; i++)
+ {
+ if (!n[list[i]])
+ {
+ n[list[i]] = true;
+ r.push(list[i]);
+ }
+ }
+ return r;
+ //*/
+ /*
+ // IE9+, a bit slower
+ return list.filter(function (x, i, a) {
+ return a.indexOf(x) === i;
+ });
+ //*/
+ }
+
+ /**
+ * Function trunc
+ *
+ * @description
+ * truncates string to specified length
+ *
+ * @param {string} str
+ * @param {number} n
+ * @param {boolean} useWordBoundary
+ * @returns string
+ */
+
+ function trunc(str, n, useWordBoundary) {
+ var toLong = str.length > n,
+ s_ = toLong ? str.substr(0, n - 1) : str;
+ s_ = useWordBoundary && toLong ? s_.substr(0, s_.lastIndexOf(' ')) : s_;
+ return toLong ? s_ + '...' : s_;
+ }
+
+ /**
+ * Function extendDeep
+ *
+ * @description
+ * Extends an object to another object using deep analyzing
+ *
+ * @param dst
+ * @returns extended object
+ */
+
+ function extendDeep(dst) {
+ angular.forEach(arguments, function (obj) {
+ if (obj !== dst) {
+ angular.forEach(obj, function (value, key) {
+ if (dst[key] && dst[key].constructor && dst[key].constructor === Object) {
+ extendDeep(dst[key], value);
+ }
+ else {
+ dst[key] = value;
+ }
+ });
+ }
+ });
+ return dst;
+ }
+
+ /**
+ * FUNCTION insertfontSmiley
+ * @description
+ * Coverts the text into font emoticons
+ *
+ * @param {string} str
+ * @param {Object} icons
+ *
+ * @return {string}
+ */
+
+ function insertfontSmiley(str, icons) {
+ var words = str.split(' ');
+ angular.forEach(words, function (word, i) {
+ var icon = icons[word];
+ if (icon) {
+ words[i] = '<i class="ne-emoticon" title="' + icon.text + '">' + '&#x' + icon.code + '</i>';
+ }
+ });
+ return words.join(' ');
+ }
+
+ /**
+ * FUNCTION insertEmoji
+ *
+ * @description
+ * Converts text into emojis
+ *
+ * @param {string} str
+ * @param {RegExp} emojiPattern
+ *
+ * @return {string}
+ */
+
+ function insertEmoji(str, emojiPattern) {
+ return str.replace(emojiPattern, function (match, text) {
+ return "<i class='emoticon emoticon-" + text + "' title=':" + text + ":'></i>";
+ });
+ }
+
+ /**
+ * FUNCTION UrlEmbed
+ * @description
+ * Converts normal links written in the text into html anchor tags.
+ *
+ * @param {string} str
+ * @param {string} linkTarget
+ * @param {RegExp} urlPattern
+ * @param {RegExp} protocolPattern
+ *
+ * @return {string}
+ */
+
+ function urlEmbed(str, linkTarget, urlPattern, protocolPattern) {
+ return str.replace(urlPattern, function (text) {
+ var url = text;
+ if (!protocolPattern.test(text)) {
+ url = getHttpProtocol() + '//' + text;
+ }
+
+ if (linkTarget == 'cordova'){
+ return '<a href="#" onclick="window.open(\''+ url +'\', \'_system\', \'location=yes\')" >' + text + '</a>';
+ }
+ else {
+ return '<a href="' + url + '" target="' + linkTarget + '">' + text + '</a>';
+ }
+ }
+ );
+ }
+
+ /**
+ * FUNCTION sanitizeHtml
+ *
+ * @description
+ * Converts <, >, & to html entities
+ *
+ * @param {string} str
+ *
+ * @return {string}
+ */
+ function sanitizeHtml(str) {
+ var map = {'&': '&', '>': '>', '<': '<'};
+ return str.replace(/[&<>]/g, function (m) {
+ return map[m];
+ });
+ }
+
+ /**
+ * FUNCTION htmlEncode
+ *
+ * @description
+ * Converts html entities for <, >, & to characters
+ *
+ * @param {string} str
+ *
+ * @return {string}
+ */
+ function htmlEncode(str) {
+ var map = {'&': '&', '>': '>', '<': '<'};
+ return str.replace(/&(amp|gt|lt);/g, function (m) {
+ return map[m];
+ });
+ }
+
+ /**
+ * FUNCTION trimSpace
+ *
+ * removes whitespace characters
+ * @param {string} str The string from which the whitespace has to be removed
+ * @return {string}
+ */
+ function trimSpace(str) {
+ var trimmed = str.replace(/^([ \t]*)/g, ''); // leading whitespace
+ trimmed = trimmed.replace(/[ \t]*$/g, ''); // trailing whitespace
+ return trimmed;
+ }
+
+ /**
+ * FUNCTION getHttpProtocol
+ *
+ * Get https: if host is running https or http: otherwise
+ * @returns string
+ */
+ function getHttpProtocol() {
+ return window.location.protocol.match(/https/) ? 'https:' : 'http:';
+ }
+})();
+
+
+/***/ }),
+
+/***/ "./src/js/chat/chat.tpl.html":
+/*!***********************************!*\
+ !*** ./src/js/chat/chat.tpl.html ***!
+ \***********************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+module.exports = __webpack_require__.p + "templates/506e63fc4fed5ec7b0ca.html";
+
+/***/ }),
+
+/***/ "./src/js/closing/closing.tpl.html":
+/*!*****************************************!*\
+ !*** ./src/js/closing/closing.tpl.html ***!
+ \*****************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+module.exports = __webpack_require__.p + "templates/2444367602029f7ce07b.html";
+
+/***/ }),
+
+/***/ "./src/js/offline/offline.tpl.html":
+/*!*****************************************!*\
+ !*** ./src/js/offline/offline.tpl.html ***!
+ \*****************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+module.exports = __webpack_require__.p + "templates/c1e929900f2af303341f.html";
+
+/***/ }),
+
+/***/ "./src/js/online/online.tpl.html":
+/*!***************************************!*\
+ !*** ./src/js/online/online.tpl.html ***!
+ \***************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+module.exports = __webpack_require__.p + "templates/cd310ba2c496545551ae.html";
+
+/***/ }),
+
+/***/ "./src/js/unmanaged/unmanaged.tpl.html":
+/*!*********************************************!*\
+ !*** ./src/js/unmanaged/unmanaged.tpl.html ***!
+ \*********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+module.exports = __webpack_require__.p + "templates/c6696015a1b93372d614.html";
+
+/***/ }),
+
+/***/ "./src/js/waiting/waiting.tpl.html":
+/*!*****************************************!*\
+ !*** ./src/js/waiting/waiting.tpl.html ***!
+ \*****************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+module.exports = __webpack_require__.p + "templates/66a0b4b6e8658e97c814.html";
+
+/***/ })
+
+},
+/******/ __webpack_require__ => { // webpackRuntimeModules
+/******/ var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
+/******/ var __webpack_exports__ = (__webpack_exec__("./node_modules/jquery/dist/jquery.js"), __webpack_exec__("./node_modules/angular/index-exposed.js"), __webpack_exec__("./node_modules/moment/moment.js"), __webpack_exec__("./node_modules/@flowjs/flow.js/src/flow.js"), __webpack_exec__("./node_modules/emojione/lib/js/emojione.js"), __webpack_exec__("./src/js/index.module.js"));
+/******/ }
+]);
+//# sourceMappingURL=chat.js.map
\ No newline at end of file
git://repos.xcallymotion.com / motion2.git / blobdiff