function transpileModule(_) {
const doImports = _.doImports;
const lines = _.lines;
const body = moduleBody(context_2.verifyResults.moduleKind, lines);
if (context_1.compileOptions.noModuleBoilerplate) return new Program_1.Script(body);
const amd = amdWrapModule(doImports, transpiledImports(_), body);
return util_3.loc(_, new Program_1.Script(util_2.cat(Op_1.opIf(context_1.compileOptions.useStrict, () => useStrict), Op_1.opIf(context_1.compileOptions.includeAmdefine, () => amdefineHeader), amd)));
}
function parseClassHeader(tokens) {
var _tokens$getKeywordSec = tokens.getKeywordSections(44, 15);
var _tokens$getKeywordSec2 = _slicedToArray(_tokens$getKeywordSec, 2);
const fieldsTokens = _tokens$getKeywordSec2[0];
var _tokens$getKeywordSec3 = _slicedToArray(_tokens$getKeywordSec2[1], 2);
const extendsTokens = _tokens$getKeywordSec3[0];
const traitTokens = _tokens$getKeywordSec3[1];
return {
opFields: Op_1.opIf(!fieldsTokens.isEmpty(), () => fieldsTokens.map(_ => {
var _parseLocalDeclares_ = parseLocalDeclares_1.parseLocalParts(_);
const name = _parseLocalDeclares_.name;
const opType = _parseLocalDeclares_.opType;
const kind = _parseLocalDeclares_.kind;
context_1.check(kind === 0, _.loc, _ => _.todoLazyField);
return new Class_1.Field(_.loc, name, opType);
})),
opSuperClass: Op_1.opMap(extendsTokens, parseExpr_1.default),
traits: Op_1.caseOp(traitTokens, parseExpr_1.parseExprParts, () => [])
};
}
constructor(loc, args, opRestArg, block) {
let opts = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4];
super(loc);
this.args = args;
this.opRestArg = opRestArg;
this.block = block;
var _util_1$applyDefaults = util_1.applyDefaults(opts, {
kind: 0,
isThisFun: false,
isDo: false,
opReturnType: null
});
const kind = _util_1$applyDefaults.kind;
const isThisFun = _util_1$applyDefaults.isThisFun;
const isDo = _util_1$applyDefaults.isDo;
const opReturnType = _util_1$applyDefaults.opReturnType;
this.kind = kind;
this.opDeclareThis = Op_1.opIf(isThisFun, () => locals_1.LocalDeclare.this(this.loc));
this.isDo = isDo;
this.opReturnType = opReturnType;
}
function keywordPlainExpr(_ref2, after) {
let kind = _ref2.kind;
let loc = _ref2.loc;
switch (kind) {
case 0:
return new Await_1.default(loc, parseExpr(after));
case 1:
return parseCase_1.default(after);
case 2:
return parseClass_1.default(after);
case 3:
return parseCond(after);
case 4:
return parseDel_1.default(after);
case 5:
return parseExcept_1.default(after);
case 6:
return parseFor_1.parseFor(after);
case 7:
return parseFor_1.parseForAsync(after);
case 8:
return parseFor_1.parseForBag(after);
case 9:
case 16:
return parseConditional(kind, after);
case 10:
{
const parts = parseExprParts(after);
return new Call_1.New(loc, util_1.head(parts), util_1.tail(parts));
}
case 12:
return parsePipe_1.default(after);
case 11:
return parsePoly_1.default(after);
case 13:
return new Class_1.SuperCall(loc, parseExprParts(after));
case 14:
return parseSwitch_1.default(after);
case 15:
return parseTrait_1.default(after);
case 17:
return parseWith(after);
case 18:
return new YieldLike_1.Yield(loc, Op_1.opIf(!after.isEmpty(), () => parseExpr(after)));
case 19:
return new YieldLike_1.YieldTo(loc, parseExpr(after));
default:
throw new Error(String(kind));
}
}
function amdWrapModule(doImports, imports, body) {
const shouldImportBoot = context_1.compileOptions.importBoot;
const allImports = doImports.concat(imports);
const allImportPaths = allImports.map(_ => manglePath_1.default(_.path));
const arrImportPaths = new Expression_1.ArrayExpression(util_2.cat(litStrExports, Op_1.opIf(shouldImportBoot, () => new Literal_1.LiteralString(context_1.compileOptions.bootPath)), allImportPaths.map(_ => new Literal_1.LiteralString(_))));
const importToIdentifier = new Map();
const importIdentifiers = [];
for (let i = 0; i < allImports.length; i = i + 1) {
const _ = allImports[i];
const id = util_1.identifier(`${ pathBaseName(_.path) }_${ i }`);
importIdentifiers.push(id);
importToIdentifier.set(_, id);
}
function getIdentifier(_) {
return importToIdentifier.get(_);
}
const importArgs = util_2.cat(idExports, Op_1.opIf(shouldImportBoot, () => idBoot), importIdentifiers);
const doBoot = Op_1.opIf(shouldImportBoot, () => new Statement_1.ExpressionStatement(ms_1.msCall('getModule', idBoot)));
const importDos = doImports.map(_ => util_3.loc(_, new Statement_1.ExpressionStatement(ms_1.msCall('getModule', getIdentifier(_)))));
const opDeclareImportedLocals = Op_1.opIf(!util_2.isEmpty(imports), () => new Declaration_1.VariableDeclarationLet(util_2.flatMap(imports, _ => importDeclarators(_, getIdentifier(_)))));
const fullBody = new Statement_1.BlockStatement(util_2.cat(doBoot, importDos, opDeclareImportedLocals, body, returnExports));
const lazyBody = context_1.compileOptions.lazyModules ? new Statement_1.BlockStatement([new Statement_1.ExpressionStatement(new Expression_1.AssignmentExpression('=', exportsGet, ms_1.msCall('lazy', new Function_1.ArrowFunctionExpression([], fullBody))))]) : fullBody;
return new Statement_1.ExpressionStatement(new Expression_1.CallExpression(idDefine, [arrImportPaths, new Function_1.ArrowFunctionExpression(importArgs, lazyBody)]));
}
function opParseExpr(tokens) {
return Op_1.opIf(!tokens.isEmpty(), () => parseExpr(tokens));
}