up n_m

node_modules/react-loadable-ssr-addon-v5-slorber/lib/ReactLoadableSSRAddon.js

@@ -0,0 +1,311 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports["default"] = exports.defaultOptions = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _url = _interopRequireDefault(require("url"));
+
+var _utils = require("./utils");
+
+var PLUGIN_NAME = 'ReactLoadableSSRAddon';
+
+var WEBPACK_VERSION = require('webpack/package.json').version;
+
+var WEBPACK_5 = WEBPACK_VERSION.startsWith('5.');
+var defaultOptions = {
+  filename: 'assets-manifest.json',
+  integrity: false,
+  integrityAlgorithms: ['sha256', 'sha384', 'sha512'],
+  integrityPropertyName: 'integrity'
+};
+exports.defaultOptions = defaultOptions;
+
+var ReactLoadableSSRAddon = function () {
+  function ReactLoadableSSRAddon(options) {
+    if (options === void 0) {
+      options = defaultOptions;
+    }
+
+    this.options = (0, _extends2["default"])({}, defaultOptions, options);
+    this.compiler = null;
+    this.stats = null;
+    this.entrypoints = new Set();
+    this.assetsByName = new Map();
+    this.manifest = {};
+  }
+
+  var _proto = ReactLoadableSSRAddon.prototype;
+
+  _proto.getAssets = function getAssets(assetsChunk) {
+    for (var i = 0; i < assetsChunk.length; i += 1) {
+      var chunk = assetsChunk[i];
+      var id = chunk.id,
+          files = chunk.files,
+          _chunk$siblings = chunk.siblings,
+          siblings = _chunk$siblings === void 0 ? [] : _chunk$siblings,
+          hash = chunk.hash;
+      var keys = this.getChunkOrigin(chunk);
+
+      for (var j = 0; j < keys.length; j += 1) {
+        this.assetsByName.set(keys[j], {
+          id: id,
+          files: files,
+          hash: hash,
+          siblings: siblings
+        });
+      }
+    }
+
+    return this.assetsByName;
+  };
+
+  _proto.getEntrypoints = function getEntrypoints(entrypoints) {
+    var entry = Object.keys(entrypoints);
+
+    for (var i = 0; i < entry.length; i += 1) {
+      this.entrypoints.add(entry[i]);
+    }
+
+    return this.entrypoints;
+  };
+
+  _proto.getChunkOrigin = function getChunkOrigin(_ref) {
+    var id = _ref.id,
+        names = _ref.names,
+        modules = _ref.modules;
+    var origins = new Set();
+
+    if (!WEBPACK_5) {
+      for (var i = 0; i < modules.length; i += 1) {
+        var reasons = modules[i].reasons;
+
+        for (var j = 0; j < reasons.length; j += 1) {
+          var reason = reasons[j];
+          var type = reason.dependency ? reason.dependency.type : null;
+          var userRequest = reason.dependency ? reason.dependency.userRequest : null;
+
+          if (type === 'import()') {
+            origins.add(userRequest);
+          }
+        }
+      }
+    }
+
+    if (origins.size === 0) {
+      return [names[0] || id];
+    }
+
+    if (this.entrypoints.has(names[0])) {
+      origins.add(names[0]);
+    }
+
+    return Array.from(origins);
+  };
+
+  _proto.apply = function apply(compiler) {
+    this.compiler = compiler;
+    compiler.hooks.emit.tapAsync(PLUGIN_NAME, this.handleEmit.bind(this));
+  };
+
+  _proto.getMinimalStatsChunks = function getMinimalStatsChunks(compilationChunks, chunkGraph) {
+    var _this = this;
+
+    var compareId = function compareId(a, b) {
+      if (typeof a !== typeof b) {
+        return typeof a < typeof b ? -1 : 1;
+      }
+
+      if (a < b) return -1;
+      if (a > b) return 1;
+      return 0;
+    };
+
+    return this.ensureArray(compilationChunks).reduce(function (chunks, chunk) {
+      var siblings = new Set();
+
+      if (chunk.groupsIterable) {
+        var chunkGroups = Array.from(chunk.groupsIterable);
+
+        for (var i = 0; i < chunkGroups.length; i += 1) {
+          var group = Array.from(chunkGroups[i].chunks);
+
+          for (var j = 0; j < group.length; j += 1) {
+            var sibling = group[j];
+            if (sibling !== chunk) siblings.add(sibling.id);
+          }
+        }
+      }
+
+      chunk.ids.forEach(function (id) {
+        chunks.push({
+          id: id,
+          names: chunk.name ? [chunk.name] : [],
+          files: _this.ensureArray(chunk.files).slice(),
+          hash: chunk.renderedHash,
+          siblings: Array.from(siblings).sort(compareId),
+          modules: WEBPACK_5 ? chunkGraph.getChunkModules(chunk) : chunk.getModules()
+        });
+      });
+      return chunks;
+    }, []);
+  };
+
+  _proto.handleEmit = function handleEmit(compilation, callback) {
+    this.stats = compilation.getStats().toJson({
+      all: false,
+      entrypoints: true
+    }, true);
+    this.options.publicPath = (compilation.outputOptions ? compilation.outputOptions.publicPath : compilation.options.output.publicPath) || '';
+    this.getEntrypoints(this.stats.entrypoints);
+    this.getAssets(this.getMinimalStatsChunks(compilation.chunks, compilation.chunkGraph));
+    this.processAssets(compilation.assets);
+    this.writeAssetsFile();
+    callback();
+  };
+
+  _proto.processAssets = function processAssets(originAssets) {
+    var _this2 = this;
+
+    var assets = {};
+    var origins = {};
+    var entrypoints = this.entrypoints;
+    this.assetsByName.forEach(function (value, key) {
+      var files = value.files,
+          id = value.id,
+          siblings = value.siblings,
+          hash = value.hash;
+
+      if (!origins[key]) {
+        origins[key] = [];
+      }
+
+      siblings.push(id);
+
+      for (var i = 0; i < siblings.length; i += 1) {
+        var sibling = siblings[i];
+
+        if (!origins[key].includes(sibling)) {
+          origins[key].push(sibling);
+        }
+      }
+
+      for (var _i = 0; _i < files.length; _i += 1) {
+        var file = files[_i];
+        var currentAsset = originAssets[file] || {};
+        var ext = (0, _utils.getFileExtension)(file).replace(/^\.+/, '').toLowerCase();
+
+        if (!assets[id]) {
+          assets[id] = {};
+        }
+
+        if (!assets[id][ext]) {
+          assets[id][ext] = [];
+        }
+
+        if (!(0, _utils.hasEntry)(assets[id][ext], 'file', file)) {
+          var shouldComputeIntegrity = Object.keys(currentAsset) && _this2.options.integrity && !currentAsset[_this2.options.integrityPropertyName];
+
+          if (shouldComputeIntegrity) {
+            currentAsset[_this2.options.integrityPropertyName] = (0, _utils.computeIntegrity)(_this2.options.integrityAlgorithms, currentAsset.source());
+          }
+
+          assets[id][ext].push({
+            file: file,
+            hash: hash,
+            publicPath: _url["default"].resolve(_this2.options.publicPath || '', file),
+            integrity: currentAsset[_this2.options.integrityPropertyName]
+          });
+        }
+      }
+    });
+    this.manifest = {
+      entrypoints: Array.from(entrypoints),
+      origins: origins,
+      assets: assets
+    };
+  };
+
+  _proto.writeAssetsFile = function writeAssetsFile() {
+    var filePath = this.manifestOutputPath;
+
+    var fileDir = _path["default"].dirname(filePath);
+
+    var json = JSON.stringify(this.manifest, null, 2);
+
+    try {
+      if (!_fs["default"].existsSync(fileDir)) {
+        _fs["default"].mkdirSync(fileDir);
+      }
+    } catch (err) {
+      if (err.code !== 'EEXIST') {
+        throw err;
+      }
+    }
+
+    _fs["default"].writeFileSync(filePath, json);
+  };
+
+  _proto.ensureArray = function ensureArray(source) {
+    if (WEBPACK_5) {
+      return Array.from(source);
+    }
+
+    return source;
+  };
+
+  (0, _createClass2["default"])(ReactLoadableSSRAddon, [{
+    key: "isRequestFromDevServer",
+    get: function get() {
+      if (process.argv.some(function (arg) {
+        return arg.includes('webpack-dev-server');
+      })) {
+        return true;
+      }
+
+      var _this$compiler = this.compiler,
+          outputFileSystem = _this$compiler.outputFileSystem,
+          name = _this$compiler.outputFileSystem.constructor.name;
+      return outputFileSystem && name === 'MemoryFileSystem';
+    }
+  }, {
+    key: "manifestOutputPath",
+    get: function get() {
+      var filename = this.options.filename;
+
+      if (_path["default"].isAbsolute(filename)) {
+        return filename;
+      }
+
+      var _this$compiler2 = this.compiler,
+          outputPath = _this$compiler2.outputPath,
+          devServer = _this$compiler2.options.devServer;
+
+      if (this.isRequestFromDevServer && devServer) {
+        var devOutputPath = devServer.outputPath || outputPath || '/';
+
+        if (devOutputPath === '/') {
+          console.warn('Please use an absolute path in options.output when using webpack-dev-server.');
+          devOutputPath = this.compiler.context || process.cwd();
+        }
+
+        return _path["default"].resolve(devOutputPath, filename);
+      }
+
+      return _path["default"].resolve(outputPath, filename);
+    }
+  }]);
+  return ReactLoadableSSRAddon;
+}();
+
+var _default = ReactLoadableSSRAddon;
+exports["default"] = _default;

