https://lib-dem-registr.herokuapp.com/packages/url.js?hash=65c7ceae2dfa23e14ee3720cc57ab78ea70caf0d

163"web.url.js":function module(require){
164
165/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
166//                                                                                                                     //
167// node_modules/meteor/url/node_modules/core-js/modules/web.url.js                                                     //
168//                                                                                                                     //
169/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
170                                                                                                                       //
171'use strict';
172// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
173require('../modules/es.string.iterator');
174var $ = require('../internals/export');
175var DESCRIPTORS = require('../internals/descriptors');
176var USE_NATIVE_URL = require('../internals/native-url');
177var global = require('../internals/global');
178var defineProperties = require('../internals/object-define-properties');
179var redefine = require('../internals/redefine');
180var anInstance = require('../internals/an-instance');
181var has = require('../internals/has');
182var assign = require('../internals/object-assign');
183var arrayFrom = require('../internals/array-from');
184var codeAt = require('../internals/string-multibyte').codeAt;
185var toASCII = require('../internals/string-punycode-to-ascii');
186var setToStringTag = require('../internals/set-to-string-tag');
187var URLSearchParamsModule = require('../modules/web.url-search-params');
188var InternalStateModule = require('../internals/internal-state');
189
190var NativeURL = global.URL;
191var URLSearchParams = URLSearchParamsModule.URLSearchParams;
192var getInternalSearchParamsState = URLSearchParamsModule.getState;
193var setInternalState = InternalStateModule.set;
194var getInternalURLState = InternalStateModule.getterFor('URL');
195var floor = Math.floor;
196var pow = Math.pow;
197
198var INVALID_AUTHORITY = 'Invalid authority';
199var INVALID_SCHEME = 'Invalid scheme';
200var INVALID_HOST = 'Invalid host';
201var INVALID_PORT = 'Invalid port';
202
203var ALPHA = /[A-Za-z]/;
204// eslint-disable-next-line regexp/no-obscure-range -- safe
205var ALPHANUMERIC = /[\d+-.A-Za-z]/;
206var DIGIT = /\d/;
207var HEX_START = /^(0x|0X)/;
208var OCT = /^[0-7]+$/;
209var DEC = /^\d+$/;
210var HEX = /^[\dA-Fa-f]+$/;
211/* eslint-disable no-control-regex -- safe */
212var FORBIDDEN_HOST_CODE_POINT = /[\0\t\n\r #%/:?@[\\]]/;
213var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\0\t\n\r #/:?@[\\]]/;
214var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g;
215var TAB_AND_NEW_LINE = /[\t\n\r]/g;
216/* eslint-enable no-control-regex -- safe */
217var EOF;
218
219var parseHost = function (url, input) {
220  var result, codePoints, index;
221  if (input.charAt(0) == '[') {
222    if (input.charAt(input.length - 1) != ']') return INVALID_HOST;
223    result = parseIPv6(input.slice(1, -1));
224    if (!result) return INVALID_HOST;
225    url.host = result;
226  // opaque host
227  } else if (!isSpecial(url)) {
228    if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) return INVALID_HOST;
229    result = '';
230    codePoints = arrayFrom(input);
231    for (index = 0; index < codePoints.length; index++) {
232      result += percentEncode(codePoints[index], C0ControlPercentEncodeSet);
233    }
234    url.host = result;
235  } else {
236    input = toASCII(input);
237    if (FORBIDDEN_HOST_CODE_POINT.test(input)) return INVALID_HOST;
238    result = parseIPv4(input);
239    if (result === null) return INVALID_HOST;
240    url.host = result;
241  }
242};
243
244var parseIPv4 = function (input) {
245  var parts = input.split('.');
246  var partsLength, numbers, index, part, radix, number, ipv4;
247  if (parts.length && parts[parts.length - 1] == '') {
248    parts.pop();
249  }
250  partsLength = parts.length;
251  if (partsLength > 4) return input;
252  numbers = [];
253  for (index = 0; index < partsLength; index++) {
254    part = parts[index];
255    if (part == '') return input;
256    radix = 10;
257    if (part.length > 1 && part.charAt(0) == '0') {

258      radix = HEX_START.test(part) ? 16 : 8;
259      part = part.slice(radix == 8 ? 1 : 2);
260    }
261    if (part === '') {
262      number = 0;
263    } else {
264      if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part)) return input;
265      number = parseInt(part, radix);
266    }
267    numbers.push(number);
268  }
269  for (index = 0; index < partsLength; index++) {
270    number = numbers[index];
271    if (index == partsLength - 1) {
272      if (number >= pow(256, 5 - partsLength)) return null;
273    } else if (number > 255) return null;
274  }
275  ipv4 = numbers.pop();
276  for (index = 0; index < numbers.length; index++) {
277    ipv4 += numbers[index] * pow(256, 3 - index);
278  }
279  return ipv4;
280};
281
282// eslint-disable-next-line max-statements -- TODO
283var parseIPv6 = function (input) {
284  var address = [0, 0, 0, 0, 0, 0, 0, 0];
285  var pieceIndex = 0;
286  var compress = null;
287  var pointer = 0;
288  var value, length, numbersSeen, ipv4Piece, number, swaps, swap;
289
290  var char = function () {
291    return input.charAt(pointer);
292  };
293
294  if (char() == ':') {
295    if (input.charAt(1) != ':') return;
296    pointer += 2;
297    pieceIndex++;
298    compress = pieceIndex;
299  }
300  while (char()) {
301    if (pieceIndex == 8) return;
302    if (char() == ':') {
303      if (compress !== null) return;
304      pointer++;
305      pieceIndex++;
306      compress = pieceIndex;
307      continue;
308    }
309    value = length = 0;
310    while (length < 4 && HEX.test(char())) {
311      value = value * 16 + parseInt(char(), 16);
312      pointer++;
313      length++;
314    }
315    if (char() == '.') {
316      if (length == 0) return;
317      pointer -= length;
318      if (pieceIndex > 6) return;
319      numbersSeen = 0;
320      while (char()) {
321        ipv4Piece = null;
322        if (numbersSeen > 0) {
323          if (char() == '.' && numbersSeen < 4) pointer++;
324          else return;
325        }
326        if (!DIGIT.test(char())) return;
327        while (DIGIT.test(char())) {
328          number = parseInt(char(), 10);
329          if (ipv4Piece === null) ipv4Piece = number;
330          else if (ipv4Piece == 0) return;
331          else ipv4Piece = ipv4Piece * 10 + number;
332          if (ipv4Piece > 255) return;
333          pointer++;
334        }
335        address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;
336        numbersSeen++;
337        if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++;
338      }
339      if (numbersSeen != 4) return;
340      break;
341    } else if (char() == ':') {
342      pointer++;
343      if (!char()) return;
344    } else if (char()) return;
345    address[pieceIndex++] = value;
346  }
347  if (compress !== null) {
348    swaps = pieceIndex - compress;
349    pieceIndex = 7;
350    while (pieceIndex != 0 && swaps > 0) {
351      swap = address[pieceIndex];
352      address[pieceIndex--] = address[compress + swaps - 1];
353      address[compress + --swaps] = swap;
354    }
355  } else if (pieceIndex != 8) return;
356  return address;
357};
358
359var findLongestZeroSequence = function (ipv6) {
360  var maxIndex = null;
361  var maxLength = 1;
362  var currStart = null;
363  var currLength = 0;
364  var index = 0;
365  for (; index < 8; index++) {
366    if (ipv6[index] !== 0) {
367      if (currLength > maxLength) {
368        maxIndex = currStart;
369        maxLength = currLength;
370      }
371      currStart = null;
372      currLength = 0;
373    } else {
374      if (currStart === null) currStart = index;
375      ++currLength;
376    }
377  }
378  if (currLength > maxLength) {
379    maxIndex = currStart;
380    maxLength = currLength;
381  }
382  return maxIndex;
383};
384
385var serializeHost = function (host) {
386  var result, index, compress, ignore0;
387  // ipv4
388  if (typeof host == 'number') {
389    result = [];
390    for (index = 0; index < 4; index++) {
391      result.unshift(host % 256);
392      host = floor(host / 256);
393    } return result.join('.');
394  // ipv6
395  } else if (typeof host == 'object') {
396    result = '';
397    compress = findLongestZeroSequence(host);
398    for (index = 0; index < 8; index++) {
399      if (ignore0 && host[index] === 0) continue;
400      if (ignore0) ignore0 = false;
401      if (compress === index) {
402        result += index ? ':' : '::';
403        ignore0 = true;
404      } else {
405        result += host[index].toString(16);
406        if (index < 7) result += ':';
407      }
408    }
409    return '[' + result + ']';
410  } return host;
411};
412
413var C0ControlPercentEncodeSet = {};
414var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {
415  ' ': 1, '"': 1, '<': 1, '>': 1, '`': 1
416});
417var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {
418  '#': 1, '?': 1, '{': 1, '}': 1
419});
420var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {
421  '/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1
422});
423
424var percentEncode = function (char, set) {
425  var code = codeAt(char, 0);
426  return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char);
427};
428
429var specialSchemes = {
430  ftp: 21,
431  file: null,
432  http: 80,
433  https: 443,
434  ws: 80,
435  wss: 443
436};
437
438var isSpecial = function (url) {
439  return has(specialSchemes, url.scheme);
440};
441
442var includesCredentials = function (url) {
443  return url.username != '' || url.password != '';
444};
445
446var cannotHaveUsernamePasswordPort = function (url) {
447  return !url.host || url.cannotBeABaseURL || url.scheme == 'file';
448};
449
450var isWindowsDriveLetter = function (string, normalized) {
451  var second;
452  return string.length == 2 && ALPHA.test(string.charAt(0))
453    && ((second = string.charAt(1)) == ':' || (!normalized && second == '|'));
454};
455
456var startsWithWindowsDriveLetter = function (string) {
457  var third;
458  return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && (
459    string.length == 2 ||
460    ((third = string.charAt(2)) === '/' || third === '\\' || third === '?' || third === '#')
461  );
462};
463
464var shortenURLsPath = function (url) {
465  var path = url.path;
466  var pathSize = path.length;
467  if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) {
468    path.pop();
469  }
470};
471
472var isSingleDot = function (segment) {
473  return segment === '.' || segment.toLowerCase() === '%2e';
474};
475
476var isDoubleDot = function (segment) {
477  segment = segment.toLowerCase();
478  return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e';
479};
480
481// States:
482var SCHEME_START = {};
483var SCHEME = {};
484var NO_SCHEME = {};
485var SPECIAL_RELATIVE_OR_AUTHORITY = {};
486var PATH_OR_AUTHORITY = {};
487var RELATIVE = {};
488var RELATIVE_SLASH = {};
489var SPECIAL_AUTHORITY_SLASHES = {};
490var SPECIAL_AUTHORITY_IGNORE_SLASHES = {};
491var AUTHORITY = {};
492var HOST = {};
493var HOSTNAME = {};
494var PORT = {};
495var FILE = {};
496var FILE_SLASH = {};
497var FILE_HOST = {};
498var PATH_START = {};
499var PATH = {};
500var CANNOT_BE_A_BASE_URL_PATH = {};
501var QUERY = {};
502var FRAGMENT = {};
503
504// eslint-disable-next-line max-statements -- TODO
505var parseURL = function (url, input, stateOverride, base) {
506  var state = stateOverride || SCHEME_START;
507  var pointer = 0;
508  var buffer = '';
509  var seenAt = false;
510  var seenBracket = false;
511  var seenPasswordToken = false;
512  var codePoints, char, bufferCodePoints, failure;
513
514  if (!stateOverride) {
515    url.scheme = '';
516    url.username = '';
517    url.password = '';
518    url.host = null;
519    url.port = null;
520    url.path = [];
521    url.query = null;
522    url.fragment = null;
523    url.cannotBeABaseURL = false;
524    input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, '');
525  }
526
527  input = input.replace(TAB_AND_NEW_LINE, '');
528
529  codePoints = arrayFrom(input);
530
531  while (pointer <= codePoints.length) {
532    char = codePoints[pointer];
533    switch (state) {
534      case SCHEME_START:
535        if (char && ALPHA.test(char)) {
536          buffer += char.toLowerCase();
537          state = SCHEME;
538        } else if (!stateOverride) {
539          state = NO_SCHEME;
540          continue;
541        } else return INVALID_SCHEME;
542        break;
543
544      case SCHEME:
545        if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) {
546          buffer += char.toLowerCase();
547        } else if (char == ':') {
548          if (stateOverride && (
549            (isSpecial(url) != has(specialSchemes, buffer)) ||
550            (buffer == 'file' && (includesCredentials(url) || url.port !== null)) ||
551            (url.scheme == 'file' && !url.host)
552          )) return;
553          url.scheme = buffer;
554          if (stateOverride) {
555            if (isSpecial(url) && specialSchemes[url.scheme] == url.port) url.port = null;
556            return;
557          }
558          buffer = '';
559          if (url.scheme == 'file') {
560            state = FILE;
561          } else if (isSpecial(url) && base && base.scheme == url.scheme) {
562            state = SPECIAL_RELATIVE_OR_AUTHORITY;
563          } else if (isSpecial(url)) {
564            state = SPECIAL_AUTHORITY_SLASHES;
565          } else if (codePoints[pointer + 1] == '/') {
566            state = PATH_OR_AUTHORITY;
567            pointer++;
568          } else {
569            url.cannotBeABaseURL = true;
570            url.path.push('');
571            state = CANNOT_BE_A_BASE_URL_PATH;
572          }
573        } else if (!stateOverride) {
574          buffer = '';
575          state = NO_SCHEME;
576          pointer = 0;
577          continue;
578        } else return INVALID_SCHEME;
579        break;
580
581      case NO_SCHEME:
582        if (!base || (base.cannotBeABaseURL && char != '#')) return INVALID_SCHEME;
583        if (base.cannotBeABaseURL && char == '#') {
584          url.scheme = base.scheme;
585          url.path = base.path.slice();
586          url.query = base.query;
587          url.fragment = '';
588          url.cannotBeABaseURL = true;
589          state = FRAGMENT;
590          break;
591        }
592        state = base.scheme == 'file' ? FILE : RELATIVE;
593        continue;
594
595      case SPECIAL_RELATIVE_OR_AUTHORITY:
596        if (char == '/' && codePoints[pointer + 1] == '/') {
597          state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
598          pointer++;
599        } else {
600          state = RELATIVE;
601          continue;
602        } break;
603
604      case PATH_OR_AUTHORITY:
605        if (char == '/') {
606          state = AUTHORITY;
607          break;
608        } else {
609          state = PATH;
610          continue;
611        }
612
613      case RELATIVE:
614        url.scheme = base.scheme;
615        if (char == EOF) {
616          url.username = base.username;
617          url.password = base.password;
618          url.host = base.host;
619          url.port = base.port;
620          url.path = base.path.slice();
621          url.query = base.query;
622        } else if (char == '/' || (char == '\\' && isSpecial(url))) {
623          state = RELATIVE_SLASH;
624        } else if (char == '?') {
625          url.username = base.username;
626          url.password = base.password;
627          url.host = base.host;
628          url.port = base.port;
629          url.path = base.path.slice();
630          url.query = '';
631          state = QUERY;
632        } else if (char == '#') {
633          url.username = base.username;
634          url.password = base.password;
635          url.host = base.host;
636          url.port = base.port;
637          url.path = base.path.slice();
638          url.query = base.query;
639          url.fragment = '';
640          state = FRAGMENT;
641        } else {
642          url.username = base.username;
643          url.password = base.password;
644          url.host = base.host;
645          url.port = base.port;
646          url.path = base.path.slice();
647          url.path.pop();
648          state = PATH;
649          continue;
650        } break;
651
652      case RELATIVE_SLASH:
653        if (isSpecial(url) && (char == '/' || char == '\\')) {
654          state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
655        } else if (char == '/') {
656          state = AUTHORITY;
657        } else {
658          url.username = base.username;
659          url.password = base.password;
660          url.host = base.host;
661          url.port = base.port;
662          state = PATH;
663          continue;
664        } break;
665
666      case SPECIAL_AUTHORITY_SLASHES:
667        state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
668        if (char != '/' || buffer.charAt(pointer + 1) != '/') continue;
669        pointer++;
670        break;
671
672      case SPECIAL_AUTHORITY_IGNORE_SLASHES:
673        if (char != '/' && char != '\\') {
674          state = AUTHORITY;
675          continue;
676        } break;
677
678      case AUTHORITY:
679        if (char == '@') {
680          if (seenAt) buffer = '%40' + buffer;
681          seenAt = true;
682          bufferCodePoints = arrayFrom(buffer);
683          for (var i = 0; i < bufferCodePoints.length; i++) {
684            var codePoint = bufferCodePoints[i];
685            if (codePoint == ':' && !seenPasswordToken) {
686              seenPasswordToken = true;
687              continue;
688            }
689            var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet);
690            if (seenPasswordToken) url.password += encodedCodePoints;
691            else url.username += encodedCodePoints;
692          }
693          buffer = '';
694        } else if (
695          char == EOF || char == '/' || char == '?' || char == '#' ||
696          (char == '\\' && isSpecial(url))
697        ) {
698          if (seenAt && buffer == '') return INVALID_AUTHORITY;
699          pointer -= arrayFrom(buffer).length + 1;
700          buffer = '';
701          state = HOST;
702        } else buffer += char;
703        break;
704
705      case HOST:
706      case HOSTNAME:
707        if (stateOverride && url.scheme == 'file') {
708          state = FILE_HOST;
709          continue;
710        } else if (char == ':' && !seenBracket) {
711          if (buffer == '') return INVALID_HOST;
712          failure = parseHost(url, buffer);
713          if (failure) return failure;
714          buffer = '';
715          state = PORT;
716          if (stateOverride == HOSTNAME) return;
717        } else if (
718          char == EOF || char == '/' || char == '?' || char == '#' ||
719          (char == '\\' && isSpecial(url))
720        ) {
721          if (isSpecial(url) && buffer == '') return INVALID_HOST;
722          if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) return;
723          failure = parseHost(url, buffer);
724          if (failure) return failure;
725          buffer = '';
726          state = PATH_START;
727          if (stateOverride) return;
728          continue;
729        } else {
730          if (char == '[') seenBracket = true;
731          else if (char == ']') seenBracket = false;
732          buffer += char;
733        } break;
734
735      case PORT:
736        if (DIGIT.test(char)) {
737          buffer += char;
738        } else if (
739          char == EOF || char == '/' || char == '?' || char == '#' ||
740          (char == '\\' && isSpecial(url)) ||
741          stateOverride
742        ) {
743          if (buffer != '') {
744            var port = parseInt(buffer, 10);
745            if (port > 0xFFFF) return INVALID_PORT;
746            url.port = (isSpecial(url) && port === specialSchemes[url.scheme]) ? null : port;
747            buffer = '';
748          }
749          if (stateOverride) return;
750          state = PATH_START;
751          continue;
752        } else return INVALID_PORT;
753        break;
754
755      case FILE:
756        url.scheme = 'file';
757        if (char == '/' || char == '\\') state = FILE_SLASH;
758        else if (base && base.scheme == 'file') {
759          if (char == EOF) {
760            url.host = base.host;
761            url.path = base.path.slice();
762            url.query = base.query;
763          } else if (char == '?') {
764            url.host = base.host;
765            url.path = base.path.slice();
766            url.query = '';
767            state = QUERY;
768          } else if (char == '#') {
769            url.host = base.host;
770            url.path = base.path.slice();
771            url.query = base.query;
772            url.fragment = '';
773            state = FRAGMENT;
774          } else {
775            if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
776              url.host = base.host;
777              url.path = base.path.slice();
778              shortenURLsPath(url);
779            }
780            state = PATH;
781            continue;
782          }
783        } else {
784          state = PATH;
785          continue;
786        } break;
787
788      case FILE_SLASH:
789        if (char == '/' || char == '\\') {
790          state = FILE_HOST;
791          break;
792        }
793        if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
794          if (isWindowsDriveLetter(base.path[0], true)) url.path.push(base.path[0]);
795          else url.host = base.host;
796        }
797        state = PATH;
798        continue;
799
800      case FILE_HOST:
801        if (char == EOF || char == '/' || char == '\\' || char == '?' || char == '#') {
802          if (!stateOverride && isWindowsDriveLetter(buffer)) {
803            state = PATH;
804          } else if (buffer == '') {
805            url.host = '';
806            if (stateOverride) return;
807            state = PATH_START;
808          } else {
809            failure = parseHost(url, buffer);
810            if (failure) return failure;
811            if (url.host == 'localhost') url.host = '';
812            if (stateOverride) return;
813            buffer = '';
814            state = PATH_START;
815          } continue;
816        } else buffer += char;
817        break;
818
819      case PATH_START:
820        if (isSpecial(url)) {
821          state = PATH;
822          if (char != '/' && char != '\\') continue;
823        } else if (!stateOverride && char == '?') {
824          url.query = '';
825          state = QUERY;
826        } else if (!stateOverride && char == '#') {
827          url.fragment = '';
828          state = FRAGMENT;
829        } else if (char != EOF) {
830          state = PATH;
831          if (char != '/') continue;
832        } break;
833
834      case PATH:
835        if (
836          char == EOF || char == '/' ||
837          (char == '\\' && isSpecial(url)) ||
838          (!stateOverride && (char == '?' || char == '#'))
839        ) {
840          if (isDoubleDot(buffer)) {
841            shortenURLsPath(url);
842            if (char != '/' && !(char == '\\' && isSpecial(url))) {
843              url.path.push('');
844            }
845          } else if (isSingleDot(buffer)) {
846            if (char != '/' && !(char == '\\' && isSpecial(url))) {
847              url.path.push('');
848            }
849          } else {
850            if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {
851              if (url.host) url.host = '';
852              buffer = buffer.charAt(0) + ':'; // normalize windows drive letter
853            }
854            url.path.push(buffer);
855          }
856          buffer = '';
857          if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) {
858            while (url.path.length > 1 && url.path[0] === '') {
859              url.path.shift();
860            }
861          }
862          if (char == '?') {
863            url.query = '';
864            state = QUERY;
865          } else if (char == '#') {
866            url.fragment = '';
867            state = FRAGMENT;
868          }
869        } else {
870          buffer += percentEncode(char, pathPercentEncodeSet);
871        } break;
872
873      case CANNOT_BE_A_BASE_URL_PATH:
874        if (char == '?') {
875          url.query = '';
876          state = QUERY;
877        } else if (char == '#') {
878          url.fragment = '';
879          state = FRAGMENT;
880        } else if (char != EOF) {
881          url.path[0] += percentEncode(char, C0ControlPercentEncodeSet);
882        } break;
883
884      case QUERY:
885        if (!stateOverride && char == '#') {
886          url.fragment = '';
887          state = FRAGMENT;
888        } else if (char != EOF) {
889          if (char == "'" && isSpecial(url)) url.query += '%27';
890          else if (char == '#') url.query += '%23';
891          else url.query += percentEncode(char, C0ControlPercentEncodeSet);
892        } break;
893
894      case FRAGMENT:
895        if (char != EOF) url.fragment += percentEncode(char, fragmentPercentEncodeSet);
896        break;
897    }
898
899    pointer++;
900  }
901};
902
903// `URL` constructor
904// https://url.spec.whatwg.org/#url-class
905var URLConstructor = function URL(url /* , base */) {
906  var that = anInstance(this, URLConstructor, 'URL');
907  var base = arguments.length > 1 ? arguments[1] : undefined;
908  var urlString = String(url);
909  var state = setInternalState(that, { type: 'URL' });
910  var baseState, failure;
911  if (base !== undefined) {
912    if (base instanceof URLConstructor) baseState = getInternalURLState(base);
913    else {
914      failure = parseURL(baseState = {}, String(base));
915      if (failure) throw TypeError(failure);
916    }
917  }
918  failure = parseURL(state, urlString, null, baseState);
919  if (failure) throw TypeError(failure);
920  var searchParams = state.searchParams = new URLSearchParams();
921  var searchParamsState = getInternalSearchParamsState(searchParams);
922  searchParamsState.updateSearchParams(state.query);
923  searchParamsState.updateURL = function () {
924    state.query = String(searchParams) || null;
925  };
926  if (!DESCRIPTORS) {
927    that.href = serializeURL.call(that);
928    that.origin = getOrigin.call(that);
929    that.protocol = getProtocol.call(that);
930    that.username = getUsername.call(that);
931    that.password = getPassword.call(that);
932    that.host = getHost.call(that);
933    that.hostname = getHostname.call(that);
934    that.port = getPort.call(that);
935    that.pathname = getPathname.call(that);
936    that.search = getSearch.call(that);
937    that.searchParams = getSearchParams.call(that);
938    that.hash = getHash.call(that);
939  }
940};
941
942var URLPrototype = URLConstructor.prototype;
943
944var serializeURL = function () {
945  var url = getInternalURLState(this);
946  var scheme = url.scheme;
947  var username = url.username;
948  var password = url.password;
949  var host = url.host;
950  var port = url.port;
951  var path = url.path;
952  var query = url.query;
953  var fragment = url.fragment;
954  var output = scheme + ':';
955  if (host !== null) {
956    output += '//';
957    if (includesCredentials(url)) {
958      output += username + (password ? ':' + password : '') + '@';
959    }
960    output += serializeHost(host);
961    if (port !== null) output += ':' + port;
962  } else if (scheme == 'file') output += '//';
963  output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
964  if (query !== null) output += '?' + query;
965  if (fragment !== null) output += '#' + fragment;
966  return output;
967};
968
969var getOrigin = function () {
970  var url = getInternalURLState(this);
971  var scheme = url.scheme;
972  var port = url.port;
973  if (scheme == 'blob') try {
974    return new URLConstructor

974(scheme.path[0]).origin;
975  } catch (error) {
976    return 'null';
977  }
978  if (scheme == 'file' || !isSpecial(url)) return 'null';
979  return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : '');
980};
981
982var getProtocol = function () {
983  return getInternalURLState(this).scheme + ':';
984};
985
986var getUsername = function () {
987  return getInternalURLState(this).username;
988};
989
990var getPassword = function () {
991  return getInternalURLState(this).password;
992};
993
994var getHost = function () {
995  var url = getInternalURLState(this);
996  var host = url.host;
997  var port = url.port;
998  return host === null ? ''
999    : port === null ? serializeHost(host)
1000    : serializeHost(host) + ':' + port;
1001};
1002
1003var getHostname = function () {
1004  var host = getInternalURLState(this).host;
1005  return host === null ? '' : serializeHost(host);
1006};
1007
1008var getPort = function () {
1009  var port = getInternalURLState(this).port;
1010  return port === null ? '' : String(port);
1011};
1012
1013var getPathname = function () {
1014  var url = getInternalURLState(this);
1015  var path = url.path;
1016  return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
1017};
1018
1019var getSearch = function () {
1020  var query = getInternalURLState(this).query;
1021  return query ? '?' + query : '';
1022};
1023
1024var getSearchParams = function () {
1025  return getInternalURLState(this).searchParams;
1026};
1027
1028var getHash = function () {
1029  var fragment = getInternalURLState(this).fragment;
1030  return fragment ? '#' + fragment : '';
1031};
1032
1033var accessorDescriptor = function (getter, setter) {
1034  return { get: getter, set: setter, configurable: true, enumerable: true };
1035};
1036
1037if (DESCRIPTORS) {
1038  defineProperties(URLPrototype, {
1039    // `URL.prototype.href` accessors pair
1040    // https://url.spec.whatwg.org/#dom-url-href
1041    href: accessorDescriptor(serializeURL, function (href) {
1042      var url = getInternalURLState(this);
1043      var urlString = String(href);
1044      var failure = parseURL(url, urlString);
1045      if (failure) throw TypeError(failure);
1046      getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
1047    }),
1048    // `URL.prototype.origin` getter
1049    // https://url.spec.whatwg.org/#dom-url-origin
1050    origin: accessorDescriptor(getOrigin),
1051    // `URL.prototype.protocol` accessors pair
1052    // https://url.spec.whatwg.org/#dom-url-protocol
1053    protocol: accessorDescriptor(getProtocol, function (protocol) {
1054      var url = getInternalURLState(this);
1055      parseURL(url, String(protocol) + ':', SCHEME_START);
1056    }),
1057    // `URL.prototype.username` accessors pair
1058    // https://url.spec.whatwg.org/#dom-url-username
1059    username: accessorDescriptor(getUsername, function (username) {
1060      var url = getInternalURLState(this);
1061      var codePoints = arrayFrom(String(username));
1062      if (cannotHaveUsernamePasswordPort(url)) return;
1063      url.username = '';
1064      for (var i = 0; i < codePoints.length; i++) {
1065        url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet);
1066      }
1067    }),
1068    // `URL.prototype.password` accessors pair
1069    // https://url.spec.whatwg.org/#dom-url-password
1070    password: accessorDescriptor(getPassword, function (password) {
1071      var url = getInternalURLState(this);
1072      var codePoints = arrayFrom(String(password));
1073      if (cannotHaveUsernamePasswordPort(url)) return;
1074      url.password = '';
1075      for (var i = 0; i < codePoints.length; i++) {
1076        url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet);
1077      }
1078    }),
1079    // `URL.prototype.host` accessors pair
1080    // https://url.spec.whatwg.org/#dom-url-host
1081    host: accessorDescriptor(getHost, function (host) {
1082      var url = getInternalURLState(this);
1083      if (url.cannotBeABaseURL) return;
1084      parseURL(url, String(host), HOST);
1085    }),
1086    // `URL.prototype.hostname` accessors pair
1087    // https://url.spec.whatwg.org/#dom-url-hostname
1088    hostname: accessorDescriptor(getHostname, function (hostname) {
1089      var url = getInternalURLState(this);
1090      if (url.cannotBeABaseURL) return;
1091      parseURL(url, String(hostname), HOSTNAME);
1092    }),
1093    // `URL.prototype.port` accessors pair
1094    // https://url.spec.whatwg.org/#dom-url-port
1095    port: accessorDescriptor(getPort, function (port) {
1096      var url = getInternalURLState(this);
1097      if (cannotHaveUsernamePasswordPort(url)) return;
1098      port = String(port);
1099      if (port == '') url.port = null;
1100      else parseURL(url, port, PORT);
1101    }),
1102    // `URL.prototype.pathname` accessors pair
1103    // https://url.spec.whatwg.org/#dom-url-pathname
1104    pathname: accessorDescriptor(getPathname, function (pathname) {
1105      var url = getInternalURLState(this);
1106      if (url.cannotBeABaseURL) return;
1107      url.path = [];
1108      parseURL(url, pathname + '', PATH_START);
1109    }),
1110    // `URL.prototype.search` accessors pair
1111    // https://url.spec.whatwg.org/#dom-url-search
1112    search: accessorDescriptor(getSearch, function (search) {
1113      var url = getInternalURLState(this);
1114      search = String(search);
1115      if (search == '') {
1116        url.query = null;
1117      } else {
1118        if ('?' == search.charAt(0)) search = search.slice(1);
1119        url.query = '';
1120        parseURL(url, search, QUERY);
1121      }
1122      getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
1123    }),
1124    // `URL.prototype.searchParams` getter
1125    // https://url.spec.whatwg.org/#dom-url-searchparams
1126    searchParams: accessorDescriptor(getSearchParams),
1127    // `URL.prototype.hash` accessors pair
1128    // https://url.spec.whatwg.org/#dom-url-hash
1129    hash: accessorDescriptor(getHash, function (hash) {
1130      var url = getInternalURLState(this);
1131      hash = String(hash);
1132      if (hash == '') {
1133        url.fragment = null;
1134        return;
1135      }
1136      if ('#' == hash.charAt(0)) hash = hash.slice(1);
1137      url.fragment = '';
1138      parseURL(url, hash, FRAGMENT);
1139    })
1140  });
1141}
1142
1143// `URL.prototype.toJSON` method
1144// https://url.spec.whatwg.org/#dom-url-tojson
1145redefine(URLPrototype, 'toJSON', function toJSON() {
1146  return serializeURL.call(this);
1147}, { enumerable: true });
1148
1149// `URL.prototype.toString` method
1150// https://url.spec.whatwg.org/#URL-stringification-behavior
1151redefine(URLPrototype, 'toString', function toString() {
1152  return serializeURL.call(this);
1153}, { enumerable: true });
1154
1155if (NativeURL) {
1156  var nativeCreateObjectURL = NativeURL.createObjectURL;
1157  var nativeRevokeObjectURL = NativeURL.revokeObjectURL;
1158  // `URL.createObjectURL` method
1159  // https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
1160  // eslint-disable-next-line no-unused-vars

1180"es.string.iterator.js":function module(require){
1181
1182/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1183//                                                                                                                     //
1184// node_modules/meteor/url/node_modules/core-js/modules/es.string.iterator.js                                          //
1185//                                                                                                                     //
1186/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1187                                                                                                                       //
1188'use strict';
1189var charAt = require('../internals/string-multibyte').charAt;
1190var InternalStateModule = require('../internals/internal-state');
1191var defineIterator = require('../internals/define-iterator');
1192
1193var STRING_ITERATOR = 'String Iterator';
1194var setInternalState = InternalStateModule.set;
1195var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
1196
1197// `String.prototype[@@iterator]` method
1198// https://tc39.es/ecma262/#sec-string.prototype-@@iterator
1199defineIterator(String, 'String', function (iterated) {
1200  setInternalState(this, {
1201    type: STRING_ITERATOR,
1202    string: String(iterated),
1203    index: 0
1204  });
1205// `%StringIteratorPrototype%.next` method
1206// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next
1207}, function next() {
1208  var state = getInternalState(this);
1209  var string = state.string;
1210  var index = state.index;
1211  var point;
1212  if (index >= string.length) return { value: undefined, done: true };
1213  point = charAt(string, index);
1214  state.index += point.length;
1215  return { value: point, done: false };
1216});
1217
1218/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1219
1220},

1249);
1250
1251var $fetch = getBuiltIn('fetch');
1252var Headers = getBuiltIn('Headers');
1253var ITERATOR = wellKnownSymbol('iterator');
1254var URL_SEARCH_PARAMS = 'URLSearchParams';
1255var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
1256var setInternalState = InternalStateModule.set;
1257var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
1258var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
1259
1260var plus = /\+/g;
1261var sequences = Array(4);
1262
1263var percentSequence = function (bytes) {
1264  return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
1265};
1266
1267var percentDecode = function (sequence) {
1268  try {
1269    return decodeURIComponent(sequence);
1270  } catch (error) {
1271    return sequence;
1272  }
1273};
1274
1275var deserialize = function (it) {
1276  var result = it.replace(plus, ' ');
1277  var bytes = 4;
1278  try {
1279    return decodeURIComponent(result);
1280  } catch (error) {
1281    while (bytes) {
1282      result = result.replace(percentSequence(bytes--), percentDecode);
1283    }
1284    return result;
1285  }
1286};
1287
1288var find = /[!'()~]|%20/g;
1289
1290var replace = {
1291  '!': '%21',
1292  "'": '%27',
1293  '(': '%28',
1294  ')': '%29',
1295  '~': '%7E',
1296  '%20': '+'
1297};
1298
1299var replacer = function (match) {
1300  return replace[match];
1301};
1302
1303var serialize = function (it) {
1304  return encodeURIComponent(it).replace(find, replacer);
1305};
1306
1307var parseSearchParams = function (result, query) {
1308  if (query) {
1309    var attributes = query.split('&');
1310    var index = 0;
1311    var attribute, entry;
1312    while (index < attributes.length) {
1313      attribute = attributes[index++];
1314      if (attribute.length) {
1315        entry = attribute.split('=');
1316        result.push({
1317          key: deserialize(entry.shift()),
1318          value: deserialize(entry.join('='))
1319        });
1320      }
1321    }
1322  }
1323};
1324
1325var updateSearchParams = function (query) {
1326  this.entries.length = 0;
1327  parseSearchParams(this.entries, query);
1328};
1329
1330var validateArgumentsLength = function (passed, required) {
1331  if (passed < required) throw TypeError('Not enough arguments');
1332};
1333
1334var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
1335  setInternalState(this, {
1336    type: URL_SEARCH_PARAMS_ITERATOR,
1337    iterator: getIterator(getInternalParamsState(params).entries),
1338    kind: kind
1339  });
1340}, 'Iterator', function next() {
1341  var state = getInternalIteratorState(this);
1342  var kind = state.kind;
1343  var step = state.iterator.next();
1344  var entry = step.value;
1345  if (!step.done) {
1346    step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value];
1347  } return step;
1348});
1349
1350// `URLSearchParams` constructor
1351// https://url.spec.whatwg.org/#interface-urlsearchparams
1352var URLSearchParamsConstructor = function URLSearchParams(/* init */) {
1353  anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS);
1354  var init = arguments.length > 0 ? arguments[0] : undefined;
1355  var that = this;
1356  var entries = [];
1357  var iteratorMethod, iterator, next, step, entryIterator, entryNext, first, second, key;
1358
1359  setInternalState(that, {
1360    type: URL_SEARCH_PARAMS,
1361    entries: entries,
1362    updateURL: function () { /* empty */ },
1363    updateSearchParams: updateSearchParams
1364  });
1365
1366  if (init !== undefined) {
1367    if (isObject(init)) {
1368      iteratorMethod = getIteratorMethod(init);
1369      if (typeof iteratorMethod === 'function') {
1370        iterator = iteratorMethod.call(init);
1371        next = iterator.next;
1372        while (!(step = next.call(iterator)).done) {
1373          entryIterator = getIterator(anObject(step.value));
1374          entryNext = entryIterator.next;
1375          if (
1376            (first = entryNext.call(entryIterator)).done ||
1377            (second = entryNext.call(entryIterator)).done ||
1378            !entryNext.call(entryIterator).done
1379          ) throw TypeError('Expected sequence with length 2');
1380          entries.push({ key: first.value + '', value: second.value + '' });
1381        }
1382      } else for (key in init) if (hasOwn(init, key)) entries.push({ key: key, value: init[key] + '' });
1383    } else {
1384      parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + '');
1385    }
1386  }
1387};
1388
1389var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
1390
1391redefineAll(URLSearchParamsPrototype, {
1392  // `URLSearchParams.prototype.append` method
1393  // https://url.spec.whatwg.org/#dom-urlsearchparams-append
1394  append: function append(name, value) {
1395    validateArgumentsLength(arguments.length, 2);
1396    var state = getInternalParamsState(this);
1397    state.entries.push({ key: name + '', value: value + '' });
1398    state.updateURL();
1399  },
1400  // `URLSearchParams.prototype.delete` method
1401  // https://url.spec.whatwg.org/#dom-urlsearchparams-delete
1402  'delete': function (name) {
1403    validateArgumentsLength(arguments.length, 1);
1404    var state = getInternalParamsState(this);
1405    var entries = state.entries;
1406    var key = name + '';
1407    var index = 0;
1408    while (index < entries.length) {
1409      if (entries[index].key === key) entries.splice(index, 1);
1410      else index++;
1411    }
1412    state.updateURL();
1413  },
1414  // `URLSearchParams.prototype.get` method
1415  // https://url.spec.whatwg.org/#dom-urlsearchparams-get
1416  get: function get(name) {
1417    validateArgumentsLength(arguments.length, 1);
1418    var entries = getInternalParamsState(this).entries;
1419    var key = name + '';
1420    var index = 0;
1421    for (; index < entries.length; index++) {
1422      if (entries[index].key === key) return entries[index].value;
1423    }
1424    return null;
1425  },
1426  // `URLSearchParams.prototype.getAll` method
1427  // https://url.spec.whatwg.org/#dom-urlsearchparams-getall
1428  getAll: function getAll(name) {
1429    validateArgumentsLength(arguments.length, 1);
1430    var entries = getInternalParamsState(this).entries;
1431    var key = name + '';
1432    var result = [];
1433    var index = 0;
1434    for (; index < entries.length; index++) {
1435      if (entries[index].key === key) result.push(entries[index].value);
1436    }
1437    return result;
1438  },
1439  // `URLSearchParams.prototype.has` method
1440  // https://url.spec.whatwg.org/#dom-urlsearchparams-has
1441  has: function has(name) {
1442    validateArgumentsLength(arguments.length, 1);
1443    var entries = getInternalParamsState(this).entries;
1444    var key = name + '';
1445    var index = 0;
1446    while (index < entries.length) {
1447      if (entries[index++].key === key) return true;
1448    }
1449    return false;
1450  },
1451  // `URLSearchParams.prototype.set` method
1452  // https://url.spec.whatwg.org/#dom-urlsearchparams-set
1453  set: function set(name, value) {
1454    validateArgumentsLength(arguments.length, 1);
1455    var state = getInternalParamsState(this);
1456    var entries = state.entries;
1457    var found = false;
1458    var key = name + '';
1459    var val = value + '';
1460    var index = 0;
1461    var entry;
1462    for (; index < entries.length; index++) {
1463      entry = entries[index];
1464      if (entry.key === key) {
1465        if (found) entries.splice(index--, 1);
1466        else {
1467          found = true;
1468          entry.value = val;
1469        }
1470      }
1471    }
1472    if (!found) entries.push({ key: key, value: val });
1473    state.updateURL();
1474  },
1475  // `URLSearchParams.prototype.sort` method
1476  // https://url.spec.whatwg.org/#dom-urlsearchparams-sort
1477  sort: function sort() {
1478    var state = getInternalParamsState(this);
1479    var entries = state.entries;
1480    // Array#sort is not stable in some engines
1481    var slice = entries.slice();
1482    var entry, entriesIndex, sliceIndex;
1483    entries.length = 0;
1484    for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) {
1485      entry = slice[sliceIndex];
1486      for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) {
1487        if (entries[entriesIndex].key > entry.key) {
1488          entries.splice(entriesIndex, 0, entry);
1489          break;
1490        }
1491      }
1492      if (entriesIndex === sliceIndex) entries.push(entry);
1493    }
1494    state.updateURL();
1495  },
1496  // `URLSearchParams.prototype.forEach` method
1497  forEach: function forEach(callback /* , thisArg */) {
1498    var entries = getInternalParamsState(this).entries;
1499    var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined, 3);
1500    var index = 0;
1501    var entry;
1502    while (index < entries.length) {
1503      entry = entries[index++];
1504      boundFunction(entry.value, entry.key, this);
1505    }
1506  },
1507  // `URLSearchParams.prototype.keys` method
1508  keys: function keys() {
1509    return new URLSearchParamsIterator(this, 'keys');
1510  },
1511  // `URLSearchParams.prototype.values` method
1512  values: function values() {
1513    return new URLSearchParamsIterator(this, 'values');
1514  },
1515  // `URLSearchParams.prototype.entries` method
1516  entries: function entries() {
1517    return new URLSearchParamsIterator(this, 'entries');
1518  }
1519}, { enumerable: true });
1520
1521// `URLSearchParams.prototype[@@iterator]` method
1522redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries);
1523
1524// `URLSearchParams.prototype.toString` method
1525// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
1526redefine(URLSearchParamsPrototype, 'toString', function toString() {
1527  var entries = getInternalParamsState(this).entries;
1528  var result = [];
1529  var index = 0;
1530  var entry;
1531  while (index < entries.length) {
1532    entry = entries[index++];
1533    result.push(serialize(entry.key) + '=' + serialize(entry.value));
1534  } return result.join('&');
1535}, { enumerable: true });
1536
1537setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
1538
1539$({ global: true, forced: !USE_NATIVE_URL }, {
1540  URLSearchParams: URLSearchParamsConstructor
1541});
1542
1543// Wrap `fetch` for correct work with polyfilled `URLSearchParams`
1544// https://github.com/zloirock/core-js/issues/674
1545if (!USE_NATIVE_URL && typeof $fetch == 'function' && typeof Headers == 'function') {
1546  $({ global: true, enumerable: true, forced: true }, {
1547    fetch: function fetch(input /* , init */) {
1548      var args = [input];
1549      var init, body, headers;
1550      if (arguments.length > 1) {
1551        init = arguments[1];
1552        if (isObject(init)) {
1553          body = init.body;
1554          if (classof(body) === URL_SEARCH_PARAMS) {
1555            headers = init.headers ? new Headers(init.headers) : new Headers();
1556            if (!headers.has('content-type')) {
1557              headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
1558            }
1559            init = create(init, {
1560              body: createPropertyDescriptor(0, String(body)),
1561              headers: createPropertyDescriptor(0, headers)
1562            });
1563          }
1564        }
1565        args.push(init);
1566      } return $fetch.apply(this, args);
1567    }
1568  });
1569}
1570
1571module.exports = {
1572  URLSearchParams: URLSearchParamsConstructor,
1573  getState: getInternalParamsState
1574};
1575

