6847 lines
375 KiB
JavaScript
6847 lines
375 KiB
JavaScript
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.tldjs = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var deprecate = require('util').deprecate;
|
|
|
|
// Load rules
|
|
var Trie = require('./lib/suffix-trie.js');
|
|
var allRules = Trie.fromJson(require('./rules.json'));
|
|
|
|
// Internals
|
|
var extractHostname = require('./lib/clean-host.js');
|
|
var getDomain = require('./lib/domain.js');
|
|
var getPublicSuffix = require('./lib/public-suffix.js');
|
|
var getSubdomain = require('./lib/subdomain.js');
|
|
var isValidHostname = require('./lib/is-valid.js');
|
|
var isIp = require('./lib/is-ip.js');
|
|
var tldExists = require('./lib/tld-exists.js');
|
|
|
|
|
|
// Flags representing steps in the `parse` function. They are used to implement
|
|
// a early stop mechanism (simulating some form of laziness) to avoid doing more
|
|
// work than necessary to perform a given action (e.g.: we don't need to extract
|
|
// the domain and subdomain if we are only interested in public suffix).
|
|
var TLD_EXISTS = 1;
|
|
var PUBLIC_SUFFIX = 2;
|
|
var DOMAIN = 3;
|
|
var SUB_DOMAIN = 4;
|
|
var ALL = 5;
|
|
|
|
/**
|
|
* @typedef {object} FactoryOptions
|
|
* @property {import('./lib/suffix-trie.js')} [rules]
|
|
* @property {string[]} [validHosts]
|
|
* @property {(string) => string|null} [extractHostname]
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} tldjs
|
|
* @property {(url: string) => string} extractHostname
|
|
* @property {(url: string) => boolean} isValidHostname
|
|
* @property {(url: string) => boolean} isValid
|
|
* @property {(url: string) => ParseResult} parse
|
|
* @property {(url: string) => boolean} tldExists
|
|
* @property {(url: string) => string} getPublicSuffix
|
|
* @property {(url: string) => string|null} getDomain
|
|
* @property {(url: string) => string} getSubdomain
|
|
* @property {(FactoryOptions) => tldjs} fromUserSettings
|
|
*/
|
|
|
|
/**
|
|
* @typedef {object} ParseResult
|
|
* @property {string|null} hostname
|
|
* @property {boolean} isValid
|
|
* @property {boolean} isIp
|
|
* @property {boolean} tldExists
|
|
* @property {string|null} publicSuffix
|
|
* @property {string|null} domain
|
|
* @property {string|null} subdomain
|
|
*/
|
|
|
|
/**
|
|
* Creates a new instance of tldjs
|
|
* @param {FactoryOptions} options [description]
|
|
* @return {tldjs} [description]
|
|
*/
|
|
function factory(options) {
|
|
var rules = options.rules || allRules || {};
|
|
var validHosts = options.validHosts || [];
|
|
var _extractHostname = options.extractHostname || extractHostname;
|
|
|
|
/**
|
|
* Process a given url and extract all information. This is a higher level API
|
|
* around private functions of `tld.js`. It allows to remove duplication (only
|
|
* extract hostname from url once for all operations) and implement some early
|
|
* termination mechanism to not pay the price of what we don't need (this
|
|
* simulates laziness at a lower cost).
|
|
*
|
|
* @param {string} url
|
|
* @param {number} [_step] - where should we stop processing
|
|
* @return {ParseResult}
|
|
*/
|
|
function parse(url, _step) {
|
|
var step = _step || ALL;
|
|
/**
|
|
* @type {ParseResult}
|
|
*/
|
|
var result = {
|
|
hostname: _extractHostname(url),
|
|
isValid: null,
|
|
isIp: null,
|
|
tldExists: false,
|
|
publicSuffix: null,
|
|
domain: null,
|
|
subdomain: null,
|
|
};
|
|
|
|
if (result.hostname === null) {
|
|
result.isIp = false;
|
|
result.isValid = false;
|
|
return result;
|
|
}
|
|
|
|
// Check if `hostname` is a valid ip address
|
|
result.isIp = isIp(result.hostname);
|
|
if (result.isIp) {
|
|
result.isValid = true;
|
|
return result;
|
|
}
|
|
|
|
// Check if `hostname` is valid
|
|
result.isValid = isValidHostname(result.hostname);
|
|
if (result.isValid === false) { return result; }
|
|
|
|
// Check if tld exists
|
|
if (step === ALL || step === TLD_EXISTS) {
|
|
result.tldExists = tldExists(rules, result.hostname);
|
|
}
|
|
if (step === TLD_EXISTS) { return result; }
|
|
|
|
// Extract public suffix
|
|
result.publicSuffix = getPublicSuffix(rules, result.hostname);
|
|
if (step === PUBLIC_SUFFIX) { return result; }
|
|
|
|
// Extract domain
|
|
result.domain = getDomain(validHosts, result.publicSuffix, result.hostname);
|
|
if (step === DOMAIN) { return result; }
|
|
|
|
// Extract subdomain
|
|
result.subdomain = getSubdomain(result.hostname, result.domain);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
return {
|
|
extractHostname: _extractHostname,
|
|
isValidHostname: isValidHostname,
|
|
isValid: deprecate(function isValid (hostname) {
|
|
return isValidHostname(hostname);
|
|
}, '"isValid" is deprecated, please use "isValidHostname" instead.'),
|
|
parse: parse,
|
|
tldExists: function (url) {
|
|
return parse(url, TLD_EXISTS).tldExists;
|
|
},
|
|
getPublicSuffix: function (url) {
|
|
return parse(url, PUBLIC_SUFFIX).publicSuffix;
|
|
},
|
|
getDomain: function (url) {
|
|
return parse(url, DOMAIN).domain;
|
|
},
|
|
getSubdomain: function (url) {
|
|
return parse(url, SUB_DOMAIN).subdomain;
|
|
},
|
|
fromUserSettings: factory
|
|
};
|
|
}
|
|
|
|
|
|
module.exports = factory({});
|
|
|
|
},{"./lib/clean-host.js":2,"./lib/domain.js":3,"./lib/is-ip.js":5,"./lib/is-valid.js":6,"./lib/public-suffix.js":7,"./lib/subdomain.js":8,"./lib/suffix-trie.js":9,"./lib/tld-exists.js":10,"./rules.json":80,"util":78}],2:[function(require,module,exports){
|
|
|
|
var URL = require('url');
|
|
var isValid = require('./is-valid.js');
|
|
|
|
|
|
/**
|
|
* Utility to cleanup the base host value. Also removes url fragments.
|
|
*
|
|
* Works for:
|
|
* - hostname
|
|
* - //hostname
|
|
* - scheme://hostname
|
|
* - scheme+scheme://hostname
|
|
*
|
|
* @param {string} value
|
|
* @return {String}
|
|
*/
|
|
|
|
// scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
|
|
var hasPrefixRE = /^(([a-z][a-z0-9+.-]*)?:)?\/\//;
|
|
|
|
|
|
/**
|
|
* @see https://github.com/thom4parisot/tld.js/issues/95
|
|
*
|
|
* @param {string} value
|
|
*/
|
|
function trimTrailingDots(value) {
|
|
if (value[value.length - 1] === '.') {
|
|
return value.substr(0, value.length - 1);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
|
|
/**
|
|
* Fast check to avoid calling `trim` when not needed.
|
|
*
|
|
* @param {string} value
|
|
*/
|
|
function checkTrimmingNeeded(value) {
|
|
return (
|
|
value.length > 0 && (
|
|
value.charCodeAt(0) <= 32 ||
|
|
value.charCodeAt(value.length - 1) <= 32
|
|
)
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
* Fast check to avoid calling `toLowerCase` when not needed.
|
|
*
|
|
* @param {string} value
|
|
*/
|
|
function checkLowerCaseNeeded(value) {
|
|
for (var i = 0; i < value.length; i += 1) {
|
|
var code = value.charCodeAt(i);
|
|
if (code >= 65 && code <= 90) { // [A-Z]
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
module.exports = function extractHostname(value) {
|
|
// First check if `value` is already a valid hostname.
|
|
if (isValid(value)) {
|
|
return trimTrailingDots(value);
|
|
}
|
|
|
|
var url = value;
|
|
|
|
if (typeof url !== 'string') {
|
|
url = '' + url;
|
|
}
|
|
|
|
var needsTrimming = checkTrimmingNeeded(url);
|
|
if (needsTrimming) {
|
|
url = url.trim();
|
|
}
|
|
|
|
var needsLowerCase = checkLowerCaseNeeded(url);
|
|
if (needsLowerCase) {
|
|
url = url.toLowerCase();
|
|
}
|
|
|
|
// Try again after `url` has been transformed to lowercase and trimmed.
|
|
if ((needsLowerCase || needsTrimming) && isValid(url)) {
|
|
return trimTrailingDots(url);
|
|
}
|
|
|
|
// Proceed with heavier url parsing to extract the hostname.
|
|
if (!hasPrefixRE.test(url)) {
|
|
url = '//' + url;
|
|
}
|
|
|
|
var parts = URL.parse(url, null, true);
|
|
|
|
if (parts.hostname) {
|
|
return trimTrailingDots(parts.hostname);
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
},{"./is-valid.js":6,"url":75}],3:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
/**
|
|
* Polyfill for `endsWith`
|
|
*
|
|
* @param {string} str
|
|
* @param {string} pattern
|
|
* @return {boolean}
|
|
*/
|
|
function endsWith(str, pattern) {
|
|
return (
|
|
str.lastIndexOf(pattern) === (str.length - pattern.length)
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
* Check if `vhost` is a valid suffix of `hostname` (top-domain)
|
|
*
|
|
* It means that `vhost` needs to be a suffix of `hostname` and we then need to
|
|
* make sure that: either they are equal, or the character preceding `vhost` in
|
|
* `hostname` is a '.' (it should not be a partial label).
|
|
*
|
|
* * hostname = 'not.evil.com' and vhost = 'vil.com' => not ok
|
|
* * hostname = 'not.evil.com' and vhost = 'evil.com' => ok
|
|
* * hostname = 'not.evil.com' and vhost = 'not.evil.com' => ok
|
|
*
|
|
* @param {string} hostname
|
|
* @param {string} vhost
|
|
* @return {boolean}
|
|
*/
|
|
function shareSameDomainSuffix(hostname, vhost) {
|
|
if (endsWith(hostname, vhost)) {
|
|
return (
|
|
hostname.length === vhost.length ||
|
|
hostname[hostname.length - vhost.length - 1] === '.'
|
|
);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Given a hostname and its public suffix, extract the general domain.
|
|
*
|
|
* @param {string} hostname
|
|
* @param {string} publicSuffix
|
|
* @return {string}
|
|
*/
|
|
function extractDomainWithSuffix(hostname, publicSuffix) {
|
|
// Locate the index of the last '.' in the part of the `hostname` preceding
|
|
// the public suffix.
|
|
//
|
|
// examples:
|
|
// 1. not.evil.co.uk => evil.co.uk
|
|
// ^ ^
|
|
// | | start of public suffix
|
|
// | index of the last dot
|
|
//
|
|
// 2. example.co.uk => example.co.uk
|
|
// ^ ^
|
|
// | | start of public suffix
|
|
// |
|
|
// | (-1) no dot found before the public suffix
|
|
var publicSuffixIndex = hostname.length - publicSuffix.length - 2;
|
|
var lastDotBeforeSuffixIndex = hostname.lastIndexOf('.', publicSuffixIndex);
|
|
|
|
// No '.' found, then `hostname` is the general domain (no sub-domain)
|
|
if (lastDotBeforeSuffixIndex === -1) {
|
|
return hostname;
|
|
}
|
|
|
|
// Extract the part between the last '.'
|
|
return hostname.substr(lastDotBeforeSuffixIndex + 1);
|
|
}
|
|
|
|
|
|
/**
|
|
* Detects the domain based on rules and upon and a host string
|
|
*
|
|
* @api
|
|
* @param {string} host
|
|
* @return {String}
|
|
*/
|
|
module.exports = function getDomain(validHosts, suffix, hostname) {
|
|
// Check if `hostname` ends with a member of `validHosts`.
|
|
for (var i = 0; i < validHosts.length; i += 1) {
|
|
var vhost = validHosts[i];
|
|
if (shareSameDomainSuffix(hostname, vhost)) {
|
|
return vhost;
|
|
}
|
|
}
|
|
|
|
// If there is no suffix, there is no hostname
|
|
if (suffix === null) {
|
|
return null;
|
|
}
|
|
|
|
// If `hostname` is a valid public suffix, then there is no domain to return.
|
|
// Since we already know that `getPublicSuffix` returns a suffix of `hostname`
|
|
// there is no need to perform a string comparison and we only compare the
|
|
// size.
|
|
if (suffix.length === hostname.length) {
|
|
return null;
|
|
}
|
|
|
|
// To extract the general domain, we start by identifying the public suffix
|
|
// (if any), then consider the domain to be the public suffix with one added
|
|
// level of depth. (e.g.: if hostname is `not.evil.co.uk` and public suffix:
|
|
// `co.uk`, then we take one more level: `evil`, giving the final result:
|
|
// `evil.co.uk`).
|
|
return extractDomainWithSuffix(hostname, suffix);
|
|
};
|
|
|
|
},{}],4:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/**
|
|
* Utility to extract the TLD from a hostname string
|
|
*
|
|
* @param {string} host
|
|
* @return {String}
|
|
*/
|
|
module.exports = function extractTldFromHost(hostname) {
|
|
var lastDotIndex = hostname.lastIndexOf('.');
|
|
if (lastDotIndex === -1) {
|
|
return null;
|
|
}
|
|
|
|
return hostname.substr(lastDotIndex + 1);
|
|
};
|
|
|
|
},{}],5:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
/**
|
|
* Check if a hostname is an IP. You should be aware that this only works
|
|
* because `hostname` is already garanteed to be a valid hostname!
|
|
*
|
|
* @param {string} hostname
|
|
* @return {boolean}
|
|
*/
|
|
function isProbablyIpv4(hostname) {
|
|
var numberOfDots = 0;
|
|
|
|
for (var i = 0; i < hostname.length; i += 1) {
|
|
var code = hostname.charCodeAt(i);
|
|
|
|
if (code === 46) { // '.'
|
|
numberOfDots += 1;
|
|
} else if (code < 48 || code > 57) {
|
|
// 48 => '0'
|
|
// 57 => '9'
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return (
|
|
numberOfDots === 3 &&
|
|
hostname[0] !== '.' &&
|
|
hostname[hostname.length - 1] !== '.'
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
* Similar to isProbablyIpv4.
|
|
*
|
|
* @param {string} hostname
|
|
* @return {boolean}
|
|
*/
|
|
function isProbablyIpv6(hostname) {
|
|
var hasColon = false;
|
|
|
|
for (var i = 0; i < hostname.length; i += 1) {
|
|
var code = hostname.charCodeAt(i);
|
|
|
|
if (code === 58) { // ':'
|
|
hasColon = true;
|
|
} else if (!(
|
|
(code >= 48 && code <= 57) || // 0-9
|
|
(code >= 97 && code <= 102) // a-f
|
|
)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return hasColon;
|
|
}
|
|
|
|
|
|
/**
|
|
* Check if `hostname` is *probably* a valid ip addr (either ipv6 or ipv4).
|
|
* This *will not* work on any string. We need `hostname` to be a valid
|
|
* hostname.
|
|
*
|
|
* @param {string} hostname
|
|
* @return {boolean}
|
|
*/
|
|
module.exports = function isIp(hostname) {
|
|
if (typeof hostname !== 'string') {
|
|
return false;
|
|
}
|
|
|
|
if (hostname.length === 0) {
|
|
return false;
|
|
}
|
|
|
|
return (isProbablyIpv6(hostname) || isProbablyIpv4(hostname));
|
|
};
|
|
|
|
},{}],6:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
/**
|
|
* Check if the code point is a digit [0-9]
|
|
*
|
|
* @param {number} code
|
|
* @return boolean
|
|
*/
|
|
function isDigit(code) {
|
|
// 48 == '0'
|
|
// 57 == '9'
|
|
return code >= 48 && code <= 57;
|
|
}
|
|
|
|
|
|
/**
|
|
* Check if the code point is a letter [a-zA-Z]
|
|
*
|
|
* @param {number} code
|
|
* @return boolean
|
|
*/
|
|
function isAlpha(code) {
|
|
// 97 === 'a'
|
|
// 122 == 'z'
|
|
return code >= 97 && code <= 122;
|
|
}
|
|
|
|
|
|
/**
|
|
* Check if a hostname string is valid (according to RFC). It's usually a
|
|
* preliminary check before trying to use getDomain or anything else.
|
|
*
|
|
* Beware: it does not check if the TLD exists.
|
|
*
|
|
* @api
|
|
* @param {string} hostname
|
|
* @return {boolean}
|
|
*/
|
|
module.exports = function isValid(hostname) {
|
|
if (typeof hostname !== 'string') {
|
|
return false;
|
|
}
|
|
|
|
if (hostname.length > 255) {
|
|
return false;
|
|
}
|
|
|
|
if (hostname.length === 0) {
|
|
return false;
|
|
}
|
|
|
|
// Check first character: [a-zA-Z0-9]
|
|
var firstCharCode = hostname.charCodeAt(0);
|
|
if (!(isAlpha(firstCharCode) || isDigit(firstCharCode))) {
|
|
return false;
|
|
}
|
|
|
|
// Validate hostname according to RFC
|
|
var lastDotIndex = -1;
|
|
var lastCharCode;
|
|
var code;
|
|
var len = hostname.length;
|
|
|
|
for (var i = 0; i < len; i += 1) {
|
|
code = hostname.charCodeAt(i);
|
|
|
|
if (code === 46) { // '.'
|
|
if (
|
|
// Check that previous label is < 63 bytes long (64 = 63 + '.')
|
|
(i - lastDotIndex) > 64 ||
|
|
// Check that previous character was not already a '.'
|
|
lastCharCode === 46 ||
|
|
// Check that the previous label does not end with a '-'
|
|
lastCharCode === 45
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
lastDotIndex = i;
|
|
} else if (!(isAlpha(code) || isDigit(code) || code === 45)) {
|
|
// Check if there is a forbidden character in the label: [^a-zA-Z0-9-]
|
|
return false;
|
|
}
|
|
|
|
lastCharCode = code;
|
|
}
|
|
|
|
return (
|
|
// Check that last label is shorter than 63 chars
|
|
(len - lastDotIndex - 1) <= 63 &&
|
|
// Check that the last character is an allowed trailing label character.
|
|
// Since we already checked that the char is a valid hostname character,
|
|
// we only need to check that it's different from '-'.
|
|
lastCharCode !== 45
|
|
);
|
|
};
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var extractTldFromHost = require('./from-host.js');
|
|
|
|
|
|
/**
|
|
* Returns the public suffix (including exact matches)
|
|
*
|
|
* @api
|
|
* @since 1.5
|
|
* @param {string} hostname
|
|
* @return {string}
|
|
*/
|
|
module.exports = function getPublicSuffix(rules, hostname) {
|
|
// First check if `hostname` is already a valid top-level Domain.
|
|
if (rules.hasTld(hostname)) {
|
|
return hostname;
|
|
}
|
|
|
|
var candidate = rules.suffixLookup(hostname);
|
|
if (candidate === null) {
|
|
// Prevailing rule is '*' so we consider the top-level domain to be the
|
|
// public suffix of `hostname` (e.g.: 'example.org' => 'org').
|
|
return extractTldFromHost(hostname);
|
|
}
|
|
|
|
return candidate;
|
|
};
|
|
|
|
},{"./from-host.js":4}],8:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
/**
|
|
* Returns the subdomain of a hostname string
|
|
*
|
|
* @api
|
|
* @param {string} hostname
|
|
* @param {string} domain - the root domain of the hostname
|
|
* @return {string|null} a subdomain string if any, blank string if subdomain
|
|
* is empty, otherwise null.
|
|
*/
|
|
module.exports = function getSubdomain(hostname, domain) {
|
|
// No domain found? Just abort, abort!
|
|
if (domain === null) {
|
|
return null;
|
|
}
|
|
|
|
return hostname.substr(0, hostname.length - domain.length - 1);
|
|
};
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var VALID_HOSTNAME_VALUE = 0;
|
|
|
|
/**
|
|
* @typedef {string} PlainRules
|
|
*/
|
|
|
|
|
|
/**
|
|
* Return min(a, b), handling possible `null` values.
|
|
*
|
|
* @param {number|null} a
|
|
* @param {number|null} b
|
|
* @return {number|null}
|
|
*/
|
|
function minIndex(a, b) {
|
|
if (a === null) {
|
|
return b;
|
|
} else if (b === null) {
|
|
return a;
|
|
}
|
|
|
|
return a < b ? a : b;
|
|
}
|
|
|
|
|
|
/**
|
|
* Insert a public suffix rule in the `trie`.
|
|
*
|
|
* @param {object} rule
|
|
* @param {object} trie
|
|
* @return {object} trie (updated)
|
|
*/
|
|
function insertInTrie(rule, trie) {
|
|
var parts = rule.parts;
|
|
var node = trie;
|
|
|
|
for (var i = 0; i < parts.length; i += 1) {
|
|
var part = parts[i];
|
|
var nextNode = node[part];
|
|
if (nextNode === undefined) {
|
|
nextNode = Object.create(null);
|
|
node[part] = nextNode;
|
|
}
|
|
|
|
node = nextNode;
|
|
}
|
|
|
|
node.$ = VALID_HOSTNAME_VALUE;
|
|
|
|
return trie;
|
|
}
|
|
|
|
|
|
/**
|
|
* Recursive lookup of `parts` (starting at `index`) in the tree.
|
|
*
|
|
* @param {array} parts
|
|
* @param {object} trie
|
|
* @param {number} index - when to start in `parts` (initially: length - 1)
|
|
* @return {number} size of the suffix found (in number of parts matched)
|
|
*/
|
|
function lookupInTrie(parts, trie, index) {
|
|
var part;
|
|
var nextNode;
|
|
var publicSuffixIndex = null;
|
|
|
|
// We have a match!
|
|
if (trie.$ !== undefined) {
|
|
publicSuffixIndex = index + 1;
|
|
}
|
|
|
|
// No more `parts` to look for
|
|
if (index === -1) {
|
|
return publicSuffixIndex;
|
|
}
|
|
|
|
part = parts[index];
|
|
|
|
// Check branch corresponding to next part of hostname
|
|
nextNode = trie[part];
|
|
if (nextNode !== undefined) {
|
|
publicSuffixIndex = minIndex(
|
|
publicSuffixIndex,
|
|
lookupInTrie(parts, nextNode, index - 1)
|
|
);
|
|
}
|
|
|
|
// Check wildcard branch
|
|
nextNode = trie['*'];
|
|
if (nextNode !== undefined) {
|
|
publicSuffixIndex = minIndex(
|
|
publicSuffixIndex,
|
|
lookupInTrie(parts, nextNode, index - 1)
|
|
);
|
|
}
|
|
|
|
return publicSuffixIndex;
|
|
}
|
|
|
|
|
|
/**
|
|
* Contains the public suffix ruleset as a Trie for efficient look-up.
|
|
*
|
|
* @constructor
|
|
* @param {PlainRules} [rules]
|
|
*/
|
|
function SuffixTrie(rules) {
|
|
this.exceptions = Object.create(null);
|
|
this.rules = Object.create(null);
|
|
|
|
if (rules) {
|
|
for (var i = 0; i < rules.length; i += 1) {
|
|
var rule = rules[i];
|
|
if (rule.exception) {
|
|
insertInTrie(rule, this.exceptions);
|
|
} else {
|
|
insertInTrie(rule, this.rules);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Load the trie from JSON (as serialized by JSON.stringify).
|
|
*/
|
|
SuffixTrie.fromJson = function (json) {
|
|
var trie = new SuffixTrie();
|
|
|
|
trie.exceptions = json.exceptions;
|
|
trie.rules = json.rules;
|
|
|
|
return trie;
|
|
};
|
|
|
|
|
|
/**
|
|
* Check if `value` is a valid TLD.
|
|
*/
|
|
SuffixTrie.prototype.hasTld = function (value) {
|
|
// All TLDs are at the root of the Trie.
|
|
return this.rules[value] !== undefined;
|
|
};
|
|
|
|
|
|
/**
|
|
* Check if `hostname` has a valid public suffix in `trie`.
|
|
*
|
|
* @param {string} hostname
|
|
* @return {string|null} public suffix
|
|
*/
|
|
SuffixTrie.prototype.suffixLookup = function (hostname) {
|
|
var parts = hostname.split('.');
|
|
|
|
// Look for a match in rules
|
|
var publicSuffixIndex = lookupInTrie(
|
|
parts,
|
|
this.rules,
|
|
parts.length - 1
|
|
);
|
|
|
|
if (publicSuffixIndex === null) {
|
|
return null;
|
|
}
|
|
|
|
// Look for exceptions
|
|
var exceptionIndex = lookupInTrie(
|
|
parts,
|
|
this.exceptions,
|
|
parts.length - 1
|
|
);
|
|
|
|
if (exceptionIndex !== null) {
|
|
return parts.slice(exceptionIndex + 1).join('.');
|
|
}
|
|
|
|
return parts.slice(publicSuffixIndex).join('.');
|
|
};
|
|
|
|
|
|
module.exports = SuffixTrie;
|
|
|
|
},{}],10:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var extractTldFromHost = require('./from-host.js');
|
|
|
|
|
|
/**
|
|
* Checks if the TLD exists for a given hostname
|
|
*
|
|
* @api
|
|
* @param {string} rules
|
|
* @param {string} hostname
|
|
* @return {boolean}
|
|
*/
|
|
module.exports = function tldExists(rules, hostname) {
|
|
// Easy case, it's a TLD
|
|
if (rules.hasTld(hostname)) {
|
|
return true;
|
|
}
|
|
|
|
// Popping only the TLD of the hostname
|
|
var hostTld = extractTldFromHost(hostname);
|
|
if (hostTld === null) {
|
|
return false;
|
|
}
|
|
|
|
return rules.hasTld(hostTld);
|
|
};
|
|
|
|
},{"./from-host.js":4}],11:[function(require,module,exports){
|
|
(function (global){(function (){
|
|
'use strict';
|
|
|
|
var possibleNames = require('possible-typed-array-names');
|
|
|
|
var g = typeof globalThis === 'undefined' ? global : globalThis;
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function availableTypedArrays() {
|
|
var /** @type {ReturnType<typeof availableTypedArrays>} */ out = [];
|
|
for (var i = 0; i < possibleNames.length; i++) {
|
|
if (typeof g[possibleNames[i]] === 'function') {
|
|
// @ts-expect-error
|
|
out[out.length] = possibleNames[i];
|
|
}
|
|
}
|
|
return out;
|
|
};
|
|
|
|
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"possible-typed-array-names":61}],12:[function(require,module,exports){
|
|
|
|
},{}],13:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var bind = require('function-bind');
|
|
|
|
var $apply = require('./functionApply');
|
|
var $call = require('./functionCall');
|
|
var $reflectApply = require('./reflectApply');
|
|
|
|
/** @type {import('./actualApply')} */
|
|
module.exports = $reflectApply || bind.call($call, $apply);
|
|
|
|
},{"./functionApply":15,"./functionCall":16,"./reflectApply":18,"function-bind":34}],14:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var bind = require('function-bind');
|
|
var $apply = require('./functionApply');
|
|
var actualApply = require('./actualApply');
|
|
|
|
/** @type {import('./applyBind')} */
|
|
module.exports = function applyBind() {
|
|
return actualApply(bind, $apply, arguments);
|
|
};
|
|
|
|
},{"./actualApply":13,"./functionApply":15,"function-bind":34}],15:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./functionApply')} */
|
|
module.exports = Function.prototype.apply;
|
|
|
|
},{}],16:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./functionCall')} */
|
|
module.exports = Function.prototype.call;
|
|
|
|
},{}],17:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var bind = require('function-bind');
|
|
var $TypeError = require('es-errors/type');
|
|
|
|
var $call = require('./functionCall');
|
|
var $actualApply = require('./actualApply');
|
|
|
|
/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */
|
|
module.exports = function callBindBasic(args) {
|
|
if (args.length < 1 || typeof args[0] !== 'function') {
|
|
throw new $TypeError('a function is required');
|
|
}
|
|
return $actualApply(bind, $call, args);
|
|
};
|
|
|
|
},{"./actualApply":13,"./functionCall":16,"es-errors/type":29,"function-bind":34}],18:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./reflectApply')} */
|
|
module.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
|
|
|
|
},{}],19:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var setFunctionLength = require('set-function-length');
|
|
|
|
var $defineProperty = require('es-define-property');
|
|
|
|
var callBindBasic = require('call-bind-apply-helpers');
|
|
var applyBind = require('call-bind-apply-helpers/applyBind');
|
|
|
|
module.exports = function callBind(originalFunction) {
|
|
var func = callBindBasic(arguments);
|
|
var adjustedLength = originalFunction.length - (arguments.length - 1);
|
|
return setFunctionLength(
|
|
func,
|
|
1 + (adjustedLength > 0 ? adjustedLength : 0),
|
|
true
|
|
);
|
|
};
|
|
|
|
if ($defineProperty) {
|
|
$defineProperty(module.exports, 'apply', { value: applyBind });
|
|
} else {
|
|
module.exports.apply = applyBind;
|
|
}
|
|
|
|
},{"call-bind-apply-helpers":17,"call-bind-apply-helpers/applyBind":14,"es-define-property":23,"set-function-length":69}],20:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var GetIntrinsic = require('get-intrinsic');
|
|
|
|
var callBindBasic = require('call-bind-apply-helpers');
|
|
|
|
/** @type {(thisArg: string, searchString: string, position?: number) => number} */
|
|
var $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]);
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function callBoundIntrinsic(name, allowMissing) {
|
|
/* eslint no-extra-parens: 0 */
|
|
|
|
var intrinsic = /** @type {(this: unknown, ...args: unknown[]) => unknown} */ (GetIntrinsic(name, !!allowMissing));
|
|
if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
|
|
return callBindBasic(/** @type {const} */ ([intrinsic]));
|
|
}
|
|
return intrinsic;
|
|
};
|
|
|
|
},{"call-bind-apply-helpers":17,"get-intrinsic":35}],21:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var $defineProperty = require('es-define-property');
|
|
|
|
var $SyntaxError = require('es-errors/syntax');
|
|
var $TypeError = require('es-errors/type');
|
|
|
|
var gopd = require('gopd');
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function defineDataProperty(
|
|
obj,
|
|
property,
|
|
value
|
|
) {
|
|
if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
|
throw new $TypeError('`obj` must be an object or a function`');
|
|
}
|
|
if (typeof property !== 'string' && typeof property !== 'symbol') {
|
|
throw new $TypeError('`property` must be a string or a symbol`');
|
|
}
|
|
if (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {
|
|
throw new $TypeError('`nonEnumerable`, if provided, must be a boolean or null');
|
|
}
|
|
if (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {
|
|
throw new $TypeError('`nonWritable`, if provided, must be a boolean or null');
|
|
}
|
|
if (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {
|
|
throw new $TypeError('`nonConfigurable`, if provided, must be a boolean or null');
|
|
}
|
|
if (arguments.length > 6 && typeof arguments[6] !== 'boolean') {
|
|
throw new $TypeError('`loose`, if provided, must be a boolean');
|
|
}
|
|
|
|
var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
|
|
var nonWritable = arguments.length > 4 ? arguments[4] : null;
|
|
var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
|
|
var loose = arguments.length > 6 ? arguments[6] : false;
|
|
|
|
/* @type {false | TypedPropertyDescriptor<unknown>} */
|
|
var desc = !!gopd && gopd(obj, property);
|
|
|
|
if ($defineProperty) {
|
|
$defineProperty(obj, property, {
|
|
configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
|
|
enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
|
|
value: value,
|
|
writable: nonWritable === null && desc ? desc.writable : !nonWritable
|
|
});
|
|
} else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) {
|
|
// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable
|
|
obj[property] = value; // eslint-disable-line no-param-reassign
|
|
} else {
|
|
throw new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.');
|
|
}
|
|
};
|
|
|
|
},{"es-define-property":23,"es-errors/syntax":28,"es-errors/type":29,"gopd":40}],22:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var callBind = require('call-bind-apply-helpers');
|
|
var gOPD = require('gopd');
|
|
|
|
var hasProtoAccessor;
|
|
try {
|
|
// eslint-disable-next-line no-extra-parens, no-proto
|
|
hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */ ([]).__proto__ === Array.prototype;
|
|
} catch (e) {
|
|
if (!e || typeof e !== 'object' || !('code' in e) || e.code !== 'ERR_PROTO_ACCESS') {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
// eslint-disable-next-line no-extra-parens
|
|
var desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, /** @type {keyof typeof Object.prototype} */ ('__proto__'));
|
|
|
|
var $Object = Object;
|
|
var $getPrototypeOf = $Object.getPrototypeOf;
|
|
|
|
/** @type {import('./get')} */
|
|
module.exports = desc && typeof desc.get === 'function'
|
|
? callBind([desc.get])
|
|
: typeof $getPrototypeOf === 'function'
|
|
? /** @type {import('./get')} */ function getDunder(value) {
|
|
// eslint-disable-next-line eqeqeq
|
|
return $getPrototypeOf(value == null ? value : $Object(value));
|
|
}
|
|
: false;
|
|
|
|
},{"call-bind-apply-helpers":17,"gopd":40}],23:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('.')} */
|
|
var $defineProperty = Object.defineProperty || false;
|
|
if ($defineProperty) {
|
|
try {
|
|
$defineProperty({}, 'a', { value: 1 });
|
|
} catch (e) {
|
|
// IE 8 has a broken defineProperty
|
|
$defineProperty = false;
|
|
}
|
|
}
|
|
|
|
module.exports = $defineProperty;
|
|
|
|
},{}],24:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./eval')} */
|
|
module.exports = EvalError;
|
|
|
|
},{}],25:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = Error;
|
|
|
|
},{}],26:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./range')} */
|
|
module.exports = RangeError;
|
|
|
|
},{}],27:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./ref')} */
|
|
module.exports = ReferenceError;
|
|
|
|
},{}],28:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./syntax')} */
|
|
module.exports = SyntaxError;
|
|
|
|
},{}],29:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./type')} */
|
|
module.exports = TypeError;
|
|
|
|
},{}],30:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./uri')} */
|
|
module.exports = URIError;
|
|
|
|
},{}],31:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = Object;
|
|
|
|
},{}],32:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var isCallable = require('is-callable');
|
|
|
|
var toStr = Object.prototype.toString;
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
|
/** @type {<This, A extends readonly unknown[]>(arr: A, iterator: (this: This | void, value: A[number], index: number, arr: A) => void, receiver: This | undefined) => void} */
|
|
var forEachArray = function forEachArray(array, iterator, receiver) {
|
|
for (var i = 0, len = array.length; i < len; i++) {
|
|
if (hasOwnProperty.call(array, i)) {
|
|
if (receiver == null) {
|
|
iterator(array[i], i, array);
|
|
} else {
|
|
iterator.call(receiver, array[i], i, array);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/** @type {<This, S extends string>(string: S, iterator: (this: This | void, value: S[number], index: number, string: S) => void, receiver: This | undefined) => void} */
|
|
var forEachString = function forEachString(string, iterator, receiver) {
|
|
for (var i = 0, len = string.length; i < len; i++) {
|
|
// no such thing as a sparse string.
|
|
if (receiver == null) {
|
|
iterator(string.charAt(i), i, string);
|
|
} else {
|
|
iterator.call(receiver, string.charAt(i), i, string);
|
|
}
|
|
}
|
|
};
|
|
|
|
/** @type {<This, O>(obj: O, iterator: (this: This | void, value: O[keyof O], index: keyof O, obj: O) => void, receiver: This | undefined) => void} */
|
|
var forEachObject = function forEachObject(object, iterator, receiver) {
|
|
for (var k in object) {
|
|
if (hasOwnProperty.call(object, k)) {
|
|
if (receiver == null) {
|
|
iterator(object[k], k, object);
|
|
} else {
|
|
iterator.call(receiver, object[k], k, object);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/** @type {(x: unknown) => x is readonly unknown[]} */
|
|
function isArray(x) {
|
|
return toStr.call(x) === '[object Array]';
|
|
}
|
|
|
|
/** @type {import('.')._internal} */
|
|
module.exports = function forEach(list, iterator, thisArg) {
|
|
if (!isCallable(iterator)) {
|
|
throw new TypeError('iterator must be a function');
|
|
}
|
|
|
|
var receiver;
|
|
if (arguments.length >= 3) {
|
|
receiver = thisArg;
|
|
}
|
|
|
|
if (isArray(list)) {
|
|
forEachArray(list, iterator, receiver);
|
|
} else if (typeof list === 'string') {
|
|
forEachString(list, iterator, receiver);
|
|
} else {
|
|
forEachObject(list, iterator, receiver);
|
|
}
|
|
};
|
|
|
|
},{"is-callable":48}],33:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/* eslint no-invalid-this: 1 */
|
|
|
|
var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
|
|
var toStr = Object.prototype.toString;
|
|
var max = Math.max;
|
|
var funcType = '[object Function]';
|
|
|
|
var concatty = function concatty(a, b) {
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < a.length; i += 1) {
|
|
arr[i] = a[i];
|
|
}
|
|
for (var j = 0; j < b.length; j += 1) {
|
|
arr[j + a.length] = b[j];
|
|
}
|
|
|
|
return arr;
|
|
};
|
|
|
|
var slicy = function slicy(arrLike, offset) {
|
|
var arr = [];
|
|
for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
|
|
arr[j] = arrLike[i];
|
|
}
|
|
return arr;
|
|
};
|
|
|
|
var joiny = function (arr, joiner) {
|
|
var str = '';
|
|
for (var i = 0; i < arr.length; i += 1) {
|
|
str += arr[i];
|
|
if (i + 1 < arr.length) {
|
|
str += joiner;
|
|
}
|
|
}
|
|
return str;
|
|
};
|
|
|
|
module.exports = function bind(that) {
|
|
var target = this;
|
|
if (typeof target !== 'function' || toStr.apply(target) !== funcType) {
|
|
throw new TypeError(ERROR_MESSAGE + target);
|
|
}
|
|
var args = slicy(arguments, 1);
|
|
|
|
var bound;
|
|
var binder = function () {
|
|
if (this instanceof bound) {
|
|
var result = target.apply(
|
|
this,
|
|
concatty(args, arguments)
|
|
);
|
|
if (Object(result) === result) {
|
|
return result;
|
|
}
|
|
return this;
|
|
}
|
|
return target.apply(
|
|
that,
|
|
concatty(args, arguments)
|
|
);
|
|
|
|
};
|
|
|
|
var boundLength = max(0, target.length - args.length);
|
|
var boundArgs = [];
|
|
for (var i = 0; i < boundLength; i++) {
|
|
boundArgs[i] = '$' + i;
|
|
}
|
|
|
|
bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);
|
|
|
|
if (target.prototype) {
|
|
var Empty = function Empty() {};
|
|
Empty.prototype = target.prototype;
|
|
bound.prototype = new Empty();
|
|
Empty.prototype = null;
|
|
}
|
|
|
|
return bound;
|
|
};
|
|
|
|
},{}],34:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var implementation = require('./implementation');
|
|
|
|
module.exports = Function.prototype.bind || implementation;
|
|
|
|
},{"./implementation":33}],35:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var undefined;
|
|
|
|
var $Object = require('es-object-atoms');
|
|
|
|
var $Error = require('es-errors');
|
|
var $EvalError = require('es-errors/eval');
|
|
var $RangeError = require('es-errors/range');
|
|
var $ReferenceError = require('es-errors/ref');
|
|
var $SyntaxError = require('es-errors/syntax');
|
|
var $TypeError = require('es-errors/type');
|
|
var $URIError = require('es-errors/uri');
|
|
|
|
var abs = require('math-intrinsics/abs');
|
|
var floor = require('math-intrinsics/floor');
|
|
var max = require('math-intrinsics/max');
|
|
var min = require('math-intrinsics/min');
|
|
var pow = require('math-intrinsics/pow');
|
|
var round = require('math-intrinsics/round');
|
|
var sign = require('math-intrinsics/sign');
|
|
|
|
var $Function = Function;
|
|
|
|
// eslint-disable-next-line consistent-return
|
|
var getEvalledConstructor = function (expressionSyntax) {
|
|
try {
|
|
return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
|
|
} catch (e) {}
|
|
};
|
|
|
|
var $gOPD = require('gopd');
|
|
var $defineProperty = require('es-define-property');
|
|
|
|
var throwTypeError = function () {
|
|
throw new $TypeError();
|
|
};
|
|
var ThrowTypeError = $gOPD
|
|
? (function () {
|
|
try {
|
|
// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
|
|
arguments.callee; // IE 8 does not throw here
|
|
return throwTypeError;
|
|
} catch (calleeThrows) {
|
|
try {
|
|
// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
|
|
return $gOPD(arguments, 'callee').get;
|
|
} catch (gOPDthrows) {
|
|
return throwTypeError;
|
|
}
|
|
}
|
|
}())
|
|
: throwTypeError;
|
|
|
|
var hasSymbols = require('has-symbols')();
|
|
|
|
var getProto = require('get-proto');
|
|
var $ObjectGPO = require('get-proto/Object.getPrototypeOf');
|
|
var $ReflectGPO = require('get-proto/Reflect.getPrototypeOf');
|
|
|
|
var $apply = require('call-bind-apply-helpers/functionApply');
|
|
var $call = require('call-bind-apply-helpers/functionCall');
|
|
|
|
var needsEval = {};
|
|
|
|
var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array);
|
|
|
|
var INTRINSICS = {
|
|
__proto__: null,
|
|
'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
|
|
'%Array%': Array,
|
|
'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
|
|
'%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,
|
|
'%AsyncFromSyncIteratorPrototype%': undefined,
|
|
'%AsyncFunction%': needsEval,
|
|
'%AsyncGenerator%': needsEval,
|
|
'%AsyncGeneratorFunction%': needsEval,
|
|
'%AsyncIteratorPrototype%': needsEval,
|
|
'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
|
|
'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
|
|
'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,
|
|
'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,
|
|
'%Boolean%': Boolean,
|
|
'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
|
|
'%Date%': Date,
|
|
'%decodeURI%': decodeURI,
|
|
'%decodeURIComponent%': decodeURIComponent,
|
|
'%encodeURI%': encodeURI,
|
|
'%encodeURIComponent%': encodeURIComponent,
|
|
'%Error%': $Error,
|
|
'%eval%': eval, // eslint-disable-line no-eval
|
|
'%EvalError%': $EvalError,
|
|
'%Float16Array%': typeof Float16Array === 'undefined' ? undefined : Float16Array,
|
|
'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
|
|
'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
|
|
'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
|
|
'%Function%': $Function,
|
|
'%GeneratorFunction%': needsEval,
|
|
'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
|
|
'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
|
|
'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
|
|
'%isFinite%': isFinite,
|
|
'%isNaN%': isNaN,
|
|
'%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,
|
|
'%JSON%': typeof JSON === 'object' ? JSON : undefined,
|
|
'%Map%': typeof Map === 'undefined' ? undefined : Map,
|
|
'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),
|
|
'%Math%': Math,
|
|
'%Number%': Number,
|
|
'%Object%': $Object,
|
|
'%Object.getOwnPropertyDescriptor%': $gOPD,
|
|
'%parseFloat%': parseFloat,
|
|
'%parseInt%': parseInt,
|
|
'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
|
|
'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
|
|
'%RangeError%': $RangeError,
|
|
'%ReferenceError%': $ReferenceError,
|
|
'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
|
|
'%RegExp%': RegExp,
|
|
'%Set%': typeof Set === 'undefined' ? undefined : Set,
|
|
'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()),
|
|
'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
|
|
'%String%': String,
|
|
'%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined,
|
|
'%Symbol%': hasSymbols ? Symbol : undefined,
|
|
'%SyntaxError%': $SyntaxError,
|
|
'%ThrowTypeError%': ThrowTypeError,
|
|
'%TypedArray%': TypedArray,
|
|
'%TypeError%': $TypeError,
|
|
'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
|
|
'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
|
|
'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
|
|
'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
|
|
'%URIError%': $URIError,
|
|
'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
|
|
'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
|
|
'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,
|
|
|
|
'%Function.prototype.call%': $call,
|
|
'%Function.prototype.apply%': $apply,
|
|
'%Object.defineProperty%': $defineProperty,
|
|
'%Object.getPrototypeOf%': $ObjectGPO,
|
|
'%Math.abs%': abs,
|
|
'%Math.floor%': floor,
|
|
'%Math.max%': max,
|
|
'%Math.min%': min,
|
|
'%Math.pow%': pow,
|
|
'%Math.round%': round,
|
|
'%Math.sign%': sign,
|
|
'%Reflect.getPrototypeOf%': $ReflectGPO
|
|
};
|
|
|
|
if (getProto) {
|
|
try {
|
|
null.error; // eslint-disable-line no-unused-expressions
|
|
} catch (e) {
|
|
// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
|
|
var errorProto = getProto(getProto(e));
|
|
INTRINSICS['%Error.prototype%'] = errorProto;
|
|
}
|
|
}
|
|
|
|
var doEval = function doEval(name) {
|
|
var value;
|
|
if (name === '%AsyncFunction%') {
|
|
value = getEvalledConstructor('async function () {}');
|
|
} else if (name === '%GeneratorFunction%') {
|
|
value = getEvalledConstructor('function* () {}');
|
|
} else if (name === '%AsyncGeneratorFunction%') {
|
|
value = getEvalledConstructor('async function* () {}');
|
|
} else if (name === '%AsyncGenerator%') {
|
|
var fn = doEval('%AsyncGeneratorFunction%');
|
|
if (fn) {
|
|
value = fn.prototype;
|
|
}
|
|
} else if (name === '%AsyncIteratorPrototype%') {
|
|
var gen = doEval('%AsyncGenerator%');
|
|
if (gen && getProto) {
|
|
value = getProto(gen.prototype);
|
|
}
|
|
}
|
|
|
|
INTRINSICS[name] = value;
|
|
|
|
return value;
|
|
};
|
|
|
|
var LEGACY_ALIASES = {
|
|
__proto__: null,
|
|
'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
|
|
'%ArrayPrototype%': ['Array', 'prototype'],
|
|
'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
|
|
'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
|
|
'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
|
|
'%ArrayProto_values%': ['Array', 'prototype', 'values'],
|
|
'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
|
|
'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
|
|
'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
|
|
'%BooleanPrototype%': ['Boolean', 'prototype'],
|
|
'%DataViewPrototype%': ['DataView', 'prototype'],
|
|
'%DatePrototype%': ['Date', 'prototype'],
|
|
'%ErrorPrototype%': ['Error', 'prototype'],
|
|
'%EvalErrorPrototype%': ['EvalError', 'prototype'],
|
|
'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
|
|
'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
|
|
'%FunctionPrototype%': ['Function', 'prototype'],
|
|
'%Generator%': ['GeneratorFunction', 'prototype'],
|
|
'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
|
|
'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
|
|
'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
|
|
'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
|
|
'%JSONParse%': ['JSON', 'parse'],
|
|
'%JSONStringify%': ['JSON', 'stringify'],
|
|
'%MapPrototype%': ['Map', 'prototype'],
|
|
'%NumberPrototype%': ['Number', 'prototype'],
|
|
'%ObjectPrototype%': ['Object', 'prototype'],
|
|
'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
|
|
'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
|
|
'%PromisePrototype%': ['Promise', 'prototype'],
|
|
'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
|
|
'%Promise_all%': ['Promise', 'all'],
|
|
'%Promise_reject%': ['Promise', 'reject'],
|
|
'%Promise_resolve%': ['Promise', 'resolve'],
|
|
'%RangeErrorPrototype%': ['RangeError', 'prototype'],
|
|
'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
|
|
'%RegExpPrototype%': ['RegExp', 'prototype'],
|
|
'%SetPrototype%': ['Set', 'prototype'],
|
|
'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
|
|
'%StringPrototype%': ['String', 'prototype'],
|
|
'%SymbolPrototype%': ['Symbol', 'prototype'],
|
|
'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
|
|
'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
|
|
'%TypeErrorPrototype%': ['TypeError', 'prototype'],
|
|
'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
|
|
'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
|
|
'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
|
|
'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
|
|
'%URIErrorPrototype%': ['URIError', 'prototype'],
|
|
'%WeakMapPrototype%': ['WeakMap', 'prototype'],
|
|
'%WeakSetPrototype%': ['WeakSet', 'prototype']
|
|
};
|
|
|
|
var bind = require('function-bind');
|
|
var hasOwn = require('hasown');
|
|
var $concat = bind.call($call, Array.prototype.concat);
|
|
var $spliceApply = bind.call($apply, Array.prototype.splice);
|
|
var $replace = bind.call($call, String.prototype.replace);
|
|
var $strSlice = bind.call($call, String.prototype.slice);
|
|
var $exec = bind.call($call, RegExp.prototype.exec);
|
|
|
|
/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
|
|
var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
|
|
var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
|
|
var stringToPath = function stringToPath(string) {
|
|
var first = $strSlice(string, 0, 1);
|
|
var last = $strSlice(string, -1);
|
|
if (first === '%' && last !== '%') {
|
|
throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
|
|
} else if (last === '%' && first !== '%') {
|
|
throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
|
|
}
|
|
var result = [];
|
|
$replace(string, rePropName, function (match, number, quote, subString) {
|
|
result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
|
|
});
|
|
return result;
|
|
};
|
|
/* end adaptation */
|
|
|
|
var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
|
|
var intrinsicName = name;
|
|
var alias;
|
|
if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
|
|
alias = LEGACY_ALIASES[intrinsicName];
|
|
intrinsicName = '%' + alias[0] + '%';
|
|
}
|
|
|
|
if (hasOwn(INTRINSICS, intrinsicName)) {
|
|
var value = INTRINSICS[intrinsicName];
|
|
if (value === needsEval) {
|
|
value = doEval(intrinsicName);
|
|
}
|
|
if (typeof value === 'undefined' && !allowMissing) {
|
|
throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
|
|
}
|
|
|
|
return {
|
|
alias: alias,
|
|
name: intrinsicName,
|
|
value: value
|
|
};
|
|
}
|
|
|
|
throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
|
|
};
|
|
|
|
module.exports = function GetIntrinsic(name, allowMissing) {
|
|
if (typeof name !== 'string' || name.length === 0) {
|
|
throw new $TypeError('intrinsic name must be a non-empty string');
|
|
}
|
|
if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
|
|
throw new $TypeError('"allowMissing" argument must be a boolean');
|
|
}
|
|
|
|
if ($exec(/^%?[^%]*%?$/, name) === null) {
|
|
throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
|
|
}
|
|
var parts = stringToPath(name);
|
|
var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
|
|
|
|
var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
|
|
var intrinsicRealName = intrinsic.name;
|
|
var value = intrinsic.value;
|
|
var skipFurtherCaching = false;
|
|
|
|
var alias = intrinsic.alias;
|
|
if (alias) {
|
|
intrinsicBaseName = alias[0];
|
|
$spliceApply(parts, $concat([0, 1], alias));
|
|
}
|
|
|
|
for (var i = 1, isOwn = true; i < parts.length; i += 1) {
|
|
var part = parts[i];
|
|
var first = $strSlice(part, 0, 1);
|
|
var last = $strSlice(part, -1);
|
|
if (
|
|
(
|
|
(first === '"' || first === "'" || first === '`')
|
|
|| (last === '"' || last === "'" || last === '`')
|
|
)
|
|
&& first !== last
|
|
) {
|
|
throw new $SyntaxError('property names with quotes must have matching quotes');
|
|
}
|
|
if (part === 'constructor' || !isOwn) {
|
|
skipFurtherCaching = true;
|
|
}
|
|
|
|
intrinsicBaseName += '.' + part;
|
|
intrinsicRealName = '%' + intrinsicBaseName + '%';
|
|
|
|
if (hasOwn(INTRINSICS, intrinsicRealName)) {
|
|
value = INTRINSICS[intrinsicRealName];
|
|
} else if (value != null) {
|
|
if (!(part in value)) {
|
|
if (!allowMissing) {
|
|
throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
|
|
}
|
|
return void undefined;
|
|
}
|
|
if ($gOPD && (i + 1) >= parts.length) {
|
|
var desc = $gOPD(value, part);
|
|
isOwn = !!desc;
|
|
|
|
// By convention, when a data property is converted to an accessor
|
|
// property to emulate a data property that does not suffer from
|
|
// the override mistake, that accessor's getter is marked with
|
|
// an `originalValue` property. Here, when we detect this, we
|
|
// uphold the illusion by pretending to see that original data
|
|
// property, i.e., returning the value rather than the getter
|
|
// itself.
|
|
if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
|
|
value = desc.get;
|
|
} else {
|
|
value = value[part];
|
|
}
|
|
} else {
|
|
isOwn = hasOwn(value, part);
|
|
value = value[part];
|
|
}
|
|
|
|
if (isOwn && !skipFurtherCaching) {
|
|
INTRINSICS[intrinsicRealName] = value;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
};
|
|
|
|
},{"call-bind-apply-helpers/functionApply":15,"call-bind-apply-helpers/functionCall":16,"es-define-property":23,"es-errors":25,"es-errors/eval":24,"es-errors/range":26,"es-errors/ref":27,"es-errors/syntax":28,"es-errors/type":29,"es-errors/uri":30,"es-object-atoms":31,"function-bind":34,"get-proto":38,"get-proto/Object.getPrototypeOf":36,"get-proto/Reflect.getPrototypeOf":37,"gopd":40,"has-symbols":42,"hasown":45,"math-intrinsics/abs":52,"math-intrinsics/floor":53,"math-intrinsics/max":55,"math-intrinsics/min":56,"math-intrinsics/pow":57,"math-intrinsics/round":58,"math-intrinsics/sign":59}],36:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var $Object = require('es-object-atoms');
|
|
|
|
/** @type {import('./Object.getPrototypeOf')} */
|
|
module.exports = $Object.getPrototypeOf || null;
|
|
|
|
},{"es-object-atoms":31}],37:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./Reflect.getPrototypeOf')} */
|
|
module.exports = (typeof Reflect !== 'undefined' && Reflect.getPrototypeOf) || null;
|
|
|
|
},{}],38:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var reflectGetProto = require('./Reflect.getPrototypeOf');
|
|
var originalGetProto = require('./Object.getPrototypeOf');
|
|
|
|
var getDunderProto = require('dunder-proto/get');
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = reflectGetProto
|
|
? function getProto(O) {
|
|
// @ts-expect-error TS can't narrow inside a closure, for some reason
|
|
return reflectGetProto(O);
|
|
}
|
|
: originalGetProto
|
|
? function getProto(O) {
|
|
if (!O || (typeof O !== 'object' && typeof O !== 'function')) {
|
|
throw new TypeError('getProto: not an object');
|
|
}
|
|
// @ts-expect-error TS can't narrow inside a closure, for some reason
|
|
return originalGetProto(O);
|
|
}
|
|
: getDunderProto
|
|
? function getProto(O) {
|
|
// @ts-expect-error TS can't narrow inside a closure, for some reason
|
|
return getDunderProto(O);
|
|
}
|
|
: null;
|
|
|
|
},{"./Object.getPrototypeOf":36,"./Reflect.getPrototypeOf":37,"dunder-proto/get":22}],39:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./gOPD')} */
|
|
module.exports = Object.getOwnPropertyDescriptor;
|
|
|
|
},{}],40:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('.')} */
|
|
var $gOPD = require('./gOPD');
|
|
|
|
if ($gOPD) {
|
|
try {
|
|
$gOPD([], 'length');
|
|
} catch (e) {
|
|
// IE 8 has a broken gOPD
|
|
$gOPD = null;
|
|
}
|
|
}
|
|
|
|
module.exports = $gOPD;
|
|
|
|
},{"./gOPD":39}],41:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var $defineProperty = require('es-define-property');
|
|
|
|
var hasPropertyDescriptors = function hasPropertyDescriptors() {
|
|
return !!$defineProperty;
|
|
};
|
|
|
|
hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
|
|
// node v0.6 has a bug where array lengths can be Set but not Defined
|
|
if (!$defineProperty) {
|
|
return null;
|
|
}
|
|
try {
|
|
return $defineProperty([], 'length', { value: 1 }).length !== 1;
|
|
} catch (e) {
|
|
// In Firefox 4-22, defining length on an array throws an exception.
|
|
return true;
|
|
}
|
|
};
|
|
|
|
module.exports = hasPropertyDescriptors;
|
|
|
|
},{"es-define-property":23}],42:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var origSymbol = typeof Symbol !== 'undefined' && Symbol;
|
|
var hasSymbolSham = require('./shams');
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function hasNativeSymbols() {
|
|
if (typeof origSymbol !== 'function') { return false; }
|
|
if (typeof Symbol !== 'function') { return false; }
|
|
if (typeof origSymbol('foo') !== 'symbol') { return false; }
|
|
if (typeof Symbol('bar') !== 'symbol') { return false; }
|
|
|
|
return hasSymbolSham();
|
|
};
|
|
|
|
},{"./shams":43}],43:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./shams')} */
|
|
/* eslint complexity: [2, 18], max-statements: [2, 33] */
|
|
module.exports = function hasSymbols() {
|
|
if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
|
|
if (typeof Symbol.iterator === 'symbol') { return true; }
|
|
|
|
/** @type {{ [k in symbol]?: unknown }} */
|
|
var obj = {};
|
|
var sym = Symbol('test');
|
|
var symObj = Object(sym);
|
|
if (typeof sym === 'string') { return false; }
|
|
|
|
if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
|
|
if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
|
|
|
|
// temp disabled per https://github.com/ljharb/object.assign/issues/17
|
|
// if (sym instanceof Symbol) { return false; }
|
|
// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
|
|
// if (!(symObj instanceof Symbol)) { return false; }
|
|
|
|
// if (typeof Symbol.prototype.toString !== 'function') { return false; }
|
|
// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
|
|
|
|
var symVal = 42;
|
|
obj[sym] = symVal;
|
|
for (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
|
|
if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
|
|
|
|
if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
|
|
|
|
var syms = Object.getOwnPropertySymbols(obj);
|
|
if (syms.length !== 1 || syms[0] !== sym) { return false; }
|
|
|
|
if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
|
|
|
|
if (typeof Object.getOwnPropertyDescriptor === 'function') {
|
|
// eslint-disable-next-line no-extra-parens
|
|
var descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym));
|
|
if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
},{}],44:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var hasSymbols = require('has-symbols/shams');
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function hasToStringTagShams() {
|
|
return hasSymbols() && !!Symbol.toStringTag;
|
|
};
|
|
|
|
},{"has-symbols/shams":43}],45:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var call = Function.prototype.call;
|
|
var $hasOwn = Object.prototype.hasOwnProperty;
|
|
var bind = require('function-bind');
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = bind.call(call, $hasOwn);
|
|
|
|
},{"function-bind":34}],46:[function(require,module,exports){
|
|
if (typeof Object.create === 'function') {
|
|
// implementation from standard node.js 'util' module
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
})
|
|
}
|
|
};
|
|
} else {
|
|
// old school shim for old browsers
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor
|
|
var TempCtor = function () {}
|
|
TempCtor.prototype = superCtor.prototype
|
|
ctor.prototype = new TempCtor()
|
|
ctor.prototype.constructor = ctor
|
|
}
|
|
}
|
|
}
|
|
|
|
},{}],47:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var hasToStringTag = require('has-tostringtag/shams')();
|
|
var callBound = require('call-bound');
|
|
|
|
var $toString = callBound('Object.prototype.toString');
|
|
|
|
/** @type {import('.')} */
|
|
var isStandardArguments = function isArguments(value) {
|
|
if (
|
|
hasToStringTag
|
|
&& value
|
|
&& typeof value === 'object'
|
|
&& Symbol.toStringTag in value
|
|
) {
|
|
return false;
|
|
}
|
|
return $toString(value) === '[object Arguments]';
|
|
};
|
|
|
|
/** @type {import('.')} */
|
|
var isLegacyArguments = function isArguments(value) {
|
|
if (isStandardArguments(value)) {
|
|
return true;
|
|
}
|
|
return value !== null
|
|
&& typeof value === 'object'
|
|
&& 'length' in value
|
|
&& typeof value.length === 'number'
|
|
&& value.length >= 0
|
|
&& $toString(value) !== '[object Array]'
|
|
&& 'callee' in value
|
|
&& $toString(value.callee) === '[object Function]';
|
|
};
|
|
|
|
var supportsStandardArguments = (function () {
|
|
return isStandardArguments(arguments);
|
|
}());
|
|
|
|
// @ts-expect-error TODO make this not error
|
|
isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
|
|
|
|
},{"call-bound":20,"has-tostringtag/shams":44}],48:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var fnToStr = Function.prototype.toString;
|
|
var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;
|
|
var badArrayLike;
|
|
var isCallableMarker;
|
|
if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {
|
|
try {
|
|
badArrayLike = Object.defineProperty({}, 'length', {
|
|
get: function () {
|
|
throw isCallableMarker;
|
|
}
|
|
});
|
|
isCallableMarker = {};
|
|
// eslint-disable-next-line no-throw-literal
|
|
reflectApply(function () { throw 42; }, null, badArrayLike);
|
|
} catch (_) {
|
|
if (_ !== isCallableMarker) {
|
|
reflectApply = null;
|
|
}
|
|
}
|
|
} else {
|
|
reflectApply = null;
|
|
}
|
|
|
|
var constructorRegex = /^\s*class\b/;
|
|
var isES6ClassFn = function isES6ClassFunction(value) {
|
|
try {
|
|
var fnStr = fnToStr.call(value);
|
|
return constructorRegex.test(fnStr);
|
|
} catch (e) {
|
|
return false; // not a function
|
|
}
|
|
};
|
|
|
|
var tryFunctionObject = function tryFunctionToStr(value) {
|
|
try {
|
|
if (isES6ClassFn(value)) { return false; }
|
|
fnToStr.call(value);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
var toStr = Object.prototype.toString;
|
|
var objectClass = '[object Object]';
|
|
var fnClass = '[object Function]';
|
|
var genClass = '[object GeneratorFunction]';
|
|
var ddaClass = '[object HTMLAllCollection]'; // IE 11
|
|
var ddaClass2 = '[object HTML document.all class]';
|
|
var ddaClass3 = '[object HTMLCollection]'; // IE 9-10
|
|
var hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`
|
|
|
|
var isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing
|
|
|
|
var isDDA = function isDocumentDotAll() { return false; };
|
|
if (typeof document === 'object') {
|
|
// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly
|
|
var all = document.all;
|
|
if (toStr.call(all) === toStr.call(document.all)) {
|
|
isDDA = function isDocumentDotAll(value) {
|
|
/* globals document: false */
|
|
// in IE 6-8, typeof document.all is "object" and it's truthy
|
|
if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {
|
|
try {
|
|
var str = toStr.call(value);
|
|
return (
|
|
str === ddaClass
|
|
|| str === ddaClass2
|
|
|| str === ddaClass3 // opera 12.16
|
|
|| str === objectClass // IE 6-8
|
|
) && value('') == null; // eslint-disable-line eqeqeq
|
|
} catch (e) { /**/ }
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
}
|
|
|
|
module.exports = reflectApply
|
|
? function isCallable(value) {
|
|
if (isDDA(value)) { return true; }
|
|
if (!value) { return false; }
|
|
if (typeof value !== 'function' && typeof value !== 'object') { return false; }
|
|
try {
|
|
reflectApply(value, null, badArrayLike);
|
|
} catch (e) {
|
|
if (e !== isCallableMarker) { return false; }
|
|
}
|
|
return !isES6ClassFn(value) && tryFunctionObject(value);
|
|
}
|
|
: function isCallable(value) {
|
|
if (isDDA(value)) { return true; }
|
|
if (!value) { return false; }
|
|
if (typeof value !== 'function' && typeof value !== 'object') { return false; }
|
|
if (hasToStringTag) { return tryFunctionObject(value); }
|
|
if (isES6ClassFn(value)) { return false; }
|
|
var strClass = toStr.call(value);
|
|
if (strClass !== fnClass && strClass !== genClass && !(/^\[object HTML/).test(strClass)) { return false; }
|
|
return tryFunctionObject(value);
|
|
};
|
|
|
|
},{}],49:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var callBound = require('call-bound');
|
|
var safeRegexTest = require('safe-regex-test');
|
|
var isFnRegex = safeRegexTest(/^\s*(?:function)?\*/);
|
|
var hasToStringTag = require('has-tostringtag/shams')();
|
|
var getProto = require('get-proto');
|
|
|
|
var toStr = callBound('Object.prototype.toString');
|
|
var fnToStr = callBound('Function.prototype.toString');
|
|
|
|
var getGeneratorFunc = function () { // eslint-disable-line consistent-return
|
|
if (!hasToStringTag) {
|
|
return false;
|
|
}
|
|
try {
|
|
return Function('return function*() {}')();
|
|
} catch (e) {
|
|
}
|
|
};
|
|
/** @type {undefined | false | null | GeneratorFunctionConstructor} */
|
|
var GeneratorFunction;
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function isGeneratorFunction(fn) {
|
|
if (typeof fn !== 'function') {
|
|
return false;
|
|
}
|
|
if (isFnRegex(fnToStr(fn))) {
|
|
return true;
|
|
}
|
|
if (!hasToStringTag) {
|
|
var str = toStr(fn);
|
|
return str === '[object GeneratorFunction]';
|
|
}
|
|
if (!getProto) {
|
|
return false;
|
|
}
|
|
if (typeof GeneratorFunction === 'undefined') {
|
|
var generatorFunc = getGeneratorFunc();
|
|
GeneratorFunction = generatorFunc
|
|
// eslint-disable-next-line no-extra-parens
|
|
? /** @type {GeneratorFunctionConstructor} */ (getProto(generatorFunc))
|
|
: false;
|
|
}
|
|
return getProto(fn) === GeneratorFunction;
|
|
};
|
|
|
|
},{"call-bound":20,"get-proto":38,"has-tostringtag/shams":44,"safe-regex-test":68}],50:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var callBound = require('call-bound');
|
|
var hasToStringTag = require('has-tostringtag/shams')();
|
|
var hasOwn = require('hasown');
|
|
var gOPD = require('gopd');
|
|
|
|
/** @type {import('.')} */
|
|
var fn;
|
|
|
|
if (hasToStringTag) {
|
|
/** @type {(receiver: ThisParameterType<typeof RegExp.prototype.exec>, ...args: Parameters<typeof RegExp.prototype.exec>) => ReturnType<typeof RegExp.prototype.exec>} */
|
|
var $exec = callBound('RegExp.prototype.exec');
|
|
/** @type {object} */
|
|
var isRegexMarker = {};
|
|
|
|
var throwRegexMarker = function () {
|
|
throw isRegexMarker;
|
|
};
|
|
/** @type {{ toString(): never, valueOf(): never, [Symbol.toPrimitive]?(): never }} */
|
|
var badStringifier = {
|
|
toString: throwRegexMarker,
|
|
valueOf: throwRegexMarker
|
|
};
|
|
|
|
if (typeof Symbol.toPrimitive === 'symbol') {
|
|
badStringifier[Symbol.toPrimitive] = throwRegexMarker;
|
|
}
|
|
|
|
/** @type {import('.')} */
|
|
// @ts-expect-error TS can't figure out that the $exec call always throws
|
|
// eslint-disable-next-line consistent-return
|
|
fn = function isRegex(value) {
|
|
if (!value || typeof value !== 'object') {
|
|
return false;
|
|
}
|
|
|
|
// eslint-disable-next-line no-extra-parens
|
|
var descriptor = /** @type {NonNullable<typeof gOPD>} */ (gOPD)(/** @type {{ lastIndex?: unknown }} */ (value), 'lastIndex');
|
|
var hasLastIndexDataProperty = descriptor && hasOwn(descriptor, 'value');
|
|
if (!hasLastIndexDataProperty) {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
// eslint-disable-next-line no-extra-parens
|
|
$exec(value, /** @type {string} */ (/** @type {unknown} */ (badStringifier)));
|
|
} catch (e) {
|
|
return e === isRegexMarker;
|
|
}
|
|
};
|
|
} else {
|
|
/** @type {(receiver: ThisParameterType<typeof Object.prototype.toString>, ...args: Parameters<typeof Object.prototype.toString>) => ReturnType<typeof Object.prototype.toString>} */
|
|
var $toString = callBound('Object.prototype.toString');
|
|
/** @const @type {'[object RegExp]'} */
|
|
var regexClass = '[object RegExp]';
|
|
|
|
/** @type {import('.')} */
|
|
fn = function isRegex(value) {
|
|
// In older browsers, typeof regex incorrectly returns 'function'
|
|
if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
|
|
return false;
|
|
}
|
|
|
|
return $toString(value) === regexClass;
|
|
};
|
|
}
|
|
|
|
module.exports = fn;
|
|
|
|
},{"call-bound":20,"gopd":40,"has-tostringtag/shams":44,"hasown":45}],51:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var whichTypedArray = require('which-typed-array');
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function isTypedArray(value) {
|
|
return !!whichTypedArray(value);
|
|
};
|
|
|
|
},{"which-typed-array":79}],52:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./abs')} */
|
|
module.exports = Math.abs;
|
|
|
|
},{}],53:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./floor')} */
|
|
module.exports = Math.floor;
|
|
|
|
},{}],54:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./isNaN')} */
|
|
module.exports = Number.isNaN || function isNaN(a) {
|
|
return a !== a;
|
|
};
|
|
|
|
},{}],55:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./max')} */
|
|
module.exports = Math.max;
|
|
|
|
},{}],56:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./min')} */
|
|
module.exports = Math.min;
|
|
|
|
},{}],57:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./pow')} */
|
|
module.exports = Math.pow;
|
|
|
|
},{}],58:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('./round')} */
|
|
module.exports = Math.round;
|
|
|
|
},{}],59:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var $isNaN = require('./isNaN');
|
|
|
|
/** @type {import('./sign')} */
|
|
module.exports = function sign(number) {
|
|
if ($isNaN(number) || number === 0) {
|
|
return number;
|
|
}
|
|
return number < 0 ? -1 : +1;
|
|
};
|
|
|
|
},{"./isNaN":54}],60:[function(require,module,exports){
|
|
(function (global){(function (){
|
|
var hasMap = typeof Map === 'function' && Map.prototype;
|
|
var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
|
|
var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;
|
|
var mapForEach = hasMap && Map.prototype.forEach;
|
|
var hasSet = typeof Set === 'function' && Set.prototype;
|
|
var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
|
|
var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;
|
|
var setForEach = hasSet && Set.prototype.forEach;
|
|
var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;
|
|
var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
|
|
var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;
|
|
var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
|
|
var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;
|
|
var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
|
|
var booleanValueOf = Boolean.prototype.valueOf;
|
|
var objectToString = Object.prototype.toString;
|
|
var functionToString = Function.prototype.toString;
|
|
var $match = String.prototype.match;
|
|
var $slice = String.prototype.slice;
|
|
var $replace = String.prototype.replace;
|
|
var $toUpperCase = String.prototype.toUpperCase;
|
|
var $toLowerCase = String.prototype.toLowerCase;
|
|
var $test = RegExp.prototype.test;
|
|
var $concat = Array.prototype.concat;
|
|
var $join = Array.prototype.join;
|
|
var $arrSlice = Array.prototype.slice;
|
|
var $floor = Math.floor;
|
|
var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
|
|
var gOPS = Object.getOwnPropertySymbols;
|
|
var symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;
|
|
var hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';
|
|
// ie, `has-tostringtag/shams
|
|
var toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol')
|
|
? Symbol.toStringTag
|
|
: null;
|
|
var isEnumerable = Object.prototype.propertyIsEnumerable;
|
|
|
|
var gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || (
|
|
[].__proto__ === Array.prototype // eslint-disable-line no-proto
|
|
? function (O) {
|
|
return O.__proto__; // eslint-disable-line no-proto
|
|
}
|
|
: null
|
|
);
|
|
|
|
function addNumericSeparator(num, str) {
|
|
if (
|
|
num === Infinity
|
|
|| num === -Infinity
|
|
|| num !== num
|
|
|| (num && num > -1000 && num < 1000)
|
|
|| $test.call(/e/, str)
|
|
) {
|
|
return str;
|
|
}
|
|
var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
|
|
if (typeof num === 'number') {
|
|
var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)
|
|
if (int !== num) {
|
|
var intStr = String(int);
|
|
var dec = $slice.call(str, intStr.length + 1);
|
|
return $replace.call(intStr, sepRegex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');
|
|
}
|
|
}
|
|
return $replace.call(str, sepRegex, '$&_');
|
|
}
|
|
|
|
var utilInspect = require('./util.inspect');
|
|
var inspectCustom = utilInspect.custom;
|
|
var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
|
|
|
|
var quotes = {
|
|
__proto__: null,
|
|
'double': '"',
|
|
single: "'"
|
|
};
|
|
var quoteREs = {
|
|
__proto__: null,
|
|
'double': /(["\\])/g,
|
|
single: /(['\\])/g
|
|
};
|
|
|
|
module.exports = function inspect_(obj, options, depth, seen) {
|
|
var opts = options || {};
|
|
|
|
if (has(opts, 'quoteStyle') && !has(quotes, opts.quoteStyle)) {
|
|
throw new TypeError('option "quoteStyle" must be "single" or "double"');
|
|
}
|
|
if (
|
|
has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'
|
|
? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity
|
|
: opts.maxStringLength !== null
|
|
)
|
|
) {
|
|
throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
|
|
}
|
|
var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;
|
|
if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {
|
|
throw new TypeError('option "customInspect", if provided, must be `true`, `false`, or `\'symbol\'`');
|
|
}
|
|
|
|
if (
|
|
has(opts, 'indent')
|
|
&& opts.indent !== null
|
|
&& opts.indent !== '\t'
|
|
&& !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)
|
|
) {
|
|
throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
|
|
}
|
|
if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !== 'boolean') {
|
|
throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
|
|
}
|
|
var numericSeparator = opts.numericSeparator;
|
|
|
|
if (typeof obj === 'undefined') {
|
|
return 'undefined';
|
|
}
|
|
if (obj === null) {
|
|
return 'null';
|
|
}
|
|
if (typeof obj === 'boolean') {
|
|
return obj ? 'true' : 'false';
|
|
}
|
|
|
|
if (typeof obj === 'string') {
|
|
return inspectString(obj, opts);
|
|
}
|
|
if (typeof obj === 'number') {
|
|
if (obj === 0) {
|
|
return Infinity / obj > 0 ? '0' : '-0';
|
|
}
|
|
var str = String(obj);
|
|
return numericSeparator ? addNumericSeparator(obj, str) : str;
|
|
}
|
|
if (typeof obj === 'bigint') {
|
|
var bigIntStr = String(obj) + 'n';
|
|
return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
|
|
}
|
|
|
|
var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;
|
|
if (typeof depth === 'undefined') { depth = 0; }
|
|
if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
|
|
return isArray(obj) ? '[Array]' : '[Object]';
|
|
}
|
|
|
|
var indent = getIndent(opts, depth);
|
|
|
|
if (typeof seen === 'undefined') {
|
|
seen = [];
|
|
} else if (indexOf(seen, obj) >= 0) {
|
|
return '[Circular]';
|
|
}
|
|
|
|
function inspect(value, from, noIndent) {
|
|
if (from) {
|
|
seen = $arrSlice.call(seen);
|
|
seen.push(from);
|
|
}
|
|
if (noIndent) {
|
|
var newOpts = {
|
|
depth: opts.depth
|
|
};
|
|
if (has(opts, 'quoteStyle')) {
|
|
newOpts.quoteStyle = opts.quoteStyle;
|
|
}
|
|
return inspect_(value, newOpts, depth + 1, seen);
|
|
}
|
|
return inspect_(value, opts, depth + 1, seen);
|
|
}
|
|
|
|
if (typeof obj === 'function' && !isRegExp(obj)) { // in older engines, regexes are callable
|
|
var name = nameOf(obj);
|
|
var keys = arrObjKeys(obj, inspect);
|
|
return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');
|
|
}
|
|
if (isSymbol(obj)) {
|
|
var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, '$1') : symToString.call(obj);
|
|
return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;
|
|
}
|
|
if (isElement(obj)) {
|
|
var s = '<' + $toLowerCase.call(String(obj.nodeName));
|
|
var attrs = obj.attributes || [];
|
|
for (var i = 0; i < attrs.length; i++) {
|
|
s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);
|
|
}
|
|
s += '>';
|
|
if (obj.childNodes && obj.childNodes.length) { s += '...'; }
|
|
s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';
|
|
return s;
|
|
}
|
|
if (isArray(obj)) {
|
|
if (obj.length === 0) { return '[]'; }
|
|
var xs = arrObjKeys(obj, inspect);
|
|
if (indent && !singleLineValues(xs)) {
|
|
return '[' + indentedJoin(xs, indent) + ']';
|
|
}
|
|
return '[ ' + $join.call(xs, ', ') + ' ]';
|
|
}
|
|
if (isError(obj)) {
|
|
var parts = arrObjKeys(obj, inspect);
|
|
if (!('cause' in Error.prototype) && 'cause' in obj && !isEnumerable.call(obj, 'cause')) {
|
|
return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }';
|
|
}
|
|
if (parts.length === 0) { return '[' + String(obj) + ']'; }
|
|
return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }';
|
|
}
|
|
if (typeof obj === 'object' && customInspect) {
|
|
if (inspectSymbol && typeof obj[inspectSymbol] === 'function' && utilInspect) {
|
|
return utilInspect(obj, { depth: maxDepth - depth });
|
|
} else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {
|
|
return obj.inspect();
|
|
}
|
|
}
|
|
if (isMap(obj)) {
|
|
var mapParts = [];
|
|
if (mapForEach) {
|
|
mapForEach.call(obj, function (value, key) {
|
|
mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));
|
|
});
|
|
}
|
|
return collectionOf('Map', mapSize.call(obj), mapParts, indent);
|
|
}
|
|
if (isSet(obj)) {
|
|
var setParts = [];
|
|
if (setForEach) {
|
|
setForEach.call(obj, function (value) {
|
|
setParts.push(inspect(value, obj));
|
|
});
|
|
}
|
|
return collectionOf('Set', setSize.call(obj), setParts, indent);
|
|
}
|
|
if (isWeakMap(obj)) {
|
|
return weakCollectionOf('WeakMap');
|
|
}
|
|
if (isWeakSet(obj)) {
|
|
return weakCollectionOf('WeakSet');
|
|
}
|
|
if (isWeakRef(obj)) {
|
|
return weakCollectionOf('WeakRef');
|
|
}
|
|
if (isNumber(obj)) {
|
|
return markBoxed(inspect(Number(obj)));
|
|
}
|
|
if (isBigInt(obj)) {
|
|
return markBoxed(inspect(bigIntValueOf.call(obj)));
|
|
}
|
|
if (isBoolean(obj)) {
|
|
return markBoxed(booleanValueOf.call(obj));
|
|
}
|
|
if (isString(obj)) {
|
|
return markBoxed(inspect(String(obj)));
|
|
}
|
|
// note: in IE 8, sometimes `global !== window` but both are the prototypes of each other
|
|
/* eslint-env browser */
|
|
if (typeof window !== 'undefined' && obj === window) {
|
|
return '{ [object Window] }';
|
|
}
|
|
if (
|
|
(typeof globalThis !== 'undefined' && obj === globalThis)
|
|
|| (typeof global !== 'undefined' && obj === global)
|
|
) {
|
|
return '{ [object globalThis] }';
|
|
}
|
|
if (!isDate(obj) && !isRegExp(obj)) {
|
|
var ys = arrObjKeys(obj, inspect);
|
|
var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
|
|
var protoTag = obj instanceof Object ? '' : 'null prototype';
|
|
var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : '';
|
|
var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';
|
|
var tag = constructorTag + (stringTag || protoTag ? '[' + $join.call($concat.call([], stringTag || [], protoTag || []), ': ') + '] ' : '');
|
|
if (ys.length === 0) { return tag + '{}'; }
|
|
if (indent) {
|
|
return tag + '{' + indentedJoin(ys, indent) + '}';
|
|
}
|
|
return tag + '{ ' + $join.call(ys, ', ') + ' }';
|
|
}
|
|
return String(obj);
|
|
};
|
|
|
|
function wrapQuotes(s, defaultStyle, opts) {
|
|
var style = opts.quoteStyle || defaultStyle;
|
|
var quoteChar = quotes[style];
|
|
return quoteChar + s + quoteChar;
|
|
}
|
|
|
|
function quote(s) {
|
|
return $replace.call(String(s), /"/g, '"');
|
|
}
|
|
|
|
function canTrustToString(obj) {
|
|
return !toStringTag || !(typeof obj === 'object' && (toStringTag in obj || typeof obj[toStringTag] !== 'undefined'));
|
|
}
|
|
function isArray(obj) { return toStr(obj) === '[object Array]' && canTrustToString(obj); }
|
|
function isDate(obj) { return toStr(obj) === '[object Date]' && canTrustToString(obj); }
|
|
function isRegExp(obj) { return toStr(obj) === '[object RegExp]' && canTrustToString(obj); }
|
|
function isError(obj) { return toStr(obj) === '[object Error]' && canTrustToString(obj); }
|
|
function isString(obj) { return toStr(obj) === '[object String]' && canTrustToString(obj); }
|
|
function isNumber(obj) { return toStr(obj) === '[object Number]' && canTrustToString(obj); }
|
|
function isBoolean(obj) { return toStr(obj) === '[object Boolean]' && canTrustToString(obj); }
|
|
|
|
// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives
|
|
function isSymbol(obj) {
|
|
if (hasShammedSymbols) {
|
|
return obj && typeof obj === 'object' && obj instanceof Symbol;
|
|
}
|
|
if (typeof obj === 'symbol') {
|
|
return true;
|
|
}
|
|
if (!obj || typeof obj !== 'object' || !symToString) {
|
|
return false;
|
|
}
|
|
try {
|
|
symToString.call(obj);
|
|
return true;
|
|
} catch (e) {}
|
|
return false;
|
|
}
|
|
|
|
function isBigInt(obj) {
|
|
if (!obj || typeof obj !== 'object' || !bigIntValueOf) {
|
|
return false;
|
|
}
|
|
try {
|
|
bigIntValueOf.call(obj);
|
|
return true;
|
|
} catch (e) {}
|
|
return false;
|
|
}
|
|
|
|
var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };
|
|
function has(obj, key) {
|
|
return hasOwn.call(obj, key);
|
|
}
|
|
|
|
function toStr(obj) {
|
|
return objectToString.call(obj);
|
|
}
|
|
|
|
function nameOf(f) {
|
|
if (f.name) { return f.name; }
|
|
var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
|
|
if (m) { return m[1]; }
|
|
return null;
|
|
}
|
|
|
|
function indexOf(xs, x) {
|
|
if (xs.indexOf) { return xs.indexOf(x); }
|
|
for (var i = 0, l = xs.length; i < l; i++) {
|
|
if (xs[i] === x) { return i; }
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
function isMap(x) {
|
|
if (!mapSize || !x || typeof x !== 'object') {
|
|
return false;
|
|
}
|
|
try {
|
|
mapSize.call(x);
|
|
try {
|
|
setSize.call(x);
|
|
} catch (s) {
|
|
return true;
|
|
}
|
|
return x instanceof Map; // core-js workaround, pre-v2.5.0
|
|
} catch (e) {}
|
|
return false;
|
|
}
|
|
|
|
function isWeakMap(x) {
|
|
if (!weakMapHas || !x || typeof x !== 'object') {
|
|
return false;
|
|
}
|
|
try {
|
|
weakMapHas.call(x, weakMapHas);
|
|
try {
|
|
weakSetHas.call(x, weakSetHas);
|
|
} catch (s) {
|
|
return true;
|
|
}
|
|
return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
|
|
} catch (e) {}
|
|
return false;
|
|
}
|
|
|
|
function isWeakRef(x) {
|
|
if (!weakRefDeref || !x || typeof x !== 'object') {
|
|
return false;
|
|
}
|
|
try {
|
|
weakRefDeref.call(x);
|
|
return true;
|
|
} catch (e) {}
|
|
return false;
|
|
}
|
|
|
|
function isSet(x) {
|
|
if (!setSize || !x || typeof x !== 'object') {
|
|
return false;
|
|
}
|
|
try {
|
|
setSize.call(x);
|
|
try {
|
|
mapSize.call(x);
|
|
} catch (m) {
|
|
return true;
|
|
}
|
|
return x instanceof Set; // core-js workaround, pre-v2.5.0
|
|
} catch (e) {}
|
|
return false;
|
|
}
|
|
|
|
function isWeakSet(x) {
|
|
if (!weakSetHas || !x || typeof x !== 'object') {
|
|
return false;
|
|
}
|
|
try {
|
|
weakSetHas.call(x, weakSetHas);
|
|
try {
|
|
weakMapHas.call(x, weakMapHas);
|
|
} catch (s) {
|
|
return true;
|
|
}
|
|
return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
|
|
} catch (e) {}
|
|
return false;
|
|
}
|
|
|
|
function isElement(x) {
|
|
if (!x || typeof x !== 'object') { return false; }
|
|
if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
|
|
return true;
|
|
}
|
|
return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';
|
|
}
|
|
|
|
function inspectString(str, opts) {
|
|
if (str.length > opts.maxStringLength) {
|
|
var remaining = str.length - opts.maxStringLength;
|
|
var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');
|
|
return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
|
|
}
|
|
var quoteRE = quoteREs[opts.quoteStyle || 'single'];
|
|
quoteRE.lastIndex = 0;
|
|
// eslint-disable-next-line no-control-regex
|
|
var s = $replace.call($replace.call(str, quoteRE, '\\$1'), /[\x00-\x1f]/g, lowbyte);
|
|
return wrapQuotes(s, 'single', opts);
|
|
}
|
|
|
|
function lowbyte(c) {
|
|
var n = c.charCodeAt(0);
|
|
var x = {
|
|
8: 'b',
|
|
9: 't',
|
|
10: 'n',
|
|
12: 'f',
|
|
13: 'r'
|
|
}[n];
|
|
if (x) { return '\\' + x; }
|
|
return '\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16));
|
|
}
|
|
|
|
function markBoxed(str) {
|
|
return 'Object(' + str + ')';
|
|
}
|
|
|
|
function weakCollectionOf(type) {
|
|
return type + ' { ? }';
|
|
}
|
|
|
|
function collectionOf(type, size, entries, indent) {
|
|
var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ', ');
|
|
return type + ' (' + size + ') {' + joinedEntries + '}';
|
|
}
|
|
|
|
function singleLineValues(xs) {
|
|
for (var i = 0; i < xs.length; i++) {
|
|
if (indexOf(xs[i], '\n') >= 0) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function getIndent(opts, depth) {
|
|
var baseIndent;
|
|
if (opts.indent === '\t') {
|
|
baseIndent = '\t';
|
|
} else if (typeof opts.indent === 'number' && opts.indent > 0) {
|
|
baseIndent = $join.call(Array(opts.indent + 1), ' ');
|
|
} else {
|
|
return null;
|
|
}
|
|
return {
|
|
base: baseIndent,
|
|
prev: $join.call(Array(depth + 1), baseIndent)
|
|
};
|
|
}
|
|
|
|
function indentedJoin(xs, indent) {
|
|
if (xs.length === 0) { return ''; }
|
|
var lineJoiner = '\n' + indent.prev + indent.base;
|
|
return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\n' + indent.prev;
|
|
}
|
|
|
|
function arrObjKeys(obj, inspect) {
|
|
var isArr = isArray(obj);
|
|
var xs = [];
|
|
if (isArr) {
|
|
xs.length = obj.length;
|
|
for (var i = 0; i < obj.length; i++) {
|
|
xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
|
|
}
|
|
}
|
|
var syms = typeof gOPS === 'function' ? gOPS(obj) : [];
|
|
var symMap;
|
|
if (hasShammedSymbols) {
|
|
symMap = {};
|
|
for (var k = 0; k < syms.length; k++) {
|
|
symMap['$' + syms[k]] = syms[k];
|
|
}
|
|
}
|
|
|
|
for (var key in obj) { // eslint-disable-line no-restricted-syntax
|
|
if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
|
|
if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
|
|
if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {
|
|
// this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section
|
|
continue; // eslint-disable-line no-restricted-syntax, no-continue
|
|
} else if ($test.call(/[^\w$]/, key)) {
|
|
xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
|
|
} else {
|
|
xs.push(key + ': ' + inspect(obj[key], obj));
|
|
}
|
|
}
|
|
if (typeof gOPS === 'function') {
|
|
for (var j = 0; j < syms.length; j++) {
|
|
if (isEnumerable.call(obj, syms[j])) {
|
|
xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));
|
|
}
|
|
}
|
|
}
|
|
return xs;
|
|
}
|
|
|
|
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./util.inspect":12}],61:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = [
|
|
'Float16Array',
|
|
'Float32Array',
|
|
'Float64Array',
|
|
'Int8Array',
|
|
'Int16Array',
|
|
'Int32Array',
|
|
'Uint8Array',
|
|
'Uint8ClampedArray',
|
|
'Uint16Array',
|
|
'Uint32Array',
|
|
'BigInt64Array',
|
|
'BigUint64Array'
|
|
];
|
|
|
|
},{}],62:[function(require,module,exports){
|
|
// shim for using process in browser
|
|
var process = module.exports = {};
|
|
|
|
// cached from whatever global is present so that test runners that stub it
|
|
// don't break things. But we need to wrap it in a try catch in case it is
|
|
// wrapped in strict mode code which doesn't define any globals. It's inside a
|
|
// function because try/catches deoptimize in certain engines.
|
|
|
|
var cachedSetTimeout;
|
|
var cachedClearTimeout;
|
|
|
|
function defaultSetTimout() {
|
|
throw new Error('setTimeout has not been defined');
|
|
}
|
|
function defaultClearTimeout () {
|
|
throw new Error('clearTimeout has not been defined');
|
|
}
|
|
(function () {
|
|
try {
|
|
if (typeof setTimeout === 'function') {
|
|
cachedSetTimeout = setTimeout;
|
|
} else {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
} catch (e) {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
try {
|
|
if (typeof clearTimeout === 'function') {
|
|
cachedClearTimeout = clearTimeout;
|
|
} else {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} catch (e) {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} ())
|
|
function runTimeout(fun) {
|
|
if (cachedSetTimeout === setTimeout) {
|
|
//normal enviroments in sane situations
|
|
return setTimeout(fun, 0);
|
|
}
|
|
// if setTimeout wasn't available but was latter defined
|
|
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
|
cachedSetTimeout = setTimeout;
|
|
return setTimeout(fun, 0);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedSetTimeout(fun, 0);
|
|
} catch(e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedSetTimeout.call(null, fun, 0);
|
|
} catch(e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
|
return cachedSetTimeout.call(this, fun, 0);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
function runClearTimeout(marker) {
|
|
if (cachedClearTimeout === clearTimeout) {
|
|
//normal enviroments in sane situations
|
|
return clearTimeout(marker);
|
|
}
|
|
// if clearTimeout wasn't available but was latter defined
|
|
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
|
cachedClearTimeout = clearTimeout;
|
|
return clearTimeout(marker);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedClearTimeout(marker);
|
|
} catch (e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedClearTimeout.call(null, marker);
|
|
} catch (e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
|
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
|
return cachedClearTimeout.call(this, marker);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
var queue = [];
|
|
var draining = false;
|
|
var currentQueue;
|
|
var queueIndex = -1;
|
|
|
|
function cleanUpNextTick() {
|
|
if (!draining || !currentQueue) {
|
|
return;
|
|
}
|
|
draining = false;
|
|
if (currentQueue.length) {
|
|
queue = currentQueue.concat(queue);
|
|
} else {
|
|
queueIndex = -1;
|
|
}
|
|
if (queue.length) {
|
|
drainQueue();
|
|
}
|
|
}
|
|
|
|
function drainQueue() {
|
|
if (draining) {
|
|
return;
|
|
}
|
|
var timeout = runTimeout(cleanUpNextTick);
|
|
draining = true;
|
|
|
|
var len = queue.length;
|
|
while(len) {
|
|
currentQueue = queue;
|
|
queue = [];
|
|
while (++queueIndex < len) {
|
|
if (currentQueue) {
|
|
currentQueue[queueIndex].run();
|
|
}
|
|
}
|
|
queueIndex = -1;
|
|
len = queue.length;
|
|
}
|
|
currentQueue = null;
|
|
draining = false;
|
|
runClearTimeout(timeout);
|
|
}
|
|
|
|
process.nextTick = function (fun) {
|
|
var args = new Array(arguments.length - 1);
|
|
if (arguments.length > 1) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
args[i - 1] = arguments[i];
|
|
}
|
|
}
|
|
queue.push(new Item(fun, args));
|
|
if (queue.length === 1 && !draining) {
|
|
runTimeout(drainQueue);
|
|
}
|
|
};
|
|
|
|
// v8 likes predictible objects
|
|
function Item(fun, array) {
|
|
this.fun = fun;
|
|
this.array = array;
|
|
}
|
|
Item.prototype.run = function () {
|
|
this.fun.apply(null, this.array);
|
|
};
|
|
process.title = 'browser';
|
|
process.browser = true;
|
|
process.env = {};
|
|
process.argv = [];
|
|
process.version = ''; // empty string to avoid regexp issues
|
|
process.versions = {};
|
|
|
|
function noop() {}
|
|
|
|
process.on = noop;
|
|
process.addListener = noop;
|
|
process.once = noop;
|
|
process.off = noop;
|
|
process.removeListener = noop;
|
|
process.removeAllListeners = noop;
|
|
process.emit = noop;
|
|
process.prependListener = noop;
|
|
process.prependOnceListener = noop;
|
|
|
|
process.listeners = function (name) { return [] }
|
|
|
|
process.binding = function (name) {
|
|
throw new Error('process.binding is not supported');
|
|
};
|
|
|
|
process.cwd = function () { return '/' };
|
|
process.chdir = function (dir) {
|
|
throw new Error('process.chdir is not supported');
|
|
};
|
|
process.umask = function() { return 0; };
|
|
|
|
},{}],63:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var replace = String.prototype.replace;
|
|
var percentTwenties = /%20/g;
|
|
|
|
var Format = {
|
|
RFC1738: 'RFC1738',
|
|
RFC3986: 'RFC3986'
|
|
};
|
|
|
|
module.exports = {
|
|
'default': Format.RFC3986,
|
|
formatters: {
|
|
RFC1738: function (value) {
|
|
return replace.call(value, percentTwenties, '+');
|
|
},
|
|
RFC3986: function (value) {
|
|
return String(value);
|
|
}
|
|
},
|
|
RFC1738: Format.RFC1738,
|
|
RFC3986: Format.RFC3986
|
|
};
|
|
|
|
},{}],64:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var stringify = require('./stringify');
|
|
var parse = require('./parse');
|
|
var formats = require('./formats');
|
|
|
|
module.exports = {
|
|
formats: formats,
|
|
parse: parse,
|
|
stringify: stringify
|
|
};
|
|
|
|
},{"./formats":63,"./parse":65,"./stringify":66}],65:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var utils = require('./utils');
|
|
|
|
var has = Object.prototype.hasOwnProperty;
|
|
var isArray = Array.isArray;
|
|
|
|
var defaults = {
|
|
allowDots: false,
|
|
allowEmptyArrays: false,
|
|
allowPrototypes: false,
|
|
allowSparse: false,
|
|
arrayLimit: 20,
|
|
charset: 'utf-8',
|
|
charsetSentinel: false,
|
|
comma: false,
|
|
decodeDotInKeys: false,
|
|
decoder: utils.decode,
|
|
delimiter: '&',
|
|
depth: 5,
|
|
duplicates: 'combine',
|
|
ignoreQueryPrefix: false,
|
|
interpretNumericEntities: false,
|
|
parameterLimit: 1000,
|
|
parseArrays: true,
|
|
plainObjects: false,
|
|
strictDepth: false,
|
|
strictNullHandling: false,
|
|
throwOnLimitExceeded: false
|
|
};
|
|
|
|
var interpretNumericEntities = function (str) {
|
|
return str.replace(/&#(\d+);/g, function ($0, numberStr) {
|
|
return String.fromCharCode(parseInt(numberStr, 10));
|
|
});
|
|
};
|
|
|
|
var parseArrayValue = function (val, options, currentArrayLength) {
|
|
if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {
|
|
return val.split(',');
|
|
}
|
|
|
|
if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
|
|
throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
|
|
}
|
|
|
|
return val;
|
|
};
|
|
|
|
// This is what browsers will submit when the ✓ character occurs in an
|
|
// application/x-www-form-urlencoded body and the encoding of the page containing
|
|
// the form is iso-8859-1, or when the submitted form has an accept-charset
|
|
// attribute of iso-8859-1. Presumably also with other charsets that do not contain
|
|
// the ✓ character, such as us-ascii.
|
|
var isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('✓')
|
|
|
|
// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.
|
|
var charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')
|
|
|
|
var parseValues = function parseQueryStringValues(str, options) {
|
|
var obj = { __proto__: null };
|
|
|
|
var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
|
|
cleanStr = cleanStr.replace(/%5B/gi, '[').replace(/%5D/gi, ']');
|
|
|
|
var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
|
|
var parts = cleanStr.split(
|
|
options.delimiter,
|
|
options.throwOnLimitExceeded ? limit + 1 : limit
|
|
);
|
|
|
|
if (options.throwOnLimitExceeded && parts.length > limit) {
|
|
throw new RangeError('Parameter limit exceeded. Only ' + limit + ' parameter' + (limit === 1 ? '' : 's') + ' allowed.');
|
|
}
|
|
|
|
var skipIndex = -1; // Keep track of where the utf8 sentinel was found
|
|
var i;
|
|
|
|
var charset = options.charset;
|
|
if (options.charsetSentinel) {
|
|
for (i = 0; i < parts.length; ++i) {
|
|
if (parts[i].indexOf('utf8=') === 0) {
|
|
if (parts[i] === charsetSentinel) {
|
|
charset = 'utf-8';
|
|
} else if (parts[i] === isoSentinel) {
|
|
charset = 'iso-8859-1';
|
|
}
|
|
skipIndex = i;
|
|
i = parts.length; // The eslint settings do not allow break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < parts.length; ++i) {
|
|
if (i === skipIndex) {
|
|
continue;
|
|
}
|
|
var part = parts[i];
|
|
|
|
var bracketEqualsPos = part.indexOf(']=');
|
|
var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;
|
|
|
|
var key;
|
|
var val;
|
|
if (pos === -1) {
|
|
key = options.decoder(part, defaults.decoder, charset, 'key');
|
|
val = options.strictNullHandling ? null : '';
|
|
} else {
|
|
key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
|
|
|
|
val = utils.maybeMap(
|
|
parseArrayValue(
|
|
part.slice(pos + 1),
|
|
options,
|
|
isArray(obj[key]) ? obj[key].length : 0
|
|
),
|
|
function (encodedVal) {
|
|
return options.decoder(encodedVal, defaults.decoder, charset, 'value');
|
|
}
|
|
);
|
|
}
|
|
|
|
if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
|
|
val = interpretNumericEntities(String(val));
|
|
}
|
|
|
|
if (part.indexOf('[]=') > -1) {
|
|
val = isArray(val) ? [val] : val;
|
|
}
|
|
|
|
var existing = has.call(obj, key);
|
|
if (existing && options.duplicates === 'combine') {
|
|
obj[key] = utils.combine(obj[key], val);
|
|
} else if (!existing || options.duplicates === 'last') {
|
|
obj[key] = val;
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
var parseObject = function (chain, val, options, valuesParsed) {
|
|
var currentArrayLength = 0;
|
|
if (chain.length > 0 && chain[chain.length - 1] === '[]') {
|
|
var parentKey = chain.slice(0, -1).join('');
|
|
currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;
|
|
}
|
|
|
|
var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);
|
|
|
|
for (var i = chain.length - 1; i >= 0; --i) {
|
|
var obj;
|
|
var root = chain[i];
|
|
|
|
if (root === '[]' && options.parseArrays) {
|
|
obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
|
|
? []
|
|
: utils.combine([], leaf);
|
|
} else {
|
|
obj = options.plainObjects ? { __proto__: null } : {};
|
|
var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
|
|
var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, '.') : cleanRoot;
|
|
var index = parseInt(decodedRoot, 10);
|
|
if (!options.parseArrays && decodedRoot === '') {
|
|
obj = { 0: leaf };
|
|
} else if (
|
|
!isNaN(index)
|
|
&& root !== decodedRoot
|
|
&& String(index) === decodedRoot
|
|
&& index >= 0
|
|
&& (options.parseArrays && index <= options.arrayLimit)
|
|
) {
|
|
obj = [];
|
|
obj[index] = leaf;
|
|
} else if (decodedRoot !== '__proto__') {
|
|
obj[decodedRoot] = leaf;
|
|
}
|
|
}
|
|
|
|
leaf = obj;
|
|
}
|
|
|
|
return leaf;
|
|
};
|
|
|
|
var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
|
|
if (!givenKey) {
|
|
return;
|
|
}
|
|
|
|
// Transform dot notation to bracket notation
|
|
var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
|
|
|
|
// The regex chunks
|
|
|
|
var brackets = /(\[[^[\]]*])/;
|
|
var child = /(\[[^[\]]*])/g;
|
|
|
|
// Get the parent
|
|
|
|
var segment = options.depth > 0 && brackets.exec(key);
|
|
var parent = segment ? key.slice(0, segment.index) : key;
|
|
|
|
// Stash the parent if it exists
|
|
|
|
var keys = [];
|
|
if (parent) {
|
|
// If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
|
|
if (!options.plainObjects && has.call(Object.prototype, parent)) {
|
|
if (!options.allowPrototypes) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
keys.push(parent);
|
|
}
|
|
|
|
// Loop through children appending to the array until we hit depth
|
|
|
|
var i = 0;
|
|
while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
|
|
i += 1;
|
|
if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
|
|
if (!options.allowPrototypes) {
|
|
return;
|
|
}
|
|
}
|
|
keys.push(segment[1]);
|
|
}
|
|
|
|
// If there's a remainder, check strictDepth option for throw, else just add whatever is left
|
|
|
|
if (segment) {
|
|
if (options.strictDepth === true) {
|
|
throw new RangeError('Input depth exceeded depth option of ' + options.depth + ' and strictDepth is true');
|
|
}
|
|
keys.push('[' + key.slice(segment.index) + ']');
|
|
}
|
|
|
|
return parseObject(keys, val, options, valuesParsed);
|
|
};
|
|
|
|
var normalizeParseOptions = function normalizeParseOptions(opts) {
|
|
if (!opts) {
|
|
return defaults;
|
|
}
|
|
|
|
if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
|
|
throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
|
|
}
|
|
|
|
if (typeof opts.decodeDotInKeys !== 'undefined' && typeof opts.decodeDotInKeys !== 'boolean') {
|
|
throw new TypeError('`decodeDotInKeys` option can only be `true` or `false`, when provided');
|
|
}
|
|
|
|
if (opts.decoder !== null && typeof opts.decoder !== 'undefined' && typeof opts.decoder !== 'function') {
|
|
throw new TypeError('Decoder has to be a function.');
|
|
}
|
|
|
|
if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
|
|
throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
|
|
}
|
|
|
|
if (typeof opts.throwOnLimitExceeded !== 'undefined' && typeof opts.throwOnLimitExceeded !== 'boolean') {
|
|
throw new TypeError('`throwOnLimitExceeded` option must be a boolean');
|
|
}
|
|
|
|
var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;
|
|
|
|
var duplicates = typeof opts.duplicates === 'undefined' ? defaults.duplicates : opts.duplicates;
|
|
|
|
if (duplicates !== 'combine' && duplicates !== 'first' && duplicates !== 'last') {
|
|
throw new TypeError('The duplicates option must be either combine, first, or last');
|
|
}
|
|
|
|
var allowDots = typeof opts.allowDots === 'undefined' ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
|
|
|
|
return {
|
|
allowDots: allowDots,
|
|
allowEmptyArrays: typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
|
|
allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,
|
|
allowSparse: typeof opts.allowSparse === 'boolean' ? opts.allowSparse : defaults.allowSparse,
|
|
arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,
|
|
charset: charset,
|
|
charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
|
|
comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,
|
|
decodeDotInKeys: typeof opts.decodeDotInKeys === 'boolean' ? opts.decodeDotInKeys : defaults.decodeDotInKeys,
|
|
decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,
|
|
delimiter: typeof opts.delimiter === 'string' || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
|
|
// eslint-disable-next-line no-implicit-coercion, no-extra-parens
|
|
depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth,
|
|
duplicates: duplicates,
|
|
ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
|
|
interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
|
|
parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,
|
|
parseArrays: opts.parseArrays !== false,
|
|
plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,
|
|
strictDepth: typeof opts.strictDepth === 'boolean' ? !!opts.strictDepth : defaults.strictDepth,
|
|
strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling,
|
|
throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === 'boolean' ? opts.throwOnLimitExceeded : false
|
|
};
|
|
};
|
|
|
|
module.exports = function (str, opts) {
|
|
var options = normalizeParseOptions(opts);
|
|
|
|
if (str === '' || str === null || typeof str === 'undefined') {
|
|
return options.plainObjects ? { __proto__: null } : {};
|
|
}
|
|
|
|
var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
|
|
var obj = options.plainObjects ? { __proto__: null } : {};
|
|
|
|
// Iterate over the keys and setup the new object
|
|
|
|
var keys = Object.keys(tempObj);
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var key = keys[i];
|
|
var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string');
|
|
obj = utils.merge(obj, newObj, options);
|
|
}
|
|
|
|
if (options.allowSparse === true) {
|
|
return obj;
|
|
}
|
|
|
|
return utils.compact(obj);
|
|
};
|
|
|
|
},{"./utils":67}],66:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var getSideChannel = require('side-channel');
|
|
var utils = require('./utils');
|
|
var formats = require('./formats');
|
|
var has = Object.prototype.hasOwnProperty;
|
|
|
|
var arrayPrefixGenerators = {
|
|
brackets: function brackets(prefix) {
|
|
return prefix + '[]';
|
|
},
|
|
comma: 'comma',
|
|
indices: function indices(prefix, key) {
|
|
return prefix + '[' + key + ']';
|
|
},
|
|
repeat: function repeat(prefix) {
|
|
return prefix;
|
|
}
|
|
};
|
|
|
|
var isArray = Array.isArray;
|
|
var push = Array.prototype.push;
|
|
var pushToArray = function (arr, valueOrArray) {
|
|
push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
|
|
};
|
|
|
|
var toISO = Date.prototype.toISOString;
|
|
|
|
var defaultFormat = formats['default'];
|
|
var defaults = {
|
|
addQueryPrefix: false,
|
|
allowDots: false,
|
|
allowEmptyArrays: false,
|
|
arrayFormat: 'indices',
|
|
charset: 'utf-8',
|
|
charsetSentinel: false,
|
|
commaRoundTrip: false,
|
|
delimiter: '&',
|
|
encode: true,
|
|
encodeDotInKeys: false,
|
|
encoder: utils.encode,
|
|
encodeValuesOnly: false,
|
|
filter: void undefined,
|
|
format: defaultFormat,
|
|
formatter: formats.formatters[defaultFormat],
|
|
// deprecated
|
|
indices: false,
|
|
serializeDate: function serializeDate(date) {
|
|
return toISO.call(date);
|
|
},
|
|
skipNulls: false,
|
|
strictNullHandling: false
|
|
};
|
|
|
|
var isNonNullishPrimitive = function isNonNullishPrimitive(v) {
|
|
return typeof v === 'string'
|
|
|| typeof v === 'number'
|
|
|| typeof v === 'boolean'
|
|
|| typeof v === 'symbol'
|
|
|| typeof v === 'bigint';
|
|
};
|
|
|
|
var sentinel = {};
|
|
|
|
var stringify = function stringify(
|
|
object,
|
|
prefix,
|
|
generateArrayPrefix,
|
|
commaRoundTrip,
|
|
allowEmptyArrays,
|
|
strictNullHandling,
|
|
skipNulls,
|
|
encodeDotInKeys,
|
|
encoder,
|
|
filter,
|
|
sort,
|
|
allowDots,
|
|
serializeDate,
|
|
format,
|
|
formatter,
|
|
encodeValuesOnly,
|
|
charset,
|
|
sideChannel
|
|
) {
|
|
var obj = object;
|
|
|
|
var tmpSc = sideChannel;
|
|
var step = 0;
|
|
var findFlag = false;
|
|
while ((tmpSc = tmpSc.get(sentinel)) !== void undefined && !findFlag) {
|
|
// Where object last appeared in the ref tree
|
|
var pos = tmpSc.get(object);
|
|
step += 1;
|
|
if (typeof pos !== 'undefined') {
|
|
if (pos === step) {
|
|
throw new RangeError('Cyclic object value');
|
|
} else {
|
|
findFlag = true; // Break while
|
|
}
|
|
}
|
|
if (typeof tmpSc.get(sentinel) === 'undefined') {
|
|
step = 0;
|
|
}
|
|
}
|
|
|
|
if (typeof filter === 'function') {
|
|
obj = filter(prefix, obj);
|
|
} else if (obj instanceof Date) {
|
|
obj = serializeDate(obj);
|
|
} else if (generateArrayPrefix === 'comma' && isArray(obj)) {
|
|
obj = utils.maybeMap(obj, function (value) {
|
|
if (value instanceof Date) {
|
|
return serializeDate(value);
|
|
}
|
|
return value;
|
|
});
|
|
}
|
|
|
|
if (obj === null) {
|
|
if (strictNullHandling) {
|
|
return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, 'key', format) : prefix;
|
|
}
|
|
|
|
obj = '';
|
|
}
|
|
|
|
if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
|
|
if (encoder) {
|
|
var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key', format);
|
|
return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value', format))];
|
|
}
|
|
return [formatter(prefix) + '=' + formatter(String(obj))];
|
|
}
|
|
|
|
var values = [];
|
|
|
|
if (typeof obj === 'undefined') {
|
|
return values;
|
|
}
|
|
|
|
var objKeys;
|
|
if (generateArrayPrefix === 'comma' && isArray(obj)) {
|
|
// we need to join elements in
|
|
if (encodeValuesOnly && encoder) {
|
|
obj = utils.maybeMap(obj, encoder);
|
|
}
|
|
objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
|
|
} else if (isArray(filter)) {
|
|
objKeys = filter;
|
|
} else {
|
|
var keys = Object.keys(obj);
|
|
objKeys = sort ? keys.sort(sort) : keys;
|
|
}
|
|
|
|
var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
|
|
|
|
var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + '[]' : encodedPrefix;
|
|
|
|
if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
|
|
return adjustedPrefix + '[]';
|
|
}
|
|
|
|
for (var j = 0; j < objKeys.length; ++j) {
|
|
var key = objKeys[j];
|
|
var value = typeof key === 'object' && key && typeof key.value !== 'undefined'
|
|
? key.value
|
|
: obj[key];
|
|
|
|
if (skipNulls && value === null) {
|
|
continue;
|
|
}
|
|
|
|
var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\./g, '%2E') : String(key);
|
|
var keyPrefix = isArray(obj)
|
|
? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix
|
|
: adjustedPrefix + (allowDots ? '.' + encodedKey : '[' + encodedKey + ']');
|
|
|
|
sideChannel.set(object, step);
|
|
var valueSideChannel = getSideChannel();
|
|
valueSideChannel.set(sentinel, sideChannel);
|
|
pushToArray(values, stringify(
|
|
value,
|
|
keyPrefix,
|
|
generateArrayPrefix,
|
|
commaRoundTrip,
|
|
allowEmptyArrays,
|
|
strictNullHandling,
|
|
skipNulls,
|
|
encodeDotInKeys,
|
|
generateArrayPrefix === 'comma' && encodeValuesOnly && isArray(obj) ? null : encoder,
|
|
filter,
|
|
sort,
|
|
allowDots,
|
|
serializeDate,
|
|
format,
|
|
formatter,
|
|
encodeValuesOnly,
|
|
charset,
|
|
valueSideChannel
|
|
));
|
|
}
|
|
|
|
return values;
|
|
};
|
|
|
|
var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
|
|
if (!opts) {
|
|
return defaults;
|
|
}
|
|
|
|
if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
|
|
throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
|
|
}
|
|
|
|
if (typeof opts.encodeDotInKeys !== 'undefined' && typeof opts.encodeDotInKeys !== 'boolean') {
|
|
throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided');
|
|
}
|
|
|
|
if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {
|
|
throw new TypeError('Encoder has to be a function.');
|
|
}
|
|
|
|
var charset = opts.charset || defaults.charset;
|
|
if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
|
|
throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
|
|
}
|
|
|
|
var format = formats['default'];
|
|
if (typeof opts.format !== 'undefined') {
|
|
if (!has.call(formats.formatters, opts.format)) {
|
|
throw new TypeError('Unknown format option provided.');
|
|
}
|
|
format = opts.format;
|
|
}
|
|
var formatter = formats.formatters[format];
|
|
|
|
var filter = defaults.filter;
|
|
if (typeof opts.filter === 'function' || isArray(opts.filter)) {
|
|
filter = opts.filter;
|
|
}
|
|
|
|
var arrayFormat;
|
|
if (opts.arrayFormat in arrayPrefixGenerators) {
|
|
arrayFormat = opts.arrayFormat;
|
|
} else if ('indices' in opts) {
|
|
arrayFormat = opts.indices ? 'indices' : 'repeat';
|
|
} else {
|
|
arrayFormat = defaults.arrayFormat;
|
|
}
|
|
|
|
if ('commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {
|
|
throw new TypeError('`commaRoundTrip` must be a boolean, or absent');
|
|
}
|
|
|
|
var allowDots = typeof opts.allowDots === 'undefined' ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
|
|
|
|
return {
|
|
addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,
|
|
allowDots: allowDots,
|
|
allowEmptyArrays: typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
|
|
arrayFormat: arrayFormat,
|
|
charset: charset,
|
|
charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
|
|
commaRoundTrip: !!opts.commaRoundTrip,
|
|
delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
|
|
encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
|
|
encodeDotInKeys: typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
|
|
encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
|
|
encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
|
|
filter: filter,
|
|
format: format,
|
|
formatter: formatter,
|
|
serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,
|
|
skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,
|
|
sort: typeof opts.sort === 'function' ? opts.sort : null,
|
|
strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling
|
|
};
|
|
};
|
|
|
|
module.exports = function (object, opts) {
|
|
var obj = object;
|
|
var options = normalizeStringifyOptions(opts);
|
|
|
|
var objKeys;
|
|
var filter;
|
|
|
|
if (typeof options.filter === 'function') {
|
|
filter = options.filter;
|
|
obj = filter('', obj);
|
|
} else if (isArray(options.filter)) {
|
|
filter = options.filter;
|
|
objKeys = filter;
|
|
}
|
|
|
|
var keys = [];
|
|
|
|
if (typeof obj !== 'object' || obj === null) {
|
|
return '';
|
|
}
|
|
|
|
var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];
|
|
var commaRoundTrip = generateArrayPrefix === 'comma' && options.commaRoundTrip;
|
|
|
|
if (!objKeys) {
|
|
objKeys = Object.keys(obj);
|
|
}
|
|
|
|
if (options.sort) {
|
|
objKeys.sort(options.sort);
|
|
}
|
|
|
|
var sideChannel = getSideChannel();
|
|
for (var i = 0; i < objKeys.length; ++i) {
|
|
var key = objKeys[i];
|
|
var value = obj[key];
|
|
|
|
if (options.skipNulls && value === null) {
|
|
continue;
|
|
}
|
|
pushToArray(keys, stringify(
|
|
value,
|
|
key,
|
|
generateArrayPrefix,
|
|
commaRoundTrip,
|
|
options.allowEmptyArrays,
|
|
options.strictNullHandling,
|
|
options.skipNulls,
|
|
options.encodeDotInKeys,
|
|
options.encode ? options.encoder : null,
|
|
options.filter,
|
|
options.sort,
|
|
options.allowDots,
|
|
options.serializeDate,
|
|
options.format,
|
|
options.formatter,
|
|
options.encodeValuesOnly,
|
|
options.charset,
|
|
sideChannel
|
|
));
|
|
}
|
|
|
|
var joined = keys.join(options.delimiter);
|
|
var prefix = options.addQueryPrefix === true ? '?' : '';
|
|
|
|
if (options.charsetSentinel) {
|
|
if (options.charset === 'iso-8859-1') {
|
|
// encodeURIComponent('✓'), the "numeric entity" representation of a checkmark
|
|
prefix += 'utf8=%26%2310003%3B&';
|
|
} else {
|
|
// encodeURIComponent('✓')
|
|
prefix += 'utf8=%E2%9C%93&';
|
|
}
|
|
}
|
|
|
|
return joined.length > 0 ? prefix + joined : '';
|
|
};
|
|
|
|
},{"./formats":63,"./utils":67,"side-channel":73}],67:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var formats = require('./formats');
|
|
|
|
var has = Object.prototype.hasOwnProperty;
|
|
var isArray = Array.isArray;
|
|
|
|
var hexTable = (function () {
|
|
var array = [];
|
|
for (var i = 0; i < 256; ++i) {
|
|
array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
|
|
}
|
|
|
|
return array;
|
|
}());
|
|
|
|
var compactQueue = function compactQueue(queue) {
|
|
while (queue.length > 1) {
|
|
var item = queue.pop();
|
|
var obj = item.obj[item.prop];
|
|
|
|
if (isArray(obj)) {
|
|
var compacted = [];
|
|
|
|
for (var j = 0; j < obj.length; ++j) {
|
|
if (typeof obj[j] !== 'undefined') {
|
|
compacted.push(obj[j]);
|
|
}
|
|
}
|
|
|
|
item.obj[item.prop] = compacted;
|
|
}
|
|
}
|
|
};
|
|
|
|
var arrayToObject = function arrayToObject(source, options) {
|
|
var obj = options && options.plainObjects ? { __proto__: null } : {};
|
|
for (var i = 0; i < source.length; ++i) {
|
|
if (typeof source[i] !== 'undefined') {
|
|
obj[i] = source[i];
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
var merge = function merge(target, source, options) {
|
|
/* eslint no-param-reassign: 0 */
|
|
if (!source) {
|
|
return target;
|
|
}
|
|
|
|
if (typeof source !== 'object' && typeof source !== 'function') {
|
|
if (isArray(target)) {
|
|
target.push(source);
|
|
} else if (target && typeof target === 'object') {
|
|
if (
|
|
(options && (options.plainObjects || options.allowPrototypes))
|
|
|| !has.call(Object.prototype, source)
|
|
) {
|
|
target[source] = true;
|
|
}
|
|
} else {
|
|
return [target, source];
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
if (!target || typeof target !== 'object') {
|
|
return [target].concat(source);
|
|
}
|
|
|
|
var mergeTarget = target;
|
|
if (isArray(target) && !isArray(source)) {
|
|
mergeTarget = arrayToObject(target, options);
|
|
}
|
|
|
|
if (isArray(target) && isArray(source)) {
|
|
source.forEach(function (item, i) {
|
|
if (has.call(target, i)) {
|
|
var targetItem = target[i];
|
|
if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
|
|
target[i] = merge(targetItem, item, options);
|
|
} else {
|
|
target.push(item);
|
|
}
|
|
} else {
|
|
target[i] = item;
|
|
}
|
|
});
|
|
return target;
|
|
}
|
|
|
|
return Object.keys(source).reduce(function (acc, key) {
|
|
var value = source[key];
|
|
|
|
if (has.call(acc, key)) {
|
|
acc[key] = merge(acc[key], value, options);
|
|
} else {
|
|
acc[key] = value;
|
|
}
|
|
return acc;
|
|
}, mergeTarget);
|
|
};
|
|
|
|
var assign = function assignSingleSource(target, source) {
|
|
return Object.keys(source).reduce(function (acc, key) {
|
|
acc[key] = source[key];
|
|
return acc;
|
|
}, target);
|
|
};
|
|
|
|
var decode = function (str, defaultDecoder, charset) {
|
|
var strWithoutPlus = str.replace(/\+/g, ' ');
|
|
if (charset === 'iso-8859-1') {
|
|
// unescape never throws, no try...catch needed:
|
|
return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
|
|
}
|
|
// utf-8
|
|
try {
|
|
return decodeURIComponent(strWithoutPlus);
|
|
} catch (e) {
|
|
return strWithoutPlus;
|
|
}
|
|
};
|
|
|
|
var limit = 1024;
|
|
|
|
/* eslint operator-linebreak: [2, "before"] */
|
|
|
|
var encode = function encode(str, defaultEncoder, charset, kind, format) {
|
|
// This code was originally written by Brian White (mscdex) for the io.js core querystring library.
|
|
// It has been adapted here for stricter adherence to RFC 3986
|
|
if (str.length === 0) {
|
|
return str;
|
|
}
|
|
|
|
var string = str;
|
|
if (typeof str === 'symbol') {
|
|
string = Symbol.prototype.toString.call(str);
|
|
} else if (typeof str !== 'string') {
|
|
string = String(str);
|
|
}
|
|
|
|
if (charset === 'iso-8859-1') {
|
|
return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
|
|
return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
|
|
});
|
|
}
|
|
|
|
var out = '';
|
|
for (var j = 0; j < string.length; j += limit) {
|
|
var segment = string.length >= limit ? string.slice(j, j + limit) : string;
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < segment.length; ++i) {
|
|
var c = segment.charCodeAt(i);
|
|
if (
|
|
c === 0x2D // -
|
|
|| c === 0x2E // .
|
|
|| c === 0x5F // _
|
|
|| c === 0x7E // ~
|
|
|| (c >= 0x30 && c <= 0x39) // 0-9
|
|
|| (c >= 0x41 && c <= 0x5A) // a-z
|
|
|| (c >= 0x61 && c <= 0x7A) // A-Z
|
|
|| (format === formats.RFC1738 && (c === 0x28 || c === 0x29)) // ( )
|
|
) {
|
|
arr[arr.length] = segment.charAt(i);
|
|
continue;
|
|
}
|
|
|
|
if (c < 0x80) {
|
|
arr[arr.length] = hexTable[c];
|
|
continue;
|
|
}
|
|
|
|
if (c < 0x800) {
|
|
arr[arr.length] = hexTable[0xC0 | (c >> 6)]
|
|
+ hexTable[0x80 | (c & 0x3F)];
|
|
continue;
|
|
}
|
|
|
|
if (c < 0xD800 || c >= 0xE000) {
|
|
arr[arr.length] = hexTable[0xE0 | (c >> 12)]
|
|
+ hexTable[0x80 | ((c >> 6) & 0x3F)]
|
|
+ hexTable[0x80 | (c & 0x3F)];
|
|
continue;
|
|
}
|
|
|
|
i += 1;
|
|
c = 0x10000 + (((c & 0x3FF) << 10) | (segment.charCodeAt(i) & 0x3FF));
|
|
|
|
arr[arr.length] = hexTable[0xF0 | (c >> 18)]
|
|
+ hexTable[0x80 | ((c >> 12) & 0x3F)]
|
|
+ hexTable[0x80 | ((c >> 6) & 0x3F)]
|
|
+ hexTable[0x80 | (c & 0x3F)];
|
|
}
|
|
|
|
out += arr.join('');
|
|
}
|
|
|
|
return out;
|
|
};
|
|
|
|
var compact = function compact(value) {
|
|
var queue = [{ obj: { o: value }, prop: 'o' }];
|
|
var refs = [];
|
|
|
|
for (var i = 0; i < queue.length; ++i) {
|
|
var item = queue[i];
|
|
var obj = item.obj[item.prop];
|
|
|
|
var keys = Object.keys(obj);
|
|
for (var j = 0; j < keys.length; ++j) {
|
|
var key = keys[j];
|
|
var val = obj[key];
|
|
if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
|
|
queue.push({ obj: obj, prop: key });
|
|
refs.push(val);
|
|
}
|
|
}
|
|
}
|
|
|
|
compactQueue(queue);
|
|
|
|
return value;
|
|
};
|
|
|
|
var isRegExp = function isRegExp(obj) {
|
|
return Object.prototype.toString.call(obj) === '[object RegExp]';
|
|
};
|
|
|
|
var isBuffer = function isBuffer(obj) {
|
|
if (!obj || typeof obj !== 'object') {
|
|
return false;
|
|
}
|
|
|
|
return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
|
|
};
|
|
|
|
var combine = function combine(a, b) {
|
|
return [].concat(a, b);
|
|
};
|
|
|
|
var maybeMap = function maybeMap(val, fn) {
|
|
if (isArray(val)) {
|
|
var mapped = [];
|
|
for (var i = 0; i < val.length; i += 1) {
|
|
mapped.push(fn(val[i]));
|
|
}
|
|
return mapped;
|
|
}
|
|
return fn(val);
|
|
};
|
|
|
|
module.exports = {
|
|
arrayToObject: arrayToObject,
|
|
assign: assign,
|
|
combine: combine,
|
|
compact: compact,
|
|
decode: decode,
|
|
encode: encode,
|
|
isBuffer: isBuffer,
|
|
isRegExp: isRegExp,
|
|
maybeMap: maybeMap,
|
|
merge: merge
|
|
};
|
|
|
|
},{"./formats":63}],68:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var callBound = require('call-bound');
|
|
var isRegex = require('is-regex');
|
|
|
|
var $exec = callBound('RegExp.prototype.exec');
|
|
var $TypeError = require('es-errors/type');
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function regexTester(regex) {
|
|
if (!isRegex(regex)) {
|
|
throw new $TypeError('`regex` must be a RegExp');
|
|
}
|
|
return function test(s) {
|
|
return $exec(regex, s) !== null;
|
|
};
|
|
};
|
|
|
|
},{"call-bound":20,"es-errors/type":29,"is-regex":50}],69:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var GetIntrinsic = require('get-intrinsic');
|
|
var define = require('define-data-property');
|
|
var hasDescriptors = require('has-property-descriptors')();
|
|
var gOPD = require('gopd');
|
|
|
|
var $TypeError = require('es-errors/type');
|
|
var $floor = GetIntrinsic('%Math.floor%');
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function setFunctionLength(fn, length) {
|
|
if (typeof fn !== 'function') {
|
|
throw new $TypeError('`fn` is not a function');
|
|
}
|
|
if (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {
|
|
throw new $TypeError('`length` must be a positive 32-bit integer');
|
|
}
|
|
|
|
var loose = arguments.length > 2 && !!arguments[2];
|
|
|
|
var functionLengthIsConfigurable = true;
|
|
var functionLengthIsWritable = true;
|
|
if ('length' in fn && gOPD) {
|
|
var desc = gOPD(fn, 'length');
|
|
if (desc && !desc.configurable) {
|
|
functionLengthIsConfigurable = false;
|
|
}
|
|
if (desc && !desc.writable) {
|
|
functionLengthIsWritable = false;
|
|
}
|
|
}
|
|
|
|
if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
|
|
if (hasDescriptors) {
|
|
define(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);
|
|
} else {
|
|
define(/** @type {Parameters<define>[0]} */ (fn), 'length', length);
|
|
}
|
|
}
|
|
return fn;
|
|
};
|
|
|
|
},{"define-data-property":21,"es-errors/type":29,"get-intrinsic":35,"gopd":40,"has-property-descriptors":41}],70:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var inspect = require('object-inspect');
|
|
|
|
var $TypeError = require('es-errors/type');
|
|
|
|
/*
|
|
* This function traverses the list returning the node corresponding to the given key.
|
|
*
|
|
* That node is also moved to the head of the list, so that if it's accessed again we don't need to traverse the whole list.
|
|
* By doing so, all the recently used nodes can be accessed relatively quickly.
|
|
*/
|
|
/** @type {import('./list.d.ts').listGetNode} */
|
|
// eslint-disable-next-line consistent-return
|
|
var listGetNode = function (list, key, isDelete) {
|
|
/** @type {typeof list | NonNullable<(typeof list)['next']>} */
|
|
var prev = list;
|
|
/** @type {(typeof list)['next']} */
|
|
var curr;
|
|
// eslint-disable-next-line eqeqeq
|
|
for (; (curr = prev.next) != null; prev = curr) {
|
|
if (curr.key === key) {
|
|
prev.next = curr.next;
|
|
if (!isDelete) {
|
|
// eslint-disable-next-line no-extra-parens
|
|
curr.next = /** @type {NonNullable<typeof list.next>} */ (list.next);
|
|
list.next = curr; // eslint-disable-line no-param-reassign
|
|
}
|
|
return curr;
|
|
}
|
|
}
|
|
};
|
|
|
|
/** @type {import('./list.d.ts').listGet} */
|
|
var listGet = function (objects, key) {
|
|
if (!objects) {
|
|
return void undefined;
|
|
}
|
|
var node = listGetNode(objects, key);
|
|
return node && node.value;
|
|
};
|
|
/** @type {import('./list.d.ts').listSet} */
|
|
var listSet = function (objects, key, value) {
|
|
var node = listGetNode(objects, key);
|
|
if (node) {
|
|
node.value = value;
|
|
} else {
|
|
// Prepend the new node to the beginning of the list
|
|
objects.next = /** @type {import('./list.d.ts').ListNode<typeof value, typeof key>} */ ({ // eslint-disable-line no-param-reassign, no-extra-parens
|
|
key: key,
|
|
next: objects.next,
|
|
value: value
|
|
});
|
|
}
|
|
};
|
|
/** @type {import('./list.d.ts').listHas} */
|
|
var listHas = function (objects, key) {
|
|
if (!objects) {
|
|
return false;
|
|
}
|
|
return !!listGetNode(objects, key);
|
|
};
|
|
/** @type {import('./list.d.ts').listDelete} */
|
|
// eslint-disable-next-line consistent-return
|
|
var listDelete = function (objects, key) {
|
|
if (objects) {
|
|
return listGetNode(objects, key, true);
|
|
}
|
|
};
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function getSideChannelList() {
|
|
/** @typedef {ReturnType<typeof getSideChannelList>} Channel */
|
|
/** @typedef {Parameters<Channel['get']>[0]} K */
|
|
/** @typedef {Parameters<Channel['set']>[1]} V */
|
|
|
|
/** @type {import('./list.d.ts').RootNode<V, K> | undefined} */ var $o;
|
|
|
|
/** @type {Channel} */
|
|
var channel = {
|
|
assert: function (key) {
|
|
if (!channel.has(key)) {
|
|
throw new $TypeError('Side channel does not contain ' + inspect(key));
|
|
}
|
|
},
|
|
'delete': function (key) {
|
|
var root = $o && $o.next;
|
|
var deletedNode = listDelete($o, key);
|
|
if (deletedNode && root && root === deletedNode) {
|
|
$o = void undefined;
|
|
}
|
|
return !!deletedNode;
|
|
},
|
|
get: function (key) {
|
|
return listGet($o, key);
|
|
},
|
|
has: function (key) {
|
|
return listHas($o, key);
|
|
},
|
|
set: function (key, value) {
|
|
if (!$o) {
|
|
// Initialize the linked list as an empty node, so that we don't have to special-case handling of the first node: we can always refer to it as (previous node).next, instead of something like (list).head
|
|
$o = {
|
|
next: void undefined
|
|
};
|
|
}
|
|
// eslint-disable-next-line no-extra-parens
|
|
listSet(/** @type {NonNullable<typeof $o>} */ ($o), key, value);
|
|
}
|
|
};
|
|
// @ts-expect-error TODO: figure out why this is erroring
|
|
return channel;
|
|
};
|
|
|
|
},{"es-errors/type":29,"object-inspect":60}],71:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var GetIntrinsic = require('get-intrinsic');
|
|
var callBound = require('call-bound');
|
|
var inspect = require('object-inspect');
|
|
|
|
var $TypeError = require('es-errors/type');
|
|
var $Map = GetIntrinsic('%Map%', true);
|
|
|
|
/** @type {<K, V>(thisArg: Map<K, V>, key: K) => V} */
|
|
var $mapGet = callBound('Map.prototype.get', true);
|
|
/** @type {<K, V>(thisArg: Map<K, V>, key: K, value: V) => void} */
|
|
var $mapSet = callBound('Map.prototype.set', true);
|
|
/** @type {<K, V>(thisArg: Map<K, V>, key: K) => boolean} */
|
|
var $mapHas = callBound('Map.prototype.has', true);
|
|
/** @type {<K, V>(thisArg: Map<K, V>, key: K) => boolean} */
|
|
var $mapDelete = callBound('Map.prototype.delete', true);
|
|
/** @type {<K, V>(thisArg: Map<K, V>) => number} */
|
|
var $mapSize = callBound('Map.prototype.size', true);
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = !!$Map && /** @type {Exclude<import('.'), false>} */ function getSideChannelMap() {
|
|
/** @typedef {ReturnType<typeof getSideChannelMap>} Channel */
|
|
/** @typedef {Parameters<Channel['get']>[0]} K */
|
|
/** @typedef {Parameters<Channel['set']>[1]} V */
|
|
|
|
/** @type {Map<K, V> | undefined} */ var $m;
|
|
|
|
/** @type {Channel} */
|
|
var channel = {
|
|
assert: function (key) {
|
|
if (!channel.has(key)) {
|
|
throw new $TypeError('Side channel does not contain ' + inspect(key));
|
|
}
|
|
},
|
|
'delete': function (key) {
|
|
if ($m) {
|
|
var result = $mapDelete($m, key);
|
|
if ($mapSize($m) === 0) {
|
|
$m = void undefined;
|
|
}
|
|
return result;
|
|
}
|
|
return false;
|
|
},
|
|
get: function (key) { // eslint-disable-line consistent-return
|
|
if ($m) {
|
|
return $mapGet($m, key);
|
|
}
|
|
},
|
|
has: function (key) {
|
|
if ($m) {
|
|
return $mapHas($m, key);
|
|
}
|
|
return false;
|
|
},
|
|
set: function (key, value) {
|
|
if (!$m) {
|
|
// @ts-expect-error TS can't handle narrowing a variable inside a closure
|
|
$m = new $Map();
|
|
}
|
|
$mapSet($m, key, value);
|
|
}
|
|
};
|
|
|
|
// @ts-expect-error TODO: figure out why TS is erroring here
|
|
return channel;
|
|
};
|
|
|
|
},{"call-bound":20,"es-errors/type":29,"get-intrinsic":35,"object-inspect":60}],72:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var GetIntrinsic = require('get-intrinsic');
|
|
var callBound = require('call-bound');
|
|
var inspect = require('object-inspect');
|
|
var getSideChannelMap = require('side-channel-map');
|
|
|
|
var $TypeError = require('es-errors/type');
|
|
var $WeakMap = GetIntrinsic('%WeakMap%', true);
|
|
|
|
/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => V} */
|
|
var $weakMapGet = callBound('WeakMap.prototype.get', true);
|
|
/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K, value: V) => void} */
|
|
var $weakMapSet = callBound('WeakMap.prototype.set', true);
|
|
/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => boolean} */
|
|
var $weakMapHas = callBound('WeakMap.prototype.has', true);
|
|
/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => boolean} */
|
|
var $weakMapDelete = callBound('WeakMap.prototype.delete', true);
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = $WeakMap
|
|
? /** @type {Exclude<import('.'), false>} */ function getSideChannelWeakMap() {
|
|
/** @typedef {ReturnType<typeof getSideChannelWeakMap>} Channel */
|
|
/** @typedef {Parameters<Channel['get']>[0]} K */
|
|
/** @typedef {Parameters<Channel['set']>[1]} V */
|
|
|
|
/** @type {WeakMap<K & object, V> | undefined} */ var $wm;
|
|
/** @type {Channel | undefined} */ var $m;
|
|
|
|
/** @type {Channel} */
|
|
var channel = {
|
|
assert: function (key) {
|
|
if (!channel.has(key)) {
|
|
throw new $TypeError('Side channel does not contain ' + inspect(key));
|
|
}
|
|
},
|
|
'delete': function (key) {
|
|
if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
|
|
if ($wm) {
|
|
return $weakMapDelete($wm, key);
|
|
}
|
|
} else if (getSideChannelMap) {
|
|
if ($m) {
|
|
return $m['delete'](key);
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
get: function (key) {
|
|
if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
|
|
if ($wm) {
|
|
return $weakMapGet($wm, key);
|
|
}
|
|
}
|
|
return $m && $m.get(key);
|
|
},
|
|
has: function (key) {
|
|
if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
|
|
if ($wm) {
|
|
return $weakMapHas($wm, key);
|
|
}
|
|
}
|
|
return !!$m && $m.has(key);
|
|
},
|
|
set: function (key, value) {
|
|
if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
|
|
if (!$wm) {
|
|
$wm = new $WeakMap();
|
|
}
|
|
$weakMapSet($wm, key, value);
|
|
} else if (getSideChannelMap) {
|
|
if (!$m) {
|
|
$m = getSideChannelMap();
|
|
}
|
|
// eslint-disable-next-line no-extra-parens
|
|
/** @type {NonNullable<typeof $m>} */ ($m).set(key, value);
|
|
}
|
|
}
|
|
};
|
|
|
|
// @ts-expect-error TODO: figure out why this is erroring
|
|
return channel;
|
|
}
|
|
: getSideChannelMap;
|
|
|
|
},{"call-bound":20,"es-errors/type":29,"get-intrinsic":35,"object-inspect":60,"side-channel-map":71}],73:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var $TypeError = require('es-errors/type');
|
|
var inspect = require('object-inspect');
|
|
var getSideChannelList = require('side-channel-list');
|
|
var getSideChannelMap = require('side-channel-map');
|
|
var getSideChannelWeakMap = require('side-channel-weakmap');
|
|
|
|
var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList;
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function getSideChannel() {
|
|
/** @typedef {ReturnType<typeof getSideChannel>} Channel */
|
|
|
|
/** @type {Channel | undefined} */ var $channelData;
|
|
|
|
/** @type {Channel} */
|
|
var channel = {
|
|
assert: function (key) {
|
|
if (!channel.has(key)) {
|
|
throw new $TypeError('Side channel does not contain ' + inspect(key));
|
|
}
|
|
},
|
|
'delete': function (key) {
|
|
return !!$channelData && $channelData['delete'](key);
|
|
},
|
|
get: function (key) {
|
|
return $channelData && $channelData.get(key);
|
|
},
|
|
has: function (key) {
|
|
return !!$channelData && $channelData.has(key);
|
|
},
|
|
set: function (key, value) {
|
|
if (!$channelData) {
|
|
$channelData = makeChannel();
|
|
}
|
|
|
|
$channelData.set(key, value);
|
|
}
|
|
};
|
|
// @ts-expect-error TODO: figure out why this is erroring
|
|
return channel;
|
|
};
|
|
|
|
},{"es-errors/type":29,"object-inspect":60,"side-channel-list":70,"side-channel-map":71,"side-channel-weakmap":72}],74:[function(require,module,exports){
|
|
(function (global){(function (){
|
|
/*! https://mths.be/punycode v1.4.1 by @mathias */
|
|
;(function(root) {
|
|
|
|
/** Detect free variables */
|
|
var freeExports = typeof exports == 'object' && exports &&
|
|
!exports.nodeType && exports;
|
|
var freeModule = typeof module == 'object' && module &&
|
|
!module.nodeType && module;
|
|
var freeGlobal = typeof global == 'object' && global;
|
|
if (
|
|
freeGlobal.global === freeGlobal ||
|
|
freeGlobal.window === freeGlobal ||
|
|
freeGlobal.self === freeGlobal
|
|
) {
|
|
root = freeGlobal;
|
|
}
|
|
|
|
/**
|
|
* The `punycode` object.
|
|
* @name punycode
|
|
* @type Object
|
|
*/
|
|
var punycode,
|
|
|
|
/** Highest positive signed 32-bit float value */
|
|
maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
|
|
|
|
/** Bootstring parameters */
|
|
base = 36,
|
|
tMin = 1,
|
|
tMax = 26,
|
|
skew = 38,
|
|
damp = 700,
|
|
initialBias = 72,
|
|
initialN = 128, // 0x80
|
|
delimiter = '-', // '\x2D'
|
|
|
|
/** Regular expressions */
|
|
regexPunycode = /^xn--/,
|
|
regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
|
|
regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
|
|
|
|
/** Error messages */
|
|
errors = {
|
|
'overflow': 'Overflow: input needs wider integers to process',
|
|
'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
|
|
'invalid-input': 'Invalid input'
|
|
},
|
|
|
|
/** Convenience shortcuts */
|
|
baseMinusTMin = base - tMin,
|
|
floor = Math.floor,
|
|
stringFromCharCode = String.fromCharCode,
|
|
|
|
/** Temporary variable */
|
|
key;
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* A generic error utility function.
|
|
* @private
|
|
* @param {String} type The error type.
|
|
* @returns {Error} Throws a `RangeError` with the applicable error message.
|
|
*/
|
|
function error(type) {
|
|
throw new RangeError(errors[type]);
|
|
}
|
|
|
|
/**
|
|
* A generic `Array#map` utility function.
|
|
* @private
|
|
* @param {Array} array The array to iterate over.
|
|
* @param {Function} callback The function that gets called for every array
|
|
* item.
|
|
* @returns {Array} A new array of values returned by the callback function.
|
|
*/
|
|
function map(array, fn) {
|
|
var length = array.length;
|
|
var result = [];
|
|
while (length--) {
|
|
result[length] = fn(array[length]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* A simple `Array#map`-like wrapper to work with domain name strings or email
|
|
* addresses.
|
|
* @private
|
|
* @param {String} domain The domain name or email address.
|
|
* @param {Function} callback The function that gets called for every
|
|
* character.
|
|
* @returns {Array} A new string of characters returned by the callback
|
|
* function.
|
|
*/
|
|
function mapDomain(string, fn) {
|
|
var parts = string.split('@');
|
|
var result = '';
|
|
if (parts.length > 1) {
|
|
// In email addresses, only the domain name should be punycoded. Leave
|
|
// the local part (i.e. everything up to `@`) intact.
|
|
result = parts[0] + '@';
|
|
string = parts[1];
|
|
}
|
|
// Avoid `split(regex)` for IE8 compatibility. See #17.
|
|
string = string.replace(regexSeparators, '\x2E');
|
|
var labels = string.split('.');
|
|
var encoded = map(labels, fn).join('.');
|
|
return result + encoded;
|
|
}
|
|
|
|
/**
|
|
* Creates an array containing the numeric code points of each Unicode
|
|
* character in the string. While JavaScript uses UCS-2 internally,
|
|
* this function will convert a pair of surrogate halves (each of which
|
|
* UCS-2 exposes as separate characters) into a single code point,
|
|
* matching UTF-16.
|
|
* @see `punycode.ucs2.encode`
|
|
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
|
* @memberOf punycode.ucs2
|
|
* @name decode
|
|
* @param {String} string The Unicode input string (UCS-2).
|
|
* @returns {Array} The new array of code points.
|
|
*/
|
|
function ucs2decode(string) {
|
|
var output = [],
|
|
counter = 0,
|
|
length = string.length,
|
|
value,
|
|
extra;
|
|
while (counter < length) {
|
|
value = string.charCodeAt(counter++);
|
|
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
|
|
// high surrogate, and there is a next character
|
|
extra = string.charCodeAt(counter++);
|
|
if ((extra & 0xFC00) == 0xDC00) { // low surrogate
|
|
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
|
|
} else {
|
|
// unmatched surrogate; only append this code unit, in case the next
|
|
// code unit is the high surrogate of a surrogate pair
|
|
output.push(value);
|
|
counter--;
|
|
}
|
|
} else {
|
|
output.push(value);
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
|
|
/**
|
|
* Creates a string based on an array of numeric code points.
|
|
* @see `punycode.ucs2.decode`
|
|
* @memberOf punycode.ucs2
|
|
* @name encode
|
|
* @param {Array} codePoints The array of numeric code points.
|
|
* @returns {String} The new Unicode string (UCS-2).
|
|
*/
|
|
function ucs2encode(array) {
|
|
return map(array, function(value) {
|
|
var output = '';
|
|
if (value > 0xFFFF) {
|
|
value -= 0x10000;
|
|
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
|
|
value = 0xDC00 | value & 0x3FF;
|
|
}
|
|
output += stringFromCharCode(value);
|
|
return output;
|
|
}).join('');
|
|
}
|
|
|
|
/**
|
|
* Converts a basic code point into a digit/integer.
|
|
* @see `digitToBasic()`
|
|
* @private
|
|
* @param {Number} codePoint The basic numeric code point value.
|
|
* @returns {Number} The numeric value of a basic code point (for use in
|
|
* representing integers) in the range `0` to `base - 1`, or `base` if
|
|
* the code point does not represent a value.
|
|
*/
|
|
function basicToDigit(codePoint) {
|
|
if (codePoint - 48 < 10) {
|
|
return codePoint - 22;
|
|
}
|
|
if (codePoint - 65 < 26) {
|
|
return codePoint - 65;
|
|
}
|
|
if (codePoint - 97 < 26) {
|
|
return codePoint - 97;
|
|
}
|
|
return base;
|
|
}
|
|
|
|
/**
|
|
* Converts a digit/integer into a basic code point.
|
|
* @see `basicToDigit()`
|
|
* @private
|
|
* @param {Number} digit The numeric value of a basic code point.
|
|
* @returns {Number} The basic code point whose value (when used for
|
|
* representing integers) is `digit`, which needs to be in the range
|
|
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
|
|
* used; else, the lowercase form is used. The behavior is undefined
|
|
* if `flag` is non-zero and `digit` has no uppercase form.
|
|
*/
|
|
function digitToBasic(digit, flag) {
|
|
// 0..25 map to ASCII a..z or A..Z
|
|
// 26..35 map to ASCII 0..9
|
|
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
|
|
}
|
|
|
|
/**
|
|
* Bias adaptation function as per section 3.4 of RFC 3492.
|
|
* https://tools.ietf.org/html/rfc3492#section-3.4
|
|
* @private
|
|
*/
|
|
function adapt(delta, numPoints, firstTime) {
|
|
var k = 0;
|
|
delta = firstTime ? floor(delta / damp) : delta >> 1;
|
|
delta += floor(delta / numPoints);
|
|
for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
|
|
delta = floor(delta / baseMinusTMin);
|
|
}
|
|
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
|
|
}
|
|
|
|
/**
|
|
* Converts a Punycode string of ASCII-only symbols to a string of Unicode
|
|
* symbols.
|
|
* @memberOf punycode
|
|
* @param {String} input The Punycode string of ASCII-only symbols.
|
|
* @returns {String} The resulting string of Unicode symbols.
|
|
*/
|
|
function decode(input) {
|
|
// Don't use UCS-2
|
|
var output = [],
|
|
inputLength = input.length,
|
|
out,
|
|
i = 0,
|
|
n = initialN,
|
|
bias = initialBias,
|
|
basic,
|
|
j,
|
|
index,
|
|
oldi,
|
|
w,
|
|
k,
|
|
digit,
|
|
t,
|
|
/** Cached calculation results */
|
|
baseMinusT;
|
|
|
|
// Handle the basic code points: let `basic` be the number of input code
|
|
// points before the last delimiter, or `0` if there is none, then copy
|
|
// the first basic code points to the output.
|
|
|
|
basic = input.lastIndexOf(delimiter);
|
|
if (basic < 0) {
|
|
basic = 0;
|
|
}
|
|
|
|
for (j = 0; j < basic; ++j) {
|
|
// if it's not a basic code point
|
|
if (input.charCodeAt(j) >= 0x80) {
|
|
error('not-basic');
|
|
}
|
|
output.push(input.charCodeAt(j));
|
|
}
|
|
|
|
// Main decoding loop: start just after the last delimiter if any basic code
|
|
// points were copied; start at the beginning otherwise.
|
|
|
|
for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
|
|
|
|
// `index` is the index of the next character to be consumed.
|
|
// Decode a generalized variable-length integer into `delta`,
|
|
// which gets added to `i`. The overflow checking is easier
|
|
// if we increase `i` as we go, then subtract off its starting
|
|
// value at the end to obtain `delta`.
|
|
for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
|
|
|
|
if (index >= inputLength) {
|
|
error('invalid-input');
|
|
}
|
|
|
|
digit = basicToDigit(input.charCodeAt(index++));
|
|
|
|
if (digit >= base || digit > floor((maxInt - i) / w)) {
|
|
error('overflow');
|
|
}
|
|
|
|
i += digit * w;
|
|
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
|
|
|
|
if (digit < t) {
|
|
break;
|
|
}
|
|
|
|
baseMinusT = base - t;
|
|
if (w > floor(maxInt / baseMinusT)) {
|
|
error('overflow');
|
|
}
|
|
|
|
w *= baseMinusT;
|
|
|
|
}
|
|
|
|
out = output.length + 1;
|
|
bias = adapt(i - oldi, out, oldi == 0);
|
|
|
|
// `i` was supposed to wrap around from `out` to `0`,
|
|
// incrementing `n` each time, so we'll fix that now:
|
|
if (floor(i / out) > maxInt - n) {
|
|
error('overflow');
|
|
}
|
|
|
|
n += floor(i / out);
|
|
i %= out;
|
|
|
|
// Insert `n` at position `i` of the output
|
|
output.splice(i++, 0, n);
|
|
|
|
}
|
|
|
|
return ucs2encode(output);
|
|
}
|
|
|
|
/**
|
|
* Converts a string of Unicode symbols (e.g. a domain name label) to a
|
|
* Punycode string of ASCII-only symbols.
|
|
* @memberOf punycode
|
|
* @param {String} input The string of Unicode symbols.
|
|
* @returns {String} The resulting Punycode string of ASCII-only symbols.
|
|
*/
|
|
function encode(input) {
|
|
var n,
|
|
delta,
|
|
handledCPCount,
|
|
basicLength,
|
|
bias,
|
|
j,
|
|
m,
|
|
q,
|
|
k,
|
|
t,
|
|
currentValue,
|
|
output = [],
|
|
/** `inputLength` will hold the number of code points in `input`. */
|
|
inputLength,
|
|
/** Cached calculation results */
|
|
handledCPCountPlusOne,
|
|
baseMinusT,
|
|
qMinusT;
|
|
|
|
// Convert the input in UCS-2 to Unicode
|
|
input = ucs2decode(input);
|
|
|
|
// Cache the length
|
|
inputLength = input.length;
|
|
|
|
// Initialize the state
|
|
n = initialN;
|
|
delta = 0;
|
|
bias = initialBias;
|
|
|
|
// Handle the basic code points
|
|
for (j = 0; j < inputLength; ++j) {
|
|
currentValue = input[j];
|
|
if (currentValue < 0x80) {
|
|
output.push(stringFromCharCode(currentValue));
|
|
}
|
|
}
|
|
|
|
handledCPCount = basicLength = output.length;
|
|
|
|
// `handledCPCount` is the number of code points that have been handled;
|
|
// `basicLength` is the number of basic code points.
|
|
|
|
// Finish the basic string - if it is not empty - with a delimiter
|
|
if (basicLength) {
|
|
output.push(delimiter);
|
|
}
|
|
|
|
// Main encoding loop:
|
|
while (handledCPCount < inputLength) {
|
|
|
|
// All non-basic code points < n have been handled already. Find the next
|
|
// larger one:
|
|
for (m = maxInt, j = 0; j < inputLength; ++j) {
|
|
currentValue = input[j];
|
|
if (currentValue >= n && currentValue < m) {
|
|
m = currentValue;
|
|
}
|
|
}
|
|
|
|
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
|
|
// but guard against overflow
|
|
handledCPCountPlusOne = handledCPCount + 1;
|
|
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
|
|
error('overflow');
|
|
}
|
|
|
|
delta += (m - n) * handledCPCountPlusOne;
|
|
n = m;
|
|
|
|
for (j = 0; j < inputLength; ++j) {
|
|
currentValue = input[j];
|
|
|
|
if (currentValue < n && ++delta > maxInt) {
|
|
error('overflow');
|
|
}
|
|
|
|
if (currentValue == n) {
|
|
// Represent delta as a generalized variable-length integer
|
|
for (q = delta, k = base; /* no condition */; k += base) {
|
|
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
|
|
if (q < t) {
|
|
break;
|
|
}
|
|
qMinusT = q - t;
|
|
baseMinusT = base - t;
|
|
output.push(
|
|
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
|
|
);
|
|
q = floor(qMinusT / baseMinusT);
|
|
}
|
|
|
|
output.push(stringFromCharCode(digitToBasic(q, 0)));
|
|
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
|
|
delta = 0;
|
|
++handledCPCount;
|
|
}
|
|
}
|
|
|
|
++delta;
|
|
++n;
|
|
|
|
}
|
|
return output.join('');
|
|
}
|
|
|
|
/**
|
|
* Converts a Punycode string representing a domain name or an email address
|
|
* to Unicode. Only the Punycoded parts of the input will be converted, i.e.
|
|
* it doesn't matter if you call it on a string that has already been
|
|
* converted to Unicode.
|
|
* @memberOf punycode
|
|
* @param {String} input The Punycoded domain name or email address to
|
|
* convert to Unicode.
|
|
* @returns {String} The Unicode representation of the given Punycode
|
|
* string.
|
|
*/
|
|
function toUnicode(input) {
|
|
return mapDomain(input, function(string) {
|
|
return regexPunycode.test(string)
|
|
? decode(string.slice(4).toLowerCase())
|
|
: string;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Converts a Unicode string representing a domain name or an email address to
|
|
* Punycode. Only the non-ASCII parts of the domain name will be converted,
|
|
* i.e. it doesn't matter if you call it with a domain that's already in
|
|
* ASCII.
|
|
* @memberOf punycode
|
|
* @param {String} input The domain name or email address to convert, as a
|
|
* Unicode string.
|
|
* @returns {String} The Punycode representation of the given domain name or
|
|
* email address.
|
|
*/
|
|
function toASCII(input) {
|
|
return mapDomain(input, function(string) {
|
|
return regexNonASCII.test(string)
|
|
? 'xn--' + encode(string)
|
|
: string;
|
|
});
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/** Define the public API */
|
|
punycode = {
|
|
/**
|
|
* A string representing the current Punycode.js version number.
|
|
* @memberOf punycode
|
|
* @type String
|
|
*/
|
|
'version': '1.4.1',
|
|
/**
|
|
* An object of methods to convert from JavaScript's internal character
|
|
* representation (UCS-2) to Unicode code points, and back.
|
|
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
|
* @memberOf punycode
|
|
* @type Object
|
|
*/
|
|
'ucs2': {
|
|
'decode': ucs2decode,
|
|
'encode': ucs2encode
|
|
},
|
|
'decode': decode,
|
|
'encode': encode,
|
|
'toASCII': toASCII,
|
|
'toUnicode': toUnicode
|
|
};
|
|
|
|
/** Expose `punycode` */
|
|
// Some AMD build optimizers, like r.js, check for specific condition patterns
|
|
// like the following:
|
|
if (
|
|
typeof define == 'function' &&
|
|
typeof define.amd == 'object' &&
|
|
define.amd
|
|
) {
|
|
define('punycode', function() {
|
|
return punycode;
|
|
});
|
|
} else if (freeExports && freeModule) {
|
|
if (module.exports == freeExports) {
|
|
// in Node.js, io.js, or RingoJS v0.8.0+
|
|
freeModule.exports = punycode;
|
|
} else {
|
|
// in Narwhal or RingoJS v0.7.0-
|
|
for (key in punycode) {
|
|
punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
|
|
}
|
|
}
|
|
} else {
|
|
// in Rhino or a web browser
|
|
root.punycode = punycode;
|
|
}
|
|
|
|
}(this));
|
|
|
|
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],75:[function(require,module,exports){
|
|
/*
|
|
* Copyright Joyent, Inc. and other Node contributors.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
* persons to whom the Software is furnished to do so, subject to the
|
|
* following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
* NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var punycode = require('punycode/');
|
|
|
|
function Url() {
|
|
this.protocol = null;
|
|
this.slashes = null;
|
|
this.auth = null;
|
|
this.host = null;
|
|
this.port = null;
|
|
this.hostname = null;
|
|
this.hash = null;
|
|
this.search = null;
|
|
this.query = null;
|
|
this.pathname = null;
|
|
this.path = null;
|
|
this.href = null;
|
|
}
|
|
|
|
// Reference: RFC 3986, RFC 1808, RFC 2396
|
|
|
|
/*
|
|
* define these here so at least they only have to be
|
|
* compiled once on the first module load.
|
|
*/
|
|
var protocolPattern = /^([a-z0-9.+-]+:)/i,
|
|
portPattern = /:[0-9]*$/,
|
|
|
|
// Special case for a simple path URL
|
|
simplePathPattern = /^(\/\/?(?!\/)[^?\s]*)(\?[^\s]*)?$/,
|
|
|
|
/*
|
|
* RFC 2396: characters reserved for delimiting URLs.
|
|
* We actually just auto-escape these.
|
|
*/
|
|
delims = [
|
|
'<', '>', '"', '`', ' ', '\r', '\n', '\t'
|
|
],
|
|
|
|
// RFC 2396: characters not allowed for various reasons.
|
|
unwise = [
|
|
'{', '}', '|', '\\', '^', '`'
|
|
].concat(delims),
|
|
|
|
// Allowed by RFCs, but cause of XSS attacks. Always escape these.
|
|
autoEscape = ['\''].concat(unwise),
|
|
/*
|
|
* Characters that are never ever allowed in a hostname.
|
|
* Note that any invalid chars are also handled, but these
|
|
* are the ones that are *expected* to be seen, so we fast-path
|
|
* them.
|
|
*/
|
|
nonHostChars = [
|
|
'%', '/', '?', ';', '#'
|
|
].concat(autoEscape),
|
|
hostEndingChars = [
|
|
'/', '?', '#'
|
|
],
|
|
hostnameMaxLen = 255,
|
|
hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
|
|
hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
|
|
// protocols that can allow "unsafe" and "unwise" chars.
|
|
unsafeProtocol = {
|
|
javascript: true,
|
|
'javascript:': true
|
|
},
|
|
// protocols that never have a hostname.
|
|
hostlessProtocol = {
|
|
javascript: true,
|
|
'javascript:': true
|
|
},
|
|
// protocols that always contain a // bit.
|
|
slashedProtocol = {
|
|
http: true,
|
|
https: true,
|
|
ftp: true,
|
|
gopher: true,
|
|
file: true,
|
|
'http:': true,
|
|
'https:': true,
|
|
'ftp:': true,
|
|
'gopher:': true,
|
|
'file:': true
|
|
},
|
|
querystring = require('qs');
|
|
|
|
function urlParse(url, parseQueryString, slashesDenoteHost) {
|
|
if (url && typeof url === 'object' && url instanceof Url) { return url; }
|
|
|
|
var u = new Url();
|
|
u.parse(url, parseQueryString, slashesDenoteHost);
|
|
return u;
|
|
}
|
|
|
|
Url.prototype.parse = function (url, parseQueryString, slashesDenoteHost) {
|
|
if (typeof url !== 'string') {
|
|
throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
|
|
}
|
|
|
|
/*
|
|
* Copy chrome, IE, opera backslash-handling behavior.
|
|
* Back slashes before the query string get converted to forward slashes
|
|
* See: https://code.google.com/p/chromium/issues/detail?id=25916
|
|
*/
|
|
var queryIndex = url.indexOf('?'),
|
|
splitter = queryIndex !== -1 && queryIndex < url.indexOf('#') ? '?' : '#',
|
|
uSplit = url.split(splitter),
|
|
slashRegex = /\\/g;
|
|
uSplit[0] = uSplit[0].replace(slashRegex, '/');
|
|
url = uSplit.join(splitter);
|
|
|
|
var rest = url;
|
|
|
|
/*
|
|
* trim before proceeding.
|
|
* This is to support parse stuff like " http://foo.com \n"
|
|
*/
|
|
rest = rest.trim();
|
|
|
|
if (!slashesDenoteHost && url.split('#').length === 1) {
|
|
// Try fast path regexp
|
|
var simplePath = simplePathPattern.exec(rest);
|
|
if (simplePath) {
|
|
this.path = rest;
|
|
this.href = rest;
|
|
this.pathname = simplePath[1];
|
|
if (simplePath[2]) {
|
|
this.search = simplePath[2];
|
|
if (parseQueryString) {
|
|
this.query = querystring.parse(this.search.substr(1));
|
|
} else {
|
|
this.query = this.search.substr(1);
|
|
}
|
|
} else if (parseQueryString) {
|
|
this.search = '';
|
|
this.query = {};
|
|
}
|
|
return this;
|
|
}
|
|
}
|
|
|
|
var proto = protocolPattern.exec(rest);
|
|
if (proto) {
|
|
proto = proto[0];
|
|
var lowerProto = proto.toLowerCase();
|
|
this.protocol = lowerProto;
|
|
rest = rest.substr(proto.length);
|
|
}
|
|
|
|
/*
|
|
* figure out if it's got a host
|
|
* user@server is *always* interpreted as a hostname, and url
|
|
* resolution will treat //foo/bar as host=foo,path=bar because that's
|
|
* how the browser resolves relative URLs.
|
|
*/
|
|
if (slashesDenoteHost || proto || rest.match(/^\/\/[^@/]+@[^@/]+/)) {
|
|
var slashes = rest.substr(0, 2) === '//';
|
|
if (slashes && !(proto && hostlessProtocol[proto])) {
|
|
rest = rest.substr(2);
|
|
this.slashes = true;
|
|
}
|
|
}
|
|
|
|
if (!hostlessProtocol[proto] && (slashes || (proto && !slashedProtocol[proto]))) {
|
|
|
|
/*
|
|
* there's a hostname.
|
|
* the first instance of /, ?, ;, or # ends the host.
|
|
*
|
|
* If there is an @ in the hostname, then non-host chars *are* allowed
|
|
* to the left of the last @ sign, unless some host-ending character
|
|
* comes *before* the @-sign.
|
|
* URLs are obnoxious.
|
|
*
|
|
* ex:
|
|
* http://a@b@c/ => user:a@b host:c
|
|
* http://a@b?@c => user:a host:c path:/?@c
|
|
*/
|
|
|
|
/*
|
|
* v0.12 TODO(isaacs): This is not quite how Chrome does things.
|
|
* Review our test case against browsers more comprehensively.
|
|
*/
|
|
|
|
// find the first instance of any hostEndingChars
|
|
var hostEnd = -1;
|
|
for (var i = 0; i < hostEndingChars.length; i++) {
|
|
var hec = rest.indexOf(hostEndingChars[i]);
|
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) { hostEnd = hec; }
|
|
}
|
|
|
|
/*
|
|
* at this point, either we have an explicit point where the
|
|
* auth portion cannot go past, or the last @ char is the decider.
|
|
*/
|
|
var auth, atSign;
|
|
if (hostEnd === -1) {
|
|
// atSign can be anywhere.
|
|
atSign = rest.lastIndexOf('@');
|
|
} else {
|
|
/*
|
|
* atSign must be in auth portion.
|
|
* http://a@b/c@d => host:b auth:a path:/c@d
|
|
*/
|
|
atSign = rest.lastIndexOf('@', hostEnd);
|
|
}
|
|
|
|
/*
|
|
* Now we have a portion which is definitely the auth.
|
|
* Pull that off.
|
|
*/
|
|
if (atSign !== -1) {
|
|
auth = rest.slice(0, atSign);
|
|
rest = rest.slice(atSign + 1);
|
|
this.auth = decodeURIComponent(auth);
|
|
}
|
|
|
|
// the host is the remaining to the left of the first non-host char
|
|
hostEnd = -1;
|
|
for (var i = 0; i < nonHostChars.length; i++) {
|
|
var hec = rest.indexOf(nonHostChars[i]);
|
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) { hostEnd = hec; }
|
|
}
|
|
// if we still have not hit it, then the entire thing is a host.
|
|
if (hostEnd === -1) { hostEnd = rest.length; }
|
|
|
|
this.host = rest.slice(0, hostEnd);
|
|
rest = rest.slice(hostEnd);
|
|
|
|
// pull out port.
|
|
this.parseHost();
|
|
|
|
/*
|
|
* we've indicated that there is a hostname,
|
|
* so even if it's empty, it has to be present.
|
|
*/
|
|
this.hostname = this.hostname || '';
|
|
|
|
/*
|
|
* if hostname begins with [ and ends with ]
|
|
* assume that it's an IPv6 address.
|
|
*/
|
|
var ipv6Hostname = this.hostname[0] === '[' && this.hostname[this.hostname.length - 1] === ']';
|
|
|
|
// validate a little.
|
|
if (!ipv6Hostname) {
|
|
var hostparts = this.hostname.split(/\./);
|
|
for (var i = 0, l = hostparts.length; i < l; i++) {
|
|
var part = hostparts[i];
|
|
if (!part) { continue; }
|
|
if (!part.match(hostnamePartPattern)) {
|
|
var newpart = '';
|
|
for (var j = 0, k = part.length; j < k; j++) {
|
|
if (part.charCodeAt(j) > 127) {
|
|
/*
|
|
* we replace non-ASCII char with a temporary placeholder
|
|
* we need this to make sure size of hostname is not
|
|
* broken by replacing non-ASCII by nothing
|
|
*/
|
|
newpart += 'x';
|
|
} else {
|
|
newpart += part[j];
|
|
}
|
|
}
|
|
// we test again with ASCII char only
|
|
if (!newpart.match(hostnamePartPattern)) {
|
|
var validParts = hostparts.slice(0, i);
|
|
var notHost = hostparts.slice(i + 1);
|
|
var bit = part.match(hostnamePartStart);
|
|
if (bit) {
|
|
validParts.push(bit[1]);
|
|
notHost.unshift(bit[2]);
|
|
}
|
|
if (notHost.length) {
|
|
rest = '/' + notHost.join('.') + rest;
|
|
}
|
|
this.hostname = validParts.join('.');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.hostname.length > hostnameMaxLen) {
|
|
this.hostname = '';
|
|
} else {
|
|
// hostnames are always lower case.
|
|
this.hostname = this.hostname.toLowerCase();
|
|
}
|
|
|
|
if (!ipv6Hostname) {
|
|
/*
|
|
* IDNA Support: Returns a punycoded representation of "domain".
|
|
* It only converts parts of the domain name that
|
|
* have non-ASCII characters, i.e. it doesn't matter if
|
|
* you call it with a domain that already is ASCII-only.
|
|
*/
|
|
this.hostname = punycode.toASCII(this.hostname);
|
|
}
|
|
|
|
var p = this.port ? ':' + this.port : '';
|
|
var h = this.hostname || '';
|
|
this.host = h + p;
|
|
this.href += this.host;
|
|
|
|
/*
|
|
* strip [ and ] from the hostname
|
|
* the host field still retains them, though
|
|
*/
|
|
if (ipv6Hostname) {
|
|
this.hostname = this.hostname.substr(1, this.hostname.length - 2);
|
|
if (rest[0] !== '/') {
|
|
rest = '/' + rest;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* now rest is set to the post-host stuff.
|
|
* chop off any delim chars.
|
|
*/
|
|
if (!unsafeProtocol[lowerProto]) {
|
|
|
|
/*
|
|
* First, make 100% sure that any "autoEscape" chars get
|
|
* escaped, even if encodeURIComponent doesn't think they
|
|
* need to be.
|
|
*/
|
|
for (var i = 0, l = autoEscape.length; i < l; i++) {
|
|
var ae = autoEscape[i];
|
|
if (rest.indexOf(ae) === -1) { continue; }
|
|
var esc = encodeURIComponent(ae);
|
|
if (esc === ae) {
|
|
esc = escape(ae);
|
|
}
|
|
rest = rest.split(ae).join(esc);
|
|
}
|
|
}
|
|
|
|
// chop off from the tail first.
|
|
var hash = rest.indexOf('#');
|
|
if (hash !== -1) {
|
|
// got a fragment string.
|
|
this.hash = rest.substr(hash);
|
|
rest = rest.slice(0, hash);
|
|
}
|
|
var qm = rest.indexOf('?');
|
|
if (qm !== -1) {
|
|
this.search = rest.substr(qm);
|
|
this.query = rest.substr(qm + 1);
|
|
if (parseQueryString) {
|
|
this.query = querystring.parse(this.query);
|
|
}
|
|
rest = rest.slice(0, qm);
|
|
} else if (parseQueryString) {
|
|
// no query string, but parseQueryString still requested
|
|
this.search = '';
|
|
this.query = {};
|
|
}
|
|
if (rest) { this.pathname = rest; }
|
|
if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
|
|
this.pathname = '/';
|
|
}
|
|
|
|
// to support http.request
|
|
if (this.pathname || this.search) {
|
|
var p = this.pathname || '';
|
|
var s = this.search || '';
|
|
this.path = p + s;
|
|
}
|
|
|
|
// finally, reconstruct the href based on what has been validated.
|
|
this.href = this.format();
|
|
return this;
|
|
};
|
|
|
|
// format a parsed object into a url string
|
|
function urlFormat(obj) {
|
|
/*
|
|
* ensure it's an object, and not a string url.
|
|
* If it's an obj, this is a no-op.
|
|
* this way, you can call url_format() on strings
|
|
* to clean up potentially wonky urls.
|
|
*/
|
|
if (typeof obj === 'string') { obj = urlParse(obj); }
|
|
if (!(obj instanceof Url)) { return Url.prototype.format.call(obj); }
|
|
return obj.format();
|
|
}
|
|
|
|
Url.prototype.format = function () {
|
|
var auth = this.auth || '';
|
|
if (auth) {
|
|
auth = encodeURIComponent(auth);
|
|
auth = auth.replace(/%3A/i, ':');
|
|
auth += '@';
|
|
}
|
|
|
|
var protocol = this.protocol || '',
|
|
pathname = this.pathname || '',
|
|
hash = this.hash || '',
|
|
host = false,
|
|
query = '';
|
|
|
|
if (this.host) {
|
|
host = auth + this.host;
|
|
} else if (this.hostname) {
|
|
host = auth + (this.hostname.indexOf(':') === -1 ? this.hostname : '[' + this.hostname + ']');
|
|
if (this.port) {
|
|
host += ':' + this.port;
|
|
}
|
|
}
|
|
|
|
if (this.query && typeof this.query === 'object' && Object.keys(this.query).length) {
|
|
query = querystring.stringify(this.query, {
|
|
arrayFormat: 'repeat',
|
|
addQueryPrefix: false
|
|
});
|
|
}
|
|
|
|
var search = this.search || (query && ('?' + query)) || '';
|
|
|
|
if (protocol && protocol.substr(-1) !== ':') { protocol += ':'; }
|
|
|
|
/*
|
|
* only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
|
|
* unless they had them to begin with.
|
|
*/
|
|
if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {
|
|
host = '//' + (host || '');
|
|
if (pathname && pathname.charAt(0) !== '/') { pathname = '/' + pathname; }
|
|
} else if (!host) {
|
|
host = '';
|
|
}
|
|
|
|
if (hash && hash.charAt(0) !== '#') { hash = '#' + hash; }
|
|
if (search && search.charAt(0) !== '?') { search = '?' + search; }
|
|
|
|
pathname = pathname.replace(/[?#]/g, function (match) {
|
|
return encodeURIComponent(match);
|
|
});
|
|
search = search.replace('#', '%23');
|
|
|
|
return protocol + host + pathname + search + hash;
|
|
};
|
|
|
|
function urlResolve(source, relative) {
|
|
return urlParse(source, false, true).resolve(relative);
|
|
}
|
|
|
|
Url.prototype.resolve = function (relative) {
|
|
return this.resolveObject(urlParse(relative, false, true)).format();
|
|
};
|
|
|
|
function urlResolveObject(source, relative) {
|
|
if (!source) { return relative; }
|
|
return urlParse(source, false, true).resolveObject(relative);
|
|
}
|
|
|
|
Url.prototype.resolveObject = function (relative) {
|
|
if (typeof relative === 'string') {
|
|
var rel = new Url();
|
|
rel.parse(relative, false, true);
|
|
relative = rel;
|
|
}
|
|
|
|
var result = new Url();
|
|
var tkeys = Object.keys(this);
|
|
for (var tk = 0; tk < tkeys.length; tk++) {
|
|
var tkey = tkeys[tk];
|
|
result[tkey] = this[tkey];
|
|
}
|
|
|
|
/*
|
|
* hash is always overridden, no matter what.
|
|
* even href="" will remove it.
|
|
*/
|
|
result.hash = relative.hash;
|
|
|
|
// if the relative url is empty, then there's nothing left to do here.
|
|
if (relative.href === '') {
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
// hrefs like //foo/bar always cut to the protocol.
|
|
if (relative.slashes && !relative.protocol) {
|
|
// take everything except the protocol from relative
|
|
var rkeys = Object.keys(relative);
|
|
for (var rk = 0; rk < rkeys.length; rk++) {
|
|
var rkey = rkeys[rk];
|
|
if (rkey !== 'protocol') { result[rkey] = relative[rkey]; }
|
|
}
|
|
|
|
// urlParse appends trailing / to urls like http://www.example.com
|
|
if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) {
|
|
result.pathname = '/';
|
|
result.path = result.pathname;
|
|
}
|
|
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
if (relative.protocol && relative.protocol !== result.protocol) {
|
|
/*
|
|
* if it's a known url protocol, then changing
|
|
* the protocol does weird things
|
|
* first, if it's not file:, then we MUST have a host,
|
|
* and if there was a path
|
|
* to begin with, then we MUST have a path.
|
|
* if it is file:, then the host is dropped,
|
|
* because that's known to be hostless.
|
|
* anything else is assumed to be absolute.
|
|
*/
|
|
if (!slashedProtocol[relative.protocol]) {
|
|
var keys = Object.keys(relative);
|
|
for (var v = 0; v < keys.length; v++) {
|
|
var k = keys[v];
|
|
result[k] = relative[k];
|
|
}
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
result.protocol = relative.protocol;
|
|
if (!relative.host && !hostlessProtocol[relative.protocol]) {
|
|
var relPath = (relative.pathname || '').split('/');
|
|
while (relPath.length && !(relative.host = relPath.shift())) { }
|
|
if (!relative.host) { relative.host = ''; }
|
|
if (!relative.hostname) { relative.hostname = ''; }
|
|
if (relPath[0] !== '') { relPath.unshift(''); }
|
|
if (relPath.length < 2) { relPath.unshift(''); }
|
|
result.pathname = relPath.join('/');
|
|
} else {
|
|
result.pathname = relative.pathname;
|
|
}
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
result.host = relative.host || '';
|
|
result.auth = relative.auth;
|
|
result.hostname = relative.hostname || relative.host;
|
|
result.port = relative.port;
|
|
// to support http.request
|
|
if (result.pathname || result.search) {
|
|
var p = result.pathname || '';
|
|
var s = result.search || '';
|
|
result.path = p + s;
|
|
}
|
|
result.slashes = result.slashes || relative.slashes;
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
var isSourceAbs = result.pathname && result.pathname.charAt(0) === '/',
|
|
isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === '/',
|
|
mustEndAbs = isRelAbs || isSourceAbs || (result.host && relative.pathname),
|
|
removeAllDots = mustEndAbs,
|
|
srcPath = result.pathname && result.pathname.split('/') || [],
|
|
relPath = relative.pathname && relative.pathname.split('/') || [],
|
|
psychotic = result.protocol && !slashedProtocol[result.protocol];
|
|
|
|
/*
|
|
* if the url is a non-slashed url, then relative
|
|
* links like ../.. should be able
|
|
* to crawl up to the hostname, as well. This is strange.
|
|
* result.protocol has already been set by now.
|
|
* Later on, put the first path part into the host field.
|
|
*/
|
|
if (psychotic) {
|
|
result.hostname = '';
|
|
result.port = null;
|
|
if (result.host) {
|
|
if (srcPath[0] === '') { srcPath[0] = result.host; } else { srcPath.unshift(result.host); }
|
|
}
|
|
result.host = '';
|
|
if (relative.protocol) {
|
|
relative.hostname = null;
|
|
relative.port = null;
|
|
if (relative.host) {
|
|
if (relPath[0] === '') { relPath[0] = relative.host; } else { relPath.unshift(relative.host); }
|
|
}
|
|
relative.host = null;
|
|
}
|
|
mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
|
|
}
|
|
|
|
if (isRelAbs) {
|
|
// it's absolute.
|
|
result.host = relative.host || relative.host === '' ? relative.host : result.host;
|
|
result.hostname = relative.hostname || relative.hostname === '' ? relative.hostname : result.hostname;
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
srcPath = relPath;
|
|
// fall through to the dot-handling below.
|
|
} else if (relPath.length) {
|
|
/*
|
|
* it's relative
|
|
* throw away the existing file, and take the new path instead.
|
|
*/
|
|
if (!srcPath) { srcPath = []; }
|
|
srcPath.pop();
|
|
srcPath = srcPath.concat(relPath);
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
} else if (relative.search != null) {
|
|
/*
|
|
* just pull out the search.
|
|
* like href='?foo'.
|
|
* Put this after the other two cases because it simplifies the booleans
|
|
*/
|
|
if (psychotic) {
|
|
result.host = srcPath.shift();
|
|
result.hostname = result.host;
|
|
/*
|
|
* occationaly the auth can get stuck only in host
|
|
* this especially happens in cases like
|
|
* url.resolveObject('mailto:local1@domain1', 'local2@domain2')
|
|
*/
|
|
var authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false;
|
|
if (authInHost) {
|
|
result.auth = authInHost.shift();
|
|
result.hostname = authInHost.shift();
|
|
result.host = result.hostname;
|
|
}
|
|
}
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
// to support http.request
|
|
if (result.pathname !== null || result.search !== null) {
|
|
result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '');
|
|
}
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
if (!srcPath.length) {
|
|
/*
|
|
* no path at all. easy.
|
|
* we've already handled the other stuff above.
|
|
*/
|
|
result.pathname = null;
|
|
// to support http.request
|
|
if (result.search) {
|
|
result.path = '/' + result.search;
|
|
} else {
|
|
result.path = null;
|
|
}
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* if a url ENDs in . or .., then it must get a trailing slash.
|
|
* however, if it ends in anything else non-slashy,
|
|
* then it must NOT get a trailing slash.
|
|
*/
|
|
var last = srcPath.slice(-1)[0];
|
|
var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === '.' || last === '..') || last === '';
|
|
|
|
/*
|
|
* strip single dots, resolve double dots to parent dir
|
|
* if the path tries to go above the root, `up` ends up > 0
|
|
*/
|
|
var up = 0;
|
|
for (var i = srcPath.length; i >= 0; i--) {
|
|
last = srcPath[i];
|
|
if (last === '.') {
|
|
srcPath.splice(i, 1);
|
|
} else if (last === '..') {
|
|
srcPath.splice(i, 1);
|
|
up++;
|
|
} else if (up) {
|
|
srcPath.splice(i, 1);
|
|
up--;
|
|
}
|
|
}
|
|
|
|
// if the path is allowed to go above the root, restore leading ..s
|
|
if (!mustEndAbs && !removeAllDots) {
|
|
for (; up--; up) {
|
|
srcPath.unshift('..');
|
|
}
|
|
}
|
|
|
|
if (mustEndAbs && srcPath[0] !== '' && (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
|
|
srcPath.unshift('');
|
|
}
|
|
|
|
if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
|
|
srcPath.push('');
|
|
}
|
|
|
|
var isAbsolute = srcPath[0] === '' || (srcPath[0] && srcPath[0].charAt(0) === '/');
|
|
|
|
// put the host back
|
|
if (psychotic) {
|
|
result.hostname = isAbsolute ? '' : srcPath.length ? srcPath.shift() : '';
|
|
result.host = result.hostname;
|
|
/*
|
|
* occationaly the auth can get stuck only in host
|
|
* this especially happens in cases like
|
|
* url.resolveObject('mailto:local1@domain1', 'local2@domain2')
|
|
*/
|
|
var authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false;
|
|
if (authInHost) {
|
|
result.auth = authInHost.shift();
|
|
result.hostname = authInHost.shift();
|
|
result.host = result.hostname;
|
|
}
|
|
}
|
|
|
|
mustEndAbs = mustEndAbs || (result.host && srcPath.length);
|
|
|
|
if (mustEndAbs && !isAbsolute) {
|
|
srcPath.unshift('');
|
|
}
|
|
|
|
if (srcPath.length > 0) {
|
|
result.pathname = srcPath.join('/');
|
|
} else {
|
|
result.pathname = null;
|
|
result.path = null;
|
|
}
|
|
|
|
// to support request.http
|
|
if (result.pathname !== null || result.search !== null) {
|
|
result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '');
|
|
}
|
|
result.auth = relative.auth || result.auth;
|
|
result.slashes = result.slashes || relative.slashes;
|
|
result.href = result.format();
|
|
return result;
|
|
};
|
|
|
|
Url.prototype.parseHost = function () {
|
|
var host = this.host;
|
|
var port = portPattern.exec(host);
|
|
if (port) {
|
|
port = port[0];
|
|
if (port !== ':') {
|
|
this.port = port.substr(1);
|
|
}
|
|
host = host.substr(0, host.length - port.length);
|
|
}
|
|
if (host) { this.hostname = host; }
|
|
};
|
|
|
|
exports.parse = urlParse;
|
|
exports.resolve = urlResolve;
|
|
exports.resolveObject = urlResolveObject;
|
|
exports.format = urlFormat;
|
|
|
|
exports.Url = Url;
|
|
|
|
},{"punycode/":74,"qs":64}],76:[function(require,module,exports){
|
|
module.exports = function isBuffer(arg) {
|
|
return arg && typeof arg === 'object'
|
|
&& typeof arg.copy === 'function'
|
|
&& typeof arg.fill === 'function'
|
|
&& typeof arg.readUInt8 === 'function';
|
|
}
|
|
},{}],77:[function(require,module,exports){
|
|
// Currently in sync with Node.js lib/internal/util/types.js
|
|
// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
|
|
|
|
'use strict';
|
|
|
|
var isArgumentsObject = require('is-arguments');
|
|
var isGeneratorFunction = require('is-generator-function');
|
|
var whichTypedArray = require('which-typed-array');
|
|
var isTypedArray = require('is-typed-array');
|
|
|
|
function uncurryThis(f) {
|
|
return f.call.bind(f);
|
|
}
|
|
|
|
var BigIntSupported = typeof BigInt !== 'undefined';
|
|
var SymbolSupported = typeof Symbol !== 'undefined';
|
|
|
|
var ObjectToString = uncurryThis(Object.prototype.toString);
|
|
|
|
var numberValue = uncurryThis(Number.prototype.valueOf);
|
|
var stringValue = uncurryThis(String.prototype.valueOf);
|
|
var booleanValue = uncurryThis(Boolean.prototype.valueOf);
|
|
|
|
if (BigIntSupported) {
|
|
var bigIntValue = uncurryThis(BigInt.prototype.valueOf);
|
|
}
|
|
|
|
if (SymbolSupported) {
|
|
var symbolValue = uncurryThis(Symbol.prototype.valueOf);
|
|
}
|
|
|
|
function checkBoxedPrimitive(value, prototypeValueOf) {
|
|
if (typeof value !== 'object') {
|
|
return false;
|
|
}
|
|
try {
|
|
prototypeValueOf(value);
|
|
return true;
|
|
} catch(e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
exports.isArgumentsObject = isArgumentsObject;
|
|
exports.isGeneratorFunction = isGeneratorFunction;
|
|
exports.isTypedArray = isTypedArray;
|
|
|
|
// Taken from here and modified for better browser support
|
|
// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js
|
|
function isPromise(input) {
|
|
return (
|
|
(
|
|
typeof Promise !== 'undefined' &&
|
|
input instanceof Promise
|
|
) ||
|
|
(
|
|
input !== null &&
|
|
typeof input === 'object' &&
|
|
typeof input.then === 'function' &&
|
|
typeof input.catch === 'function'
|
|
)
|
|
);
|
|
}
|
|
exports.isPromise = isPromise;
|
|
|
|
function isArrayBufferView(value) {
|
|
if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {
|
|
return ArrayBuffer.isView(value);
|
|
}
|
|
|
|
return (
|
|
isTypedArray(value) ||
|
|
isDataView(value)
|
|
);
|
|
}
|
|
exports.isArrayBufferView = isArrayBufferView;
|
|
|
|
|
|
function isUint8Array(value) {
|
|
return whichTypedArray(value) === 'Uint8Array';
|
|
}
|
|
exports.isUint8Array = isUint8Array;
|
|
|
|
function isUint8ClampedArray(value) {
|
|
return whichTypedArray(value) === 'Uint8ClampedArray';
|
|
}
|
|
exports.isUint8ClampedArray = isUint8ClampedArray;
|
|
|
|
function isUint16Array(value) {
|
|
return whichTypedArray(value) === 'Uint16Array';
|
|
}
|
|
exports.isUint16Array = isUint16Array;
|
|
|
|
function isUint32Array(value) {
|
|
return whichTypedArray(value) === 'Uint32Array';
|
|
}
|
|
exports.isUint32Array = isUint32Array;
|
|
|
|
function isInt8Array(value) {
|
|
return whichTypedArray(value) === 'Int8Array';
|
|
}
|
|
exports.isInt8Array = isInt8Array;
|
|
|
|
function isInt16Array(value) {
|
|
return whichTypedArray(value) === 'Int16Array';
|
|
}
|
|
exports.isInt16Array = isInt16Array;
|
|
|
|
function isInt32Array(value) {
|
|
return whichTypedArray(value) === 'Int32Array';
|
|
}
|
|
exports.isInt32Array = isInt32Array;
|
|
|
|
function isFloat32Array(value) {
|
|
return whichTypedArray(value) === 'Float32Array';
|
|
}
|
|
exports.isFloat32Array = isFloat32Array;
|
|
|
|
function isFloat64Array(value) {
|
|
return whichTypedArray(value) === 'Float64Array';
|
|
}
|
|
exports.isFloat64Array = isFloat64Array;
|
|
|
|
function isBigInt64Array(value) {
|
|
return whichTypedArray(value) === 'BigInt64Array';
|
|
}
|
|
exports.isBigInt64Array = isBigInt64Array;
|
|
|
|
function isBigUint64Array(value) {
|
|
return whichTypedArray(value) === 'BigUint64Array';
|
|
}
|
|
exports.isBigUint64Array = isBigUint64Array;
|
|
|
|
function isMapToString(value) {
|
|
return ObjectToString(value) === '[object Map]';
|
|
}
|
|
isMapToString.working = (
|
|
typeof Map !== 'undefined' &&
|
|
isMapToString(new Map())
|
|
);
|
|
|
|
function isMap(value) {
|
|
if (typeof Map === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isMapToString.working
|
|
? isMapToString(value)
|
|
: value instanceof Map;
|
|
}
|
|
exports.isMap = isMap;
|
|
|
|
function isSetToString(value) {
|
|
return ObjectToString(value) === '[object Set]';
|
|
}
|
|
isSetToString.working = (
|
|
typeof Set !== 'undefined' &&
|
|
isSetToString(new Set())
|
|
);
|
|
function isSet(value) {
|
|
if (typeof Set === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isSetToString.working
|
|
? isSetToString(value)
|
|
: value instanceof Set;
|
|
}
|
|
exports.isSet = isSet;
|
|
|
|
function isWeakMapToString(value) {
|
|
return ObjectToString(value) === '[object WeakMap]';
|
|
}
|
|
isWeakMapToString.working = (
|
|
typeof WeakMap !== 'undefined' &&
|
|
isWeakMapToString(new WeakMap())
|
|
);
|
|
function isWeakMap(value) {
|
|
if (typeof WeakMap === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isWeakMapToString.working
|
|
? isWeakMapToString(value)
|
|
: value instanceof WeakMap;
|
|
}
|
|
exports.isWeakMap = isWeakMap;
|
|
|
|
function isWeakSetToString(value) {
|
|
return ObjectToString(value) === '[object WeakSet]';
|
|
}
|
|
isWeakSetToString.working = (
|
|
typeof WeakSet !== 'undefined' &&
|
|
isWeakSetToString(new WeakSet())
|
|
);
|
|
function isWeakSet(value) {
|
|
return isWeakSetToString(value);
|
|
}
|
|
exports.isWeakSet = isWeakSet;
|
|
|
|
function isArrayBufferToString(value) {
|
|
return ObjectToString(value) === '[object ArrayBuffer]';
|
|
}
|
|
isArrayBufferToString.working = (
|
|
typeof ArrayBuffer !== 'undefined' &&
|
|
isArrayBufferToString(new ArrayBuffer())
|
|
);
|
|
function isArrayBuffer(value) {
|
|
if (typeof ArrayBuffer === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isArrayBufferToString.working
|
|
? isArrayBufferToString(value)
|
|
: value instanceof ArrayBuffer;
|
|
}
|
|
exports.isArrayBuffer = isArrayBuffer;
|
|
|
|
function isDataViewToString(value) {
|
|
return ObjectToString(value) === '[object DataView]';
|
|
}
|
|
isDataViewToString.working = (
|
|
typeof ArrayBuffer !== 'undefined' &&
|
|
typeof DataView !== 'undefined' &&
|
|
isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1))
|
|
);
|
|
function isDataView(value) {
|
|
if (typeof DataView === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isDataViewToString.working
|
|
? isDataViewToString(value)
|
|
: value instanceof DataView;
|
|
}
|
|
exports.isDataView = isDataView;
|
|
|
|
// Store a copy of SharedArrayBuffer in case it's deleted elsewhere
|
|
var SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined;
|
|
function isSharedArrayBufferToString(value) {
|
|
return ObjectToString(value) === '[object SharedArrayBuffer]';
|
|
}
|
|
function isSharedArrayBuffer(value) {
|
|
if (typeof SharedArrayBufferCopy === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
if (typeof isSharedArrayBufferToString.working === 'undefined') {
|
|
isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());
|
|
}
|
|
|
|
return isSharedArrayBufferToString.working
|
|
? isSharedArrayBufferToString(value)
|
|
: value instanceof SharedArrayBufferCopy;
|
|
}
|
|
exports.isSharedArrayBuffer = isSharedArrayBuffer;
|
|
|
|
function isAsyncFunction(value) {
|
|
return ObjectToString(value) === '[object AsyncFunction]';
|
|
}
|
|
exports.isAsyncFunction = isAsyncFunction;
|
|
|
|
function isMapIterator(value) {
|
|
return ObjectToString(value) === '[object Map Iterator]';
|
|
}
|
|
exports.isMapIterator = isMapIterator;
|
|
|
|
function isSetIterator(value) {
|
|
return ObjectToString(value) === '[object Set Iterator]';
|
|
}
|
|
exports.isSetIterator = isSetIterator;
|
|
|
|
function isGeneratorObject(value) {
|
|
return ObjectToString(value) === '[object Generator]';
|
|
}
|
|
exports.isGeneratorObject = isGeneratorObject;
|
|
|
|
function isWebAssemblyCompiledModule(value) {
|
|
return ObjectToString(value) === '[object WebAssembly.Module]';
|
|
}
|
|
exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;
|
|
|
|
function isNumberObject(value) {
|
|
return checkBoxedPrimitive(value, numberValue);
|
|
}
|
|
exports.isNumberObject = isNumberObject;
|
|
|
|
function isStringObject(value) {
|
|
return checkBoxedPrimitive(value, stringValue);
|
|
}
|
|
exports.isStringObject = isStringObject;
|
|
|
|
function isBooleanObject(value) {
|
|
return checkBoxedPrimitive(value, booleanValue);
|
|
}
|
|
exports.isBooleanObject = isBooleanObject;
|
|
|
|
function isBigIntObject(value) {
|
|
return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);
|
|
}
|
|
exports.isBigIntObject = isBigIntObject;
|
|
|
|
function isSymbolObject(value) {
|
|
return SymbolSupported && checkBoxedPrimitive(value, symbolValue);
|
|
}
|
|
exports.isSymbolObject = isSymbolObject;
|
|
|
|
function isBoxedPrimitive(value) {
|
|
return (
|
|
isNumberObject(value) ||
|
|
isStringObject(value) ||
|
|
isBooleanObject(value) ||
|
|
isBigIntObject(value) ||
|
|
isSymbolObject(value)
|
|
);
|
|
}
|
|
exports.isBoxedPrimitive = isBoxedPrimitive;
|
|
|
|
function isAnyArrayBuffer(value) {
|
|
return typeof Uint8Array !== 'undefined' && (
|
|
isArrayBuffer(value) ||
|
|
isSharedArrayBuffer(value)
|
|
);
|
|
}
|
|
exports.isAnyArrayBuffer = isAnyArrayBuffer;
|
|
|
|
['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) {
|
|
Object.defineProperty(exports, method, {
|
|
enumerable: false,
|
|
value: function() {
|
|
throw new Error(method + ' is not supported in userland');
|
|
}
|
|
});
|
|
});
|
|
|
|
},{"is-arguments":47,"is-generator-function":49,"is-typed-array":51,"which-typed-array":79}],78:[function(require,module,exports){
|
|
(function (process){(function (){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||
|
|
function getOwnPropertyDescriptors(obj) {
|
|
var keys = Object.keys(obj);
|
|
var descriptors = {};
|
|
for (var i = 0; i < keys.length; i++) {
|
|
descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
|
|
}
|
|
return descriptors;
|
|
};
|
|
|
|
var formatRegExp = /%[sdj%]/g;
|
|
exports.format = function(f) {
|
|
if (!isString(f)) {
|
|
var objects = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
objects.push(inspect(arguments[i]));
|
|
}
|
|
return objects.join(' ');
|
|
}
|
|
|
|
var i = 1;
|
|
var args = arguments;
|
|
var len = args.length;
|
|
var str = String(f).replace(formatRegExp, function(x) {
|
|
if (x === '%%') return '%';
|
|
if (i >= len) return x;
|
|
switch (x) {
|
|
case '%s': return String(args[i++]);
|
|
case '%d': return Number(args[i++]);
|
|
case '%j':
|
|
try {
|
|
return JSON.stringify(args[i++]);
|
|
} catch (_) {
|
|
return '[Circular]';
|
|
}
|
|
default:
|
|
return x;
|
|
}
|
|
});
|
|
for (var x = args[i]; i < len; x = args[++i]) {
|
|
if (isNull(x) || !isObject(x)) {
|
|
str += ' ' + x;
|
|
} else {
|
|
str += ' ' + inspect(x);
|
|
}
|
|
}
|
|
return str;
|
|
};
|
|
|
|
|
|
// Mark that a method should not be used.
|
|
// Returns a modified function which warns once by default.
|
|
// If --no-deprecation is set, then it is a no-op.
|
|
exports.deprecate = function(fn, msg) {
|
|
if (typeof process !== 'undefined' && process.noDeprecation === true) {
|
|
return fn;
|
|
}
|
|
|
|
// Allow for deprecating things in the process of starting up.
|
|
if (typeof process === 'undefined') {
|
|
return function() {
|
|
return exports.deprecate(fn, msg).apply(this, arguments);
|
|
};
|
|
}
|
|
|
|
var warned = false;
|
|
function deprecated() {
|
|
if (!warned) {
|
|
if (process.throwDeprecation) {
|
|
throw new Error(msg);
|
|
} else if (process.traceDeprecation) {
|
|
console.trace(msg);
|
|
} else {
|
|
console.error(msg);
|
|
}
|
|
warned = true;
|
|
}
|
|
return fn.apply(this, arguments);
|
|
}
|
|
|
|
return deprecated;
|
|
};
|
|
|
|
|
|
var debugs = {};
|
|
var debugEnvRegex = /^$/;
|
|
|
|
if (process.env.NODE_DEBUG) {
|
|
var debugEnv = process.env.NODE_DEBUG;
|
|
debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, '\\$&')
|
|
.replace(/\*/g, '.*')
|
|
.replace(/,/g, '$|^')
|
|
.toUpperCase();
|
|
debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i');
|
|
}
|
|
exports.debuglog = function(set) {
|
|
set = set.toUpperCase();
|
|
if (!debugs[set]) {
|
|
if (debugEnvRegex.test(set)) {
|
|
var pid = process.pid;
|
|
debugs[set] = function() {
|
|
var msg = exports.format.apply(exports, arguments);
|
|
console.error('%s %d: %s', set, pid, msg);
|
|
};
|
|
} else {
|
|
debugs[set] = function() {};
|
|
}
|
|
}
|
|
return debugs[set];
|
|
};
|
|
|
|
|
|
/**
|
|
* Echos the value of a value. Trys to print the value out
|
|
* in the best way possible given the different types.
|
|
*
|
|
* @param {Object} obj The object to print out.
|
|
* @param {Object} opts Optional options object that alters the output.
|
|
*/
|
|
/* legacy: obj, showHidden, depth, colors*/
|
|
function inspect(obj, opts) {
|
|
// default options
|
|
var ctx = {
|
|
seen: [],
|
|
stylize: stylizeNoColor
|
|
};
|
|
// legacy...
|
|
if (arguments.length >= 3) ctx.depth = arguments[2];
|
|
if (arguments.length >= 4) ctx.colors = arguments[3];
|
|
if (isBoolean(opts)) {
|
|
// legacy...
|
|
ctx.showHidden = opts;
|
|
} else if (opts) {
|
|
// got an "options" object
|
|
exports._extend(ctx, opts);
|
|
}
|
|
// set default options
|
|
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
|
if (isUndefined(ctx.depth)) ctx.depth = 2;
|
|
if (isUndefined(ctx.colors)) ctx.colors = false;
|
|
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
|
if (ctx.colors) ctx.stylize = stylizeWithColor;
|
|
return formatValue(ctx, obj, ctx.depth);
|
|
}
|
|
exports.inspect = inspect;
|
|
|
|
|
|
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
|
inspect.colors = {
|
|
'bold' : [1, 22],
|
|
'italic' : [3, 23],
|
|
'underline' : [4, 24],
|
|
'inverse' : [7, 27],
|
|
'white' : [37, 39],
|
|
'grey' : [90, 39],
|
|
'black' : [30, 39],
|
|
'blue' : [34, 39],
|
|
'cyan' : [36, 39],
|
|
'green' : [32, 39],
|
|
'magenta' : [35, 39],
|
|
'red' : [31, 39],
|
|
'yellow' : [33, 39]
|
|
};
|
|
|
|
// Don't use 'blue' not visible on cmd.exe
|
|
inspect.styles = {
|
|
'special': 'cyan',
|
|
'number': 'yellow',
|
|
'boolean': 'yellow',
|
|
'undefined': 'grey',
|
|
'null': 'bold',
|
|
'string': 'green',
|
|
'date': 'magenta',
|
|
// "name": intentionally not styling
|
|
'regexp': 'red'
|
|
};
|
|
|
|
|
|
function stylizeWithColor(str, styleType) {
|
|
var style = inspect.styles[styleType];
|
|
|
|
if (style) {
|
|
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
|
|
'\u001b[' + inspect.colors[style][1] + 'm';
|
|
} else {
|
|
return str;
|
|
}
|
|
}
|
|
|
|
|
|
function stylizeNoColor(str, styleType) {
|
|
return str;
|
|
}
|
|
|
|
|
|
function arrayToHash(array) {
|
|
var hash = {};
|
|
|
|
array.forEach(function(val, idx) {
|
|
hash[val] = true;
|
|
});
|
|
|
|
return hash;
|
|
}
|
|
|
|
|
|
function formatValue(ctx, value, recurseTimes) {
|
|
// Provide a hook for user-specified inspect functions.
|
|
// Check that value is an object with an inspect function on it
|
|
if (ctx.customInspect &&
|
|
value &&
|
|
isFunction(value.inspect) &&
|
|
// Filter out the util module, it's inspect function is special
|
|
value.inspect !== exports.inspect &&
|
|
// Also filter out any prototype objects using the circular check.
|
|
!(value.constructor && value.constructor.prototype === value)) {
|
|
var ret = value.inspect(recurseTimes, ctx);
|
|
if (!isString(ret)) {
|
|
ret = formatValue(ctx, ret, recurseTimes);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// Primitive types cannot have properties
|
|
var primitive = formatPrimitive(ctx, value);
|
|
if (primitive) {
|
|
return primitive;
|
|
}
|
|
|
|
// Look up the keys of the object.
|
|
var keys = Object.keys(value);
|
|
var visibleKeys = arrayToHash(keys);
|
|
|
|
if (ctx.showHidden) {
|
|
keys = Object.getOwnPropertyNames(value);
|
|
}
|
|
|
|
// IE doesn't make error fields non-enumerable
|
|
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
|
|
if (isError(value)
|
|
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
|
|
return formatError(value);
|
|
}
|
|
|
|
// Some type of object without properties can be shortcutted.
|
|
if (keys.length === 0) {
|
|
if (isFunction(value)) {
|
|
var name = value.name ? ': ' + value.name : '';
|
|
return ctx.stylize('[Function' + name + ']', 'special');
|
|
}
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
}
|
|
if (isDate(value)) {
|
|
return ctx.stylize(Date.prototype.toString.call(value), 'date');
|
|
}
|
|
if (isError(value)) {
|
|
return formatError(value);
|
|
}
|
|
}
|
|
|
|
var base = '', array = false, braces = ['{', '}'];
|
|
|
|
// Make Array say that they are Array
|
|
if (isArray(value)) {
|
|
array = true;
|
|
braces = ['[', ']'];
|
|
}
|
|
|
|
// Make functions say that they are functions
|
|
if (isFunction(value)) {
|
|
var n = value.name ? ': ' + value.name : '';
|
|
base = ' [Function' + n + ']';
|
|
}
|
|
|
|
// Make RegExps say that they are RegExps
|
|
if (isRegExp(value)) {
|
|
base = ' ' + RegExp.prototype.toString.call(value);
|
|
}
|
|
|
|
// Make dates with properties first say the date
|
|
if (isDate(value)) {
|
|
base = ' ' + Date.prototype.toUTCString.call(value);
|
|
}
|
|
|
|
// Make error with message first say the error
|
|
if (isError(value)) {
|
|
base = ' ' + formatError(value);
|
|
}
|
|
|
|
if (keys.length === 0 && (!array || value.length == 0)) {
|
|
return braces[0] + base + braces[1];
|
|
}
|
|
|
|
if (recurseTimes < 0) {
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
} else {
|
|
return ctx.stylize('[Object]', 'special');
|
|
}
|
|
}
|
|
|
|
ctx.seen.push(value);
|
|
|
|
var output;
|
|
if (array) {
|
|
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
|
} else {
|
|
output = keys.map(function(key) {
|
|
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
|
});
|
|
}
|
|
|
|
ctx.seen.pop();
|
|
|
|
return reduceToSingleString(output, base, braces);
|
|
}
|
|
|
|
|
|
function formatPrimitive(ctx, value) {
|
|
if (isUndefined(value))
|
|
return ctx.stylize('undefined', 'undefined');
|
|
if (isString(value)) {
|
|
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
|
|
.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"') + '\'';
|
|
return ctx.stylize(simple, 'string');
|
|
}
|
|
if (isNumber(value))
|
|
return ctx.stylize('' + value, 'number');
|
|
if (isBoolean(value))
|
|
return ctx.stylize('' + value, 'boolean');
|
|
// For some reason typeof null is "object", so special case here.
|
|
if (isNull(value))
|
|
return ctx.stylize('null', 'null');
|
|
}
|
|
|
|
|
|
function formatError(value) {
|
|
return '[' + Error.prototype.toString.call(value) + ']';
|
|
}
|
|
|
|
|
|
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
|
var output = [];
|
|
for (var i = 0, l = value.length; i < l; ++i) {
|
|
if (hasOwnProperty(value, String(i))) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
String(i), true));
|
|
} else {
|
|
output.push('');
|
|
}
|
|
}
|
|
keys.forEach(function(key) {
|
|
if (!key.match(/^\d+$/)) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
key, true));
|
|
}
|
|
});
|
|
return output;
|
|
}
|
|
|
|
|
|
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
|
|
var name, str, desc;
|
|
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
|
|
if (desc.get) {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Getter/Setter]', 'special');
|
|
} else {
|
|
str = ctx.stylize('[Getter]', 'special');
|
|
}
|
|
} else {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Setter]', 'special');
|
|
}
|
|
}
|
|
if (!hasOwnProperty(visibleKeys, key)) {
|
|
name = '[' + key + ']';
|
|
}
|
|
if (!str) {
|
|
if (ctx.seen.indexOf(desc.value) < 0) {
|
|
if (isNull(recurseTimes)) {
|
|
str = formatValue(ctx, desc.value, null);
|
|
} else {
|
|
str = formatValue(ctx, desc.value, recurseTimes - 1);
|
|
}
|
|
if (str.indexOf('\n') > -1) {
|
|
if (array) {
|
|
str = str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n').slice(2);
|
|
} else {
|
|
str = '\n' + str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n');
|
|
}
|
|
}
|
|
} else {
|
|
str = ctx.stylize('[Circular]', 'special');
|
|
}
|
|
}
|
|
if (isUndefined(name)) {
|
|
if (array && key.match(/^\d+$/)) {
|
|
return str;
|
|
}
|
|
name = JSON.stringify('' + key);
|
|
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
|
name = name.slice(1, -1);
|
|
name = ctx.stylize(name, 'name');
|
|
} else {
|
|
name = name.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"')
|
|
.replace(/(^"|"$)/g, "'");
|
|
name = ctx.stylize(name, 'string');
|
|
}
|
|
}
|
|
|
|
return name + ': ' + str;
|
|
}
|
|
|
|
|
|
function reduceToSingleString(output, base, braces) {
|
|
var numLinesEst = 0;
|
|
var length = output.reduce(function(prev, cur) {
|
|
numLinesEst++;
|
|
if (cur.indexOf('\n') >= 0) numLinesEst++;
|
|
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
|
|
}, 0);
|
|
|
|
if (length > 60) {
|
|
return braces[0] +
|
|
(base === '' ? '' : base + '\n ') +
|
|
' ' +
|
|
output.join(',\n ') +
|
|
' ' +
|
|
braces[1];
|
|
}
|
|
|
|
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
|
}
|
|
|
|
|
|
// NOTE: These type checking functions intentionally don't use `instanceof`
|
|
// because it is fragile and can be easily faked with `Object.create()`.
|
|
exports.types = require('./support/types');
|
|
|
|
function isArray(ar) {
|
|
return Array.isArray(ar);
|
|
}
|
|
exports.isArray = isArray;
|
|
|
|
function isBoolean(arg) {
|
|
return typeof arg === 'boolean';
|
|
}
|
|
exports.isBoolean = isBoolean;
|
|
|
|
function isNull(arg) {
|
|
return arg === null;
|
|
}
|
|
exports.isNull = isNull;
|
|
|
|
function isNullOrUndefined(arg) {
|
|
return arg == null;
|
|
}
|
|
exports.isNullOrUndefined = isNullOrUndefined;
|
|
|
|
function isNumber(arg) {
|
|
return typeof arg === 'number';
|
|
}
|
|
exports.isNumber = isNumber;
|
|
|
|
function isString(arg) {
|
|
return typeof arg === 'string';
|
|
}
|
|
exports.isString = isString;
|
|
|
|
function isSymbol(arg) {
|
|
return typeof arg === 'symbol';
|
|
}
|
|
exports.isSymbol = isSymbol;
|
|
|
|
function isUndefined(arg) {
|
|
return arg === void 0;
|
|
}
|
|
exports.isUndefined = isUndefined;
|
|
|
|
function isRegExp(re) {
|
|
return isObject(re) && objectToString(re) === '[object RegExp]';
|
|
}
|
|
exports.isRegExp = isRegExp;
|
|
exports.types.isRegExp = isRegExp;
|
|
|
|
function isObject(arg) {
|
|
return typeof arg === 'object' && arg !== null;
|
|
}
|
|
exports.isObject = isObject;
|
|
|
|
function isDate(d) {
|
|
return isObject(d) && objectToString(d) === '[object Date]';
|
|
}
|
|
exports.isDate = isDate;
|
|
exports.types.isDate = isDate;
|
|
|
|
function isError(e) {
|
|
return isObject(e) &&
|
|
(objectToString(e) === '[object Error]' || e instanceof Error);
|
|
}
|
|
exports.isError = isError;
|
|
exports.types.isNativeError = isError;
|
|
|
|
function isFunction(arg) {
|
|
return typeof arg === 'function';
|
|
}
|
|
exports.isFunction = isFunction;
|
|
|
|
function isPrimitive(arg) {
|
|
return arg === null ||
|
|
typeof arg === 'boolean' ||
|
|
typeof arg === 'number' ||
|
|
typeof arg === 'string' ||
|
|
typeof arg === 'symbol' || // ES6 symbol
|
|
typeof arg === 'undefined';
|
|
}
|
|
exports.isPrimitive = isPrimitive;
|
|
|
|
exports.isBuffer = require('./support/isBuffer');
|
|
|
|
function objectToString(o) {
|
|
return Object.prototype.toString.call(o);
|
|
}
|
|
|
|
|
|
function pad(n) {
|
|
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
|
}
|
|
|
|
|
|
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
|
'Oct', 'Nov', 'Dec'];
|
|
|
|
// 26 Feb 16:19:34
|
|
function timestamp() {
|
|
var d = new Date();
|
|
var time = [pad(d.getHours()),
|
|
pad(d.getMinutes()),
|
|
pad(d.getSeconds())].join(':');
|
|
return [d.getDate(), months[d.getMonth()], time].join(' ');
|
|
}
|
|
|
|
|
|
// log is just a thin wrapper to console.log that prepends a timestamp
|
|
exports.log = function() {
|
|
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
|
|
};
|
|
|
|
|
|
/**
|
|
* Inherit the prototype methods from one constructor into another.
|
|
*
|
|
* The Function.prototype.inherits from lang.js rewritten as a standalone
|
|
* function (not on Function.prototype). NOTE: If this file is to be loaded
|
|
* during bootstrapping this function needs to be rewritten using some native
|
|
* functions as prototype setup using normal JavaScript does not work as
|
|
* expected during bootstrapping (see mirror.js in r114903).
|
|
*
|
|
* @param {function} ctor Constructor function which needs to inherit the
|
|
* prototype.
|
|
* @param {function} superCtor Constructor function to inherit prototype from.
|
|
*/
|
|
exports.inherits = require('inherits');
|
|
|
|
exports._extend = function(origin, add) {
|
|
// Don't do anything if add isn't an object
|
|
if (!add || !isObject(add)) return origin;
|
|
|
|
var keys = Object.keys(add);
|
|
var i = keys.length;
|
|
while (i--) {
|
|
origin[keys[i]] = add[keys[i]];
|
|
}
|
|
return origin;
|
|
};
|
|
|
|
function hasOwnProperty(obj, prop) {
|
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
|
}
|
|
|
|
var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;
|
|
|
|
exports.promisify = function promisify(original) {
|
|
if (typeof original !== 'function')
|
|
throw new TypeError('The "original" argument must be of type Function');
|
|
|
|
if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
|
|
var fn = original[kCustomPromisifiedSymbol];
|
|
if (typeof fn !== 'function') {
|
|
throw new TypeError('The "util.promisify.custom" argument must be of type Function');
|
|
}
|
|
Object.defineProperty(fn, kCustomPromisifiedSymbol, {
|
|
value: fn, enumerable: false, writable: false, configurable: true
|
|
});
|
|
return fn;
|
|
}
|
|
|
|
function fn() {
|
|
var promiseResolve, promiseReject;
|
|
var promise = new Promise(function (resolve, reject) {
|
|
promiseResolve = resolve;
|
|
promiseReject = reject;
|
|
});
|
|
|
|
var args = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
args.push(arguments[i]);
|
|
}
|
|
args.push(function (err, value) {
|
|
if (err) {
|
|
promiseReject(err);
|
|
} else {
|
|
promiseResolve(value);
|
|
}
|
|
});
|
|
|
|
try {
|
|
original.apply(this, args);
|
|
} catch (err) {
|
|
promiseReject(err);
|
|
}
|
|
|
|
return promise;
|
|
}
|
|
|
|
Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
|
|
|
|
if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
|
|
value: fn, enumerable: false, writable: false, configurable: true
|
|
});
|
|
return Object.defineProperties(
|
|
fn,
|
|
getOwnPropertyDescriptors(original)
|
|
);
|
|
}
|
|
|
|
exports.promisify.custom = kCustomPromisifiedSymbol
|
|
|
|
function callbackifyOnRejected(reason, cb) {
|
|
// `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
|
|
// Because `null` is a special error value in callbacks which means "no error
|
|
// occurred", we error-wrap so the callback consumer can distinguish between
|
|
// "the promise rejected with null" or "the promise fulfilled with undefined".
|
|
if (!reason) {
|
|
var newReason = new Error('Promise was rejected with a falsy value');
|
|
newReason.reason = reason;
|
|
reason = newReason;
|
|
}
|
|
return cb(reason);
|
|
}
|
|
|
|
function callbackify(original) {
|
|
if (typeof original !== 'function') {
|
|
throw new TypeError('The "original" argument must be of type Function');
|
|
}
|
|
|
|
// We DO NOT return the promise as it gives the user a false sense that
|
|
// the promise is actually somehow related to the callback's execution
|
|
// and that the callback throwing will reject the promise.
|
|
function callbackified() {
|
|
var args = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
args.push(arguments[i]);
|
|
}
|
|
|
|
var maybeCb = args.pop();
|
|
if (typeof maybeCb !== 'function') {
|
|
throw new TypeError('The last argument must be of type Function');
|
|
}
|
|
var self = this;
|
|
var cb = function() {
|
|
return maybeCb.apply(self, arguments);
|
|
};
|
|
// In true node style we process the callback on `nextTick` with all the
|
|
// implications (stack, `uncaughtException`, `async_hooks`)
|
|
original.apply(this, args)
|
|
.then(function(ret) { process.nextTick(cb.bind(null, null, ret)) },
|
|
function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) });
|
|
}
|
|
|
|
Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
|
|
Object.defineProperties(callbackified,
|
|
getOwnPropertyDescriptors(original));
|
|
return callbackified;
|
|
}
|
|
exports.callbackify = callbackify;
|
|
|
|
}).call(this)}).call(this,require('_process'))
|
|
},{"./support/isBuffer":76,"./support/types":77,"_process":62,"inherits":46}],79:[function(require,module,exports){
|
|
(function (global){(function (){
|
|
'use strict';
|
|
|
|
var forEach = require('for-each');
|
|
var availableTypedArrays = require('available-typed-arrays');
|
|
var callBind = require('call-bind');
|
|
var callBound = require('call-bound');
|
|
var gOPD = require('gopd');
|
|
var getProto = require('get-proto');
|
|
|
|
var $toString = callBound('Object.prototype.toString');
|
|
var hasToStringTag = require('has-tostringtag/shams')();
|
|
|
|
var g = typeof globalThis === 'undefined' ? global : globalThis;
|
|
var typedArrays = availableTypedArrays();
|
|
|
|
var $slice = callBound('String.prototype.slice');
|
|
|
|
/** @type {<T = unknown>(array: readonly T[], value: unknown) => number} */
|
|
var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {
|
|
for (var i = 0; i < array.length; i += 1) {
|
|
if (array[i] === value) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
|
|
/** @typedef {import('./types').Getter} Getter */
|
|
/** @type {import('./types').Cache} */
|
|
var cache = { __proto__: null };
|
|
if (hasToStringTag && gOPD && getProto) {
|
|
forEach(typedArrays, function (typedArray) {
|
|
var arr = new g[typedArray]();
|
|
if (Symbol.toStringTag in arr && getProto) {
|
|
var proto = getProto(arr);
|
|
// @ts-expect-error TS won't narrow inside a closure
|
|
var descriptor = gOPD(proto, Symbol.toStringTag);
|
|
if (!descriptor && proto) {
|
|
var superProto = getProto(proto);
|
|
// @ts-expect-error TS won't narrow inside a closure
|
|
descriptor = gOPD(superProto, Symbol.toStringTag);
|
|
}
|
|
// @ts-expect-error TODO: fix
|
|
cache['$' + typedArray] = callBind(descriptor.get);
|
|
}
|
|
});
|
|
} else {
|
|
forEach(typedArrays, function (typedArray) {
|
|
var arr = new g[typedArray]();
|
|
var fn = arr.slice || arr.set;
|
|
if (fn) {
|
|
cache[
|
|
/** @type {`$${import('.').TypedArrayName}`} */ ('$' + typedArray)
|
|
] = /** @type {import('./types').BoundSlice | import('./types').BoundSet} */ (
|
|
// @ts-expect-error TODO FIXME
|
|
callBind(fn)
|
|
);
|
|
}
|
|
});
|
|
}
|
|
|
|
/** @type {(value: object) => false | import('.').TypedArrayName} */
|
|
var tryTypedArrays = function tryAllTypedArrays(value) {
|
|
/** @type {ReturnType<typeof tryAllTypedArrays>} */ var found = false;
|
|
forEach(
|
|
/** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */ (cache),
|
|
/** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
|
|
function (getter, typedArray) {
|
|
if (!found) {
|
|
try {
|
|
// @ts-expect-error a throw is fine here
|
|
if ('$' + getter(value) === typedArray) {
|
|
found = /** @type {import('.').TypedArrayName} */ ($slice(typedArray, 1));
|
|
}
|
|
} catch (e) { /**/ }
|
|
}
|
|
}
|
|
);
|
|
return found;
|
|
};
|
|
|
|
/** @type {(value: object) => false | import('.').TypedArrayName} */
|
|
var trySlices = function tryAllSlices(value) {
|
|
/** @type {ReturnType<typeof tryAllSlices>} */ var found = false;
|
|
forEach(
|
|
/** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */(cache),
|
|
/** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */ function (getter, name) {
|
|
if (!found) {
|
|
try {
|
|
// @ts-expect-error a throw is fine here
|
|
getter(value);
|
|
found = /** @type {import('.').TypedArrayName} */ ($slice(name, 1));
|
|
} catch (e) { /**/ }
|
|
}
|
|
}
|
|
);
|
|
return found;
|
|
};
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function whichTypedArray(value) {
|
|
if (!value || typeof value !== 'object') { return false; }
|
|
if (!hasToStringTag) {
|
|
/** @type {string} */
|
|
var tag = $slice($toString(value), 8, -1);
|
|
if ($indexOf(typedArrays, tag) > -1) {
|
|
return tag;
|
|
}
|
|
if (tag !== 'Object') {
|
|
return false;
|
|
}
|
|
// node < 0.6 hits here on real Typed Arrays
|
|
return trySlices(value);
|
|
}
|
|
if (!gOPD) { return null; } // unknown engine
|
|
return tryTypedArrays(value);
|
|
};
|
|
|
|
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"available-typed-arrays":11,"call-bind":19,"call-bound":20,"for-each":32,"get-proto":38,"gopd":40,"has-tostringtag/shams":44}],80:[function(require,module,exports){
|
|
module.exports={"exceptions":{"ck":{"www":{"$":0}},"jp":{"kawasaki":{"city":{"$":0}},"kitakyushu":{"city":{"$":0}},"kobe":{"city":{"$":0}},"nagoya":{"city":{"$":0}},"sapporo":{"city":{"$":0}},"sendai":{"city":{"$":0}},"yokohama":{"city":{"$":0}}}},"rules":{"ac":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"drr":{"$":0},"feedback":{"$":0},"forms":{"$":0}},"ad":{"$":0},"ae":{"$":0,"ac":{"$":0},"co":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"sch":{"$":0}},"aero":{"$":0,"airline":{"$":0},"airport":{"$":0},"accident-investigation":{"$":0},"accident-prevention":{"$":0},"aerobatic":{"$":0},"aeroclub":{"$":0},"aerodrome":{"$":0},"agents":{"$":0},"air-surveillance":{"$":0},"air-traffic-control":{"$":0},"aircraft":{"$":0},"airtraffic":{"$":0},"ambulance":{"$":0},"association":{"$":0},"author":{"$":0},"ballooning":{"$":0},"broker":{"$":0},"caa":{"$":0},"cargo":{"$":0},"catering":{"$":0},"certification":{"$":0},"championship":{"$":0},"charter":{"$":0},"civilaviation":{"$":0},"club":{"$":0},"conference":{"$":0},"consultant":{"$":0},"consulting":{"$":0},"control":{"$":0},"council":{"$":0},"crew":{"$":0},"design":{"$":0},"dgca":{"$":0},"educator":{"$":0},"emergency":{"$":0},"engine":{"$":0},"engineer":{"$":0},"entertainment":{"$":0},"equipment":{"$":0},"exchange":{"$":0},"express":{"$":0},"federation":{"$":0},"flight":{"$":0},"freight":{"$":0},"fuel":{"$":0},"gliding":{"$":0},"government":{"$":0},"groundhandling":{"$":0},"group":{"$":0},"hanggliding":{"$":0},"homebuilt":{"$":0},"insurance":{"$":0},"journal":{"$":0},"journalist":{"$":0},"leasing":{"$":0},"logistics":{"$":0},"magazine":{"$":0},"maintenance":{"$":0},"marketplace":{"$":0},"media":{"$":0},"microlight":{"$":0},"modelling":{"$":0},"navigation":{"$":0},"parachuting":{"$":0},"paragliding":{"$":0},"passenger-association":{"$":0},"pilot":{"$":0},"press":{"$":0},"production":{"$":0},"recreation":{"$":0},"repbody":{"$":0},"res":{"$":0},"research":{"$":0},"rotorcraft":{"$":0},"safety":{"$":0},"scientist":{"$":0},"services":{"$":0},"show":{"$":0},"skydiving":{"$":0},"software":{"$":0},"student":{"$":0},"taxi":{"$":0},"trader":{"$":0},"trading":{"$":0},"trainer":{"$":0},"union":{"$":0},"workinggroup":{"$":0},"works":{"$":0}},"af":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"ag":{"$":0,"co":{"$":0},"com":{"$":0},"net":{"$":0},"nom":{"$":0},"org":{"$":0},"obj":{"$":0}},"ai":{"$":0,"com":{"$":0},"net":{"$":0},"off":{"$":0},"org":{"$":0},"uwu":{"$":0},"caffeine":{"$":0},"id":{"$":0},"framer":{"$":0}},"al":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"am":{"$":0,"co":{"$":0},"com":{"$":0},"commune":{"$":0},"net":{"$":0},"org":{"$":0},"radio":{"$":0}},"ao":{"$":0,"co":{"$":0},"ed":{"$":0},"edu":{"$":0},"gov":{"$":0},"gv":{"$":0},"it":{"$":0},"og":{"$":0},"org":{"$":0},"pb":{"$":0}},"aq":{"$":0},"ar":{"$":0,"bet":{"$":0},"com":{"$":0},"coop":{"$":0},"edu":{"$":0},"gob":{"$":0},"gov":{"$":0},"int":{"$":0},"mil":{"$":0},"musica":{"$":0},"mutual":{"$":0},"net":{"$":0},"org":{"$":0},"seg":{"$":0},"senasa":{"$":0},"tur":{"$":0}},"arpa":{"$":0,"e164":{"$":0},"home":{"$":0},"in-addr":{"$":0},"ip6":{"$":0},"iris":{"$":0},"uri":{"$":0},"urn":{"$":0}},"as":{"$":0,"gov":{"$":0}},"asia":{"$":0,"cloudns":{"$":0},"daemon":{"$":0},"dix":{"$":0}},"at":{"4":{"$":0},"$":0,"ac":{"$":0,"sth":{"$":0}},"co":{"$":0},"gv":{"$":0},"or":{"$":0},"funkfeuer":{"wien":{"$":0}},"futurecms":{"*":{"$":0},"ex":{"*":{"$":0}},"in":{"*":{"$":0}}},"futurehosting":{"$":0},"futuremailing":{"$":0},"ortsinfo":{"ex":{"*":{"$":0}},"kunden":{"*":{"$":0}}},"biz":{"$":0},"info":{"$":0},"123webseite":{"$":0},"priv":{"$":0},"my":{"$":0},"myspreadshop":{"$":0},"12hp":{"$":0},"2ix":{"$":0},"4lima":{"$":0},"lima-city":{"$":0}},"au":{"$":0,"asn":{"$":0},"com":{"$":0,"cloudlets":{"mel":{"$":0}},"myspreadshop":{"$":0}},"edu":{"$":0,"act":{"$":0},"catholic":{"$":0},"nsw":{"$":0,"schools":{"$":0}},"nt":{"$":0},"qld":{"$":0},"sa":{"$":0},"tas":{"$":0},"vic":{"$":0},"wa":{"$":0}},"gov":{"$":0,"qld":{"$":0},"sa":{"$":0},"tas":{"$":0},"vic":{"$":0},"wa":{"$":0}},"id":{"$":0},"net":{"$":0},"org":{"$":0},"conf":{"$":0},"oz":{"$":0},"act":{"$":0},"nsw":{"$":0},"nt":{"$":0},"qld":{"$":0},"sa":{"$":0},"tas":{"$":0},"vic":{"$":0},"wa":{"$":0}},"aw":{"$":0,"com":{"$":0}},"ax":{"$":0},"az":{"$":0,"biz":{"$":0},"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"int":{"$":0},"mil":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"pp":{"$":0},"pro":{"$":0}},"ba":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"rs":{"$":0}},"bb":{"$":0,"biz":{"$":0},"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"net":{"$":0},"org":{"$":0},"store":{"$":0},"tv":{"$":0}},"bd":{"*":{"$":0}},"be":{"$":0,"ac":{"$":0},"cloudns":{"$":0},"webhosting":{"$":0},"interhostsolutions":{"cloud":{"$":0}},"kuleuven":{"ezproxy":{"$":0}},"123website":{"$":0},"myspreadshop":{"$":0},"transurl":{"*":{"$":0}}},"bf":{"$":0,"gov":{"$":0}},"bg":{"0":{"$":0},"1":{"$":0},"2":{"$":0},"3":{"$":0},"4":{"$":0},"5":{"$":0},"6":{"$":0},"7":{"$":0},"8":{"$":0},"9":{"$":0},"$":0,"a":{"$":0},"b":{"$":0},"c":{"$":0},"d":{"$":0},"e":{"$":0},"f":{"$":0},"g":{"$":0},"h":{"$":0},"i":{"$":0},"j":{"$":0},"k":{"$":0},"l":{"$":0},"m":{"$":0},"n":{"$":0},"o":{"$":0},"p":{"$":0},"q":{"$":0},"r":{"$":0},"s":{"$":0},"t":{"$":0},"u":{"$":0},"v":{"$":0},"w":{"$":0},"x":{"$":0},"y":{"$":0},"z":{"$":0},"barsy":{"$":0}},"bh":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"bi":{"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"or":{"$":0},"org":{"$":0}},"biz":{"$":0,"activetrail":{"$":0},"cloud-ip":{"$":0},"cloudns":{"$":0},"jozi":{"$":0},"dyndns":{"$":0},"for-better":{"$":0},"for-more":{"$":0},"for-some":{"$":0},"for-the":{"$":0},"selfip":{"$":0},"webhop":{"$":0},"orx":{"$":0},"mmafan":{"$":0},"myftp":{"$":0},"no-ip":{"$":0},"dscloud":{"$":0}},"bj":{"$":0,"africa":{"$":0},"agro":{"$":0},"architectes":{"$":0},"assur":{"$":0},"avocats":{"$":0},"co":{"$":0},"com":{"$":0},"eco":{"$":0},"econo":{"$":0},"edu":{"$":0},"info":{"$":0},"loisirs":{"$":0},"money":{"$":0},"net":{"$":0},"org":{"$":0},"ote":{"$":0},"restaurant":{"$":0},"resto":{"$":0},"tourism":{"$":0},"univ":{"$":0}},"bm":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"bn":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"co":{"$":0}},"bo":{"$":0,"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"int":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"tv":{"$":0},"web":{"$":0},"academia":{"$":0},"agro":{"$":0},"arte":{"$":0},"blog":{"$":0},"bolivia":{"$":0},"ciencia":{"$":0},"cooperativa":{"$":0},"democracia":{"$":0},"deporte":{"$":0},"ecologia":{"$":0},"economia":{"$":0},"empresa":{"$":0},"indigena":{"$":0},"industria":{"$":0},"info":{"$":0},"medicina":{"$":0},"movimiento":{"$":0},"musica":{"$":0},"natural":{"$":0},"nombre":{"$":0},"noticias":{"$":0},"patria":{"$":0},"plurinacional":{"$":0},"politica":{"$":0},"profesional":{"$":0},"pueblo":{"$":0},"revista":{"$":0},"salud":{"$":0},"tecnologia":{"$":0},"tksat":{"$":0},"transporte":{"$":0},"wiki":{"$":0}},"br":{"$":0,"9guacu":{"$":0},"abc":{"$":0},"adm":{"$":0},"adv":{"$":0},"agr":{"$":0},"aju":{"$":0},"am":{"$":0},"anani":{"$":0},"aparecida":{"$":0},"app":{"$":0},"arq":{"$":0},"art":{"$":0},"ato":{"$":0},"b":{"$":0},"barueri":{"$":0},"belem":{"$":0},"bet":{"$":0},"bhz":{"$":0},"bib":{"$":0},"bio":{"$":0},"blog":{"$":0},"bmd":{"$":0},"boavista":{"$":0},"bsb":{"$":0},"campinagrande":{"$":0},"campinas":{"$":0},"caxias":{"$":0},"cim":{"$":0},"cng":{"$":0},"cnt":{"$":0},"com":{"$":0,"simplesite":{"$":0}},"contagem":{"$":0},"coop":{"$":0},"coz":{"$":0},"cri":{"$":0},"cuiaba":{"$":0},"curitiba":{"$":0},"def":{"$":0},"des":{"$":0},"det":{"$":0},"dev":{"$":0},"ecn":{"$":0},"eco":{"$":0},"edu":{"$":0},"emp":{"$":0},"enf":{"$":0},"eng":{"$":0},"esp":{"$":0},"etc":{"$":0},"eti":{"$":0},"far":{"$":0},"feira":{"$":0},"flog":{"$":0},"floripa":{"$":0},"fm":{"$":0},"fnd":{"$":0},"fortal":{"$":0},"fot":{"$":0},"foz":{"$":0},"fst":{"$":0},"g12":{"$":0},"geo":{"$":0},"ggf":{"$":0},"goiania":{"$":0},"gov":{"$":0,"ac":{"$":0},"al":{"$":0},"am":{"$":0},"ap":{"$":0},"ba":{"$":0},"ce":{"$":0},"df":{"$":0},"es":{"$":0},"go":{"$":0},"ma":{"$":0},"mg":{"$":0},"ms":{"$":0},"mt":{"$":0},"pa":{"$":0},"pb":{"$":0},"pe":{"$":0},"pi":{"$":0},"pr":{"$":0},"rj":{"$":0},"rn":{"$":0},"ro":{"$":0},"rr":{"$":0},"rs":{"$":0},"sc":{"$":0},"se":{"$":0},"sp":{"$":0},"to":{"$":0}},"gru":{"$":0},"imb":{"$":0},"ind":{"$":0},"inf":{"$":0},"jab":{"$":0},"jampa":{"$":0},"jdf":{"$":0},"joinville":{"$":0},"jor":{"$":0},"jus":{"$":0},"leg":{"$":0,"ac":{"$":0},"al":{"$":0},"am":{"$":0},"ap":{"$":0},"ba":{"$":0},"ce":{"$":0},"df":{"$":0},"es":{"$":0},"go":{"$":0},"ma":{"$":0},"mg":{"$":0},"ms":{"$":0},"mt":{"$":0},"pa":{"$":0},"pb":{"$":0},"pe":{"$":0},"pi":{"$":0},"pr":{"$":0},"rj":{"$":0},"rn":{"$":0},"ro":{"$":0},"rr":{"$":0},"rs":{"$":0},"sc":{"$":0},"se":{"$":0},"sp":{"$":0},"to":{"$":0}},"leilao":{"$":0},"lel":{"$":0},"log":{"$":0},"londrina":{"$":0},"macapa":{"$":0},"maceio":{"$":0},"manaus":{"$":0},"maringa":{"$":0},"mat":{"$":0},"med":{"$":0},"mil":{"$":0},"morena":{"$":0},"mp":{"$":0},"mus":{"$":0},"natal":{"$":0},"net":{"$":0},"niteroi":{"$":0},"nom":{"*":{"$":0}},"not":{"$":0},"ntr":{"$":0},"odo":{"$":0},"ong":{"$":0},"org":{"$":0},"osasco":{"$":0},"palmas":{"$":0},"poa":{"$":0},"ppg":{"$":0},"pro":{"$":0},"psc":{"$":0},"psi":{"$":0},"pvh":{"$":0},"qsl":{"$":0},"radio":{"$":0},"rec":{"$":0},"recife":{"$":0},"rep":{"$":0},"ribeirao":{"$":0},"rio":{"$":0},"riobranco":{"$":0},"riopreto":{"$":0},"salvador":{"$":0},"sampa":{"$":0},"santamaria":{"$":0},"santoandre":{"$":0},"saobernardo":{"$":0},"saogonca":{"$":0},"seg":{"$":0},"sjc":{"$":0},"slg":{"$":0},"slz":{"$":0},"sorocaba":{"$":0},"srv":{"$":0},"taxi":{"$":0},"tc":{"$":0},"tec":{"$":0},"teo":{"$":0},"the":{"$":0},"tmp":{"$":0},"trd":{"$":0},"tur":{"$":0},"tv":{"$":0},"udi":{"$":0},"vet":{"$":0},"vix":{"$":0},"vlog":{"$":0},"wiki":{"$":0},"zlg":{"$":0},"tche":{"$":0}},"bs":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"we":{"$":0}},"bt":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"bv":{"$":0},"bw":{"$":0,"ac":{"$":0},"co":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"by":{"$":0,"gov":{"$":0},"mil":{"$":0},"com":{"$":0},"of":{"$":0},"mediatech":{"$":0}},"bz":{"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"za":{"$":0},"mydns":{"$":0},"gsj":{"$":0}},"ca":{"$":0,"ab":{"$":0},"bc":{"$":0},"mb":{"$":0},"nb":{"$":0},"nf":{"$":0},"nl":{"$":0},"ns":{"$":0},"nt":{"$":0},"nu":{"$":0},"on":{"$":0},"pe":{"$":0},"qc":{"$":0},"sk":{"$":0},"yk":{"$":0},"gc":{"$":0},"barsy":{"$":0},"awdev":{"*":{"$":0}},"co":{"$":0},"no-ip":{"$":0},"onid":{"$":0},"myspreadshop":{"$":0},"box":{"$":0}},"cat":{"$":0},"cc":{"$":0,"cleverapps":{"$":0},"cloudns":{"$":0},"ftpaccess":{"$":0},"game-server":{"$":0},"myphotos":{"$":0},"scrapping":{"$":0},"twmail":{"$":0},"csx":{"$":0},"fantasyleague":{"$":0},"spawn":{"instances":{"$":0}}},"cd":{"$":0,"gov":{"$":0}},"cf":{"$":0},"cg":{"$":0},"ch":{"$":0,"square7":{"$":0},"cloudns":{"$":0},"cloudscale":{"cust":{"$":0},"lpg":{"objects":{"$":0}},"rma":{"objects":{"$":0}}},"objectstorage":{"lpg":{"$":0},"rma":{"$":0}},"flow":{"ae":{"alp1":{"$":0}},"appengine":{"$":0}},"linkyard-cloud":{"$":0},"gotdns":{"$":0},"dnsking":{"$":0},"123website":{"$":0},"myspreadshop":{"$":0},"firenet":{"*":{"$":0},"svc":{"*":{"$":0}}},"12hp":{"$":0},"2ix":{"$":0},"4lima":{"$":0},"lima-city":{"$":0}},"ci":{"$":0,"ac":{"$":0},"xn--aroport-bya":{"$":0},"asso":{"$":0},"co":{"$":0},"com":{"$":0},"ed":{"$":0},"edu":{"$":0},"go":{"$":0},"gouv":{"$":0},"int":{"$":0},"net":{"$":0},"or":{"$":0},"org":{"$":0}},"ck":{"*":{"$":0}},"cl":{"$":0,"co":{"$":0},"gob":{"$":0},"gov":{"$":0},"mil":{"$":0},"cloudns":{"$":0}},"cm":{"$":0,"co":{"$":0},"com":{"$":0},"gov":{"$":0},"net":{"$":0}},"cn":{"$":0,"ac":{"$":0},"com":{"$":0,"amazonaws":{"cn-north-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-deprecated":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"cn-northwest-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"compute":{"*":{"$":0}},"airflow":{"cn-north-1":{"*":{"$":0}},"cn-northwest-1":{"*":{"$":0}}},"eb":{"cn-north-1":{"$":0},"cn-northwest-1":{"$":0}},"elb":{"*":{"$":0}}},"sagemaker":{"cn-north-1":{"notebook":{"$":0},"studio":{"$":0}},"cn-northwest-1":{"notebook":{"$":0},"studio":{"$":0}}}},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"xn--55qx5d":{"$":0},"xn--od0alg":{"$":0},"xn--io0a7i":{"$":0},"ah":{"$":0},"bj":{"$":0},"cq":{"$":0},"fj":{"$":0},"gd":{"$":0},"gs":{"$":0},"gx":{"$":0},"gz":{"$":0},"ha":{"$":0},"hb":{"$":0},"he":{"$":0},"hi":{"$":0},"hk":{"$":0},"hl":{"$":0},"hn":{"$":0},"jl":{"$":0},"js":{"$":0},"jx":{"$":0},"ln":{"$":0},"mo":{"$":0},"nm":{"$":0},"nx":{"$":0},"qh":{"$":0},"sc":{"$":0},"sd":{"$":0},"sh":{"$":0,"as":{"$":0}},"sn":{"$":0},"sx":{"$":0},"tj":{"$":0},"tw":{"$":0},"xj":{"$":0},"xz":{"$":0},"yn":{"$":0},"zj":{"$":0},"canva-apps":{"$":0},"canvasite":{"my":{"$":0}},"myqnapcloud":{"$":0},"quickconnect":{"direct":{"$":0}}},"co":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"nom":{"$":0},"org":{"$":0},"carrd":{"$":0},"crd":{"$":0},"otap":{"*":{"$":0}},"leadpages":{"$":0},"lpages":{"$":0},"mypi":{"$":0},"xmit":{"*":{"$":0}},"firewalledreplit":{"$":0,"id":{"$":0}},"repl":{"$":0,"id":{"$":0}},"supabase":{"$":0}},"com":{"$":0,"a2hosted":{"$":0},"cpserver":{"$":0},"adobeaemcloud":{"$":0,"dev":{"*":{"$":0}}},"africa":{"$":0},"airkitapps":{"$":0},"airkitapps-au":{"$":0},"aivencloud":{"$":0},"alibabacloudcs":{"$":0},"kasserver":{"$":0},"amazonaws":{"af-south-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"ap-east-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"ap-northeast-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"ap-northeast-2":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"ap-northeast-3":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"ap-south-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"ap-south-2":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"ap-southeast-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"ap-southeast-2":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"ap-southeast-3":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"ap-southeast-4":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"ap-southeast-5":{"execute-api":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-deprecated":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"ca-central-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"ca-west-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"eu-central-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"eu-central-2":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"eu-north-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"eu-south-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"eu-south-2":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"eu-west-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-deprecated":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"eu-west-2":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"eu-west-3":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"il-central-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0}}},"me-central-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"me-south-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"sa-east-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"us-east-1":{"execute-api":{"$":0},"$":0,"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-deprecated":{"$":0},"s3-fips":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"us-east-2":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-deprecated":{"$":0},"s3-fips":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"us-gov-east-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"us-gov-west-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0}},"us-west-1":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"us-west-2":{"execute-api":{"$":0},"emrappui-prod":{"$":0},"emrnotebooks-prod":{"$":0},"emrstudio-prod":{"$":0},"dualstack":{"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-fips":{"$":0},"s3-website":{"$":0}},"s3":{"$":0},"s3-accesspoint":{"$":0},"s3-accesspoint-fips":{"$":0},"s3-deprecated":{"$":0},"s3-fips":{"$":0},"s3-object-lambda":{"$":0},"s3-website":{"$":0},"analytics-gateway":{"$":0},"aws-cloud9":{"webview-assets":{"$":0}},"cloud9":{"vfs":{"$":0},"webview-assets":{"$":0}}},"compute":{"*":{"$":0}},"compute-1":{"*":{"$":0}},"airflow":{"af-south-1":{"*":{"$":0}},"ap-east-1":{"*":{"$":0}},"ap-northeast-1":{"*":{"$":0}},"ap-northeast-2":{"*":{"$":0}},"ap-northeast-3":{"*":{"$":0}},"ap-south-1":{"*":{"$":0}},"ap-south-2":{"*":{"$":0}},"ap-southeast-1":{"*":{"$":0}},"ap-southeast-2":{"*":{"$":0}},"ap-southeast-3":{"*":{"$":0}},"ap-southeast-4":{"*":{"$":0}},"ca-central-1":{"*":{"$":0}},"ca-west-1":{"*":{"$":0}},"eu-central-1":{"*":{"$":0}},"eu-central-2":{"*":{"$":0}},"eu-north-1":{"*":{"$":0}},"eu-south-1":{"*":{"$":0}},"eu-south-2":{"*":{"$":0}},"eu-west-1":{"*":{"$":0}},"eu-west-2":{"*":{"$":0}},"eu-west-3":{"*":{"$":0}},"il-central-1":{"*":{"$":0}},"me-central-1":{"*":{"$":0}},"me-south-1":{"*":{"$":0}},"sa-east-1":{"*":{"$":0}},"us-east-1":{"*":{"$":0}},"us-east-2":{"*":{"$":0}},"us-west-1":{"*":{"$":0}},"us-west-2":{"*":{"$":0}}},"s3":{"$":0},"s3-1":{"$":0},"s3-ap-east-1":{"$":0},"s3-ap-northeast-1":{"$":0},"s3-ap-northeast-2":{"$":0},"s3-ap-northeast-3":{"$":0},"s3-ap-south-1":{"$":0},"s3-ap-southeast-1":{"$":0},"s3-ap-southeast-2":{"$":0},"s3-ca-central-1":{"$":0},"s3-eu-central-1":{"$":0},"s3-eu-north-1":{"$":0},"s3-eu-west-1":{"$":0},"s3-eu-west-2":{"$":0},"s3-eu-west-3":{"$":0},"s3-external-1":{"$":0},"s3-fips-us-gov-east-1":{"$":0},"s3-fips-us-gov-west-1":{"$":0},"s3-global":{"accesspoint":{"mrap":{"$":0}}},"s3-me-south-1":{"$":0},"s3-sa-east-1":{"$":0},"s3-us-east-2":{"$":0},"s3-us-gov-east-1":{"$":0},"s3-us-gov-west-1":{"$":0},"s3-us-west-1":{"$":0},"s3-us-west-2":{"$":0},"s3-website-ap-northeast-1":{"$":0},"s3-website-ap-southeast-1":{"$":0},"s3-website-ap-southeast-2":{"$":0},"s3-website-eu-west-1":{"$":0},"s3-website-sa-east-1":{"$":0},"s3-website-us-east-1":{"$":0},"s3-website-us-gov-west-1":{"$":0},"s3-website-us-west-1":{"$":0},"s3-website-us-west-2":{"$":0},"elb":{"*":{"$":0}}},"amazoncognito":{"af-south-1":{"auth":{"$":0}},"ap-east-1":{"auth":{"$":0}},"ap-northeast-1":{"auth":{"$":0}},"ap-northeast-2":{"auth":{"$":0}},"ap-northeast-3":{"auth":{"$":0}},"ap-south-1":{"auth":{"$":0}},"ap-south-2":{"auth":{"$":0}},"ap-southeast-1":{"auth":{"$":0}},"ap-southeast-2":{"auth":{"$":0}},"ap-southeast-3":{"auth":{"$":0}},"ap-southeast-4":{"auth":{"$":0}},"ap-southeast-5":{"auth":{"$":0}},"ca-central-1":{"auth":{"$":0}},"ca-west-1":{"auth":{"$":0}},"eu-central-1":{"auth":{"$":0}},"eu-central-2":{"auth":{"$":0}},"eu-north-1":{"auth":{"$":0}},"eu-south-1":{"auth":{"$":0}},"eu-south-2":{"auth":{"$":0}},"eu-west-1":{"auth":{"$":0}},"eu-west-2":{"auth":{"$":0}},"eu-west-3":{"auth":{"$":0}},"il-central-1":{"auth":{"$":0}},"me-central-1":{"auth":{"$":0}},"me-south-1":{"auth":{"$":0}},"sa-east-1":{"auth":{"$":0}},"us-east-1":{"auth":{"$":0},"auth-fips":{"$":0}},"us-east-2":{"auth":{"$":0},"auth-fips":{"$":0}},"us-gov-east-1":{"auth-fips":{"$":0}},"us-gov-west-1":{"auth-fips":{"$":0}},"us-west-1":{"auth":{"$":0},"auth-fips":{"$":0}},"us-west-2":{"auth":{"$":0},"auth-fips":{"$":0}}},"amplifyapp":{"$":0},"awsapprunner":{"*":{"$":0}},"awsapps":{"$":0},"elasticbeanstalk":{"$":0,"af-south-1":{"$":0},"ap-east-1":{"$":0},"ap-northeast-1":{"$":0},"ap-northeast-2":{"$":0},"ap-northeast-3":{"$":0},"ap-south-1":{"$":0},"ap-southeast-1":{"$":0},"ap-southeast-2":{"$":0},"ap-southeast-3":{"$":0},"ca-central-1":{"$":0},"eu-central-1":{"$":0},"eu-north-1":{"$":0},"eu-south-1":{"$":0},"eu-west-1":{"$":0},"eu-west-2":{"$":0},"eu-west-3":{"$":0},"il-central-1":{"$":0},"me-south-1":{"$":0},"sa-east-1":{"$":0},"us-east-1":{"$":0},"us-east-2":{"$":0},"us-gov-east-1":{"$":0},"us-gov-west-1":{"$":0},"us-west-1":{"$":0},"us-west-2":{"$":0}},"awsglobalaccelerator":{"$":0},"siiites":{"$":0},"appspacehosted":{"$":0},"appspaceusercontent":{"$":0},"on-aptible":{"$":0},"myasustor":{"$":0},"balena-devices":{"$":0},"boutir":{"$":0},"bplaced":{"$":0},"cafjs":{"$":0},"canva-apps":{"$":0},"cdn77-storage":{"$":0},"br":{"$":0},"cn":{"$":0},"de":{"$":0},"eu":{"$":0},"jpn":{"$":0},"mex":{"$":0},"ru":{"$":0},"sa":{"$":0},"uk":{"$":0},"us":{"$":0},"za":{"$":0},"clever-cloud":{"services":{"*":{"$":0}}},"dnsabr":{"$":0},"ip-ddns":{"$":0},"jdevcloud":{"$":0},"wpdevcloud":{"$":0},"cf-ipfs":{"$":0},"cloudflare-ipfs":{"$":0},"trycloudflare":{"$":0},"co":{"$":0},"devinapps":{"*":{"$":0}},"builtwithdark":{"$":0},"datadetect":{"demo":{"$":0},"instance":{"$":0}},"dattolocal":{"$":0},"dattorelay":{"$":0},"dattoweb":{"$":0},"mydatto":{"$":0},"digitaloceanspaces":{"*":{"$":0}},"discordsays":{"$":0},"discordsez":{"$":0},"drayddns":{"$":0},"dreamhosters":{"$":0},"durumis":{"$":0},"mydrobo":{"$":0},"blogdns":{"$":0},"cechire":{"$":0},"dnsalias":{"$":0},"dnsdojo":{"$":0},"doesntexist":{"$":0},"dontexist":{"$":0},"doomdns":{"$":0},"dyn-o-saur":{"$":0},"dynalias":{"$":0},"dyndns-at-home":{"$":0},"dyndns-at-work":{"$":0},"dyndns-blog":{"$":0},"dyndns-free":{"$":0},"dyndns-home":{"$":0},"dyndns-ip":{"$":0},"dyndns-mail":{"$":0},"dyndns-office":{"$":0},"dyndns-pics":{"$":0},"dyndns-remote":{"$":0},"dyndns-server":{"$":0},"dyndns-web":{"$":0},"dyndns-wiki":{"$":0},"dyndns-work":{"$":0},"est-a-la-maison":{"$":0},"est-a-la-masion":{"$":0},"est-le-patron":{"$":0},"est-mon-blogueur":{"$":0},"from-ak":{"$":0},"from-al":{"$":0},"from-ar":{"$":0},"from-ca":{"$":0},"from-ct":{"$":0},"from-dc":{"$":0},"from-de":{"$":0},"from-fl":{"$":0},"from-ga":{"$":0},"from-hi":{"$":0},"from-ia":{"$":0},"from-id":{"$":0},"from-il":{"$":0},"from-in":{"$":0},"from-ks":{"$":0},"from-ky":{"$":0},"from-ma":{"$":0},"from-md":{"$":0},"from-mi":{"$":0},"from-mn":{"$":0},"from-mo":{"$":0},"from-ms":{"$":0},"from-mt":{"$":0},"from-nc":{"$":0},"from-nd":{"$":0},"from-ne":{"$":0},"from-nh":{"$":0},"from-nj":{"$":0},"from-nm":{"$":0},"from-nv":{"$":0},"from-oh":{"$":0},"from-ok":{"$":0},"from-or":{"$":0},"from-pa":{"$":0},"from-pr":{"$":0},"from-ri":{"$":0},"from-sc":{"$":0},"from-sd":{"$":0},"from-tn":{"$":0},"from-tx":{"$":0},"from-ut":{"$":0},"from-va":{"$":0},"from-vt":{"$":0},"from-wa":{"$":0},"from-wi":{"$":0},"from-wv":{"$":0},"from-wy":{"$":0},"getmyip":{"$":0},"gotdns":{"$":0},"hobby-site":{"$":0},"homelinux":{"$":0},"homeunix":{"$":0},"iamallama":{"$":0},"is-a-anarchist":{"$":0},"is-a-blogger":{"$":0},"is-a-bookkeeper":{"$":0},"is-a-bulls-fan":{"$":0},"is-a-caterer":{"$":0},"is-a-chef":{"$":0},"is-a-conservative":{"$":0},"is-a-cpa":{"$":0},"is-a-cubicle-slave":{"$":0},"is-a-democrat":{"$":0},"is-a-designer":{"$":0},"is-a-doctor":{"$":0},"is-a-financialadvisor":{"$":0},"is-a-geek":{"$":0},"is-a-green":{"$":0},"is-a-guru":{"$":0},"is-a-hard-worker":{"$":0},"is-a-hunter":{"$":0},"is-a-landscaper":{"$":0},"is-a-lawyer":{"$":0},"is-a-liberal":{"$":0},"is-a-libertarian":{"$":0},"is-a-llama":{"$":0},"is-a-musician":{"$":0},"is-a-nascarfan":{"$":0},"is-a-nurse":{"$":0},"is-a-painter":{"$":0},"is-a-personaltrainer":{"$":0},"is-a-photographer":{"$":0},"is-a-player":{"$":0},"is-a-republican":{"$":0},"is-a-rockstar":{"$":0},"is-a-socialist":{"$":0},"is-a-student":{"$":0},"is-a-teacher":{"$":0},"is-a-techie":{"$":0},"is-a-therapist":{"$":0},"is-an-accountant":{"$":0},"is-an-actor":{"$":0},"is-an-actress":{"$":0},"is-an-anarchist":{"$":0},"is-an-artist":{"$":0},"is-an-engineer":{"$":0},"is-an-entertainer":{"$":0},"is-certified":{"$":0},"is-gone":{"$":0},"is-into-anime":{"$":0},"is-into-cars":{"$":0},"is-into-cartoons":{"$":0},"is-into-games":{"$":0},"is-leet":{"$":0},"is-not-certified":{"$":0},"is-slick":{"$":0},"is-uberleet":{"$":0},"is-with-theband":{"$":0},"isa-geek":{"$":0},"isa-hockeynut":{"$":0},"issmarterthanyou":{"$":0},"likes-pie":{"$":0},"likescandy":{"$":0},"neat-url":{"$":0},"saves-the-whales":{"$":0},"selfip":{"$":0},"sells-for-less":{"$":0},"sells-for-u":{"$":0},"servebbs":{"$":0},"simple-url":{"$":0},"space-to-rent":{"$":0},"teaches-yoga":{"$":0},"writesthisblog":{"$":0},"ddnsfree":{"$":0},"ddnsgeek":{"$":0},"giize":{"$":0},"gleeze":{"$":0},"kozow":{"$":0},"loseyourip":{"$":0},"ooguy":{"$":0},"theworkpc":{"$":0},"mytuleap":{"$":0},"tuleap-partners":{"$":0},"encoreapi":{"$":0},"evennode":{"eu-1":{"$":0},"eu-2":{"$":0},"eu-3":{"$":0},"eu-4":{"$":0},"us-1":{"$":0},"us-2":{"$":0},"us-3":{"$":0},"us-4":{"$":0}},"onfabrica":{"$":0},"fastly-edge":{"$":0},"fastly-terrarium":{"$":0},"fastvps-server":{"$":0},"mydobiss":{"$":0},"firebaseapp":{"$":0},"fldrv":{"$":0},"forgeblocks":{"$":0},"framercanvas":{"$":0},"freebox-os":{"$":0},"freeboxos":{"$":0},"freemyip":{"$":0},"aliases121":{"$":0},"gentapps":{"$":0},"gentlentapis":{"$":0},"githubusercontent":{"$":0},"0emm":{"*":{"$":0}},"appspot":{"$":0,"r":{"*":{"$":0}}},"blogspot":{"$":0},"codespot":{"$":0},"googleapis":{"$":0},"googlecode":{"$":0},"pagespeedmobilizer":{"$":0},"withgoogle":{"$":0},"withyoutube":{"$":0},"grayjayleagues":{"$":0},"hatenablog":{"$":0},"hatenadiary":{"$":0},"herokuapp":{"$":0},"gr":{"$":0},"smushcdn":{"$":0},"wphostedmail":{"$":0},"wpmucdn":{"$":0},"pixolino":{"$":0},"apps-1and1":{"$":0},"live-website":{"$":0},"webspace-host":{"$":0},"dopaas":{"$":0},"hosted-by-previder":{"paas":{"$":0}},"hosteur":{"rag-cloud":{"$":0},"rag-cloud-ch":{"$":0}},"ik-server":{"jcloud":{"$":0},"jcloud-ver-jpc":{"$":0}},"jelastic":{"demo":{"$":0}},"massivegrid":{"paas":{"$":0}},"wafaicloud":{"jed":{"$":0},"ryd":{"$":0}},"webadorsite":{"$":0},"joyent":{"cns":{"*":{"$":0}}},"lpusercontent":{"$":0},"linode":{"members":{"$":0},"nodebalancer":{"*":{"$":0}}},"linodeobjects":{"*":{"$":0}},"linodeusercontent":{"ip":{"$":0}},"localtonet":{"$":0},"lovableproject":{"$":0},"barsycenter":{"$":0},"barsyonline":{"$":0},"lutrausercontent":{"*":{"$":0}},"modelscape":{"$":0},"mwcloudnonprod":{"$":0},"polyspace":{"$":0},"mazeplay":{"$":0},"miniserver":{"$":0},"atmeta":{"$":0},"fbsbx":{"apps":{"$":0}},"meteorapp":{"$":0,"eu":{"$":0}},"routingthecloud":{"$":0},"mydbserver":{"$":0},"hostedpi":{"$":0},"mythic-beasts":{"caracal":{"$":0},"customer":{"$":0},"fentiger":{"$":0},"lynx":{"$":0},"ocelot":{"$":0},"oncilla":{"$":0},"onza":{"$":0},"sphinx":{"$":0},"vs":{"$":0},"x":{"$":0},"yali":{"$":0}},"nospamproxy":{"cloud":{"$":0,"o365":{"$":0}}},"4u":{"$":0},"nfshost":{"$":0},"3utilities":{"$":0},"blogsyte":{"$":0},"ciscofreak":{"$":0},"damnserver":{"$":0},"ddnsking":{"$":0},"ditchyourip":{"$":0},"dnsiskinky":{"$":0},"dynns":{"$":0},"geekgalaxy":{"$":0},"health-carereform":{"$":0},"homesecuritymac":{"$":0},"homesecuritypc":{"$":0},"myactivedirectory":{"$":0},"mysecuritycamera":{"$":0},"myvnc":{"$":0},"net-freaks":{"$":0},"onthewifi":{"$":0},"point2this":{"$":0},"quicksytes":{"$":0},"securitytactics":{"$":0},"servebeer":{"$":0},"servecounterstrike":{"$":0},"serveexchange":{"$":0},"serveftp":{"$":0},"servegame":{"$":0},"servehalflife":{"$":0},"servehttp":{"$":0},"servehumour":{"$":0},"serveirc":{"$":0},"servemp3":{"$":0},"servep2p":{"$":0},"servepics":{"$":0},"servequake":{"$":0},"servesarcasm":{"$":0},"stufftoread":{"$":0},"unusualperson":{"$":0},"workisboring":{"$":0},"myiphost":{"$":0},"observableusercontent":{"static":{"$":0}},"simplesite":{"$":0},"oaiusercontent":{"*":{"$":0}},"orsites":{"$":0},"operaunite":{"$":0},"customer-oci":{"*":{"$":0},"oci":{"*":{"$":0}},"ocp":{"*":{"$":0}},"ocs":{"*":{"$":0}}},"oraclecloudapps":{"*":{"$":0}},"oraclegovcloudapps":{"*":{"$":0}},"authgear-staging":{"$":0},"authgearapps":{"$":0},"skygearapp":{"$":0},"outsystemscloud":{"$":0},"ownprovider":{"$":0},"pgfog":{"$":0},"pagexl":{"$":0},"gotpantheon":{"$":0},"paywhirl":{"*":{"$":0}},"upsunapp":{"$":0},"postman-echo":{"$":0},"prgmr":{"xen":{"$":0}},"project-study":{"dev":{"$":0}},"pythonanywhere":{"$":0,"eu":{"$":0}},"qa2":{"$":0},"alpha-myqnapcloud":{"$":0},"dev-myqnapcloud":{"$":0},"mycloudnas":{"$":0},"mynascloud":{"$":0},"myqnapcloud":{"$":0},"qualifioapp":{"$":0},"ladesk":{"$":0},"qbuser":{"$":0},"quipelements":{"*":{"$":0}},"rackmaze":{"$":0},"readthedocs-hosted":{"$":0},"rhcloud":{"$":0},"onrender":{"$":0},"render":{"app":{"$":0}},"subsc-pay":{"$":0},"180r":{"$":0},"dojin":{"$":0},"sakuratan":{"$":0},"sakuraweb":{"$":0},"x0":{"$":0},"code":{"builder":{"*":{"$":0}},"dev-builder":{"*":{"$":0}},"stg-builder":{"*":{"$":0}}},"salesforce":{"platform":{"code-builder-stg":{"test":{"001":{"*":{"$":0}}}}}},"logoip":{"$":0},"scrysec":{"$":0},"firewall-gateway":{"$":0},"myshopblocks":{"$":0},"myshopify":{"$":0},"shopitsite":{"$":0},"1kapp":{"$":0},"appchizi":{"$":0},"applinzi":{"$":0},"sinaapp":{"$":0},"vipsinaapp":{"$":0},"streamlitapp":{"$":0},"try-snowplow":{"$":0},"playstation-cloud":{"$":0},"myspreadshop":{"$":0},"w-corp-staticblitz":{"$":0},"w-credentialless-staticblitz":{"$":0},"w-staticblitz":{"$":0},"stackhero-network":{"$":0},"stdlib":{"api":{"$":0}},"strapiapp":{"$":0,"media":{"$":0}},"streak-link":{"$":0},"streaklinks":{"$":0},"streakusercontent":{"$":0},"temp-dns":{"$":0},"dsmynas":{"$":0},"familyds":{"$":0},"mytabit":{"$":0},"taveusercontent":{"$":0},"tb-hosting":{"site":{"$":0}},"reservd":{"$":0},"thingdustdata":{"$":0},"townnews-staging":{"$":0},"typeform":{"pro":{"$":0}},"hk":{"$":0},"it":{"$":0},"deus-canvas":{"$":0},"vultrobjects":{"*":{"$":0}},"wafflecell":{"$":0},"hotelwithflight":{"$":0},"reserve-online":{"$":0},"cprapid":{"$":0},"pleskns":{"$":0},"remotewd":{"$":0},"wiardweb":{"pages":{"$":0}},"wixsite":{"$":0},"wixstudio":{"$":0},"messwithdns":{"$":0},"woltlab-demo":{"$":0},"wpenginepowered":{"$":0,"js":{"$":0}},"xnbay":{"$":0,"u2":{"$":0},"u2-local":{"$":0}},"yolasite":{"$":0}},"coop":{"$":0},"cr":{"$":0,"ac":{"$":0},"co":{"$":0},"ed":{"$":0},"fi":{"$":0},"go":{"$":0},"or":{"$":0},"sa":{"$":0}},"cu":{"$":0,"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"inf":{"$":0},"nat":{"$":0},"net":{"$":0},"org":{"$":0}},"cv":{"$":0,"com":{"$":0},"edu":{"$":0},"id":{"$":0},"int":{"$":0},"net":{"$":0},"nome":{"$":0},"org":{"$":0},"publ":{"$":0}},"cw":{"$":0,"com":{"$":0},"edu":{"$":0},"net":{"$":0},"org":{"$":0}},"cx":{"$":0,"gov":{"$":0},"cloudns":{"$":0},"ath":{"$":0},"info":{"$":0},"assessments":{"$":0},"calculators":{"$":0},"funnels":{"$":0},"paynow":{"$":0},"quizzes":{"$":0},"researched":{"$":0},"tests":{"$":0}},"cy":{"$":0,"ac":{"$":0},"biz":{"$":0},"com":{"$":0,"scaleforce":{"j":{"$":0}}},"ekloges":{"$":0},"gov":{"$":0},"ltd":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"press":{"$":0},"pro":{"$":0},"tm":{"$":0}},"cz":{"$":0,"contentproxy9":{"rsc":{"$":0}},"realm":{"$":0},"e4":{"$":0},"co":{"$":0},"metacentrum":{"cloud":{"*":{"$":0}},"custom":{"$":0}},"muni":{"cloud":{"flt":{"$":0},"usr":{"$":0}}}},"de":{"$":0,"bplaced":{"$":0},"square7":{"$":0},"com":{"$":0},"cosidns":{"dyn":{"$":0}},"dnsupdater":{"$":0},"dynamisches-dns":{"$":0},"internet-dns":{"$":0},"l-o-g-i-n":{"$":0},"ddnss":{"$":0,"dyn":{"$":0},"dyndns":{"$":0}},"dyn-ip24":{"$":0},"dyndns1":{"$":0},"home-webserver":{"$":0,"dyn":{"$":0}},"myhome-server":{"$":0},"dnshome":{"$":0},"fuettertdasnetz":{"$":0},"isteingeek":{"$":0},"istmein":{"$":0},"lebtimnetz":{"$":0},"leitungsen":{"$":0},"traeumtgerade":{"$":0},"frusky":{"*":{"$":0}},"goip":{"$":0},"xn--gnstigbestellen-zvb":{"$":0},"xn--gnstigliefern-wob":{"$":0},"hs-heilbronn":{"it":{"pages":{"$":0},"pages-research":{"$":0}}},"dyn-berlin":{"$":0},"in-berlin":{"$":0},"in-brb":{"$":0},"in-butter":{"$":0},"in-dsl":{"$":0},"in-vpn":{"$":0},"iservschule":{"$":0},"mein-iserv":{"$":0},"schuldock":{"$":0},"schulplattform":{"$":0},"schulserver":{"$":0},"test-iserv":{"$":0},"keymachine":{"$":0},"git-repos":{"$":0},"lcube-server":{"$":0},"svn-repos":{"$":0},"barsy":{"$":0},"webspaceconfig":{"$":0},"123webseite":{"$":0},"rub":{"$":0},"ruhr-uni-bochum":{"$":0,"noc":{"io":{"$":0}}},"logoip":{"$":0},"firewall-gateway":{"$":0},"my-gateway":{"$":0},"my-router":{"$":0},"spdns":{"$":0},"my":{"$":0},"speedpartner":{"customer":{"$":0}},"myspreadshop":{"$":0},"taifun-dns":{"$":0},"12hp":{"$":0},"2ix":{"$":0},"4lima":{"$":0},"lima-city":{"$":0},"dd-dns":{"$":0},"dray-dns":{"$":0},"draydns":{"$":0},"dyn-vpn":{"$":0},"dynvpn":{"$":0},"mein-vigor":{"$":0},"my-vigor":{"$":0},"my-wan":{"$":0},"syno-ds":{"$":0},"synology-diskstation":{"$":0},"synology-ds":{"$":0},"uberspace":{"*":{"$":0}},"virtual-user":{"$":0},"virtualuser":{"$":0},"community-pro":{"$":0},"diskussionsbereich":{"$":0}},"dj":{"$":0},"dk":{"$":0,"biz":{"$":0},"co":{"$":0},"firm":{"$":0},"reg":{"$":0},"store":{"$":0},"123hjemmeside":{"$":0},"myspreadshop":{"$":0}},"dm":{"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"do":{"$":0,"art":{"$":0},"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"sld":{"$":0},"web":{"$":0}},"dz":{"$":0,"art":{"$":0},"asso":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"pol":{"$":0},"soc":{"$":0},"tm":{"$":0}},"ec":{"$":0,"abg":{"$":0},"adm":{"$":0},"agron":{"$":0},"arqt":{"$":0},"art":{"$":0},"bar":{"$":0},"chef":{"$":0},"com":{"$":0},"cont":{"$":0},"cpa":{"$":0},"cue":{"$":0},"dent":{"$":0},"dgn":{"$":0},"disco":{"$":0},"doc":{"$":0},"edu":{"$":0},"eng":{"$":0},"esm":{"$":0},"fin":{"$":0},"fot":{"$":0},"gal":{"$":0},"gob":{"$":0},"gov":{"$":0},"gye":{"$":0},"ibr":{"$":0},"info":{"$":0},"k12":{"$":0},"lat":{"$":0},"loj":{"$":0},"med":{"$":0},"mil":{"$":0},"mktg":{"$":0},"mon":{"$":0},"net":{"$":0},"ntr":{"$":0},"odont":{"$":0},"org":{"$":0},"pro":{"$":0},"prof":{"$":0},"psic":{"$":0},"psiq":{"$":0},"pub":{"$":0},"rio":{"$":0},"rrpp":{"$":0},"sal":{"$":0},"tech":{"$":0},"tul":{"$":0},"tur":{"$":0},"uio":{"$":0},"vet":{"$":0},"xxx":{"$":0},"base":{"$":0},"official":{"$":0}},"edu":{"$":0,"rit":{"git-pages":{"$":0}}},"ee":{"$":0,"aip":{"$":0},"com":{"$":0},"edu":{"$":0},"fie":{"$":0},"gov":{"$":0},"lib":{"$":0},"med":{"$":0},"org":{"$":0},"pri":{"$":0},"riik":{"$":0}},"eg":{"$":0,"ac":{"$":0},"com":{"$":0},"edu":{"$":0},"eun":{"$":0},"gov":{"$":0},"info":{"$":0},"me":{"$":0},"mil":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"sci":{"$":0},"sport":{"$":0},"tv":{"$":0}},"er":{"*":{"$":0}},"es":{"$":0,"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"nom":{"$":0},"org":{"$":0},"123miweb":{"$":0},"myspreadshop":{"$":0}},"et":{"$":0,"biz":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0}},"eu":{"$":0,"airkitapps":{"$":0},"cloudns":{"$":0},"dogado":{"jelastic":{"$":0}},"barsy":{"$":0},"spdns":{"$":0},"nxa":{"*":{"$":0}},"transurl":{"*":{"$":0}},"diskstation":{"$":0}},"fi":{"$":0,"aland":{"$":0},"dy":{"$":0},"xn--hkkinen-5wa":{"$":0},"iki":{"$":0},"cloudplatform":{"fi":{"$":0}},"datacenter":{"demo":{"$":0},"paas":{"$":0}},"kapsi":{"$":0},"123kotisivu":{"$":0},"myspreadshop":{"$":0}},"fj":{"$":0,"ac":{"$":0},"biz":{"$":0},"com":{"$":0},"gov":{"$":0},"info":{"$":0},"mil":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"pro":{"$":0}},"fk":{"*":{"$":0}},"fm":{"$":0,"com":{"$":0},"edu":{"$":0},"net":{"$":0},"org":{"$":0},"radio":{"$":0},"user":{"*":{"$":0}}},"fo":{"$":0},"fr":{"$":0,"asso":{"$":0},"com":{"$":0},"gouv":{"$":0},"nom":{"$":0},"prd":{"$":0},"tm":{"$":0},"avoues":{"$":0},"cci":{"$":0},"greta":{"$":0},"huissier-justice":{"$":0},"en-root":{"$":0},"fbx-os":{"$":0},"fbxos":{"$":0},"freebox-os":{"$":0},"freeboxos":{"$":0},"goupile":{"$":0},"123siteweb":{"$":0},"on-web":{"$":0},"chirurgiens-dentistes-en-france":{"$":0},"dedibox":{"$":0},"aeroport":{"$":0},"avocat":{"$":0},"chambagri":{"$":0},"chirurgiens-dentistes":{"$":0},"experts-comptables":{"$":0},"medecin":{"$":0},"notaires":{"$":0},"pharmacien":{"$":0},"port":{"$":0},"veterinaire":{"$":0},"myspreadshop":{"$":0},"ynh":{"$":0}},"ga":{"$":0},"gb":{"$":0},"gd":{"$":0,"edu":{"$":0},"gov":{"$":0}},"ge":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"pvt":{"$":0},"school":{"$":0}},"gf":{"$":0},"gg":{"$":0,"co":{"$":0},"net":{"$":0},"org":{"$":0},"botdash":{"$":0},"kaas":{"$":0},"stackit":{"$":0},"panel":{"$":0,"daemon":{"$":0}}},"gh":{"$":0,"biz":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"gi":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"ltd":{"$":0},"mod":{"$":0},"org":{"$":0}},"gl":{"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"net":{"$":0},"org":{"$":0},"biz":{"$":0}},"gm":{"$":0},"gn":{"$":0,"ac":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"gov":{"$":0},"gp":{"$":0,"asso":{"$":0},"com":{"$":0},"edu":{"$":0},"mobi":{"$":0},"net":{"$":0},"org":{"$":0}},"gq":{"$":0},"gr":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"barsy":{"$":0},"simplesite":{"$":0}},"gs":{"$":0},"gt":{"$":0,"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"ind":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"gu":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"guam":{"$":0},"info":{"$":0},"net":{"$":0},"org":{"$":0},"web":{"$":0}},"gw":{"$":0,"nx":{"$":0}},"gy":{"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"hk":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"idv":{"$":0},"net":{"$":0},"org":{"$":0},"xn--ciqpn":{"$":0},"xn--gmqw5a":{"$":0},"xn--55qx5d":{"$":0},"xn--mxtq1m":{"$":0},"xn--lcvr32d":{"$":0},"xn--wcvs22d":{"$":0},"xn--gmq050i":{"$":0},"xn--uc0atv":{"$":0},"xn--uc0ay4a":{"$":0},"xn--od0alg":{"$":0},"xn--zf0avx":{"$":0},"xn--mk0axi":{"$":0},"xn--tn0ag":{"$":0},"xn--od0aq3b":{"$":0},"xn--io0a7i":{"$":0},"inc":{"$":0},"ltd":{"$":0}},"hm":{"$":0},"hn":{"$":0,"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"hr":{"$":0,"com":{"$":0},"from":{"$":0},"iz":{"$":0},"name":{"$":0},"brendly":{"shop":{"$":0}}},"ht":{"$":0,"adult":{"$":0},"art":{"$":0},"asso":{"$":0},"com":{"$":0},"coop":{"$":0},"edu":{"$":0},"firm":{"$":0},"gouv":{"$":0},"info":{"$":0},"med":{"$":0},"net":{"$":0},"org":{"$":0},"perso":{"$":0},"pol":{"$":0},"pro":{"$":0},"rel":{"$":0},"shop":{"$":0},"rt":{"$":0}},"hu":{"2000":{"$":0},"$":0,"agrar":{"$":0},"bolt":{"$":0},"casino":{"$":0},"city":{"$":0},"co":{"$":0},"erotica":{"$":0},"erotika":{"$":0},"film":{"$":0},"forum":{"$":0},"games":{"$":0},"hotel":{"$":0},"info":{"$":0},"ingatlan":{"$":0},"jogasz":{"$":0},"konyvelo":{"$":0},"lakas":{"$":0},"media":{"$":0},"news":{"$":0},"org":{"$":0},"priv":{"$":0},"reklam":{"$":0},"sex":{"$":0},"shop":{"$":0},"sport":{"$":0},"suli":{"$":0},"szex":{"$":0},"tm":{"$":0},"tozsde":{"$":0},"utazas":{"$":0},"video":{"$":0}},"id":{"$":0,"ac":{"$":0},"biz":{"$":0},"co":{"$":0},"desa":{"$":0},"go":{"$":0},"kop":{"$":0},"mil":{"$":0},"my":{"$":0},"net":{"$":0},"or":{"$":0},"ponpes":{"$":0},"sch":{"$":0},"web":{"$":0},"zone":{"$":0}},"ie":{"$":0,"gov":{"$":0},"myspreadshop":{"$":0}},"il":{"$":0,"ac":{"$":0},"co":{"$":0,"ravpage":{"$":0},"mytabit":{"$":0},"tabitorder":{"$":0}},"gov":{"$":0},"idf":{"$":0},"k12":{"$":0},"muni":{"$":0},"net":{"$":0},"org":{"$":0}},"xn--4dbrk0ce":{"$":0,"xn--4dbgdty6c":{"$":0},"xn--5dbhl8d":{"$":0},"xn--8dbq2a":{"$":0},"xn--hebda8b":{"$":0}},"im":{"$":0,"ac":{"$":0},"co":{"$":0,"ltd":{"$":0},"plc":{"$":0}},"com":{"$":0},"net":{"$":0},"org":{"$":0},"tt":{"$":0},"tv":{"$":0}},"in":{"$":0,"5g":{"$":0},"6g":{"$":0},"ac":{"$":0},"ai":{"$":0},"am":{"$":0},"bihar":{"$":0},"biz":{"$":0},"business":{"$":0},"ca":{"$":0},"cn":{"$":0},"co":{"$":0},"com":{"$":0},"coop":{"$":0},"cs":{"$":0},"delhi":{"$":0},"dr":{"$":0},"edu":{"$":0},"er":{"$":0},"firm":{"$":0},"gen":{"$":0},"gov":{"$":0},"gujarat":{"$":0},"ind":{"$":0},"info":{"$":0},"int":{"$":0},"internet":{"$":0},"io":{"$":0},"me":{"$":0},"mil":{"$":0},"net":{"$":0},"nic":{"$":0},"org":{"$":0},"pg":{"$":0},"post":{"$":0},"pro":{"$":0},"res":{"$":0},"travel":{"$":0},"tv":{"$":0},"uk":{"$":0},"up":{"$":0},"us":{"$":0},"cloudns":{"$":0},"barsy":{"$":0},"web":{"$":0},"supabase":{"$":0}},"info":{"$":0,"cloudns":{"$":0},"dynamic-dns":{"$":0},"barrel-of-knowledge":{"$":0},"barrell-of-knowledge":{"$":0},"dyndns":{"$":0},"for-our":{"$":0},"groks-the":{"$":0},"groks-this":{"$":0},"here-for-more":{"$":0},"knowsitall":{"$":0},"selfip":{"$":0},"webhop":{"$":0},"barsy":{"$":0},"mayfirst":{"$":0},"mittwald":{"$":0},"mittwaldserver":{"$":0},"typo3server":{"$":0},"dvrcam":{"$":0},"ilovecollege":{"$":0},"no-ip":{"$":0},"forumz":{"$":0},"nsupdate":{"$":0},"dnsupdate":{"$":0},"v-info":{"$":0}},"int":{"$":0,"eu":{"$":0}},"io":{"2038":{"$":0},"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"nom":{"$":0},"org":{"$":0},"on-acorn":{"*":{"$":0}},"myaddr":{"$":0},"apigee":{"$":0},"b-data":{"$":0},"beagleboard":{"$":0},"bitbucket":{"$":0},"bluebite":{"$":0},"boxfuse":{"$":0},"brave":{"$":0,"s":{"*":{"$":0}}},"browsersafetymark":{"$":0},"bubble":{"cdn":{"$":0}},"bubbleapps":{"$":0},"bigv":{"uk0":{"$":0}},"cleverapps":{"$":0},"cloudbeesusercontent":{"$":0},"dappnode":{"dyndns":{"$":0}},"darklang":{"$":0},"definima":{"$":0},"dedyn":{"$":0},"icp-api":{"$":0},"icp0":{"$":0,"raw":{"*":{"$":0}}},"icp1":{"$":0,"raw":{"*":{"$":0}}},"qzz":{"$":0},"fh-muenster":{"$":0},"shw":{"$":0},"forgerock":{"id":{"$":0}},"github":{"$":0},"gitlab":{"$":0},"lolipop":{"$":0},"hasura-app":{"$":0},"hostyhosting":{"$":0},"hypernode":{"$":0},"moonscale":{"*":{"$":0}},"beebyte":{"paas":{"$":0}},"beebyteapp":{"sekd1":{"$":0}},"jele":{"$":0},"webthings":{"$":0},"loginline":{"$":0},"barsy":{"$":0},"azurecontainer":{"*":{"$":0}},"ngrok":{"$":0,"ap":{"$":0},"au":{"$":0},"eu":{"$":0},"in":{"$":0},"jp":{"$":0},"sa":{"$":0},"us":{"$":0}},"nodeart":{"stage":{"$":0}},"pantheonsite":{"$":0},"pstmn":{"$":0,"mock":{"$":0}},"protonet":{"$":0},"qcx":{"$":0,"sys":{"*":{"$":0}}},"qoto":{"$":0},"vaporcloud":{"$":0},"myrdbx":{"$":0},"rb-hosting":{"site":{"$":0}},"on-k3s":{"*":{"$":0}},"on-rio":{"*":{"$":0}},"readthedocs":{"$":0},"resindevice":{"$":0},"resinstaging":{"devices":{"$":0}},"hzc":{"$":0},"sandcats":{"$":0},"scrypted":{"client":{"$":0}},"mo-siemens":{"$":0},"lair":{"apps":{"$":0}},"stolos":{"*":{"$":0}},"musician":{"$":0},"utwente":{"$":0},"edugit":{"$":0},"telebit":{"$":0},"thingdust":{"dev":{"cust":{"$":0},"reservd":{"$":0}},"disrec":{"cust":{"$":0},"reservd":{"$":0}},"prod":{"cust":{"$":0}},"testing":{"cust":{"$":0},"reservd":{"$":0}}},"tickets":{"$":0},"webflow":{"$":0},"webflowtest":{"$":0},"editorx":{"$":0},"wixstudio":{"$":0},"basicserver":{"$":0},"virtualserver":{"$":0}},"iq":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"ir":{"$":0,"ac":{"$":0},"co":{"$":0},"gov":{"$":0},"id":{"$":0},"net":{"$":0},"org":{"$":0},"sch":{"$":0},"xn--mgba3a4f16a":{"$":0},"xn--mgba3a4fra":{"$":0},"arvanedge":{"$":0},"vistablog":{"$":0}},"is":{"$":0},"it":{"$":0,"edu":{"$":0},"gov":{"$":0},"abr":{"$":0},"abruzzo":{"$":0},"aosta-valley":{"$":0},"aostavalley":{"$":0},"bas":{"$":0},"basilicata":{"$":0},"cal":{"$":0},"calabria":{"$":0},"cam":{"$":0},"campania":{"$":0},"emilia-romagna":{"$":0},"emiliaromagna":{"$":0},"emr":{"$":0},"friuli-v-giulia":{"$":0},"friuli-ve-giulia":{"$":0},"friuli-vegiulia":{"$":0},"friuli-venezia-giulia":{"$":0},"friuli-veneziagiulia":{"$":0},"friuli-vgiulia":{"$":0},"friuliv-giulia":{"$":0},"friulive-giulia":{"$":0},"friulivegiulia":{"$":0},"friulivenezia-giulia":{"$":0},"friuliveneziagiulia":{"$":0},"friulivgiulia":{"$":0},"fvg":{"$":0},"laz":{"$":0},"lazio":{"$":0},"lig":{"$":0},"liguria":{"$":0},"lom":{"$":0},"lombardia":{"$":0},"lombardy":{"$":0},"lucania":{"$":0},"mar":{"$":0},"marche":{"$":0},"mol":{"$":0},"molise":{"$":0},"piedmont":{"$":0},"piemonte":{"$":0},"pmn":{"$":0},"pug":{"$":0},"puglia":{"$":0},"sar":{"$":0},"sardegna":{"$":0},"sardinia":{"$":0},"sic":{"$":0},"sicilia":{"$":0},"sicily":{"$":0},"taa":{"$":0},"tos":{"$":0},"toscana":{"$":0},"trentin-sud-tirol":{"$":0},"xn--trentin-sd-tirol-rzb":{"$":0},"trentin-sudtirol":{"$":0},"xn--trentin-sdtirol-7vb":{"$":0},"trentin-sued-tirol":{"$":0},"trentin-suedtirol":{"$":0},"trentino":{"$":0},"trentino-a-adige":{"$":0},"trentino-aadige":{"$":0},"trentino-alto-adige":{"$":0},"trentino-altoadige":{"$":0},"trentino-s-tirol":{"$":0},"trentino-stirol":{"$":0},"trentino-sud-tirol":{"$":0},"xn--trentino-sd-tirol-c3b":{"$":0},"trentino-sudtirol":{"$":0},"xn--trentino-sdtirol-szb":{"$":0},"trentino-sued-tirol":{"$":0},"trentino-suedtirol":{"$":0},"trentinoa-adige":{"$":0},"trentinoaadige":{"$":0},"trentinoalto-adige":{"$":0},"trentinoaltoadige":{"$":0},"trentinos-tirol":{"$":0},"trentinostirol":{"$":0},"trentinosud-tirol":{"$":0},"xn--trentinosd-tirol-rzb":{"$":0},"trentinosudtirol":{"$":0},"xn--trentinosdtirol-7vb":{"$":0},"trentinosued-tirol":{"$":0},"trentinosuedtirol":{"$":0},"trentinsud-tirol":{"$":0},"xn--trentinsd-tirol-6vb":{"$":0},"trentinsudtirol":{"$":0},"xn--trentinsdtirol-nsb":{"$":0},"trentinsued-tirol":{"$":0},"trentinsuedtirol":{"$":0},"tuscany":{"$":0},"umb":{"$":0},"umbria":{"$":0},"val-d-aosta":{"$":0},"val-daosta":{"$":0},"vald-aosta":{"$":0},"valdaosta":{"$":0},"valle-aosta":{"$":0},"valle-d-aosta":{"$":0},"valle-daosta":{"$":0},"valleaosta":{"$":0},"valled-aosta":{"$":0},"valledaosta":{"$":0},"vallee-aoste":{"$":0},"xn--valle-aoste-ebb":{"$":0},"vallee-d-aoste":{"$":0},"xn--valle-d-aoste-ehb":{"$":0},"valleeaoste":{"$":0},"xn--valleaoste-e7a":{"$":0},"valleedaoste":{"$":0},"xn--valledaoste-ebb":{"$":0},"vao":{"$":0},"vda":{"$":0},"ven":{"$":0},"veneto":{"$":0},"ag":{"$":0},"agrigento":{"$":0},"al":{"$":0},"alessandria":{"$":0},"alto-adige":{"$":0},"altoadige":{"$":0},"an":{"$":0},"ancona":{"$":0},"andria-barletta-trani":{"$":0},"andria-trani-barletta":{"$":0},"andriabarlettatrani":{"$":0},"andriatranibarletta":{"$":0},"ao":{"$":0},"aosta":{"$":0},"aoste":{"$":0},"ap":{"$":0},"aq":{"$":0},"aquila":{"$":0},"ar":{"$":0},"arezzo":{"$":0},"ascoli-piceno":{"$":0},"ascolipiceno":{"$":0},"asti":{"$":0},"at":{"$":0},"av":{"$":0},"avellino":{"$":0},"ba":{"$":0},"balsan":{"$":0},"balsan-sudtirol":{"$":0},"xn--balsan-sdtirol-nsb":{"$":0},"balsan-suedtirol":{"$":0},"bari":{"$":0},"barletta-trani-andria":{"$":0},"barlettatraniandria":{"$":0},"belluno":{"$":0},"benevento":{"$":0},"bergamo":{"$":0},"bg":{"$":0},"bi":{"$":0},"biella":{"$":0},"bl":{"$":0},"bn":{"$":0},"bo":{"$":0},"bologna":{"$":0},"bolzano":{"$":0},"bolzano-altoadige":{"$":0},"bozen":{"$":0},"bozen-sudtirol":{"$":0},"xn--bozen-sdtirol-2ob":{"$":0},"bozen-suedtirol":{"$":0},"br":{"$":0},"brescia":{"$":0},"brindisi":{"$":0},"bs":{"$":0},"bt":{"$":0},"bulsan":{"$":0},"bulsan-sudtirol":{"$":0},"xn--bulsan-sdtirol-nsb":{"$":0},"bulsan-suedtirol":{"$":0},"bz":{"$":0},"ca":{"$":0},"cagliari":{"$":0},"caltanissetta":{"$":0},"campidano-medio":{"$":0},"campidanomedio":{"$":0},"campobasso":{"$":0},"carbonia-iglesias":{"$":0},"carboniaiglesias":{"$":0},"carrara-massa":{"$":0},"carraramassa":{"$":0},"caserta":{"$":0},"catania":{"$":0},"catanzaro":{"$":0},"cb":{"$":0},"ce":{"$":0},"cesena-forli":{"$":0},"xn--cesena-forl-mcb":{"$":0},"cesenaforli":{"$":0},"xn--cesenaforl-i8a":{"$":0},"ch":{"$":0},"chieti":{"$":0},"ci":{"$":0},"cl":{"$":0},"cn":{"$":0},"co":{"$":0},"como":{"$":0},"cosenza":{"$":0},"cr":{"$":0},"cremona":{"$":0},"crotone":{"$":0},"cs":{"$":0},"ct":{"$":0},"cuneo":{"$":0},"cz":{"$":0},"dell-ogliastra":{"$":0},"dellogliastra":{"$":0},"en":{"$":0},"enna":{"$":0},"fc":{"$":0},"fe":{"$":0},"fermo":{"$":0},"ferrara":{"$":0},"fg":{"$":0},"fi":{"$":0},"firenze":{"$":0},"florence":{"$":0},"fm":{"$":0},"foggia":{"$":0},"forli-cesena":{"$":0},"xn--forl-cesena-fcb":{"$":0},"forlicesena":{"$":0},"xn--forlcesena-c8a":{"$":0},"fr":{"$":0},"frosinone":{"$":0},"ge":{"$":0},"genoa":{"$":0},"genova":{"$":0},"go":{"$":0},"gorizia":{"$":0},"gr":{"$":0},"grosseto":{"$":0},"iglesias-carbonia":{"$":0},"iglesiascarbonia":{"$":0},"im":{"$":0},"imperia":{"$":0},"is":{"$":0},"isernia":{"$":0},"kr":{"$":0},"la-spezia":{"$":0},"laquila":{"$":0},"laspezia":{"$":0},"latina":{"$":0},"lc":{"$":0},"le":{"$":0},"lecce":{"$":0},"lecco":{"$":0},"li":{"$":0},"livorno":{"$":0},"lo":{"$":0},"lodi":{"$":0},"lt":{"$":0},"lu":{"$":0},"lucca":{"$":0},"macerata":{"$":0},"mantova":{"$":0},"massa-carrara":{"$":0},"massacarrara":{"$":0},"matera":{"$":0},"mb":{"$":0},"mc":{"$":0},"me":{"$":0},"medio-campidano":{"$":0},"mediocampidano":{"$":0},"messina":{"$":0},"mi":{"$":0},"milan":{"$":0},"milano":{"$":0},"mn":{"$":0},"mo":{"$":0},"modena":{"$":0},"monza":{"$":0},"monza-brianza":{"$":0},"monza-e-della-brianza":{"$":0},"monzabrianza":{"$":0},"monzaebrianza":{"$":0},"monzaedellabrianza":{"$":0},"ms":{"$":0},"mt":{"$":0},"na":{"$":0},"naples":{"$":0},"napoli":{"$":0},"no":{"$":0},"novara":{"$":0},"nu":{"$":0},"nuoro":{"$":0},"og":{"$":0},"ogliastra":{"$":0},"olbia-tempio":{"$":0},"olbiatempio":{"$":0},"or":{"$":0},"oristano":{"$":0},"ot":{"$":0},"pa":{"$":0},"padova":{"$":0},"padua":{"$":0},"palermo":{"$":0},"parma":{"$":0},"pavia":{"$":0},"pc":{"$":0},"pd":{"$":0},"pe":{"$":0},"perugia":{"$":0},"pesaro-urbino":{"$":0},"pesarourbino":{"$":0},"pescara":{"$":0},"pg":{"$":0},"pi":{"$":0},"piacenza":{"$":0},"pisa":{"$":0},"pistoia":{"$":0},"pn":{"$":0},"po":{"$":0},"pordenone":{"$":0},"potenza":{"$":0},"pr":{"$":0},"prato":{"$":0},"pt":{"$":0},"pu":{"$":0},"pv":{"$":0},"pz":{"$":0},"ra":{"$":0},"ragusa":{"$":0},"ravenna":{"$":0},"rc":{"$":0},"re":{"$":0},"reggio-calabria":{"$":0},"reggio-emilia":{"$":0},"reggiocalabria":{"$":0},"reggioemilia":{"$":0},"rg":{"$":0},"ri":{"$":0},"rieti":{"$":0},"rimini":{"$":0},"rm":{"$":0},"rn":{"$":0},"ro":{"$":0},"roma":{"$":0},"rome":{"$":0},"rovigo":{"$":0},"sa":{"$":0},"salerno":{"$":0},"sassari":{"$":0},"savona":{"$":0},"si":{"$":0},"siena":{"$":0},"siracusa":{"$":0},"so":{"$":0},"sondrio":{"$":0},"sp":{"$":0},"sr":{"$":0},"ss":{"$":0},"xn--sdtirol-n2a":{"$":0},"suedtirol":{"$":0},"sv":{"$":0},"ta":{"$":0},"taranto":{"$":0},"te":{"$":0},"tempio-olbia":{"$":0},"tempioolbia":{"$":0},"teramo":{"$":0},"terni":{"$":0},"tn":{"$":0},"to":{"$":0},"torino":{"$":0},"tp":{"$":0},"tr":{"$":0},"trani-andria-barletta":{"$":0},"trani-barletta-andria":{"$":0},"traniandriabarletta":{"$":0},"tranibarlettaandria":{"$":0},"trapani":{"$":0},"trento":{"$":0},"treviso":{"$":0},"trieste":{"$":0},"ts":{"$":0},"turin":{"$":0},"tv":{"$":0},"ud":{"$":0},"udine":{"$":0},"urbino-pesaro":{"$":0},"urbinopesaro":{"$":0},"va":{"$":0},"varese":{"$":0},"vb":{"$":0},"vc":{"$":0},"ve":{"$":0},"venezia":{"$":0},"venice":{"$":0},"verbania":{"$":0},"vercelli":{"$":0},"verona":{"$":0},"vi":{"$":0},"vibo-valentia":{"$":0},"vibovalentia":{"$":0},"vicenza":{"$":0},"viterbo":{"$":0},"vr":{"$":0},"vs":{"$":0},"vt":{"$":0},"vv":{"$":0},"12chars":{"$":0},"ibxos":{"$":0},"iliadboxos":{"$":0},"neen":{"jc":{"$":0}},"123homepage":{"$":0},"16-b":{"$":0},"32-b":{"$":0},"64-b":{"$":0},"myspreadshop":{"$":0},"syncloud":{"$":0}},"je":{"$":0,"co":{"$":0},"net":{"$":0},"org":{"$":0},"of":{"$":0}},"jm":{"*":{"$":0}},"jo":{"$":0,"agri":{"$":0},"ai":{"$":0},"com":{"$":0},"edu":{"$":0},"eng":{"$":0},"fm":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"per":{"$":0},"phd":{"$":0},"sch":{"$":0},"tv":{"$":0}},"jobs":{"$":0},"jp":{"$":0,"ac":{"$":0},"ad":{"$":0},"co":{"$":0},"ed":{"$":0},"go":{"$":0},"gr":{"$":0},"lg":{"$":0},"ne":{"$":0,"aseinet":{"user":{"$":0}},"gehirn":{"$":0},"ivory":{"$":0},"mail-box":{"$":0},"mints":{"$":0},"mokuren":{"$":0},"opal":{"$":0},"sakura":{"$":0},"sumomo":{"$":0},"topaz":{"$":0}},"or":{"$":0},"aichi":{"$":0,"aisai":{"$":0},"ama":{"$":0},"anjo":{"$":0},"asuke":{"$":0},"chiryu":{"$":0},"chita":{"$":0},"fuso":{"$":0},"gamagori":{"$":0},"handa":{"$":0},"hazu":{"$":0},"hekinan":{"$":0},"higashiura":{"$":0},"ichinomiya":{"$":0},"inazawa":{"$":0},"inuyama":{"$":0},"isshiki":{"$":0},"iwakura":{"$":0},"kanie":{"$":0},"kariya":{"$":0},"kasugai":{"$":0},"kira":{"$":0},"kiyosu":{"$":0},"komaki":{"$":0},"konan":{"$":0},"kota":{"$":0},"mihama":{"$":0},"miyoshi":{"$":0},"nishio":{"$":0},"nisshin":{"$":0},"obu":{"$":0},"oguchi":{"$":0},"oharu":{"$":0},"okazaki":{"$":0},"owariasahi":{"$":0},"seto":{"$":0},"shikatsu":{"$":0},"shinshiro":{"$":0},"shitara":{"$":0},"tahara":{"$":0},"takahama":{"$":0},"tobishima":{"$":0},"toei":{"$":0},"togo":{"$":0},"tokai":{"$":0},"tokoname":{"$":0},"toyoake":{"$":0},"toyohashi":{"$":0},"toyokawa":{"$":0},"toyone":{"$":0},"toyota":{"$":0},"tsushima":{"$":0},"yatomi":{"$":0}},"akita":{"$":0,"akita":{"$":0},"daisen":{"$":0},"fujisato":{"$":0},"gojome":{"$":0},"hachirogata":{"$":0},"happou":{"$":0},"higashinaruse":{"$":0},"honjo":{"$":0},"honjyo":{"$":0},"ikawa":{"$":0},"kamikoani":{"$":0},"kamioka":{"$":0},"katagami":{"$":0},"kazuno":{"$":0},"kitaakita":{"$":0},"kosaka":{"$":0},"kyowa":{"$":0},"misato":{"$":0},"mitane":{"$":0},"moriyoshi":{"$":0},"nikaho":{"$":0},"noshiro":{"$":0},"odate":{"$":0},"oga":{"$":0},"ogata":{"$":0},"semboku":{"$":0},"yokote":{"$":0},"yurihonjo":{"$":0}},"aomori":{"$":0,"aomori":{"$":0},"gonohe":{"$":0},"hachinohe":{"$":0},"hashikami":{"$":0},"hiranai":{"$":0},"hirosaki":{"$":0},"itayanagi":{"$":0},"kuroishi":{"$":0},"misawa":{"$":0},"mutsu":{"$":0},"nakadomari":{"$":0},"noheji":{"$":0},"oirase":{"$":0},"owani":{"$":0},"rokunohe":{"$":0},"sannohe":{"$":0},"shichinohe":{"$":0},"shingo":{"$":0},"takko":{"$":0},"towada":{"$":0},"tsugaru":{"$":0},"tsuruta":{"$":0}},"chiba":{"$":0,"abiko":{"$":0},"asahi":{"$":0},"chonan":{"$":0},"chosei":{"$":0},"choshi":{"$":0},"chuo":{"$":0},"funabashi":{"$":0},"futtsu":{"$":0},"hanamigawa":{"$":0},"ichihara":{"$":0},"ichikawa":{"$":0},"ichinomiya":{"$":0},"inzai":{"$":0},"isumi":{"$":0},"kamagaya":{"$":0},"kamogawa":{"$":0},"kashiwa":{"$":0},"katori":{"$":0},"katsuura":{"$":0},"kimitsu":{"$":0},"kisarazu":{"$":0},"kozaki":{"$":0},"kujukuri":{"$":0},"kyonan":{"$":0},"matsudo":{"$":0},"midori":{"$":0},"mihama":{"$":0},"minamiboso":{"$":0},"mobara":{"$":0},"mutsuzawa":{"$":0},"nagara":{"$":0},"nagareyama":{"$":0},"narashino":{"$":0},"narita":{"$":0},"noda":{"$":0},"oamishirasato":{"$":0},"omigawa":{"$":0},"onjuku":{"$":0},"otaki":{"$":0},"sakae":{"$":0},"sakura":{"$":0},"shimofusa":{"$":0},"shirako":{"$":0},"shiroi":{"$":0},"shisui":{"$":0},"sodegaura":{"$":0},"sosa":{"$":0},"tako":{"$":0},"tateyama":{"$":0},"togane":{"$":0},"tohnosho":{"$":0},"tomisato":{"$":0},"urayasu":{"$":0},"yachimata":{"$":0},"yachiyo":{"$":0},"yokaichiba":{"$":0},"yokoshibahikari":{"$":0},"yotsukaido":{"$":0}},"ehime":{"$":0,"ainan":{"$":0},"honai":{"$":0},"ikata":{"$":0},"imabari":{"$":0},"iyo":{"$":0},"kamijima":{"$":0},"kihoku":{"$":0},"kumakogen":{"$":0},"masaki":{"$":0},"matsuno":{"$":0},"matsuyama":{"$":0},"namikata":{"$":0},"niihama":{"$":0},"ozu":{"$":0},"saijo":{"$":0},"seiyo":{"$":0},"shikokuchuo":{"$":0},"tobe":{"$":0},"toon":{"$":0},"uchiko":{"$":0},"uwajima":{"$":0},"yawatahama":{"$":0}},"fukui":{"$":0,"echizen":{"$":0},"eiheiji":{"$":0},"fukui":{"$":0},"ikeda":{"$":0},"katsuyama":{"$":0},"mihama":{"$":0},"minamiechizen":{"$":0},"obama":{"$":0},"ohi":{"$":0},"ono":{"$":0},"sabae":{"$":0},"sakai":{"$":0},"takahama":{"$":0},"tsuruga":{"$":0},"wakasa":{"$":0}},"fukuoka":{"$":0,"ashiya":{"$":0},"buzen":{"$":0},"chikugo":{"$":0},"chikuho":{"$":0},"chikujo":{"$":0},"chikushino":{"$":0},"chikuzen":{"$":0},"chuo":{"$":0},"dazaifu":{"$":0},"fukuchi":{"$":0},"hakata":{"$":0},"higashi":{"$":0},"hirokawa":{"$":0},"hisayama":{"$":0},"iizuka":{"$":0},"inatsuki":{"$":0},"kaho":{"$":0},"kasuga":{"$":0},"kasuya":{"$":0},"kawara":{"$":0},"keisen":{"$":0},"koga":{"$":0},"kurate":{"$":0},"kurogi":{"$":0},"kurume":{"$":0},"minami":{"$":0},"miyako":{"$":0},"miyama":{"$":0},"miyawaka":{"$":0},"mizumaki":{"$":0},"munakata":{"$":0},"nakagawa":{"$":0},"nakama":{"$":0},"nishi":{"$":0},"nogata":{"$":0},"ogori":{"$":0},"okagaki":{"$":0},"okawa":{"$":0},"oki":{"$":0},"omuta":{"$":0},"onga":{"$":0},"onojo":{"$":0},"oto":{"$":0},"saigawa":{"$":0},"sasaguri":{"$":0},"shingu":{"$":0},"shinyoshitomi":{"$":0},"shonai":{"$":0},"soeda":{"$":0},"sue":{"$":0},"tachiarai":{"$":0},"tagawa":{"$":0},"takata":{"$":0},"toho":{"$":0},"toyotsu":{"$":0},"tsuiki":{"$":0},"ukiha":{"$":0},"umi":{"$":0},"usui":{"$":0},"yamada":{"$":0},"yame":{"$":0},"yanagawa":{"$":0},"yukuhashi":{"$":0}},"fukushima":{"$":0,"aizubange":{"$":0},"aizumisato":{"$":0},"aizuwakamatsu":{"$":0},"asakawa":{"$":0},"bandai":{"$":0},"date":{"$":0},"fukushima":{"$":0},"furudono":{"$":0},"futaba":{"$":0},"hanawa":{"$":0},"higashi":{"$":0},"hirata":{"$":0},"hirono":{"$":0},"iitate":{"$":0},"inawashiro":{"$":0},"ishikawa":{"$":0},"iwaki":{"$":0},"izumizaki":{"$":0},"kagamiishi":{"$":0},"kaneyama":{"$":0},"kawamata":{"$":0},"kitakata":{"$":0},"kitashiobara":{"$":0},"koori":{"$":0},"koriyama":{"$":0},"kunimi":{"$":0},"miharu":{"$":0},"mishima":{"$":0},"namie":{"$":0},"nango":{"$":0},"nishiaizu":{"$":0},"nishigo":{"$":0},"okuma":{"$":0},"omotego":{"$":0},"ono":{"$":0},"otama":{"$":0},"samegawa":{"$":0},"shimogo":{"$":0},"shirakawa":{"$":0},"showa":{"$":0},"soma":{"$":0},"sukagawa":{"$":0},"taishin":{"$":0},"tamakawa":{"$":0},"tanagura":{"$":0},"tenei":{"$":0},"yabuki":{"$":0},"yamato":{"$":0},"yamatsuri":{"$":0},"yanaizu":{"$":0},"yugawa":{"$":0}},"gifu":{"$":0,"anpachi":{"$":0},"ena":{"$":0},"gifu":{"$":0},"ginan":{"$":0},"godo":{"$":0},"gujo":{"$":0},"hashima":{"$":0},"hichiso":{"$":0},"hida":{"$":0},"higashishirakawa":{"$":0},"ibigawa":{"$":0},"ikeda":{"$":0},"kakamigahara":{"$":0},"kani":{"$":0},"kasahara":{"$":0},"kasamatsu":{"$":0},"kawaue":{"$":0},"kitagata":{"$":0},"mino":{"$":0},"minokamo":{"$":0},"mitake":{"$":0},"mizunami":{"$":0},"motosu":{"$":0},"nakatsugawa":{"$":0},"ogaki":{"$":0},"sakahogi":{"$":0},"seki":{"$":0},"sekigahara":{"$":0},"shirakawa":{"$":0},"tajimi":{"$":0},"takayama":{"$":0},"tarui":{"$":0},"toki":{"$":0},"tomika":{"$":0},"wanouchi":{"$":0},"yamagata":{"$":0},"yaotsu":{"$":0},"yoro":{"$":0}},"gunma":{"$":0,"annaka":{"$":0},"chiyoda":{"$":0},"fujioka":{"$":0},"higashiagatsuma":{"$":0},"isesaki":{"$":0},"itakura":{"$":0},"kanna":{"$":0},"kanra":{"$":0},"katashina":{"$":0},"kawaba":{"$":0},"kiryu":{"$":0},"kusatsu":{"$":0},"maebashi":{"$":0},"meiwa":{"$":0},"midori":{"$":0},"minakami":{"$":0},"naganohara":{"$":0},"nakanojo":{"$":0},"nanmoku":{"$":0},"numata":{"$":0},"oizumi":{"$":0},"ora":{"$":0},"ota":{"$":0},"shibukawa":{"$":0},"shimonita":{"$":0},"shinto":{"$":0},"showa":{"$":0},"takasaki":{"$":0},"takayama":{"$":0},"tamamura":{"$":0},"tatebayashi":{"$":0},"tomioka":{"$":0},"tsukiyono":{"$":0},"tsumagoi":{"$":0},"ueno":{"$":0},"yoshioka":{"$":0}},"hiroshima":{"$":0,"asaminami":{"$":0},"daiwa":{"$":0},"etajima":{"$":0},"fuchu":{"$":0},"fukuyama":{"$":0},"hatsukaichi":{"$":0},"higashihiroshima":{"$":0},"hongo":{"$":0},"jinsekikogen":{"$":0},"kaita":{"$":0},"kui":{"$":0},"kumano":{"$":0},"kure":{"$":0},"mihara":{"$":0},"miyoshi":{"$":0},"naka":{"$":0},"onomichi":{"$":0},"osakikamijima":{"$":0},"otake":{"$":0},"saka":{"$":0},"sera":{"$":0},"seranishi":{"$":0},"shinichi":{"$":0},"shobara":{"$":0},"takehara":{"$":0}},"hokkaido":{"$":0,"abashiri":{"$":0},"abira":{"$":0},"aibetsu":{"$":0},"akabira":{"$":0},"akkeshi":{"$":0},"asahikawa":{"$":0},"ashibetsu":{"$":0},"ashoro":{"$":0},"assabu":{"$":0},"atsuma":{"$":0},"bibai":{"$":0},"biei":{"$":0},"bifuka":{"$":0},"bihoro":{"$":0},"biratori":{"$":0},"chippubetsu":{"$":0},"chitose":{"$":0},"date":{"$":0},"ebetsu":{"$":0},"embetsu":{"$":0},"eniwa":{"$":0},"erimo":{"$":0},"esan":{"$":0},"esashi":{"$":0},"fukagawa":{"$":0},"fukushima":{"$":0},"furano":{"$":0},"furubira":{"$":0},"haboro":{"$":0},"hakodate":{"$":0},"hamatonbetsu":{"$":0},"hidaka":{"$":0},"higashikagura":{"$":0},"higashikawa":{"$":0},"hiroo":{"$":0},"hokuryu":{"$":0},"hokuto":{"$":0},"honbetsu":{"$":0},"horokanai":{"$":0},"horonobe":{"$":0},"ikeda":{"$":0},"imakane":{"$":0},"ishikari":{"$":0},"iwamizawa":{"$":0},"iwanai":{"$":0},"kamifurano":{"$":0},"kamikawa":{"$":0},"kamishihoro":{"$":0},"kamisunagawa":{"$":0},"kamoenai":{"$":0},"kayabe":{"$":0},"kembuchi":{"$":0},"kikonai":{"$":0},"kimobetsu":{"$":0},"kitahiroshima":{"$":0},"kitami":{"$":0},"kiyosato":{"$":0},"koshimizu":{"$":0},"kunneppu":{"$":0},"kuriyama":{"$":0},"kuromatsunai":{"$":0},"kushiro":{"$":0},"kutchan":{"$":0},"kyowa":{"$":0},"mashike":{"$":0},"matsumae":{"$":0},"mikasa":{"$":0},"minamifurano":{"$":0},"mombetsu":{"$":0},"moseushi":{"$":0},"mukawa":{"$":0},"muroran":{"$":0},"naie":{"$":0},"nakagawa":{"$":0},"nakasatsunai":{"$":0},"nakatombetsu":{"$":0},"nanae":{"$":0},"nanporo":{"$":0},"nayoro":{"$":0},"nemuro":{"$":0},"niikappu":{"$":0},"niki":{"$":0},"nishiokoppe":{"$":0},"noboribetsu":{"$":0},"numata":{"$":0},"obihiro":{"$":0},"obira":{"$":0},"oketo":{"$":0},"okoppe":{"$":0},"otaru":{"$":0},"otobe":{"$":0},"otofuke":{"$":0},"otoineppu":{"$":0},"oumu":{"$":0},"ozora":{"$":0},"pippu":{"$":0},"rankoshi":{"$":0},"rebun":{"$":0},"rikubetsu":{"$":0},"rishiri":{"$":0},"rishirifuji":{"$":0},"saroma":{"$":0},"sarufutsu":{"$":0},"shakotan":{"$":0},"shari":{"$":0},"shibecha":{"$":0},"shibetsu":{"$":0},"shikabe":{"$":0},"shikaoi":{"$":0},"shimamaki":{"$":0},"shimizu":{"$":0},"shimokawa":{"$":0},"shinshinotsu":{"$":0},"shintoku":{"$":0},"shiranuka":{"$":0},"shiraoi":{"$":0},"shiriuchi":{"$":0},"sobetsu":{"$":0},"sunagawa":{"$":0},"taiki":{"$":0},"takasu":{"$":0},"takikawa":{"$":0},"takinoue":{"$":0},"teshikaga":{"$":0},"tobetsu":{"$":0},"tohma":{"$":0},"tomakomai":{"$":0},"tomari":{"$":0},"toya":{"$":0},"toyako":{"$":0},"toyotomi":{"$":0},"toyoura":{"$":0},"tsubetsu":{"$":0},"tsukigata":{"$":0},"urakawa":{"$":0},"urausu":{"$":0},"uryu":{"$":0},"utashinai":{"$":0},"wakkanai":{"$":0},"wassamu":{"$":0},"yakumo":{"$":0},"yoichi":{"$":0}},"hyogo":{"$":0,"aioi":{"$":0},"akashi":{"$":0},"ako":{"$":0},"amagasaki":{"$":0},"aogaki":{"$":0},"asago":{"$":0},"ashiya":{"$":0},"awaji":{"$":0},"fukusaki":{"$":0},"goshiki":{"$":0},"harima":{"$":0},"himeji":{"$":0},"ichikawa":{"$":0},"inagawa":{"$":0},"itami":{"$":0},"kakogawa":{"$":0},"kamigori":{"$":0},"kamikawa":{"$":0},"kasai":{"$":0},"kasuga":{"$":0},"kawanishi":{"$":0},"miki":{"$":0},"minamiawaji":{"$":0},"nishinomiya":{"$":0},"nishiwaki":{"$":0},"ono":{"$":0},"sanda":{"$":0},"sannan":{"$":0},"sasayama":{"$":0},"sayo":{"$":0},"shingu":{"$":0},"shinonsen":{"$":0},"shiso":{"$":0},"sumoto":{"$":0},"taishi":{"$":0},"taka":{"$":0},"takarazuka":{"$":0},"takasago":{"$":0},"takino":{"$":0},"tamba":{"$":0},"tatsuno":{"$":0},"toyooka":{"$":0},"yabu":{"$":0},"yashiro":{"$":0},"yoka":{"$":0},"yokawa":{"$":0}},"ibaraki":{"$":0,"ami":{"$":0},"asahi":{"$":0},"bando":{"$":0},"chikusei":{"$":0},"daigo":{"$":0},"fujishiro":{"$":0},"hitachi":{"$":0},"hitachinaka":{"$":0},"hitachiomiya":{"$":0},"hitachiota":{"$":0},"ibaraki":{"$":0},"ina":{"$":0},"inashiki":{"$":0},"itako":{"$":0},"iwama":{"$":0},"joso":{"$":0},"kamisu":{"$":0},"kasama":{"$":0},"kashima":{"$":0},"kasumigaura":{"$":0},"koga":{"$":0},"miho":{"$":0},"mito":{"$":0},"moriya":{"$":0},"naka":{"$":0},"namegata":{"$":0},"oarai":{"$":0},"ogawa":{"$":0},"omitama":{"$":0},"ryugasaki":{"$":0},"sakai":{"$":0},"sakuragawa":{"$":0},"shimodate":{"$":0},"shimotsuma":{"$":0},"shirosato":{"$":0},"sowa":{"$":0},"suifu":{"$":0},"takahagi":{"$":0},"tamatsukuri":{"$":0},"tokai":{"$":0},"tomobe":{"$":0},"tone":{"$":0},"toride":{"$":0},"tsuchiura":{"$":0},"tsukuba":{"$":0},"uchihara":{"$":0},"ushiku":{"$":0},"yachiyo":{"$":0},"yamagata":{"$":0},"yawara":{"$":0},"yuki":{"$":0}},"ishikawa":{"$":0,"anamizu":{"$":0},"hakui":{"$":0},"hakusan":{"$":0},"kaga":{"$":0},"kahoku":{"$":0},"kanazawa":{"$":0},"kawakita":{"$":0},"komatsu":{"$":0},"nakanoto":{"$":0},"nanao":{"$":0},"nomi":{"$":0},"nonoichi":{"$":0},"noto":{"$":0},"shika":{"$":0},"suzu":{"$":0},"tsubata":{"$":0},"tsurugi":{"$":0},"uchinada":{"$":0},"wajima":{"$":0}},"iwate":{"$":0,"fudai":{"$":0},"fujisawa":{"$":0},"hanamaki":{"$":0},"hiraizumi":{"$":0},"hirono":{"$":0},"ichinohe":{"$":0},"ichinoseki":{"$":0},"iwaizumi":{"$":0},"iwate":{"$":0},"joboji":{"$":0},"kamaishi":{"$":0},"kanegasaki":{"$":0},"karumai":{"$":0},"kawai":{"$":0},"kitakami":{"$":0},"kuji":{"$":0},"kunohe":{"$":0},"kuzumaki":{"$":0},"miyako":{"$":0},"mizusawa":{"$":0},"morioka":{"$":0},"ninohe":{"$":0},"noda":{"$":0},"ofunato":{"$":0},"oshu":{"$":0},"otsuchi":{"$":0},"rikuzentakata":{"$":0},"shiwa":{"$":0},"shizukuishi":{"$":0},"sumita":{"$":0},"tanohata":{"$":0},"tono":{"$":0},"yahaba":{"$":0},"yamada":{"$":0}},"kagawa":{"$":0,"ayagawa":{"$":0},"higashikagawa":{"$":0},"kanonji":{"$":0},"kotohira":{"$":0},"manno":{"$":0},"marugame":{"$":0},"mitoyo":{"$":0},"naoshima":{"$":0},"sanuki":{"$":0},"tadotsu":{"$":0},"takamatsu":{"$":0},"tonosho":{"$":0},"uchinomi":{"$":0},"utazu":{"$":0},"zentsuji":{"$":0}},"kagoshima":{"$":0,"akune":{"$":0},"amami":{"$":0},"hioki":{"$":0},"isa":{"$":0},"isen":{"$":0},"izumi":{"$":0},"kagoshima":{"$":0},"kanoya":{"$":0},"kawanabe":{"$":0},"kinko":{"$":0},"kouyama":{"$":0},"makurazaki":{"$":0},"matsumoto":{"$":0},"minamitane":{"$":0},"nakatane":{"$":0},"nishinoomote":{"$":0},"satsumasendai":{"$":0},"soo":{"$":0},"tarumizu":{"$":0},"yusui":{"$":0}},"kanagawa":{"$":0,"aikawa":{"$":0},"atsugi":{"$":0},"ayase":{"$":0},"chigasaki":{"$":0},"ebina":{"$":0},"fujisawa":{"$":0},"hadano":{"$":0},"hakone":{"$":0},"hiratsuka":{"$":0},"isehara":{"$":0},"kaisei":{"$":0},"kamakura":{"$":0},"kiyokawa":{"$":0},"matsuda":{"$":0},"minamiashigara":{"$":0},"miura":{"$":0},"nakai":{"$":0},"ninomiya":{"$":0},"odawara":{"$":0},"oi":{"$":0},"oiso":{"$":0},"sagamihara":{"$":0},"samukawa":{"$":0},"tsukui":{"$":0},"yamakita":{"$":0},"yamato":{"$":0},"yokosuka":{"$":0},"yugawara":{"$":0},"zama":{"$":0},"zushi":{"$":0}},"kochi":{"$":0,"aki":{"$":0},"geisei":{"$":0},"hidaka":{"$":0},"higashitsuno":{"$":0},"ino":{"$":0},"kagami":{"$":0},"kami":{"$":0},"kitagawa":{"$":0},"kochi":{"$":0},"mihara":{"$":0},"motoyama":{"$":0},"muroto":{"$":0},"nahari":{"$":0},"nakamura":{"$":0},"nankoku":{"$":0},"nishitosa":{"$":0},"niyodogawa":{"$":0},"ochi":{"$":0},"okawa":{"$":0},"otoyo":{"$":0},"otsuki":{"$":0},"sakawa":{"$":0},"sukumo":{"$":0},"susaki":{"$":0},"tosa":{"$":0},"tosashimizu":{"$":0},"toyo":{"$":0},"tsuno":{"$":0},"umaji":{"$":0},"yasuda":{"$":0},"yusuhara":{"$":0}},"kumamoto":{"$":0,"amakusa":{"$":0},"arao":{"$":0},"aso":{"$":0},"choyo":{"$":0},"gyokuto":{"$":0},"kamiamakusa":{"$":0},"kikuchi":{"$":0},"kumamoto":{"$":0},"mashiki":{"$":0},"mifune":{"$":0},"minamata":{"$":0},"minamioguni":{"$":0},"nagasu":{"$":0},"nishihara":{"$":0},"oguni":{"$":0},"ozu":{"$":0},"sumoto":{"$":0},"takamori":{"$":0},"uki":{"$":0},"uto":{"$":0},"yamaga":{"$":0},"yamato":{"$":0},"yatsushiro":{"$":0}},"kyoto":{"$":0,"ayabe":{"$":0},"fukuchiyama":{"$":0},"higashiyama":{"$":0},"ide":{"$":0},"ine":{"$":0},"joyo":{"$":0},"kameoka":{"$":0},"kamo":{"$":0},"kita":{"$":0},"kizu":{"$":0},"kumiyama":{"$":0},"kyotamba":{"$":0},"kyotanabe":{"$":0},"kyotango":{"$":0},"maizuru":{"$":0},"minami":{"$":0},"minamiyamashiro":{"$":0},"miyazu":{"$":0},"muko":{"$":0},"nagaokakyo":{"$":0},"nakagyo":{"$":0},"nantan":{"$":0},"oyamazaki":{"$":0},"sakyo":{"$":0},"seika":{"$":0},"tanabe":{"$":0},"uji":{"$":0},"ujitawara":{"$":0},"wazuka":{"$":0},"yamashina":{"$":0},"yawata":{"$":0}},"mie":{"$":0,"asahi":{"$":0},"inabe":{"$":0},"ise":{"$":0},"kameyama":{"$":0},"kawagoe":{"$":0},"kiho":{"$":0},"kisosaki":{"$":0},"kiwa":{"$":0},"komono":{"$":0},"kumano":{"$":0},"kuwana":{"$":0},"matsusaka":{"$":0},"meiwa":{"$":0},"mihama":{"$":0},"minamiise":{"$":0},"misugi":{"$":0},"miyama":{"$":0},"nabari":{"$":0},"shima":{"$":0},"suzuka":{"$":0},"tado":{"$":0},"taiki":{"$":0},"taki":{"$":0},"tamaki":{"$":0},"toba":{"$":0},"tsu":{"$":0},"udono":{"$":0},"ureshino":{"$":0},"watarai":{"$":0},"yokkaichi":{"$":0}},"miyagi":{"$":0,"furukawa":{"$":0},"higashimatsushima":{"$":0},"ishinomaki":{"$":0},"iwanuma":{"$":0},"kakuda":{"$":0},"kami":{"$":0},"kawasaki":{"$":0},"marumori":{"$":0},"matsushima":{"$":0},"minamisanriku":{"$":0},"misato":{"$":0},"murata":{"$":0},"natori":{"$":0},"ogawara":{"$":0},"ohira":{"$":0},"onagawa":{"$":0},"osaki":{"$":0},"rifu":{"$":0},"semine":{"$":0},"shibata":{"$":0},"shichikashuku":{"$":0},"shikama":{"$":0},"shiogama":{"$":0},"shiroishi":{"$":0},"tagajo":{"$":0},"taiwa":{"$":0},"tome":{"$":0},"tomiya":{"$":0},"wakuya":{"$":0},"watari":{"$":0},"yamamoto":{"$":0},"zao":{"$":0}},"miyazaki":{"$":0,"aya":{"$":0},"ebino":{"$":0},"gokase":{"$":0},"hyuga":{"$":0},"kadogawa":{"$":0},"kawaminami":{"$":0},"kijo":{"$":0},"kitagawa":{"$":0},"kitakata":{"$":0},"kitaura":{"$":0},"kobayashi":{"$":0},"kunitomi":{"$":0},"kushima":{"$":0},"mimata":{"$":0},"miyakonojo":{"$":0},"miyazaki":{"$":0},"morotsuka":{"$":0},"nichinan":{"$":0},"nishimera":{"$":0},"nobeoka":{"$":0},"saito":{"$":0},"shiiba":{"$":0},"shintomi":{"$":0},"takaharu":{"$":0},"takanabe":{"$":0},"takazaki":{"$":0},"tsuno":{"$":0}},"nagano":{"$":0,"achi":{"$":0},"agematsu":{"$":0},"anan":{"$":0},"aoki":{"$":0},"asahi":{"$":0},"azumino":{"$":0},"chikuhoku":{"$":0},"chikuma":{"$":0},"chino":{"$":0},"fujimi":{"$":0},"hakuba":{"$":0},"hara":{"$":0},"hiraya":{"$":0},"iida":{"$":0},"iijima":{"$":0},"iiyama":{"$":0},"iizuna":{"$":0},"ikeda":{"$":0},"ikusaka":{"$":0},"ina":{"$":0},"karuizawa":{"$":0},"kawakami":{"$":0},"kiso":{"$":0},"kisofukushima":{"$":0},"kitaaiki":{"$":0},"komagane":{"$":0},"komoro":{"$":0},"matsukawa":{"$":0},"matsumoto":{"$":0},"miasa":{"$":0},"minamiaiki":{"$":0},"minamimaki":{"$":0},"minamiminowa":{"$":0},"minowa":{"$":0},"miyada":{"$":0},"miyota":{"$":0},"mochizuki":{"$":0},"nagano":{"$":0},"nagawa":{"$":0},"nagiso":{"$":0},"nakagawa":{"$":0},"nakano":{"$":0},"nozawaonsen":{"$":0},"obuse":{"$":0},"ogawa":{"$":0},"okaya":{"$":0},"omachi":{"$":0},"omi":{"$":0},"ookuwa":{"$":0},"ooshika":{"$":0},"otaki":{"$":0},"otari":{"$":0},"sakae":{"$":0},"sakaki":{"$":0},"saku":{"$":0},"sakuho":{"$":0},"shimosuwa":{"$":0},"shinanomachi":{"$":0},"shiojiri":{"$":0},"suwa":{"$":0},"suzaka":{"$":0},"takagi":{"$":0},"takamori":{"$":0},"takayama":{"$":0},"tateshina":{"$":0},"tatsuno":{"$":0},"togakushi":{"$":0},"togura":{"$":0},"tomi":{"$":0},"ueda":{"$":0},"wada":{"$":0},"yamagata":{"$":0},"yamanouchi":{"$":0},"yasaka":{"$":0},"yasuoka":{"$":0}},"nagasaki":{"$":0,"chijiwa":{"$":0},"futsu":{"$":0},"goto":{"$":0},"hasami":{"$":0},"hirado":{"$":0},"iki":{"$":0},"isahaya":{"$":0},"kawatana":{"$":0},"kuchinotsu":{"$":0},"matsuura":{"$":0},"nagasaki":{"$":0},"obama":{"$":0},"omura":{"$":0},"oseto":{"$":0},"saikai":{"$":0},"sasebo":{"$":0},"seihi":{"$":0},"shimabara":{"$":0},"shinkamigoto":{"$":0},"togitsu":{"$":0},"tsushima":{"$":0},"unzen":{"$":0}},"nara":{"$":0,"ando":{"$":0},"gose":{"$":0},"heguri":{"$":0},"higashiyoshino":{"$":0},"ikaruga":{"$":0},"ikoma":{"$":0},"kamikitayama":{"$":0},"kanmaki":{"$":0},"kashiba":{"$":0},"kashihara":{"$":0},"katsuragi":{"$":0},"kawai":{"$":0},"kawakami":{"$":0},"kawanishi":{"$":0},"koryo":{"$":0},"kurotaki":{"$":0},"mitsue":{"$":0},"miyake":{"$":0},"nara":{"$":0},"nosegawa":{"$":0},"oji":{"$":0},"ouda":{"$":0},"oyodo":{"$":0},"sakurai":{"$":0},"sango":{"$":0},"shimoichi":{"$":0},"shimokitayama":{"$":0},"shinjo":{"$":0},"soni":{"$":0},"takatori":{"$":0},"tawaramoto":{"$":0},"tenkawa":{"$":0},"tenri":{"$":0},"uda":{"$":0},"yamatokoriyama":{"$":0},"yamatotakada":{"$":0},"yamazoe":{"$":0},"yoshino":{"$":0}},"niigata":{"$":0,"aga":{"$":0},"agano":{"$":0},"gosen":{"$":0},"itoigawa":{"$":0},"izumozaki":{"$":0},"joetsu":{"$":0},"kamo":{"$":0},"kariwa":{"$":0},"kashiwazaki":{"$":0},"minamiuonuma":{"$":0},"mitsuke":{"$":0},"muika":{"$":0},"murakami":{"$":0},"myoko":{"$":0},"nagaoka":{"$":0},"niigata":{"$":0},"ojiya":{"$":0},"omi":{"$":0},"sado":{"$":0},"sanjo":{"$":0},"seiro":{"$":0},"seirou":{"$":0},"sekikawa":{"$":0},"shibata":{"$":0},"tagami":{"$":0},"tainai":{"$":0},"tochio":{"$":0},"tokamachi":{"$":0},"tsubame":{"$":0},"tsunan":{"$":0},"uonuma":{"$":0},"yahiko":{"$":0},"yoita":{"$":0},"yuzawa":{"$":0}},"oita":{"$":0,"beppu":{"$":0},"bungoono":{"$":0},"bungotakada":{"$":0},"hasama":{"$":0},"hiji":{"$":0},"himeshima":{"$":0},"hita":{"$":0},"kamitsue":{"$":0},"kokonoe":{"$":0},"kuju":{"$":0},"kunisaki":{"$":0},"kusu":{"$":0},"oita":{"$":0},"saiki":{"$":0},"taketa":{"$":0},"tsukumi":{"$":0},"usa":{"$":0},"usuki":{"$":0},"yufu":{"$":0}},"okayama":{"$":0,"akaiwa":{"$":0},"asakuchi":{"$":0},"bizen":{"$":0},"hayashima":{"$":0},"ibara":{"$":0},"kagamino":{"$":0},"kasaoka":{"$":0},"kibichuo":{"$":0},"kumenan":{"$":0},"kurashiki":{"$":0},"maniwa":{"$":0},"misaki":{"$":0},"nagi":{"$":0},"niimi":{"$":0},"nishiawakura":{"$":0},"okayama":{"$":0},"satosho":{"$":0},"setouchi":{"$":0},"shinjo":{"$":0},"shoo":{"$":0},"soja":{"$":0},"takahashi":{"$":0},"tamano":{"$":0},"tsuyama":{"$":0},"wake":{"$":0},"yakage":{"$":0}},"okinawa":{"$":0,"aguni":{"$":0},"ginowan":{"$":0},"ginoza":{"$":0},"gushikami":{"$":0},"haebaru":{"$":0},"higashi":{"$":0},"hirara":{"$":0},"iheya":{"$":0},"ishigaki":{"$":0},"ishikawa":{"$":0},"itoman":{"$":0},"izena":{"$":0},"kadena":{"$":0},"kin":{"$":0},"kitadaito":{"$":0},"kitanakagusuku":{"$":0},"kumejima":{"$":0},"kunigami":{"$":0},"minamidaito":{"$":0},"motobu":{"$":0},"nago":{"$":0},"naha":{"$":0},"nakagusuku":{"$":0},"nakijin":{"$":0},"nanjo":{"$":0},"nishihara":{"$":0},"ogimi":{"$":0},"okinawa":{"$":0},"onna":{"$":0},"shimoji":{"$":0},"taketomi":{"$":0},"tarama":{"$":0},"tokashiki":{"$":0},"tomigusuku":{"$":0},"tonaki":{"$":0},"urasoe":{"$":0},"uruma":{"$":0},"yaese":{"$":0},"yomitan":{"$":0},"yonabaru":{"$":0},"yonaguni":{"$":0},"zamami":{"$":0}},"osaka":{"$":0,"abeno":{"$":0},"chihayaakasaka":{"$":0},"chuo":{"$":0},"daito":{"$":0},"fujiidera":{"$":0},"habikino":{"$":0},"hannan":{"$":0},"higashiosaka":{"$":0},"higashisumiyoshi":{"$":0},"higashiyodogawa":{"$":0},"hirakata":{"$":0},"ibaraki":{"$":0},"ikeda":{"$":0},"izumi":{"$":0},"izumiotsu":{"$":0},"izumisano":{"$":0},"kadoma":{"$":0},"kaizuka":{"$":0},"kanan":{"$":0},"kashiwara":{"$":0},"katano":{"$":0},"kawachinagano":{"$":0},"kishiwada":{"$":0},"kita":{"$":0},"kumatori":{"$":0},"matsubara":{"$":0},"minato":{"$":0},"minoh":{"$":0},"misaki":{"$":0},"moriguchi":{"$":0},"neyagawa":{"$":0},"nishi":{"$":0},"nose":{"$":0},"osakasayama":{"$":0},"sakai":{"$":0},"sayama":{"$":0},"sennan":{"$":0},"settsu":{"$":0},"shijonawate":{"$":0},"shimamoto":{"$":0},"suita":{"$":0},"tadaoka":{"$":0},"taishi":{"$":0},"tajiri":{"$":0},"takaishi":{"$":0},"takatsuki":{"$":0},"tondabayashi":{"$":0},"toyonaka":{"$":0},"toyono":{"$":0},"yao":{"$":0}},"saga":{"$":0,"ariake":{"$":0},"arita":{"$":0},"fukudomi":{"$":0},"genkai":{"$":0},"hamatama":{"$":0},"hizen":{"$":0},"imari":{"$":0},"kamimine":{"$":0},"kanzaki":{"$":0},"karatsu":{"$":0},"kashima":{"$":0},"kitagata":{"$":0},"kitahata":{"$":0},"kiyama":{"$":0},"kouhoku":{"$":0},"kyuragi":{"$":0},"nishiarita":{"$":0},"ogi":{"$":0},"omachi":{"$":0},"ouchi":{"$":0},"saga":{"$":0},"shiroishi":{"$":0},"taku":{"$":0},"tara":{"$":0},"tosu":{"$":0},"yoshinogari":{"$":0}},"saitama":{"$":0,"arakawa":{"$":0},"asaka":{"$":0},"chichibu":{"$":0},"fujimi":{"$":0},"fujimino":{"$":0},"fukaya":{"$":0},"hanno":{"$":0},"hanyu":{"$":0},"hasuda":{"$":0},"hatogaya":{"$":0},"hatoyama":{"$":0},"hidaka":{"$":0},"higashichichibu":{"$":0},"higashimatsuyama":{"$":0},"honjo":{"$":0},"ina":{"$":0},"iruma":{"$":0},"iwatsuki":{"$":0},"kamiizumi":{"$":0},"kamikawa":{"$":0},"kamisato":{"$":0},"kasukabe":{"$":0},"kawagoe":{"$":0},"kawaguchi":{"$":0},"kawajima":{"$":0},"kazo":{"$":0},"kitamoto":{"$":0},"koshigaya":{"$":0},"kounosu":{"$":0},"kuki":{"$":0},"kumagaya":{"$":0},"matsubushi":{"$":0},"minano":{"$":0},"misato":{"$":0},"miyashiro":{"$":0},"miyoshi":{"$":0},"moroyama":{"$":0},"nagatoro":{"$":0},"namegawa":{"$":0},"niiza":{"$":0},"ogano":{"$":0},"ogawa":{"$":0},"ogose":{"$":0},"okegawa":{"$":0},"omiya":{"$":0},"otaki":{"$":0},"ranzan":{"$":0},"ryokami":{"$":0},"saitama":{"$":0},"sakado":{"$":0},"satte":{"$":0},"sayama":{"$":0},"shiki":{"$":0},"shiraoka":{"$":0},"soka":{"$":0},"sugito":{"$":0},"toda":{"$":0},"tokigawa":{"$":0},"tokorozawa":{"$":0},"tsurugashima":{"$":0},"urawa":{"$":0},"warabi":{"$":0},"yashio":{"$":0},"yokoze":{"$":0},"yono":{"$":0},"yorii":{"$":0},"yoshida":{"$":0},"yoshikawa":{"$":0},"yoshimi":{"$":0}},"shiga":{"$":0,"aisho":{"$":0},"gamo":{"$":0},"higashiomi":{"$":0},"hikone":{"$":0},"koka":{"$":0},"konan":{"$":0},"kosei":{"$":0},"koto":{"$":0},"kusatsu":{"$":0},"maibara":{"$":0},"moriyama":{"$":0},"nagahama":{"$":0},"nishiazai":{"$":0},"notogawa":{"$":0},"omihachiman":{"$":0},"otsu":{"$":0},"ritto":{"$":0},"ryuoh":{"$":0},"takashima":{"$":0},"takatsuki":{"$":0},"torahime":{"$":0},"toyosato":{"$":0},"yasu":{"$":0}},"shimane":{"$":0,"akagi":{"$":0},"ama":{"$":0},"gotsu":{"$":0},"hamada":{"$":0},"higashiizumo":{"$":0},"hikawa":{"$":0},"hikimi":{"$":0},"izumo":{"$":0},"kakinoki":{"$":0},"masuda":{"$":0},"matsue":{"$":0},"misato":{"$":0},"nishinoshima":{"$":0},"ohda":{"$":0},"okinoshima":{"$":0},"okuizumo":{"$":0},"shimane":{"$":0},"tamayu":{"$":0},"tsuwano":{"$":0},"unnan":{"$":0},"yakumo":{"$":0},"yasugi":{"$":0},"yatsuka":{"$":0}},"shizuoka":{"$":0,"arai":{"$":0},"atami":{"$":0},"fuji":{"$":0},"fujieda":{"$":0},"fujikawa":{"$":0},"fujinomiya":{"$":0},"fukuroi":{"$":0},"gotemba":{"$":0},"haibara":{"$":0},"hamamatsu":{"$":0},"higashiizu":{"$":0},"ito":{"$":0},"iwata":{"$":0},"izu":{"$":0},"izunokuni":{"$":0},"kakegawa":{"$":0},"kannami":{"$":0},"kawanehon":{"$":0},"kawazu":{"$":0},"kikugawa":{"$":0},"kosai":{"$":0},"makinohara":{"$":0},"matsuzaki":{"$":0},"minamiizu":{"$":0},"mishima":{"$":0},"morimachi":{"$":0},"nishiizu":{"$":0},"numazu":{"$":0},"omaezaki":{"$":0},"shimada":{"$":0},"shimizu":{"$":0},"shimoda":{"$":0},"shizuoka":{"$":0},"susono":{"$":0},"yaizu":{"$":0},"yoshida":{"$":0}},"tochigi":{"$":0,"ashikaga":{"$":0},"bato":{"$":0},"haga":{"$":0},"ichikai":{"$":0},"iwafune":{"$":0},"kaminokawa":{"$":0},"kanuma":{"$":0},"karasuyama":{"$":0},"kuroiso":{"$":0},"mashiko":{"$":0},"mibu":{"$":0},"moka":{"$":0},"motegi":{"$":0},"nasu":{"$":0},"nasushiobara":{"$":0},"nikko":{"$":0},"nishikata":{"$":0},"nogi":{"$":0},"ohira":{"$":0},"ohtawara":{"$":0},"oyama":{"$":0},"sakura":{"$":0},"sano":{"$":0},"shimotsuke":{"$":0},"shioya":{"$":0},"takanezawa":{"$":0},"tochigi":{"$":0},"tsuga":{"$":0},"ujiie":{"$":0},"utsunomiya":{"$":0},"yaita":{"$":0}},"tokushima":{"$":0,"aizumi":{"$":0},"anan":{"$":0},"ichiba":{"$":0},"itano":{"$":0},"kainan":{"$":0},"komatsushima":{"$":0},"matsushige":{"$":0},"mima":{"$":0},"minami":{"$":0},"miyoshi":{"$":0},"mugi":{"$":0},"nakagawa":{"$":0},"naruto":{"$":0},"sanagochi":{"$":0},"shishikui":{"$":0},"tokushima":{"$":0},"wajiki":{"$":0}},"tokyo":{"$":0,"adachi":{"$":0},"akiruno":{"$":0},"akishima":{"$":0},"aogashima":{"$":0},"arakawa":{"$":0},"bunkyo":{"$":0},"chiyoda":{"$":0},"chofu":{"$":0},"chuo":{"$":0},"edogawa":{"$":0},"fuchu":{"$":0},"fussa":{"$":0},"hachijo":{"$":0},"hachioji":{"$":0},"hamura":{"$":0},"higashikurume":{"$":0},"higashimurayama":{"$":0},"higashiyamato":{"$":0},"hino":{"$":0},"hinode":{"$":0},"hinohara":{"$":0},"inagi":{"$":0},"itabashi":{"$":0},"katsushika":{"$":0},"kita":{"$":0},"kiyose":{"$":0},"kodaira":{"$":0},"koganei":{"$":0},"kokubunji":{"$":0},"komae":{"$":0},"koto":{"$":0},"kouzushima":{"$":0},"kunitachi":{"$":0},"machida":{"$":0},"meguro":{"$":0},"minato":{"$":0},"mitaka":{"$":0},"mizuho":{"$":0},"musashimurayama":{"$":0},"musashino":{"$":0},"nakano":{"$":0},"nerima":{"$":0},"ogasawara":{"$":0},"okutama":{"$":0},"ome":{"$":0},"oshima":{"$":0},"ota":{"$":0},"setagaya":{"$":0},"shibuya":{"$":0},"shinagawa":{"$":0},"shinjuku":{"$":0},"suginami":{"$":0},"sumida":{"$":0},"tachikawa":{"$":0},"taito":{"$":0},"tama":{"$":0},"toshima":{"$":0}},"tottori":{"$":0,"chizu":{"$":0},"hino":{"$":0},"kawahara":{"$":0},"koge":{"$":0},"kotoura":{"$":0},"misasa":{"$":0},"nanbu":{"$":0},"nichinan":{"$":0},"sakaiminato":{"$":0},"tottori":{"$":0},"wakasa":{"$":0},"yazu":{"$":0},"yonago":{"$":0}},"toyama":{"$":0,"asahi":{"$":0},"fuchu":{"$":0},"fukumitsu":{"$":0},"funahashi":{"$":0},"himi":{"$":0},"imizu":{"$":0},"inami":{"$":0},"johana":{"$":0},"kamiichi":{"$":0},"kurobe":{"$":0},"nakaniikawa":{"$":0},"namerikawa":{"$":0},"nanto":{"$":0},"nyuzen":{"$":0},"oyabe":{"$":0},"taira":{"$":0},"takaoka":{"$":0},"tateyama":{"$":0},"toga":{"$":0},"tonami":{"$":0},"toyama":{"$":0},"unazuki":{"$":0},"uozu":{"$":0},"yamada":{"$":0}},"wakayama":{"$":0,"arida":{"$":0},"aridagawa":{"$":0},"gobo":{"$":0},"hashimoto":{"$":0},"hidaka":{"$":0},"hirogawa":{"$":0},"inami":{"$":0},"iwade":{"$":0},"kainan":{"$":0},"kamitonda":{"$":0},"katsuragi":{"$":0},"kimino":{"$":0},"kinokawa":{"$":0},"kitayama":{"$":0},"koya":{"$":0},"koza":{"$":0},"kozagawa":{"$":0},"kudoyama":{"$":0},"kushimoto":{"$":0},"mihama":{"$":0},"misato":{"$":0},"nachikatsuura":{"$":0},"shingu":{"$":0},"shirahama":{"$":0},"taiji":{"$":0},"tanabe":{"$":0},"wakayama":{"$":0},"yuasa":{"$":0},"yura":{"$":0}},"yamagata":{"$":0,"asahi":{"$":0},"funagata":{"$":0},"higashine":{"$":0},"iide":{"$":0},"kahoku":{"$":0},"kaminoyama":{"$":0},"kaneyama":{"$":0},"kawanishi":{"$":0},"mamurogawa":{"$":0},"mikawa":{"$":0},"murayama":{"$":0},"nagai":{"$":0},"nakayama":{"$":0},"nanyo":{"$":0},"nishikawa":{"$":0},"obanazawa":{"$":0},"oe":{"$":0},"oguni":{"$":0},"ohkura":{"$":0},"oishida":{"$":0},"sagae":{"$":0},"sakata":{"$":0},"sakegawa":{"$":0},"shinjo":{"$":0},"shirataka":{"$":0},"shonai":{"$":0},"takahata":{"$":0},"tendo":{"$":0},"tozawa":{"$":0},"tsuruoka":{"$":0},"yamagata":{"$":0},"yamanobe":{"$":0},"yonezawa":{"$":0},"yuza":{"$":0}},"yamaguchi":{"$":0,"abu":{"$":0},"hagi":{"$":0},"hikari":{"$":0},"hofu":{"$":0},"iwakuni":{"$":0},"kudamatsu":{"$":0},"mitou":{"$":0},"nagato":{"$":0},"oshima":{"$":0},"shimonoseki":{"$":0},"shunan":{"$":0},"tabuse":{"$":0},"tokuyama":{"$":0},"toyota":{"$":0},"ube":{"$":0},"yuu":{"$":0}},"yamanashi":{"$":0,"chuo":{"$":0},"doshi":{"$":0},"fuefuki":{"$":0},"fujikawa":{"$":0},"fujikawaguchiko":{"$":0},"fujiyoshida":{"$":0},"hayakawa":{"$":0},"hokuto":{"$":0},"ichikawamisato":{"$":0},"kai":{"$":0},"kofu":{"$":0},"koshu":{"$":0},"kosuge":{"$":0},"minami-alps":{"$":0},"minobu":{"$":0},"nakamichi":{"$":0},"nanbu":{"$":0},"narusawa":{"$":0},"nirasaki":{"$":0},"nishikatsura":{"$":0},"oshino":{"$":0},"otsuki":{"$":0},"showa":{"$":0},"tabayama":{"$":0},"tsuru":{"$":0},"uenohara":{"$":0},"yamanakako":{"$":0},"yamanashi":{"$":0}},"xn--ehqz56n":{"$":0},"xn--1lqs03n":{"$":0},"xn--qqqt11m":{"$":0},"xn--f6qx53a":{"$":0},"xn--djrs72d6uy":{"$":0},"xn--mkru45i":{"$":0},"xn--0trq7p7nn":{"$":0},"xn--5js045d":{"$":0},"xn--kbrq7o":{"$":0},"xn--pssu33l":{"$":0},"xn--ntsq17g":{"$":0},"xn--uisz3g":{"$":0},"xn--6btw5a":{"$":0},"xn--1ctwo":{"$":0},"xn--6orx2r":{"$":0},"xn--rht61e":{"$":0},"xn--rht27z":{"$":0},"xn--nit225k":{"$":0},"xn--rht3d":{"$":0},"xn--djty4k":{"$":0},"xn--klty5x":{"$":0},"xn--kltx9a":{"$":0},"xn--kltp7d":{"$":0},"xn--c3s14m":{"$":0},"xn--vgu402c":{"$":0},"xn--efvn9s":{"$":0},"xn--1lqs71d":{"$":0},"xn--4pvxs":{"$":0},"xn--uuwu58a":{"$":0},"xn--zbx025d":{"$":0},"xn--8pvr4u":{"$":0},"xn--5rtp49c":{"$":0},"xn--ntso0iqx3a":{"$":0},"xn--elqq16h":{"$":0},"xn--4it168d":{"$":0},"xn--klt787d":{"$":0},"xn--rny31h":{"$":0},"xn--7t0a264c":{"$":0},"xn--uist22h":{"$":0},"xn--8ltr62k":{"$":0},"xn--2m4a15e":{"$":0},"xn--32vp30h":{"$":0},"xn--4it797k":{"$":0},"xn--5rtq34k":{"$":0},"xn--k7yn95e":{"$":0},"xn--tor131o":{"$":0},"xn--d5qv7z876c":{"$":0},"kawasaki":{"*":{"$":0}},"kitakyushu":{"*":{"$":0}},"kobe":{"*":{"$":0}},"nagoya":{"*":{"$":0}},"sapporo":{"*":{"$":0}},"sendai":{"*":{"$":0}},"yokohama":{"*":{"$":0}},"buyshop":{"$":0},"fashionstore":{"$":0},"handcrafted":{"$":0},"kawaiishop":{"$":0},"supersale":{"$":0},"theshop":{"$":0},"0am":{"$":0},"0g0":{"$":0},"0j0":{"$":0},"0t0":{"$":0},"mydns":{"$":0},"pgw":{"$":0},"wjg":{"$":0},"usercontent":{"$":0},"angry":{"$":0},"babyblue":{"$":0},"babymilk":{"$":0},"backdrop":{"$":0},"bambina":{"$":0},"bitter":{"$":0},"blush":{"$":0},"boo":{"$":0},"boy":{"$":0},"boyfriend":{"$":0},"but":{"$":0},"candypop":{"$":0},"capoo":{"$":0},"catfood":{"$":0},"cheap":{"$":0},"chicappa":{"$":0},"chillout":{"$":0},"chips":{"$":0},"chowder":{"$":0},"chu":{"$":0},"ciao":{"$":0},"cocotte":{"$":0},"coolblog":{"$":0},"cranky":{"$":0},"cutegirl":{"$":0},"daa":{"$":0},"deca":{"$":0},"deci":{"$":0},"digick":{"$":0},"egoism":{"$":0},"fakefur":{"$":0},"fem":{"$":0},"flier":{"$":0},"floppy":{"$":0},"fool":{"$":0},"frenchkiss":{"$":0},"girlfriend":{"$":0},"girly":{"$":0},"gloomy":{"$":0},"gonna":{"$":0},"greater":{"$":0},"hacca":{"$":0},"heavy":{"$":0},"her":{"$":0},"hiho":{"$":0},"hippy":{"$":0},"holy":{"$":0},"hungry":{"$":0},"icurus":{"$":0},"itigo":{"$":0},"jellybean":{"$":0},"kikirara":{"$":0},"kill":{"$":0},"kilo":{"$":0},"kuron":{"$":0},"littlestar":{"$":0},"lolipopmc":{"$":0},"lolitapunk":{"$":0},"lomo":{"$":0},"lovepop":{"$":0},"lovesick":{"$":0},"main":{"$":0},"mods":{"$":0},"mond":{"$":0},"mongolian":{"$":0},"moo":{"$":0},"namaste":{"$":0},"nikita":{"$":0},"nobushi":{"$":0},"noor":{"$":0},"oops":{"$":0},"parallel":{"$":0},"parasite":{"$":0},"pecori":{"$":0},"peewee":{"$":0},"penne":{"$":0},"pepper":{"$":0},"perma":{"$":0},"pigboat":{"$":0},"pinoko":{"$":0},"punyu":{"$":0},"pupu":{"$":0},"pussycat":{"$":0},"pya":{"$":0},"raindrop":{"$":0},"readymade":{"$":0},"sadist":{"$":0},"schoolbus":{"$":0},"secret":{"$":0},"staba":{"$":0},"stripper":{"$":0},"sub":{"$":0},"sunnyday":{"$":0},"thick":{"$":0},"tonkotsu":{"$":0},"under":{"$":0},"upper":{"$":0},"velvet":{"$":0},"verse":{"$":0},"versus":{"$":0},"vivian":{"$":0},"watson":{"$":0},"weblike":{"$":0},"whitesnow":{"$":0},"zombie":{"$":0},"hateblo":{"$":0},"hatenablog":{"$":0},"hatenadiary":{"$":0},"2-d":{"$":0},"bona":{"$":0},"crap":{"$":0},"daynight":{"$":0},"eek":{"$":0},"flop":{"$":0},"halfmoon":{"$":0},"jeez":{"$":0},"matrix":{"$":0},"mimoza":{"$":0},"netgamers":{"$":0},"nyanta":{"$":0},"o0o0":{"$":0},"rdy":{"$":0},"rgr":{"$":0},"rulez":{"$":0},"sakurastorage":{"isk01":{"s3":{"$":0}},"isk02":{"s3":{"$":0}}},"saloon":{"$":0},"sblo":{"$":0},"skr":{"$":0},"tank":{"$":0},"uh-oh":{"$":0},"undo":{"$":0},"webaccel":{"rs":{"$":0},"user":{"$":0}},"websozai":{"$":0},"xii":{"$":0}},"ke":{"$":0,"ac":{"$":0},"co":{"$":0},"go":{"$":0},"info":{"$":0},"me":{"$":0},"mobi":{"$":0},"ne":{"$":0},"or":{"$":0},"sc":{"$":0}},"kg":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"us":{"$":0},"xx":{"$":0}},"kh":{"*":{"$":0}},"ki":{"$":0,"biz":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"net":{"$":0},"org":{"$":0}},"km":{"$":0,"ass":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"nom":{"$":0},"org":{"$":0},"prd":{"$":0},"tm":{"$":0},"asso":{"$":0},"coop":{"$":0},"gouv":{"$":0},"medecin":{"$":0},"notaires":{"$":0},"pharmaciens":{"$":0},"presse":{"$":0},"veterinaire":{"$":0}},"kn":{"$":0,"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"kp":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"org":{"$":0},"rep":{"$":0},"tra":{"$":0}},"kr":{"$":0,"ac":{"$":0},"ai":{"$":0},"co":{"$":0},"es":{"$":0},"go":{"$":0},"hs":{"$":0},"io":{"$":0},"it":{"$":0},"kg":{"$":0},"me":{"$":0},"mil":{"$":0},"ms":{"$":0},"ne":{"$":0},"or":{"$":0},"pe":{"$":0},"re":{"$":0},"sc":{"$":0},"busan":{"$":0},"chungbuk":{"$":0},"chungnam":{"$":0},"daegu":{"$":0},"daejeon":{"$":0},"gangwon":{"$":0},"gwangju":{"$":0},"gyeongbuk":{"$":0},"gyeonggi":{"$":0},"gyeongnam":{"$":0},"incheon":{"$":0},"jeju":{"$":0},"jeonbuk":{"$":0},"jeonnam":{"$":0},"seoul":{"$":0},"ulsan":{"$":0},"c01":{"$":0},"eliv-cdn":{"$":0},"eliv-dns":{"$":0},"mmv":{"$":0},"vki":{"$":0}},"kw":{"$":0,"com":{"$":0},"edu":{"$":0},"emb":{"$":0},"gov":{"$":0},"ind":{"$":0},"net":{"$":0},"org":{"$":0}},"ky":{"$":0,"com":{"$":0},"edu":{"$":0},"net":{"$":0},"org":{"$":0}},"kz":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"jcloud":{"$":0}},"la":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"int":{"$":0},"net":{"$":0},"org":{"$":0},"per":{"$":0},"bnr":{"$":0}},"lb":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"lc":{"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"oy":{"$":0}},"li":{"$":0},"lk":{"$":0,"ac":{"$":0},"assn":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"grp":{"$":0},"hotel":{"$":0},"int":{"$":0},"ltd":{"$":0},"net":{"$":0},"ngo":{"$":0},"org":{"$":0},"sch":{"$":0},"soc":{"$":0},"web":{"$":0}},"lr":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"ls":{"$":0,"ac":{"$":0},"biz":{"$":0},"co":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"net":{"$":0},"org":{"$":0},"sc":{"$":0}},"lt":{"$":0,"gov":{"$":0}},"lu":{"$":0,"123website":{"$":0}},"lv":{"$":0,"asn":{"$":0},"com":{"$":0},"conf":{"$":0},"edu":{"$":0},"gov":{"$":0},"id":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"ly":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"id":{"$":0},"med":{"$":0},"net":{"$":0},"org":{"$":0},"plc":{"$":0},"sch":{"$":0}},"ma":{"$":0,"ac":{"$":0},"co":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"press":{"$":0}},"mc":{"$":0,"asso":{"$":0},"tm":{"$":0}},"md":{"$":0,"ir":{"$":0}},"me":{"$":0,"ac":{"$":0},"co":{"$":0},"edu":{"$":0},"gov":{"$":0},"its":{"$":0},"net":{"$":0},"org":{"$":0},"priv":{"$":0},"c66":{"$":0},"craft":{"$":0},"edgestack":{"$":0},"filegear":{"$":0},"glitch":{"$":0},"filegear-sg":{"$":0},"lohmus":{"$":0},"barsy":{"$":0},"mcdir":{"$":0},"brasilia":{"$":0},"ddns":{"$":0},"dnsfor":{"$":0},"hopto":{"$":0},"loginto":{"$":0},"noip":{"$":0},"webhop":{"$":0},"soundcast":{"$":0},"tcp4":{"$":0},"vp4":{"$":0},"diskstation":{"$":0},"dscloud":{"$":0},"i234":{"$":0},"myds":{"$":0},"synology":{"$":0},"transip":{"site":{"$":0}},"nohost":{"$":0}},"mg":{"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"nom":{"$":0},"org":{"$":0},"prd":{"$":0}},"mh":{"$":0},"mil":{"$":0},"mk":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"inf":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0}},"ml":{"$":0,"ac":{"$":0},"art":{"$":0},"asso":{"$":0},"com":{"$":0},"edu":{"$":0},"gouv":{"$":0},"gov":{"$":0},"info":{"$":0},"inst":{"$":0},"net":{"$":0},"org":{"$":0},"pr":{"$":0},"presse":{"$":0}},"mm":{"*":{"$":0}},"mn":{"$":0,"edu":{"$":0},"gov":{"$":0},"org":{"$":0},"nyc":{"$":0}},"mo":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"mobi":{"$":0,"barsy":{"$":0},"dscloud":{"$":0}},"mp":{"$":0,"ju":{"$":0}},"mq":{"$":0},"mr":{"$":0,"gov":{"$":0}},"ms":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"minisite":{"$":0}},"mt":{"$":0,"com":{"$":0},"edu":{"$":0},"net":{"$":0},"org":{"$":0}},"mu":{"$":0,"ac":{"$":0},"co":{"$":0},"com":{"$":0},"gov":{"$":0},"net":{"$":0},"or":{"$":0},"org":{"$":0}},"museum":{"$":0},"mv":{"$":0,"aero":{"$":0},"biz":{"$":0},"com":{"$":0},"coop":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"int":{"$":0},"mil":{"$":0},"museum":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"pro":{"$":0}},"mw":{"$":0,"ac":{"$":0},"biz":{"$":0},"co":{"$":0},"com":{"$":0},"coop":{"$":0},"edu":{"$":0},"gov":{"$":0},"int":{"$":0},"net":{"$":0},"org":{"$":0}},"mx":{"$":0,"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"net":{"$":0},"org":{"$":0}},"my":{"$":0,"biz":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0}},"mz":{"$":0,"ac":{"$":0},"adv":{"$":0},"co":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"na":{"$":0,"alt":{"$":0},"co":{"$":0},"com":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"name":{"$":0,"her":{"forgot":{"$":0}},"his":{"forgot":{"$":0}}},"nc":{"$":0,"asso":{"$":0},"nom":{"$":0}},"ne":{"$":0},"net":{"$":0,"adobeaemcloud":{"$":0},"adobeio-static":{"$":0},"adobeioruntime":{"$":0},"akadns":{"$":0},"akamai":{"$":0},"akamai-staging":{"$":0},"akamaiedge":{"$":0},"akamaiedge-staging":{"$":0},"akamaihd":{"$":0},"akamaihd-staging":{"$":0},"akamaiorigin":{"$":0},"akamaiorigin-staging":{"$":0},"akamaized":{"$":0},"akamaized-staging":{"$":0},"edgekey":{"$":0},"edgekey-staging":{"$":0},"edgesuite":{"$":0},"edgesuite-staging":{"$":0},"alwaysdata":{"$":0},"myamaze":{"$":0},"cloudfront":{"$":0},"appudo":{"$":0},"atlassian-dev":{"prod":{"cdn":{"$":0}}},"myfritz":{"$":0},"onavstack":{"$":0},"shopselect":{"$":0},"blackbaudcdn":{"$":0},"boomla":{"$":0},"bplaced":{"$":0},"square7":{"$":0},"cdn77":{"r":{"$":0}},"cdn77-ssl":{"$":0},"gb":{"$":0},"hu":{"$":0},"jp":{"$":0},"se":{"$":0},"uk":{"$":0},"clickrising":{"$":0},"ddns-ip":{"$":0},"dns-cloud":{"$":0},"dns-dynamic":{"$":0},"cloudaccess":{"$":0},"cloudflare":{"$":0,"cdn":{"$":0}},"cloudflareanycast":{"cdn":{"$":0}},"cloudflarecn":{"cdn":{"$":0}},"cloudflareglobal":{"cdn":{"$":0}},"ctfcloud":{"$":0},"feste-ip":{"$":0},"knx-server":{"$":0},"static-access":{"$":0},"cryptonomic":{"*":{"$":0}},"dattolocal":{"$":0},"mydatto":{"$":0},"debian":{"$":0},"definima":{"$":0},"deno":{"$":0},"at-band-camp":{"$":0},"blogdns":{"$":0},"broke-it":{"$":0},"buyshouses":{"$":0},"dnsalias":{"$":0},"dnsdojo":{"$":0},"does-it":{"$":0},"dontexist":{"$":0},"dynalias":{"$":0},"dynathome":{"$":0},"endofinternet":{"$":0},"from-az":{"$":0},"from-co":{"$":0},"from-la":{"$":0},"from-ny":{"$":0},"gets-it":{"$":0},"ham-radio-op":{"$":0},"homeftp":{"$":0},"homeip":{"$":0},"homelinux":{"$":0},"homeunix":{"$":0},"in-the-band":{"$":0},"is-a-chef":{"$":0},"is-a-geek":{"$":0},"isa-geek":{"$":0},"kicks-ass":{"$":0},"office-on-the":{"$":0},"podzone":{"$":0},"scrapper-site":{"$":0},"selfip":{"$":0},"sells-it":{"$":0},"servebbs":{"$":0},"serveftp":{"$":0},"thruhere":{"$":0},"webhop":{"$":0},"casacam":{"$":0},"dynu":{"$":0},"dynv6":{"$":0},"twmail":{"$":0},"ru":{"$":0},"channelsdvr":{"$":0,"u":{"$":0}},"fastly":{"freetls":{"$":0},"map":{"$":0},"prod":{"a":{"$":0},"global":{"$":0}},"ssl":{"a":{"$":0},"b":{"$":0},"global":{"$":0}}},"fastlylb":{"$":0,"map":{"$":0}},"edgeapp":{"$":0},"keyword-on":{"$":0},"live-on":{"$":0},"server-on":{"$":0},"cdn-edges":{"$":0},"heteml":{"$":0},"cloudfunctions":{"$":0},"grafana-dev":{"$":0},"iobb":{"$":0},"moonscale":{"$":0},"in-dsl":{"$":0},"in-vpn":{"$":0},"oninferno":{"$":0},"botdash":{"$":0},"apps-1and1":{"$":0},"ipifony":{"$":0},"cloudjiffy":{"$":0,"fra1-de":{"$":0},"west1-us":{"$":0}},"elastx":{"jls-sto1":{"$":0},"jls-sto2":{"$":0},"jls-sto3":{"$":0}},"massivegrid":{"paas":{"fr-1":{"$":0},"lon-1":{"$":0},"lon-2":{"$":0},"ny-1":{"$":0},"ny-2":{"$":0},"sg-1":{"$":0}}},"saveincloud":{"jelastic":{"$":0},"nordeste-idc":{"$":0}},"scaleforce":{"j":{"$":0}},"kinghost":{"$":0},"uni5":{"$":0},"krellian":{"$":0},"ggff":{"$":0},"localcert":{"$":0},"localto":{"*":{"$":0}},"barsy":{"$":0},"luyani":{"$":0},"memset":{"$":0},"azure-api":{"$":0},"azure-mobile":{"$":0},"azureedge":{"$":0},"azurefd":{"$":0},"azurestaticapps":{"1":{"$":0},"2":{"$":0},"3":{"$":0},"4":{"$":0},"5":{"$":0},"6":{"$":0},"7":{"$":0},"$":0,"centralus":{"$":0},"eastasia":{"$":0},"eastus2":{"$":0},"westeurope":{"$":0},"westus2":{"$":0}},"azurewebsites":{"$":0},"cloudapp":{"$":0},"trafficmanager":{"$":0},"windows":{"core":{"blob":{"$":0}},"servicebus":{"$":0}},"mynetname":{"sn":{"$":0}},"routingthecloud":{"$":0},"bounceme":{"$":0},"ddns":{"$":0},"eating-organic":{"$":0},"mydissent":{"$":0},"myeffect":{"$":0},"mymediapc":{"$":0},"mypsx":{"$":0},"mysecuritycamera":{"$":0},"nhlfan":{"$":0},"no-ip":{"$":0},"pgafan":{"$":0},"privatizehealthinsurance":{"$":0},"redirectme":{"$":0},"serveblog":{"$":0},"serveminecraft":{"$":0},"sytes":{"$":0},"dnsup":{"$":0},"hicam":{"$":0},"now-dns":{"$":0},"ownip":{"$":0},"vpndns":{"$":0},"cloudycluster":{"$":0},"ovh":{"hosting":{"*":{"$":0}},"webpaas":{"*":{"$":0}}},"rackmaze":{"$":0},"myradweb":{"$":0},"in":{"$":0},"subsc-pay":{"$":0},"squares":{"$":0},"schokokeks":{"$":0},"firewall-gateway":{"$":0},"seidat":{"$":0},"senseering":{"$":0},"siteleaf":{"$":0},"mafelo":{"$":0},"myspreadshop":{"$":0},"vps-host":{"$":0,"jelastic":{"atl":{"$":0},"njs":{"$":0},"ric":{"$":0}}},"srcf":{"soc":{"$":0},"user":{"$":0}},"supabase":{"$":0},"dsmynas":{"$":0},"familyds":{"$":0},"ts":{"$":0,"c":{"*":{"$":0}}},"torproject":{"$":0,"pages":{"$":0}},"vusercontent":{"$":0},"reserve-online":{"$":0},"community-pro":{"$":0},"meinforum":{"$":0},"yandexcloud":{"$":0,"storage":{"$":0},"website":{"$":0}},"za":{"$":0}},"nf":{"$":0,"arts":{"$":0},"com":{"$":0},"firm":{"$":0},"info":{"$":0},"net":{"$":0},"other":{"$":0},"per":{"$":0},"rec":{"$":0},"store":{"$":0},"web":{"$":0}},"ng":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"i":{"$":0},"mil":{"$":0},"mobi":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"sch":{"$":0},"biz":{"$":0,"co":{"$":0},"dl":{"$":0},"go":{"$":0},"lg":{"$":0},"on":{"$":0}},"col":{"$":0},"firm":{"$":0},"gen":{"$":0},"ltd":{"$":0},"ngo":{"$":0},"plc":{"$":0}},"ni":{"$":0,"ac":{"$":0},"biz":{"$":0},"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"in":{"$":0},"info":{"$":0},"int":{"$":0},"mil":{"$":0},"net":{"$":0},"nom":{"$":0},"org":{"$":0},"web":{"$":0}},"nl":{"$":0,"co":{"$":0},"hosting-cluster":{"$":0},"gov":{"$":0},"khplay":{"$":0},"123website":{"$":0},"myspreadshop":{"$":0},"transurl":{"*":{"$":0}},"cistron":{"$":0},"demon":{"$":0}},"no":{"$":0,"fhs":{"$":0},"folkebibl":{"$":0},"fylkesbibl":{"$":0},"idrett":{"$":0},"museum":{"$":0},"priv":{"$":0},"vgs":{"$":0},"dep":{"$":0},"herad":{"$":0},"kommune":{"$":0},"mil":{"$":0},"stat":{"$":0},"aa":{"$":0,"gs":{"$":0}},"ah":{"$":0,"gs":{"$":0}},"bu":{"$":0,"gs":{"$":0}},"fm":{"$":0,"gs":{"$":0}},"hl":{"$":0,"gs":{"$":0}},"hm":{"$":0,"gs":{"$":0}},"jan-mayen":{"$":0,"gs":{"$":0}},"mr":{"$":0,"gs":{"$":0}},"nl":{"$":0,"gs":{"$":0}},"nt":{"$":0,"gs":{"$":0}},"of":{"$":0,"gs":{"$":0}},"ol":{"$":0,"gs":{"$":0}},"oslo":{"$":0,"gs":{"$":0}},"rl":{"$":0,"gs":{"$":0}},"sf":{"$":0,"gs":{"$":0}},"st":{"$":0,"gs":{"$":0}},"svalbard":{"$":0,"gs":{"$":0}},"tm":{"$":0,"gs":{"$":0}},"tr":{"$":0,"gs":{"$":0}},"va":{"$":0,"gs":{"$":0}},"vf":{"$":0,"gs":{"$":0}},"akrehamn":{"$":0},"xn--krehamn-dxa":{"$":0},"algard":{"$":0},"xn--lgrd-poac":{"$":0},"arna":{"$":0},"bronnoysund":{"$":0},"xn--brnnysund-m8ac":{"$":0},"brumunddal":{"$":0},"bryne":{"$":0},"drobak":{"$":0},"xn--drbak-wua":{"$":0},"egersund":{"$":0},"fetsund":{"$":0},"floro":{"$":0},"xn--flor-jra":{"$":0},"fredrikstad":{"$":0},"hokksund":{"$":0},"honefoss":{"$":0},"xn--hnefoss-q1a":{"$":0},"jessheim":{"$":0},"jorpeland":{"$":0},"xn--jrpeland-54a":{"$":0},"kirkenes":{"$":0},"kopervik":{"$":0},"krokstadelva":{"$":0},"langevag":{"$":0},"xn--langevg-jxa":{"$":0},"leirvik":{"$":0},"mjondalen":{"$":0},"xn--mjndalen-64a":{"$":0},"mo-i-rana":{"$":0},"mosjoen":{"$":0},"xn--mosjen-eya":{"$":0},"nesoddtangen":{"$":0},"orkanger":{"$":0},"osoyro":{"$":0},"xn--osyro-wua":{"$":0},"raholt":{"$":0},"xn--rholt-mra":{"$":0},"sandnessjoen":{"$":0},"xn--sandnessjen-ogb":{"$":0},"skedsmokorset":{"$":0},"slattum":{"$":0},"spjelkavik":{"$":0},"stathelle":{"$":0},"stavern":{"$":0},"stjordalshalsen":{"$":0},"xn--stjrdalshalsen-sqb":{"$":0},"tananger":{"$":0},"tranby":{"$":0},"vossevangen":{"$":0},"aarborte":{"$":0},"aejrie":{"$":0},"afjord":{"$":0},"xn--fjord-lra":{"$":0},"agdenes":{"$":0},"akershus":{"nes":{"$":0}},"aknoluokta":{"$":0},"xn--koluokta-7ya57h":{"$":0},"al":{"$":0},"xn--l-1fa":{"$":0},"alaheadju":{"$":0},"xn--laheadju-7ya":{"$":0},"alesund":{"$":0},"xn--lesund-hua":{"$":0},"alstahaug":{"$":0},"alta":{"$":0},"xn--lt-liac":{"$":0},"alvdal":{"$":0},"amli":{"$":0},"xn--mli-tla":{"$":0},"amot":{"$":0},"xn--mot-tla":{"$":0},"andasuolo":{"$":0},"andebu":{"$":0},"andoy":{"$":0},"xn--andy-ira":{"$":0},"ardal":{"$":0},"xn--rdal-poa":{"$":0},"aremark":{"$":0},"arendal":{"$":0},"xn--s-1fa":{"$":0},"aseral":{"$":0},"xn--seral-lra":{"$":0},"asker":{"$":0},"askim":{"$":0},"askoy":{"$":0},"xn--asky-ira":{"$":0},"askvoll":{"$":0},"asnes":{"$":0},"xn--snes-poa":{"$":0},"audnedaln":{"$":0},"aukra":{"$":0},"aure":{"$":0},"aurland":{"$":0},"aurskog-holand":{"$":0},"xn--aurskog-hland-jnb":{"$":0},"austevoll":{"$":0},"austrheim":{"$":0},"averoy":{"$":0},"xn--avery-yua":{"$":0},"badaddja":{"$":0},"xn--bdddj-mrabd":{"$":0},"xn--brum-voa":{"$":0},"bahcavuotna":{"$":0},"xn--bhcavuotna-s4a":{"$":0},"bahccavuotna":{"$":0},"xn--bhccavuotna-k7a":{"$":0},"baidar":{"$":0},"xn--bidr-5nac":{"$":0},"bajddar":{"$":0},"xn--bjddar-pta":{"$":0},"balat":{"$":0},"xn--blt-elab":{"$":0},"balestrand":{"$":0},"ballangen":{"$":0},"balsfjord":{"$":0},"bamble":{"$":0},"bardu":{"$":0},"barum":{"$":0},"batsfjord":{"$":0},"xn--btsfjord-9za":{"$":0},"bearalvahki":{"$":0},"xn--bearalvhki-y4a":{"$":0},"beardu":{"$":0},"beiarn":{"$":0},"berg":{"$":0},"bergen":{"$":0},"berlevag":{"$":0},"xn--berlevg-jxa":{"$":0},"bievat":{"$":0},"xn--bievt-0qa":{"$":0},"bindal":{"$":0},"birkenes":{"$":0},"bjarkoy":{"$":0},"xn--bjarky-fya":{"$":0},"bjerkreim":{"$":0},"bjugn":{"$":0},"bodo":{"$":0},"xn--bod-2na":{"$":0},"bokn":{"$":0},"bomlo":{"$":0},"xn--bmlo-gra":{"$":0},"bremanger":{"$":0},"bronnoy":{"$":0},"xn--brnny-wuac":{"$":0},"budejju":{"$":0},"buskerud":{"nes":{"$":0}},"bygland":{"$":0},"bykle":{"$":0},"cahcesuolo":{"$":0},"xn--hcesuolo-7ya35b":{"$":0},"davvenjarga":{"$":0},"xn--davvenjrga-y4a":{"$":0},"davvesiida":{"$":0},"deatnu":{"$":0},"dielddanuorri":{"$":0},"divtasvuodna":{"$":0},"divttasvuotna":{"$":0},"donna":{"$":0},"xn--dnna-gra":{"$":0},"dovre":{"$":0},"drammen":{"$":0},"drangedal":{"$":0},"dyroy":{"$":0},"xn--dyry-ira":{"$":0},"eid":{"$":0},"eidfjord":{"$":0},"eidsberg":{"$":0},"eidskog":{"$":0},"eidsvoll":{"$":0},"eigersund":{"$":0},"elverum":{"$":0},"enebakk":{"$":0},"engerdal":{"$":0},"etne":{"$":0},"etnedal":{"$":0},"evenassi":{"$":0},"xn--eveni-0qa01ga":{"$":0},"evenes":{"$":0},"evje-og-hornnes":{"$":0},"farsund":{"$":0},"fauske":{"$":0},"fedje":{"$":0},"fet":{"$":0},"finnoy":{"$":0},"xn--finny-yua":{"$":0},"fitjar":{"$":0},"fjaler":{"$":0},"fjell":{"$":0},"fla":{"$":0},"xn--fl-zia":{"$":0},"flakstad":{"$":0},"flatanger":{"$":0},"flekkefjord":{"$":0},"flesberg":{"$":0},"flora":{"$":0},"folldal":{"$":0},"forde":{"$":0},"xn--frde-gra":{"$":0},"forsand":{"$":0},"fosnes":{"$":0},"xn--frna-woa":{"$":0},"frana":{"$":0},"frei":{"$":0},"frogn":{"$":0},"froland":{"$":0},"frosta":{"$":0},"froya":{"$":0},"xn--frya-hra":{"$":0},"fuoisku":{"$":0},"fuossko":{"$":0},"fusa":{"$":0},"fyresdal":{"$":0},"gaivuotna":{"$":0},"xn--givuotna-8ya":{"$":0},"galsa":{"$":0},"xn--gls-elac":{"$":0},"gamvik":{"$":0},"gangaviika":{"$":0},"xn--ggaviika-8ya47h":{"$":0},"gaular":{"$":0},"gausdal":{"$":0},"giehtavuoatna":{"$":0},"gildeskal":{"$":0},"xn--gildeskl-g0a":{"$":0},"giske":{"$":0},"gjemnes":{"$":0},"gjerdrum":{"$":0},"gjerstad":{"$":0},"gjesdal":{"$":0},"gjovik":{"$":0},"xn--gjvik-wua":{"$":0},"gloppen":{"$":0},"gol":{"$":0},"gran":{"$":0},"grane":{"$":0},"granvin":{"$":0},"gratangen":{"$":0},"grimstad":{"$":0},"grong":{"$":0},"grue":{"$":0},"gulen":{"$":0},"guovdageaidnu":{"$":0},"ha":{"$":0},"xn--h-2fa":{"$":0},"habmer":{"$":0},"xn--hbmer-xqa":{"$":0},"hadsel":{"$":0},"xn--hgebostad-g3a":{"$":0},"hagebostad":{"$":0},"halden":{"$":0},"halsa":{"$":0},"hamar":{"$":0},"hamaroy":{"$":0},"hammarfeasta":{"$":0},"xn--hmmrfeasta-s4ac":{"$":0},"hammerfest":{"$":0},"hapmir":{"$":0},"xn--hpmir-xqa":{"$":0},"haram":{"$":0},"hareid":{"$":0},"harstad":{"$":0},"hasvik":{"$":0},"hattfjelldal":{"$":0},"haugesund":{"$":0},"hedmark":{"os":{"$":0},"valer":{"$":0},"xn--vler-qoa":{"$":0}},"hemne":{"$":0},"hemnes":{"$":0},"hemsedal":{"$":0},"hitra":{"$":0},"hjartdal":{"$":0},"hjelmeland":{"$":0},"hobol":{"$":0},"xn--hobl-ira":{"$":0},"hof":{"$":0},"hol":{"$":0},"hole":{"$":0},"holmestrand":{"$":0},"holtalen":{"$":0},"xn--holtlen-hxa":{"$":0},"hordaland":{"os":{"$":0}},"hornindal":{"$":0},"horten":{"$":0},"hoyanger":{"$":0},"xn--hyanger-q1a":{"$":0},"hoylandet":{"$":0},"xn--hylandet-54a":{"$":0},"hurdal":{"$":0},"hurum":{"$":0},"hvaler":{"$":0},"hyllestad":{"$":0},"ibestad":{"$":0},"inderoy":{"$":0},"xn--indery-fya":{"$":0},"iveland":{"$":0},"ivgu":{"$":0},"jevnaker":{"$":0},"jolster":{"$":0},"xn--jlster-bya":{"$":0},"jondal":{"$":0},"kafjord":{"$":0},"xn--kfjord-iua":{"$":0},"karasjohka":{"$":0},"xn--krjohka-hwab49j":{"$":0},"karasjok":{"$":0},"karlsoy":{"$":0},"karmoy":{"$":0},"xn--karmy-yua":{"$":0},"kautokeino":{"$":0},"klabu":{"$":0},"xn--klbu-woa":{"$":0},"klepp":{"$":0},"kongsberg":{"$":0},"kongsvinger":{"$":0},"kraanghke":{"$":0},"xn--kranghke-b0a":{"$":0},"kragero":{"$":0},"xn--krager-gya":{"$":0},"kristiansand":{"$":0},"kristiansund":{"$":0},"krodsherad":{"$":0},"xn--krdsherad-m8a":{"$":0},"xn--kvfjord-nxa":{"$":0},"xn--kvnangen-k0a":{"$":0},"kvafjord":{"$":0},"kvalsund":{"$":0},"kvam":{"$":0},"kvanangen":{"$":0},"kvinesdal":{"$":0},"kvinnherad":{"$":0},"kviteseid":{"$":0},"kvitsoy":{"$":0},"xn--kvitsy-fya":{"$":0},"laakesvuemie":{"$":0},"xn--lrdal-sra":{"$":0},"lahppi":{"$":0},"xn--lhppi-xqa":{"$":0},"lardal":{"$":0},"larvik":{"$":0},"lavagis":{"$":0},"lavangen":{"$":0},"leangaviika":{"$":0},"xn--leagaviika-52b":{"$":0},"lebesby":{"$":0},"leikanger":{"$":0},"leirfjord":{"$":0},"leka":{"$":0},"leksvik":{"$":0},"lenvik":{"$":0},"lerdal":{"$":0},"lesja":{"$":0},"levanger":{"$":0},"lier":{"$":0},"lierne":{"$":0},"lillehammer":{"$":0},"lillesand":{"$":0},"lindas":{"$":0},"xn--linds-pra":{"$":0},"lindesnes":{"$":0},"loabat":{"$":0},"xn--loabt-0qa":{"$":0},"lodingen":{"$":0},"xn--ldingen-q1a":{"$":0},"lom":{"$":0},"loppa":{"$":0},"lorenskog":{"$":0},"xn--lrenskog-54a":{"$":0},"loten":{"$":0},"xn--lten-gra":{"$":0},"lund":{"$":0},"lunner":{"$":0},"luroy":{"$":0},"xn--lury-ira":{"$":0},"luster":{"$":0},"lyngdal":{"$":0},"lyngen":{"$":0},"malatvuopmi":{"$":0},"xn--mlatvuopmi-s4a":{"$":0},"malselv":{"$":0},"xn--mlselv-iua":{"$":0},"malvik":{"$":0},"mandal":{"$":0},"marker":{"$":0},"marnardal":{"$":0},"masfjorden":{"$":0},"masoy":{"$":0},"xn--msy-ula0h":{"$":0},"matta-varjjat":{"$":0},"xn--mtta-vrjjat-k7af":{"$":0},"meland":{"$":0},"meldal":{"$":0},"melhus":{"$":0},"meloy":{"$":0},"xn--mely-ira":{"$":0},"meraker":{"$":0},"xn--merker-kua":{"$":0},"midsund":{"$":0},"midtre-gauldal":{"$":0},"moareke":{"$":0},"xn--moreke-jua":{"$":0},"modalen":{"$":0},"modum":{"$":0},"molde":{"$":0},"more-og-romsdal":{"heroy":{"$":0},"sande":{"$":0}},"xn--mre-og-romsdal-qqb":{"xn--hery-ira":{"$":0},"sande":{"$":0}},"moskenes":{"$":0},"moss":{"$":0},"mosvik":{"$":0},"muosat":{"$":0},"xn--muost-0qa":{"$":0},"naamesjevuemie":{"$":0},"xn--nmesjevuemie-tcba":{"$":0},"xn--nry-yla5g":{"$":0},"namdalseid":{"$":0},"namsos":{"$":0},"namsskogan":{"$":0},"nannestad":{"$":0},"naroy":{"$":0},"narviika":{"$":0},"narvik":{"$":0},"naustdal":{"$":0},"navuotna":{"$":0},"xn--nvuotna-hwa":{"$":0},"nedre-eiker":{"$":0},"nesna":{"$":0},"nesodden":{"$":0},"nesseby":{"$":0},"nesset":{"$":0},"nissedal":{"$":0},"nittedal":{"$":0},"nord-aurdal":{"$":0},"nord-fron":{"$":0},"nord-odal":{"$":0},"norddal":{"$":0},"nordkapp":{"$":0},"nordland":{"bo":{"$":0},"xn--b-5ga":{"$":0},"heroy":{"$":0},"xn--hery-ira":{"$":0}},"nordre-land":{"$":0},"nordreisa":{"$":0},"nore-og-uvdal":{"$":0},"notodden":{"$":0},"notteroy":{"$":0},"xn--nttery-byae":{"$":0},"odda":{"$":0},"oksnes":{"$":0},"xn--ksnes-uua":{"$":0},"omasvuotna":{"$":0},"oppdal":{"$":0},"oppegard":{"$":0},"xn--oppegrd-ixa":{"$":0},"orkdal":{"$":0},"orland":{"$":0},"xn--rland-uua":{"$":0},"orskog":{"$":0},"xn--rskog-uua":{"$":0},"orsta":{"$":0},"xn--rsta-fra":{"$":0},"osen":{"$":0},"osteroy":{"$":0},"xn--ostery-fya":{"$":0},"ostfold":{"valer":{"$":0}},"xn--stfold-9xa":{"xn--vler-qoa":{"$":0}},"ostre-toten":{"$":0},"xn--stre-toten-zcb":{"$":0},"overhalla":{"$":0},"ovre-eiker":{"$":0},"xn--vre-eiker-k8a":{"$":0},"oyer":{"$":0},"xn--yer-zna":{"$":0},"oygarden":{"$":0},"xn--ygarden-p1a":{"$":0},"oystre-slidre":{"$":0},"xn--ystre-slidre-ujb":{"$":0},"porsanger":{"$":0},"porsangu":{"$":0},"xn--porsgu-sta26f":{"$":0},"porsgrunn":{"$":0},"rade":{"$":0},"xn--rde-ula":{"$":0},"radoy":{"$":0},"xn--rady-ira":{"$":0},"xn--rlingen-mxa":{"$":0},"rahkkeravju":{"$":0},"xn--rhkkervju-01af":{"$":0},"raisa":{"$":0},"xn--risa-5na":{"$":0},"rakkestad":{"$":0},"ralingen":{"$":0},"rana":{"$":0},"randaberg":{"$":0},"rauma":{"$":0},"rendalen":{"$":0},"rennebu":{"$":0},"rennesoy":{"$":0},"xn--rennesy-v1a":{"$":0},"rindal":{"$":0},"ringebu":{"$":0},"ringerike":{"$":0},"ringsaker":{"$":0},"risor":{"$":0},"xn--risr-ira":{"$":0},"rissa":{"$":0},"roan":{"$":0},"rodoy":{"$":0},"xn--rdy-0nab":{"$":0},"rollag":{"$":0},"romsa":{"$":0},"romskog":{"$":0},"xn--rmskog-bya":{"$":0},"roros":{"$":0},"xn--rros-gra":{"$":0},"rost":{"$":0},"xn--rst-0na":{"$":0},"royken":{"$":0},"xn--ryken-vua":{"$":0},"royrvik":{"$":0},"xn--ryrvik-bya":{"$":0},"ruovat":{"$":0},"rygge":{"$":0},"salangen":{"$":0},"salat":{"$":0},"xn--slat-5na":{"$":0},"xn--slt-elab":{"$":0},"saltdal":{"$":0},"samnanger":{"$":0},"sandefjord":{"$":0},"sandnes":{"$":0},"sandoy":{"$":0},"xn--sandy-yua":{"$":0},"sarpsborg":{"$":0},"sauda":{"$":0},"sauherad":{"$":0},"sel":{"$":0},"selbu":{"$":0},"selje":{"$":0},"seljord":{"$":0},"siellak":{"$":0},"sigdal":{"$":0},"siljan":{"$":0},"sirdal":{"$":0},"skanit":{"$":0},"xn--sknit-yqa":{"$":0},"skanland":{"$":0},"xn--sknland-fxa":{"$":0},"skaun":{"$":0},"skedsmo":{"$":0},"ski":{"$":0},"skien":{"$":0},"skierva":{"$":0},"xn--skierv-uta":{"$":0},"skiptvet":{"$":0},"skjak":{"$":0},"xn--skjk-soa":{"$":0},"skjervoy":{"$":0},"xn--skjervy-v1a":{"$":0},"skodje":{"$":0},"smola":{"$":0},"xn--smla-hra":{"$":0},"snaase":{"$":0},"xn--snase-nra":{"$":0},"snasa":{"$":0},"xn--snsa-roa":{"$":0},"snillfjord":{"$":0},"snoasa":{"$":0},"sogndal":{"$":0},"sogne":{"$":0},"xn--sgne-gra":{"$":0},"sokndal":{"$":0},"sola":{"$":0},"solund":{"$":0},"somna":{"$":0},"xn--smna-gra":{"$":0},"sondre-land":{"$":0},"xn--sndre-land-0cb":{"$":0},"songdalen":{"$":0},"sor-aurdal":{"$":0},"xn--sr-aurdal-l8a":{"$":0},"sor-fron":{"$":0},"xn--sr-fron-q1a":{"$":0},"sor-odal":{"$":0},"xn--sr-odal-q1a":{"$":0},"sor-varanger":{"$":0},"xn--sr-varanger-ggb":{"$":0},"sorfold":{"$":0},"xn--srfold-bya":{"$":0},"sorreisa":{"$":0},"xn--srreisa-q1a":{"$":0},"sortland":{"$":0},"sorum":{"$":0},"xn--srum-gra":{"$":0},"spydeberg":{"$":0},"stange":{"$":0},"stavanger":{"$":0},"steigen":{"$":0},"steinkjer":{"$":0},"stjordal":{"$":0},"xn--stjrdal-s1a":{"$":0},"stokke":{"$":0},"stor-elvdal":{"$":0},"stord":{"$":0},"stordal":{"$":0},"storfjord":{"$":0},"strand":{"$":0},"stranda":{"$":0},"stryn":{"$":0},"sula":{"$":0},"suldal":{"$":0},"sund":{"$":0},"sunndal":{"$":0},"surnadal":{"$":0},"sveio":{"$":0},"svelvik":{"$":0},"sykkylven":{"$":0},"tana":{"$":0},"telemark":{"bo":{"$":0},"xn--b-5ga":{"$":0}},"time":{"$":0},"tingvoll":{"$":0},"tinn":{"$":0},"tjeldsund":{"$":0},"tjome":{"$":0},"xn--tjme-hra":{"$":0},"tokke":{"$":0},"tolga":{"$":0},"tonsberg":{"$":0},"xn--tnsberg-q1a":{"$":0},"torsken":{"$":0},"xn--trna-woa":{"$":0},"trana":{"$":0},"tranoy":{"$":0},"xn--trany-yua":{"$":0},"troandin":{"$":0},"trogstad":{"$":0},"xn--trgstad-r1a":{"$":0},"tromsa":{"$":0},"tromso":{"$":0},"xn--troms-zua":{"$":0},"trondheim":{"$":0},"trysil":{"$":0},"tvedestrand":{"$":0},"tydal":{"$":0},"tynset":{"$":0},"tysfjord":{"$":0},"tysnes":{"$":0},"xn--tysvr-vra":{"$":0},"tysvar":{"$":0},"ullensaker":{"$":0},"ullensvang":{"$":0},"ulvik":{"$":0},"unjarga":{"$":0},"xn--unjrga-rta":{"$":0},"utsira":{"$":0},"vaapste":{"$":0},"vadso":{"$":0},"xn--vads-jra":{"$":0},"xn--vry-yla5g":{"$":0},"vaga":{"$":0},"xn--vg-yiab":{"$":0},"vagan":{"$":0},"xn--vgan-qoa":{"$":0},"vagsoy":{"$":0},"xn--vgsy-qoa0j":{"$":0},"vaksdal":{"$":0},"valle":{"$":0},"vang":{"$":0},"vanylven":{"$":0},"vardo":{"$":0},"xn--vard-jra":{"$":0},"varggat":{"$":0},"xn--vrggt-xqad":{"$":0},"varoy":{"$":0},"vefsn":{"$":0},"vega":{"$":0},"vegarshei":{"$":0},"xn--vegrshei-c0a":{"$":0},"vennesla":{"$":0},"verdal":{"$":0},"verran":{"$":0},"vestby":{"$":0},"vestfold":{"sande":{"$":0}},"vestnes":{"$":0},"vestre-slidre":{"$":0},"vestre-toten":{"$":0},"vestvagoy":{"$":0},"xn--vestvgy-ixa6o":{"$":0},"vevelstad":{"$":0},"vik":{"$":0},"vikna":{"$":0},"vindafjord":{"$":0},"voagat":{"$":0},"volda":{"$":0},"voss":{"$":0},"co":{"$":0},"123hjemmeside":{"$":0},"myspreadshop":{"$":0}},"np":{"*":{"$":0}},"nr":{"$":0,"biz":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"net":{"$":0},"org":{"$":0}},"nu":{"$":0,"merseine":{"$":0},"mine":{"$":0},"shacknet":{"$":0},"enterprisecloud":{"$":0}},"nz":{"$":0,"ac":{"$":0},"co":{"$":0},"cri":{"$":0},"geek":{"$":0},"gen":{"$":0},"govt":{"$":0},"health":{"$":0},"iwi":{"$":0},"kiwi":{"$":0},"maori":{"$":0},"xn--mori-qsa":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"parliament":{"$":0},"school":{"$":0},"cloudns":{"$":0}},"om":{"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"med":{"$":0},"museum":{"$":0},"net":{"$":0},"org":{"$":0},"pro":{"$":0}},"onion":{"$":0},"org":{"$":0,"altervista":{"$":0},"pimienta":{"$":0},"poivron":{"$":0},"potager":{"$":0},"sweetpepper":{"$":0},"cdn77":{"c":{"$":0},"rsc":{"$":0}},"cdn77-secure":{"origin":{"ssl":{"$":0}}},"ae":{"$":0},"cloudns":{"$":0},"ip-dynamic":{"$":0},"ddnss":{"$":0},"dpdns":{"$":0},"duckdns":{"$":0},"tunk":{"$":0},"blogdns":{"$":0},"blogsite":{"$":0},"boldlygoingnowhere":{"$":0},"dnsalias":{"$":0},"dnsdojo":{"$":0},"doesntexist":{"$":0},"dontexist":{"$":0},"doomdns":{"$":0},"dvrdns":{"$":0},"dynalias":{"$":0},"dyndns":{"$":0,"go":{"$":0},"home":{"$":0}},"endofinternet":{"$":0},"endoftheinternet":{"$":0},"from-me":{"$":0},"game-host":{"$":0},"gotdns":{"$":0},"hobby-site":{"$":0},"homedns":{"$":0},"homeftp":{"$":0},"homelinux":{"$":0},"homeunix":{"$":0},"is-a-bruinsfan":{"$":0},"is-a-candidate":{"$":0},"is-a-celticsfan":{"$":0},"is-a-chef":{"$":0},"is-a-geek":{"$":0},"is-a-knight":{"$":0},"is-a-linux-user":{"$":0},"is-a-patsfan":{"$":0},"is-a-soxfan":{"$":0},"is-found":{"$":0},"is-lost":{"$":0},"is-saved":{"$":0},"is-very-bad":{"$":0},"is-very-evil":{"$":0},"is-very-good":{"$":0},"is-very-nice":{"$":0},"is-very-sweet":{"$":0},"isa-geek":{"$":0},"kicks-ass":{"$":0},"misconfused":{"$":0},"podzone":{"$":0},"readmyblog":{"$":0},"selfip":{"$":0},"sellsyourhome":{"$":0},"servebbs":{"$":0},"serveftp":{"$":0},"servegame":{"$":0},"stuff-4-sale":{"$":0},"webhop":{"$":0},"accesscam":{"$":0},"camdvr":{"$":0},"freeddns":{"$":0},"mywire":{"$":0},"webredirect":{"$":0},"twmail":{"$":0},"eu":{"$":0,"al":{"$":0},"asso":{"$":0},"at":{"$":0},"au":{"$":0},"be":{"$":0},"bg":{"$":0},"ca":{"$":0},"cd":{"$":0},"ch":{"$":0},"cn":{"$":0},"cy":{"$":0},"cz":{"$":0},"de":{"$":0},"dk":{"$":0},"edu":{"$":0},"ee":{"$":0},"es":{"$":0},"fi":{"$":0},"fr":{"$":0},"gr":{"$":0},"hr":{"$":0},"hu":{"$":0},"ie":{"$":0},"il":{"$":0},"in":{"$":0},"int":{"$":0},"is":{"$":0},"it":{"$":0},"jp":{"$":0},"kr":{"$":0},"lt":{"$":0},"lu":{"$":0},"lv":{"$":0},"me":{"$":0},"mk":{"$":0},"mt":{"$":0},"my":{"$":0},"net":{"$":0},"ng":{"$":0},"nl":{"$":0},"no":{"$":0},"nz":{"$":0},"pl":{"$":0},"pt":{"$":0},"ro":{"$":0},"ru":{"$":0},"se":{"$":0},"si":{"$":0},"sk":{"$":0},"tr":{"$":0},"uk":{"$":0},"us":{"$":0}},"fedorainfracloud":{"$":0},"fedorapeople":{"$":0},"fedoraproject":{"cloud":{"$":0},"os":{"app":{"$":0}},"stg":{"os":{"app":{"$":0}}}},"freedesktop":{"$":0},"hatenadiary":{"$":0},"hepforge":{"$":0},"in-dsl":{"$":0},"in-vpn":{"$":0},"js":{"$":0},"barsy":{"$":0},"mayfirst":{"$":0},"routingthecloud":{"$":0},"bmoattachments":{"$":0},"cable-modem":{"$":0},"collegefan":{"$":0},"couchpotatofries":{"$":0},"hopto":{"$":0},"mlbfan":{"$":0},"myftp":{"$":0},"mysecuritycamera":{"$":0},"nflfan":{"$":0},"no-ip":{"$":0},"read-books":{"$":0},"ufcfan":{"$":0},"zapto":{"$":0},"dynserv":{"$":0},"now-dns":{"$":0},"is-local":{"$":0},"httpbin":{"$":0},"pubtls":{"$":0},"jpn":{"$":0},"my-firewall":{"$":0},"myfirewall":{"$":0},"spdns":{"$":0},"small-web":{"$":0},"dsmynas":{"$":0},"familyds":{"$":0},"teckids":{"s3":{"$":0}},"tuxfamily":{"$":0},"diskstation":{"$":0},"hk":{"$":0},"us":{"$":0},"toolforge":{"$":0},"wmcloud":{"$":0},"wmflabs":{"$":0},"za":{"$":0}},"pa":{"$":0,"abo":{"$":0},"ac":{"$":0},"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"ing":{"$":0},"med":{"$":0},"net":{"$":0},"nom":{"$":0},"org":{"$":0},"sld":{"$":0}},"pe":{"$":0,"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"mil":{"$":0},"net":{"$":0},"nom":{"$":0},"org":{"$":0}},"pf":{"$":0,"com":{"$":0},"edu":{"$":0},"org":{"$":0}},"pg":{"*":{"$":0}},"ph":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"i":{"$":0},"mil":{"$":0},"net":{"$":0},"ngo":{"$":0},"org":{"$":0},"cloudns":{"$":0}},"pk":{"$":0,"ac":{"$":0},"biz":{"$":0},"com":{"$":0},"edu":{"$":0},"fam":{"$":0},"gkp":{"$":0},"gob":{"$":0},"gog":{"$":0},"gok":{"$":0},"gop":{"$":0},"gos":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"web":{"$":0}},"pl":{"$":0,"com":{"$":0},"net":{"$":0},"org":{"$":0},"agro":{"$":0},"aid":{"$":0},"atm":{"$":0},"auto":{"$":0},"biz":{"$":0},"edu":{"$":0},"gmina":{"$":0},"gsm":{"$":0},"info":{"$":0},"mail":{"$":0},"media":{"$":0},"miasta":{"$":0},"mil":{"$":0},"nieruchomosci":{"$":0},"nom":{"$":0},"pc":{"$":0},"powiat":{"$":0},"priv":{"$":0},"realestate":{"$":0},"rel":{"$":0},"sex":{"$":0},"shop":{"$":0},"sklep":{"$":0},"sos":{"$":0},"szkola":{"$":0},"targi":{"$":0},"tm":{"$":0},"tourism":{"$":0},"travel":{"$":0},"turystyka":{"$":0},"gov":{"$":0,"ap":{"$":0},"griw":{"$":0},"ic":{"$":0},"is":{"$":0},"kmpsp":{"$":0},"konsulat":{"$":0},"kppsp":{"$":0},"kwp":{"$":0},"kwpsp":{"$":0},"mup":{"$":0},"mw":{"$":0},"oia":{"$":0},"oirm":{"$":0},"oke":{"$":0},"oow":{"$":0},"oschr":{"$":0},"oum":{"$":0},"pa":{"$":0},"pinb":{"$":0},"piw":{"$":0},"po":{"$":0},"pr":{"$":0},"psp":{"$":0},"psse":{"$":0},"pup":{"$":0},"rzgw":{"$":0},"sa":{"$":0},"sdn":{"$":0},"sko":{"$":0},"so":{"$":0},"sr":{"$":0},"starostwo":{"$":0},"ug":{"$":0},"ugim":{"$":0},"um":{"$":0},"umig":{"$":0},"upow":{"$":0},"uppo":{"$":0},"us":{"$":0},"uw":{"$":0},"uzs":{"$":0},"wif":{"$":0},"wiih":{"$":0},"winb":{"$":0},"wios":{"$":0},"witd":{"$":0},"wiw":{"$":0},"wkz":{"$":0},"wsa":{"$":0},"wskr":{"$":0},"wsse":{"$":0},"wuoz":{"$":0},"wzmiuw":{"$":0},"zp":{"$":0},"zpisdn":{"$":0}},"augustow":{"$":0},"babia-gora":{"$":0},"bedzin":{"$":0},"beskidy":{"$":0},"bialowieza":{"$":0},"bialystok":{"$":0},"bielawa":{"$":0},"bieszczady":{"$":0},"boleslawiec":{"$":0},"bydgoszcz":{"$":0},"bytom":{"$":0},"cieszyn":{"$":0},"czeladz":{"$":0},"czest":{"$":0},"dlugoleka":{"$":0},"elblag":{"$":0},"elk":{"$":0},"glogow":{"$":0},"gniezno":{"$":0},"gorlice":{"$":0},"grajewo":{"$":0},"ilawa":{"$":0},"jaworzno":{"$":0},"jelenia-gora":{"$":0},"jgora":{"$":0},"kalisz":{"$":0},"karpacz":{"$":0},"kartuzy":{"$":0},"kaszuby":{"$":0},"katowice":{"$":0},"kazimierz-dolny":{"$":0},"kepno":{"$":0},"ketrzyn":{"$":0},"klodzko":{"$":0},"kobierzyce":{"$":0},"kolobrzeg":{"$":0},"konin":{"$":0},"konskowola":{"$":0},"kutno":{"$":0},"lapy":{"$":0},"lebork":{"$":0},"legnica":{"$":0},"lezajsk":{"$":0},"limanowa":{"$":0},"lomza":{"$":0},"lowicz":{"$":0},"lubin":{"$":0},"lukow":{"$":0},"malbork":{"$":0},"malopolska":{"$":0},"mazowsze":{"$":0},"mazury":{"$":0},"mielec":{"$":0},"mielno":{"$":0},"mragowo":{"$":0},"naklo":{"$":0},"nowaruda":{"$":0},"nysa":{"$":0},"olawa":{"$":0},"olecko":{"$":0},"olkusz":{"$":0},"olsztyn":{"$":0},"opoczno":{"$":0},"opole":{"$":0},"ostroda":{"$":0},"ostroleka":{"$":0},"ostrowiec":{"$":0},"ostrowwlkp":{"$":0},"pila":{"$":0},"pisz":{"$":0},"podhale":{"$":0},"podlasie":{"$":0},"polkowice":{"$":0},"pomorskie":{"$":0},"pomorze":{"$":0},"prochowice":{"$":0},"pruszkow":{"$":0},"przeworsk":{"$":0},"pulawy":{"$":0},"radom":{"$":0},"rawa-maz":{"$":0},"rybnik":{"$":0},"rzeszow":{"$":0},"sanok":{"$":0},"sejny":{"$":0},"skoczow":{"$":0},"slask":{"$":0},"slupsk":{"$":0},"sosnowiec":{"$":0},"stalowa-wola":{"$":0},"starachowice":{"$":0},"stargard":{"$":0},"suwalki":{"$":0},"swidnica":{"$":0},"swiebodzin":{"$":0},"swinoujscie":{"$":0},"szczecin":{"$":0},"szczytno":{"$":0},"tarnobrzeg":{"$":0},"tgory":{"$":0},"turek":{"$":0},"tychy":{"$":0},"ustka":{"$":0},"walbrzych":{"$":0},"warmia":{"$":0},"warszawa":{"$":0},"waw":{"$":0},"wegrow":{"$":0},"wielun":{"$":0},"wlocl":{"$":0},"wloclawek":{"$":0},"wodzislaw":{"$":0},"wolomin":{"$":0},"wroclaw":{"$":0},"zachpomor":{"$":0},"zagan":{"$":0},"zarow":{"$":0},"zgora":{"$":0},"zgorzelec":{"$":0},"art":{"$":0},"gliwice":{"$":0},"krakow":{"$":0},"poznan":{"$":0},"wroc":{"$":0},"zakopane":{"$":0},"beep":{"$":0},"ecommerce-shop":{"$":0},"cfolks":{"$":0},"dfirma":{"$":0},"dkonto":{"$":0},"you2":{"$":0},"shoparena":{"$":0},"homesklep":{"$":0},"sdscloud":{"$":0},"unicloud":{"$":0},"lodz":{"$":0},"pabianice":{"$":0},"plock":{"$":0},"sieradz":{"$":0},"skierniewice":{"$":0},"zgierz":{"$":0},"krasnik":{"$":0},"leczna":{"$":0},"lubartow":{"$":0},"lublin":{"$":0},"poniatowa":{"$":0},"swidnik":{"$":0},"co":{"$":0},"torun":{"$":0},"simplesite":{"$":0},"myspreadshop":{"$":0},"gda":{"$":0},"gdansk":{"$":0},"gdynia":{"$":0},"med":{"$":0},"sopot":{"$":0},"bielsko":{"$":0}},"pm":{"$":0,"own":{"$":0},"name":{"$":0}},"pn":{"$":0,"co":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"post":{"$":0},"pr":{"$":0,"biz":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"isla":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"pro":{"$":0},"ac":{"$":0},"est":{"$":0},"prof":{"$":0}},"pro":{"$":0,"aaa":{"$":0},"aca":{"$":0},"acct":{"$":0},"avocat":{"$":0},"bar":{"$":0},"cpa":{"$":0},"eng":{"$":0},"jur":{"$":0},"law":{"$":0},"med":{"$":0},"recht":{"$":0},"12chars":{"$":0},"cloudns":{"$":0},"barsy":{"$":0},"ngrok":{"$":0}},"ps":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"plo":{"$":0},"sec":{"$":0}},"pt":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"int":{"$":0},"net":{"$":0},"nome":{"$":0},"org":{"$":0},"publ":{"$":0},"123paginaweb":{"$":0}},"pw":{"$":0,"gov":{"$":0},"cloudns":{"$":0},"x443":{"$":0}},"py":{"$":0,"com":{"$":0},"coop":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"qa":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"sch":{"$":0}},"re":{"$":0,"asso":{"$":0},"com":{"$":0},"netlib":{"$":0},"can":{"$":0}},"ro":{"$":0,"arts":{"$":0},"com":{"$":0},"firm":{"$":0},"info":{"$":0},"nom":{"$":0},"nt":{"$":0},"org":{"$":0},"rec":{"$":0},"store":{"$":0},"tm":{"$":0},"www":{"$":0},"co":{"$":0},"shop":{"$":0},"barsy":{"$":0}},"rs":{"$":0,"ac":{"$":0},"co":{"$":0},"edu":{"$":0},"gov":{"$":0},"in":{"$":0},"org":{"$":0},"brendly":{"shop":{"$":0}},"barsy":{"$":0},"ox":{"$":0}},"ru":{"$":0,"ac":{"$":0},"edu":{"$":0},"gov":{"$":0},"int":{"$":0},"mil":{"$":0},"eurodir":{"$":0},"adygeya":{"$":0},"bashkiria":{"$":0},"bir":{"$":0},"cbg":{"$":0},"com":{"$":0},"dagestan":{"$":0},"grozny":{"$":0},"kalmykia":{"$":0},"kustanai":{"$":0},"marine":{"$":0},"mordovia":{"$":0},"msk":{"$":0},"mytis":{"$":0},"nalchik":{"$":0},"nov":{"$":0},"pyatigorsk":{"$":0},"spb":{"$":0},"vladikavkaz":{"$":0},"vladimir":{"$":0},"na4u":{"$":0},"mircloud":{"$":0},"myjino":{"$":0,"hosting":{"*":{"$":0}},"landing":{"*":{"$":0}},"spectrum":{"*":{"$":0}},"vps":{"*":{"$":0}}},"cldmail":{"hb":{"$":0}},"mcdir":{"$":0,"vps":{"$":0}},"mcpre":{"$":0},"net":{"$":0},"org":{"$":0},"pp":{"$":0},"lk3":{"$":0},"ras":{"$":0}},"rw":{"$":0,"ac":{"$":0},"co":{"$":0},"coop":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"sa":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"med":{"$":0},"net":{"$":0},"org":{"$":0},"pub":{"$":0},"sch":{"$":0}},"sb":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"sc":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"sd":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"med":{"$":0},"net":{"$":0},"org":{"$":0},"tv":{"$":0}},"se":{"$":0,"a":{"$":0},"ac":{"$":0},"b":{"$":0},"bd":{"$":0},"brand":{"$":0},"c":{"$":0},"d":{"$":0},"e":{"$":0},"f":{"$":0},"fh":{"$":0},"fhsk":{"$":0},"fhv":{"$":0},"g":{"$":0},"h":{"$":0},"i":{"$":0},"k":{"$":0},"komforb":{"$":0},"kommunalforbund":{"$":0},"komvux":{"$":0},"l":{"$":0},"lanbib":{"$":0},"m":{"$":0},"n":{"$":0},"naturbruksgymn":{"$":0},"o":{"$":0},"org":{"$":0},"p":{"$":0},"parti":{"$":0},"pp":{"$":0},"press":{"$":0},"r":{"$":0},"s":{"$":0},"t":{"$":0},"tm":{"$":0},"u":{"$":0},"w":{"$":0},"x":{"$":0},"y":{"$":0},"z":{"$":0},"com":{"$":0},"iopsys":{"$":0},"123minsida":{"$":0},"itcouldbewor":{"$":0},"myspreadshop":{"$":0}},"sg":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"enscaled":{"$":0}},"sh":{"$":0,"com":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"hashbang":{"$":0},"botda":{"$":0},"platform":{"ent":{"$":0},"eu":{"$":0},"us":{"$":0}},"now":{"$":0}},"si":{"$":0,"f5":{"$":0},"gitapp":{"$":0},"gitpage":{"$":0}},"sj":{"$":0},"sk":{"$":0},"sl":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0}},"sm":{"$":0},"sn":{"$":0,"art":{"$":0},"com":{"$":0},"edu":{"$":0},"gouv":{"$":0},"org":{"$":0},"perso":{"$":0},"univ":{"$":0}},"so":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"me":{"$":0},"net":{"$":0},"org":{"$":0},"surveys":{"$":0}},"sr":{"$":0},"ss":{"$":0,"biz":{"$":0},"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"me":{"$":0},"net":{"$":0},"org":{"$":0},"sch":{"$":0}},"st":{"$":0,"co":{"$":0},"com":{"$":0},"consulado":{"$":0},"edu":{"$":0},"embaixada":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"principe":{"$":0},"saotome":{"$":0},"store":{"$":0},"helioho":{"$":0},"kirara":{"$":0},"noho":{"$":0}},"su":{"$":0,"abkhazia":{"$":0},"adygeya":{"$":0},"aktyubinsk":{"$":0},"arkhangelsk":{"$":0},"armenia":{"$":0},"ashgabad":{"$":0},"azerbaijan":{"$":0},"balashov":{"$":0},"bashkiria":{"$":0},"bryansk":{"$":0},"bukhara":{"$":0},"chimkent":{"$":0},"dagestan":{"$":0},"east-kazakhstan":{"$":0},"exnet":{"$":0},"georgia":{"$":0},"grozny":{"$":0},"ivanovo":{"$":0},"jambyl":{"$":0},"kalmykia":{"$":0},"kaluga":{"$":0},"karacol":{"$":0},"karaganda":{"$":0},"karelia":{"$":0},"khakassia":{"$":0},"krasnodar":{"$":0},"kurgan":{"$":0},"kustanai":{"$":0},"lenug":{"$":0},"mangyshlak":{"$":0},"mordovia":{"$":0},"msk":{"$":0},"murmansk":{"$":0},"nalchik":{"$":0},"navoi":{"$":0},"north-kazakhstan":{"$":0},"nov":{"$":0},"obninsk":{"$":0},"penza":{"$":0},"pokrovsk":{"$":0},"sochi":{"$":0},"spb":{"$":0},"tashkent":{"$":0},"termez":{"$":0},"togliatti":{"$":0},"troitsk":{"$":0},"tselinograd":{"$":0},"tula":{"$":0},"tuva":{"$":0},"vladikavkaz":{"$":0},"vladimir":{"$":0},"vologda":{"$":0}},"sv":{"$":0,"com":{"$":0},"edu":{"$":0},"gob":{"$":0},"org":{"$":0},"red":{"$":0}},"sx":{"$":0,"gov":{"$":0}},"sy":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"sz":{"$":0,"ac":{"$":0},"co":{"$":0},"org":{"$":0}},"tc":{"$":0},"td":{"$":0},"tel":{"$":0},"tf":{"$":0,"sch":{"$":0}},"tg":{"$":0},"th":{"$":0,"ac":{"$":0},"co":{"$":0},"go":{"$":0},"in":{"$":0},"mi":{"$":0},"net":{"$":0},"or":{"$":0},"online":{"$":0},"shop":{"$":0}},"tj":{"$":0,"ac":{"$":0},"biz":{"$":0},"co":{"$":0},"com":{"$":0},"edu":{"$":0},"go":{"$":0},"gov":{"$":0},"int":{"$":0},"mil":{"$":0},"name":{"$":0},"net":{"$":0},"nic":{"$":0},"org":{"$":0},"test":{"$":0},"web":{"$":0}},"tk":{"$":0},"tl":{"$":0,"gov":{"$":0}},"tm":{"$":0,"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"nom":{"$":0},"org":{"$":0}},"tn":{"$":0,"com":{"$":0},"ens":{"$":0},"fin":{"$":0},"gov":{"$":0},"ind":{"$":0},"info":{"$":0},"intl":{"$":0},"mincom":{"$":0},"nat":{"$":0},"net":{"$":0},"org":{"$":0},"perso":{"$":0},"tourism":{"$":0},"orangecloud":{"$":0}},"to":{"611":{"$":0},"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"oya":{"$":0},"x0":{"$":0},"quickconnect":{"direct":{"$":0}},"vpnplus":{"$":0}},"tr":{"$":0,"av":{"$":0},"bbs":{"$":0},"bel":{"$":0},"biz":{"$":0},"com":{"$":0},"dr":{"$":0},"edu":{"$":0},"gen":{"$":0},"gov":{"$":0},"info":{"$":0},"k12":{"$":0},"kep":{"$":0},"mil":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"pol":{"$":0},"tel":{"$":0},"tsk":{"$":0},"tv":{"$":0},"web":{"$":0},"nc":{"$":0,"gov":{"$":0}}},"tt":{"$":0,"biz":{"$":0},"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"mil":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"pro":{"$":0}},"tv":{"$":0,"better-than":{"$":0},"dyndns":{"$":0},"on-the-web":{"$":0},"worse-than":{"$":0},"from":{"$":0},"sakura":{"$":0}},"tw":{"$":0,"club":{"$":0},"com":{"$":0,"mymailer":{"$":0}},"ebiz":{"$":0},"edu":{"$":0},"game":{"$":0},"gov":{"$":0},"idv":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"url":{"$":0},"mydns":{"$":0}},"tz":{"$":0,"ac":{"$":0},"co":{"$":0},"go":{"$":0},"hotel":{"$":0},"info":{"$":0},"me":{"$":0},"mil":{"$":0},"mobi":{"$":0},"ne":{"$":0},"or":{"$":0},"sc":{"$":0},"tv":{"$":0}},"ua":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"in":{"$":0},"net":{"$":0},"org":{"$":0},"cherkassy":{"$":0},"cherkasy":{"$":0},"chernigov":{"$":0},"chernihiv":{"$":0},"chernivtsi":{"$":0},"chernovtsy":{"$":0},"ck":{"$":0},"cn":{"$":0},"cr":{"$":0},"crimea":{"$":0},"cv":{"$":0},"dn":{"$":0},"dnepropetrovsk":{"$":0},"dnipropetrovsk":{"$":0},"donetsk":{"$":0},"dp":{"$":0},"if":{"$":0},"ivano-frankivsk":{"$":0},"kh":{"$":0},"kharkiv":{"$":0},"kharkov":{"$":0},"kherson":{"$":0},"khmelnitskiy":{"$":0},"khmelnytskyi":{"$":0},"kiev":{"$":0},"kirovograd":{"$":0},"km":{"$":0},"kr":{"$":0},"kropyvnytskyi":{"$":0},"krym":{"$":0},"ks":{"$":0},"kv":{"$":0},"kyiv":{"$":0},"lg":{"$":0},"lt":{"$":0},"lugansk":{"$":0},"luhansk":{"$":0},"lutsk":{"$":0},"lv":{"$":0},"lviv":{"$":0},"mk":{"$":0},"mykolaiv":{"$":0},"nikolaev":{"$":0},"od":{"$":0},"odesa":{"$":0},"odessa":{"$":0},"pl":{"$":0},"poltava":{"$":0},"rivne":{"$":0},"rovno":{"$":0},"rv":{"$":0},"sb":{"$":0},"sebastopol":{"$":0},"sevastopol":{"$":0},"sm":{"$":0},"sumy":{"$":0},"te":{"$":0},"ternopil":{"$":0},"uz":{"$":0},"uzhgorod":{"$":0},"uzhhorod":{"$":0},"vinnica":{"$":0},"vinnytsia":{"$":0},"vn":{"$":0},"volyn":{"$":0},"yalta":{"$":0},"zakarpattia":{"$":0},"zaporizhzhe":{"$":0},"zaporizhzhia":{"$":0},"zhitomir":{"$":0},"zhytomyr":{"$":0},"zp":{"$":0},"zt":{"$":0},"cc":{"$":0},"inf":{"$":0},"ltd":{"$":0},"cx":{"$":0},"biz":{"$":0},"co":{"$":0},"pp":{"$":0},"v":{"$":0}},"ug":{"$":0,"ac":{"$":0},"co":{"$":0},"com":{"$":0},"edu":{"$":0},"go":{"$":0},"gov":{"$":0},"mil":{"$":0},"ne":{"$":0},"or":{"$":0},"org":{"$":0},"sc":{"$":0},"us":{"$":0}},"uk":{"$":0,"ac":{"$":0},"co":{"$":0,"bytemark":{"dh":{"$":0},"vm":{"$":0}},"layershift":{"j":{"$":0}},"barsy":{"$":0},"barsyonline":{"$":0},"retrosnub":{"cust":{"$":0}},"nh-serv":{"$":0},"no-ip":{"$":0},"adimo":{"$":0},"myspreadshop":{"$":0}},"gov":{"$":0,"api":{"$":0},"campaign":{"$":0},"service":{"$":0}},"ltd":{"$":0},"me":{"$":0},"net":{"$":0},"nhs":{"$":0},"org":{"$":0,"glug":{"$":0},"lug":{"$":0},"lugs":{"$":0},"affinitylottery":{"$":0},"raffleentry":{"$":0},"weeklylottery":{"$":0}},"plc":{"$":0},"police":{"$":0},"sch":{"*":{"$":0}},"conn":{"$":0},"copro":{"$":0},"hosp":{"$":0},"independent-commission":{"$":0},"independent-inquest":{"$":0},"independent-inquiry":{"$":0},"independent-panel":{"$":0},"independent-review":{"$":0},"public-inquiry":{"$":0},"royal-commission":{"$":0},"pymnt":{"$":0},"barsy":{"$":0},"nimsite":{"$":0},"oraclegovcloudapps":{"*":{"$":0}}},"us":{"$":0,"dni":{"$":0},"isa":{"$":0},"nsn":{"$":0},"ak":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"al":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ar":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"as":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"az":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ca":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"co":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ct":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"dc":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"de":{"$":0,"cc":{"$":0},"lib":{"$":0}},"fl":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ga":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"gu":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"hi":{"$":0,"cc":{"$":0},"lib":{"$":0}},"ia":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"id":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"il":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"in":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ks":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ky":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"la":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ma":{"$":0,"k12":{"$":0,"chtr":{"$":0},"paroch":{"$":0},"pvt":{"$":0}},"cc":{"$":0},"lib":{"$":0}},"md":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"me":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"mi":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0},"ann-arbor":{"$":0},"cog":{"$":0},"dst":{"$":0},"eaton":{"$":0},"gen":{"$":0},"mus":{"$":0},"tec":{"$":0},"washtenaw":{"$":0}},"mn":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"mo":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ms":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"mt":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"nc":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"nd":{"$":0,"cc":{"$":0},"lib":{"$":0}},"ne":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"nh":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"nj":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"nm":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"nv":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ny":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"oh":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ok":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"or":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"pa":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"pr":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ri":{"$":0,"cc":{"$":0},"lib":{"$":0}},"sc":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"sd":{"$":0,"cc":{"$":0},"lib":{"$":0}},"tn":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"tx":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"ut":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"va":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"vi":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"vt":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"wa":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"wi":{"$":0,"k12":{"$":0},"cc":{"$":0},"lib":{"$":0}},"wv":{"$":0,"cc":{"$":0}},"wy":{"$":0,"cc":{"$":0},"k12":{"$":0},"lib":{"$":0}},"cloudns":{"$":0},"is-by":{"$":0},"land-4-sale":{"$":0},"stuff-4-sale":{"$":0},"heliohost":{"$":0},"enscaled":{"phx":{"$":0}},"mircloud":{"$":0},"ngo":{"$":0},"golffan":{"$":0},"noip":{"$":0},"pointto":{"$":0},"freeddns":{"$":0},"srv":{"$":0,"gh":{"$":0},"gl":{"$":0}},"platterp":{"$":0},"servername":{"$":0}},"uy":{"$":0,"com":{"$":0},"edu":{"$":0},"gub":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"uz":{"$":0,"co":{"$":0},"com":{"$":0},"net":{"$":0},"org":{"$":0}},"va":{"$":0},"vc":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"gv":{"$":0,"d":{"$":0}},"0e":{"*":{"$":0}},"mydns":{"$":0}},"ve":{"$":0,"arts":{"$":0},"bib":{"$":0},"co":{"$":0},"com":{"$":0},"e12":{"$":0},"edu":{"$":0},"emprende":{"$":0},"firm":{"$":0},"gob":{"$":0},"gov":{"$":0},"info":{"$":0},"int":{"$":0},"mil":{"$":0},"net":{"$":0},"nom":{"$":0},"org":{"$":0},"rar":{"$":0},"rec":{"$":0},"store":{"$":0},"tec":{"$":0},"web":{"$":0}},"vg":{"$":0,"edu":{"$":0}},"vi":{"$":0,"co":{"$":0},"com":{"$":0},"k12":{"$":0},"net":{"$":0},"org":{"$":0}},"vn":{"$":0,"ac":{"$":0},"ai":{"$":0},"biz":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"health":{"$":0},"id":{"$":0},"info":{"$":0},"int":{"$":0},"io":{"$":0},"name":{"$":0},"net":{"$":0},"org":{"$":0},"pro":{"$":0},"angiang":{"$":0},"bacgiang":{"$":0},"backan":{"$":0},"baclieu":{"$":0},"bacninh":{"$":0},"baria-vungtau":{"$":0},"bentre":{"$":0},"binhdinh":{"$":0},"binhduong":{"$":0},"binhphuoc":{"$":0},"binhthuan":{"$":0},"camau":{"$":0},"cantho":{"$":0},"caobang":{"$":0},"daklak":{"$":0},"daknong":{"$":0},"danang":{"$":0},"dienbien":{"$":0},"dongnai":{"$":0},"dongthap":{"$":0},"gialai":{"$":0},"hagiang":{"$":0},"haiduong":{"$":0},"haiphong":{"$":0},"hanam":{"$":0},"hanoi":{"$":0},"hatinh":{"$":0},"haugiang":{"$":0},"hoabinh":{"$":0},"hungyen":{"$":0},"khanhhoa":{"$":0},"kiengiang":{"$":0},"kontum":{"$":0},"laichau":{"$":0},"lamdong":{"$":0},"langson":{"$":0},"laocai":{"$":0},"longan":{"$":0},"namdinh":{"$":0},"nghean":{"$":0},"ninhbinh":{"$":0},"ninhthuan":{"$":0},"phutho":{"$":0},"phuyen":{"$":0},"quangbinh":{"$":0},"quangnam":{"$":0},"quangngai":{"$":0},"quangninh":{"$":0},"quangtri":{"$":0},"soctrang":{"$":0},"sonla":{"$":0},"tayninh":{"$":0},"thaibinh":{"$":0},"thainguyen":{"$":0},"thanhhoa":{"$":0},"thanhphohochiminh":{"$":0},"thuathienhue":{"$":0},"tiengiang":{"$":0},"travinh":{"$":0},"tuyenquang":{"$":0},"vinhlong":{"$":0},"vinhphuc":{"$":0},"yenbai":{"$":0}},"vu":{"$":0,"com":{"$":0},"edu":{"$":0},"net":{"$":0},"org":{"$":0}},"wf":{"$":0,"biz":{"$":0},"sch":{"$":0}},"ws":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"net":{"$":0},"org":{"$":0},"advisor":{"*":{"$":0}},"cloud66":{"$":0},"dyndns":{"$":0},"mypets":{"$":0}},"yt":{"$":0,"org":{"$":0}},"xn--mgbaam7a8h":{"$":0},"xn--y9a3aq":{"$":0},"xn--54b7fta0cc":{"$":0},"xn--90ae":{"$":0},"xn--mgbcpq6gpa1a":{"$":0},"xn--90ais":{"$":0},"xn--fiqs8s":{"$":0},"xn--fiqz9s":{"$":0},"xn--lgbbat1ad8j":{"$":0},"xn--wgbh1c":{"$":0},"xn--e1a4c":{"$":0},"xn--qxa6a":{"$":0},"xn--mgbah1a3hjkrd":{"$":0},"xn--node":{"$":0},"xn--qxam":{"$":0},"xn--j6w193g":{"$":0,"xn--gmqw5a":{"$":0},"xn--55qx5d":{"$":0},"xn--mxtq1m":{"$":0},"xn--wcvs22d":{"$":0},"xn--uc0atv":{"$":0},"xn--od0alg":{"$":0}},"xn--2scrj9c":{"$":0},"xn--3hcrj9c":{"$":0},"xn--45br5cyl":{"$":0},"xn--h2breg3eve":{"$":0},"xn--h2brj9c8c":{"$":0},"xn--mgbgu82a":{"$":0},"xn--rvc1e0am3e":{"$":0},"xn--h2brj9c":{"$":0},"xn--mgbbh1a":{"$":0},"xn--mgbbh1a71e":{"$":0},"xn--fpcrj9c3d":{"$":0},"xn--gecrj9c":{"$":0},"xn--s9brj9c":{"$":0},"xn--45brj9c":{"$":0},"xn--xkc2dl3a5ee0h":{"$":0},"xn--mgba3a4f16a":{"$":0},"xn--mgba3a4fra":{"$":0},"xn--mgbtx2b":{"$":0},"xn--mgbayh7gpa":{"$":0},"xn--3e0b707e":{"$":0},"xn--80ao21a":{"$":0},"xn--q7ce6a":{"$":0},"xn--fzc2c9e2c":{"$":0},"xn--xkc2al3hye2a":{"$":0},"xn--mgbc0a9azcg":{"$":0},"xn--d1alf":{"$":0},"xn--l1acc":{"$":0},"xn--mix891f":{"$":0},"xn--mix082f":{"$":0},"xn--mgbx4cd0ab":{"$":0},"xn--mgb9awbf":{"$":0},"xn--mgbai9azgqp6j":{"$":0},"xn--mgbai9a5eva00b":{"$":0},"xn--ygbi2ammx":{"$":0},"xn--90a3ac":{"$":0,"xn--80au":{"$":0},"xn--90azh":{"$":0},"xn--d1at":{"$":0},"xn--c1avg":{"$":0},"xn--o1ac":{"$":0},"xn--o1ach":{"$":0}},"xn--p1ai":{"$":0},"xn--wgbl6a":{"$":0},"xn--mgberp4a5d4ar":{"$":0},"xn--mgberp4a5d4a87g":{"$":0},"xn--mgbqly7c0a67fbc":{"$":0},"xn--mgbqly7cvafr":{"$":0},"xn--mgbpl2fh":{"$":0},"xn--yfro4i67o":{"$":0},"xn--clchc0ea0b2g2a9gcd":{"$":0},"xn--ogbpf8fl":{"$":0},"xn--mgbtf8fl":{"$":0},"xn--o3cw4h":{"$":0,"xn--o3cyx2a":{"$":0},"xn--12co0c3b4eva":{"$":0},"xn--m3ch0j3a":{"$":0},"xn--h3cuzk1di":{"$":0},"xn--12c1fe0br":{"$":0},"xn--12cfi8ixb8l":{"$":0}},"xn--pgbs0dh":{"$":0},"xn--kpry57d":{"$":0},"xn--kprw13d":{"$":0},"xn--nnx388a":{"$":0},"xn--j1amh":{"$":0},"xn--mgb2ddes":{"$":0},"xxx":{"$":0},"ye":{"$":0,"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0}},"za":{"ac":{"$":0},"agric":{"$":0},"alt":{"$":0},"co":{"$":0},"edu":{"$":0},"gov":{"$":0},"grondar":{"$":0},"law":{"$":0},"mil":{"$":0},"net":{"$":0},"ngo":{"$":0},"nic":{"$":0},"nis":{"$":0},"nom":{"$":0},"org":{"$":0},"school":{"$":0},"tm":{"$":0},"web":{"$":0}},"zm":{"$":0,"ac":{"$":0},"biz":{"$":0},"co":{"$":0},"com":{"$":0},"edu":{"$":0},"gov":{"$":0},"info":{"$":0},"mil":{"$":0},"net":{"$":0},"org":{"$":0},"sch":{"$":0}},"zw":{"$":0,"ac":{"$":0},"co":{"$":0},"gov":{"$":0},"mil":{"$":0},"org":{"$":0}},"aaa":{"$":0},"aarp":{"$":0},"abb":{"$":0},"abbott":{"$":0},"abbvie":{"$":0},"abc":{"$":0},"able":{"$":0},"abogado":{"$":0},"abudhabi":{"$":0},"academy":{"$":0,"official":{"$":0}},"accenture":{"$":0},"accountant":{"$":0},"accountants":{"$":0},"aco":{"$":0},"actor":{"$":0},"ads":{"$":0},"adult":{"$":0},"aeg":{"$":0},"aetna":{"$":0},"afl":{"$":0},"africa":{"$":0},"agakhan":{"$":0},"agency":{"$":0},"aig":{"$":0},"airbus":{"$":0},"airforce":{"$":0},"airtel":{"$":0},"akdn":{"$":0},"alibaba":{"$":0},"alipay":{"$":0},"allfinanz":{"$":0},"allstate":{"$":0},"ally":{"$":0},"alsace":{"$":0},"alstom":{"$":0},"amazon":{"$":0},"americanexpress":{"$":0},"americanfamily":{"$":0},"amex":{"$":0},"amfam":{"$":0},"amica":{"$":0},"amsterdam":{"$":0},"analytics":{"$":0},"android":{"$":0},"anquan":{"$":0},"anz":{"$":0},"aol":{"$":0},"apartments":{"$":0},"app":{"$":0,"adaptable":{"$":0},"aiven":{"$":0},"beget":{"*":{"$":0}},"brave":{"$":0,"s":{"*":{"$":0}}},"clerk":{"$":0},"clerkstage":{"$":0},"wnext":{"$":0},"csb":{"$":0,"preview":{"$":0}},"convex":{"$":0},"deta":{"$":0},"ondigitalocean":{"$":0},"easypanel":{"$":0},"encr":{"$":0,"frontend":{"$":0}},"evervault":{"relay":{"$":0}},"expo":{"$":0,"staging":{"$":0}},"edgecompute":{"$":0},"on-fleek":{"$":0},"flutterflow":{"$":0},"e2b":{"$":0},"framer":{"$":0},"github":{"$":0},"hosted":{"*":{"$":0}},"run":{"*":{"$":0},"mtls":{"*":{"$":0}}},"web":{"$":0},"hasura":{"$":0},"botdash":{"$":0},"loginline":{"$":0},"lovable":{"$":0},"luyani":{"$":0},"medusajs":{"$":0},"messerli":{"$":0},"netfy":{"$":0},"netlify":{"$":0},"ngrok":{"$":0},"ngrok-free":{"$":0},"developer":{"*":{"$":0}},"noop":{"$":0},"northflank":{"*":{"$":0}},"upsun":{"*":{"$":0}},"replit":{"$":0,"id":{"$":0}},"nyat":{"$":0},"snowflake":{"*":{"$":0},"privatelink":{"*":{"$":0}}},"streamlit":{"$":0},"storipress":{"$":0},"telebit":{"$":0},"typedream":{"$":0},"vercel":{"$":0},"bookonline":{"$":0},"wdh":{"$":0},"windsurf":{"$":0},"zeabur":{"$":0},"zerops":{"*":{"$":0}}},"apple":{"$":0},"aquarelle":{"$":0},"arab":{"$":0},"aramco":{"$":0},"archi":{"$":0},"army":{"$":0},"art":{"$":0},"arte":{"$":0},"asda":{"$":0},"associates":{"$":0},"athleta":{"$":0},"attorney":{"$":0},"auction":{"$":0},"audi":{"$":0},"audible":{"$":0},"audio":{"$":0},"auspost":{"$":0},"author":{"$":0},"auto":{"$":0},"autos":{"$":0},"aws":{"$":0,"sagemaker":{"ap-northeast-1":{"labeling":{"$":0},"notebook":{"$":0},"studio":{"$":0}},"ap-northeast-2":{"labeling":{"$":0},"notebook":{"$":0},"studio":{"$":0}},"ap-south-1":{"labeling":{"$":0},"notebook":{"$":0},"studio":{"$":0}},"ap-southeast-1":{"labeling":{"$":0},"notebook":{"$":0},"studio":{"$":0}},"ap-southeast-2":{"labeling":{"$":0},"notebook":{"$":0},"studio":{"$":0}},"ca-central-1":{"labeling":{"$":0},"notebook":{"$":0},"notebook-fips":{"$":0},"studio":{"$":0}},"eu-central-1":{"labeling":{"$":0},"notebook":{"$":0},"studio":{"$":0}},"eu-west-1":{"labeling":{"$":0},"notebook":{"$":0},"studio":{"$":0}},"eu-west-2":{"labeling":{"$":0},"notebook":{"$":0},"studio":{"$":0}},"us-east-1":{"labeling":{"$":0},"notebook":{"$":0},"notebook-fips":{"$":0},"studio":{"$":0}},"us-east-2":{"labeling":{"$":0},"notebook":{"$":0},"notebook-fips":{"$":0},"studio":{"$":0}},"us-west-2":{"labeling":{"$":0},"notebook":{"$":0},"notebook-fips":{"$":0},"studio":{"$":0}},"af-south-1":{"notebook":{"$":0},"studio":{"$":0}},"ap-east-1":{"notebook":{"$":0},"studio":{"$":0}},"ap-northeast-3":{"notebook":{"$":0},"studio":{"$":0}},"ap-south-2":{"notebook":{"$":0}},"ap-southeast-3":{"notebook":{"$":0},"studio":{"$":0}},"ap-southeast-4":{"notebook":{"$":0}},"ca-west-1":{"notebook":{"$":0},"notebook-fips":{"$":0}},"eu-central-2":{"notebook":{"$":0},"studio":{"$":0}},"eu-north-1":{"notebook":{"$":0},"studio":{"$":0}},"eu-south-1":{"notebook":{"$":0},"studio":{"$":0}},"eu-south-2":{"notebook":{"$":0},"studio":{"$":0}},"eu-west-3":{"notebook":{"$":0},"studio":{"$":0}},"il-central-1":{"notebook":{"$":0},"studio":{"$":0}},"me-central-1":{"notebook":{"$":0},"studio":{"$":0}},"me-south-1":{"notebook":{"$":0},"studio":{"$":0}},"sa-east-1":{"notebook":{"$":0},"studio":{"$":0}},"us-gov-east-1":{"notebook":{"$":0},"notebook-fips":{"$":0},"studio":{"$":0},"studio-fips":{"$":0}},"us-gov-west-1":{"notebook":{"$":0},"notebook-fips":{"$":0},"studio":{"$":0},"studio-fips":{"$":0}},"us-west-1":{"notebook":{"$":0},"notebook-fips":{"$":0},"studio":{"$":0}},"experiments":{"*":{"$":0}}},"repost":{"private":{"*":{"$":0}}},"on":{"ap-northeast-1":{"transfer-webapp":{"$":0}},"ap-southeast-1":{"transfer-webapp":{"$":0}},"ap-southeast-2":{"transfer-webapp":{"$":0}},"eu-central-1":{"transfer-webapp":{"$":0}},"eu-north-1":{"transfer-webapp":{"$":0}},"eu-west-1":{"transfer-webapp":{"$":0}},"us-east-1":{"transfer-webapp":{"$":0}},"us-east-2":{"transfer-webapp":{"$":0}},"us-west-2":{"transfer-webapp":{"$":0}}}},"axa":{"$":0},"azure":{"$":0},"baby":{"$":0},"baidu":{"$":0},"banamex":{"$":0},"band":{"$":0},"bank":{"$":0},"bar":{"$":0},"barcelona":{"$":0},"barclaycard":{"$":0},"barclays":{"$":0},"barefoot":{"$":0},"bargains":{"$":0},"baseball":{"$":0},"basketball":{"$":0,"aus":{"$":0},"nz":{"$":0}},"bauhaus":{"$":0},"bayern":{"$":0},"bbc":{"$":0},"bbt":{"$":0},"bbva":{"$":0},"bcg":{"$":0},"bcn":{"$":0},"beats":{"$":0},"beauty":{"$":0},"beer":{"$":0},"berlin":{"$":0},"best":{"$":0},"bestbuy":{"$":0},"bet":{"$":0},"bharti":{"$":0},"bible":{"$":0},"bid":{"$":0},"bike":{"$":0},"bing":{"$":0},"bingo":{"$":0},"bio":{"$":0},"black":{"$":0},"blackfriday":{"$":0},"blockbuster":{"$":0},"blog":{"$":0},"bloomberg":{"$":0},"blue":{"$":0},"bms":{"$":0},"bmw":{"$":0},"bnpparibas":{"$":0},"boats":{"$":0},"boehringer":{"$":0},"bofa":{"$":0},"bom":{"$":0},"bond":{"$":0},"boo":{"$":0},"book":{"$":0},"booking":{"$":0},"bosch":{"$":0},"bostik":{"$":0},"boston":{"$":0},"bot":{"$":0},"boutique":{"$":0},"box":{"$":0},"bradesco":{"$":0},"bridgestone":{"$":0},"broadway":{"$":0},"broker":{"$":0},"brother":{"$":0},"brussels":{"$":0},"build":{"$":0,"v0":{"$":0},"windsurf":{"$":0}},"builders":{"$":0,"cloudsite":{"$":0}},"business":{"$":0,"co":{"$":0}},"buy":{"$":0},"buzz":{"$":0},"bzh":{"$":0},"cab":{"$":0},"cafe":{"$":0},"cal":{"$":0},"call":{"$":0},"calvinklein":{"$":0},"cam":{"$":0},"camera":{"$":0},"camp":{"$":0,"emf":{"at":{"$":0}}},"canon":{"$":0},"capetown":{"$":0},"capital":{"$":0},"capitalone":{"$":0},"car":{"$":0},"caravan":{"$":0},"cards":{"$":0},"care":{"$":0},"career":{"$":0},"careers":{"$":0},"cars":{"$":0},"casa":{"$":0,"nabu":{"ui":{"$":0}}},"case":{"$":0},"cash":{"$":0},"casino":{"$":0},"catering":{"$":0},"catholic":{"$":0},"cba":{"$":0},"cbn":{"$":0},"cbre":{"$":0},"center":{"$":0},"ceo":{"$":0},"cern":{"$":0},"cfa":{"$":0},"cfd":{"$":0},"chanel":{"$":0},"channel":{"$":0},"charity":{"$":0},"chase":{"$":0},"chat":{"$":0},"cheap":{"$":0},"chintai":{"$":0},"christmas":{"$":0},"chrome":{"$":0},"church":{"$":0},"cipriani":{"$":0},"circle":{"$":0},"cisco":{"$":0},"citadel":{"$":0},"citi":{"$":0},"citic":{"$":0},"city":{"$":0},"claims":{"$":0},"cleaning":{"$":0},"click":{"$":0},"clinic":{"$":0},"clinique":{"$":0},"clothing":{"$":0},"cloud":{"$":0,"convex":{"$":0},"elementor":{"$":0},"encoway":{"eu":{"$":0}},"statics":{"*":{"$":0}},"ravendb":{"$":0},"axarnet":{"es-1":{"$":0}},"diadem":{"$":0},"jelastic":{"vip":{"$":0}},"jele":{"$":0},"jenv-aruba":{"aruba":{"eur":{"it1":{"$":0}}},"it1":{"$":0}},"keliweb":{"$":0,"cs":{"$":0}},"oxa":{"$":0,"tn":{"$":0},"uk":{"$":0}},"primetel":{"$":0,"uk":{"$":0}},"reclaim":{"ca":{"$":0},"uk":{"$":0},"us":{"$":0}},"trendhosting":{"ch":{"$":0},"de":{"$":0}},"jotelulu":{"$":0},"kuleuven":{"$":0},"laravel":{"$":0},"linkyard":{"$":0},"magentosite":{"*":{"$":0}},"matlab":{"$":0},"observablehq":{"$":0},"perspecta":{"$":0},"vapor":{"$":0},"on-rancher":{"*":{"$":0}},"scw":{"baremetal":{"fr-par-1":{"$":0},"fr-par-2":{"$":0},"nl-ams-1":{"$":0}},"fr-par":{"cockpit":{"$":0},"ddl":{"$":0},"dtwh":{"$":0},"fnc":{"$":0,"functions":{"$":0}},"ifr":{"$":0},"k8s":{"$":0,"nodes":{"$":0}},"kafk":{"$":0},"mgdb":{"$":0},"rdb":{"$":0},"s3":{"$":0},"s3-website":{"$":0},"scbl":{"$":0},"whm":{"$":0}},"instances":{"priv":{"$":0},"pub":{"$":0}},"k8s":{"$":0},"nl-ams":{"cockpit":{"$":0},"ddl":{"$":0},"dtwh":{"$":0},"ifr":{"$":0},"k8s":{"$":0,"nodes":{"$":0}},"kafk":{"$":0},"mgdb":{"$":0},"rdb":{"$":0},"s3":{"$":0},"s3-website":{"$":0},"scbl":{"$":0},"whm":{"$":0}},"pl-waw":{"cockpit":{"$":0},"ddl":{"$":0},"dtwh":{"$":0},"ifr":{"$":0},"k8s":{"$":0,"nodes":{"$":0}},"kafk":{"$":0},"mgdb":{"$":0},"rdb":{"$":0},"s3":{"$":0},"s3-website":{"$":0},"scbl":{"$":0}},"scalebook":{"$":0},"smartlabeling":{"$":0}},"servebolt":{"$":0},"onstackit":{"runs":{"$":0}},"trafficplex":{"$":0},"unison-services":{"$":0},"urown":{"$":0},"voorloper":{"$":0},"zap":{"$":0}},"club":{"$":0,"cloudns":{"$":0},"jele":{"$":0},"barsy":{"$":0}},"clubmed":{"$":0},"coach":{"$":0},"codes":{"$":0,"owo":{"*":{"$":0}}},"coffee":{"$":0},"college":{"$":0},"cologne":{"$":0},"commbank":{"$":0},"community":{"$":0,"nog":{"$":0},"ravendb":{"$":0},"myforum":{"$":0}},"company":{"$":0},"compare":{"$":0},"computer":{"$":0},"comsec":{"$":0},"condos":{"$":0},"construction":{"$":0},"consulting":{"$":0},"contact":{"$":0},"contractors":{"$":0},"cooking":{"$":0},"cool":{"$":0,"elementor":{"$":0},"de":{"$":0}},"corsica":{"$":0},"country":{"$":0},"coupon":{"$":0},"coupons":{"$":0},"courses":{"$":0},"cpa":{"$":0},"credit":{"$":0},"creditcard":{"$":0},"creditunion":{"$":0},"cricket":{"$":0},"crown":{"$":0},"crs":{"$":0},"cruise":{"$":0},"cruises":{"$":0},"cuisinella":{"$":0},"cymru":{"$":0},"cyou":{"$":0},"dad":{"$":0},"dance":{"$":0},"data":{"$":0},"date":{"$":0},"dating":{"$":0},"datsun":{"$":0},"day":{"$":0},"dclk":{"$":0},"dds":{"$":0},"deal":{"$":0},"dealer":{"$":0},"deals":{"$":0},"degree":{"$":0},"delivery":{"$":0},"dell":{"$":0},"deloitte":{"$":0},"delta":{"$":0},"democrat":{"$":0},"dental":{"$":0},"dentist":{"$":0},"desi":{"$":0},"design":{"$":0,"graphic":{"$":0},"bss":{"$":0}},"dev":{"$":0,"12chars":{"$":0},"myaddr":{"$":0},"panel":{"$":0},"lcl":{"*":{"$":0}},"lclstage":{"*":{"$":0}},"stg":{"*":{"$":0}},"stgstage":{"*":{"$":0}},"pages":{"$":0},"r2":{"$":0},"workers":{"$":0},"deno":{"$":0},"deno-staging":{"$":0},"deta":{"$":0},"lp":{"$":0,"api":{"$":0},"objects":{"$":0}},"evervault":{"relay":{"$":0}},"fly":{"$":0},"githubpreview":{"$":0},"gateway":{"*":{"$":0}},"botdash":{"$":0},"inbrowser":{"*":{"$":0}},"is-a-good":{"$":0},"is-a":{"$":0},"iserv":{"$":0},"runcontainers":{"$":0},"localcert":{"user":{"*":{"$":0}}},"loginline":{"$":0},"barsy":{"$":0},"mediatech":{"$":0},"modx":{"$":0},"ngrok":{"$":0},"ngrok-free":{"$":0},"is-a-fullstack":{"$":0},"is-cool":{"$":0},"is-not-a":{"$":0},"localplayer":{"$":0},"xmit":{"$":0},"platter-app":{"$":0},"replit":{"$":0,"archer":{"$":0},"bones":{"$":0},"canary":{"$":0},"global":{"$":0},"hacker":{"$":0},"id":{"$":0},"janeway":{"$":0},"kim":{"$":0},"kira":{"$":0},"kirk":{"$":0},"odo":{"$":0},"paris":{"$":0},"picard":{"$":0},"pike":{"$":0},"prerelease":{"$":0},"reed":{"$":0},"riker":{"$":0},"sisko":{"$":0},"spock":{"$":0},"staging":{"$":0},"sulu":{"$":0},"tarpit":{"$":0},"teams":{"$":0},"tucker":{"$":0},"wesley":{"$":0},"worf":{"$":0}},"crm":{"d":{"*":{"$":0}},"w":{"*":{"$":0}},"wa":{"*":{"$":0}},"wb":{"*":{"$":0}},"wc":{"*":{"$":0}},"wd":{"*":{"$":0}},"we":{"*":{"$":0}},"wf":{"*":{"$":0}}},"vercel":{"$":0},"webhare":{"*":{"$":0}},"hrsn":{"$":0}},"dhl":{"$":0},"diamonds":{"$":0},"diet":{"$":0},"digital":{"$":0,"cloudapps":{"$":0,"london":{"$":0}}},"direct":{"$":0,"libp2p":{"$":0}},"directory":{"$":0},"discount":{"$":0},"discover":{"$":0},"dish":{"$":0},"diy":{"$":0},"dnp":{"$":0},"docs":{"$":0},"doctor":{"$":0},"dog":{"$":0},"domains":{"$":0},"dot":{"$":0},"download":{"$":0},"drive":{"$":0},"dtv":{"$":0},"dubai":{"$":0},"dunlop":{"$":0},"dupont":{"$":0},"durban":{"$":0},"dvag":{"$":0},"dvr":{"$":0},"earth":{"$":0},"eat":{"$":0},"eco":{"$":0},"edeka":{"$":0},"education":{"$":0,"co":{"$":0}},"email":{"$":0,"crisp":{"on":{"$":0}},"tawk":{"p":{"$":0}},"tawkto":{"p":{"$":0}}},"emerck":{"$":0},"energy":{"$":0},"engineer":{"$":0},"engineering":{"$":0},"enterprises":{"$":0},"epson":{"$":0},"equipment":{"$":0},"ericsson":{"$":0},"erni":{"$":0},"esq":{"$":0},"estate":{"$":0,"compute":{"*":{"$":0}}},"eurovision":{"$":0},"eus":{"$":0,"party":{"user":{"$":0}}},"events":{"$":0,"koobin":{"$":0},"co":{"$":0}},"exchange":{"$":0},"expert":{"$":0},"exposed":{"$":0},"express":{"$":0},"extraspace":{"$":0},"fage":{"$":0},"fail":{"$":0},"fairwinds":{"$":0},"faith":{"$":0},"family":{"$":0},"fan":{"$":0},"fans":{"$":0},"farm":{"$":0,"storj":{"$":0}},"farmers":{"$":0},"fashion":{"$":0},"fast":{"$":0},"fedex":{"$":0},"feedback":{"$":0},"ferrari":{"$":0},"ferrero":{"$":0},"fidelity":{"$":0},"fido":{"$":0},"film":{"$":0},"final":{"$":0},"finance":{"$":0},"financial":{"$":0,"co":{"$":0}},"fire":{"$":0},"firestone":{"$":0},"firmdale":{"$":0},"fish":{"$":0},"fishing":{"$":0},"fit":{"$":0},"fitness":{"$":0},"flickr":{"$":0},"flights":{"$":0},"flir":{"$":0},"florist":{"$":0},"flowers":{"$":0},"fly":{"$":0},"foo":{"$":0},"food":{"$":0},"football":{"$":0},"ford":{"$":0},"forex":{"$":0},"forsale":{"$":0},"forum":{"$":0},"foundation":{"$":0},"fox":{"$":0},"free":{"$":0},"fresenius":{"$":0},"frl":{"$":0},"frogans":{"$":0},"frontier":{"$":0},"ftr":{"$":0},"fujitsu":{"$":0},"fun":{"$":0},"fund":{"$":0},"furniture":{"$":0},"futbol":{"$":0},"fyi":{"$":0},"gal":{"$":0},"gallery":{"$":0},"gallo":{"$":0},"gallup":{"$":0},"game":{"$":0},"games":{"$":0,"pley":{"$":0},"sheezy":{"$":0}},"gap":{"$":0},"garden":{"$":0},"gay":{"$":0,"pages":{"$":0}},"gbiz":{"$":0},"gdn":{"$":0,"cnpy":{"$":0}},"gea":{"$":0},"gent":{"$":0},"genting":{"$":0},"george":{"$":0},"ggee":{"$":0},"gift":{"$":0},"gifts":{"$":0},"gives":{"$":0},"giving":{"$":0},"glass":{"$":0},"gle":{"$":0},"global":{"$":0,"appwrite":{"$":0}},"globo":{"$":0},"gmail":{"$":0},"gmbh":{"$":0},"gmo":{"$":0},"gmx":{"$":0},"godaddy":{"$":0},"gold":{"$":0},"goldpoint":{"$":0},"golf":{"$":0},"goo":{"$":0},"goodyear":{"$":0},"goog":{"$":0,"cloud":{"$":0},"translate":{"$":0},"usercontent":{"*":{"$":0}}},"google":{"$":0},"gop":{"$":0},"got":{"$":0},"grainger":{"$":0},"graphics":{"$":0},"gratis":{"$":0},"green":{"$":0},"gripe":{"$":0},"grocery":{"$":0},"group":{"$":0,"discourse":{"$":0}},"gucci":{"$":0},"guge":{"$":0},"guide":{"$":0},"guitars":{"$":0},"guru":{"$":0},"hair":{"$":0},"hamburg":{"$":0},"hangout":{"$":0},"haus":{"$":0},"hbo":{"$":0},"hdfc":{"$":0},"hdfcbank":{"$":0},"health":{"$":0,"hra":{"$":0}},"healthcare":{"$":0},"help":{"$":0},"helsinki":{"$":0},"here":{"$":0},"hermes":{"$":0},"hiphop":{"$":0},"hisamitsu":{"$":0},"hitachi":{"$":0},"hiv":{"$":0},"hkt":{"$":0},"hockey":{"$":0},"holdings":{"$":0},"holiday":{"$":0},"homedepot":{"$":0},"homegoods":{"$":0},"homes":{"$":0},"homesense":{"$":0},"honda":{"$":0},"horse":{"$":0},"hospital":{"$":0},"host":{"$":0,"cloudaccess":{"$":0},"freesite":{"$":0},"easypanel":{"$":0},"fastvps":{"$":0},"myfast":{"$":0},"tempurl":{"$":0},"wpmudev":{"$":0},"iserv":{"$":0},"jele":{"$":0},"mircloud":{"$":0},"wp2":{"$":0},"half":{"$":0}},"hosting":{"$":0,"opencraft":{"$":0}},"hot":{"$":0},"hotel":{"$":0},"hotels":{"$":0},"hotmail":{"$":0},"house":{"$":0},"how":{"$":0},"hsbc":{"$":0},"hughes":{"$":0},"hyatt":{"$":0},"hyundai":{"$":0},"ibm":{"$":0},"icbc":{"$":0},"ice":{"$":0},"icu":{"$":0},"ieee":{"$":0},"ifm":{"$":0},"ikano":{"$":0},"imamat":{"$":0},"imdb":{"$":0},"immo":{"$":0},"immobilien":{"$":0},"inc":{"$":0},"industries":{"$":0},"infiniti":{"$":0},"ing":{"$":0},"ink":{"$":0},"institute":{"$":0},"insurance":{"$":0},"insure":{"$":0},"international":{"$":0},"intuit":{"$":0},"investments":{"$":0},"ipiranga":{"$":0},"irish":{"$":0},"ismaili":{"$":0},"ist":{"$":0},"istanbul":{"$":0},"itau":{"$":0},"itv":{"$":0},"jaguar":{"$":0},"java":{"$":0},"jcb":{"$":0},"jeep":{"$":0},"jetzt":{"$":0},"jewelry":{"$":0},"jio":{"$":0},"jll":{"$":0},"jmp":{"$":0},"jnj":{"$":0},"joburg":{"$":0},"jot":{"$":0},"joy":{"$":0},"jpmorgan":{"$":0},"jprs":{"$":0},"juegos":{"$":0},"juniper":{"$":0},"kaufen":{"$":0},"kddi":{"$":0},"kerryhotels":{"$":0},"kerryproperties":{"$":0},"kfh":{"$":0},"kia":{"$":0},"kids":{"$":0},"kim":{"$":0},"kindle":{"$":0},"kitchen":{"$":0},"kiwi":{"$":0},"koeln":{"$":0},"komatsu":{"$":0},"kosher":{"$":0},"kpmg":{"$":0},"kpn":{"$":0},"krd":{"$":0,"co":{"$":0},"edu":{"$":0}},"kred":{"$":0},"kuokgroup":{"$":0},"kyoto":{"$":0},"lacaixa":{"$":0},"lamborghini":{"$":0},"lamer":{"$":0},"land":{"$":0},"landrover":{"$":0},"lanxess":{"$":0},"lasalle":{"$":0},"lat":{"$":0},"latino":{"$":0},"latrobe":{"$":0},"law":{"$":0},"lawyer":{"$":0},"lds":{"$":0},"lease":{"$":0},"leclerc":{"$":0},"lefrak":{"$":0},"legal":{"$":0},"lego":{"$":0},"lexus":{"$":0},"lgbt":{"$":0},"lidl":{"$":0},"life":{"$":0},"lifeinsurance":{"$":0},"lifestyle":{"$":0},"lighting":{"$":0},"like":{"$":0},"lilly":{"$":0},"limited":{"$":0},"limo":{"$":0},"lincoln":{"$":0},"link":{"$":0,"myfritz":{"$":0},"cyon":{"$":0},"dweb":{"*":{"$":0}},"inbrowser":{"*":{"$":0}},"nftstorage":{"ipfs":{"$":0}},"mypep":{"$":0},"storacha":{"ipfs":{"$":0}},"w3s":{"ipfs":{"$":0}}},"live":{"$":0,"aem":{"$":0},"hlx":{"$":0},"ewp":{"*":{"$":0}}},"living":{"$":0},"llc":{"$":0},"llp":{"$":0},"loan":{"$":0},"loans":{"$":0},"locker":{"$":0},"locus":{"$":0},"lol":{"$":0,"omg":{"$":0}},"london":{"$":0},"lotte":{"$":0},"lotto":{"$":0},"love":{"$":0},"lpl":{"$":0},"lplfinancial":{"$":0},"ltd":{"$":0},"ltda":{"$":0},"lundbeck":{"$":0},"luxe":{"$":0},"luxury":{"$":0},"madrid":{"$":0},"maif":{"$":0},"maison":{"$":0},"makeup":{"$":0},"man":{"$":0},"management":{"$":0},"mango":{"$":0},"map":{"$":0},"market":{"$":0},"marketing":{"$":0},"markets":{"$":0},"marriott":{"$":0},"marshalls":{"$":0},"mattel":{"$":0},"mba":{"$":0},"mckinsey":{"$":0},"med":{"$":0},"media":{"$":0,"framer":{"$":0}},"meet":{"$":0},"melbourne":{"$":0},"meme":{"$":0},"memorial":{"$":0},"men":{"$":0},"menu":{"$":0,"barsy":{"$":0},"barsyonline":{"$":0}},"merck":{"$":0},"merckmsd":{"$":0},"miami":{"$":0},"microsoft":{"$":0},"mini":{"$":0},"mint":{"$":0},"mit":{"$":0},"mitsubishi":{"$":0},"mlb":{"$":0},"mls":{"$":0},"mma":{"$":0},"mobile":{"$":0},"moda":{"$":0},"moe":{"$":0},"moi":{"$":0},"mom":{"$":0},"monash":{"$":0},"money":{"$":0},"monster":{"$":0},"mormon":{"$":0},"mortgage":{"$":0},"moscow":{"$":0},"moto":{"$":0},"motorcycles":{"$":0},"mov":{"$":0},"movie":{"$":0},"msd":{"$":0},"mtn":{"$":0},"mtr":{"$":0},"music":{"$":0},"nab":{"$":0},"nagoya":{"$":0},"navy":{"$":0},"nba":{"$":0},"nec":{"$":0},"netbank":{"$":0},"netflix":{"$":0},"network":{"$":0,"aem":{"$":0},"alces":{"*":{"$":0}},"co":{"$":0},"arvo":{"$":0},"azimuth":{"$":0},"tlon":{"$":0}},"neustar":{"$":0},"new":{"$":0},"news":{"$":0,"noticeable":{"$":0}},"next":{"$":0},"nextdirect":{"$":0},"nexus":{"$":0},"nfl":{"$":0},"ngo":{"$":0},"nhk":{"$":0},"nico":{"$":0},"nike":{"$":0},"nikon":{"$":0},"ninja":{"$":0},"nissan":{"$":0},"nissay":{"$":0},"nokia":{"$":0},"norton":{"$":0},"now":{"$":0},"nowruz":{"$":0},"nowtv":{"$":0},"nra":{"$":0},"nrw":{"$":0},"ntt":{"$":0},"nyc":{"$":0},"obi":{"$":0},"observer":{"$":0},"office":{"$":0},"okinawa":{"$":0},"olayan":{"$":0},"olayangroup":{"$":0},"ollo":{"$":0},"omega":{"$":0},"one":{"$":0,"kin":{"*":{"$":0}},"service":{"$":0}},"ong":{"$":0,"obl":{"$":0}},"onl":{"$":0},"online":{"$":0,"eero":{"$":0},"eero-stage":{"$":0},"websitebuilder":{"$":0},"barsy":{"$":0}},"ooo":{"$":0},"open":{"$":0},"oracle":{"$":0},"orange":{"$":0,"tech":{"$":0}},"organic":{"$":0},"origins":{"$":0},"osaka":{"$":0},"otsuka":{"$":0},"ott":{"$":0},"ovh":{"$":0,"nerdpol":{"$":0}},"page":{"$":0,"aem":{"$":0},"hlx":{"$":0},"translated":{"$":0},"codeberg":{"$":0},"heyflow":{"$":0},"prvcy":{"$":0},"rocky":{"$":0},"pdns":{"$":0},"plesk":{"$":0}},"panasonic":{"$":0},"paris":{"$":0},"pars":{"$":0},"partners":{"$":0},"parts":{"$":0},"party":{"$":0},"pay":{"$":0},"pccw":{"$":0},"pet":{"$":0},"pfizer":{"$":0},"pharmacy":{"$":0},"phd":{"$":0},"philips":{"$":0},"phone":{"$":0},"photo":{"$":0},"photography":{"$":0},"photos":{"$":0,"framer":{"$":0}},"physio":{"$":0},"pics":{"$":0},"pictet":{"$":0},"pictures":{"1337":{"$":0},"$":0},"pid":{"$":0},"pin":{"$":0},"ping":{"$":0},"pink":{"$":0},"pioneer":{"$":0},"pizza":{"$":0,"ngrok":{"$":0}},"place":{"$":0,"co":{"$":0}},"play":{"$":0},"playstation":{"$":0},"plumbing":{"$":0},"plus":{"$":0},"pnc":{"$":0},"pohl":{"$":0},"poker":{"$":0},"politie":{"$":0},"porn":{"$":0},"praxi":{"$":0},"press":{"$":0},"prime":{"$":0},"prod":{"$":0},"productions":{"$":0},"prof":{"$":0},"progressive":{"$":0},"promo":{"$":0},"properties":{"$":0},"property":{"$":0},"protection":{"$":0},"pru":{"$":0},"prudential":{"$":0},"pub":{"$":0,"id":{"*":{"$":0}},"kin":{"*":{"$":0}},"barsy":{"$":0}},"pwc":{"$":0},"qpon":{"$":0},"quebec":{"$":0},"quest":{"$":0},"racing":{"$":0},"radio":{"$":0},"read":{"$":0},"realestate":{"$":0},"realtor":{"$":0},"realty":{"$":0},"recipes":{"$":0},"red":{"$":0},"redstone":{"$":0},"redumbrella":{"$":0},"rehab":{"$":0},"reise":{"$":0},"reisen":{"$":0},"reit":{"$":0},"reliance":{"$":0},"ren":{"$":0},"rent":{"$":0},"rentals":{"$":0},"repair":{"$":0},"report":{"$":0},"republican":{"$":0},"rest":{"$":0},"restaurant":{"$":0},"review":{"$":0},"reviews":{"$":0,"aem":{"$":0}},"rexroth":{"$":0},"rich":{"$":0},"richardli":{"$":0},"ricoh":{"$":0},"ril":{"$":0},"rio":{"$":0},"rip":{"$":0,"clan":{"$":0}},"rocks":{"$":0,"myddns":{"$":0},"stackit":{"$":0},"lima-city":{"$":0},"webspace":{"$":0}},"rodeo":{"$":0},"rogers":{"$":0},"room":{"$":0},"rsvp":{"$":0},"rugby":{"$":0},"ruhr":{"$":0},"run":{"$":0,"appwrite":{"*":{"$":0}},"development":{"$":0},"ravendb":{"$":0},"liara":{"$":0,"iran":{"$":0}},"servers":{"$":0},"build":{"*":{"$":0}},"code":{"*":{"$":0}},"database":{"*":{"$":0}},"migration":{"*":{"$":0}},"onporter":{"$":0},"repl":{"$":0},"stackit":{"$":0},"val":{"$":0,"web":{"$":0}},"vercel":{"$":0},"wix":{"$":0}},"rwe":{"$":0},"ryukyu":{"$":0},"saarland":{"$":0},"safe":{"$":0},"safety":{"$":0},"sakura":{"$":0},"sale":{"$":0},"salon":{"$":0},"samsclub":{"$":0},"samsung":{"$":0},"sandvik":{"$":0},"sandvikcoromant":{"$":0},"sanofi":{"$":0},"sap":{"$":0},"sarl":{"$":0},"sas":{"$":0},"save":{"$":0},"saxo":{"$":0},"sbi":{"$":0},"sbs":{"$":0},"scb":{"$":0},"schaeffler":{"$":0},"schmidt":{"$":0},"scholarships":{"$":0},"school":{"$":0},"schule":{"$":0},"schwarz":{"$":0},"science":{"$":0},"scot":{"$":0,"gov":{"$":0,"service":{"$":0}}},"search":{"$":0},"seat":{"$":0},"secure":{"$":0},"security":{"$":0},"seek":{"$":0},"select":{"$":0},"sener":{"$":0},"services":{"$":0,"loginline":{"$":0}},"seven":{"$":0},"sew":{"$":0},"sex":{"$":0},"sexy":{"$":0},"sfr":{"$":0},"shangrila":{"$":0},"sharp":{"$":0},"shell":{"$":0},"shia":{"$":0},"shiksha":{"$":0},"shoes":{"$":0},"shop":{"$":0,"base":{"$":0},"hoplix":{"$":0},"barsy":{"$":0},"barsyonline":{"$":0},"shopware":{"$":0}},"shopping":{"$":0},"shouji":{"$":0},"show":{"$":0},"silk":{"$":0},"sina":{"$":0},"singles":{"$":0},"site":{"$":0,"square":{"$":0},"canva":{"my":{"$":0}},"cloudera":{"*":{"$":0}},"convex":{"$":0},"cyon":{"$":0},"caffeine":{"$":0},"fastvps":{"$":0},"figma":{"$":0},"preview":{"$":0},"heyflow":{"$":0},"jele":{"$":0},"jouwweb":{"$":0},"loginline":{"$":0},"barsy":{"$":0},"notion":{"$":0},"omniwe":{"$":0},"opensocial":{"$":0},"madethis":{"$":0},"platformsh":{"*":{"$":0}},"tst":{"*":{"$":0}},"byen":{"$":0},"srht":{"$":0},"novecore":{"$":0},"cpanel":{"$":0},"wpsquared":{"$":0}},"ski":{"$":0},"skin":{"$":0},"sky":{"$":0},"skype":{"$":0},"sling":{"$":0},"smart":{"$":0},"smile":{"$":0},"sncf":{"$":0},"soccer":{"$":0},"social":{"$":0},"softbank":{"$":0},"software":{"$":0},"sohu":{"$":0},"solar":{"$":0},"solutions":{"$":0},"song":{"$":0},"sony":{"$":0},"soy":{"$":0},"spa":{"$":0},"space":{"$":0,"myfast":{"$":0},"heiyu":{"$":0},"hf":{"$":0,"static":{"$":0}},"app-ionos":{"$":0},"project":{"$":0},"uber":{"$":0},"xs4all":{"$":0}},"sport":{"$":0},"spot":{"$":0},"srl":{"$":0},"stada":{"$":0},"staples":{"$":0},"star":{"$":0},"statebank":{"$":0},"statefarm":{"$":0},"stc":{"$":0},"stcgroup":{"$":0},"stockholm":{"$":0},"storage":{"$":0},"store":{"$":0,"barsy":{"$":0},"sellfy":{"$":0},"shopware":{"$":0},"storebase":{"$":0}},"stream":{"$":0},"studio":{"$":0},"study":{"$":0},"style":{"$":0},"sucks":{"$":0},"supplies":{"$":0},"supply":{"$":0},"support":{"$":0,"barsy":{"$":0}},"surf":{"$":0},"surgery":{"$":0},"suzuki":{"$":0},"swatch":{"$":0},"swiss":{"$":0},"sydney":{"$":0},"systems":{"$":0,"knightpoint":{"$":0}},"tab":{"$":0},"taipei":{"$":0},"talk":{"$":0},"taobao":{"$":0},"target":{"$":0},"tatamotors":{"$":0},"tatar":{"$":0},"tattoo":{"$":0},"tax":{"$":0},"taxi":{"$":0},"tci":{"$":0},"tdk":{"$":0},"team":{"$":0,"discourse":{"$":0},"jelastic":{"$":0}},"tech":{"$":0,"cleverapps":{"$":0}},"technology":{"$":0,"co":{"$":0}},"temasek":{"$":0},"tennis":{"$":0},"teva":{"$":0},"thd":{"$":0},"theater":{"$":0},"theatre":{"$":0},"tiaa":{"$":0},"tickets":{"$":0},"tienda":{"$":0},"tips":{"$":0},"tires":{"$":0},"tirol":{"$":0},"tjmaxx":{"$":0},"tjx":{"$":0},"tkmaxx":{"$":0},"tmall":{"$":0},"today":{"$":0,"prequalifyme":{"$":0}},"tokyo":{"$":0},"tools":{"$":0,"addr":{"dyn":{"$":0}},"myaddr":{"$":0}},"top":{"$":0,"ntdll":{"$":0},"wadl":{"*":{"$":0}}},"toray":{"$":0},"toshiba":{"$":0},"total":{"$":0},"tours":{"$":0},"town":{"$":0},"toyota":{"$":0},"toys":{"$":0},"trade":{"$":0},"trading":{"$":0},"training":{"$":0},"travel":{"$":0},"travelers":{"$":0},"travelersinsurance":{"$":0},"trust":{"$":0},"trv":{"$":0},"tube":{"$":0},"tui":{"$":0},"tunes":{"$":0},"tushu":{"$":0},"tvs":{"$":0},"ubank":{"$":0},"ubs":{"$":0},"unicom":{"$":0},"university":{"$":0},"uno":{"$":0},"uol":{"$":0},"ups":{"$":0},"vacations":{"$":0},"vana":{"$":0},"vanguard":{"$":0},"vegas":{"$":0},"ventures":{"$":0},"verisign":{"$":0},"versicherung":{"$":0},"vet":{"$":0},"viajes":{"$":0},"video":{"$":0},"vig":{"$":0},"viking":{"$":0},"villas":{"$":0},"vin":{"$":0},"vip":{"$":0},"virgin":{"$":0},"visa":{"$":0},"vision":{"$":0},"viva":{"$":0},"vivo":{"$":0},"vlaanderen":{"$":0},"vodka":{"$":0},"volvo":{"$":0},"vote":{"$":0},"voting":{"$":0},"voto":{"$":0},"voyage":{"$":0},"wales":{"$":0},"walmart":{"$":0},"walter":{"$":0},"wang":{"$":0},"wanggou":{"$":0},"watch":{"$":0},"watches":{"$":0},"weather":{"$":0},"weatherchannel":{"$":0},"webcam":{"$":0},"weber":{"$":0},"website":{"$":0,"framer":{"$":0}},"wed":{"$":0},"wedding":{"$":0},"weibo":{"$":0},"weir":{"$":0},"whoswho":{"$":0},"wien":{"$":0},"wiki":{"$":0,"framer":{"$":0}},"williamhill":{"$":0},"win":{"$":0},"windows":{"$":0},"wine":{"$":0},"winners":{"$":0},"wme":{"$":0},"wolterskluwer":{"$":0},"woodside":{"$":0},"work":{"$":0},"works":{"$":0},"world":{"$":0},"wow":{"$":0},"wtc":{"$":0},"wtf":{"$":0},"xbox":{"$":0},"xerox":{"$":0},"xihuan":{"$":0},"xin":{"$":0},"xn--11b4c3d":{"$":0},"xn--1ck2e1b":{"$":0},"xn--1qqw23a":{"$":0},"xn--30rr7y":{"$":0},"xn--3bst00m":{"$":0},"xn--3ds443g":{"$":0},"xn--3pxu8k":{"$":0},"xn--42c2d9a":{"$":0},"xn--45q11c":{"$":0},"xn--4gbrim":{"$":0},"xn--55qw42g":{"$":0},"xn--55qx5d":{"$":0},"xn--5su34j936bgsg":{"$":0},"xn--5tzm5g":{"$":0},"xn--6frz82g":{"$":0},"xn--6qq986b3xl":{"$":0},"xn--80adxhks":{"$":0},"xn--80aqecdr1a":{"$":0},"xn--80asehdb":{"$":0},"xn--80aswg":{"$":0},"xn--8y0a063a":{"$":0},"xn--9dbq2a":{"$":0},"xn--9et52u":{"$":0},"xn--9krt00a":{"$":0},"xn--b4w605ferd":{"$":0},"xn--bck1b9a5dre4c":{"$":0},"xn--c1avg":{"$":0},"xn--c2br7g":{"$":0},"xn--cck2b3b":{"$":0},"xn--cckwcxetd":{"$":0},"xn--cg4bki":{"$":0},"xn--czr694b":{"$":0},"xn--czrs0t":{"$":0},"xn--czru2d":{"$":0},"xn--d1acj3b":{"$":0},"xn--eckvdtc9d":{"$":0},"xn--efvy88h":{"$":0},"xn--fct429k":{"$":0},"xn--fhbei":{"$":0},"xn--fiq228c5hs":{"$":0},"xn--fiq64b":{"$":0},"xn--fjq720a":{"$":0},"xn--flw351e":{"$":0},"xn--fzys8d69uvgm":{"$":0},"xn--g2xx48c":{"$":0},"xn--gckr3f0f":{"$":0},"xn--gk3at1e":{"$":0},"xn--hxt814e":{"$":0},"xn--i1b6b1a6a2e":{"$":0},"xn--imr513n":{"$":0},"xn--io0a7i":{"$":0},"xn--j1aef":{"$":0},"xn--jlq480n2rg":{"$":0},"xn--jvr189m":{"$":0},"xn--kcrx77d1x4a":{"$":0},"xn--kput3i":{"$":0},"xn--mgba3a3ejt":{"$":0},"xn--mgba7c0bbn0a":{"$":0},"xn--mgbab2bd":{"$":0},"xn--mgbca7dzdo":{"$":0},"xn--mgbi4ecexp":{"$":0},"xn--mgbt3dhd":{"$":0},"xn--mk1bu44c":{"$":0},"xn--mxtq1m":{"$":0},"xn--ngbc5azd":{"$":0},"xn--ngbe9e0a":{"$":0},"xn--ngbrx":{"$":0},"xn--nqv7f":{"$":0},"xn--nqv7fs00ema":{"$":0},"xn--nyqy26a":{"$":0},"xn--otu796d":{"$":0},"xn--p1acf":{"$":0,"xn--90amc":{"$":0},"xn--j1aef":{"$":0},"xn--j1ael8b":{"$":0},"xn--h1ahn":{"$":0},"xn--j1adp":{"$":0},"xn--c1avg":{"$":0},"xn--80aaa0cvac":{"$":0},"xn--h1aliz":{"$":0},"xn--90a1af":{"$":0},"xn--41a":{"$":0}},"xn--pssy2u":{"$":0},"xn--q9jyb4c":{"$":0},"xn--qcka1pmc":{"$":0},"xn--rhqv96g":{"$":0},"xn--rovu88b":{"$":0},"xn--ses554g":{"$":0},"xn--t60b56a":{"$":0},"xn--tckwe":{"$":0},"xn--tiq49xqyj":{"$":0},"xn--unup4y":{"$":0},"xn--vermgensberater-ctb":{"$":0},"xn--vermgensberatung-pwb":{"$":0},"xn--vhquv":{"$":0},"xn--vuq861b":{"$":0},"xn--w4r85el8fhu5dnra":{"$":0},"xn--w4rs40l":{"$":0},"xn--xhq521b":{"$":0},"xn--zfr164b":{"$":0},"xyz":{"$":0,"botdash":{"$":0},"telebit":{"*":{"$":0}}},"yachts":{"$":0},"yahoo":{"$":0},"yamaxun":{"$":0},"yandex":{"$":0},"yodobashi":{"$":0},"yoga":{"$":0},"yokohama":{"$":0},"you":{"$":0},"youtube":{"$":0},"yun":{"$":0},"zappos":{"$":0},"zara":{"$":0},"zero":{"$":0},"zip":{"$":0},"zone":{"$":0,"triton":{"*":{"$":0}},"stackit":{"$":0},"lima":{"$":0}},"zuerich":{"$":0}}}
|
|
},{}]},{},[1])(1)
|
|
});
|