@utrecht/web-component-library-stencil 1.0.0-alpha.319 → 1.0.0-alpha.321

package/dist/collection/node_modules/@babel/core/lib/config/validation/option-assertions.js

@@ -0,0 +1,354 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.access = access;
+exports.assertArray = assertArray;
+exports.assertAssumptions = assertAssumptions;
+exports.assertBabelrcSearch = assertBabelrcSearch;
+exports.assertBoolean = assertBoolean;
+exports.assertCallerMetadata = assertCallerMetadata;
+exports.assertCompact = assertCompact;
+exports.assertConfigApplicableTest = assertConfigApplicableTest;
+exports.assertConfigFileSearch = assertConfigFileSearch;
+exports.assertFunction = assertFunction;
+exports.assertIgnoreList = assertIgnoreList;
+exports.assertInputSourceMap = assertInputSourceMap;
+exports.assertObject = assertObject;
+exports.assertPluginList = assertPluginList;
+exports.assertRootMode = assertRootMode;
+exports.assertSourceMaps = assertSourceMaps;
+exports.assertSourceType = assertSourceType;
+exports.assertString = assertString;
+exports.assertTargets = assertTargets;
+exports.msg = msg;
+
+function _helperCompilationTargets() {
+  const data = require("@babel/helper-compilation-targets");
+
+  _helperCompilationTargets = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _options = require("./options");
+
+function msg(loc) {
+  switch (loc.type) {
+    case "root":
+      return ``;
+
+    case "env":
+      return `${msg(loc.parent)}.env["${loc.name}"]`;
+
+    case "overrides":
+      return `${msg(loc.parent)}.overrides[${loc.index}]`;
+
+    case "option":
+      return `${msg(loc.parent)}.${loc.name}`;
+
+    case "access":
+      return `${msg(loc.parent)}[${JSON.stringify(loc.name)}]`;
+
+    default:
+      throw new Error(`Assertion failure: Unknown type ${loc.type}`);
+  }
+}
+
+function access(loc, name) {
+  return {
+    type: "access",
+    name,
+    parent: loc
+  };
+}
+
+function assertRootMode(loc, value) {
+  if (value !== undefined && value !== "root" && value !== "upward" && value !== "upward-optional") {
+    throw new Error(`${msg(loc)} must be a "root", "upward", "upward-optional" or undefined`);
+  }
+
+  return value;
+}
+
+function assertSourceMaps(loc, value) {
+  if (value !== undefined && typeof value !== "boolean" && value !== "inline" && value !== "both") {
+    throw new Error(`${msg(loc)} must be a boolean, "inline", "both", or undefined`);
+  }
+
+  return value;
+}
+
+function assertCompact(loc, value) {
+  if (value !== undefined && typeof value !== "boolean" && value !== "auto") {
+    throw new Error(`${msg(loc)} must be a boolean, "auto", or undefined`);
+  }
+
+  return value;
+}
+
+function assertSourceType(loc, value) {
+  if (value !== undefined && value !== "module" && value !== "script" && value !== "unambiguous") {
+    throw new Error(`${msg(loc)} must be "module", "script", "unambiguous", or undefined`);
+  }
+
+  return value;
+}
+
+function assertCallerMetadata(loc, value) {
+  const obj = assertObject(loc, value);
+
+  if (obj) {
+    if (typeof obj.name !== "string") {
+      throw new Error(`${msg(loc)} set but does not contain "name" property string`);
+    }
+
+    for (const prop of Object.keys(obj)) {
+      const propLoc = access(loc, prop);
+      const value = obj[prop];
+
+      if (value != null && typeof value !== "boolean" && typeof value !== "string" && typeof value !== "number") {
+        throw new Error(`${msg(propLoc)} must be null, undefined, a boolean, a string, or a number.`);
+      }
+    }
+  }
+
+  return value;
+}
+
+function assertInputSourceMap(loc, value) {
+  if (value !== undefined && typeof value !== "boolean" && (typeof value !== "object" || !value)) {
+    throw new Error(`${msg(loc)} must be a boolean, object, or undefined`);
+  }
+
+  return value;
+}
+
+function assertString(loc, value) {
+  if (value !== undefined && typeof value !== "string") {
+    throw new Error(`${msg(loc)} must be a string, or undefined`);
+  }
+
+  return value;
+}
+
+function assertFunction(loc, value) {
+  if (value !== undefined && typeof value !== "function") {
+    throw new Error(`${msg(loc)} must be a function, or undefined`);
+  }
+
+  return value;
+}
+
+function assertBoolean(loc, value) {
+  if (value !== undefined && typeof value !== "boolean") {
+    throw new Error(`${msg(loc)} must be a boolean, or undefined`);
+  }
+
+  return value;
+}
+
+function assertObject(loc, value) {
+  if (value !== undefined && (typeof value !== "object" || Array.isArray(value) || !value)) {
+    throw new Error(`${msg(loc)} must be an object, or undefined`);
+  }
+
+  return value;
+}
+
+function assertArray(loc, value) {
+  if (value != null && !Array.isArray(value)) {
+    throw new Error(`${msg(loc)} must be an array, or undefined`);
+  }
+
+  return value;
+}
+
+function assertIgnoreList(loc, value) {
+  const arr = assertArray(loc, value);
+
+  if (arr) {
+    arr.forEach((item, i) => assertIgnoreItem(access(loc, i), item));
+  }
+
+  return arr;
+}
+
+function assertIgnoreItem(loc, value) {
+  if (typeof value !== "string" && typeof value !== "function" && !(value instanceof RegExp)) {
+    throw new Error(`${msg(loc)} must be an array of string/Function/RegExp values, or undefined`);
+  }
+
+  return value;
+}
+
+function assertConfigApplicableTest(loc, value) {
+  if (value === undefined) return value;
+
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => {
+      if (!checkValidTest(item)) {
+        throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
+      }
+    });
+  } else if (!checkValidTest(value)) {
+    throw new Error(`${msg(loc)} must be a string/Function/RegExp, or an array of those`);
+  }
+
+  return value;
+}
+
+function checkValidTest(value) {
+  return typeof value === "string" || typeof value === "function" || value instanceof RegExp;
+}
+
+function assertConfigFileSearch(loc, value) {
+  if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") {
+    throw new Error(`${msg(loc)} must be a undefined, a boolean, a string, ` + `got ${JSON.stringify(value)}`);
+  }
+
+  return value;
+}
+
+function assertBabelrcSearch(loc, value) {
+  if (value === undefined || typeof value === "boolean") return value;
+
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => {
+      if (!checkValidTest(item)) {
+        throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
+      }
+    });
+  } else if (!checkValidTest(value)) {
+    throw new Error(`${msg(loc)} must be a undefined, a boolean, a string/Function/RegExp ` + `or an array of those, got ${JSON.stringify(value)}`);
+  }
+
+  return value;
+}
+
+function assertPluginList(loc, value) {
+  const arr = assertArray(loc, value);
+
+  if (arr) {
+    arr.forEach((item, i) => assertPluginItem(access(loc, i), item));
+  }
+
+  return arr;
+}
+
+function assertPluginItem(loc, value) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new Error(`${msg(loc)} must include an object`);
+    }
+
+    if (value.length > 3) {
+      throw new Error(`${msg(loc)} may only be a two-tuple or three-tuple`);
+    }
+
+    assertPluginTarget(access(loc, 0), value[0]);
+
+    if (value.length > 1) {
+      const opts = value[1];
+
+      if (opts !== undefined && opts !== false && (typeof opts !== "object" || Array.isArray(opts) || opts === null)) {
+        throw new Error(`${msg(access(loc, 1))} must be an object, false, or undefined`);
+      }
+    }
+
+    if (value.length === 3) {
+      const name = value[2];
+
+      if (name !== undefined && typeof name !== "string") {
+        throw new Error(`${msg(access(loc, 2))} must be a string, or undefined`);
+      }
+    }
+  } else {
+    assertPluginTarget(loc, value);
+  }
+
+  return value;
+}
+
+function assertPluginTarget(loc, value) {
+  if ((typeof value !== "object" || !value) && typeof value !== "string" && typeof value !== "function") {
+    throw new Error(`${msg(loc)} must be a string, object, function`);
+  }
+
+  return value;
+}
+
+function assertTargets(loc, value) {
+  if ((0, _helperCompilationTargets().isBrowsersQueryValid)(value)) return value;
+
+  if (typeof value !== "object" || !value || Array.isArray(value)) {
+    throw new Error(`${msg(loc)} must be a string, an array of strings or an object`);
+  }
+
+  const browsersLoc = access(loc, "browsers");
+  const esmodulesLoc = access(loc, "esmodules");
+  assertBrowsersList(browsersLoc, value.browsers);
+  assertBoolean(esmodulesLoc, value.esmodules);
+
+  for (const key of Object.keys(value)) {
+    const val = value[key];
+    const subLoc = access(loc, key);
+    if (key === "esmodules") assertBoolean(subLoc, val);else if (key === "browsers") assertBrowsersList(subLoc, val);else if (!Object.hasOwnProperty.call(_helperCompilationTargets().TargetNames, key)) {
+      const validTargets = Object.keys(_helperCompilationTargets().TargetNames).join(", ");
+      throw new Error(`${msg(subLoc)} is not a valid target. Supported targets are ${validTargets}`);
+    } else assertBrowserVersion(subLoc, val);
+  }
+
+  return value;
+}
+
+function assertBrowsersList(loc, value) {
+  if (value !== undefined && !(0, _helperCompilationTargets().isBrowsersQueryValid)(value)) {
+    throw new Error(`${msg(loc)} must be undefined, a string or an array of strings`);
+  }
+}
+
+function assertBrowserVersion(loc, value) {
+  if (typeof value === "number" && Math.round(value) === value) return;
+  if (typeof value === "string") return;
+  throw new Error(`${msg(loc)} must be a string or an integer number`);
+}
+
+function assertAssumptions(loc, value) {
+  if (value === undefined) return;
+
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`${msg(loc)} must be an object or undefined.`);
+  }
+
+  let root = loc;
+
+  do {
+    root = root.parent;
+  } while (root.type !== "root");
+
+  const inPreset = root.source === "preset";
+
+  for (const name of Object.keys(value)) {
+    const subLoc = access(loc, name);
+
+    if (!_options.assumptionsNames.has(name)) {
+      throw new Error(`${msg(subLoc)} is not a supported assumption.`);
+    }
+
+    if (typeof value[name] !== "boolean") {
+      throw new Error(`${msg(subLoc)} must be a boolean.`);
+    }
+
+    if (inPreset && value[name] === false) {
+      throw new Error(`${msg(subLoc)} cannot be set to 'false' inside presets.`);
+    }
+  }
+
+  return value;
+}
+
+0 && 0;