1578"es.array.iterator.js":function module(require,exports,module){
1579
1580/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1581//                                                                                                                     //
1582// node_modules/meteor/url/node_modules/core-js/modules/es.array.iterator.js                                           //
1583//                                                                                                                     //
1584/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1585                                                                                                                       //
1586'use strict';
1587var toIndexedObject = require('../internals/to-indexed-object');
1588var addToUnscopables = require('../internals/add-to-unscopables');
1589var Iterators = require('../internals/iterators');
1590var InternalStateModule = require('../internals/internal-state');
1591var defineIterator = require('../internals/define-iterator');
1592
1593var ARRAY_ITERATOR = 'Array Iterator';
1594var setInternalState = InternalStateModule.set;
1595var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
1596
1597// `Array.prototype.entries` method
1598// https://tc39.es/ecma262/#sec-array.prototype.entries
1599// `Array.prototype.keys` method
1600// https://tc39.es/ecma262/#sec-array.prototype.keys
1601// `Array.prototype.values` method
1602// https://tc39.es/ecma262/#sec-array.prototype.values
1603// `Array.prototype[@@iterator]` method
1604// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
1605// `CreateArrayIterator` internal method
1606// https://tc39.es/ecma262/#sec-createarrayiterator
1607module.exports = defineIterator(Array, 'Array', function (iterated, kind) {
1608  setInternalState(this, {
1609    type: ARRAY_ITERATOR,
1610    target: toIndexedObject(iterated), // target
1611    index: 0,                          // next index
1612    kind: kind                         // kind
1613  });
1614// `%ArrayIteratorPrototype%.next` method
1615// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
1616}, function () {
1617  var state = getInternalState(this);
1618  var target = state.target;
1619  var kind = state.kind;
1620  var index = state.index++;
1621  if (!target || index >= target.length) {
1622    state.target = undefined;
1623    return { value: undefined, done: true };
1624  }
1625  if (kind == 'keys') return { value: index, done: false };
1626  if (kind == 'values') return { value: target[index], done: false };
1627  return { value: [index, target[index]], done: false };
1628}, 'values');
1629
1630// argumentsList[@@iterator] is %ArrayProto_values%
1631// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
1632// https://tc39.es/ecma262/#sec-createmappedargumentsobject
1633Iterators.Arguments = Iterators.Array;
1634
1635// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1636addToUnscopables('keys');
1637addToUnscopables('values');
1638addToUnscopables('entries');
1639
1640/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1641
1642},

