/**
|
* @param {{ defer?: boolean, source?: boolean }} options
|
* @param {typeof import("acorn").Parser} Parser
|
* @param {typeof import("acorn").tokTypes} acorn
|
*/
|
exports.plugin = function acornImportPhase(options, Parser, tt) {
|
return class extends Parser {
|
parseImport(node) {
|
this._phase = null;
|
const result = super.parseImport(node);
|
if (this._phase) {
|
node.phase = this._phase;
|
}
|
return result;
|
}
|
|
parseImportSpecifiers() {
|
let phase =
|
options.defer !== false && this.isContextual("defer")
|
? "defer"
|
: options.source !== false && this.isContextual("source")
|
? "source"
|
: null;
|
if (!phase) return super.parseImportSpecifiers();
|
|
const phaseId = this.parseIdent();
|
if (this.isContextual("from") || this.type === tt.comma) {
|
const defaultSpecifier = this.startNodeAt(phaseId.start, phaseId.loc && phaseId.loc.start);
|
defaultSpecifier.local = phaseId;
|
this.checkLValSimple(phaseId, /* BIND_LEXICAL */ 2);
|
|
const nodes = [this.finishNode(defaultSpecifier, "ImportDefaultSpecifier")];
|
if (this.eat(tt.comma)) {
|
if (this.type !== tt.star && this.type !== tt.braceL) {
|
this.unexpected();
|
}
|
nodes.push(...super.parseImportSpecifiers());
|
}
|
return nodes;
|
}
|
|
this._phase = phase;
|
|
if (phase === "defer") {
|
if (this.type !== tt.star) {
|
this.raiseRecoverable(
|
phaseId.start,
|
"'import defer' can only be used with namespace imports ('import defer * as identifierName from ...')."
|
);
|
}
|
} else if (phase === "source") {
|
if (this.type !== tt.name) {
|
this.raiseRecoverable(
|
phaseId.start,
|
"'import source' can only be used with direct identifier specifier imports."
|
);
|
}
|
}
|
|
const specifiers = super.parseImportSpecifiers();
|
|
if (phase === "source" && specifiers.some(s => s.type !== "ImportDefaultSpecifier")) {
|
this.raiseRecoverable(
|
phaseId.start,
|
`'import source' can only be used with direct identifier specifier imports ('import source identifierName from ...').`
|
);
|
}
|
|
return specifiers;
|
}
|
|
parseExprImport(forNew) {
|
const node = super.parseExprImport(forNew);
|
|
if (node.type === "MetaProperty" && (node.property.name === "defer" || node.property.name === "source")) {
|
if (this.type === tt.parenL) {
|
const dynImport = this.parseDynamicImport(this.startNodeAt(node.start, node.loc && node.loc.start));
|
dynImport.phase = node.property.name;
|
return dynImport;
|
} else {
|
this.raiseRecoverable(
|
node.start,
|
`'import.${node.property.name}' can only be used in a dynamic import.`
|
);
|
}
|
}
|
|
return node;
|
}
|
|
parseImportMeta(node) {
|
this.next();
|
|
var containsEsc = this.containsEsc;
|
node.property = this.parseIdent(true);
|
|
const { name } = node.property;
|
|
if (name !== "meta" && name !== "defer" && name !== "source") {
|
this.raiseRecoverable(
|
node.property.start,
|
"The only valid meta property for import is 'import.meta'"
|
);
|
}
|
if (containsEsc) {
|
this.raiseRecoverable(
|
node.start,
|
`'import.${name}' must not contain escaped characters`
|
);
|
}
|
if (
|
name === "meta" &&
|
this.options.sourceType !== "module" &&
|
!this.options.allowImportExportEverywhere
|
) {
|
this.raiseRecoverable(
|
node.start,
|
"Cannot use 'import.meta' outside a module"
|
);
|
}
|
|
return this.finishNode(node, "MetaProperty");
|
}
|
};
|
};
|