package/dist/collection/node_modules/@babel/core/lib/config/validation/options.js

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assumptionsNames = void 0;
+exports.checkNoUnwrappedItemOptionPairs = checkNoUnwrappedItemOptionPairs;
+exports.validate = validate;
+
+var _plugin = require("../plugin");
+
+var _removed = require("./removed");
+
+var _optionAssertions = require("./option-assertions");
+
+const ROOT_VALIDATORS = {
+  cwd: _optionAssertions.assertString,
+  root: _optionAssertions.assertString,
+  rootMode: _optionAssertions.assertRootMode,
+  configFile: _optionAssertions.assertConfigFileSearch,
+  caller: _optionAssertions.assertCallerMetadata,
+  filename: _optionAssertions.assertString,
+  filenameRelative: _optionAssertions.assertString,
+  code: _optionAssertions.assertBoolean,
+  ast: _optionAssertions.assertBoolean,
+  cloneInputAst: _optionAssertions.assertBoolean,
+  envName: _optionAssertions.assertString
+};
+const BABELRC_VALIDATORS = {
+  babelrc: _optionAssertions.assertBoolean,
+  babelrcRoots: _optionAssertions.assertBabelrcSearch
+};
+const NONPRESET_VALIDATORS = {
+  extends: _optionAssertions.assertString,
+  ignore: _optionAssertions.assertIgnoreList,
+  only: _optionAssertions.assertIgnoreList,
+  targets: _optionAssertions.assertTargets,
+  browserslistConfigFile: _optionAssertions.assertConfigFileSearch,
+  browserslistEnv: _optionAssertions.assertString
+};
+const COMMON_VALIDATORS = {
+  inputSourceMap: _optionAssertions.assertInputSourceMap,
+  presets: _optionAssertions.assertPluginList,
+  plugins: _optionAssertions.assertPluginList,
+  passPerPreset: _optionAssertions.assertBoolean,
+  assumptions: _optionAssertions.assertAssumptions,
+  env: assertEnvSet,
+  overrides: assertOverridesList,
+  test: _optionAssertions.assertConfigApplicableTest,
+  include: _optionAssertions.assertConfigApplicableTest,
+  exclude: _optionAssertions.assertConfigApplicableTest,
+  retainLines: _optionAssertions.assertBoolean,
+  comments: _optionAssertions.assertBoolean,
+  shouldPrintComment: _optionAssertions.assertFunction,
+  compact: _optionAssertions.assertCompact,
+  minified: _optionAssertions.assertBoolean,
+  auxiliaryCommentBefore: _optionAssertions.assertString,
+  auxiliaryCommentAfter: _optionAssertions.assertString,
+  sourceType: _optionAssertions.assertSourceType,
+  wrapPluginVisitorMethod: _optionAssertions.assertFunction,
+  highlightCode: _optionAssertions.assertBoolean,
+  sourceMaps: _optionAssertions.assertSourceMaps,
+  sourceMap: _optionAssertions.assertSourceMaps,
+  sourceFileName: _optionAssertions.assertString,
+  sourceRoot: _optionAssertions.assertString,
+  parserOpts: _optionAssertions.assertObject,
+  generatorOpts: _optionAssertions.assertObject
+};
+{
+  Object.assign(COMMON_VALIDATORS, {
+    getModuleId: _optionAssertions.assertFunction,
+    moduleRoot: _optionAssertions.assertString,
+    moduleIds: _optionAssertions.assertBoolean,
+    moduleId: _optionAssertions.assertString
+  });
+}
+const knownAssumptions = ["arrayLikeIsIterable", "constantReexports", "constantSuper", "enumerableModuleMeta", "ignoreFunctionLength", "ignoreToPrimitiveHint", "iterableIsArray", "mutableTemplateObject", "noClassCalls", "noDocumentAll", "noIncompleteNsImportDetection", "noNewArrows", "objectRestNoSymbols", "privateFieldsAsProperties", "pureGetters", "setClassMethods", "setComputedProperties", "setPublicClassFields", "setSpreadProperties", "skipForOfIteratorClosing", "superIsCallableConstructor"];
+const assumptionsNames = new Set(knownAssumptions);
+exports.assumptionsNames = assumptionsNames;
+
+function getSource(loc) {
+  return loc.type === "root" ? loc.source : getSource(loc.parent);
+}
+
+function validate(type, opts) {
+  return validateNested({
+    type: "root",
+    source: type
+  }, opts);
+}
+
+function validateNested(loc, opts) {
+  const type = getSource(loc);
+  assertNoDuplicateSourcemap(opts);
+  Object.keys(opts).forEach(key => {
+    const optLoc = {
+      type: "option",
+      name: key,
+      parent: loc
+    };
+
+    if (type === "preset" && NONPRESET_VALIDATORS[key]) {
+      throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in preset options`);
+    }
+
+    if (type !== "arguments" && ROOT_VALIDATORS[key]) {
+      throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options`);
+    }
+
+    if (type !== "arguments" && type !== "configfile" && BABELRC_VALIDATORS[key]) {
+      if (type === "babelrcfile" || type === "extendsfile") {
+        throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in .babelrc or "extends"ed files, only in root programmatic options, ` + `or babel.config.js/config file options`);
+      }
+
+      throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options, or babel.config.js/config file options`);
+    }
+
+    const validator = COMMON_VALIDATORS[key] || NONPRESET_VALIDATORS[key] || BABELRC_VALIDATORS[key] || ROOT_VALIDATORS[key] || throwUnknownError;
+    validator(optLoc, opts[key]);
+  });
+  return opts;
+}
+
+function throwUnknownError(loc) {
+  const key = loc.name;
+
+  if (_removed.default[key]) {
+    const {
+      message,
+      version = 5
+    } = _removed.default[key];
+    throw new Error(`Using removed Babel ${version} option: ${(0, _optionAssertions.msg)(loc)} - ${message}`);
+  } else {
+    const unknownOptErr = new Error(`Unknown option: ${(0, _optionAssertions.msg)(loc)}. Check out https://babeljs.io/docs/en/babel-core/#options for more information about options.`);
+    unknownOptErr.code = "BABEL_UNKNOWN_OPTION";
+    throw unknownOptErr;
+  }
+}
+
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function assertNoDuplicateSourcemap(opts) {
+  if (has(opts, "sourceMap") && has(opts, "sourceMaps")) {
+    throw new Error(".sourceMap is an alias for .sourceMaps, cannot use both");
+  }
+}
+
+function assertEnvSet(loc, value) {
+  if (loc.parent.type === "env") {
+    throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside of another .env block`);
+  }
+
+  const parent = loc.parent;
+  const obj = (0, _optionAssertions.assertObject)(loc, value);
+
+  if (obj) {
+    for (const envName of Object.keys(obj)) {
+      const env = (0, _optionAssertions.assertObject)((0, _optionAssertions.access)(loc, envName), obj[envName]);
+      if (!env) continue;
+      const envLoc = {
+        type: "env",
+        name: envName,
+        parent
+      };
+      validateNested(envLoc, env);
+    }
+  }
+
+  return obj;
+}
+
+function assertOverridesList(loc, value) {
+  if (loc.parent.type === "env") {
+    throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .env block`);
+  }
+
+  if (loc.parent.type === "overrides") {
+    throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .overrides block`);
+  }
+
+  const parent = loc.parent;
+  const arr = (0, _optionAssertions.assertArray)(loc, value);
+
+  if (arr) {
+    for (const [index, item] of arr.entries()) {
+      const objLoc = (0, _optionAssertions.access)(loc, index);
+      const env = (0, _optionAssertions.assertObject)(objLoc, item);
+      if (!env) throw new Error(`${(0, _optionAssertions.msg)(objLoc)} must be an object`);
+      const overridesLoc = {
+        type: "overrides",
+        index,
+        parent
+      };
+      validateNested(overridesLoc, env);
+    }
+  }
+
+  return arr;
+}
+
+function checkNoUnwrappedItemOptionPairs(items, index, type, e) {
+  if (index === 0) return;
+  const lastItem = items[index - 1];
+  const thisItem = items[index];
+
+  if (lastItem.file && lastItem.options === undefined && typeof thisItem.value === "object") {
+    e.message += `\n- Maybe you meant to use\n` + `"${type}s": [\n  ["${lastItem.file.request}", ${JSON.stringify(thisItem.value, undefined, 2)}]\n]\n` + `To be a valid ${type}, its name and options should be wrapped in a pair of brackets`;
+  }
+}
+
+0 && 0;

package/dist/collection/node_modules/@babel/core/lib/config/validation/plugins.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validatePluginObject = validatePluginObject;
+
+var _optionAssertions = require("./option-assertions");
+
+const VALIDATORS = {
+  name: _optionAssertions.assertString,
+  manipulateOptions: _optionAssertions.assertFunction,
+  pre: _optionAssertions.assertFunction,
+  post: _optionAssertions.assertFunction,
+  inherits: _optionAssertions.assertFunction,
+  visitor: assertVisitorMap,
+  parserOverride: _optionAssertions.assertFunction,
+  generatorOverride: _optionAssertions.assertFunction
+};
+
+function assertVisitorMap(loc, value) {
+  const obj = (0, _optionAssertions.assertObject)(loc, value);
+
+  if (obj) {
+    Object.keys(obj).forEach(prop => assertVisitorHandler(prop, obj[prop]));
+
+    if (obj.enter || obj.exit) {
+      throw new Error(`${(0, _optionAssertions.msg)(loc)} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`);
+    }
+  }
+
+  return obj;
+}
+
+function assertVisitorHandler(key, value) {
+  if (value && typeof value === "object") {
+    Object.keys(value).forEach(handler => {
+      if (handler !== "enter" && handler !== "exit") {
+        throw new Error(`.visitor["${key}"] may only have .enter and/or .exit handlers.`);
+      }
+    });
+  } else if (typeof value !== "function") {
+    throw new Error(`.visitor["${key}"] must be a function`);
+  }
+
+  return value;
+}
+
+function validatePluginObject(obj) {
+  const rootPath = {
+    type: "root",
+    source: "plugin"
+  };
+  Object.keys(obj).forEach(key => {
+    const validator = VALIDATORS[key];
+
+    if (validator) {
+      const optLoc = {
+        type: "option",
+        name: key,
+        parent: rootPath
+      };
+      validator(optLoc, obj[key]);
+    } else {
+      const invalidPluginPropertyError = new Error(`.${key} is not a valid Plugin property`);
+      invalidPluginPropertyError.code = "BABEL_UNKNOWN_PLUGIN_PROPERTY";
+      throw invalidPluginPropertyError;
+    }
+  });
+  return obj;
+}
+
+0 && 0;

package/dist/collection/node_modules/@babel/core/lib/config/validation/removed.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  auxiliaryComment: {
+    message: "Use `auxiliaryCommentBefore` or `auxiliaryCommentAfter`"
+  },
+  blacklist: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  breakConfig: {
+    message: "This is not a necessary option in Babel 6"
+  },
+  experimental: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  externalHelpers: {
+    message: "Use the `external-helpers` plugin instead. " + "Check out http://babeljs.io/docs/plugins/external-helpers/"
+  },
+  extra: {
+    message: ""
+  },
+  jsxPragma: {
+    message: "use the `pragma` option in the `react-jsx` plugin. " + "Check out http://babeljs.io/docs/plugins/transform-react-jsx/"
+  },
+  loose: {
+    message: "Specify the `loose` option for the relevant plugin you are using " + "or use a preset that sets the option."
+  },
+  metadataUsedHelpers: {
+    message: "Not required anymore as this is enabled by default"
+  },
+  modules: {
+    message: "Use the corresponding module transform plugin in the `plugins` option. " + "Check out http://babeljs.io/docs/plugins/#modules"
+  },
+  nonStandard: {
+    message: "Use the `react-jsx` and `flow-strip-types` plugins to support JSX and Flow. " + "Also check out the react preset http://babeljs.io/docs/plugins/preset-react/"
+  },
+  optional: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  sourceMapName: {
+    message: "The `sourceMapName` option has been removed because it makes more sense for the " + "tooling that calls Babel to assign `map.file` themselves."
+  },
+  stage: {
+    message: "Check out the corresponding stage-x presets http://babeljs.io/docs/plugins/#presets"
+  },
+  whitelist: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  resolveModuleSource: {
+    version: 6,
+    message: "Use `babel-plugin-module-resolver@3`'s 'resolvePath' options"
+  },
+  metadata: {
+    version: 6,
+    message: "Generated plugin metadata is always included in the output result"
+  },
+  sourceMapTarget: {
+    version: 6,
+    message: "The `sourceMapTarget` option has been removed because it makes more sense for the tooling " + "that calls Babel to assign `map.file` themselves."
+  }
+};
+exports.default = _default;
+0 && 0;