1663"string-multibyte.js":function module(require,exports,module){
1664
1665/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1666//                                                                                                                     //
1667// node_modules/meteor/url/node_modules/core-js/internals/string-multibyte.js                                          //
1668//                                                                                                                     //
1669/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1670                                                                                                                       //
1671var toInteger = require('../internals/to-integer');
1672var requireObjectCoercible = require('../internals/require-object-coercible');
1673
1674// `String.prototype.{ codePointAt, at }` methods implementation
1675var createMethod = function (CONVERT_TO_STRING) {
1676  return function ($this, pos) {
1677    var S = String(requireObjectCoercible($this));
1678    var position = toInteger(pos);
1679    var size = S.length;
1680    var first, second;
1681    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
1682    first = S.charCodeAt(position);
1683    return first < 0xD800 || first > 0xDBFF || position + 1 === size
1684      || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF
1685        ? CONVERT_TO_STRING ? S.charAt(position) : first
1686        : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
1687  };
1688};
1689
1690module.exports = {
1691  // `String.prototype.codePointAt` method
1692  // https://tc39.es/ecma262/#sec-string.prototype.codepointat
1693  codeAt: createMethod(false),
1694  // `String.prototype.at` method
1695  // https://github.com/mathiasbynens/String.prototype.at
1696  charAt: createMethod(true)
1697};
1698
1699/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1700
1701},

