@utrecht/web-component-library-stencil 1.0.0-alpha.32 → 1.0.0-alpha.320

package/dist/collection/node_modules/@babel/core/lib/transformation/block-hoist-plugin.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadBlockHoistPlugin;
+
+function _traverse() {
+  const data = require("@babel/traverse");
+
+  _traverse = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _plugin = require("../config/plugin");
+
+let LOADED_PLUGIN;
+
+function loadBlockHoistPlugin() {
+  if (!LOADED_PLUGIN) {
+    LOADED_PLUGIN = new _plugin.default(Object.assign({}, blockHoistPlugin, {
+      visitor: _traverse().default.explode(blockHoistPlugin.visitor)
+    }), {});
+  }
+
+  return LOADED_PLUGIN;
+}
+
+function priority(bodyNode) {
+  const priority = bodyNode == null ? void 0 : bodyNode._blockHoist;
+  if (priority == null) return 1;
+  if (priority === true) return 2;
+  return priority;
+}
+
+function stableSort(body) {
+  const buckets = Object.create(null);
+
+  for (let i = 0; i < body.length; i++) {
+    const n = body[i];
+    const p = priority(n);
+    const bucket = buckets[p] || (buckets[p] = []);
+    bucket.push(n);
+  }
+
+  const keys = Object.keys(buckets).map(k => +k).sort((a, b) => b - a);
+  let index = 0;
+
+  for (const key of keys) {
+    const bucket = buckets[key];
+
+    for (const n of bucket) {
+      body[index++] = n;
+    }
+  }
+
+  return body;
+}
+
+const blockHoistPlugin = {
+  name: "internal.blockHoist",
+  visitor: {
+    Block: {
+      exit({
+        node
+      }) {
+        const {
+          body
+        } = node;
+        let max = Math.pow(2, 30) - 1;
+        let hasChange = false;
+
+        for (let i = 0; i < body.length; i++) {
+          const n = body[i];
+          const p = priority(n);
+
+          if (p > max) {
+            hasChange = true;
+            break;
+          }
+
+          max = p;
+        }
+
+        if (!hasChange) return;
+        node.body = stableSort(body.slice());
+      }
+
+    }
+  }
+};
+0 && 0;

package/dist/collection/node_modules/@babel/core/lib/transformation/file/file.js

@@ -0,0 +1,255 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function helpers() {
+  const data = require("@babel/helpers");
+
+  helpers = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _traverse() {
+  const data = require("@babel/traverse");
+
+  _traverse = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _codeFrame() {
+  const data = require("@babel/code-frame");
+
+  _codeFrame = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _t() {
+  const data = require("@babel/types");
+
+  _t = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleTransforms() {
+  const data = require("@babel/helper-module-transforms");
+
+  _helperModuleTransforms = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _semver() {
+  const data = require("semver");
+
+  _semver = function () {
+    return data;
+  };
+
+  return data;
+}
+
+const {
+  cloneNode,
+  interpreterDirective
+} = _t();
+
+const errorVisitor = {
+  enter(path, state) {
+    const loc = path.node.loc;
+
+    if (loc) {
+      state.loc = loc;
+      path.stop();
+    }
+  }
+
+};
+
+class File {
+  constructor(options, {
+    code,
+    ast,
+    inputMap
+  }) {
+    this._map = new Map();
+    this.opts = void 0;
+    this.declarations = {};
+    this.path = void 0;
+    this.ast = void 0;
+    this.scope = void 0;
+    this.metadata = {};
+    this.code = "";
+    this.inputMap = void 0;
+    this.hub = {
+      file: this,
+      getCode: () => this.code,
+      getScope: () => this.scope,
+      addHelper: this.addHelper.bind(this),
+      buildError: this.buildCodeFrameError.bind(this)
+    };
+    this.opts = options;
+    this.code = code;
+    this.ast = ast;
+    this.inputMap = inputMap;
+    this.path = _traverse().NodePath.get({
+      hub: this.hub,
+      parentPath: null,
+      parent: this.ast,
+      container: this.ast,
+      key: "program"
+    }).setContext();
+    this.scope = this.path.scope;
+  }
+
+  get shebang() {
+    const {
+      interpreter
+    } = this.path.node;
+    return interpreter ? interpreter.value : "";
+  }
+
+  set shebang(value) {
+    if (value) {
+      this.path.get("interpreter").replaceWith(interpreterDirective(value));
+    } else {
+      this.path.get("interpreter").remove();
+    }
+  }
+
+  set(key, val) {
+    if (key === "helpersNamespace") {
+      throw new Error("Babel 7.0.0-beta.56 has dropped support for the 'helpersNamespace' utility." + "If you are using @babel/plugin-external-helpers you will need to use a newer " + "version than the one you currently have installed. " + "If you have your own implementation, you'll want to explore using 'helperGenerator' " + "alongside 'file.availableHelper()'.");
+    }
+
+    this._map.set(key, val);
+  }
+
+  get(key) {
+    return this._map.get(key);
+  }
+
+  has(key) {
+    return this._map.has(key);
+  }
+
+  getModuleName() {
+    return (0, _helperModuleTransforms().getModuleName)(this.opts, this.opts);
+  }
+
+  addImport() {
+    throw new Error("This API has been removed. If you're looking for this " + "functionality in Babel 7, you should import the " + "'@babel/helper-module-imports' module and use the functions exposed " + " from that module, such as 'addNamed' or 'addDefault'.");
+  }
+
+  availableHelper(name, versionRange) {
+    let minVersion;
+
+    try {
+      minVersion = helpers().minVersion(name);
+    } catch (err) {
+      if (err.code !== "BABEL_HELPER_UNKNOWN") throw err;
+      return false;
+    }
+
+    if (typeof versionRange !== "string") return true;
+    if (_semver().valid(versionRange)) versionRange = `^${versionRange}`;
+    return !_semver().intersects(`<${minVersion}`, versionRange) && !_semver().intersects(`>=8.0.0`, versionRange);
+  }
+
+  addHelper(name) {
+    const declar = this.declarations[name];
+    if (declar) return cloneNode(declar);
+    const generator = this.get("helperGenerator");
+
+    if (generator) {
+      const res = generator(name);
+      if (res) return res;
+    }
+
+    helpers().ensure(name, File);
+    const uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
+    const dependencies = {};
+
+    for (const dep of helpers().getDependencies(name)) {
+      dependencies[dep] = this.addHelper(dep);
+    }
+
+    const {
+      nodes,
+      globals
+    } = helpers().get(name, dep => dependencies[dep], uid, Object.keys(this.scope.getAllBindings()));
+    globals.forEach(name => {
+      if (this.path.scope.hasBinding(name, true)) {
+        this.path.scope.rename(name);
+      }
+    });
+    nodes.forEach(node => {
+      node._compact = true;
+    });
+    this.path.unshiftContainer("body", nodes);
+    this.path.get("body").forEach(path => {
+      if (nodes.indexOf(path.node) === -1) return;
+      if (path.isVariableDeclaration()) this.scope.registerDeclaration(path);
+    });
+    return uid;
+  }
+
+  addTemplateObject() {
+    throw new Error("This function has been moved into the template literal transform itself.");
+  }
+
+  buildCodeFrameError(node, msg, _Error = SyntaxError) {
+    let loc = node && (node.loc || node._loc);
+
+    if (!loc && node) {
+      const state = {
+        loc: null
+      };
+      (0, _traverse().default)(node, errorVisitor, this.scope, state);
+      loc = state.loc;
+      let txt = "This is an error on an internal node. Probably an internal error.";
+      if (loc) txt += " Location has been estimated.";
+      msg += ` (${txt})`;
+    }
+
+    if (loc) {
+      const {
+        highlightCode = true
+      } = this.opts;
+      msg += "\n" + (0, _codeFrame().codeFrameColumns)(this.code, {
+        start: {
+          line: loc.start.line,
+          column: loc.start.column + 1
+        },
+        end: loc.end && loc.start.line === loc.end.line ? {
+          line: loc.end.line,
+          column: loc.end.column + 1
+        } : undefined
+      }, {
+        highlightCode
+      });
+    }
+
+    return new _Error(msg);
+  }
+
+}
+
+exports.default = File;
+0 && 0;

package/dist/collection/node_modules/@babel/core/lib/transformation/file/generate.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateCode;
+
+function _convertSourceMap() {
+  const data = require("convert-source-map");
+
+  _convertSourceMap = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _generator() {
+  const data = require("@babel/generator");
+
+  _generator = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _mergeMap = require("./merge-map");
+
+function generateCode(pluginPasses, file) {
+  const {
+    opts,
+    ast,
+    code,
+    inputMap
+  } = file;
+  const {
+    generatorOpts
+  } = opts;
+  const results = [];
+
+  for (const plugins of pluginPasses) {
+    for (const plugin of plugins) {
+      const {
+        generatorOverride
+      } = plugin;
+
+      if (generatorOverride) {
+        const result = generatorOverride(ast, generatorOpts, code, _generator().default);
+        if (result !== undefined) results.push(result);
+      }
+    }
+  }
+
+  let result;
+
+  if (results.length === 0) {
+    result = (0, _generator().default)(ast, generatorOpts, code);
+  } else if (results.length === 1) {
+    result = results[0];
+
+    if (typeof result.then === "function") {
+      throw new Error(`You appear to be using an async codegen plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version.`);
+    }
+  } else {
+    throw new Error("More than one plugin attempted to override codegen.");
+  }
+
+  let {
+    code: outputCode,
+    decodedMap: outputMap = result.map
+  } = result;
+
+  if (outputMap) {
+    if (inputMap) {
+      outputMap = (0, _mergeMap.default)(inputMap.toObject(), outputMap, generatorOpts.sourceFileName);
+    } else {
+      outputMap = result.map;
+    }
+  }
+
+  if (opts.sourceMaps === "inline" || opts.sourceMaps === "both") {
+    outputCode += "\n" + _convertSourceMap().fromObject(outputMap).toComment();
+  }
+
+  if (opts.sourceMaps === "inline") {
+    outputMap = null;
+  }
+
+  return {
+    outputCode,
+    outputMap
+  };
+}
+
+0 && 0;

package/dist/collection/node_modules/@babel/core/lib/transformation/file/merge-map.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = mergeSourceMap;
+
+function _remapping() {
+  const data = require("@ampproject/remapping");
+
+  _remapping = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function mergeSourceMap(inputMap, map, sourceFileName) {
+  const source = sourceFileName.replace(/\\/g, "/");
+  let found = false;
+
+  const result = _remapping()(rootless(map), (s, ctx) => {
+    if (s === source && !found) {
+      found = true;
+      ctx.source = "";
+      return rootless(inputMap);
+    }
+
+    return null;
+  });
+
+  if (typeof inputMap.sourceRoot === "string") {
+    result.sourceRoot = inputMap.sourceRoot;
+  }
+
+  return Object.assign({}, result);
+}
+
+function rootless(map) {
+  return Object.assign({}, map, {
+    sourceRoot: null
+  });
+}
+
+0 && 0;

package/dist/collection/node_modules/@babel/core/lib/transformation/index.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.run = run;
+
+function _traverse() {
+  const data = require("@babel/traverse");
+
+  _traverse = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _pluginPass = require("./plugin-pass");
+
+var _blockHoistPlugin = require("./block-hoist-plugin");
+
+var _normalizeOpts = require("./normalize-opts");
+
+var _normalizeFile = require("./normalize-file");
+
+var _generate = require("./file/generate");
+
+var _deepArray = require("../config/helpers/deep-array");
+
+function* run(config, code, ast) {
+  const file = yield* (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast);
+  const opts = file.opts;
+
+  try {
+    yield* transformFile(file, config.passes);
+  } catch (e) {
+    var _opts$filename;
+
+    e.message = `${(_opts$filename = opts.filename) != null ? _opts$filename : "unknown"}: ${e.message}`;
+
+    if (!e.code) {
+      e.code = "BABEL_TRANSFORM_ERROR";
+    }
+
+    throw e;
+  }
+
+  let outputCode, outputMap;
+
+  try {
+    if (opts.code !== false) {
+      ({
+        outputCode,
+        outputMap
+      } = (0, _generate.default)(config.passes, file));
+    }
+  } catch (e) {
+    var _opts$filename2;
+
+    e.message = `${(_opts$filename2 = opts.filename) != null ? _opts$filename2 : "unknown"}: ${e.message}`;
+
+    if (!e.code) {
+      e.code = "BABEL_GENERATE_ERROR";
+    }
+
+    throw e;
+  }
+
+  return {
+    metadata: file.metadata,
+    options: opts,
+    ast: opts.ast === true ? file.ast : null,
+    code: outputCode === undefined ? null : outputCode,
+    map: outputMap === undefined ? null : outputMap,
+    sourceType: file.ast.program.sourceType,
+    externalDependencies: (0, _deepArray.flattenToSet)(config.externalDependencies)
+  };
+}
+
+function* transformFile(file, pluginPasses) {
+  for (const pluginPairs of pluginPasses) {
+    const passPairs = [];
+    const passes = [];
+    const visitors = [];
+
+    for (const plugin of pluginPairs.concat([(0, _blockHoistPlugin.default)()])) {
+      const pass = new _pluginPass.default(file, plugin.key, plugin.options);
+      passPairs.push([plugin, pass]);
+      passes.push(pass);
+      visitors.push(plugin.visitor);
+    }
+
+    for (const [plugin, pass] of passPairs) {
+      const fn = plugin.pre;
+
+      if (fn) {
+        const result = fn.call(pass, file);
+        yield* [];
+
+        if (isThenable(result)) {
+          throw new Error(`You appear to be using an plugin with an async .pre, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+        }
+      }
+    }
+
+    const visitor = _traverse().default.visitors.merge(visitors, passes, file.opts.wrapPluginVisitorMethod);
+
+    (0, _traverse().default)(file.ast, visitor, file.scope);
+
+    for (const [plugin, pass] of passPairs) {
+      const fn = plugin.post;
+
+      if (fn) {
+        const result = fn.call(pass, file);
+        yield* [];
+
+        if (isThenable(result)) {
+          throw new Error(`You appear to be using an plugin with an async .post, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+        }
+      }
+    }
+  }
+}
+
+function isThenable(val) {
+  return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
+}
+
+0 && 0;