☰

cookie-umd

UMD build of cookie

このスクリプトは単体で利用できません。右のようなメタデータを含むスクリプトから、ライブラリとして読み込まれます: // @require https://update.greatest.deepsurf.us/scripts/501949/1418023/cookie-umd.js

このスクリプトの質問や評価の投稿はこちら、通報はこちらへお寄せください。 
  1. // ==UserScript==
  2. // @name          cookie-umd
  3. // @namespace     flomk.userscripts
  4. // @version       1.0
  5. // @description   UMD build of cookie
  6. // @author        flomk
  7. // ==/UserScript==
  8. (function (global, factory) {
  9. 	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  10. 	typeof define === 'function' && define.amd ? define(['exports'], factory) :
  11. 	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.cookie = {}));
  12. })(this, (function (exports) { 'use strict';
  13.     const __toString = Object.prototype.toString
  14.     
  15.     /**
  16.      * RegExp to match field-content in RFC 7230 sec 3.2
  17.      *
  18.      * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
  19.      * field-vchar   = VCHAR / obs-text
  20.      * obs-text      = %x80-FF
  21.      */
  22.     
  23.     const fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
  24.     
  25.     /**
  26.      * Parse a cookie header.
  27.      *
  28.      * Parse the given cookie header string into an object
  29.      * The object has the various cookies as keys(names) => values
  30.      *
  31.      * @param {string} str
  32.      * @param {object} [options]
  33.      * @return {object}
  34.      * @public
  35.      */
  36.     
  37.     const parse = (str, options) => {
  38.         if (typeof str !== 'string') {
  39.             throw new TypeError('argument str must be a string');
  40.         }
  41.     
  42.         var obj = {}
  43.         var opt = options || {};
  44.         var dec = opt.decode || decode;
  45.     
  46.         var index = 0
  47.         while (index < str.length) {
  48.             var eqIdx = str.indexOf('=', index)
  49.     
  50.             // no more cookie pairs
  51.             if (eqIdx === -1) {
  52.                 break
  53.             }
  54.     
  55.             var endIdx = str.indexOf(';', index)
  56.     
  57.             if (endIdx === -1) {
  58.                 endIdx = str.length
  59.             } else if (endIdx < eqIdx) {
  60.                 // backtrack on prior semicolon
  61.                 index = str.lastIndexOf(';', eqIdx - 1) + 1
  62.                 continue
  63.             }
  64.     
  65.             var key = str.slice(index, eqIdx).trim()
  66.     
  67.             // only assign once
  68.             if (undefined === obj[key]) {
  69.                 var val = str.slice(eqIdx + 1, endIdx).trim()
  70.     
  71.                 // quoted values
  72.                 if (val.charCodeAt(0) === 0x22) {
  73.                     val = val.slice(1, -1)
  74.                 }
  75.     
  76.                 obj[key] = tryDecode(val, dec);
  77.             }
  78.     
  79.             index = endIdx + 1
  80.         }
  81.     
  82.         return obj;
  83.     };
  84.     
  85.     /**
  86.      * Serialize data into a cookie header.
  87.      *
  88.      * Serialize the a name value pair into a cookie string suitable for
  89.      * http headers. An optional options object specified cookie parameters.
  90.      *
  91.      * serialize('foo', 'bar', { httpOnly: true })
  92.      *   => "foo=bar; httpOnly"
  93.      *
  94.      * @param {string} name
  95.      * @param {string} val
  96.      * @param {object} [options]
  97.      * @return {string}
  98.      * @public
  99.      */
  100.     
  101.     const serialize = (name, val, options) => {
  102.         var opt = options || {};
  103.         var enc = opt.encode || encode;
  104.     
  105.         if (typeof enc !== 'function') {
  106.             throw new TypeError('option encode is invalid');
  107.         }
  108.     
  109.         if (!fieldContentRegExp.test(name)) {
  110.             throw new TypeError('argument name is invalid');
  111.         }
  112.     
  113.         var value = enc(val);
  114.     
  115.         if (value && !fieldContentRegExp.test(value)) {
  116.             throw new TypeError('argument val is invalid');
  117.         }
  118.     
  119.         var str = name + '=' + value;
  120.     
  121.         if (null != opt.maxAge) {
  122.             var maxAge = opt.maxAge - 0;
  123.     
  124.             if (isNaN(maxAge) || !isFinite(maxAge)) {
  125.                 throw new TypeError('option maxAge is invalid')
  126.             }
  127.     
  128.             str += '; Max-Age=' + Math.floor(maxAge);
  129.         }
  130.     
  131.         if (opt.domain) {
  132.             if (!fieldContentRegExp.test(opt.domain)) {
  133.                 throw new TypeError('option domain is invalid');
  134.             }
  135.     
  136.             str += '; Domain=' + opt.domain;
  137.         }
  138.     
  139.         if (opt.path) {
  140.             if (!fieldContentRegExp.test(opt.path)) {
  141.                 throw new TypeError('option path is invalid');
  142.             }
  143.     
  144.             str += '; Path=' + opt.path;
  145.         }
  146.     
  147.         if (opt.expires) {
  148.             var expires = opt.expires
  149.     
  150.             if (!isDate(expires) || isNaN(expires.valueOf())) {
  151.                 throw new TypeError('option expires is invalid');
  152.             }
  153.     
  154.             str += '; Expires=' + expires.toUTCString()
  155.         }
  156.     
  157.         if (opt.httpOnly) {
  158.             str += '; HttpOnly';
  159.         }
  160.     
  161.         if (opt.secure) {
  162.             str += '; Secure';
  163.         }
  164.     
  165.         if (opt.partitioned) {
  166.             str += '; Partitioned'
  167.         }
  168.     
  169.         if (opt.priority) {
  170.             var priority = typeof opt.priority === 'string'
  171.                 ? opt.priority.toLowerCase()
  172.                 : opt.priority
  173.     
  174.             switch (priority) {
  175.                 case 'low':
  176.                     str += '; Priority=Low'
  177.                     break
  178.                 case 'medium':
  179.                     str += '; Priority=Medium'
  180.                     break
  181.                 case 'high':
  182.                     str += '; Priority=High'
  183.                     break
  184.                 default:
  185.                     throw new TypeError('option priority is invalid')
  186.             }
  187.         }
  188.     
  189.         if (opt.sameSite) {
  190.             var sameSite = typeof opt.sameSite === 'string'
  191.                 ? opt.sameSite.toLowerCase() : opt.sameSite;
  192.     
  193.             switch (sameSite) {
  194.                 case true:
  195.                     str += '; SameSite=Strict';
  196.                     break;
  197.                 case 'lax':
  198.                     str += '; SameSite=Lax';
  199.                     break;
  200.                 case 'strict':
  201.                     str += '; SameSite=Strict';
  202.                     break;
  203.                 case 'none':
  204.                     str += '; SameSite=None';
  205.                     break;
  206.                 default:
  207.                     throw new TypeError('option sameSite is invalid');
  208.             }
  209.         }
  210.     
  211.         return str;
  212.     };
  213.     
  214.     /**
  215.      * URL-decode string value. Optimized to skip native call when no %.
  216.      *
  217.      * @param {string} str
  218.      * @returns {string}
  219.      */
  220.     
  221.     const decode = str => str.indexOf('%') !== -1 ? decodeURIComponent(str) : str;
  222.     
  223.     /**
  224.      * URL-encode value.
  225.      *
  226.      * @param {string} val
  227.      * @returns {string}
  228.      */
  229.     
  230.     const encode = val => encodeURIComponent(val);
  231.     
  232.     /**
  233.      * Determine if value is a Date.
  234.      *
  235.      * @param {*} val
  236.      * @private
  237.      */
  238.     
  239.     const isDate = val => __toString.call(val) === '[object Date]' || val instanceof Date;
  240.     
  241.     /**
  242.      * Try decoding a string using a decoding function.
  243.      *
  244.      * @param {string} str
  245.      * @param {function} decode
  246.      * @private
  247.      */
  248.     
  249.     const tryDecode = (str, decode) => {
  250.         try {
  251.             return decode(str);
  252.         } catch (e) {
  253.             return str;
  254.         }
  255.     };
  256.     
  257.     
  258.     
  259.     exports.parse = parse;
  260.     exports.serialize = serialize;
  261. }));