jscrewit 2.29.0 → 2.33.0

package/lib/jscrewit.js

@@ -1,11 +1,10 @@
-// JScrewIt 2.29.0 – https://jscrew.it
+// JScrewIt 2.33.0 – https://jscrew.it
 
 (function () {
     'use strict';
 
     var _Array                           = Array;
-    var _Array_isArray                   = _Array.isArray;
-    var _Array_prototype_every_call;
+    var _Array_isArray$1                   = _Array.isArray;
     var _Array_prototype_forEach_call;
     var _Array_prototype_map_call;
     var _Array_prototype_push_apply;
@@ -13,12 +12,12 @@
 
     var _Date                            = Date;
 
-    var _Error                           = Error;
+    var _Error$1                           = Error;
 
     var _Function                        = Function;
 
     var _JSON_parse                      = JSON.parse;
-    var _JSON_stringify                  = JSON.stringify;
+    var _JSON_stringify$1                  = JSON.stringify;
 
     var _Math_abs                        = Math.abs;
     var _Math_max                        = Math.max;
@@ -26,53 +25,52 @@
     var _Math_pow                        = Math.pow;
 
     var _Object                          = Object;
-    var _Object_create                   = _Object.create;
-    var _Object_defineProperty           = _Object.defineProperty;
-    var _Object_freeze                   = _Object.freeze;
-    var _Object_getOwnPropertyDescriptor = _Object.getOwnPropertyDescriptor;
-    var _Object_keys                     = _Object.keys;
+    var _Object_create$1                   = _Object.create;
+    var _Object_defineProperty$1           = _Object.defineProperty;
+    var _Object_getOwnPropertyDescriptor$1 = _Object.getOwnPropertyDescriptor;
+    var _Object_keys$1                     = _Object.keys;
 
     var _RegExp                          = RegExp;
 
-    var _String                          = String;
+    var _String$1                          = String;
 
     var _SyntaxError                     = SyntaxError;
 
-    var _TypeError                       = TypeError;
+    var _TypeError$1                       = TypeError;
 
     var _parseInt                        = parseInt;
 
     var _setTimeout                      = setTimeout;
 
-    function assignNoEnum(target, source)
+    function assignNoEnum$1(target, source)
     {
-        var names = _Object_keys(source);
+        var names = _Object_keys$1(source);
         names.forEach
         (
             function (name)
             {
-                var descriptor = _Object_getOwnPropertyDescriptor(source, name);
+                var descriptor = _Object_getOwnPropertyDescriptor$1(source, name);
                 descriptor.enumerable = false;
-                _Object_defineProperty(target, name, descriptor);
+                _Object_defineProperty$1(target, name, descriptor);
             }
         );
         return target;
     }
 
-    var createEmpty = _Object_create.bind(null, null, undefined);
+    var createEmpty = _Object_create$1.bind(null, null, undefined);
 
-    function esToString(arg)
+    function esToString$1(arg)
     {
         if (typeof arg === 'symbol')
-            throw new _TypeError('Cannot convert a symbol to a string');
-        var str = _String(arg);
+            throw new _TypeError$1('Cannot convert a symbol to a string');
+        var str = _String$1(arg);
         return str;
     }
 
     function noProto(obj)
     {
         var result = createEmpty();
-        _Object_keys(obj).forEach
+        _Object_keys$1(obj).forEach
         (
             function (name)
             {
@@ -105,7 +103,7 @@
         var _Function_prototype_apply   = _Function_prototype.apply;
         var _Function_prototype_call    = _Function_prototype.call;
 
-        _Array_prototype_every_call     = _Function_prototype_call.bind(_Array_prototype.every);
+        _Function_prototype_call.bind(_Array_prototype.every);
         _Array_prototype_forEach_call   = _Function_prototype_call.bind(_Array_prototype.forEach);
         _Array_prototype_map_call       = _Function_prototype_call.bind(_Array_prototype.map);
         _Array_prototype_slice_call     = _Function_prototype_call.bind(_Array_prototype.slice);
@@ -248,7 +246,18 @@
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     }
 
-    // quinquaginta-duo 3.1.1 – https://github.com/fasttime/JScrewIt/tree/master/packages/quinquaginta-duo
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    // ~feature-hub – https://github.com/fasttime/JScrewIt/tree/master/packages/~feature-hub
 
     var BIN_POW_31 = 2147483648;
     var BIN_POW_32 = 4294967296;
@@ -370,60 +379,514 @@
         return MaskSet;
     }(MaskIndex));
 
-    var ALL                     = createEmpty();
-    var DESCRIPTION_MAP         = createEmpty();
-    var ELEMENTARY              = [];
-    var FEATURE_PROTOTYPE       = Feature.prototype;
-    var INCLUDES_MAP            = createEmpty();
-    var INCOMPATIBLE_MASK_LIST  = [];
-
-    function Feature()
-    {
-        var mask = validMaskFromArguments(arguments);
-        var featureObj = this instanceof Feature ? this : _Object_create(FEATURE_PROTOTYPE);
-        initMask(featureObj, mask);
-        return featureObj;
-    }
-
-    function areCompatible()
-    {
-        var arg0;
-        var features =
-        arguments.length === 1 && _Array_isArray(arg0 = arguments[0]) ? arg0 : arguments;
-        var compatible;
-        if (features.length > 1)
-        {
+    var _Array_isArray = Array.isArray;
+    var _Error = Error;
+    var _JSON_stringify = JSON.stringify;
+    var _Object_create = Object.create, _Object_defineProperty = Object.defineProperty, _Object_freeze = Object.freeze, _Object_getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, _Object_keys = Object.keys;
+    var _String = String;
+    var _TypeError = TypeError;
+    function assignNoEnum(target, source) {
+        var names = _Object_keys(source);
+        for (var _i = 0, names_1 = names; _i < names_1.length; _i++) {
+            var name_1 = names_1[_i];
+            var descriptor = _Object_getOwnPropertyDescriptor(source, name_1);
+            descriptor.enumerable = false;
+            _Object_defineProperty(target, name_1, descriptor);
+        }
+    }
+    function createFeatureClass(featureInfos, formatEngineDescription) {
+        var ALL = createMap();
+        var DESCRIPTION_MAP = createMap();
+        var ELEMENTARY = [];
+        var ENGINE = [];
+        var FAMILIES = createMap();
+        var FEATURE_PROTOTYPE = Feature.prototype;
+        var INCOMPATIBLE_MASK_LIST = [];
+        var PRISTINE_ELEMENTARY;
+        function Feature() {
+            var features = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                features[_i] = arguments[_i];
+            }
+            var mask = maskNew();
+            for (var _a = 0, features_1 = features; _a < features_1.length; _a++) {
+                var feature = features_1[_a];
+                var otherMask = validMaskFromArrayOrStringOrFeature(feature);
+                mask = maskUnion(mask, otherMask);
+            }
+            if (features.length > 1)
+                validateMask(mask);
+            var featureObj = this instanceof Feature ? this : _Object_create(FEATURE_PROTOTYPE);
+            initMask(featureObj, mask);
+            return featureObj;
+        }
+        function _fromMask(mask) {
+            if (isMaskCompatible(mask)) {
+                var includedMask = maskNew();
+                for (var _i = 0, ELEMENTARY_1 = ELEMENTARY; _i < ELEMENTARY_1.length; _i++) {
+                    var featureMask = ELEMENTARY_1[_i].mask;
+                    if (maskIncludes(mask, featureMask))
+                        includedMask = maskUnion(includedMask, featureMask);
+                }
+                if (maskAreEqual(mask, includedMask)) {
+                    var featureObj = featureFromMask(mask);
+                    return featureObj;
+                }
+            }
+            return null;
+        }
+        function _getMask(feature) {
+            var mask = feature !== undefined ? validMaskFromArrayOrStringOrFeature(feature) : maskNew();
+            return mask;
+        }
+        function areCompatible() {
+            var arg0;
+            var features = arguments.length === 1 &&
+                _Array_isArray(arg0 = arguments[0]) ?
+                arg0 : arguments;
             var mask = featureArrayLikeToMask(features);
-            compatible = isMaskCompatible(mask);
+            var compatible = isMaskCompatible(mask);
+            return compatible;
         }
-        else
-            compatible = true;
-        return compatible;
-    }
-
-    function areEqual()
-    {
-        var mask;
-        var equal =
-        _Array_prototype_every_call
-        (
-            arguments,
-            function (arg, index)
-            {
+        function areEqual() {
+            var features = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                features[_i] = arguments[_i];
+            }
+            var mask;
+            var equal = features.every(function (feature, index) {
                 var returnValue;
-                var otherMask = validMaskFromArrayOrStringOrFeature(arg);
+                var otherMask = validMaskFromArrayOrStringOrFeature(feature);
                 if (index)
                     returnValue = maskAreEqual(otherMask, mask);
-                else
-                {
+                else {
                     mask = otherMask;
                     returnValue = true;
                 }
                 return returnValue;
+            });
+            return equal;
+        }
+        function commonOf() {
+            var features = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                features[_i] = arguments[_i];
             }
-        );
-        return equal;
+            var featureObj;
+            if (features.length) {
+                var mask = void 0;
+                for (var _a = 0, features_2 = features; _a < features_2.length; _a++) {
+                    var feature = features_2[_a];
+                    var otherMask = validMaskFromArrayOrStringOrFeature(feature);
+                    if (mask != null)
+                        mask = maskIntersection(mask, otherMask);
+                    else
+                        mask = otherMask;
+                }
+                featureObj = featureFromMask(mask);
+            }
+            else
+                featureObj = null;
+            return featureObj;
+        }
+        function createFeature(name, mask, check, attributes, elementary) {
+            _Object_freeze(attributes);
+            var descriptors = { attributes: { value: attributes }, check: { value: check }, name: { value: name } };
+            if (elementary)
+                descriptors.elementary = { value: true };
+            var featureObj = _Object_create(FEATURE_PROTOTYPE, descriptors);
+            initMask(featureObj, mask);
+            return featureObj;
+        }
+        function descriptionFor(name) {
+            name = esToString(name);
+            if (!(name in DESCRIPTION_MAP))
+                throwUnknownFeatureError(name);
+            var description = DESCRIPTION_MAP[name];
+            return description;
+        }
+        function featureArrayLikeToMask(features) {
+            var mask = maskNew();
+            var length = features.length;
+            for (var index = 0; index < length; ++index) {
+                var feature = features[index];
+                var otherMask = maskFromStringOrFeature(feature);
+                mask = maskUnion(mask, otherMask);
+            }
+            return mask;
+        }
+        function featureFromMask(mask) {
+            var featureObj = _Object_create(FEATURE_PROTOTYPE);
+            initMask(featureObj, mask);
+            return featureObj;
+        }
+        /**
+         * Node.js custom inspection function.
+         * Set on `Feature.prototype` with name `"inspect"` for Node.js ≤ 8.6.x and with symbol
+         * `Symbol.for("nodejs.util.inspect.custom")` for Node.js ≥ 6.6.x.
+         *
+         * @see
+         * {@link https://nodejs.org/api/util.html#util_custom_inspection_functions_on_objects} for
+         * further information.
+         */
+        // opts can be undefined in Node.js 0.10.0.
+        function inspect(depth, opts) {
+            var _a, _b;
+            var breakLength = (_a = opts === null || opts === void 0 ? void 0 : opts.breakLength) !== null && _a !== void 0 ? _a : 80;
+            var compact = (_b = opts === null || opts === void 0 ? void 0 : opts.compact) !== null && _b !== void 0 ? _b : true;
+            var name = this.name;
+            if (name === undefined)
+                name = joinParts(compact, '<', '', this.canonicalNames, ',', '>', breakLength - 3);
+            var parts = [name];
+            if (this.elementary)
+                parts.push('(elementary)');
+            if (this.check)
+                parts.push('(check)');
+            {
+                var attributes = this.attributes;
+                if (typeof attributes === 'object') {
+                    var str_1 = utilInspect(__assign({}, attributes), opts);
+                    parts.push(str_1);
+                }
+            }
+            var str = joinParts(compact, '[Feature', ' ', parts, '', ']', breakLength - 1);
+            return str;
+        }
+        function isMaskCompatible(mask) {
+            var compatible = INCOMPATIBLE_MASK_LIST.every(function (incompatibleMask) { return !maskIncludes(mask, incompatibleMask); });
+            return compatible;
+        }
+        function maskFromStringOrFeature(feature) {
+            var featureObj;
+            if (feature instanceof Feature)
+                featureObj = feature;
+            else {
+                var name_2 = esToString(feature);
+                if (!(name_2 in ALL))
+                    throwUnknownFeatureError(name_2);
+                featureObj = ALL[name_2];
+            }
+            var mask = featureObj.mask;
+            return mask;
+        }
+        function validMaskFromArrayOrStringOrFeature(feature) {
+            var mask;
+            if (_Array_isArray(feature)) {
+                mask = featureArrayLikeToMask(feature);
+                if (feature.length > 1)
+                    validateMask(mask);
+            }
+            else
+                mask = maskFromStringOrFeature(feature);
+            return mask;
+        }
+        function validateMask(mask) {
+            if (!isMaskCompatible(mask))
+                throw new _Error('Incompatible features');
+        }
+        var utilInspect;
+        try {
+            utilInspect = require('util').inspect;
+        }
+        catch (_a) { }
+        {
+            var protoSource = {
+                get canonicalNames() {
+                    var mask = this.mask;
+                    var names = [];
+                    var includedMask = maskNew();
+                    for (var index = PRISTINE_ELEMENTARY.length; index--;) {
+                        var featureObj = PRISTINE_ELEMENTARY[index];
+                        var featureMask = featureObj.mask;
+                        if (maskIncludes(mask, featureMask) && !maskIncludes(includedMask, featureMask)) {
+                            includedMask = maskUnion(includedMask, featureMask);
+                            names.push(featureObj.name);
+                        }
+                    }
+                    names.sort();
+                    return names;
+                },
+                elementary: false,
+                get elementaryNames() {
+                    var names = [];
+                    var mask = this.mask;
+                    for (var _i = 0, ELEMENTARY_2 = ELEMENTARY; _i < ELEMENTARY_2.length; _i++) {
+                        var featureObj = ELEMENTARY_2[_i];
+                        var included = maskIncludes(mask, featureObj.mask);
+                        if (included)
+                            names.push(featureObj.name);
+                    }
+                    return names;
+                },
+                includes: function () {
+                    var features = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        features[_i] = arguments[_i];
+                    }
+                    var mask = this.mask;
+                    var included = features.every(function (feature) {
+                        var otherMask = validMaskFromArrayOrStringOrFeature(feature);
+                        var returnValue = maskIncludes(mask, otherMask);
+                        return returnValue;
+                    });
+                    return included;
+                },
+                name: undefined,
+                toString: function () {
+                    var _a;
+                    var name = (_a = this.name) !== null && _a !== void 0 ? _a : "<" + this.canonicalNames.join(', ') + ">";
+                    var str = "[Feature " + name + "]";
+                    return str;
+                },
+            };
+            if (utilInspect)
+                protoSource.inspect = inspect;
+            assignNoEnum(FEATURE_PROTOTYPE, protoSource);
+        }
+        (function () {
+            var compareFeatureNames = function (feature1, feature2) {
+                return feature1.name < feature2.name ? -1 : 1;
+            };
+            function completeExclusions() {
+                var incompatibleMaskSet = new MaskSet();
+                for (var _i = 0, featureNames_1 = featureNames; _i < featureNames_1.length; _i++) {
+                    var name_3 = featureNames_1[_i];
+                    var excludes = featureInfos[name_3].excludes;
+                    if (excludes) {
+                        var mask = ALL[name_3].mask;
+                        for (var _a = 0, excludes_1 = excludes; _a < excludes_1.length; _a++) {
+                            var exclude = excludes_1[_a];
+                            var excludeMask = completeFeature(exclude);
+                            var incompatibleMask = maskUnion(mask, excludeMask);
+                            if (!incompatibleMaskSet.has(incompatibleMask)) {
+                                INCOMPATIBLE_MASK_LIST.push(incompatibleMask);
+                                incompatibleMaskSet.add(incompatibleMask);
+                            }
+                        }
+                    }
+                }
+            }
+            function completeFeature(name) {
+                var mask;
+                if (name in ALL)
+                    (mask = ALL[name].mask);
+                else {
+                    var info_1 = featureInfos[name];
+                    var getInfoStringField = function (fieldName) {
+                        return fieldName in info_1 ?
+                            esToString(info_1[fieldName]) : undefined;
+                    };
+                    var description = getInfoStringField('description');
+                    var featureObj = void 0;
+                    if ('aliasFor' in info_1) {
+                        var aliasFor = esToString(info_1.aliasFor);
+                        mask = completeFeature(aliasFor);
+                        featureObj = ALL[aliasFor];
+                        if (description == null)
+                            description = DESCRIPTION_MAP[aliasFor];
+                    }
+                    else {
+                        var inherits = getInfoStringField('inherits');
+                        if (inherits != null)
+                            completeFeature(inherits);
+                        var wrappedCheck = void 0;
+                        var compatibilities = void 0;
+                        var check = info_1.check;
+                        if (check !== undefined) {
+                            mask = maskNext(unionMask);
+                            unionMask = maskUnion(unionMask, mask);
+                            wrappedCheck = wrapCheck(check);
+                        }
+                        else {
+                            mask = maskNew();
+                            wrappedCheck = null;
+                        }
+                        {
+                            var includes = info_1.includes;
+                            var includeSet = includeSetMap[name] = createMap();
+                            if (_Array_isArray(includes)) {
+                                for (var _i = 0, includes_1 = includes; _i < includes_1.length; _i++) {
+                                    var include = includes_1[_i];
+                                    includeSet[include] = null;
+                                }
+                            }
+                            else {
+                                if (inherits != null) {
+                                    var inheritedIncludeSet = includeSetMap[inherits];
+                                    for (var include in inheritedIncludeSet)
+                                        includeSet[include] = null;
+                                }
+                                if (includes) {
+                                    var includeDiffNames = _Object_keys(includes);
+                                    for (var _a = 0, includeDiffNames_1 = includeDiffNames; _a < includeDiffNames_1.length; _a++) {
+                                        var include = includeDiffNames_1[_a];
+                                        if (includes[include])
+                                            includeSet[include] = null;
+                                        else
+                                            delete includeSet[include];
+                                    }
+                                }
+                            }
+                            for (var include in includeSet) {
+                                var includeMask = completeFeature(include);
+                                mask = maskUnion(mask, includeMask);
+                            }
+                        }
+                        if ('versions' in info_1) {
+                            var families = info_1.families;
+                            var versions_1 = info_1.versions;
+                            if (inherits != null)
+                                families !== null && families !== void 0 ? families : (families = familiesMap[inherits]);
+                            familiesMap[name] = families;
+                            var tag_1 = getInfoStringField('compatibilityTag');
+                            var shortTag_1 = getInfoStringField('compatibilityShortTag');
+                            compatibilities =
+                                families.map(function (family, index) {
+                                    var _a;
+                                    family = esToString(family);
+                                    var versionInfo = versions_1[index];
+                                    var version;
+                                    if (_Array_isArray(versionInfo)) {
+                                        var length_1 = versionInfo.length;
+                                        var from = esToString(versionInfo[0]);
+                                        var to = length_1 < 2 ? undefined : esToString(versionInfo[length_1 - 1]);
+                                        var dense = versionInfo.length === 2;
+                                        version = _Object_freeze({ from: from, to: to, dense: dense });
+                                    }
+                                    else
+                                        version = esToString(versionInfo);
+                                    var compatibility = _Object_freeze({ family: family, featureName: name, version: version, tag: tag_1, shortTag: shortTag_1 });
+                                    var familyCompatibilities = (_a = FAMILIES[family]) !== null && _a !== void 0 ? _a : (FAMILIES[family] = []);
+                                    familyCompatibilities.push(compatibility);
+                                    return compatibility;
+                                });
+                            if (description == null)
+                                description = formatEngineDescription === null || formatEngineDescription === void 0 ? void 0 : formatEngineDescription(compatibilities);
+                        }
+                        var attributes = createMap();
+                        if (inherits != null) {
+                            var inheritedAttributes = ALL[inherits].attributes;
+                            for (var attributeName in inheritedAttributes)
+                                attributes[attributeName] = inheritedAttributes[attributeName];
+                        }
+                        {
+                            var infoAttributes = info_1.attributes;
+                            if (infoAttributes !== undefined) {
+                                var attributeNames = _Object_keys(infoAttributes);
+                                for (var _b = 0, attributeNames_1 = attributeNames; _b < attributeNames_1.length; _b++) {
+                                    var attributeName = attributeNames_1[_b];
+                                    var attributeValue = infoAttributes[attributeName];
+                                    if (attributeValue !== undefined) {
+                                        attributes[attributeName] =
+                                            typeof attributeValue === 'string' ? attributeValue : null;
+                                    }
+                                    else
+                                        delete attributes[attributeName];
+                                }
+                            }
+                        }
+                        var elementary = wrappedCheck !== null && wrappedCheck !== void 0 ? wrappedCheck : info_1.excludes;
+                        featureObj = createFeature(name, mask, wrappedCheck, attributes, elementary);
+                        if (elementary)
+                            ELEMENTARY.push(featureObj);
+                        if (compatibilities)
+                            ENGINE.push(featureObj);
+                    }
+                    ALL[name] = featureObj;
+                    DESCRIPTION_MAP[name] = description;
+                }
+                return mask;
+            }
+            {
+                var constructorSource = {
+                    ALL: ALL,
+                    ELEMENTARY: ELEMENTARY,
+                    ENGINE: ENGINE,
+                    FAMILIES: FAMILIES,
+                    _fromMask: _fromMask,
+                    _getMask: _getMask,
+                    areCompatible: areCompatible,
+                    areEqual: areEqual,
+                    commonOf: commonOf,
+                    descriptionFor: descriptionFor,
+                };
+                assignNoEnum(Feature, constructorSource);
+            }
+            if (utilInspect) {
+                var inspectKey = utilInspect.custom;
+                if (inspectKey) {
+                    _Object_defineProperty(FEATURE_PROTOTYPE, inspectKey, { configurable: true, value: inspect, writable: true });
+                }
+            }
+            var featureNames = _Object_keys(featureInfos);
+            var includeSetMap = createMap();
+            var familiesMap = createMap();
+            var unionMask = maskNew();
+            featureNames.forEach(completeFeature);
+            completeExclusions();
+            PRISTINE_ELEMENTARY = ELEMENTARY.slice();
+            ELEMENTARY.sort(compareFeatureNames);
+            _Object_freeze(ELEMENTARY);
+            ENGINE.sort(compareFeatureNames);
+            _Object_freeze(ENGINE);
+            _Object_freeze(ALL);
+            _Object_freeze(FAMILIES);
+            for (var family in FAMILIES)
+                _Object_freeze(FAMILIES[family]);
+        })();
+        return Feature;
+    }
+    var createMap = function () { return _Object_create(null); };
+    function esToString(name) {
+        if (typeof name === 'symbol')
+            throw new _TypeError('Cannot convert a symbol to a string');
+        var str = _String(name);
+        return str;
+    }
+    function featuresToMask(featureObjs) {
+        var mask = featureObjs.reduce(function (mask, featureObj) { return maskUnion(mask, featureObj.mask); }, maskNew());
+        return mask;
+    }
+    function indent(text) {
+        var returnValue = text.replace(/^/gm, '  ');
+        return returnValue;
+    }
+    function initMask(featureObj, mask) {
+        _Object_defineProperty(featureObj, 'mask', { value: mask });
+    }
+    function joinParts(compact, intro, preSeparator, parts, partSeparator, outro, maxLength) {
+        function isMultiline() {
+            var length = intro.length +
+                preSeparator.length +
+                (parts.length - 1) * (partSeparator.length + 1) +
+                outro.length;
+            for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+                var part = parts_1[_i];
+                if (~part.indexOf('\n'))
+                    return true;
+                length += part.replace(/\x1b\[\d+m/g, '').length;
+                if (length > maxLength)
+                    return true;
+            }
+            return false;
+        }
+        var str = parts.length && (!compact || isMultiline()) ?
+            intro + "\n" + indent(parts.join(partSeparator + "\n")) + "\n" + outro :
+            "" + intro + preSeparator + parts.join(partSeparator + " ") + outro;
+        return str;
+    }
+    function throwUnknownFeatureError(name) {
+        throw new _Error("Unknown feature " + _JSON_stringify(name));
     }
+    function wrapCheck(check) {
+        var wrappedCheck = function () { return !!check(); };
+        return wrappedCheck;
+    }
+
+    // End of module ~feature-hub
+
+    var ELEMENTARY;
+    var Feature;
 
     function checkLocaleNumeral(locale, number, regExp)
     {
@@ -447,2123 +910,1303 @@
         return available;
     }
 
-    function commonOf()
-    {
-        var returnValue;
-        if (arguments.length)
-        {
-            var mask;
-            _Array_prototype_forEach_call
-            (
-                arguments,
-                function (arg)
-                {
-                    var otherMask = validMaskFromArrayOrStringOrFeature(arg);
-                    if (mask != null)
-                        mask = maskIntersection(mask, otherMask);
-                    else
-                        mask = otherMask;
-                }
-            );
-            returnValue = featureFromMask(mask);
-        }
-        else
-            returnValue = null;
-        return returnValue;
-    }
-
-    function descriptionFor(name)
+    function describeEngine(engine)
     {
-        name = esToString(name);
-        var description = DESCRIPTION_MAP[name];
-        if (description == null)
-            throw new _Error('Unknown feature ' + _JSON_stringify(name));
+        var description = 'Features available in ' + engine + '.';
         return description;
     }
 
-    function featureArrayLikeToMask(arrayLike)
-    {
-        var mask = maskNew();
-        _Array_prototype_forEach_call
-        (
-            arrayLike,
-            function (feature)
-            {
-                var otherMask = maskFromStringOrFeature(feature);
-                mask = maskUnion(mask, otherMask);
-            }
-        );
-        return mask;
-    }
-
-    function featureFromMask(mask)
-    {
-        var featureObj = _Object_create(FEATURE_PROTOTYPE);
-        initMask(featureObj, mask);
-        return featureObj;
-    }
-
-    function featuresToMask(featureObjs)
-    {
-        var mask = maskNew();
-        featureObjs.forEach
-        (
-            function (featureObj)
-            {
-                mask = maskUnion(mask, featureObj.mask);
-            }
-        );
-        return mask;
-    }
-
-    function initMask(featureObj, mask)
-    {
-        _Object_defineProperty(featureObj, 'mask', { value: mask });
-    }
-
-    /**
-     * Node.js custom inspection function.
-     * Set on `Feature.prototype` with name `"inspect"` for Node.js ≤ 8.6.x and with symbol
-     * `Symbol.for("nodejs.util.inspect.custom")` for Node.js ≥ 6.6.x.
-     *
-     * @function inspect
-     *
-     * @see
-     * {@link https://tiny.cc/j4wz9y|Custom inspection functions on Objects} for further information.
-     */
-    function inspect(depth, opts)
-    {
-        var returnValue;
-        var str = this.toString();
-        if (opts !== undefined) // opts can be undefined in Node.js 0.10.0.
-            returnValue = opts.stylize(str, 'jscrewit-feature');
-        else
-            returnValue = str;
-        return returnValue;
-    }
-
-    function isExcludingAttribute(attributeCache, attributeName, featureObjs)
+    function isExcludingAttribute(restrictionCache, restrictionName, featureObjs)
     {
-        var returnValue = attributeCache[attributeName];
+        var returnValue = restrictionCache[restrictionName];
         if (returnValue === undefined)
         {
-            attributeCache[attributeName] =
+            restrictionCache[restrictionName] =
             returnValue =
             featureObjs.some
             (
                 function (featureObj)
                 {
-                    return attributeName in featureObj.attributes;
+                    var returnValue = restrictionName in featureObj.attributes;
+                    return returnValue;
                 }
             );
         }
         return returnValue;
     }
 
-    function isMaskCompatible(mask)
+    function restrict(environment, engineFeatureObjs)
     {
-        var compatible =
-        INCOMPATIBLE_MASK_LIST.every
+        var restrictionCache = createEmpty();
+        var elementaryFeatureObjs =
+        ELEMENTARY.filter
         (
-            function (incompatibleMask)
+            function (elementaryFeatureObj)
             {
-                var returnValue = !maskIncludes(mask, incompatibleMask);
-                return returnValue;
-            }
+                var included = this.includes(elementaryFeatureObj);
+                if (included)
+                {
+                    var attributes = elementaryFeatureObj.attributes;
+                    included =
+                    !(
+                        environment in attributes &&
+                        (
+                            engineFeatureObjs === undefined ||
+                            isExcludingAttribute
+                            (restrictionCache, attributes[environment], engineFeatureObjs)
+                        )
+                    );
+                }
+                return included;
+            },
+            this
         );
-        return compatible;
+        var restrictedFeatureObj = Feature(elementaryFeatureObjs);
+        return restrictedFeatureObj;
     }
 
-    function maskFromStringOrFeature(arg)
+    var featureInfos =
     {
-        var mask;
-        if (arg instanceof Feature)
-            mask = arg.mask;
-        else
+        ANY_DOCUMENT:
         {
-            var name = esToString(arg);
-            var featureObj = ALL[name];
-            if (!featureObj)
-                throw new _Error('Unknown feature ' + _JSON_stringify(name));
-            mask = featureObj.mask;
-        }
-        return mask;
-    }
-
-    function validateMask(mask)
-    {
-        if (!isMaskCompatible(mask))
-            throw new _Error('Incompatible features');
-    }
-
-    function validMaskFromArguments(args)
-    {
-        var mask = maskNew();
-        var validationNeeded = 0;
-        _Array_prototype_forEach_call
-        (
-            args,
-            function (arg)
+            description:
+            'Existence of the global object document whose string representation starts with ' +
+            '"[object " and ends with "Document]".',
+            check:
+            function ()
             {
-                var otherMask;
-                if (_Array_isArray(arg))
+                var available =
+                typeof document === 'object' && /^\[object [\S\s]*Document]$/.test(document + '');
+                return available;
+            },
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        ANY_WINDOW:
+        {
+            description:
+            'Existence of the global object self whose string representation starts with "[object " ' +
+            'and ends with "Window]".',
+            check:
+            checkSelfFeature.bind
+            (
+                function (str)
                 {
-                    otherMask = featureArrayLikeToMask(arg);
-                    validationNeeded |= arg.length > 1;
+                    var available = /^\[object [\S\s]*Window]$/.test(str);
+                    return available;
                 }
-                else
-                    otherMask = maskFromStringOrFeature(arg);
-                mask = maskUnion(mask, otherMask);
-            }
-        );
-        validationNeeded |= args.length > 1;
-        if (validationNeeded)
-            validateMask(mask);
-        return mask;
-    }
-
-    function validMaskFromArrayOrStringOrFeature(arg)
-    {
-        var mask;
-        if (_Array_isArray(arg))
-        {
-            mask = featureArrayLikeToMask(arg);
-            if (arg.length > 1)
-                validateMask(mask);
-        }
-        else
-            mask = maskFromStringOrFeature(arg);
-        return mask;
-    }
-
-    function wrapCheck(check)
-    {
-        var returnValue =
-        function ()
+            ),
+            includes: ['SELF_OBJ'],
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        ARRAY_ITERATOR:
         {
-            var available = !!check();
-            return available;
-        };
-        return returnValue;
-    }
-
-    assignNoEnum
-    (
-        FEATURE_PROTOTYPE,
+            description:
+            'The property that the string representation of Array.prototype.entries() starts with ' +
+            '"[object Array" and ends with "]" at index 21 or 22.',
+            check:
+            function ()
+            {
+                var available =
+                Array.prototype.entries && /^\[object Array[\S\s]{8,9}]$/.test([].entries());
+                return available;
+            },
+        },
+        ARROW:
         {
-            get canonicalNames()
+            description: 'Support for arrow functions.',
+            check:
+            function ()
             {
-                var mask = this.mask;
-                var featureNameSet = createEmpty();
-                var allIncludes = [];
-                ELEMENTARY.forEach
-                (
-                    function (featureObj)
-                    {
-                        var included = maskIncludes(mask, featureObj.mask);
-                        if (included)
-                        {
-                            var name = featureObj.name;
-                            featureNameSet[name] = null;
-                            var includes = INCLUDES_MAP[name];
-                            _Array_prototype_push_apply(allIncludes, includes);
-                        }
-                    }
-                );
-                allIncludes.forEach
-                (
-                    function (name)
-                    {
-                        delete featureNameSet[name];
-                    }
-                );
-                var names = _Object_keys(featureNameSet).sort();
-                return names;
-            },
-
-            elementary: false,
-
-            get elementaryNames()
-            {
-                var names = [];
-                var mask = this.mask;
-                ELEMENTARY.forEach
-                (
-                    function (featureObj)
-                    {
-                        var included = maskIncludes(mask, featureObj.mask);
-                        if (included)
-                            names.push(featureObj.name);
-                    }
-                );
-                return names;
+                try
+                {
+                    Function('()=>{}')();
+                    return true;
+                }
+                catch (error)
+                { }
             },
-
-            includes:
+        },
+        AT:
+        {
+            description: 'Existence of the native function Array.prototype.at.',
+            check:
             function ()
             {
-                var mask = this.mask;
-                var included =
-                _Array_prototype_every_call
-                (
-                    arguments,
-                    function (arg)
-                    {
-                        var otherMask = validMaskFromArrayOrStringOrFeature(arg);
-                        var returnValue = maskIncludes(mask, otherMask);
-                        return returnValue;
-                    }
-                );
-                return included;
+                var available = Array.prototype.at;
+                return available;
             },
-
-            inspect: inspect,
-
-            name: undefined,
-
-            restrict:
-            function (environment, engineFeatureObjs)
-            {
-                var resultMask = maskNew();
-                var thisMask = this.mask;
-                var attributeCache = createEmpty();
-                ELEMENTARY.forEach
-                (
-                    function (featureObj)
-                    {
-                        var otherMask = featureObj.mask;
-                        var included = maskIncludes(thisMask, otherMask);
-                        if (included)
-                        {
-                            var attributeValue = featureObj.attributes[environment];
-                            if
-                            (
-                                attributeValue === undefined ||
-                                engineFeatureObjs !== undefined &&
-                                !isExcludingAttribute(attributeCache, attributeValue, engineFeatureObjs)
-                            )
-                                resultMask = maskUnion(resultMask, otherMask);
-                        }
-                    }
-                );
-                var returnValue = featureFromMask(resultMask);
-                return returnValue;
-            },
-
-            toString:
+        },
+        ATOB:
+        {
+            description: 'Existence of the global functions atob and btoa.',
+            check:
             function ()
             {
-                var name = this.name;
-                if (name === undefined)
-                    name = '{' + this.canonicalNames.join(', ') + '}';
-                var str = '[Feature ' + name + ']';
-                return str;
+                var available = typeof atob === 'function' && typeof btoa === 'function';
+                return available;
             },
-        }
-    );
-
-    (function (featureInfos)
-    {
-        function completeExclusions()
-        {
-            var incompatibleMaskSet = new MaskSet();
-            featureNames.forEach
-            (
-                function (name)
-                {
-                    var info = featureInfos[name];
-                    var excludes = info.excludes;
-                    if (excludes)
-                    {
-                        var featureObj = ALL[name];
-                        var mask = featureObj.mask;
-                        excludes.forEach
-                        (
-                            function (exclude)
-                            {
-                                var excludeMask = completeFeature(exclude);
-                                var incompatibleMask = maskUnion(mask, excludeMask);
-                                if (!incompatibleMaskSet.has(incompatibleMask))
-                                {
-                                    INCOMPATIBLE_MASK_LIST.push(incompatibleMask);
-                                    incompatibleMaskSet.add(incompatibleMask);
-                                }
-                            }
-                        );
-                    }
-                }
-            );
-        }
-
-        function completeFeature(name)
-        {
-            var mask;
-            var featureObj = ALL[name];
-            if (featureObj)
-                mask = featureObj.mask;
-            else
-            {
-                var description;
-                var info = featureInfos[name];
-                var engine = info.engine;
-                if (engine == null)
-                    description = info.description;
-                else
-                    description = createEngineFeatureDescription(engine);
-                var aliasFor = info.aliasFor;
-                if (aliasFor != null)
-                {
-                    mask = completeFeature(aliasFor);
-                    featureObj = ALL[aliasFor];
-                    if (description == null)
-                        description = DESCRIPTION_MAP[aliasFor];
-                }
-                else
-                {
-                    var check = info.check;
-                    if (check)
-                    {
-                        mask = maskNext(unionMask);
-                        unionMask = maskUnion(unionMask, mask);
-                        if (check())
-                            autoMask = maskUnion(autoMask, mask);
-                        check = wrapCheck(check);
-                    }
-                    else
-                        mask = maskNew();
-                    var includes = INCLUDES_MAP[name] = info.includes || [];
-                    includes.forEach
-                    (
-                        function (include)
-                        {
-                            var includeMask = completeFeature(include);
-                            mask = maskUnion(mask, includeMask);
-                        }
-                    );
-                    var elementary = check || info.excludes;
-                    featureObj = createFeature(name, mask, check, engine, info.attributes, elementary);
-                    if (elementary)
-                        ELEMENTARY.push(featureObj);
-                }
-                registerFeature(name, description, featureObj);
-            }
-            return mask;
-        }
-
-        function createEngineFeatureDescription(engine)
-        {
-            var description = 'Features available in ' + engine + '.';
-            return description;
-        }
-
-        function createFeature(name, mask, check, engine, attributes, elementary)
-        {
-            attributes = _Object_freeze(attributes || { });
-            var descriptors =
-            {
-                attributes:     { value: attributes },
-                check:          { value: check },
-                engine:         { value: engine },
-                name:           { value: name },
-            };
-            if (elementary)
-                descriptors.elementary = { value: true };
-            var featureObj = _Object_create(FEATURE_PROTOTYPE, descriptors);
-            initMask(featureObj, mask);
-            return featureObj;
-        }
-
-        function registerFeature(name, description, featureObj)
-        {
-            var descriptor = { enumerable: true, value: featureObj };
-            _Object_defineProperty(Feature, name, descriptor);
-            ALL[name] = featureObj;
-            DESCRIPTION_MAP[name] = description;
-        }
-
-        var constructorSource =
-        {
-            ALL:            ALL,
-            ELEMENTARY:     ELEMENTARY,
-            areCompatible:  areCompatible,
-            areEqual:       areEqual,
-            commonOf:       commonOf,
-            descriptionFor: descriptionFor,
-        };
-        assignNoEnum(Feature, constructorSource);
-
-        try
-        {
-            var inspectKey = require('util').inspect.custom;
-        }
-        catch (error)
-        { }
-        if (inspectKey)
-        {
-            _Object_defineProperty
-            (FEATURE_PROTOTYPE, inspectKey, { configurable: true, value: inspect, writable: true });
-        }
-
-        var autoMask = maskNew();
-        var unionMask = maskNew();
-
-        var featureNames = _Object_keys(featureInfos);
-        featureNames.forEach(completeFeature);
-        completeExclusions();
-        ELEMENTARY.sort
-        (
-            function (feature1, feature2)
-            {
-                var returnValue = feature1.name < feature2.name ? -1 : 1;
-                return returnValue;
-            }
-        );
-        _Object_freeze(ELEMENTARY);
-        var autoFeatureObj = createFeature('AUTO', autoMask);
-        registerFeature('AUTO', 'All features available in the current engine.', autoFeatureObj);
-        _Object_freeze(ALL);
-    })
-    (
+            attributes: { 'web-worker': 'old-safari-restriction' },
+        },
+        BARPROP:
         {
-            ANY_DOCUMENT:
-            {
-                description:
-                'Existence of the global object document whose string representation starts with ' +
-                '"[object " and ends with "Document]".',
-                check:
-                function ()
-                {
-                    var available =
-                    typeof document === 'object' && /^\[object .*Document]$/.test(document + '');
-                    return available;
-                },
-                attributes: { 'web-worker': 'web-worker-restriction' },
-            },
-            ANY_WINDOW:
-            {
-                description:
-                'Existence of the global object self whose string representation starts with ' +
-                '"[object " and ends with "Window]".',
-                check:
-                checkSelfFeature.bind
-                (
-                    function (str)
-                    {
-                        var available = /^\[object .*Window]$/.test(str);
-                        return available;
-                    }
-                ),
-                includes: ['SELF_OBJ'],
-                attributes: { 'web-worker': 'web-worker-restriction' },
-            },
-            ARRAY_ITERATOR:
-            {
-                description:
-                'The property that the string representation of Array.prototype.entries() starts ' +
-                'with "[object Array" and ends with "]" at index 21 or 22.',
-                check:
-                function ()
-                {
-                    var available =
-                    Array.prototype.entries && /^\[object Array.{8,9}]$/.test([].entries());
-                    return available;
-                },
-            },
-            ARROW:
-            {
-                description: 'Support for arrow functions.',
-                check:
-                function ()
-                {
-                    try
-                    {
-                        Function('()=>{}')();
-                        return true;
-                    }
-                    catch (error)
-                    { }
-                },
-            },
-            AT:
-            {
-                description: 'Existence of the native function Array.prototype.at.',
-                check:
-                function ()
-                {
-                    var available = Array.prototype.at;
-                    return available;
-                },
-            },
-            ATOB:
-            {
-                description: 'Existence of the global functions atob and btoa.',
-                check:
-                function ()
-                {
-                    var available = typeof atob === 'function' && typeof btoa === 'function';
-                    return available;
-                },
-                attributes: { 'web-worker': 'no-atob-in-web-worker' },
-            },
-            BARPROP:
-            {
-                description:
-                'Existence of the global object statusbar having the string representation "[object ' +
-                'BarProp]".',
-                check:
-                function ()
-                {
-                    var available =
-                    typeof statusbar === 'object' && statusbar + '' === '[object BarProp]';
-                    return available;
-                },
-                attributes: { 'web-worker': 'web-worker-restriction' },
-            },
-            CAPITAL_HTML:
-            {
-                description:
-                'The property that the various string methods returning HTML code such as ' +
-                'String.prototype.big or String.prototype.link have both the tag name and attributes ' +
-                'written in capital letters.',
-                check:
-                function ()
-                {
-                    var available =
-                    ''.big()            === '<BIG></BIG>'               &&
-                    ''.fontcolor('')    === '<FONT COLOR=""></FONT>'    &&
-                    ''.fontsize('')     === '<FONT SIZE=""></FONT>'     &&
-                    ''.link('')         === '<A HREF=""></A>'           &&
-                    ''.small()          === '<SMALL></SMALL>'           &&
-                    ''.strike()         === '<STRIKE></STRIKE>'         &&
-                    ''.sub()            === '<SUB></SUB>'               &&
-                    ''.sup()            === '<SUP></SUP>';
-                    return available;
-                },
-            },
-            CONSOLE:
-            {
-                description:
-                'Existence of the global object console having the string representation "[object ' +
-                'Console]".\n' +
-                'This feature may become unavailable when certain browser extensions are active.',
-                check:
-                function ()
-                {
-                    var available = typeof console === 'object' && console + '' === '[object Console]';
-                    return available;
-                },
-                attributes: { 'web-worker': 'no-console-in-web-worker' },
-            },
-            DOCUMENT:
+            description:
+            'Existence of the global object statusbar having the string representation "[object ' +
+            'BarProp]".',
+            check:
+            function ()
             {
-                description:
-                'Existence of the global object document having the string representation "[object ' +
-                'Document]".',
-                check:
-                function ()
-                {
-                    var available =
-                    typeof document === 'object' && document + '' === '[object Document]';
-                    return available;
-                },
-                includes: ['ANY_DOCUMENT'],
-                excludes: ['HTMLDOCUMENT'],
-                attributes: { 'web-worker': 'web-worker-restriction' },
+                var available = typeof statusbar === 'object' && statusbar + '' === '[object BarProp]';
+                return available;
             },
-            DOMWINDOW:
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        CAPITAL_HTML:
+        {
+            description:
+            'The property that the various string methods returning HTML code such as ' +
+            'String.prototype.big or String.prototype.link have both the tag name and attributes ' +
+            'written in capital letters.',
+            check:
+            function ()
             {
-                description:
-                'Existence of the global object self having the string representation "[object ' +
-                'DOMWindow]".',
-                check:
-                checkSelfFeature.bind
-                (
-                    function (str)
-                    {
-                        var available = str === '[object DOMWindow]';
-                        return available;
-                    }
-                ),
-                includes: ['ANY_WINDOW'],
-                excludes: ['WINDOW'],
-                attributes: { 'web-worker': 'web-worker-restriction' },
-            },
-            ESC_HTML_ALL:
-            {
-                description:
-                'The property that double quotation mark, less than and greater than characters in ' +
-                'the argument of String.prototype.fontcolor are escaped into their respective HTML ' +
-                'entities.',
-                check:
-                function ()
-                {
-                    var available = ~''.fontcolor('"<>').indexOf('&quot;&lt;&gt;');
-                    return available;
-                },
-                includes: ['ESC_HTML_QUOT'],
-                excludes: ['ESC_HTML_QUOT_ONLY'],
+                var available =
+                ''.big()            === '<BIG></BIG>'               &&
+                ''.fontcolor('')    === '<FONT COLOR=""></FONT>'    &&
+                ''.fontsize('')     === '<FONT SIZE=""></FONT>'     &&
+                ''.link('')         === '<A HREF=""></A>'           &&
+                ''.small()          === '<SMALL></SMALL>'           &&
+                ''.strike()         === '<STRIKE></STRIKE>'         &&
+                ''.sub()            === '<SUB></SUB>'               &&
+                ''.sup()            === '<SUP></SUP>';
+                return available;
             },
-            ESC_HTML_QUOT:
+        },
+        CONSOLE:
+        {
+            description:
+            'Existence of the global object console having the string representation "[object ' +
+            'Console]".\n' +
+            'This feature may become unavailable when certain browser extensions are active.',
+            check:
+            function ()
             {
-                description:
-                'The property that double quotation marks in the argument of ' +
-                'String.prototype.fontcolor are escaped as "&quot;".',
-                check:
-                function ()
-                {
-                    var available = ~''.fontcolor('"').indexOf('&quot;');
-                    return available;
-                },
+                var available = typeof console === 'object' && console + '' === '[object Console]';
+                return available;
             },
-            ESC_HTML_QUOT_ONLY:
+            attributes: { 'web-worker': 'no-console-in-web-worker' },
+        },
+        DOCUMENT:
+        {
+            description:
+            'Existence of the global object document having the string representation "[object ' +
+            'Document]".',
+            check:
+            function ()
             {
-                description:
-                'The property that only double quotation marks and no other characters in the ' +
-                'argument of String.prototype.fontcolor are escaped into HTML entities.',
-                check:
-                function ()
-                {
-                    var available = ~''.fontcolor('"<>').indexOf('&quot;<>');
-                    return available;
-                },
-                includes: ['ESC_HTML_QUOT'],
-                excludes: ['ESC_HTML_ALL'],
+                var available = typeof document === 'object' && document + '' === '[object Document]';
+                return available;
             },
-            ESC_REGEXP_LF:
-            {
-                description:
-                'Having regular expressions created with the RegExp constructor use escape sequences ' +
-                'starting with a backslash to format line feed characters ("\\n") in their string ' +
-                'representation.',
-                check:
-                function ()
+            includes: ['ANY_DOCUMENT'],
+            excludes: ['HTMLDOCUMENT'],
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        DOMWINDOW:
+        {
+            description:
+            'Existence of the global object self having the string representation "[object ' +
+            'DOMWindow]".',
+            check:
+            checkSelfFeature.bind
+            (
+                function (str)
                 {
-                    var available = (RegExp('\n') + '')[1] === '\\';
+                    var available = str === '[object DOMWindow]';
                     return available;
-                },
-            },
-            ESC_REGEXP_SLASH:
+                }
+            ),
+            includes: ['ANY_WINDOW'],
+            excludes: ['WINDOW'],
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        ESC_HTML_ALL:
+        {
+            description:
+            'The property that double quotation mark, less than and greater than characters in the ' +
+            'argument of String.prototype.fontcolor are escaped into their respective HTML entities.',
+            check:
+            function ()
             {
-                description:
-                'Having regular expressions created with the RegExp constructor use escape sequences ' +
-                'starting with a backslash to format slashes ("/") in their string representation.',
-                check:
-                function ()
-                {
-                    var available = (RegExp('/') + '')[1] === '\\';
-                    return available;
-                },
+                var available = ~''.fontcolor('"<>').indexOf('&quot;&lt;&gt;');
+                return available;
             },
-            EXTERNAL:
+            includes: ['ESC_HTML_QUOT'],
+            excludes: ['ESC_HTML_QUOT_ONLY'],
+        },
+        ESC_HTML_QUOT:
+        {
+            description:
+            'The property that double quotation marks in the argument of String.prototype.fontcolor ' +
+            'are escaped as "&quot;".',
+            check:
+            function ()
             {
-                description:
-                'Existence of the global object sidebar having the string representation "[object ' +
-                'External]".',
-                check:
-                function ()
-                {
-                    var available = typeof sidebar === 'object' && sidebar + '' === '[object External]';
-                    return available;
-                },
-                attributes: { 'web-worker': 'web-worker-restriction' },
+                var available = ~''.fontcolor('"').indexOf('&quot;');
+                return available;
             },
-            FF_SRC:
-            {
-                description:
-                'A string representation of native functions typical for Firefox and Safari.\n' +
-                'Remarkable traits are the lack of line feed characters at the beginning and at the ' +
-                'end of the string and the presence of a line feed followed by four whitespaces ' +
-                '("\\n    ") before the "[native code]" sequence.',
-                includes: ['NO_IE_SRC', 'NO_V8_SRC'],
-                excludes: ['NO_FF_SRC'],
-            },
-            FILL:
-            {
-                description: 'Existence of the native function Array.prototype.fill.',
-                check:
-                function ()
-                {
-                    var available = Array.prototype.fill;
-                    return available;
-                },
-            },
-            FLAT:
+        },
+        ESC_HTML_QUOT_ONLY:
+        {
+            description:
+            'The property that only double quotation marks and no other characters in the argument ' +
+            'of String.prototype.fontcolor are escaped into HTML entities.',
+            check:
+            function ()
             {
-                description: 'Existence of the native function Array.prototype.flat.',
-                check:
-                function ()
-                {
-                    var available = Array.prototype.flat;
-                    return available;
-                },
+                var available = ~''.fontcolor('"<>').indexOf('&quot;<>');
+                return available;
             },
-            FROM_CODE_POINT:
+            includes: ['ESC_HTML_QUOT'],
+            excludes: ['ESC_HTML_ALL'],
+        },
+        ESC_REGEXP_LF:
+        {
+            description:
+            'Having regular expressions created with the RegExp constructor use escape sequences ' +
+            'starting with a backslash to format line feed characters ("\\n") in their string ' +
+            'representation.',
+            check:
+            function ()
             {
-                description: 'Existence of the function String.fromCodePoint.',
-                check:
-                function ()
-                {
-                    var available = String.fromCodePoint;
-                    return available;
-                },
+                var available = (RegExp('\n') + '')[1] === '\\';
+                return available;
             },
-            FUNCTION_19_LF:
+        },
+        ESC_REGEXP_SLASH:
+        {
+            description:
+            'Having regular expressions created with the RegExp constructor use escape sequences ' +
+            'starting with a backslash to format slashes ("/") in their string representation.',
+            check:
+            function ()
             {
-                description:
-                'A string representation of dynamically generated functions where the character at ' +
-                'index 19 is a line feed ("\\n").',
-                check:
-                function ()
-                {
-                    var available = (Function() + '')[19] === '\n';
-                    return available;
-                },
+                var available = (RegExp('/') + '')[1] === '\\';
+                return available;
             },
-            FUNCTION_22_LF:
+        },
+        FF_SRC:
+        {
+            description:
+            'A string representation of native functions typical for Firefox and Safari.\n' +
+            'Remarkable traits are the lack of line feed characters at the beginning and at the end ' +
+            'of the string and the presence of a line feed followed by four whitespaces ("\\n    ") ' +
+            'before the "[native code]" sequence.',
+            includes: ['NO_IE_SRC', 'NO_V8_SRC'],
+            excludes: ['NO_FF_SRC'],
+        },
+        FILL:
+        {
+            description: 'Existence of the native function Array.prototype.fill.',
+            check:
+            function ()
             {
-                description:
-                'A string representation of dynamically generated functions where the character at ' +
-                'index 22 is a line feed ("\\n").',
-                check:
-                function ()
-                {
-                    var available = (Function() + '')[22] === '\n';
-                    return available;
-                },
+                var available = Array.prototype.fill;
+                return available;
             },
-            GENERIC_ARRAY_TO_STRING:
+        },
+        FLAT:
+        {
+            description: 'Existence of the native function Array.prototype.flat.',
+            check:
+            function ()
             {
-                description: 'Ability to call Array.prototype.toString with a non-array binding.',
-                check:
-                function ()
-                {
-                    try
-                    {
-                        Array.prototype.toString.call({ });
-                        return true;
-                    }
-                    catch (error)
-                    { }
-                },
+                var available = Array.prototype.flat;
+                return available;
             },
-            GLOBAL_UNDEFINED:
+        },
+        FROM_CODE_POINT:
+        {
+            description: 'Existence of the function String.fromCodePoint.',
+            check:
+            function ()
             {
-                description:
-                'Having the global function toString return the string "[object Undefined]" when ' +
-                'invoked without a binding.',
-                check:
-                function ()
-                {
-                    var getToString = Function('return toString');
-                    var available = getToString()() === '[object Undefined]';
-                    return available;
-                },
-                includes: ['OBJECT_UNDEFINED'],
-            },
-            GMT:
-            {
-                description:
-                'Presence of the text "GMT" after the first 25 characters in the string returned by ' +
-                'Date().\n' +
-                'The string representation of dates is implementation dependent, but most engines ' +
-                'use a similar format, making this feature available in all supported engines except ' +
-                'Internet Explorer 9 and 10.',
-                check:
-                function ()
-                {
-                    var available = /^.{25}GMT/.test(Date());
-                    return available;
-                },
+                var available = String.fromCodePoint;
+                return available;
             },
-            HISTORY:
+        },
+        FUNCTION_19_LF:
+        {
+            description:
+            'A string representation of dynamically generated functions where the character at index ' +
+            '19 is a line feed ("\\n").',
+            check:
+            function ()
             {
-                description:
-                'Existence of the global object history having the string representation "[object ' +
-                'History]".',
-                check:
-                function ()
-                {
-                    var available = typeof history === 'object' && history + '' === '[object History]';
-                    return available;
-                },
-                attributes: { 'web-worker': 'web-worker-restriction' },
+                var available = (Function() + '')[19] === '\n';
+                return available;
             },
-            HTMLAUDIOELEMENT:
+        },
+        FUNCTION_22_LF:
+        {
+            description:
+            'A string representation of dynamically generated functions where the character at index ' +
+            '22 is a line feed ("\\n").',
+            check:
+            function ()
             {
-                description:
-                'Existence of the global object Audio whose string representation starts with ' +
-                '"function HTMLAudioElement".',
-                check:
-                function ()
-                {
-                    var available =
-                    typeof Audio !== 'undefined' && /^function HTMLAudioElement/.test(Audio);
-                    return available;
-                },
-                includes: ['NO_IE_SRC'],
-                attributes: { 'web-worker': 'web-worker-restriction' },
+                var available = (Function() + '')[22] === '\n';
+                return available;
             },
-            HTMLDOCUMENT:
+        },
+        GENERIC_ARRAY_TO_STRING:
+        {
+            description: 'Ability to call Array.prototype.toString with a non-array binding.',
+            check:
+            function ()
             {
-                description:
-                'Existence of the global object document having the string representation "[object ' +
-                'HTMLDocument]".',
-                check:
-                function ()
-                {
-                    var available =
-                    typeof document === 'object' && document + '' === '[object HTMLDocument]';
-                    return available;
-                },
-                includes: ['ANY_DOCUMENT'],
-                excludes: ['DOCUMENT'],
-                attributes: { 'web-worker': 'web-worker-restriction' },
-            },
-            IE_SRC:
-            {
-                description:
-                'A string representation of native functions typical for Internet Explorer.\n' +
-                'Remarkable traits are the presence of a line feed character ("\\n") at the ' +
-                'beginning and at the end of the string and a line feed followed by four whitespaces ' +
-                '("\\n    ") before the "[native code]" sequence.',
-                includes: ['NO_FF_SRC', 'NO_V8_SRC'],
-                excludes: ['NO_IE_SRC'],
-            },
-            INCR_CHAR:
-            {
-                description:
-                'The ability to use unary increment operators with string characters, like in ( ' +
-                '++"some string"[0] ): this will result in a TypeError in strict mode in ECMAScript ' +
-                'compliant engines.',
-                check:
-                function ()
+                try
                 {
+                    Array.prototype.toString.call({ });
                     return true;
-                },
-                attributes: { 'forced-strict-mode': 'char-increment-restriction' },
-            },
-            INTL:
-            {
-                description: 'Existence of the global object Intl.',
-                check:
-                function ()
-                {
-                    var available = typeof Intl === 'object';
-                    return available;
-                },
-            },
-            LOCALE_INFINITY:
-            {
-                description: 'Language sensitive string representation of Infinity as "∞".',
-                check:
-                function ()
-                {
-                    var available = Infinity.toLocaleString() === '∞';
-                    return available;
-                },
-            },
-            LOCALE_NUMERALS:
-            {
-                description:
-                'Features shared by all engines capable of localized number formatting, including ' +
-                'output of Arabic digits, the Arabic decimal separator "٫", the letters in the first ' +
-                'word of the Arabic string representation of NaN ("ليس"), Persian digits and the ' +
-                'Persian digit group separator "٬".',
-                check:
-                function ()
-                {
-                    var available =
-                    Number.prototype.toLocaleString &&
-                    checkLocaleNumeral('ar', NaN, /^ليس/) &&
-                    checkLocaleNumeral('ar-td', 234567890.1, /^٢٣٤٬?٥٦٧٬?٨٩٠٫١/) &&
-                    checkLocaleNumeral('fa', 1234567890, /^۱٬۲۳۴٬۵۶۷٬۸۹۰/);
-                    return available;
-                },
-            },
-            LOCALE_NUMERALS_EXT:
-            {
-                description:
-                'Extended localized number formatting.\n' +
-                'This includes all features of LOCALE_NUMERALS plus the output of the first three ' +
-                'letters in the second word of the Arabic string representation of NaN ("رقم"), ' +
-                'Bengali digits, the letters in the Russian string representation of NaN ("не\xa0' +
-                'число") and the letters in the Persian string representation of NaN ("ناعدد").',
-                check:
-                function ()
-                {
-                    var available =
-                    Number.prototype.toLocaleString &&
-                    checkLocaleNumeral('ar', NaN, /^ليس.رقم/) &&
-                    checkLocaleNumeral('ar-td', 234567890.1, /^٢٣٤٬?٥٦٧٬?٨٩٠٫١/) &&
-                    checkLocaleNumeral('bn', 1234567890, /^১,২৩,৪৫,৬৭,৮৯০/) &&
-                    checkLocaleNumeral('fa', 1234567890, /^۱٬۲۳۴٬۵۶۷٬۸۹۰/) &&
-                    checkLocaleNumeral('fa', NaN, /^ناعد/) &&
-                    checkLocaleNumeral('ru', NaN, /^не.число/);
-                    return available;
-                },
-                includes: ['LOCALE_NUMERALS'],
-            },
-            LOCATION:
-            {
-                description:
-                'Existence of the global object location with the property that ' +
-                'Object.prototype.toString.call(location) evaluates to a string that starts with ' +
-                '"[object " and ends with "Location]".',
-                check:
-                function ()
-                {
-                    var available =
-                    typeof location === 'object' &&
-                    /^\[object .*Location]$/.test(Object.prototype.toString.call(location));
-                    return available;
-                },
-            },
-            NAME:
-            {
-                description: 'Existence of the name property for functions.',
-                check:
-                function ()
-                {
-                    var available = 'name' in Function();
-                    return available;
-                },
-            },
-            NODECONSTRUCTOR:
-            {
-                description:
-                'Existence of the global object Node having the string representation "[object ' +
-                'NodeConstructor]".',
-                check:
-                function ()
-                {
-                    var available =
-                    typeof Node !== 'undefined' && Node + '' === '[object NodeConstructor]';
-                    return available;
-                },
-                attributes: { 'web-worker': 'web-worker-restriction' },
-            },
-            NO_FF_SRC:
-            {
-                description:
-                'A string representation of native functions typical for V8 or for Internet Explorer ' +
-                'but not for Firefox and Safari.',
-                check:
-                function ()
-                {
-                    var available = /^(\n?)function Object\(\) \{\1 +\[native code]\s\}/.test(Object);
-                    return available;
-                },
-                excludes: ['FF_SRC'],
-            },
-            NO_IE_SRC:
-            {
-                description:
-                'A string representation of native functions typical for most engines with the ' +
-                'notable exception of Internet Explorer.\n' +
-                'A remarkable trait of this feature is the lack of line feed characters at the ' +
-                'beginning and at the end of the string.',
-                check:
-                function ()
-                {
-                    var available = /^function Object\(\) \{(\n   )? \[native code]\s\}/.test(Object);
-                    return available;
-                },
-                excludes: ['IE_SRC'],
-            },
-            NO_OLD_SAFARI_ARRAY_ITERATOR:
-            {
-                description:
-                'The property that the string representation of Array.prototype.entries() evaluates ' +
-                'to "[object Array Iterator]" and that Array.prototype.entries().constructor is the ' +
-                'global function Object.',
-                check:
-                function ()
-                {
-                    if (Array.prototype.entries)
-                    {
-                        var arrayIterator = [].entries();
-                        var available =
-                        arrayIterator + '' === '[object Array Iterator]' &&
-                        arrayIterator.constructor === Object;
-                        return available;
-                    }
-                },
-                includes: ['ARRAY_ITERATOR'],
-            },
-            NO_V8_SRC:
-            {
-                description:
-                'A string representation of native functions typical for Firefox, Internet Explorer ' +
-                'and Safari.\n' +
-                'A most remarkable trait of this feature is the presence of a line feed followed by ' +
-                'four whitespaces ("\\n    ") before the "[native code]" sequence.',
-                check:
-                function ()
-                {
-                    var available = /^\n?function Object\(\) \{\n    \[native code]\s\}/.test(Object);
-                    return available;
-                },
-                excludes: ['V8_SRC'],
-            },
-            OBJECT_UNDEFINED:
-            {
-                description:
-                'Having the function Object.prototype.toString return the string "[object ' +
-                'Undefined]" when invoked without a binding.',
-                check:
-                function ()
-                {
-                    var toString = Object.prototype.toString;
-                    var available = toString() === '[object Undefined]';
-                    return available;
-                },
-                includes: ['UNDEFINED'],
-            },
-            PLAIN_INTL:
-            {
-                description:
-                'Existence of the global object Intl having the string representation "[object ' +
-                'Object]"',
-                check:
-                function ()
-                {
-                    var available = typeof Intl === 'object' && Intl + '' === '[object Object]';
-                    return available;
-                },
-                includes: ['INTL'],
-            },
-            REGEXP_STRING_ITERATOR:
-            {
-                description:
-                'The property that the string representation of String.prototype.matchAll() ' +
-                'evaluates to "[object RegExp String Iterator]".',
-                check:
-                function ()
-                {
-                    var available =
-                    String.prototype.matchAll &&
-                    ''.matchAll() + '' === '[object RegExp String Iterator]';
-                    return available;
-                },
-            },
-            SELF: { aliasFor: 'ANY_WINDOW' },
-            SELF_OBJ:
-            {
-                description:
-                'Existence of the global object self whose string representation starts with ' +
-                '"[object ".',
-                check:
-                checkSelfFeature.bind
-                (
-                    function (str)
-                    {
-                        var available = /^\[object /.test(str);
-                        return available;
-                    }
-                ),
-                attributes: { 'web-worker': 'safari-bug-21820506' },
-            },
-            SHORT_LOCALES:
-            {
-                description:
-                'Support for the two-letter locale name "ar" to format decimal numbers as Arabic ' +
-                'numerals.',
-                check:
-                function ()
-                {
-                    var NUMBER = 9876430.125;
-
-                    var localizedNumeral = NUMBER.toLocaleString('ar');
-                    var available =
-                    localizedNumeral === NUMBER.toLocaleString('ar-td') &&
-                    localizedNumeral !== NUMBER.toLocaleString('en');
-                    return available;
-                },
-                includes: ['LOCALE_NUMERALS'],
-            },
-            STATUS:
-            {
-                description: 'Existence of the global string status.',
-                check:
-                function ()
-                {
-                    var available = typeof status === 'string';
-                    return available;
-                },
-                attributes: { 'web-worker': 'web-worker-restriction' },
-            },
-            UNDEFINED:
-            {
-                description:
-                'The property that Object.prototype.toString.call() evaluates to "[object ' +
-                'Undefined]".\n' +
-                'This behavior is specified by ECMAScript, and is enforced by all engines except ' +
-                'Android Browser versions prior to 4.1.2, where this feature is not available.',
-                check:
-                function ()
-                {
-                    var available = Object.prototype.toString.call() === '[object Undefined]';
-                    return available;
-                },
-            },
-            V8_SRC:
-            {
-                description:
-                'A string representation of native functions typical for the V8 engine.\n' +
-                'Remarkable traits are the lack of line feed characters at the beginning and at the ' +
-                'end of the string and the presence of a single whitespace before the "[native ' +
-                'code]" sequence.',
-                includes: ['NO_FF_SRC', 'NO_IE_SRC'],
-                excludes: ['NO_V8_SRC'],
-            },
-            WINDOW:
-            {
-                description:
-                'Existence of the global object self having the string representation "[object ' +
-                'Window]".',
-                check:
-                checkSelfFeature.bind
-                (
-                    function (str)
-                    {
-                        var available = str === '[object Window]';
-                        return available;
-                    }
-                ),
-                includes: ['ANY_WINDOW'],
-                excludes: ['DOMWINDOW'],
-                attributes: { 'web-worker': 'web-worker-restriction' },
-            },
-
-            DEFAULT:
-            {
-                description:
-                'Minimum feature level, compatible with all supported engines in all environments.',
-            },
-            BROWSER:
-            {
-                description:
-                'Features available in all browsers.\n' +
-                'No support for Node.js.',
-                includes: ['ANY_DOCUMENT', 'ANY_WINDOW', 'HISTORY', 'INCR_CHAR', 'STATUS'],
-                attributes:
-                {
-                    'char-increment-restriction':   null,
-                    'safari-bug-21820506':          null,
-                    'web-worker-restriction':       null,
-                },
-            },
-            COMPACT:
-            {
-                description:
-                'All new browsers\' features.\n' +
-                'No support for Node.js and older browsers like Internet Explorer, Safari 9 or ' +
-                'Android Browser.',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'BARPROP',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'INTL',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_IE_SRC',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'REGEXP_STRING_ITERATOR',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
-            },
-            ANDRO_4_0:
-            {
-                engine: 'Android Browser 4.0',
-                includes:
-                [
-                    'ATOB',
-                    'CONSOLE',
-                    'DOMWINDOW',
-                    'ESC_HTML_ALL',
-                    'FUNCTION_22_LF',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCATION',
-                    'NAME',
-                    'STATUS',
-                    'V8_SRC',
-                ],
-            },
-            ANDRO_4_1:
-            {
-                engine: 'Android Browser 4.1 to 4.3',
-                includes:
-                [
-                    'ATOB',
-                    'CONSOLE',
-                    'DOMWINDOW',
-                    'ESC_HTML_ALL',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCATION',
-                    'NAME',
-                    'OBJECT_UNDEFINED',
-                    'STATUS',
-                    'V8_SRC',
-                ],
-            },
-            ANDRO_4_4:
-            {
-                engine: 'Android Browser 4.4',
-                includes:
-                [
-                    'ATOB',
-                    'BARPROP',
-                    'CONSOLE',
-                    'ESC_HTML_ALL',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLAUDIOELEMENT',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'OBJECT_UNDEFINED',
-                    'PLAIN_INTL',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'V8_SRC',
-                    'WINDOW',
-                ],
-                attributes: { 'no-console-in-web-worker': null, 'web-worker-restriction': null },
+                }
+                catch (error)
+                { }
             },
-            CHROME_PREV:
+        },
+        GLOBAL_UNDEFINED:
+        {
+            description:
+            'Having the global function toString return the string "[object Undefined]" when invoked ' +
+            'without a binding.',
+            check:
+            function ()
             {
-                engine: 'the previous to current versions of Chrome and Edge',
-                aliasFor: 'CHROME_86',
+                var getToString = Function('return toString');
+                var available = getToString()() === '[object Undefined]';
+                return available;
             },
-            CHROME:
+            includes: ['OBJECT_UNDEFINED'],
+        },
+        GMT:
+        {
+            description:
+            'Presence of the text "GMT" after the first 25 characters in the string returned by ' +
+            'Date().\n' +
+            'The string representation of dates is implementation dependent, but most engines use a ' +
+            'similar format, making this feature available in all supported engines except Internet ' +
+            'Explorer 9 and 10.',
+            check:
+            function ()
             {
-                engine: 'the current stable versions of Chrome, Edge and Opera',
-                aliasFor: 'CHROME_86',
+                var available = /^.{25}GMT/.test(Date());
+                return available;
             },
-            CHROME_86:
+        },
+        HISTORY:
+        {
+            description:
+            'Existence of the global object history having the string representation "[object ' +
+            'History]".',
+            check:
+            function ()
             {
-                engine: 'Chrome 86, Edge 86 and Opera 72 or later',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'BARPROP',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'INTL',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'REGEXP_STRING_ITERATOR',
-                    'STATUS',
-                    'V8_SRC',
-                    'WINDOW',
-                ],
-                attributes:
-                {
-                    'char-increment-restriction':   null,
-                    'unstable':                     null,
-                    'web-worker-restriction':       null,
-                },
+                var available = typeof history === 'object' && history + '' === '[object History]';
+                return available;
             },
-            FF_ESR:
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        HTMLAUDIOELEMENT:
+        {
+            description:
+            'Existence of the global object Audio whose string representation starts with ' +
+            '"function HTMLAudioElement".',
+            check:
+            function ()
             {
-                engine: 'the current version of Firefox ESR',
-                aliasFor: 'FF_78',
+                var available =
+                typeof Audio !== 'undefined' && /^function HTMLAudioElement/.test(Audio);
+                return available;
             },
-            FF_78:
+            includes: ['NO_IE_SRC'],
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        HTMLDOCUMENT:
+        {
+            description:
+            'Existence of the global object document having the string representation "[object ' +
+            'HTMLDocument]".',
+            check:
+            function ()
             {
-                engine: 'Firefox 78 to 82',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'BARPROP',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'EXTERNAL',
-                    'FF_SRC',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'REGEXP_STRING_ITERATOR',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes:
-                {
-                    'char-increment-restriction':   null,
-                    'unstable':                     null,
-                    'web-worker-restriction':       null,
-                },
+                var available =
+                typeof document === 'object' && document + '' === '[object HTMLDocument]';
+                return available;
             },
-            FF_PREV:
+            includes: ['ANY_DOCUMENT'],
+            excludes: ['DOCUMENT'],
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        IE_SRC:
+        {
+            description:
+            'A string representation of native functions typical for Internet Explorer.\n' +
+            'Remarkable traits are the presence of a line feed character ("\\n") at the beginning ' +
+            'and at the end of the string and a line feed followed by four whitespaces ("\\n    ") ' +
+            'before the "[native code]" sequence.',
+            includes: ['NO_FF_SRC', 'NO_V8_SRC'],
+            excludes: ['NO_IE_SRC'],
+        },
+        INCR_CHAR:
+        {
+            description:
+            'The ability to use unary increment operators with string characters, like in ( ++"some ' +
+            'string"[0] ): this will result in a TypeError in strict mode in ECMAScript compliant ' +
+            'engines.',
+            check:
+            function ()
             {
-                engine: 'the previous to current version of Firefox',
-                aliasFor: 'FF_83',
+                return true;
             },
-            FF_83:
+            attributes: { 'forced-strict-mode': 'char-increment-restriction' },
+        },
+        INTL:
+        {
+            description: 'Existence of the global object Intl.',
+            check:
+            function ()
             {
-                engine: 'Firefox 83 to 89',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'BARPROP',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'EXTERNAL',
-                    'FF_SRC',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'INTL',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'REGEXP_STRING_ITERATOR',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes:
-                {
-                    'char-increment-restriction':   null,
-                    'unstable':                     null,
-                    'web-worker-restriction':       null,
-                },
+                var available = typeof Intl === 'object';
+                return available;
             },
-            FF:
+        },
+        LOCALE_INFINITY:
+        {
+            description: 'Language sensitive string representation of Infinity as "∞".',
+            check:
+            function ()
             {
-                engine: 'the current stable version of Firefox',
-                aliasFor: 'FF_90',
+                var available = Infinity.toLocaleString() === '∞';
+                return available;
             },
-            FF_90:
+        },
+        LOCALE_NUMERALS:
+        {
+            description:
+            'Features shared by all engines capable of localized number formatting, including output ' +
+            'of Arabic digits, the Arabic decimal separator "٫", the letters in the first word of ' +
+            'the Arabic string representation of NaN ("ليس"), Persian digits and the Persian digit ' +
+            'group separator "٬".',
+            check:
+            function ()
             {
-                engine: 'Firefox 90 or later',
-                includes:
-                [
-                    'ARROW',
-                    'AT',
-                    'ATOB',
-                    'BARPROP',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'EXTERNAL',
-                    'FF_SRC',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'INTL',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'REGEXP_STRING_ITERATOR',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes:
-                {
-                    'char-increment-restriction':   null,
-                    'unstable':                     null,
-                    'web-worker-restriction':       null,
-                },
+                var available =
+                Number.prototype.toLocaleString &&
+                checkLocaleNumeral('ar', NaN, /^ليس/) &&
+                checkLocaleNumeral('ar-td', 234567890.1, /^٢٣٤٬?٥٦٧٬?٨٩٠٫١/) &&
+                checkLocaleNumeral('fa', 1234567890, /^۱٬۲۳۴٬۵۶۷٬۸۹۰/);
+                return available;
             },
-            IE_9:
+        },
+        LOCALE_NUMERALS_EXT:
+        {
+            description:
+            'Extended localized number formatting.\n' +
+            'This includes all features of LOCALE_NUMERALS plus the output of the first three ' +
+            'letters in the second word of the Arabic string representation of NaN ("رقم"), Bengali ' +
+            'digits, the letters in the Russian string representation of NaN ("не\xa0число") and the ' +
+            'letters in the Persian string representation of NaN ("ناعدد").',
+            check:
+            function ()
             {
-                engine: 'Internet Explorer 9',
-                includes:
-                [
-                    'CAPITAL_HTML',
-                    'DOCUMENT',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'HISTORY',
-                    'IE_SRC',
-                    'INCR_CHAR',
-                    'STATUS',
-                    'UNDEFINED',
-                    'WINDOW',
-                ],
-            },
-            IE_10:
+                var available =
+                Number.prototype.toLocaleString &&
+                checkLocaleNumeral('ar', NaN, /^ليس.رقم/) &&
+                checkLocaleNumeral('ar-td', 234567890.1, /^٢٣٤٬?٥٦٧٬?٨٩٠٫١/) &&
+                checkLocaleNumeral('bn', 1234567890, /^১,২৩,৪৫,৬৭,৮৯০/) &&
+                checkLocaleNumeral('fa', 1234567890, /^۱٬۲۳۴٬۵۶۷٬۸۹۰/) &&
+                checkLocaleNumeral('fa', NaN, /^ناعد/) &&
+                checkLocaleNumeral('ru', NaN, /^не.число/);
+                return available;
+            },
+            includes: ['LOCALE_NUMERALS'],
+        },
+        LOCATION:
+        {
+            description:
+            'Existence of the global object location with the property that ' +
+            'Object.prototype.toString.call(location) evaluates to a string that starts with ' +
+            '"[object " and ends with "Location]".',
+            check:
+            function ()
             {
-                engine: 'Internet Explorer 10',
-                includes:
-                [
-                    'ATOB',
-                    'CAPITAL_HTML',
-                    'CONSOLE',
-                    'DOCUMENT',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'HISTORY',
-                    'IE_SRC',
-                    'INCR_CHAR',
-                    'OBJECT_UNDEFINED',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+                var available =
+                typeof location === 'object' &&
+                /^\[object [\S\s]*Location]$/.test(Object.prototype.toString.call(location));
+                return available;
             },
-            IE_11:
+        },
+        NAME:
+        {
+            description: 'Existence of the name property for functions.',
+            check:
+            function ()
             {
-                engine: 'Internet Explorer 11',
-                includes:
-                [
-                    'ATOB',
-                    'CAPITAL_HTML',
-                    'CONSOLE',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'IE_SRC',
-                    'INCR_CHAR',
-                    'LOCALE_NUMERALS',
-                    'OBJECT_UNDEFINED',
-                    'PLAIN_INTL',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+                var available = 'name' in Function();
+                return available;
             },
-            IE_11_WIN_10:
+        },
+        NODECONSTRUCTOR:
+        {
+            description:
+            'Existence of the global object Node having the string representation "[object ' +
+            'NodeConstructor]".',
+            check:
+            function ()
             {
-                engine: 'Internet Explorer 11 on Windows 10',
-                includes:
-                [
-                    'ATOB',
-                    'CAPITAL_HTML',
-                    'CONSOLE',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'IE_SRC',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'OBJECT_UNDEFINED',
-                    'PLAIN_INTL',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+                var available = typeof Node !== 'undefined' && Node + '' === '[object NodeConstructor]';
+                return available;
             },
-            NODE_0_10:
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        NO_FF_SRC:
+        {
+            description:
+            'A string representation of native functions typical for V8 or for Internet Explorer but ' +
+            'not for Firefox and Safari.',
+            check:
+            function ()
             {
-                engine: 'Node.js 0.10',
-                includes:
-                [
-                    'ESC_HTML_ALL',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'NAME',
-                    'V8_SRC',
-                ],
+                var available = /^(\n?)function Object\(\) \{\1 +\[native code]\s\}/.test(Object);
+                return available;
             },
-            NODE_0_12:
+            excludes: ['FF_SRC'],
+        },
+        NO_IE_SRC:
+        {
+            description:
+            'A string representation of native functions typical for most engines with the notable ' +
+            'exception of Internet Explorer.\n' +
+            'A remarkable trait of this feature is the lack of line feed characters at the beginning ' +
+            'and at the end of the string.',
+            check:
+            function ()
             {
-                engine: 'Node.js 0.12',
-                includes:
-                [
-                    'ESC_HTML_QUOT_ONLY',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'V8_SRC',
-                ],
+                var available = /^function Object\(\) \{(\n   )? \[native code]\s\}/.test(Object);
+                return available;
             },
-            NODE_4:
+            excludes: ['IE_SRC'],
+        },
+        NO_OLD_SAFARI_ARRAY_ITERATOR:
+        {
+            description:
+            'The property that the string representation of Array.prototype.entries() evaluates to ' +
+            '"[object Array Iterator]" and that Array.prototype.entries().constructor is the global ' +
+            'function Object.',
+            check:
+            function ()
             {
-                engine: 'Node.js 4',
-                includes:
-                [
-                    'ARROW',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'V8_SRC',
-                ],
+                if (Array.prototype.entries)
+                {
+                    var arrayIterator = [].entries();
+                    var available =
+                    arrayIterator + '' === '[object Array Iterator]' &&
+                    arrayIterator.constructor === Object;
+                    return available;
+                }
             },
-            NODE_5:
+            includes: ['ARRAY_ITERATOR'],
+        },
+        NO_V8_SRC:
+        {
+            description:
+            'A string representation of native functions typical for Firefox, Internet Explorer and ' +
+            'Safari.\n' +
+            'A most remarkable trait of this feature is the presence of a line feed followed by four ' +
+            'whitespaces ("\\n    ") before the "[native code]" sequence.',
+            check:
+            function ()
             {
-                engine: 'Node.js 5 to 9',
-                includes:
-                [
-                    'ARROW',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'V8_SRC',
-                ],
-                attributes: { 'char-increment-restriction': null },
+                var available = /^\n?function Object\(\) \{\n    \[native code]\s\}/.test(Object);
+                return available;
             },
-            NODE_10:
+            excludes: ['V8_SRC'],
+        },
+        OBJECT_L_LOCATION_CTOR:
+        {
+            description:
+            'Existence of the global function location.constructor whose string representation ' +
+            'starts with "[object L"',
+            check:
+            function ()
             {
-                engine: 'Node.js 10',
-                includes:
-                [
-                    'ARROW',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'V8_SRC',
-                ],
-                attributes: { 'char-increment-restriction': null },
+                var available =
+                typeof location === 'object' && /^\[object L/.test(location.constructor);
+                return available;
             },
-            NODE_11:
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        OBJECT_UNDEFINED:
+        {
+            description:
+            'Having the function Object.prototype.toString return the string "[object Undefined]" ' +
+            'when invoked without a binding.',
+            check:
+            function ()
             {
-                engine: 'Node.js 11',
-                includes:
-                [
-                    'ARROW',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'V8_SRC',
-                ],
-                attributes: { 'char-increment-restriction': null },
+                var toString = Object.prototype.toString;
+                var available = toString() === '[object Undefined]';
+                return available;
             },
-            NODE_12:
+            includes: ['UNDEFINED'],
+        },
+        OBJECT_W_CTOR:
+        {
+            description:
+            'The property that the string representation of the global object constructor starts ' +
+            'with "[object W"',
+            check:
+            function ()
             {
-                engine: 'Node.js 12',
-                includes:
-                [
-                    'ARROW',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'REGEXP_STRING_ITERATOR',
-                    'V8_SRC',
-                ],
-                attributes: { 'char-increment-restriction': null },
+                var available = /^\[object W/.test(constructor);
+                return available;
             },
-            NODE_13:
+            attributes: { 'web-worker': 'old-safari-restriction' },
+        },
+        OLD_SAFARI_LOCATION_CTOR:
+        {
+            description:
+            'Existence of the global object location.constructor whose string representation starts ' +
+            'with "[object " and ends with "LocationConstructor]"',
+            check:
+            function ()
             {
-                engine: 'Node.js 13 and Node.js 14',
-                includes:
-                [
-                    'ARROW',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'REGEXP_STRING_ITERATOR',
-                    'SHORT_LOCALES',
-                    'V8_SRC',
-                ],
-                attributes: { 'char-increment-restriction': null },
+                var available =
+                typeof location === 'object' &&
+                /^\[object [\S\s]*LocationConstructor]$/.test(location.constructor);
+                return available;
             },
-            NODE_15:
+        },
+        PLAIN_INTL:
+        {
+            description:
+            'Existence of the global object Intl having the string representation "[object Object]"',
+            check:
+            function ()
             {
-                engine: 'Node.js 15',
-                includes:
-                [
-                    'ARROW',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'INTL',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'REGEXP_STRING_ITERATOR',
-                    'SHORT_LOCALES',
-                    'V8_SRC',
-                ],
-                attributes: { 'char-increment-restriction': null },
+                var available = typeof Intl === 'object' && Intl + '' === '[object Object]';
+                return available;
             },
-            NODE_16:
+            includes: ['INTL'],
+        },
+        REGEXP_STRING_ITERATOR:
+        {
+            description:
+            'The property that the string representation of String.prototype.matchAll() evaluates to ' +
+            '"[object RegExp String Iterator]".',
+            check:
+            function ()
             {
-                engine: 'Node.js 16 or later',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_19_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'INCR_CHAR',
-                    'INTL',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'REGEXP_STRING_ITERATOR',
-                    'SHORT_LOCALES',
-                    'V8_SRC',
-                ],
-                attributes: { 'char-increment-restriction': null },
+                var available =
+                String.prototype.matchAll && ''.matchAll() + '' === '[object RegExp String Iterator]';
+                return available;
             },
-            SAFARI_7_0:
-            {
-                engine: 'Safari 7.0',
-                includes:
-                [
-                    'ATOB',
-                    'BARPROP',
-                    'CONSOLE',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FF_SRC',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCATION',
-                    'NAME',
-                    'NODECONSTRUCTOR',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes:
+        },
+        SELF: { aliasFor: 'ANY_WINDOW' },
+        SELF_OBJ:
+        {
+            description:
+            'Existence of the global object self whose string representation starts with "[object ".',
+            check:
+            checkSelfFeature.bind
+            (
+                function (str)
                 {
-                    'char-increment-restriction':   null,
-                    'no-atob-in-web-worker':        null,
-                    'no-console-in-web-worker':     null,
-                    'web-worker-restriction':       null,
-                },
-            },
-            SAFARI_7_1:
+                    var available = /^\[object /.test(str);
+                    return available;
+                }
+            ),
+            attributes: { 'web-worker': 'safari-bug-21820506' },
+        },
+        SHORT_LOCALES:
+        {
+            description:
+            'Support for the two-letter locale name "ar" to format decimal numbers as Arabic numerals.',
+            check:
+            function ()
             {
-                engine: 'Safari 7.1 and Safari 8',
-                includes:
-                [
-                    'ARRAY_ITERATOR',
-                    'ATOB',
-                    'BARPROP',
-                    'CONSOLE',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FF_SRC',
-                    'FILL',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCATION',
-                    'NAME',
-                    'NODECONSTRUCTOR',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes:
-                {
-                    'char-increment-restriction':   null,
-                    'no-atob-in-web-worker':        null,
-                    'safari-bug-21820506':          null,
-                    'web-worker-restriction':       null,
-                },
+                var NUMBER = 9876430.125;
+
+                var localizedNumeral = NUMBER.toLocaleString('ar');
+                var available =
+                localizedNumeral === NUMBER.toLocaleString('ar-td') &&
+                localizedNumeral !== NUMBER.toLocaleString('en');
+                return available;
             },
-            SAFARI_8: { aliasFor: 'SAFARI_7_1' },
-            SAFARI_9:
+            includes: ['LOCALE_NUMERALS'],
+        },
+        STATUS:
+        {
+            description: 'Existence of the global string status.',
+            check:
+            function ()
             {
-                engine: 'Safari 9',
-                includes:
-                [
-                    'ATOB',
-                    'BARPROP',
-                    'CONSOLE',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FF_SRC',
-                    'FILL',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCATION',
-                    'NAME',
-                    'NODECONSTRUCTOR',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes:
-                {
-                    'char-increment-restriction':   null,
-                    'no-atob-in-web-worker':        null,
-                    'safari-bug-21820506':          null,
-                    'web-worker-restriction':       null,
-                },
+                var available = typeof status === 'string';
+                return available;
             },
-            SAFARI_10:
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+        UNDEFINED:
+        {
+            description:
+            'The property that Object.prototype.toString.call() evaluates to "[object Undefined]".\n' +
+            'This behavior is specified by ECMAScript, and is enforced by all engines except Android ' +
+            'Browser versions prior to 4.1.2, where this feature is not available.',
+            check:
+            function ()
             {
-                engine: 'Safari 10 and Safari 11',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'BARPROP',
-                    'CONSOLE',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FF_SRC',
-                    'FILL',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+                var available = Object.prototype.toString.call() === '[object Undefined]';
+                return available;
             },
-            SAFARI_12:
+        },
+        V8_SRC:
+        {
+            description:
+            'A string representation of native functions typical for the V8 engine.\n' +
+            'Remarkable traits are the lack of line feed characters at the beginning and at the end ' +
+            'of the string and the presence of a single whitespace before the "[native code]" ' +
+            'sequence.',
+            includes: ['NO_FF_SRC', 'NO_IE_SRC'],
+            excludes: ['NO_V8_SRC'],
+        },
+        WINDOW:
+        {
+            description:
+            'Existence of the global object self having the string representation "[object Window]".',
+            check:
+            checkSelfFeature.bind
+            (
+                function (str)
+                {
+                    var available = str === '[object Window]';
+                    return available;
+                }
+            ),
+            includes: ['ANY_WINDOW'],
+            excludes: ['DOMWINDOW'],
+            attributes: { 'web-worker': 'web-worker-restriction' },
+        },
+
+        DEFAULT:
+        {
+            description:
+            'Minimum feature level, compatible with all supported engines in all environments.',
+        },
+        BROWSER:
+        {
+            description:
+            'Features available in all browsers.\n' +
+            'No support for Node.js.',
+            includes: ['ANY_DOCUMENT', 'ANY_WINDOW', 'HISTORY', 'INCR_CHAR', 'STATUS'],
+            attributes:
             {
-                engine: 'Safari 12',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'BARPROP',
-                    'CONSOLE',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FF_SRC',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+                'char-increment-restriction':   null,
+                'safari-bug-21820506':          null,
+                'web-worker-restriction':       null,
             },
-            SAFARI_13:
+        },
+        COMPACT:
+        {
+            description:
+            'All new browsers\' features.\n' +
+            'No support for Node.js and older browsers like Internet Explorer, Safari 9 or Android ' +
+            'Browser.',
+            includes:
+            [
+                'ARROW',
+                'ATOB',
+                'BARPROP',
+                'ESC_HTML_QUOT_ONLY',
+                'ESC_REGEXP_LF',
+                'ESC_REGEXP_SLASH',
+                'FILL',
+                'FLAT',
+                'FROM_CODE_POINT',
+                'GENERIC_ARRAY_TO_STRING',
+                'GLOBAL_UNDEFINED',
+                'GMT',
+                'HISTORY',
+                'HTMLDOCUMENT',
+                'INCR_CHAR',
+                'INTL',
+                'LOCALE_INFINITY',
+                'LOCALE_NUMERALS_EXT',
+                'LOCATION',
+                'NAME',
+                'NO_IE_SRC',
+                'NO_OLD_SAFARI_ARRAY_ITERATOR',
+                'REGEXP_STRING_ITERATOR',
+                'STATUS',
+                'WINDOW',
+            ],
+            attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+        },
+        ANDRO_4_0:
+        {
+            families: ['Android Browser'],
+            versions: ['4.0'],
+            includes:
+            [
+                'ATOB',
+                'CONSOLE',
+                'DOMWINDOW',
+                'ESC_HTML_ALL',
+                'FUNCTION_22_LF',
+                'GMT',
+                'HISTORY',
+                'HTMLDOCUMENT',
+                'INCR_CHAR',
+                'LOCATION',
+                'NAME',
+                'STATUS',
+                'V8_SRC',
+            ],
+        },
+        ANDRO_4_1:
+        {
+            inherits: 'ANDRO_4_0',
+            versions: [['4.1',, '4.3']],
+            includes: { GENERIC_ARRAY_TO_STRING: true, OBJECT_UNDEFINED: true },
+        },
+        ANDRO_4_4:
+        {
+            inherits: 'ANDRO_4_1',
+            versions: ['4.4'],
+            includes:
             {
-                engine: 'Safari 13 and Safari 14.0.0',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'BARPROP',
-                    'CONSOLE',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FF_SRC',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'PLAIN_INTL',
-                    'REGEXP_STRING_ITERATOR',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+                BARPROP:                true,
+                DOMWINDOW:              false,
+                HTMLAUDIOELEMENT:       true,
+                LOCALE_INFINITY:        true,
+                LOCALE_NUMERALS_EXT:    true,
+                PLAIN_INTL:             true,
+                SHORT_LOCALES:          true,
+                WINDOW:                 true,
             },
-            SAFARI_14_0_1:
+            attributes: { 'no-console-in-web-worker': null, 'web-worker-restriction': null },
+        },
+        CHROME_PREV:
+        {
+            description: describeEngine('the previous to current versions of Chrome and Edge'),
+            aliasFor: 'CHROME_92',
+        },
+        CHROME:
+        {
+            description: describeEngine('the current stable versions of Chrome, Edge and Opera'),
+            aliasFor: 'CHROME_92',
+        },
+        CHROME_92:
+        {
+            families: ['Chrome', 'Edge', 'Opera'],
+            versions: [['92'], ['92'], ['78']],
+            includes:
+            [
+                'ARROW',
+                'AT',
+                'ATOB',
+                'BARPROP',
+                'ESC_HTML_QUOT_ONLY',
+                'ESC_REGEXP_LF',
+                'ESC_REGEXP_SLASH',
+                'FILL',
+                'FLAT',
+                'FROM_CODE_POINT',
+                'FUNCTION_19_LF',
+                'GENERIC_ARRAY_TO_STRING',
+                'GLOBAL_UNDEFINED',
+                'GMT',
+                'HISTORY',
+                'HTMLDOCUMENT',
+                'INCR_CHAR',
+                'INTL',
+                'LOCALE_INFINITY',
+                'LOCALE_NUMERALS_EXT',
+                'LOCATION',
+                'NAME',
+                'NO_OLD_SAFARI_ARRAY_ITERATOR',
+                'REGEXP_STRING_ITERATOR',
+                'STATUS',
+                'V8_SRC',
+                'WINDOW',
+            ],
+            attributes:
+            { 'char-increment-restriction': null, 'unstable': null, 'web-worker-restriction': null },
+        },
+        FF_ESR:
+        {
+            description: describeEngine('the current version of Firefox ESR'),
+            aliasFor: 'FF_78',
+        },
+        FF_78:
+        {
+            families: ['Firefox'],
+            versions: [['78',, '82']],
+            includes:
+            [
+                'ARROW',
+                'ATOB',
+                'BARPROP',
+                'ESC_HTML_QUOT_ONLY',
+                'ESC_REGEXP_LF',
+                'ESC_REGEXP_SLASH',
+                'FF_SRC',
+                'FILL',
+                'FLAT',
+                'FROM_CODE_POINT',
+                'FUNCTION_19_LF',
+                'GENERIC_ARRAY_TO_STRING',
+                'GLOBAL_UNDEFINED',
+                'GMT',
+                'HISTORY',
+                'HTMLDOCUMENT',
+                'INCR_CHAR',
+                'LOCALE_INFINITY',
+                'LOCALE_NUMERALS_EXT',
+                'LOCATION',
+                'NAME',
+                'NO_OLD_SAFARI_ARRAY_ITERATOR',
+                'PLAIN_INTL',
+                'REGEXP_STRING_ITERATOR',
+                'SHORT_LOCALES',
+                'STATUS',
+                'WINDOW',
+            ],
+            attributes:
+            { 'char-increment-restriction': null, 'unstable': null, 'web-worker-restriction': null },
+        },
+        FF_83:
+        {
+            inherits: 'FF_78',
+            versions: [['83',, '89']],
+            includes: { INTL: true, PLAIN_INTL: false },
+        },
+        FF_PREV:
+        {
+            description: describeEngine('the previous to current version of Firefox'),
+            aliasFor: 'FF_90',
+        },
+        FF:
+        {
+            description: describeEngine('the current stable version of Firefox'),
+            aliasFor: 'FF_90',
+        },
+        FF_90:
+        {
+            inherits: 'FF_83',
+            versions: [['90']],
+            includes: { AT: true },
+        },
+        IE_9:
+        {
+            families: ['Internet Explorer'],
+            versions: ['9'],
+            includes:
+            [
+                'CAPITAL_HTML',
+                'DOCUMENT',
+                'ESC_REGEXP_LF',
+                'ESC_REGEXP_SLASH',
+                'FUNCTION_22_LF',
+                'GENERIC_ARRAY_TO_STRING',
+                'HISTORY',
+                'IE_SRC',
+                'INCR_CHAR',
+                'OBJECT_L_LOCATION_CTOR',
+                'OBJECT_W_CTOR',
+                'STATUS',
+                'UNDEFINED',
+                'WINDOW',
+            ],
+        },
+        IE_10:
+        {
+            inherits: 'IE_9',
+            versions: ['10'],
+            includes: { ATOB: true, CONSOLE: true, OBJECT_UNDEFINED: true, UNDEFINED: false },
+            attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+        },
+        IE_11:
+        {
+            inherits: 'IE_10',
+            versions: ['11'],
+            includes:
             {
-                engine: 'Safari 14.0.1 to 14.0.3',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'BARPROP',
-                    'CONSOLE',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FF_SRC',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'INTL',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'REGEXP_STRING_ITERATOR',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+                DOCUMENT:           false,
+                GMT:                true,
+                HTMLDOCUMENT:       true,
+                LOCALE_NUMERALS:    true,
+                PLAIN_INTL:         true,
+                SHORT_LOCALES:      true,
             },
-            SAFARI:
+        },
+        IE_11_WIN_10:
+        {
+            inherits: 'IE_11',
+            versions: ['11'],
+            compatibilityTag: 'on Windows 10',
+            compatibilityShortTag: 'W10',
+            includes: { LOCALE_INFINITY: true, LOCALE_NUMERALS: false, LOCALE_NUMERALS_EXT: true },
+        },
+        NODE_0_10:
+        {
+            families: ['Node.js'],
+            versions: ['0.10'],
+            includes:
+            [
+                'ESC_HTML_ALL',
+                'FUNCTION_22_LF',
+                'GENERIC_ARRAY_TO_STRING',
+                'GLOBAL_UNDEFINED',
+                'GMT',
+                'INCR_CHAR',
+                'NAME',
+                'V8_SRC',
+            ],
+        },
+        NODE_0_12:
+        {
+            inherits: 'NODE_0_10',
+            versions: ['0.12'],
+            includes:
             {
-                engine: 'the current stable version of Safari',
-                aliasFor: 'SAFARI_14_1',
+                ESC_HTML_ALL:                   false,
+                ESC_HTML_QUOT_ONLY:             true,
+                LOCALE_INFINITY:                true,
+                NO_OLD_SAFARI_ARRAY_ITERATOR:   true,
+                PLAIN_INTL:                     true,
+            },
+        },
+        NODE_4:
+        {
+            inherits: 'NODE_0_12',
+            versions: ['4'],
+            includes: { ARROW: true, ESC_REGEXP_SLASH: true, FILL: true, FROM_CODE_POINT: true },
+        },
+        NODE_5:
+        {
+            inherits: 'NODE_4',
+            versions: [['5',, '9']],
+            attributes: { 'char-increment-restriction': null },
+        },
+        NODE_10:
+        {
+            inherits: 'NODE_5',
+            versions: ['10'],
+            includes: { FUNCTION_19_LF: true, FUNCTION_22_LF: false },
+        },
+        NODE_11:
+        {
+            inherits: 'NODE_10',
+            versions: ['11'],
+            includes: { FLAT: true },
+        },
+        NODE_12:
+        {
+            inherits: 'NODE_11',
+            versions: ['12'],
+            includes: { ESC_REGEXP_LF: true, REGEXP_STRING_ITERATOR: true },
+        },
+        NODE_13:
+        {
+            inherits: 'NODE_12',
+            versions: [['13', '14']],
+            includes: { LOCALE_NUMERALS_EXT: true, SHORT_LOCALES: true },
+        },
+        NODE_15:
+        {
+            inherits: 'NODE_13',
+            versions: ['15'],
+            includes: { INTL: true, PLAIN_INTL: false },
+        },
+        NODE_16_0:
+        {
+            inherits: 'NODE_15',
+            versions: [['16.0',, '16.5']],
+            includes: { ATOB: true },
+        },
+        NODE_16_6:
+        {
+            inherits: 'NODE_16_0',
+            versions: [['16.6']],
+            includes: { AT: true },
+        },
+        SAFARI_7_0:
+        {
+            families: ['Safari'],
+            versions: ['7.0'],
+            includes:
+            [
+                'ATOB',
+                'BARPROP',
+                'CONSOLE',
+                'ESC_HTML_QUOT_ONLY',
+                'ESC_REGEXP_LF',
+                'ESC_REGEXP_SLASH',
+                'FF_SRC',
+                'GENERIC_ARRAY_TO_STRING',
+                'GLOBAL_UNDEFINED',
+                'GMT',
+                'HISTORY',
+                'HTMLDOCUMENT',
+                'INCR_CHAR',
+                'LOCATION',
+                'NAME',
+                'NODECONSTRUCTOR',
+                'OBJECT_L_LOCATION_CTOR',
+                'OBJECT_W_CTOR',
+                'OLD_SAFARI_LOCATION_CTOR',
+                'STATUS',
+                'WINDOW',
+            ],
+            attributes:
+            {
+                'char-increment-restriction':   null,
+                'no-console-in-web-worker':     null,
+                'old-safari-restriction':       null,
+                'web-worker-restriction':       null,
             },
-            SAFARI_14_1:
+        },
+        SAFARI_7_1:
+        {
+            inherits: 'SAFARI_7_0',
+            versions: [['7.1', '8']],
+            includes: { ARRAY_ITERATOR: true, FILL: true },
+            attributes: { 'no-console-in-web-worker': undefined, 'safari-bug-21820506': null },
+        },
+        SAFARI_9:
+        {
+            inherits: 'SAFARI_7_1',
+            versions: ['9'],
+            includes:
             {
-                engine: 'Safari 14.1 or later',
-                includes:
-                [
-                    'ARROW',
-                    'ATOB',
-                    'BARPROP',
-                    'ESC_HTML_QUOT_ONLY',
-                    'ESC_REGEXP_LF',
-                    'ESC_REGEXP_SLASH',
-                    'FF_SRC',
-                    'FILL',
-                    'FLAT',
-                    'FROM_CODE_POINT',
-                    'FUNCTION_22_LF',
-                    'GENERIC_ARRAY_TO_STRING',
-                    'GLOBAL_UNDEFINED',
-                    'GMT',
-                    'HISTORY',
-                    'HTMLDOCUMENT',
-                    'INCR_CHAR',
-                    'INTL',
-                    'LOCALE_INFINITY',
-                    'LOCALE_NUMERALS_EXT',
-                    'LOCATION',
-                    'NAME',
-                    'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                    'REGEXP_STRING_ITERATOR',
-                    'SHORT_LOCALES',
-                    'STATUS',
-                    'WINDOW',
-                ],
-                attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
+                ARRAY_ITERATOR:                 false,
+                FROM_CODE_POINT:                true,
+                FUNCTION_22_LF:                 true,
+                NO_OLD_SAFARI_ARRAY_ITERATOR:   true,
             },
+        },
+        SAFARI_10:
+        {
+            inherits: 'SAFARI_9',
+            versions: [['10', '11']],
+            includes:
+            {
+                ARROW:                      true,
+                LOCALE_INFINITY:            true,
+                LOCALE_NUMERALS_EXT:        true,
+                NODECONSTRUCTOR:            false,
+                OBJECT_L_LOCATION_CTOR:     false,
+                OBJECT_W_CTOR:              false,
+                OLD_SAFARI_LOCATION_CTOR:   false,
+                PLAIN_INTL:                 true,
+                SHORT_LOCALES:              true,
+            },
+            attributes: { 'old-safari-restriction': undefined, 'safari-bug-21820506': undefined },
+        },
+        SAFARI_12:
+        {
+            inherits: 'SAFARI_10',
+            versions: ['12'],
+            includes: { FLAT: true },
+        },
+        SAFARI_13:
+        {
+            inherits: 'SAFARI_12',
+            versions: [['13', '14.0.0']],
+            includes: { REGEXP_STRING_ITERATOR: true },
+        },
+        SAFARI_14_0_1:
+        {
+            inherits: 'SAFARI_13',
+            versions: [['14.0.1',, '14.0.3']],
+            includes: { INTL: true, PLAIN_INTL: false },
+        },
+        SAFARI:
+        {
+            description: describeEngine('the current stable version of Safari'),
+            aliasFor: 'SAFARI_14_1',
+        },
+        SAFARI_14_1:
+        {
+            inherits: 'SAFARI_14_0_1',
+            versions: [['14.1']],
+            includes: { CONSOLE: false },
+        },
+    };
+    (function ()
+    {
+        function formatEngineDescription(compatibilities)
+        {
+            var appendix = '';
+            var parts =
+            compatibilities.map
+            (
+                function (compatibility)
+                {
+                    var family = compatibility.family;
+                    var version = compatibility.version;
+                    var part = family;
+                    if (typeof version === 'string')
+                        part += ' ' + version;
+                    else
+                    {
+                        part += ' ' + version.from;
+                        var to = version.to;
+                        if (to != null)
+                            part += (version.dense ? ' and ' + family + ' ' : ' to ') + to;
+                        else
+                            appendix = ' or later';
+                    }
+                    var tag = compatibility.tag;
+                    if (tag != null)
+                        part += ' ' + tag;
+                    return part;
+                }
+            );
+            var lastPart = parts.pop();
+            var engine = (parts.length ? parts.join(', ') + ' and ' + lastPart : lastPart) + appendix;
+            var description = describeEngine(engine);
+            return description;
         }
-    );
+
+        var autoIncludes =
+        _Object_keys$1(featureInfos).filter
+        (
+            function (featureName)
+            {
+                var featureInfo = featureInfos[featureName];
+                var check = featureInfo.check;
+                var returnValue = check && check();
+                return returnValue;
+            }
+        );
+        featureInfos.AUTO =
+        {
+            description: describeEngine('the current environment'),
+            includes: autoIncludes,
+        };
+        Feature = createFeatureClass(featureInfos, formatEngineDescription);
+        ELEMENTARY = Feature.ELEMENTARY;
+        featureInfos = null;
+        assignNoEnum$1(Feature.prototype, { restrict: restrict });
+        var ALL = Feature.ALL;
+        var descriptor = { enumerable: true };
+        for (var featureName in ALL)
+        {
+            var featureObj = ALL[featureName];
+            descriptor.value = featureObj;
+            _Object_defineProperty$1(Feature, featureName, descriptor);
+        }
+    }
+    )();
 
     function callWithFeatures()
     {
@@ -2675,7 +2318,7 @@
 
     var staticEncoder;
 
-    // novem 2.0.1 – https://github.com/fasttime/JScrewIt/tree/master/packages/novem
+    // ~solution – https://github.com/fasttime/JScrewIt/tree/master/packages/~solution
 
     var INVALID_EXPR = {};
     function evalExpr$1(expr) {
@@ -3046,7 +2689,9 @@
         return replacement;
     };
 
-    assignNoEnum
+    // End of module ~solution
+
+    assignNoEnum$1
     (
         AbstractSolution.prototype,
         {
@@ -3058,12 +2703,16 @@
             },
             set appendLength(appendLength)
             {
-                _Object_defineProperty(this, 'appendLength', { enumerable: true, value: appendLength });
+                _Object_defineProperty$1(this, 'appendLength', { enumerable: true, value: appendLength });
             },
         }
     );
 
     // As of version 2.1.0, definitions are interpreted using JScrewIt's own express parser, which can
+    // handle and optimize a useful subset of the JavaScript syntax.
+    // See express-parse.js for details about constructs recognized by express.
+    // Compared to generic purpose encoding, definition encoding differs mainly in that every identifier
+    // used must be defined itself, too, in a constant definition.
 
     var AMENDINGS = ['true', 'undefined', 'NaN'];
 
@@ -3417,7 +3066,6 @@
         var ESC_HTML_QUOT_ONLY              = Feature.ESC_HTML_QUOT_ONLY;
         var ESC_REGEXP_LF                   = Feature.ESC_REGEXP_LF;
         var ESC_REGEXP_SLASH                = Feature.ESC_REGEXP_SLASH;
-        var EXTERNAL                        = Feature.EXTERNAL;
         var FF_SRC                          = Feature.FF_SRC;
         var FILL                            = Feature.FILL;
         var FLAT                            = Feature.FLAT;
@@ -3443,7 +3091,10 @@
         var NO_IE_SRC                       = Feature.NO_IE_SRC;
         var NO_OLD_SAFARI_ARRAY_ITERATOR    = Feature.NO_OLD_SAFARI_ARRAY_ITERATOR;
         var NO_V8_SRC                       = Feature.NO_V8_SRC;
+        var OBJECT_L_LOCATION_CTOR          = Feature.OBJECT_L_LOCATION_CTOR;
         var OBJECT_UNDEFINED                = Feature.OBJECT_UNDEFINED;
+        var OBJECT_W_CTOR                   = Feature.OBJECT_W_CTOR;
+        var OLD_SAFARI_LOCATION_CTOR        = Feature.OLD_SAFARI_LOCATION_CTOR;
         var PLAIN_INTL                      = Feature.PLAIN_INTL;
         var REGEXP_STRING_ITERATOR          = Feature.REGEXP_STRING_ITERATOR;
         var SELF_OBJ                        = Feature.SELF_OBJ;
@@ -3511,7 +3162,15 @@
         {
             var expr = '(' + number + ')[TO_LOCALE_STRING](' + locale + ')';
             if (index != null)
-                expr += '[' + index + ']';
+            {
+                if (index > 4)
+                {
+                    var paddingBlock = R_PADDINGS[10 - index];
+                    expr = '(' + paddingBlock + ' + ' + expr + ')[10]';
+                }
+                else
+                    expr += '[' + index + ']';
+            }
             var entry = define._callWithFeatures(expr, LOCALE_NUMERALS, arguments, 3);
             return entry;
         }
@@ -3549,7 +3208,7 @@
 
         function useLocaleNumeralDigitDefinitions(locale, zeroCharCode)
         {
-            var fromCharCode = _String.fromCharCode;
+            var fromCharCode = _String$1.fromCharCode;
             for (var digit = 0; digit <= 9; ++digit)
             {
                 var char = fromCharCode(zeroCharCode + digit);
@@ -3837,6 +3496,7 @@
                 define('escape((RP_4_A + [+("1000" + (AT + 0)[31] + 0)] + AT)[40])[2]', AT), // *
                 define('btoa("00")[1]', ATOB),
                 define('(RP_3_WA + document)[11]', DOCUMENT),
+                define('(RP_3_WA + self)[11]', DOMWINDOW),
                 define // *
                 ('escape((NaN + [+("10" + [(RP_6_S + FILL)[40]] + "000")] + FILL)[40])[2]', FILL),
                 define // *
@@ -3857,7 +3517,6 @@
                 defineCharAtFnPos('RegExp', 12),
                 define('btoa("0NaN")[1]', ATOB),
                 define('(RP_5_A + "".link())[10]', CAPITAL_HTML),
-                define('(RP_3_WA + sidebar)[11]', EXTERNAL),
                 define('(RP_3_WA + Audio)[21]', HTMLAUDIOELEMENT),
                 define('(RP_0_S + REGEXP_STRING_ITERATOR)[11]', REGEXP_STRING_ITERATOR),
             ],
@@ -3907,6 +3566,12 @@
                     },
                     LOCATION
                 ),
+                define('(RP_3_WA + LOCATION_CONSTRUCTOR)[11]', OBJECT_L_LOCATION_CTOR),
+                define
+                (
+                    '(LOCATION_CONSTRUCTOR + RP_0_S)[SLICE_OR_SUBSTR]("-20")[0]',
+                    OLD_SAFARI_LOCATION_CTOR
+                ),
                 define
                 (
                     {
@@ -3916,6 +3581,7 @@
                     AT,
                     LOCATION
                 ),
+                define('(LOCATION_CONSTRUCTOR + RP_0_S).at("-20")', AT, OLD_SAFARI_LOCATION_CTOR),
                 define
                 (
                     '[][TO_STRING].call(location)[SLICE_OR_SUBSTR]("-10")[1]',
@@ -3934,6 +3600,7 @@
             [
                 define('btoa(0)[0]', ATOB),
                 define('"".small()[2]', CAPITAL_HTML),
+                define('(RP_0_S + self)[10]', DOMWINDOW),
                 define('(RP_4_A + Date())[30]', GMT),
                 define('(RP_0_S + Audio)[11]', HTMLAUDIOELEMENT),
                 define('(RP_0_S + document)[10]', HTMLDOCUMENT),
@@ -3945,6 +3612,7 @@
                 define('(RP_3_WA + PLAIN_OBJECT)[11]'),
                 define('btoa(NaN)[3]', ATOB),
                 define('"".fontcolor()[2]', CAPITAL_HTML),
+                define('(RP_1_WA + self)[10]', DOMWINDOW),
                 define('(RP_3_WA + Intl)[11]', PLAIN_INTL),
             ],
             'P':
@@ -3996,11 +3664,24 @@
             [
                 define('btoa("1NaN")[1]', ATOB),
                 define('"".sub()[2]', CAPITAL_HTML),
-                define('(RP_3_WA + Function("return toString")()())[11]', GLOBAL_UNDEFINED),
-                define('(RP_3_WA + Function("return{}.toString")()())[11]', OBJECT_UNDEFINED),
+                define
+                (
+                    { expr: '(RP_3_WA + Function("return toString")()())[11]', optimize: true },
+                    GLOBAL_UNDEFINED
+                ),
+                define
+                (
+                    { expr: '(RP_3_WA + Function("return{}.toString")()())[11]', optimize: true },
+                    OBJECT_UNDEFINED
+                ),
                 define('(RP_3_WA + PLAIN_OBJECT[TO_STRING].call())[11]', UNDEFINED),
                 define('(RP_3_WA + ARRAY_ITERATOR[TO_STRING].call())[11]', ARRAY_ITERATOR, UNDEFINED),
-                define('(RP_3_WA + Function("return Intl.toString")()())[11]', INTL, OBJECT_UNDEFINED),
+                define
+                (
+                    { expr: '(RP_3_WA + Function("return Intl.toString")()())[11]', optimize: true },
+                    INTL,
+                    OBJECT_UNDEFINED
+                ),
                 define('(RP_3_WA + Intl[TO_STRING].call())[11]', INTL, UNDEFINED),
             ],
             'V':
@@ -4016,6 +3697,7 @@
                 define('(self + RP_4_A)[SLICE_OR_SUBSTR]("-11")[0]', ANY_WINDOW),
                 define('btoa(undefined)[1]', ATOB),
                 define('(RP_0_S + self)[11]', DOMWINDOW),
+                define('(RP_3_WA + Function("return constructor")())[11]', OBJECT_W_CTOR),
                 define('(RP_3_WA + self)[11]', WINDOW),
                 define('(self + RP_4_A).at("-11")', ANY_WINDOW, AT),
                 defineCharDefault({ atob: false }),
@@ -4142,7 +3824,6 @@
             [
                 define('101[TO_STRING]("34")[1]'),
                 define('btoa("falsefalse")[10]', ATOB),
-                define('(RP_1_WA + sidebar)[10]', EXTERNAL),
             ],
             'y': '(RP_3_WA + [Infinity])[10]',
             'z':
@@ -4335,10 +4016,6 @@
             [
                 define('Function("return self")()', SELF_OBJ),
             ],
-            sidebar:
-            [
-                define('Function("return sidebar")()', EXTERNAL),
-            ],
             unescape:
             [
                 define({ expr: 'Function("return unescape")()', optimize: true }),
@@ -4486,6 +4163,11 @@
                 define({ expr: '"ar-td"', solutionType: SolutionType.COMBINED_STRING }),
                 define({ expr: '"ar"', solutionType: SolutionType.COMBINED_STRING }, SHORT_LOCALES),
             ],
+            LOCATION_CONSTRUCTOR:
+            [
+                define('Function("return location")().constructor', OBJECT_L_LOCATION_CTOR),
+                define('Function("return location")().constructor', OLD_SAFARI_LOCATION_CTOR),
+            ],
             PLAIN_OBJECT:
             [
                 define('Function("return{}")()'),
@@ -5474,8 +5156,8 @@
         while ('value' in unit && isUndecoratedUnit(unit))
         {
             var value = unit.value;
-            if (!_Array_isArray(value))
-                return value == null && inArray ? '' : _String(value);
+            if (!_Array_isArray$1(value))
+                return value == null && inArray ? '' : _String$1(value);
             unit = value[0];
             if (!unit)
                 return '';
@@ -5669,7 +5351,7 @@
         this._length = -APPEND_LENGTH_OF_EMPTY;
     }
 
-    assignNoEnum
+    assignNoEnum$1
     (
         ScrewBuffer.prototype,
         {
@@ -5781,7 +5463,7 @@
     function findBase64AlphabetDefinition(encoder, element)
     {
         var definition;
-        if (_Array_isArray(element))
+        if (_Array_isArray$1(element))
             definition = encoder.findDefinition(element);
         else
             definition = element;
@@ -5815,7 +5497,7 @@
 
     function replaceIndexer(index)
     {
-        var indexStr = _String(index);
+        var indexStr = _String$1(index);
         var replacement = '[' + replaceStaticString(indexStr) + ']';
         return replacement;
     }
@@ -5949,13 +5631,15 @@
     var BOND_STRENGTH_WEAK      = 1;
     var BOND_STRENGTH_STRONG    = 2;
 
+    var featureFromMask = Feature._fromMask;
+
     /** @class Encoder */
 
     function Encoder(mask)
     {
         this.mask               = mask;
-        this._charCache         = _Object_create(STATIC_CHAR_CACHE);
-        this._constCache        = _Object_create(STATIC_CONST_CACHE);
+        this._charCache         = _Object_create$1(STATIC_CHAR_CACHE);
+        this._constCache        = _Object_create$1(STATIC_CONST_CACHE);
         this._definitionCache   = createEmpty();
         this._optimizers        = createEmpty();
         this._stack             = [];
@@ -5974,7 +5658,7 @@
                 var feature = featureFromMask(encoder.mask);
                 var message = 'Circular reference detected: ' + chain.join(' < ') + ' – ' + feature;
                 var error = new _SyntaxError(message);
-                assignNoEnum(error, { chain: chain, feature: feature });
+                assignNoEnum$1(error, { chain: chain, feature: feature });
                 throw error;
             }
             resolver.call(encoder);
@@ -6168,7 +5852,7 @@
         APPEND_LENGTH_OF_DIGIT_0 * extraZeroCount +
         APPEND_LENGTH_OF_SMALL_E +
         APPEND_LENGTH_OF_MINUS +
-        getMultiDigitLength(_String(-exp));
+        getMultiDigitLength(_String$1(-exp));
         if (extraLength < rivalExtraLength)
         {
             var str = mantissa + 'e' + exp;
@@ -6249,7 +5933,7 @@
                 var screwMode = bondStrength ? SCREW_AS_BONDED_STRING : SCREW_AS_STRING;
                 output = strReplacer(encoder, value, screwMode, unitIndices, maxLength);
             }
-            else if (_Array_isArray(value))
+            else if (_Array_isArray$1(value))
             {
                 if (value.length)
                 {
@@ -6284,7 +5968,7 @@
                         output = '(' + output + ')';
                 }
                 else
-                    output = replaceIdentifier(STATIC_ENCODER, _String(value), bondStrength);
+                    output = replaceIdentifier(STATIC_ENCODER, _String$1(value), bondStrength);
                 if (output.length > maxLength)
                     return;
             }
@@ -6313,7 +5997,7 @@
     (function ()
     {
         var matchSimpleAt;
-        var pattern = _Object_keys(SIMPLE).join('|');
+        var pattern = _Object_keys$1(SIMPLE).join('|');
         var regExp = tryCreateRegExp(pattern, 'y');
         if (regExp)
         {
@@ -6343,7 +6027,7 @@
     }
     )();
 
-    assignNoEnum
+    assignNoEnum$1
     (
         Encoder.prototype,
         {
@@ -6389,7 +6073,7 @@
             function (length)
             {
                 var paddingBlock = R_PADDINGS[length];
-                if (paddingBlock !== undefined)
+                if (paddingBlock)
                     return paddingBlock;
                 throwSyntaxError(this, 'Undefined regular padding block with length ' + length);
             },
@@ -6486,7 +6170,7 @@
                     paddingBlock = padding.block;
                     shiftedIndex = padding.shiftedIndex;
                 }
-                var fullExpr = '(' + paddingBlock + '+' + expr + ')[' + shiftedIndex + ']';
+                var fullExpr = '(' + paddingBlock + ' + ' + expr + ')[' + shiftedIndex + ']';
                 var replacement = this.replaceExpr(fullExpr);
                 var solution = new SimpleSolution(char, replacement, SolutionType.STRING);
                 return solution;
@@ -6638,7 +6322,7 @@
                     if (!buffer.append(solution) || buffer.length > maxLength)
                         return;
                 }
-                var replacement = _String(buffer);
+                var replacement = _String$1(buffer);
                 if (!(replacement.length > maxLength))
                     return replacement;
             },
@@ -6684,11 +6368,11 @@
                     callResolver
                     (
                         this,
-                        _JSON_stringify(char),
+                        _JSON_stringify$1(char),
                         function ()
                         {
                             var entries = CHARACTERS[char];
-                            if (!entries || _Array_isArray(entries))
+                            if (!entries || _Array_isArray$1(entries))
                             {
                                 if (entries)
                                     solution = findOptimalSolution(this, char, entries);
@@ -6722,7 +6406,7 @@
                         function ()
                         {
                             var entries = this.constantDefinitions[constant];
-                            if (_Array_isArray(entries))
+                            if (_Array_isArray$1(entries))
                             {
                                 solution =
                                 findOptimalSolution(this, constant, entries, SolutionType.OBJECT);
@@ -6899,7 +6583,7 @@
         perfInfoList.inputLength = inputLength;
         perfLog.push(perfInfoList);
         var inputData = _Object(input);
-        _Object_keys(options).forEach
+        _Object_keys$1(options).forEach
         (
             function (optName)
             {
@@ -7249,7 +6933,7 @@
                     .count++;
                 }
             );
-            var charList = _Object_keys(charMap);
+            var charList = _Object_keys$1(charMap);
             inputData.freqList =
             freqList =
             charList.map
@@ -7780,7 +7464,7 @@
     }
     )();
 
-    assignNoEnum
+    assignNoEnum$1
     (
         Encoder.prototype,
         {
@@ -7866,7 +7550,7 @@
                     {
                         var separator = AMENDINGS[index];
                         var digit = firstDigit + index;
-                        var joiner = _String(digit);
+                        var joiner = _String$1(digit);
                         var substitution = { separator: separator, joiner: joiner };
                         substitutions.push(substitution);
                     }
@@ -7933,7 +7617,7 @@
                     perfInfo.perfLog = perfLog;
                 delete this.perfLog;
                 if (output == null)
-                    throw new _Error('Encoding failed');
+                    throw new _Error$1('Encoding failed');
                 return output;
             },
 
@@ -8197,7 +7881,7 @@
     );
 
     var codePointOf =
-    _String.prototype.codePointAt ?
+    _String$1.prototype.codePointAt ?
     function (char)
     {
         var codePoint = char.codePointAt();
@@ -8538,6 +8222,14 @@
     }
 
     // Optimized clusters take the form:
+    //
+    // +(X)["toString"](Y)
+    //
+    // X is a JSFuck integer between 23 and MAX_SAFE_INTEGER.
+    //
+    // Y takes at least 15 charactes for "20" and at most 46 characters for "36".
+    //
+    // The leading append plus is omitted when the optimized cluster is the first element of a group.
 
     var BOND_EXTRA_LENGTH = 2; // Extra length of bonding parentheses "(" and ")".
     var CLUSTER_EXTRA_LENGTHS = [];
@@ -8840,7 +8532,7 @@
         return optimizerList;
     }
 
-    assignNoEnum
+    assignNoEnum$1
     (
         Encoder.prototype,
         {
@@ -8883,7 +8575,7 @@
 
     function encode(input, options)
     {
-        input = esToString(input);
+        input = esToString$1(input);
         options = options || { };
         var features = options.features;
         var runAsData;
@@ -8910,7 +8602,7 @@
 
         if (input === undefined)
             return [wrapWithEval, STRATEGY_NAMES_BOTH];
-        switch (_String(input))
+        switch (_String$1(input))
         {
         case 'call':
             return [wrapWithCall, STRATEGY_NAMES_TEXT];
@@ -8925,7 +8617,7 @@
         case 'none':
             return [, STRATEGY_NAMES_TEXT];
         }
-        throw new _Error('Invalid value for option ' + name);
+        throw new _Error$1('Invalid value for option ' + name);
     }
 
     function flushEncoderCache()
@@ -8940,7 +8632,7 @@
 
     function getEncoder(features)
     {
-        var mask = getValidFeatureMask(features);
+        var mask = getFeatureMask(features);
         var encoder = encoderCache.get(mask);
         if (!encoder)
         {
@@ -8952,15 +8644,9 @@
         return encoder;
     }
 
-    function getValidFeatureMask(features)
-    {
-        var mask = features !== undefined ? validMaskFromArrayOrStringOrFeature(features) : maskNew();
-        return mask;
-    }
-
     function isEncoderInCache(features)
     {
-        var mask = getValidFeatureMask(features);
+        var mask = getFeatureMask(features);
         var returnValue = encoderCache.has(mask);
         return returnValue;
     }
@@ -8976,7 +8662,9 @@
             timeout = _setTimeout(flushEncoderCache);
     }
 
-    var JScrewIt = assignNoEnum({ }, { Feature: Feature, encode: encode });
+    var JScrewIt = assignNoEnum$1({ }, { Feature: Feature, encode: encode });
+
+    var getFeatureMask = Feature._getMask;
 
     var _permanentCaching = false;
     var encoderCache;
@@ -8985,7 +8673,7 @@
 
     resetEncoderCache();
 
-    assignNoEnum
+    assignNoEnum$1
     (
         encode,
         {
@@ -9022,7 +8710,7 @@
                 if (typeof obj === 'object')
                 {
                     var target = { };
-                    var names = _Object_keys(obj);
+                    var names = _Object_keys$1(obj);
                     names.forEach
                     (
                         function (name)
@@ -9041,7 +8729,7 @@
                 var outputEntries;
                 if (inputEntries)
                 {
-                    if (_Array_isArray(inputEntries))
+                    if (_Array_isArray$1(inputEntries))
                         outputEntries = inputEntries.map(clone);
                     else
                         outputEntries = [createEntryClone(inputEntries, EMPTY_MASK)];
@@ -9051,7 +8739,7 @@
 
             function createEncoder(features)
             {
-                var mask = getValidFeatureMask(features);
+                var mask = getFeatureMask(features);
                 var encoder = new Encoder(mask);
                 encoder.perfLog = [];
                 return encoder;
@@ -9064,12 +8752,6 @@
                 return entry;
             }
 
-            function createFeatureFromMask(mask)
-            {
-                var featureObj = isMaskCompatible(mask) ? featureFromMask(mask) : null;
-                return featureObj;
-            }
-
             function createScrewBuffer(screwMode, groupThreshold, optimizerList)
             {
                 var buffer = new ScrewBuffer(screwMode, groupThreshold, optimizerList);
@@ -9078,12 +8760,12 @@
 
             function defineConstant(encoder, constant, definition)
             {
-                constant = _String(constant);
+                constant = _String$1(constant);
                 if (!/^[$A-Z_a-z][$\w]*$/.test(constant))
-                    throw new _SyntaxError('Invalid identifier ' + _JSON_stringify(constant));
+                    throw new _SyntaxError('Invalid identifier ' + _JSON_stringify$1(constant));
                 if (!encoder.hasOwnProperty('constantDefinitions'))
-                    encoder.constantDefinitions = _Object_create(CONSTANTS);
-                var entries = [define(esToString(definition))];
+                    encoder.constantDefinitions = _Object_create$1(CONSTANTS);
+                var entries = [define(esToString$1(definition))];
                 encoder.constantDefinitions[constant] = entries;
             }
 
@@ -9095,7 +8777,7 @@
 
             function getCharacters()
             {
-                var chars = _Object_keys(CHARACTERS).sort();
+                var chars = _Object_keys$1(CHARACTERS).sort();
                 return chars;
             }
 
@@ -9107,7 +8789,7 @@
 
             function getComplexNames()
             {
-                var names = _Object_keys(COMPLEX).sort();
+                var names = _Object_keys$1(COMPLEX).sort();
                 return names;
             }
 
@@ -9119,7 +8801,7 @@
 
             function getConstantNames()
             {
-                var names = _Object_keys(CONSTANTS).sort();
+                var names = _Object_keys$1(CONSTANTS).sort();
                 return names;
             }
 
@@ -9145,6 +8827,9 @@
             ENTRIES['BASE64_ALPHABET_LO_4:1']                       = BASE64_ALPHABET_LO_4[1];
             ENTRIES['BASE64_ALPHABET_LO_4:3']                       = BASE64_ALPHABET_LO_4[3];
 
+            var featureFromMask = Feature._fromMask;
+            var getFeatureMask = Feature._getMask;
+
             (function ()
             {
                 function exposeEntries(name, entries)
@@ -9163,7 +8848,7 @@
             )();
 
             var debug =
-            assignNoEnum
+            assignNoEnum$1
             (
                 { },
                 {
@@ -9175,11 +8860,11 @@
                     calculateSolutionType:  calculateSolutionType,
                     createClusteringPlan:   createClusteringPlan,
                     createEncoder:          createEncoder,
-                    createFeatureFromMask:  createFeatureFromMask,
                     createFigurator:        createFigurator,
                     createReindexMap:       createReindexMap,
                     createScrewBuffer:      createScrewBuffer,
                     defineConstant:         defineConstant,
+                    featureFromMask:        featureFromMask,
                     getCharacterEntries:    getCharacterEntries,
                     getCharacters:          getCharacters,
                     getComplexEntry:        getComplexEntry,
@@ -9189,17 +8874,14 @@
                     getEntries:             getEntries,
                     getStrategies:          getStrategies,
                     isEncoderInCache:       isEncoderInCache,
-                    maskAreEqual:           maskAreEqual,
                     maskIncludes:           maskIncludes,
-                    maskNew:                maskNew,
-                    maskNext:               maskNext,
                     maskUnion:              maskUnion,
                     optimizeSolutions:      optimizeSolutions,
                     trimJS:                 trimJS$1,
                 }
             );
 
-            assignNoEnum(JScrewIt, { debug: debug });
+            assignNoEnum$1(JScrewIt, { debug: debug });
         }
         )();
     }