| 1 | "use strict";
|
| 2 |
|
| 3 | Object.defineProperty(exports, "__esModule", {
|
| 4 | value: true
|
| 5 | });
|
| 6 | exports.default = _default;
|
| 7 | function helpers() {
|
| 8 | const data = require("@babel/helpers");
|
| 9 | helpers = function () {
|
| 10 | return data;
|
| 11 | };
|
| 12 | return data;
|
| 13 | }
|
| 14 | function _generator() {
|
| 15 | const data = require("@babel/generator");
|
| 16 | _generator = function () {
|
| 17 | return data;
|
| 18 | };
|
| 19 | return data;
|
| 20 | }
|
| 21 | function _template() {
|
| 22 | const data = require("@babel/template");
|
| 23 | _template = function () {
|
| 24 | return data;
|
| 25 | };
|
| 26 | return data;
|
| 27 | }
|
| 28 | function _t() {
|
| 29 | const data = require("@babel/types");
|
| 30 | _t = function () {
|
| 31 | return data;
|
| 32 | };
|
| 33 | return data;
|
| 34 | }
|
| 35 | var _file = require("../transformation/file/file.js");
|
| 36 | const {
|
| 37 | arrayExpression,
|
| 38 | assignmentExpression,
|
| 39 | binaryExpression,
|
| 40 | blockStatement,
|
| 41 | callExpression,
|
| 42 | cloneNode,
|
| 43 | conditionalExpression,
|
| 44 | exportNamedDeclaration,
|
| 45 | exportSpecifier,
|
| 46 | expressionStatement,
|
| 47 | functionExpression,
|
| 48 | identifier,
|
| 49 | memberExpression,
|
| 50 | objectExpression,
|
| 51 | program,
|
| 52 | stringLiteral,
|
| 53 | unaryExpression,
|
| 54 | variableDeclaration,
|
| 55 | variableDeclarator
|
| 56 | } = _t();
|
| 57 | const buildUmdWrapper = replacements => _template().default.statement`
|
| 58 | (function (root, factory) {
|
| 59 | if (typeof define === "function" && define.amd) {
|
| 60 | define(AMD_ARGUMENTS, factory);
|
| 61 | } else if (typeof exports === "object") {
|
| 62 | factory(COMMON_ARGUMENTS);
|
| 63 | } else {
|
| 64 | factory(BROWSER_ARGUMENTS);
|
| 65 | }
|
| 66 | })(UMD_ROOT, function (FACTORY_PARAMETERS) {
|
| 67 | FACTORY_BODY
|
| 68 | });
|
| 69 | `(replacements);
|
| 70 | function buildGlobal(allowlist) {
|
| 71 | const namespace = identifier("babelHelpers");
|
| 72 | const body = [];
|
| 73 | const container = functionExpression(null, [identifier("global")], blockStatement(body));
|
| 74 | const tree = program([expressionStatement(callExpression(container, [conditionalExpression(binaryExpression("===", unaryExpression("typeof", identifier("global")), stringLiteral("undefined")), identifier("self"), identifier("global"))]))]);
|
| 75 | body.push(variableDeclaration("var", [variableDeclarator(namespace, assignmentExpression("=", memberExpression(identifier("global"), namespace), objectExpression([])))]));
|
| 76 | buildHelpers(body, namespace, allowlist);
|
| 77 | return tree;
|
| 78 | }
|
| 79 | function buildModule(allowlist) {
|
| 80 | const body = [];
|
| 81 | const refs = buildHelpers(body, null, allowlist);
|
| 82 | body.unshift(exportNamedDeclaration(null, Object.keys(refs).map(name => {
|
| 83 | return exportSpecifier(cloneNode(refs[name]), identifier(name));
|
| 84 | })));
|
| 85 | return program(body, [], "module");
|
| 86 | }
|
| 87 | function buildUmd(allowlist) {
|
| 88 | const namespace = identifier("babelHelpers");
|
| 89 | const body = [];
|
| 90 | body.push(variableDeclaration("var", [variableDeclarator(namespace, identifier("global"))]));
|
| 91 | buildHelpers(body, namespace, allowlist);
|
| 92 | return program([buildUmdWrapper({
|
| 93 | FACTORY_PARAMETERS: identifier("global"),
|
| 94 | BROWSER_ARGUMENTS: assignmentExpression("=", memberExpression(identifier("root"), namespace), objectExpression([])),
|
| 95 | COMMON_ARGUMENTS: identifier("exports"),
|
| 96 | AMD_ARGUMENTS: arrayExpression([stringLiteral("exports")]),
|
| 97 | FACTORY_BODY: body,
|
| 98 | UMD_ROOT: identifier("this")
|
| 99 | })]);
|
| 100 | }
|
| 101 | function buildVar(allowlist) {
|
| 102 | const namespace = identifier("babelHelpers");
|
| 103 | const body = [];
|
| 104 | body.push(variableDeclaration("var", [variableDeclarator(namespace, objectExpression([]))]));
|
| 105 | const tree = program(body);
|
| 106 | buildHelpers(body, namespace, allowlist);
|
| 107 | body.push(expressionStatement(namespace));
|
| 108 | return tree;
|
| 109 | }
|
| 110 | function buildHelpers(body, namespace, allowlist) {
|
| 111 | const getHelperReference = name => {
|
| 112 | return namespace ? memberExpression(namespace, identifier(name)) : identifier(`_${name}`);
|
| 113 | };
|
| 114 | const refs = {};
|
| 115 | helpers().list.forEach(function (name) {
|
| 116 | if (allowlist && allowlist.indexOf(name) < 0) return;
|
| 117 | const ref = refs[name] = getHelperReference(name);
|
| 118 | helpers().ensure(name, _file.default);
|
| 119 | const {
|
| 120 | nodes
|
| 121 | } = helpers().get(name, getHelperReference, ref);
|
| 122 | body.push(...nodes);
|
| 123 | });
|
| 124 | return refs;
|
| 125 | }
|
| 126 | function _default(allowlist, outputType = "global") {
|
| 127 | let tree;
|
| 128 | const build = {
|
| 129 | global: buildGlobal,
|
| 130 | module: buildModule,
|
| 131 | umd: buildUmd,
|
| 132 | var: buildVar
|
| 133 | }[outputType];
|
| 134 | if (build) {
|
| 135 | tree = build(allowlist);
|
| 136 | } else {
|
| 137 | throw new Error(`Unsupported output type ${outputType}`);
|
| 138 | }
|
| 139 | return (0, _generator().default)(tree).code;
|
| 140 | }
|
| 141 | 0 && 0;
|
| 142 |
|
| 143 |
|