@tachybase/module-cloud-component 0.23.8

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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeFile;
+function _fs() {
+  const data = require("fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _debug() {
+  const data = require("debug");
+  _debug = function () {
+    return data;
+  };
+  return data;
+}
+function _t() {
+  const data = require("@babel/types");
+  _t = function () {
+    return data;
+  };
+  return data;
+}
+function _convertSourceMap() {
+  const data = require("convert-source-map");
+  _convertSourceMap = function () {
+    return data;
+  };
+  return data;
+}
+var _file = require("./file/file.js");
+var _index = require("../parser/index.js");
+var _cloneDeep = require("./util/clone-deep.js");
+const {
+  file,
+  traverseFast
+} = _t();
+const debug = _debug()("babel:transform:file");
+const INLINE_SOURCEMAP_REGEX = /^[@#]\s+sourceMappingURL=data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,.*$/;
+const EXTERNAL_SOURCEMAP_REGEX = /^[@#][ \t]+sourceMappingURL=([^\s'"`]+)[ \t]*$/;
+function* normalizeFile(pluginPasses, options, code, ast) {
+  code = `${code || ""}`;
+  if (ast) {
+    if (ast.type === "Program") {
+      ast = file(ast, [], []);
+    } else if (ast.type !== "File") {
+      throw new Error("AST root must be a Program or File node");
+    }
+    if (options.cloneInputAst) {
+      ast = (0, _cloneDeep.default)(ast);
+    }
+  } else {
+    ast = yield* (0, _index.default)(pluginPasses, options, code);
+  }
+  let inputMap = null;
+  if (options.inputSourceMap !== false) {
+    if (typeof options.inputSourceMap === "object") {
+      inputMap = _convertSourceMap().fromObject(options.inputSourceMap);
+    }
+    if (!inputMap) {
+      const lastComment = extractComments(INLINE_SOURCEMAP_REGEX, ast);
+      if (lastComment) {
+        try {
+          inputMap = _convertSourceMap().fromComment("//" + lastComment);
+        } catch (err) {
+          {
+            debug("discarding unknown inline input sourcemap");
+          }
+        }
+      }
+    }
+    if (!inputMap) {
+      const lastComment = extractComments(EXTERNAL_SOURCEMAP_REGEX, ast);
+      if (typeof options.filename === "string" && lastComment) {
+        try {
+          const match = EXTERNAL_SOURCEMAP_REGEX.exec(lastComment);
+          const inputMapContent = _fs().readFileSync(_path().resolve(_path().dirname(options.filename), match[1]), "utf8");
+          inputMap = _convertSourceMap().fromJSON(inputMapContent);
+        } catch (err) {
+          debug("discarding unknown file input sourcemap", err);
+        }
+      } else if (lastComment) {
+        debug("discarding un-loadable file input sourcemap");
+      }
+    }
+  }
+  return new _file.default(options, {
+    code,
+    ast: ast,
+    inputMap
+  });
+}
+function extractCommentsFromList(regex, comments, lastComment) {
+  if (comments) {
+    comments = comments.filter(({
+      value
+    }) => {
+      if (regex.test(value)) {
+        lastComment = value;
+        return false;
+      }
+      return true;
+    });
+  }
+  return [comments, lastComment];
+}
+function extractComments(regex, ast) {
+  let lastComment = null;
+  traverseFast(ast, node => {
+    [node.leadingComments, lastComment] = extractCommentsFromList(regex, node.leadingComments, lastComment);
+    [node.innerComments, lastComment] = extractCommentsFromList(regex, node.innerComments, lastComment);
+    [node.trailingComments, lastComment] = extractCommentsFromList(regex, node.trailingComments, lastComment);
+  });
+  return lastComment;
+}
+0 && 0;
+
+//# sourceMappingURL=normalize-file.js.map

package/dist/node_modules/@babel/core/lib/transformation/normalize-opts.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeOptions;
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function normalizeOptions(config) {
+  const {
+    filename,
+    cwd,
+    filenameRelative = typeof filename === "string" ? _path().relative(cwd, filename) : "unknown",
+    sourceType = "module",
+    inputSourceMap,
+    sourceMaps = !!inputSourceMap,
+    sourceRoot = config.options.moduleRoot,
+    sourceFileName = _path().basename(filenameRelative),
+    comments = true,
+    compact = "auto"
+  } = config.options;
+  const opts = config.options;
+  const options = Object.assign({}, opts, {
+    parserOpts: Object.assign({
+      sourceType: _path().extname(filenameRelative) === ".mjs" ? "module" : sourceType,
+      sourceFileName: filename,
+      plugins: []
+    }, opts.parserOpts),
+    generatorOpts: Object.assign({
+      filename,
+      auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
+      auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
+      retainLines: opts.retainLines,
+      comments,
+      shouldPrintComment: opts.shouldPrintComment,
+      compact,
+      minified: opts.minified,
+      sourceMaps,
+      sourceRoot,
+      sourceFileName
+    }, opts.generatorOpts)
+  });
+  for (const plugins of config.passes) {
+    for (const plugin of plugins) {
+      if (plugin.manipulateOptions) {
+        plugin.manipulateOptions(options, options.parserOpts);
+      }
+    }
+  }
+  return options;
+}
+0 && 0;
+
+//# sourceMappingURL=normalize-opts.js.map

package/dist/node_modules/@babel/core/lib/transformation/plugin-pass.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class PluginPass {
+  constructor(file, key, options, isAsync) {
+    this._map = new Map();
+    this.key = void 0;
+    this.file = void 0;
+    this.opts = void 0;
+    this.cwd = void 0;
+    this.filename = void 0;
+    this.isAsync = void 0;
+    this.key = key;
+    this.file = file;
+    this.opts = options || {};
+    this.cwd = file.opts.cwd;
+    this.filename = file.opts.filename;
+    this.isAsync = isAsync;
+  }
+  set(key, val) {
+    this._map.set(key, val);
+  }
+  get(key) {
+    return this._map.get(key);
+  }
+  availableHelper(name, versionRange) {
+    return this.file.availableHelper(name, versionRange);
+  }
+  addHelper(name) {
+    return this.file.addHelper(name);
+  }
+  buildCodeFrameError(node, msg, _Error) {
+    return this.file.buildCodeFrameError(node, msg, _Error);
+  }
+}
+exports.default = PluginPass;
+{
+  PluginPass.prototype.getModuleName = function getModuleName() {
+    return this.file.getModuleName();
+  };
+  PluginPass.prototype.addImport = function addImport() {
+    this.file.addImport();
+  };
+}
+0 && 0;
+
+//# sourceMappingURL=plugin-pass.js.map

package/dist/node_modules/@babel/core/lib/transformation/util/clone-deep.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+function deepClone(value, cache) {
+  if (value !== null) {
+    if (cache.has(value)) return cache.get(value);
+    let cloned;
+    if (Array.isArray(value)) {
+      cloned = new Array(value.length);
+      cache.set(value, cloned);
+      for (let i = 0; i < value.length; i++) {
+        cloned[i] = typeof value[i] !== "object" ? value[i] : deepClone(value[i], cache);
+      }
+    } else {
+      cloned = {};
+      cache.set(value, cloned);
+      const keys = Object.keys(value);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        cloned[key] = typeof value[key] !== "object" ? value[key] : deepClone(value[key], cache);
+      }
+    }
+    return cloned;
+  }
+  return value;
+}
+function _default(value) {
+  if (typeof value !== "object") return value;
+  return deepClone(value, new Map());
+}
+0 && 0;
+
+//# sourceMappingURL=clone-deep.js.map