1737"internal-state.js":function module(require,exports,module){
1738
1739/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1740//                                                                                                                     //
1741// node_modules/meteor/url/node_modules/core-js/internals/internal-state.js                                            //
1742//                                                                                                                     //
1743/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1744                                                                                                                       //
1745var NATIVE_WEAK_MAP = require('../internals/native-weak-map');
1746var global = require('../internals/global');
1747var isObject = require('../internals/is-object');
1748var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
1749var objectHas = require('../internals/has');
1750var shared = require('../internals/shared-store');
1751var sharedKey = require('../internals/shared-key');
1752var hiddenKeys = require('../internals/hidden-keys');
1753
1754var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
1755var WeakMap = global.WeakMap;
1756var set, get, has;
1757
1758var enforce = function (it) {
1759  return has(it) ? get(it) : set(it, {});
1760};
1761
1762var getterFor = function (TYPE) {
1763  return function (it) {
1764    var state;
1765    if (!isObject(it) || (state = get(it)).type !== TYPE) {
1766      throw TypeError('Incompatible receiver, ' + TYPE + ' required');
1767    } return state;
1768  };
1769};
1770
1771if (NATIVE_WEAK_MAP || shared.state) {
1772  var store = shared.state || (shared.state = new WeakMap());
1773  var wmget = store.get;
1774  var wmhas = store.has;
1775  var wmset = store.set;
1776  set = function (it, metadata) {
1777    if (wmhas.call(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
1778    metadata.facade = it;
1779    wmset.call(store, it, metadata);
1780    return metadata;
1781  };
1782  get = function (it) {
1783    return wmget.call(store, it) || {};
1784  };
1785  has = function (it) {
1786    return wmhas.call(store, it);
1787  };
1788} else {
1789  var STATE = sharedKey('state');
1790  hiddenKeys[STATE] = true;
1791  set = function (it, metadata) {
1792    if (objectHas(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
1793    metadata.facade = it;
1794    createNonEnumerableProperty(it, STATE, metadata);
1795    return metadata;
1796  };
1797  get = function (it) {
1798    return objectHas(it, STATE) ? it[STATE] : {};
1799  };
1800  has = function (it) {
1801    return objectHas(it, STATE);
1802  };
1803}
1804
1805module.exports = {
1806  set: set,
1807  get: get,
1808  has: has,
1809  enforce: enforce,
1810  getterFor: getterFor
1811};
1812
1813/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1814
1815},

2244"define-iterator.js":function module(require,exports,module){
2245
2246/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2247//                                                                                                                     //
2248// node_modules/meteor/url/node_modules/core-js/internals/define-iterator.js                                           //
2249//                                                                                                                     //
2250/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2251                                                                                                                       //
2252'use strict';
2253var $ = require('../internals/export');
2254var createIteratorConstructor = require('../internals/create-iterator-constructor');
2255var getPrototypeOf = require('../internals/object-get-prototype-of');
2256var setPrototypeOf = require('../internals/object-set-prototype-of');
2257var setToStringTag = require('../internals/set-to-string-tag');
2258var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
2259var redefine = require('../internals/redefine');
2260var wellKnownSymbol = require('../internals/well-known-symbol');
2261var IS_PURE = require('../internals/is-pure');
2262var Iterators = require('../internals/iterators');
2263var IteratorsCore = require('../internals/iterators-core');
2264
2265var IteratorPrototype = IteratorsCore.IteratorPrototype;
2266var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
2267var ITERATOR = wellKnownSymbol('iterator');
2268var KEYS = 'keys';
2269var VALUES = 'values';
2270var ENTRIES = 'entries';
2271
2272var returnThis = function () { return this; };
2273
2274module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
2275  createIteratorConstructor(IteratorConstructor, NAME, next);
2276
2277  var getIterationMethod = function (KIND) {
2278    if (KIND === DEFAULT && defaultIterator) return defaultIterator;
2279    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
2280    switch (KIND) {
2281      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
2282      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
2283      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
2284    } return function () { return new IteratorConstructor(this); };
2285  };
2286
2287  var TO_STRING_TAG = NAME + ' Iterator';
2288  var INCORRECT_VALUES_NAME = false;
2289  var IterablePrototype = Iterable.prototype;
2290  var nativeIterator = IterablePrototype[ITERATOR]
2291    || IterablePrototype['@@iterator']
2292    || DEFAULT && IterablePrototype[DEFAULT];
2293  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
2294  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
2295  var CurrentIteratorPrototype, methods, KEY;
2296
2297  // fix native
2298  if (anyNativeIterator) {
2299    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
2300    if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
2301      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
2302        if (setPrototypeOf) {
2303          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
2304        } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {
2305          createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);
2306        }
2307      }
2308      // Set @@toStringTag to native iterators
2309      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
2310      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;
2311    }
2312  }
2313
2314  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
2315  if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
2316    INCORRECT_VALUES_NAME = true;
2317    defaultIterator = function values() { return nativeIterator.call(this); };
2318  }
2319
2320  // define iterator
2321  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
2322    createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);
2323  }
2324  Iterators[NAME] = defaultIterator;
2325
2326  // export additional methods
2327  if (DEFAULT) {
2328    methods = {
2329      values: getIterationMethod(VALUES),
2330      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),

2345"export.js":function module(require,exports,module){
2346
2347/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2348//                                                                                                                     //
2349// node_modules/meteor/url/node_modules/core-js/internals/export.js                                                    //
2350//                                                                                                                     //
2351/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2352                                                                                                                       //
2353var global = require('../internals/global');
2354var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
2355var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
2356var redefine = require('../internals/redefine');
2357var setGlobal = require('../internals/set-global');
2358var copyConstructorProperties = require('../internals/copy-constructor-properties');
2359var isForced = require('../internals/is-forced');
2360
2361/*
2362  options.target      - name of the target object
2363  options.global      - target is the global object
2364  options.stat        - export as static methods of target
2365  options.proto       - export as prototype methods of target
2366  options.real        - real prototype method for the `pure` version
2367  options.forced      - export even if the native feature is available
2368  options.bind        - bind methods to the target, required for the `pure` version
2369  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
2370  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
2371  options.sham        - add a flag to not completely full polyfills
2372  options.enumerable  - export as enumerable property
2373  options.noTargetGet - prevent calling a getter on target
2374*/
2375module.exports = function (options, source) {
2376  var TARGET = options.target;
2377  var GLOBAL = options.global;
2378  var STATIC = options.stat;
2379  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
2380  if (GLOBAL) {
2381    target = global;
2382  } else if (STATIC) {
2383    target = global[TARGET] || setGlobal(TARGET, {});
2384  } else {
2385    target = (global[TARGET] || {}).prototype;
2386  }
2387  if (target) for (key in source) {
2388    sourceProperty = source[key];
2389    if (options.noTargetGet) {
2390      descriptor = getOwnPropertyDescriptor(target, key);
2391      targetProperty = descriptor && descriptor.value;
2392    } else targetProperty = target[key];
2393    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
2394    // contained in target
2395    if (!FORCED && targetProperty !== undefined) {
2396      if (typeof sourceProperty === typeof targetProperty) continue;
2397      copyConstructorProperties(sourceProperty, targetProperty);
2398    }
2399    // add a flag to not completely full polyfills
2400    if (options.sham || (targetProperty && targetProperty.sham)) {
2401      createNonEnumerableProperty(sourceProperty, 'sham', true);
2402    }
2403    // extend global
2404    redefine(target, key, sourceProperty, options);
2405  }
2406};
2407
2408/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2409
2410},

2548  var state;
2549  if (typeof value == 'function') {
2550    if (typeof key == 'string' && !has(value, 'name')) {
2551      createNonEnumerableProperty(value, 'name', key);
2552    }
2553    state = enforceInternalState(value);
2554    if (!state.source) {
2555      state.source = TEMPLATE.join(typeof key == 'string' ? key : '');
2556    }
2557  }
2558  if (O === global) {
2559    if (simple) O[key] = value;
2560    else setGlobal(key, value);
2561    return;
2562  } else if (!unsafe) {
2563    delete O[key];
2564  } else if (!noTargetGet && O[key]) {
2565    simple = true;
2566  }
2567  if (simple) O[key] = value;
2568  else createNonEnumerableProperty(O, key, value);
2569// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
2570})(Function.prototype, 'toString', function toString() {
2571  return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
2572});
2573
2574/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2575
2576},