@micromag/data 0.3.508 → 0.3.509

package/es/index.js

@@ -6,8 +6,8 @@ import _callSuper from '@babel/runtime/helpers/callSuper';
 import _inherits from '@babel/runtime/helpers/inherits';
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { getJSON, getCSRFHeaders, postJSON } from '@folklore/fetch';
-import { stringify, parse } from 'query-string';
 import { generatePath } from '@folklore/routes';
+import queryString from 'query-string';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
@@ -28,10 +28,10 @@ var Base = /*#__PURE__*/function () {
     key: "requestGet",
     value: function requestGet(path) {
       var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      var queryString = query !== null ? stringify(query, {
+      var finalQueryString = query !== null ? queryString.stringify(query, {
         arrayFormat: 'bracket'
       }) : null;
-      return getJSON("".concat(this.getFullUrl(path)).concat(queryString !== null && queryString.length > 0 ? "?".concat(queryString) : ''), {
+      return getJSON("".concat(this.getFullUrl(path)).concat(finalQueryString !== null && finalQueryString.length > 0 ? "?".concat(finalQueryString) : ''), {
         credentials: 'include',
         headers: getCSRFHeaders()
       });
@@ -749,7 +749,7 @@ var useItems = function useItems(_ref) {
 
   // Query
   var query = useMemo(function () {
-    return _objectSpread({}, isString(pageQuery) ? parse(pageQuery || null, {
+    return _objectSpread({}, isString(pageQuery) ? queryString.parse(pageQuery || null, {
       arrayFormat: 'bracket'
     }) : pageQuery);
   }, [pageQuery]);

package/lib/index.js

@@ -8,11 +8,13 @@ var _callSuper = require('@babel/runtime/helpers/callSuper');
 var _inherits = require('@babel/runtime/helpers/inherits');
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var fetch = require('@folklore/fetch');
-var queryString = require('query-string');
 var pathToRegexp = require('path-to-regexp');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
-var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var _createForOfIteratorHelper = require('@babel/runtime/helpers/createForOfIteratorHelper');
+var _typeof = require('@babel/runtime/helpers/typeof');
 var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
 var isString = require('lodash/isString');
 var contexts = require('@micromag/core/contexts');
 
@@ -32,6 +34,579 @@ function generatePath(fullPath, data) {
   return fullUrlMatches !== null ? "".concat(fullUrlMatches[1]).concat(compiler(data)) : compiler(data);
 }
 
+var token = '%[a-f0-9]{2}';
+var singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');
+var multiMatcher = new RegExp('(' + token + ')+', 'gi');
+function decodeComponents(components, split) {
+  try {
+    // Try to decode the entire string first
+    return [decodeURIComponent(components.join(''))];
+  } catch (_unused) {
+    // Do nothing
+  }
+  if (components.length === 1) {
+    return components;
+  }
+  split = split || 1;
+
+  // Split the array in 2 parts
+  var left = components.slice(0, split);
+  var right = components.slice(split);
+  return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+function decode$1(input) {
+  try {
+    return decodeURIComponent(input);
+  } catch (_unused2) {
+    var tokens = input.match(singleMatcher) || [];
+    for (var i = 1; i < tokens.length; i++) {
+      input = decodeComponents(tokens, i).join('');
+      tokens = input.match(singleMatcher) || [];
+    }
+    return input;
+  }
+}
+function customDecodeURIComponent(input) {
+  // Keep track of all the replacements and prefill the map with the `BOM`
+  var replaceMap = {
+    '%FE%FF': "\uFFFD\uFFFD",
+    '%FF%FE': "\uFFFD\uFFFD"
+  };
+  var match = multiMatcher.exec(input);
+  while (match) {
+    try {
+      // Decode as big chunks as possible
+      replaceMap[match[0]] = decodeURIComponent(match[0]);
+    } catch (_unused3) {
+      var result = decode$1(match[0]);
+      if (result !== match[0]) {
+        replaceMap[match[0]] = result;
+      }
+    }
+    match = multiMatcher.exec(input);
+  }
+
+  // Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
+  replaceMap['%C2'] = "\uFFFD";
+  var entries = Object.keys(replaceMap);
+  for (var _i = 0, _entries = entries; _i < _entries.length; _i++) {
+    var key = _entries[_i];
+    // Replace all decoded components
+    input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+  }
+  return input;
+}
+function decodeUriComponent(encodedURI) {
+  if (typeof encodedURI !== 'string') {
+    throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + _typeof(encodedURI) + '`');
+  }
+  try {
+    // Try the built in decoder first
+    return decodeURIComponent(encodedURI);
+  } catch (_unused4) {
+    // Fallback to a more advanced decoder
+    return customDecodeURIComponent(encodedURI);
+  }
+}
+
+function splitOnFirst(string, separator) {
+  if (!(typeof string === 'string' && typeof separator === 'string')) {
+    throw new TypeError('Expected the arguments to be of type `string`');
+  }
+  if (string === '' || separator === '') {
+    return [];
+  }
+  var separatorIndex = string.indexOf(separator);
+  if (separatorIndex === -1) {
+    return [];
+  }
+  return [string.slice(0, separatorIndex), string.slice(separatorIndex + separator.length)];
+}
+
+function includeKeys(object, predicate) {
+  var result = {};
+  if (Array.isArray(predicate)) {
+    var _iterator = _createForOfIteratorHelper(predicate),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var key = _step.value;
+        var descriptor = Object.getOwnPropertyDescriptor(object, key);
+        if (descriptor !== null && descriptor !== void 0 && descriptor.enumerable) {
+          Object.defineProperty(result, key, descriptor);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  } else {
+    // `Reflect.ownKeys()` is required to retrieve symbol properties
+    var _iterator2 = _createForOfIteratorHelper(Reflect.ownKeys(object)),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _key = _step2.value;
+        var _descriptor = Object.getOwnPropertyDescriptor(object, _key);
+        if (_descriptor.enumerable) {
+          var value = object[_key];
+          if (predicate(_key, value, object)) {
+            Object.defineProperty(result, _key, _descriptor);
+          }
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+  return result;
+}
+
+var isNullOrUndefined = function isNullOrUndefined(value) {
+  return value === null || value === undefined;
+};
+
+// eslint-disable-next-line unicorn/prefer-code-point
+var strictUriEncode = function strictUriEncode(string) {
+  return encodeURIComponent(string).replaceAll(/[!'()*]/g, function (x) {
+    return "%".concat(x.charCodeAt(0).toString(16).toUpperCase());
+  });
+};
+var encodeFragmentIdentifier = Symbol('encodeFragmentIdentifier');
+function encoderForArrayFormat(options) {
+  switch (options.arrayFormat) {
+    case 'index':
+      {
+        return function (key) {
+          return function (result, value) {
+            var index = result.length;
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+            if (value === null) {
+              return [].concat(_toConsumableArray(result), [[encode(key, options), '[', index, ']'].join('')]);
+            }
+            return [].concat(_toConsumableArray(result), [[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')]);
+          };
+        };
+      }
+    case 'bracket':
+      {
+        return function (key) {
+          return function (result, value) {
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+            if (value === null) {
+              return [].concat(_toConsumableArray(result), [[encode(key, options), '[]'].join('')]);
+            }
+            return [].concat(_toConsumableArray(result), [[encode(key, options), '[]=', encode(value, options)].join('')]);
+          };
+        };
+      }
+    case 'colon-list-separator':
+      {
+        return function (key) {
+          return function (result, value) {
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+            if (value === null) {
+              return [].concat(_toConsumableArray(result), [[encode(key, options), ':list='].join('')]);
+            }
+            return [].concat(_toConsumableArray(result), [[encode(key, options), ':list=', encode(value, options)].join('')]);
+          };
+        };
+      }
+    case 'comma':
+    case 'separator':
+    case 'bracket-separator':
+      {
+        var keyValueSeparator = options.arrayFormat === 'bracket-separator' ? '[]=' : '=';
+        return function (key) {
+          return function (result, value) {
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+
+            // Translate null to an empty string so that it doesn't serialize as 'null'
+            value = value === null ? '' : value;
+            if (result.length === 0) {
+              return [[encode(key, options), keyValueSeparator, encode(value, options)].join('')];
+            }
+            return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+          };
+        };
+      }
+    default:
+      {
+        return function (key) {
+          return function (result, value) {
+            if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+              return result;
+            }
+            if (value === null) {
+              return [].concat(_toConsumableArray(result), [encode(key, options)]);
+            }
+            return [].concat(_toConsumableArray(result), [[encode(key, options), '=', encode(value, options)].join('')]);
+          };
+        };
+      }
+  }
+}
+function parserForArrayFormat(options) {
+  var result;
+  switch (options.arrayFormat) {
+    case 'index':
+      {
+        return function (key, value, accumulator) {
+          result = /\[(\d*)]$/.exec(key);
+          key = key.replace(/\[\d*]$/, '');
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === undefined) {
+            accumulator[key] = {};
+          }
+          accumulator[key][result[1]] = value;
+        };
+      }
+    case 'bracket':
+      {
+        return function (key, value, accumulator) {
+          result = /(\[])$/.exec(key);
+          key = key.replace(/\[]$/, '');
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === undefined) {
+            accumulator[key] = [value];
+            return;
+          }
+          accumulator[key] = [].concat(_toConsumableArray(accumulator[key]), [value]);
+        };
+      }
+    case 'colon-list-separator':
+      {
+        return function (key, value, accumulator) {
+          result = /(:list)$/.exec(key);
+          key = key.replace(/:list$/, '');
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === undefined) {
+            accumulator[key] = [value];
+            return;
+          }
+          accumulator[key] = [].concat(_toConsumableArray(accumulator[key]), [value]);
+        };
+      }
+    case 'comma':
+    case 'separator':
+      {
+        return function (key, value, accumulator) {
+          var isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);
+          var isEncodedArray = typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator);
+          value = isEncodedArray ? decode(value, options) : value;
+          var newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(function (item) {
+            return decode(item, options);
+          }) : value === null ? value : decode(value, options);
+          accumulator[key] = newValue;
+        };
+      }
+    case 'bracket-separator':
+      {
+        return function (key, value, accumulator) {
+          var isArray = /(\[])$/.test(key);
+          key = key.replace(/\[]$/, '');
+          if (!isArray) {
+            accumulator[key] = value ? decode(value, options) : value;
+            return;
+          }
+          var arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map(function (item) {
+            return decode(item, options);
+          });
+          if (accumulator[key] === undefined) {
+            accumulator[key] = arrayValue;
+            return;
+          }
+          accumulator[key] = [].concat(_toConsumableArray(accumulator[key]), _toConsumableArray(arrayValue));
+        };
+      }
+    default:
+      {
+        return function (key, value, accumulator) {
+          if (accumulator[key] === undefined) {
+            accumulator[key] = value;
+            return;
+          }
+          accumulator[key] = [].concat(_toConsumableArray([accumulator[key]].flat()), [value]);
+        };
+      }
+  }
+}
+function validateArrayFormatSeparator(value) {
+  if (typeof value !== 'string' || value.length !== 1) {
+    throw new TypeError('arrayFormatSeparator must be single character string');
+  }
+}
+function encode(value, options) {
+  if (options.encode) {
+    return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
+  }
+  return value;
+}
+function decode(value, options) {
+  if (options.decode) {
+    return decodeUriComponent(value);
+  }
+  return value;
+}
+function keysSorter(input) {
+  if (Array.isArray(input)) {
+    return input.sort();
+  }
+  if (_typeof(input) === 'object') {
+    return keysSorter(Object.keys(input)).sort(function (a, b) {
+      return Number(a) - Number(b);
+    }).map(function (key) {
+      return input[key];
+    });
+  }
+  return input;
+}
+function removeHash(input) {
+  var hashStart = input.indexOf('#');
+  if (hashStart !== -1) {
+    input = input.slice(0, hashStart);
+  }
+  return input;
+}
+function getHash(url) {
+  var hash = '';
+  var hashStart = url.indexOf('#');
+  if (hashStart !== -1) {
+    hash = url.slice(hashStart);
+  }
+  return hash;
+}
+function parseValue(value, options) {
+  if (options.parseNumbers && !Number.isNaN(Number(value)) && typeof value === 'string' && value.trim() !== '') {
+    value = Number(value);
+  } else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
+    value = value.toLowerCase() === 'true';
+  }
+  return value;
+}
+function extract(input) {
+  input = removeHash(input);
+  var queryStart = input.indexOf('?');
+  if (queryStart === -1) {
+    return '';
+  }
+  return input.slice(queryStart + 1);
+}
+function parse(query, options) {
+  options = _objectSpread({
+    decode: true,
+    sort: true,
+    arrayFormat: 'none',
+    arrayFormatSeparator: ',',
+    parseNumbers: false,
+    parseBooleans: false
+  }, options);
+  validateArrayFormatSeparator(options.arrayFormatSeparator);
+  var formatter = parserForArrayFormat(options);
+
+  // Create an object with no prototype
+  var returnValue = Object.create(null);
+  if (typeof query !== 'string') {
+    return returnValue;
+  }
+  query = query.trim().replace(/^[?#&]/, '');
+  if (!query) {
+    return returnValue;
+  }
+  var _iterator = _createForOfIteratorHelper(query.split('&')),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var parameter = _step.value;
+      if (parameter === '') {
+        continue;
+      }
+      var parameter_ = options.decode ? parameter.replaceAll('+', ' ') : parameter;
+      var _splitOnFirst = splitOnFirst(parameter_, '='),
+        _splitOnFirst2 = _slicedToArray(_splitOnFirst, 2),
+        _key = _splitOnFirst2[0],
+        _value = _splitOnFirst2[1];
+      if (_key === undefined) {
+        _key = parameter_;
+      }
+
+      // Missing `=` should be `null`:
+      // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+      _value = _value === undefined ? null : ['comma', 'separator', 'bracket-separator'].includes(options.arrayFormat) ? _value : decode(_value, options);
+      formatter(decode(_key, options), _value, returnValue);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  for (var _i = 0, _Object$entries = Object.entries(returnValue); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    if (_typeof(value) === 'object' && value !== null) {
+      for (var _i2 = 0, _Object$entries2 = Object.entries(value); _i2 < _Object$entries2.length; _i2++) {
+        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          key2 = _Object$entries2$_i[0],
+          value2 = _Object$entries2$_i[1];
+        value[key2] = parseValue(value2, options);
+      }
+    } else {
+      returnValue[key] = parseValue(value, options);
+    }
+  }
+  if (options.sort === false) {
+    return returnValue;
+  }
+
+  // TODO: Remove the use of `reduce`.
+  // eslint-disable-next-line unicorn/no-array-reduce
+  return (options.sort === true ? Object.keys(returnValue).sort() : Object.keys(returnValue).sort(options.sort)).reduce(function (result, key) {
+    var value = returnValue[key];
+    result[key] = Boolean(value) && _typeof(value) === 'object' && !Array.isArray(value) ? keysSorter(value) : value;
+    return result;
+  }, Object.create(null));
+}
+function stringify(object, options) {
+  if (!object) {
+    return '';
+  }
+  options = _objectSpread({
+    encode: true,
+    strict: true,
+    arrayFormat: 'none',
+    arrayFormatSeparator: ','
+  }, options);
+  validateArrayFormatSeparator(options.arrayFormatSeparator);
+  var shouldFilter = function shouldFilter(key) {
+    return options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === '';
+  };
+  var formatter = encoderForArrayFormat(options);
+  var objectCopy = {};
+  for (var _i3 = 0, _Object$entries3 = Object.entries(object); _i3 < _Object$entries3.length; _i3++) {
+    var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+      key = _Object$entries3$_i[0],
+      value = _Object$entries3$_i[1];
+    if (!shouldFilter(key)) {
+      objectCopy[key] = value;
+    }
+  }
+  var keys = Object.keys(objectCopy);
+  if (options.sort !== false) {
+    keys.sort(options.sort);
+  }
+  return keys.map(function (key) {
+    var value = object[key];
+    if (value === undefined) {
+      return '';
+    }
+    if (value === null) {
+      return encode(key, options);
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0 && options.arrayFormat === 'bracket-separator') {
+        return encode(key, options) + '[]';
+      }
+      return value.reduce(formatter(key), []).join('&');
+    }
+    return encode(key, options) + '=' + encode(value, options);
+  }).filter(function (x) {
+    return x.length > 0;
+  }).join('&');
+}
+function parseUrl(url, options) {
+  var _url_$split$, _url_;
+  options = _objectSpread({
+    decode: true
+  }, options);
+  var _splitOnFirst3 = splitOnFirst(url, '#'),
+    _splitOnFirst4 = _slicedToArray(_splitOnFirst3, 2),
+    url_ = _splitOnFirst4[0],
+    hash = _splitOnFirst4[1];
+  if (url_ === undefined) {
+    url_ = url;
+  }
+  return _objectSpread({
+    url: (_url_$split$ = (_url_ = url_) === null || _url_ === void 0 || (_url_ = _url_.split('?')) === null || _url_ === void 0 ? void 0 : _url_[0]) !== null && _url_$split$ !== void 0 ? _url_$split$ : '',
+    query: parse(extract(url), options)
+  }, options && options.parseFragmentIdentifier && hash ? {
+    fragmentIdentifier: decode(hash, options)
+  } : {});
+}
+function stringifyUrl(object, options) {
+  options = _objectSpread(_defineProperty({
+    encode: true,
+    strict: true
+  }, encodeFragmentIdentifier, true), options);
+  var url = removeHash(object.url).split('?')[0] || '';
+  var queryFromUrl = extract(object.url);
+  var query = _objectSpread(_objectSpread({}, parse(queryFromUrl, {
+    sort: false
+  })), object.query);
+  var queryString = stringify(query, options);
+  queryString && (queryString = "?".concat(queryString));
+  var hash = getHash(object.url);
+  if (typeof object.fragmentIdentifier === 'string') {
+    var urlObjectForFragmentEncode = new URL(url);
+    urlObjectForFragmentEncode.hash = object.fragmentIdentifier;
+    hash = options[encodeFragmentIdentifier] ? urlObjectForFragmentEncode.hash : "#".concat(object.fragmentIdentifier);
+  }
+  return "".concat(url).concat(queryString).concat(hash);
+}
+function pick(input, filter, options) {
+  options = _objectSpread(_defineProperty({
+    parseFragmentIdentifier: true
+  }, encodeFragmentIdentifier, false), options);
+  var _parseUrl = parseUrl(input, options),
+    url = _parseUrl.url,
+    query = _parseUrl.query,
+    fragmentIdentifier = _parseUrl.fragmentIdentifier;
+  return stringifyUrl({
+    url: url,
+    query: includeKeys(query, filter),
+    fragmentIdentifier: fragmentIdentifier
+  }, options);
+}
+function exclude(input, filter, options) {
+  var exclusionFilter = Array.isArray(filter) ? function (key) {
+    return !filter.includes(key);
+  } : function (key, value) {
+    return !filter(key, value);
+  };
+  return pick(input, exclusionFilter, options);
+}
+
+var queryString = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  exclude: exclude,
+  extract: extract,
+  parse: parse,
+  parseUrl: parseUrl,
+  pick: pick,
+  stringify: stringify,
+  stringifyUrl: stringifyUrl
+});
+
 var Base = /*#__PURE__*/function () {
   function Base() {
     var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
@@ -46,10 +621,10 @@ var Base = /*#__PURE__*/function () {
     key: "requestGet",
     value: function requestGet(path) {
       var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      var queryString$1 = query !== null ? queryString.stringify(query, {
+      var finalQueryString = query !== null ? queryString.stringify(query, {
         arrayFormat: 'bracket'
       }) : null;
-      return fetch.getJSON("".concat(this.getFullUrl(path)).concat(queryString$1 !== null && queryString$1.length > 0 ? "?".concat(queryString$1) : ''), {
+      return fetch.getJSON("".concat(this.getFullUrl(path)).concat(finalQueryString !== null && finalQueryString.length > 0 ? "?".concat(finalQueryString) : ''), {
         credentials: 'include',
         headers: fetch.getCSRFHeaders()
       });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@micromag/data",
-    "version": "0.3.508",
+    "version": "0.3.509",
     "private": false,
     "description": "",
     "keywords": [
@@ -60,14 +60,14 @@
         "@babel/runtime": "^7.13.10",
         "@folklore/fetch": "^0.1.17",
         "@folklore/routes": "^0.2.27",
-        "@micromag/core": "^0.3.508",
+        "@micromag/core": "^0.3.509",
         "lodash": "^4.17.21",
         "prop-types": "^15.7.2",
-        "query-string": "^6.13.7"
+        "query-string": "^9.0.0"
     },
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "9baca9a69d472a9bcdfd35d0ebcd833595492ba4"
+    "gitHead": "28ca6abf74ab585d218a4918b415b7d0564e5a09"
 }