YLShipBuildLandMap/YLShipBuildLandMap.Web/wwwroot/scripts/angular-cookies.js

/**
 * @license AngularJS v1.6.5
 * (c) 2010-2017 Google, Inc. http://angularjs.org
 * License: MIT
 */
(function (window, angular) {
    'use strict';

    /**
     * @ngdoc module
     * @name ngCookies
     * @description
     *
     * # ngCookies
     *
     * The `ngCookies` module provides a convenient wrapper for reading and writing browser cookies.
     *
     *
     * <div doc-module-components="ngCookies"></div>
     *
     * See {@link ngCookies.$cookies `$cookies`} for usage.
     */


    angular.module('ngCookies', ['ng']).info({angularVersion: '1.6.5'}).
    /**
     * @ngdoc provider
     * @name $cookiesProvider
     * @description
     * Use `$cookiesProvider` to change the default behavior of the {@link ngCookies.$cookies $cookies} service.
     * */
    provider('$cookies', [/** @this */function $CookiesProvider() {
        /**
         * @ngdoc property
         * @name $cookiesProvider#defaults
         * @description
         *
         * Object containing default options to pass when setting cookies.
         *
         * The object may have following properties:
         *
         * - **path** - `{string}` - The cookie will be available only for this path and its
         *   sub-paths. By default, this is the URL that appears in your `<base>` tag.
         * - **domain** - `{string}` - The cookie will be available only for this domain and
         *   its sub-domains. For security reasons the user agent will not accept the cookie
         *   if the current domain is not a sub-domain of this domain or equal to it.
         * - **expires** - `{string|Date}` - String of the form "Wdy, DD Mon YYYY HH:MM:SS GMT"
         *   or a Date object indicating the exact date/time this cookie will expire.
         * - **secure** - `{boolean}` - If `true`, then the cookie will only be available through a
         *   secured connection.
         *
         * Note: By default, the address that appears in your `<base>` tag will be used as the path.
         * This is important so that cookies will be visible for all routes when html5mode is enabled.
         *
         * @example
         *
         * ```js
         * angular.module('cookiesProviderExample', ['ngCookies'])
         *   .config(['$cookiesProvider', function($cookiesProvider) {
         *     // Setting default options
         *     $cookiesProvider.defaults.domain = 'foo.com';
         *     $cookiesProvider.defaults.secure = true;
         *   }]);
         * ```
         **/
        var defaults = this.defaults = {};

        function calcOptions(options) {
            return options ? angular.extend({}, defaults, options) : defaults;
        }

        /**
         * @ngdoc service
         * @name $cookies
         *
         * @description
         * Provides read/write access to browser's cookies.
         *
         * <div class="alert alert-info">
         * Up until Angular 1.3, `$cookies` exposed properties that represented the
         * current browser cookie values. In version 1.4, this behavior has changed, and
         * `$cookies` now provides a standard api of getters, setters etc.
         * </div>
         *
         * Requires the {@link ngCookies `ngCookies`} module to be installed.
         *
         * @example
         *
         * ```js
         * angular.module('cookiesExample', ['ngCookies'])
         *   .controller('ExampleController', ['$cookies', function($cookies) {
         *     // Retrieving a cookie
         *     var favoriteCookie = $cookies.get('myFavorite');
         *     // Setting a cookie
         *     $cookies.put('myFavorite', 'oatmeal');
         *   }]);
         * ```
         */
        this.$get = ['$$cookieReader', '$$cookieWriter', function ($$cookieReader, $$cookieWriter) {
            return {
                /**
                 * @ngdoc method
                 * @name $cookies#get
                 *
                 * @description
                 * Returns the value of given cookie key
                 *
                 * @param {string} key Id to use for lookup.
                 * @returns {string} Raw cookie value.
                 */
                get: function (key) {
                    return $$cookieReader()[key];
                },

                /**
                 * @ngdoc method
                 * @name $cookies#getObject
                 *
                 * @description
                 * Returns the deserialized value of given cookie key
                 *
                 * @param {string} key Id to use for lookup.
                 * @returns {Object} Deserialized cookie value.
                 */
                getObject: function (key) {
                    var value = this.get(key);
                    return value ? angular.fromJson(value) : value;
                },

                /**
                 * @ngdoc method
                 * @name $cookies#getAll
                 *
                 * @description
                 * Returns a key value object with all the cookies
                 *
                 * @returns {Object} All cookies
                 */
                getAll: function () {
                    return $$cookieReader();
                },

                /**
                 * @ngdoc method
                 * @name $cookies#put
                 *
                 * @description
                 * Sets a value for given cookie key
                 *
                 * @param {string} key Id for the `value`.
                 * @param {string} value Raw value to be stored.
                 * @param {Object=} options Options object.
                 *    See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults}
                 */
                put: function (key, value, options) {
                    $$cookieWriter(key, value, calcOptions(options));
                },

                /**
                 * @ngdoc method
                 * @name $cookies#putObject
                 *
                 * @description
                 * Serializes and sets a value for given cookie key
                 *
                 * @param {string} key Id for the `value`.
                 * @param {Object} value Value to be stored.
                 * @param {Object=} options Options object.
                 *    See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults}
                 */
                putObject: function (key, value, options) {
                    this.put(key, angular.toJson(value), options);
                },

                /**
                 * @ngdoc method
                 * @name $cookies#remove
                 *
                 * @description
                 * Remove given cookie
                 *
                 * @param {string} key Id of the key-value pair to delete.
                 * @param {Object=} options Options object.
                 *    See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults}
                 */
                remove: function (key, options) {
                    $$cookieWriter(key, undefined, calcOptions(options));
                }
            };
        }];
    }]);

    angular.module('ngCookies').
    /**
     * @ngdoc service
     * @name $cookieStore
     * @deprecated
     * sinceVersion="v1.4.0"
     * Please use the {@link ngCookies.$cookies `$cookies`} service instead.
     *
     * @requires $cookies
     *
     * @description
     * Provides a key-value (string-object) storage, that is backed by session cookies.
     * Objects put or retrieved from this storage are automatically serialized or
     * deserialized by angular's toJson/fromJson.
     *
     * Requires the {@link ngCookies `ngCookies`} module to be installed.
     *
     * @example
     *
     * ```js
     * angular.module('cookieStoreExample', ['ngCookies'])
     *   .controller('ExampleController', ['$cookieStore', function($cookieStore) {
     *     // Put cookie
     *     $cookieStore.put('myFavorite','oatmeal');
     *     // Get cookie
     *     var favoriteCookie = $cookieStore.get('myFavorite');
     *     // Removing a cookie
     *     $cookieStore.remove('myFavorite');
     *   }]);
     * ```
     */
    factory('$cookieStore', ['$cookies', function ($cookies) {

        return {
            /**
             * @ngdoc method
             * @name $cookieStore#get
             *
             * @description
             * Returns the value of given cookie key
             *
             * @param {string} key Id to use for lookup.
             * @returns {Object} Deserialized cookie value, undefined if the cookie does not exist.
             */
            get: function (key) {
                return $cookies.getObject(key);
            },

            /**
             * @ngdoc method
             * @name $cookieStore#put
             *
             * @description
             * Sets a value for given cookie key
             *
             * @param {string} key Id for the `value`.
             * @param {Object} value Value to be stored.
             */
            put: function (key, value) {
                $cookies.putObject(key, value);
            },

            /**
             * @ngdoc method
             * @name $cookieStore#remove
             *
             * @description
             * Remove given cookie
             *
             * @param {string} key Id of the key-value pair to delete.
             */
            remove: function (key) {
                $cookies.remove(key);
            }
        };

    }]);

    /**
     * @name $$cookieWriter
     * @requires $document
     *
     * @description
     * This is a private service for writing cookies
     *
     * @param {string} name Cookie name
     * @param {string=} value Cookie value (if undefined, cookie will be deleted)
     * @param {Object=} options Object with options that need to be stored for the cookie.
     */
    function $$CookieWriter($document, $log, $browser) {
        var cookiePath = $browser.baseHref();
        var rawDocument = $document[0];

        function buildCookieString(name, value, options) {
            var path, expires;
            options = options || {};
            expires = options.expires;
            path = angular.isDefined(options.path) ? options.path : cookiePath;
            if (angular.isUndefined(value)) {
                expires = 'Thu, 01 Jan 1970 00:00:00 GMT';
                value = '';
            }
            if (angular.isString(expires)) {
                expires = new Date(expires);
            }

            var str = encodeURIComponent(name) + '=' + encodeURIComponent(value);
            str += path ? ';path=' + path : '';
            str += options.domain ? ';domain=' + options.domain : '';
            str += expires ? ';expires=' + expires.toUTCString() : '';
            str += options.secure ? ';secure' : '';

            // per http://www.ietf.org/rfc/rfc2109.txt browser must allow at minimum:
            // - 300 cookies
            // - 20 cookies per unique domain
            // - 4096 bytes per cookie
            var cookieLength = str.length + 1;
            if (cookieLength > 4096) {
                $log.warn('Cookie \'' + name +
                    '\' possibly not set or overflowed because it was too large (' +
                    cookieLength + ' > 4096 bytes)!');
            }

            return str;
        }

        return function (name, value, options) {
            rawDocument.cookie = buildCookieString(name, value, options);
        };
    }

    $$CookieWriter.$inject = ['$document', '$log', '$browser'];

    angular.module('ngCookies').provider('$$cookieWriter', /** @this */ function $$CookieWriterProvider() {
        this.$get = $$CookieWriter;
    });


})(window, window.angular);