diff options
Diffstat (limited to 'node_modules/@babel/helper-module-imports/lib')
4 files changed, 511 insertions, 0 deletions
diff --git a/node_modules/@babel/helper-module-imports/lib/import-builder.js b/node_modules/@babel/helper-module-imports/lib/import-builder.js new file mode 100644 index 0000000..8a1800e --- /dev/null +++ b/node_modules/@babel/helper-module-imports/lib/import-builder.js @@ -0,0 +1,162 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _assert = require("assert"); + +var _t = require("@babel/types"); + +const { + callExpression, + cloneNode, + expressionStatement, + identifier, + importDeclaration, + importDefaultSpecifier, + importNamespaceSpecifier, + importSpecifier, + memberExpression, + stringLiteral, + variableDeclaration, + variableDeclarator +} = _t; + +class ImportBuilder { + constructor(importedSource, scope, hub) { + this._statements = []; + this._resultName = null; + this._scope = null; + this._hub = null; + this._importedSource = void 0; + this._scope = scope; + this._hub = hub; + this._importedSource = importedSource; + } + + done() { + return { + statements: this._statements, + resultName: this._resultName + }; + } + + import() { + this._statements.push(importDeclaration([], stringLiteral(this._importedSource))); + + return this; + } + + require() { + this._statements.push(expressionStatement(callExpression(identifier("require"), [stringLiteral(this._importedSource)]))); + + return this; + } + + namespace(name = "namespace") { + const local = this._scope.generateUidIdentifier(name); + + const statement = this._statements[this._statements.length - 1]; + + _assert(statement.type === "ImportDeclaration"); + + _assert(statement.specifiers.length === 0); + + statement.specifiers = [importNamespaceSpecifier(local)]; + this._resultName = cloneNode(local); + return this; + } + + default(name) { + name = this._scope.generateUidIdentifier(name); + const statement = this._statements[this._statements.length - 1]; + + _assert(statement.type === "ImportDeclaration"); + + _assert(statement.specifiers.length === 0); + + statement.specifiers = [importDefaultSpecifier(name)]; + this._resultName = cloneNode(name); + return this; + } + + named(name, importName) { + if (importName === "default") return this.default(name); + name = this._scope.generateUidIdentifier(name); + const statement = this._statements[this._statements.length - 1]; + + _assert(statement.type === "ImportDeclaration"); + + _assert(statement.specifiers.length === 0); + + statement.specifiers = [importSpecifier(name, identifier(importName))]; + this._resultName = cloneNode(name); + return this; + } + + var(name) { + name = this._scope.generateUidIdentifier(name); + let statement = this._statements[this._statements.length - 1]; + + if (statement.type !== "ExpressionStatement") { + _assert(this._resultName); + + statement = expressionStatement(this._resultName); + + this._statements.push(statement); + } + + this._statements[this._statements.length - 1] = variableDeclaration("var", [variableDeclarator(name, statement.expression)]); + this._resultName = cloneNode(name); + return this; + } + + defaultInterop() { + return this._interop(this._hub.addHelper("interopRequireDefault")); + } + + wildcardInterop() { + return this._interop(this._hub.addHelper("interopRequireWildcard")); + } + + _interop(callee) { + const statement = this._statements[this._statements.length - 1]; + + if (statement.type === "ExpressionStatement") { + statement.expression = callExpression(callee, [statement.expression]); + } else if (statement.type === "VariableDeclaration") { + _assert(statement.declarations.length === 1); + + statement.declarations[0].init = callExpression(callee, [statement.declarations[0].init]); + } else { + _assert.fail("Unexpected type."); + } + + return this; + } + + prop(name) { + const statement = this._statements[this._statements.length - 1]; + + if (statement.type === "ExpressionStatement") { + statement.expression = memberExpression(statement.expression, identifier(name)); + } else if (statement.type === "VariableDeclaration") { + _assert(statement.declarations.length === 1); + + statement.declarations[0].init = memberExpression(statement.declarations[0].init, identifier(name)); + } else { + _assert.fail("Unexpected type:" + statement.type); + } + + return this; + } + + read(name) { + this._resultName = memberExpression(this._resultName, identifier(name)); + } + +} + +exports.default = ImportBuilder;
\ No newline at end of file diff --git a/node_modules/@babel/helper-module-imports/lib/import-injector.js b/node_modules/@babel/helper-module-imports/lib/import-injector.js new file mode 100644 index 0000000..adb9627 --- /dev/null +++ b/node_modules/@babel/helper-module-imports/lib/import-injector.js @@ -0,0 +1,290 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _assert = require("assert"); + +var _t = require("@babel/types"); + +var _importBuilder = require("./import-builder"); + +var _isModule = require("./is-module"); + +const { + numericLiteral, + sequenceExpression +} = _t; + +class ImportInjector { + constructor(path, importedSource, opts) { + this._defaultOpts = { + importedSource: null, + importedType: "commonjs", + importedInterop: "babel", + importingInterop: "babel", + ensureLiveReference: false, + ensureNoContext: false, + importPosition: "before" + }; + const programPath = path.find(p => p.isProgram()); + this._programPath = programPath; + this._programScope = programPath.scope; + this._hub = programPath.hub; + this._defaultOpts = this._applyDefaults(importedSource, opts, true); + } + + addDefault(importedSourceIn, opts) { + return this.addNamed("default", importedSourceIn, opts); + } + + addNamed(importName, importedSourceIn, opts) { + _assert(typeof importName === "string"); + + return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName); + } + + addNamespace(importedSourceIn, opts) { + return this._generateImport(this._applyDefaults(importedSourceIn, opts), null); + } + + addSideEffect(importedSourceIn, opts) { + return this._generateImport(this._applyDefaults(importedSourceIn, opts), false); + } + + _applyDefaults(importedSource, opts, isInit = false) { + const optsList = []; + + if (typeof importedSource === "string") { + optsList.push({ + importedSource + }); + optsList.push(opts); + } else { + _assert(!opts, "Unexpected secondary arguments."); + + optsList.push(importedSource); + } + + const newOpts = Object.assign({}, this._defaultOpts); + + for (const opts of optsList) { + if (!opts) continue; + Object.keys(newOpts).forEach(key => { + if (opts[key] !== undefined) newOpts[key] = opts[key]; + }); + + if (!isInit) { + if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint; + if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist; + } + } + + return newOpts; + } + + _generateImport(opts, importName) { + const isDefault = importName === "default"; + const isNamed = !!importName && !isDefault; + const isNamespace = importName === null; + const { + importedSource, + importedType, + importedInterop, + importingInterop, + ensureLiveReference, + ensureNoContext, + nameHint, + importPosition, + blockHoist + } = opts; + let name = nameHint || importName; + const isMod = (0, _isModule.default)(this._programPath); + const isModuleForNode = isMod && importingInterop === "node"; + const isModuleForBabel = isMod && importingInterop === "babel"; + + if (importPosition === "after" && !isMod) { + throw new Error(`"importPosition": "after" is only supported in modules`); + } + + const builder = new _importBuilder.default(importedSource, this._programScope, this._hub); + + if (importedType === "es6") { + if (!isModuleForNode && !isModuleForBabel) { + throw new Error("Cannot import an ES6 module from CommonJS"); + } + + builder.import(); + + if (isNamespace) { + builder.namespace(nameHint || importedSource); + } else if (isDefault || isNamed) { + builder.named(name, importName); + } + } else if (importedType !== "commonjs") { + throw new Error(`Unexpected interopType "${importedType}"`); + } else if (importedInterop === "babel") { + if (isModuleForNode) { + name = name !== "default" ? name : importedSource; + const es6Default = `${importedSource}$es6Default`; + builder.import(); + + if (isNamespace) { + builder.default(es6Default).var(name || importedSource).wildcardInterop(); + } else if (isDefault) { + if (ensureLiveReference) { + builder.default(es6Default).var(name || importedSource).defaultInterop().read("default"); + } else { + builder.default(es6Default).var(name).defaultInterop().prop(importName); + } + } else if (isNamed) { + builder.default(es6Default).read(importName); + } + } else if (isModuleForBabel) { + builder.import(); + + if (isNamespace) { + builder.namespace(name || importedSource); + } else if (isDefault || isNamed) { + builder.named(name, importName); + } + } else { + builder.require(); + + if (isNamespace) { + builder.var(name || importedSource).wildcardInterop(); + } else if ((isDefault || isNamed) && ensureLiveReference) { + if (isDefault) { + name = name !== "default" ? name : importedSource; + builder.var(name).read(importName); + builder.defaultInterop(); + } else { + builder.var(importedSource).read(importName); + } + } else if (isDefault) { + builder.var(name).defaultInterop().prop(importName); + } else if (isNamed) { + builder.var(name).prop(importName); + } + } + } else if (importedInterop === "compiled") { + if (isModuleForNode) { + builder.import(); + + if (isNamespace) { + builder.default(name || importedSource); + } else if (isDefault || isNamed) { + builder.default(importedSource).read(name); + } + } else if (isModuleForBabel) { + builder.import(); + + if (isNamespace) { + builder.namespace(name || importedSource); + } else if (isDefault || isNamed) { + builder.named(name, importName); + } + } else { + builder.require(); + + if (isNamespace) { + builder.var(name || importedSource); + } else if (isDefault || isNamed) { + if (ensureLiveReference) { + builder.var(importedSource).read(name); + } else { + builder.prop(importName).var(name); + } + } + } + } else if (importedInterop === "uncompiled") { + if (isDefault && ensureLiveReference) { + throw new Error("No live reference for commonjs default"); + } + + if (isModuleForNode) { + builder.import(); + + if (isNamespace) { + builder.default(name || importedSource); + } else if (isDefault) { + builder.default(name); + } else if (isNamed) { + builder.default(importedSource).read(name); + } + } else if (isModuleForBabel) { + builder.import(); + + if (isNamespace) { + builder.default(name || importedSource); + } else if (isDefault) { + builder.default(name); + } else if (isNamed) { + builder.named(name, importName); + } + } else { + builder.require(); + + if (isNamespace) { + builder.var(name || importedSource); + } else if (isDefault) { + builder.var(name); + } else if (isNamed) { + if (ensureLiveReference) { + builder.var(importedSource).read(name); + } else { + builder.var(name).prop(importName); + } + } + } + } else { + throw new Error(`Unknown importedInterop "${importedInterop}".`); + } + + const { + statements, + resultName + } = builder.done(); + + this._insertStatements(statements, importPosition, blockHoist); + + if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") { + return sequenceExpression([numericLiteral(0), resultName]); + } + + return resultName; + } + + _insertStatements(statements, importPosition = "before", blockHoist = 3) { + const body = this._programPath.get("body"); + + if (importPosition === "after") { + for (let i = body.length - 1; i >= 0; i--) { + if (body[i].isImportDeclaration()) { + body[i].insertAfter(statements); + return; + } + } + } else { + statements.forEach(node => { + node._blockHoist = blockHoist; + }); + const targetPath = body.find(p => { + const val = p.node._blockHoist; + return Number.isFinite(val) && val < 4; + }); + + if (targetPath) { + targetPath.insertBefore(statements); + return; + } + } + + this._programPath.unshiftContainer("body", statements); + } + +} + +exports.default = ImportInjector;
\ No newline at end of file diff --git a/node_modules/@babel/helper-module-imports/lib/index.js b/node_modules/@babel/helper-module-imports/lib/index.js new file mode 100644 index 0000000..a3d7921 --- /dev/null +++ b/node_modules/@babel/helper-module-imports/lib/index.js @@ -0,0 +1,41 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "ImportInjector", { + enumerable: true, + get: function () { + return _importInjector.default; + } +}); +exports.addDefault = addDefault; +exports.addNamed = addNamed; +exports.addNamespace = addNamespace; +exports.addSideEffect = addSideEffect; +Object.defineProperty(exports, "isModule", { + enumerable: true, + get: function () { + return _isModule.default; + } +}); + +var _importInjector = require("./import-injector"); + +var _isModule = require("./is-module"); + +function addDefault(path, importedSource, opts) { + return new _importInjector.default(path).addDefault(importedSource, opts); +} + +function addNamed(path, name, importedSource, opts) { + return new _importInjector.default(path).addNamed(name, importedSource, opts); +} + +function addNamespace(path, importedSource, opts) { + return new _importInjector.default(path).addNamespace(importedSource, opts); +} + +function addSideEffect(path, importedSource, opts) { + return new _importInjector.default(path).addSideEffect(importedSource, opts); +}
\ No newline at end of file diff --git a/node_modules/@babel/helper-module-imports/lib/is-module.js b/node_modules/@babel/helper-module-imports/lib/is-module.js new file mode 100644 index 0000000..ad9e399 --- /dev/null +++ b/node_modules/@babel/helper-module-imports/lib/is-module.js @@ -0,0 +1,18 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isModule; + +function isModule(path) { + const { + sourceType + } = path.node; + + if (sourceType !== "module" && sourceType !== "script") { + throw path.buildCodeFrameError(`Unknown sourceType "${sourceType}", cannot transform.`); + } + + return path.node.sourceType === "module"; +}
\ No newline at end of file |