node_modules/react-loadable-ssr-addon-v5-slorber/lib/ReactLoadableSSRAddon.test.js

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _waitForExpect = _interopRequireDefault(require("wait-for-expect"));
+
+var _webpack = _interopRequireDefault(require("webpack"));
+
+var _webpack2 = _interopRequireDefault(require("../webpack.config"));
+
+var _ReactLoadableSSRAddon = _interopRequireWildcard(require("./ReactLoadableSSRAddon"));
+
+var outputPath;
+var manifestOutputPath;
+
+var runWebpack = function runWebpack(configuration, end, callback) {
+  (0, _webpack["default"])(configuration, function (err, stats) {
+    if (err) {
+      return end(err);
+    }
+
+    if (stats.hasErrors()) {
+      return end(stats.toString());
+    }
+
+    callback();
+    end();
+  });
+};
+
+_ava["default"].beforeEach(function () {
+  var publicPathSanitized = _webpack2["default"].output.publicPath.slice(1, -1);
+
+  outputPath = _path["default"].resolve('./example', publicPathSanitized);
+  manifestOutputPath = _path["default"].resolve(outputPath, _ReactLoadableSSRAddon.defaultOptions.filename);
+});
+
+_ava["default"].cb('outputs with default settings', function (t) {
+  _webpack2["default"].plugins = [new _ReactLoadableSSRAddon["default"]()];
+  runWebpack(_webpack2["default"], t.end, function () {
+    var feedback = _fs["default"].existsSync(manifestOutputPath) ? 'pass' : 'fail';
+    t[feedback]();
+  });
+});
+
+_ava["default"].cb('outputs with custom filename', function (t) {
+  var filename = 'new-assets-manifest.json';
+  _webpack2["default"].plugins = [new _ReactLoadableSSRAddon["default"]({
+    filename: filename
+  })];
+  runWebpack(_webpack2["default"], t.end, function () {
+    var feedback = _fs["default"].existsSync(manifestOutputPath.replace(_ReactLoadableSSRAddon.defaultOptions.filename, filename)) ? 'pass' : 'fail';
+    t[feedback]();
+  });
+});
+
+_ava["default"].cb('outputs with integrity', function (t) {
+  _webpack2["default"].plugins = [new _ReactLoadableSSRAddon["default"]({
+    integrity: true
+  })];
+  runWebpack(_webpack2["default"], t.end, (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee() {
+    var manifest;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            manifest = require("" + manifestOutputPath);
+            _context.next = 3;
+            return (0, _waitForExpect["default"])(function () {
+              Object.keys(manifest.assets).forEach(function (asset) {
+                manifest.assets[asset].js.forEach(function (_ref2) {
+                  var integrity = _ref2.integrity;
+                  t.truthy(integrity);
+                });
+              });
+            });
+
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+});

node_modules/react-loadable-ssr-addon-v5-slorber/lib/getBundles.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _utils = require("./utils");
+
+function getBundles(manifest, chunks) {
+  if (!manifest || !chunks) {
+    return {};
+  }
+
+  var assetsKey = chunks.reduce(function (key, chunk) {
+    if (manifest.origins[chunk]) {
+      key = (0, _utils.unique)([].concat(key, manifest.origins[chunk]));
+    }
+
+    return key;
+  }, []);
+  return assetsKey.reduce(function (bundle, asset) {
+    Object.keys(manifest.assets[asset] || {}).forEach(function (key) {
+      var content = manifest.assets[asset][key];
+
+      if (!bundle[key]) {
+        bundle[key] = [];
+      }
+
+      bundle[key] = (0, _utils.unique)([].concat(bundle[key], content));
+    });
+    return bundle;
+  }, {});
+}
+
+var _default = getBundles;
+exports["default"] = _default;

node_modules/react-loadable-ssr-addon-v5-slorber/lib/getBundles.test.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _getBundles = _interopRequireDefault(require("./getBundles"));
+
+var _webpack = _interopRequireDefault(require("../webpack.config"));
+
+var _reactLoadableSsrAddon = _interopRequireDefault(require("../example/dist/react-loadable-ssr-addon"));
+
+var modules = ['./Header', './multilevel/Multilevel', './SharedMultilevel', '../../SharedMultilevel'];
+var fileType = ['js'];
+var bundles;
+
+_ava["default"].beforeEach(function () {
+  bundles = (0, _getBundles["default"])(_reactLoadableSsrAddon["default"], [].concat(_reactLoadableSsrAddon["default"].entrypoints, modules));
+});
+
+(0, _ava["default"])('returns the correct bundle size and content', function (t) {
+  t["true"](Object.keys(bundles).length === fileType.length);
+  fileType.forEach(function (type) {
+    return !!bundles[type];
+  });
+});
+(0, _ava["default"])('returns the correct bundle infos', function (t) {
+  fileType.forEach(function (type) {
+    bundles[type].forEach(function (bundle) {
+      var expectedPublichPath = _path["default"].resolve(_webpack["default"].output.publicPath, bundle.file);
+
+      t["true"](bundle.file !== '');
+      t["true"](bundle.hash !== '');
+      t["true"](bundle.publicPath === expectedPublichPath);
+    });
+  });
+});
+(0, _ava["default"])('returns nothing when there is no match', function (t) {
+  bundles = (0, _getBundles["default"])(_reactLoadableSsrAddon["default"], ['foo-bar', 'foo', null, undefined]);
+  t["true"](Object.keys(bundles).length === 0);
+});
+(0, _ava["default"])('should work even with null/undefined manifest or modules', function (t) {
+  bundles = (0, _getBundles["default"])(_reactLoadableSsrAddon["default"], null);
+  t["true"](Object.keys(bundles).length === 0);
+  bundles = (0, _getBundles["default"])(null, []);
+  t["true"](Object.keys(bundles).length === 0);
+  bundles = (0, _getBundles["default"])([], null);
+  t["true"](Object.keys(bundles).length === 0);
+});

node_modules/react-loadable-ssr-addon-v5-slorber/lib/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _ReactLoadableSSRAddon = _interopRequireDefault(require("./ReactLoadableSSRAddon"));
+
+var _getBundles = _interopRequireDefault(require("./getBundles"));
+
+module.exports = _ReactLoadableSSRAddon["default"];
+module.exports.getBundles = _getBundles["default"];

node_modules/react-loadable-ssr-addon-v5-slorber/lib/utils/computeIntegrity.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+function computeIntegrity(algorithms, source) {
+  return Array.isArray(algorithms) ? algorithms.map(function (algorithm) {
+    var hash = _crypto["default"].createHash(algorithm).update(source, 'utf8').digest('base64');
+
+    return algorithm + "-" + hash;
+  }).join(' ') : '';
+}
+
+var _default = computeIntegrity;
+exports["default"] = _default;

node_modules/react-loadable-ssr-addon-v5-slorber/lib/utils/getFileExtension.js

@@ -0,0 +1,18 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+function getFileExtension(filename) {
+  if (!filename || typeof filename !== 'string') {
+    return '';
+  }
+
+  var fileExtRegex = /\.\w{2,4}\.(?:map|gz)$|\.\w+$/i;
+  var name = filename.split(/[?#]/)[0];
+  var ext = name.match(fileExtRegex);
+  return ext && ext.length ? ext[0] : '';
+}
+
+var _default = getFileExtension;
+exports["default"] = _default;

node_modules/react-loadable-ssr-addon-v5-slorber/lib/utils/getFileExtension.test.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _getFileExtension = _interopRequireDefault(require("./getFileExtension"));
+
+(0, _ava["default"])('returns the correct file extension', function (t) {
+  var extensions = ['.jpeg', '.js', '.css', '.json', '.xml'];
+  var filePath = 'source/static/images/hello-world';
+  extensions.forEach(function (ext) {
+    t["true"]((0, _getFileExtension["default"])("" + filePath + ext) === ext);
+  });
+});
+(0, _ava["default"])('sanitize file hash', function (t) {
+  var hashes = ['?', '#'];
+  var filePath = 'source/static/images/hello-world.jpeg';
+  hashes.forEach(function (hash) {
+    t["true"]((0, _getFileExtension["default"])("" + filePath + hash + "d587bbd6e38337f5accd") === '.jpeg');
+  });
+});
+(0, _ava["default"])('returns empty string when there is no file extension', function (t) {
+  var filePath = 'source/static/resource';
+  t["true"]((0, _getFileExtension["default"])(filePath) === '');
+});
+(0, _ava["default"])('should work even with null/undefined arg', function (t) {
+  var filePaths = ['', null, undefined];
+  filePaths.forEach(function (path) {
+    t["true"]((0, _getFileExtension["default"])(path) === '');
+  });
+});

node_modules/react-loadable-ssr-addon-v5-slorber/lib/utils/hasEntry.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = hasEntry;
+
+function hasEntry(target, targetKey, searchFor) {
+  if (!target) {
+    return false;
+  }
+
+  for (var i = 0; i < target.length; i += 1) {
+    var file = target[i][targetKey];
+
+    if (file === searchFor) {
+      return true;
+    }
+  }
+
+  return false;
+}

node_modules/react-loadable-ssr-addon-v5-slorber/lib/utils/hasEntry.test.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _hasEntry = _interopRequireDefault(require("./hasEntry"));
+
+var assets = [{
+  file: 'content.chunk.js',
+  hash: 'd41d8cd98f00b204e9800998ecf8427e',
+  publicPath: './',
+  integrity: null
+}, {
+  file: 'header.chunk.js',
+  hash: '699f4bd49870f2b90e1d1596d362efcb',
+  publicPath: './',
+  integrity: null
+}, {
+  file: 'shared-multilevel.chunk.js',
+  hash: 'ab7b8b1c1d5083c17a39ccd2962202e1',
+  publicPath: './',
+  integrity: null
+}];
+(0, _ava["default"])('should flag as has entry', function (t) {
+  var fileName = 'header.chunk.js';
+  t["true"]((0, _hasEntry["default"])(assets, 'file', fileName));
+});
+(0, _ava["default"])('should flag as has no entry', function (t) {
+  var fileName = 'footer.chunk.js';
+  t["false"]((0, _hasEntry["default"])(assets, 'file', fileName));
+});
+(0, _ava["default"])('should work even with null/undefined target', function (t) {
+  var targets = [[], null, undefined];
+  targets.forEach(function (target) {
+    t["false"]((0, _hasEntry["default"])(target, 'file', 'foo.js'));
+  });
+});

node_modules/react-loadable-ssr-addon-v5-slorber/lib/utils/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.hasEntry = exports.unique = exports.getFileExtension = exports.computeIntegrity = void 0;
+
+var _computeIntegrity = _interopRequireDefault(require("./computeIntegrity"));
+
+exports.computeIntegrity = _computeIntegrity["default"];
+
+var _getFileExtension = _interopRequireDefault(require("./getFileExtension"));
+
+exports.getFileExtension = _getFileExtension["default"];
+
+var _unique = _interopRequireDefault(require("./unique"));
+
+exports.unique = _unique["default"];
+
+var _hasEntry = _interopRequireDefault(require("./hasEntry"));
+
+exports.hasEntry = _hasEntry["default"];

node_modules/react-loadable-ssr-addon-v5-slorber/lib/utils/unique.js

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = unique;
+
+function unique(array) {
+  return array.filter(function (elem, pos, arr) {
+    return arr.indexOf(elem) === pos;
+  });
+}

node_modules/react-loadable-ssr-addon-v5-slorber/lib/utils/unique.test.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _unique = _interopRequireDefault(require("./unique"));
+
+(0, _ava["default"])('it filters duplicated entries', function (t) {
+  var duplicated = ['two', 'four'];
+  var raw = ['one', 'two', 'three', 'four'];
+  var filtered = (0, _unique["default"])([].concat(raw, duplicated));
+  duplicated.forEach(function (dup) {
+    t["true"](filtered.filter(function (item) {
+      return item === dup;
+    }).length === 1);
+  });
+});
+(0, _ava["default"])('should work with null/undefined values', function (t) {
+  var falsy = [null, undefined];
+  var raw = ['one', 'two', 'three', 'four'];
+  var filtered = (0, _unique["default"])([].concat(raw, falsy));
+  falsy.forEach(function (value) {
+    t["true"](filtered.includes(value));
+  });
+});