@rindo/core 3.1.0 → 3.2.0

package/cli/index.cjs

@@ -1,5 +1,5 @@
 /*!
- Rindo CLI (CommonJS) v3.1.0 | MIT Licensed | https://rindojs.web.app
+ Rindo CLI (CommonJS) v3.2.0 | MIT Licensed | https://rindojs.web.app
  */
 'use strict';
 
@@ -536,12 +536,23 @@ const CLI_FLAG_ALIASES = {
     h: 'help',
     p: 'port',
     v: 'version',
+    // JEST SPECIFIC CLI FLAGS
+    // these are defined in
+    // https://github.com/facebook/jest/blob/4156f86/packages/jest-cli/src/args.ts
+    b: 'bail',
+    e: 'expand',
+    f: 'onlyFailures',
+    i: 'runInBand',
+    o: 'onlyChanged',
+    t: 'testNamePattern',
+    u: 'updateSnapshot',
+    w: 'maxWorkers',
 };
 /**
  * A regular expression which can be used to match a CLI flag for one of our
  * short aliases.
  */
-const CLI_FLAG_REGEX = new RegExp(`^-[chpv]{1}$`);
+const CLI_FLAG_REGEX = new RegExp(`^-[chpvbewofitu]{1}$`);
 /**
  * Helper function for initializing a `ConfigFlags` object. Provide any overrides
  * for default values and off you go!
@@ -586,13 +597,6 @@ const parseFlags = (args) => {
             flags.args.splice(i, 1);
         }
     }
-    // to find unknown / unrecognized arguments we filter `args`, including only
-    // arguments whose normalized form is not found in `knownArgs`. `knownArgs`
-    // is populated during the call to `parseArgs` above. For arguments like
-    // `--foobar` the string `"--foobar"` will be added, while for more
-    // complicated arguments like `--bizBoz=bop` or `--bizBoz bop` just the
-    // string `"--bizBoz"` will be added.
-    flags.unknownArgs = flags.args.filter((arg) => !flags.knownArgs.includes(parseEqualsArg(arg)[0]));
     return flags;
 };
 /**
@@ -670,12 +674,12 @@ const parseCLITerm = (flags, args) => {
     else if (arg.startsWith('-') && arg.includes('=')) {
         // we're dealing with an AliasEqualsArg, we have a special helper for that
         const [originalArg, value] = parseEqualsArg(arg);
-        setCLIArg(flags, arg.split('=')[0], normalizeFlagName(originalArg), value);
+        setCLIArg(flags, desugarRawAlias(originalArg), normalizeFlagName(originalArg), value);
     }
     // AliasArg → "-" AliasName ( " " CLIValue )? ;
     else if (CLI_FLAG_REGEX.test(arg)) {
         // this is a short alias, like `-c` for Config
-        setCLIArg(flags, arg, normalizeFlagName(arg), parseCLIValue(args));
+        setCLIArg(flags, desugarRawAlias(arg), normalizeFlagName(arg), parseCLIValue(args));
     }
     // NegativeDashArg → "--no-" ArgName ;
     else if (arg.startsWith('--no-') && arg.length > '--no-'.length) {
@@ -698,11 +702,14 @@ const parseCLITerm = (flags, args) => {
     else if (arg.startsWith('--') && arg.length > '--'.length) {
         setCLIArg(flags, arg, normalizeFlagName(arg), parseCLIValue(args));
     }
-    // if we get here it is not an argument in our list of supported arguments.
-    // This doesn't necessarily mean we want to report an error or anything
-    // though! Instead, with unknown / unrecognized arguments we stick them into
-    // the `unknownArgs` array, which is used when we pass CLI args to Jest, for
-    // instance. So we just return void here.
+    else {
+        // if we get here then `arg` is not an argument in our list of supported
+        // arguments. This doesn't necessarily mean we want to report an error or
+        // anything though! Instead, with unknown / unrecognized arguments we want
+        // to stick them into the `unknownArgs` array, which is used when we pass
+        // CLI args to Jest, for instance.
+        flags.unknownArgs.push(arg);
+    }
 };
 /**
  * Normalize a 'negative' flag name, just to do a little pre-processing before
@@ -748,7 +755,7 @@ const normalizeFlagName = (flagName) => {
  * @param value the raw value to be set onto the config flags object
  */
 const setCLIArg = (flags, rawArg, normalizedArg, value) => {
-    normalizedArg = dereferenceAlias(normalizedArg);
+    normalizedArg = desugarAlias(normalizedArg);
     // We're setting a boolean!
     if (readOnlyArrayHasStringMember(BOOLEAN_CLI_FLAGS, normalizedArg)) {
         flags[normalizedArg] =
@@ -850,6 +857,14 @@ const setCLIArg = (flags, rawArg, normalizedArg, value) => {
             throwCLIParsingError(rawArg, 'expected to receive a valid log level but received nothing');
         }
     }
+    else {
+        // we haven't found this flag in any of our lists of arguments, so we
+        // should put it in our list of unknown arguments
+        flags.unknownArgs.push(rawArg);
+        if (typeof value === 'string') {
+            flags.unknownArgs.push(value);
+        }
+    }
 };
 /**
  * We use this regular expression to detect CLI parameters which
@@ -874,9 +889,10 @@ const Empty = Symbol('Empty');
  * A little helper which tries to parse a CLI value (as opposed to a flag) off
  * of the argument array.
  *
- * We support a variety of different argument formats, but all of them start
- * with `-`, so we can check the first character to test whether the next token
- * in our array of CLI arguments is a flag name or a value.
+ * We support a variety of different argument formats for flags (as opposed to
+ * values), but all of them start with `-`, so we can check the first character
+ * to test whether the next token in our array of CLI arguments is a flag name
+ * or a value.
  *
  * @param args an array of CLI args
  * @returns either a string result or an Empty sentinel
@@ -965,24 +981,36 @@ const throwNumberParsingError = (flag, value) => {
     throwCLIParsingError(flag, `expected a number but received "${value}"`);
 };
 /**
- * A little helper to 'dereference' a flag alias, which if you squint a little
- * you can think of like a pointer to a full flag name. Thus 'c' is like a
- * pointer to 'config', so here we're doing something like `*c`. Of course, this
- * being JS, this is just a metaphor!
+ * A little helper to 'desugar' a flag alias, meaning expand it to its full
+ * name. For instance, the alias `"c"` will desugar to `"config"`.
  *
- * If no 'dereference' is found for the possible alias we just return the
- * passed string unmodified.
+ * If no expansion is found for the possible alias we just return the passed
+ * string unmodified.
  *
  * @param maybeAlias a string which _could_ be an alias to a full flag name
  * @returns the full aliased flag name, if found, or the passed string if not
  */
-const dereferenceAlias = (maybeAlias) => {
-    const possibleDereference = CLI_FLAG_ALIASES[maybeAlias];
-    if (typeof possibleDereference === 'string') {
-        return possibleDereference;
+const desugarAlias = (maybeAlias) => {
+    const possiblyDesugared = CLI_FLAG_ALIASES[maybeAlias];
+    if (typeof possiblyDesugared === 'string') {
+        return possiblyDesugared;
     }
     return maybeAlias;
 };
+/**
+ * Desugar a 'raw' alias (with a leading dash) and return an equivalent,
+ * desugared argument.
+ *
+ * For instance, passing `"-c` will return `"--config"`.
+ *
+ * The reason we'd like to do this is not so much for our own code, but so that
+ * we can transform an alias like `"-u"` to `"--updateSnapshot"` in order to
+ * pass it along to Jest.
+ *
+ * @param rawAlias a CLI flag alias as found on the command line (like `"-c"`)
+ * @returns an equivalent full command (like `"--config"`)
+ */
+const desugarRawAlias = (rawAlias) => '--' + desugarAlias(normalizeFlagName(rawAlias));
 
 const IS_NODE_ENV = typeof global !== 'undefined' &&
     typeof require === 'function' &&
@@ -2254,12 +2282,18 @@ const taskHelp = async (flags, logger, sys) => {
 `);
 };
 
+/**
+ * Generate the output for Rindos 'info' task, and log that output - `npx rindo info`
+ * @param coreCompiler the compiler instance to derive certain version information from
+ * @param sys the compiler system instance that provides details about the system Rindo is running on
+ * @param logger the logger instance to use to log information out to
+ */
 const taskInfo = (coreCompiler, sys, logger) => {
     const details = sys.details;
     const versions = coreCompiler.versions;
     console.log(``);
     console.log(`${logger.cyan('      System:')} ${sys.name} ${sys.version}`);
-    console.log(`${logger.cyan('     Plaform:')} ${details.platform} (${details.release})`);
+    console.log(`${logger.cyan('    Platform:')} ${details.platform} (${details.release})`);
     console.log(`${logger.cyan('   CPU Model:')} ${details.cpuModel} (${sys.hardwareConcurrency} cpu${sys.hardwareConcurrency !== 1 ? 's' : ''})`);
     console.log(`${logger.cyan('    Compiler:')} ${sys.getCompilerExecutingPath()}`);
     console.log(`${logger.cyan('       Build:')} ${coreCompiler.buildId}`);

package/cli/index.js

@@ -1,5 +1,5 @@
 /*!
- Rindo CLI v3.1.0 | MIT Licensed | https://rindojs.web.app
+ Rindo CLI v3.2.0 | MIT Licensed | https://rindojs.web.app
  */
 /**
  * Convert a string from dash-case / kebab-case to PascalCase (or CamelCase,
@@ -512,12 +512,23 @@ const CLI_FLAG_ALIASES = {
     h: 'help',
     p: 'port',
     v: 'version',
+    // JEST SPECIFIC CLI FLAGS
+    // these are defined in
+    // https://github.com/facebook/jest/blob/4156f86/packages/jest-cli/src/args.ts
+    b: 'bail',
+    e: 'expand',
+    f: 'onlyFailures',
+    i: 'runInBand',
+    o: 'onlyChanged',
+    t: 'testNamePattern',
+    u: 'updateSnapshot',
+    w: 'maxWorkers',
 };
 /**
  * A regular expression which can be used to match a CLI flag for one of our
  * short aliases.
  */
-const CLI_FLAG_REGEX = new RegExp(`^-[chpv]{1}$`);
+const CLI_FLAG_REGEX = new RegExp(`^-[chpvbewofitu]{1}$`);
 /**
  * Helper function for initializing a `ConfigFlags` object. Provide any overrides
  * for default values and off you go!
@@ -562,13 +573,6 @@ const parseFlags = (args) => {
             flags.args.splice(i, 1);
         }
     }
-    // to find unknown / unrecognized arguments we filter `args`, including only
-    // arguments whose normalized form is not found in `knownArgs`. `knownArgs`
-    // is populated during the call to `parseArgs` above. For arguments like
-    // `--foobar` the string `"--foobar"` will be added, while for more
-    // complicated arguments like `--bizBoz=bop` or `--bizBoz bop` just the
-    // string `"--bizBoz"` will be added.
-    flags.unknownArgs = flags.args.filter((arg) => !flags.knownArgs.includes(parseEqualsArg(arg)[0]));
     return flags;
 };
 /**
@@ -646,12 +650,12 @@ const parseCLITerm = (flags, args) => {
     else if (arg.startsWith('-') && arg.includes('=')) {
         // we're dealing with an AliasEqualsArg, we have a special helper for that
         const [originalArg, value] = parseEqualsArg(arg);
-        setCLIArg(flags, arg.split('=')[0], normalizeFlagName(originalArg), value);
+        setCLIArg(flags, desugarRawAlias(originalArg), normalizeFlagName(originalArg), value);
     }
     // AliasArg → "-" AliasName ( " " CLIValue )? ;
     else if (CLI_FLAG_REGEX.test(arg)) {
         // this is a short alias, like `-c` for Config
-        setCLIArg(flags, arg, normalizeFlagName(arg), parseCLIValue(args));
+        setCLIArg(flags, desugarRawAlias(arg), normalizeFlagName(arg), parseCLIValue(args));
     }
     // NegativeDashArg → "--no-" ArgName ;
     else if (arg.startsWith('--no-') && arg.length > '--no-'.length) {
@@ -674,11 +678,14 @@ const parseCLITerm = (flags, args) => {
     else if (arg.startsWith('--') && arg.length > '--'.length) {
         setCLIArg(flags, arg, normalizeFlagName(arg), parseCLIValue(args));
     }
-    // if we get here it is not an argument in our list of supported arguments.
-    // This doesn't necessarily mean we want to report an error or anything
-    // though! Instead, with unknown / unrecognized arguments we stick them into
-    // the `unknownArgs` array, which is used when we pass CLI args to Jest, for
-    // instance. So we just return void here.
+    else {
+        // if we get here then `arg` is not an argument in our list of supported
+        // arguments. This doesn't necessarily mean we want to report an error or
+        // anything though! Instead, with unknown / unrecognized arguments we want
+        // to stick them into the `unknownArgs` array, which is used when we pass
+        // CLI args to Jest, for instance.
+        flags.unknownArgs.push(arg);
+    }
 };
 /**
  * Normalize a 'negative' flag name, just to do a little pre-processing before
@@ -724,7 +731,7 @@ const normalizeFlagName = (flagName) => {
  * @param value the raw value to be set onto the config flags object
  */
 const setCLIArg = (flags, rawArg, normalizedArg, value) => {
-    normalizedArg = dereferenceAlias(normalizedArg);
+    normalizedArg = desugarAlias(normalizedArg);
     // We're setting a boolean!
     if (readOnlyArrayHasStringMember(BOOLEAN_CLI_FLAGS, normalizedArg)) {
         flags[normalizedArg] =
@@ -826,6 +833,14 @@ const setCLIArg = (flags, rawArg, normalizedArg, value) => {
             throwCLIParsingError(rawArg, 'expected to receive a valid log level but received nothing');
         }
     }
+    else {
+        // we haven't found this flag in any of our lists of arguments, so we
+        // should put it in our list of unknown arguments
+        flags.unknownArgs.push(rawArg);
+        if (typeof value === 'string') {
+            flags.unknownArgs.push(value);
+        }
+    }
 };
 /**
  * We use this regular expression to detect CLI parameters which
@@ -850,9 +865,10 @@ const Empty = Symbol('Empty');
  * A little helper which tries to parse a CLI value (as opposed to a flag) off
  * of the argument array.
  *
- * We support a variety of different argument formats, but all of them start
- * with `-`, so we can check the first character to test whether the next token
- * in our array of CLI arguments is a flag name or a value.
+ * We support a variety of different argument formats for flags (as opposed to
+ * values), but all of them start with `-`, so we can check the first character
+ * to test whether the next token in our array of CLI arguments is a flag name
+ * or a value.
  *
  * @param args an array of CLI args
  * @returns either a string result or an Empty sentinel
@@ -941,24 +957,36 @@ const throwNumberParsingError = (flag, value) => {
     throwCLIParsingError(flag, `expected a number but received "${value}"`);
 };
 /**
- * A little helper to 'dereference' a flag alias, which if you squint a little
- * you can think of like a pointer to a full flag name. Thus 'c' is like a
- * pointer to 'config', so here we're doing something like `*c`. Of course, this
- * being JS, this is just a metaphor!
+ * A little helper to 'desugar' a flag alias, meaning expand it to its full
+ * name. For instance, the alias `"c"` will desugar to `"config"`.
  *
- * If no 'dereference' is found for the possible alias we just return the
- * passed string unmodified.
+ * If no expansion is found for the possible alias we just return the passed
+ * string unmodified.
  *
  * @param maybeAlias a string which _could_ be an alias to a full flag name
  * @returns the full aliased flag name, if found, or the passed string if not
  */
-const dereferenceAlias = (maybeAlias) => {
-    const possibleDereference = CLI_FLAG_ALIASES[maybeAlias];
-    if (typeof possibleDereference === 'string') {
-        return possibleDereference;
+const desugarAlias = (maybeAlias) => {
+    const possiblyDesugared = CLI_FLAG_ALIASES[maybeAlias];
+    if (typeof possiblyDesugared === 'string') {
+        return possiblyDesugared;
     }
     return maybeAlias;
 };
+/**
+ * Desugar a 'raw' alias (with a leading dash) and return an equivalent,
+ * desugared argument.
+ *
+ * For instance, passing `"-c` will return `"--config"`.
+ *
+ * The reason we'd like to do this is not so much for our own code, but so that
+ * we can transform an alias like `"-u"` to `"--updateSnapshot"` in order to
+ * pass it along to Jest.
+ *
+ * @param rawAlias a CLI flag alias as found on the command line (like `"-c"`)
+ * @returns an equivalent full command (like `"--config"`)
+ */
+const desugarRawAlias = (rawAlias) => '--' + desugarAlias(normalizeFlagName(rawAlias));
 
 const IS_NODE_ENV = typeof global !== 'undefined' &&
     typeof require === 'function' &&
@@ -2230,12 +2258,18 @@ const taskHelp = async (flags, logger, sys) => {
 `);
 };
 
+/**
+ * Generate the output for Rindos 'info' task, and log that output - `npx rindo info`
+ * @param coreCompiler the compiler instance to derive certain version information from
+ * @param sys the compiler system instance that provides details about the system Rindo is running on
+ * @param logger the logger instance to use to log information out to
+ */
 const taskInfo = (coreCompiler, sys, logger) => {
     const details = sys.details;
     const versions = coreCompiler.versions;
     console.log(``);
     console.log(`${logger.cyan('      System:')} ${sys.name} ${sys.version}`);
-    console.log(`${logger.cyan('     Plaform:')} ${details.platform} (${details.release})`);
+    console.log(`${logger.cyan('    Platform:')} ${details.platform} (${details.release})`);
     console.log(`${logger.cyan('   CPU Model:')} ${details.cpuModel} (${sys.hardwareConcurrency} cpu${sys.hardwareConcurrency !== 1 ? 's' : ''})`);
     console.log(`${logger.cyan('    Compiler:')} ${sys.getCompilerExecutingPath()}`);
     console.log(`${logger.cyan('       Build:')} ${coreCompiler.buildId}`);

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rindo/core/cli",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Rindo CLI.",
   "main": "./index.cjs",
   "module": "./index.js",

package/compiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rindo/core/compiler",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Rindo Compiler.",
   "main": "./rindo.js",
   "types": "./rindo.d.ts",

package/compiler/rindo.js

@@ -1,5 +1,5 @@
 /*!
- Rindo Compiler v3.1.0 | MIT Licensed | https://rindojs.web.app
+ Rindo Compiler v3.2.0 | MIT Licensed | https://rindojs.web.app
  */
 (function(exports) {
 'use strict';
@@ -2155,7 +2155,7 @@ const process$3 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(null), p
   'default': process_1
 });
 
-const buildId = '20230407110404';
+const buildId = '1680872033';
 const minfyJsId = 'terser5.16.1_7';
 const optimizeCssId = 'autoprefixer10.4.13_postcss8.4.21_7';
 const parse5Version = '7.1.2';
@@ -2163,8 +2163,8 @@ const rollupVersion = '2.42.3';
 const sizzleVersion = '2.42.3';
 const terserVersion = '5.16.1';
 const typescriptVersion = '4.9.4';
-const vermoji = '💥';
-const version$3 = '3.1.0';
+const vermoji = '🏙';
+const version$3 = '3.2.0';
 const versions = {
   rindo: version$3,
   parse5: parse5Version,
@@ -11644,6 +11644,7 @@ class MagicString$3 {
 			sourcemapLocations: { writable: true, value: new BitSet$3() },
 			storedNames: { writable: true, value: {} },
 			indentStr: { writable: true, value: undefined },
+			ignoreList: { writable: true, value: options.ignoreList },
 		});
 
 		this.byStart[0] = chunk;
@@ -11761,11 +11762,12 @@ class MagicString$3 {
 		});
 
 		return {
-			file: options.file ? options.file.split(/[/\\]/).pop() : null,
-			sources: [options.source ? getRelativePath$3(options.file || '', options.source) : null],
-			sourcesContent: options.includeContent ? [this.original] : [null],
+			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+			sources: [options.source ? getRelativePath$3(options.file || '', options.source) : (options.file || '')],
+			sourcesContent: options.includeContent ? [this.original] : undefined,
 			names,
 			mappings: mappings.raw,
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined
 		};
 	}
 
@@ -20104,6 +20106,40 @@ const getTypeReferenceLocation = (typeName, tsNode) => {
     location: 'global',
   };
 };
+/**
+ * Resolve a type annotation, using the TypeScript typechecker to convert a
+ * {@link ts.Type} record to a string.
+ *
+ * For instance, assume there's a module `foo.ts` which exports a type `Foo`
+ * which looks like this:
+ *
+ * ```ts
+ * // foo.ts
+ * type Foo = (b: string) => boolean;
+ * ```
+ *
+ * and then a module `bar.ts` which imports `Foo` and uses it to annotate a
+ * variable declaration like so:
+ *
+ * ```ts
+ * // bar.ts
+ * import { Foo } from './foo';
+ *
+ * let foo: Foo | undefined;
+ * ```
+ *
+ * If this function is called with the {@link ts.Type} object corresponding to
+ * the {@link ts.Node} object for the `foo` variable, it will return something
+ * like:
+ *
+ * ```ts
+ * "(b: string) => boolean | undefined";
+ * ```
+ *
+ * @param checker a typescript typechecker
+ * @param type the type to resolve
+ * @returns a resolved, user-readable string
+ */
 const resolveType = (checker, type) => {
   const set = new Set();
   parseDocsType(checker, type, set);
@@ -20114,7 +20150,7 @@ const resolveType = (checker, type) => {
     set.add('boolean');
   }
   let parts = Array.from(set.keys()).sort();
-  // TODO: Get this section of code under tests that directly exercises this behavior
+  // TODO: Get this section of code under tests that directly exercise this behavior
   if (parts.length > 1) {
     parts = parts.map((p) => (p.indexOf('=>') >= 0 ? `(${p})` : p));
   }
@@ -20127,6 +20163,7 @@ const resolveType = (checker, type) => {
 };
 /**
  * Formats a TypeScript `Type` entity as a string
+ *
  * @param checker a reference to the TypeScript type checker
  * @param type a TypeScript `Type` entity to format
  * @returns the formatted string
@@ -20135,6 +20172,18 @@ const typeToString = (checker, type) => {
   const TYPE_FORMAT_FLAGS = t.TypeFormatFlags.NoTruncation | t.TypeFormatFlags.InTypeAlias | t.TypeFormatFlags.InElementType;
   return checker.typeToString(type, undefined, TYPE_FORMAT_FLAGS);
 };
+/**
+ * Parse a type into its component parts, recursively dealing with each variant
+ * if it is a union type.
+ *
+ * **Note**: this function will mutate the `parts` set, adding new strings for
+ * any types it finds.
+ *
+ * @param checker a TypeScript typechecker instance
+ * @param type a TypeScript type
+ * @param parts an out param that holds parts of the type annotation we're
+ * assembling
+ */
 const parseDocsType = (checker, type, parts) => {
   if (type.isUnion()) {
     type.types.forEach((t) => {
@@ -61770,7 +61819,7 @@ const getBundleId = async (config, entryKey, shouldHash, code, sufix) => {
 };
 
 const generateLazyModules = async (config, compilerCtx, buildCtx, outputTargetType, destinations, results, sourceTarget, isBrowserBuild, sufix) => {
-  var _a;
+  var _a, _b;
   if (!Array.isArray(destinations) || destinations.length === 0) {
     return [];
   }
@@ -61781,7 +61830,7 @@ const generateLazyModules = async (config, compilerCtx, buildCtx, outputTargetTy
   const bundleModules = await Promise.all(entryComponentsResults.map((rollupResult) => {
     return generateLazyEntryModule(config, compilerCtx, buildCtx, rollupResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild, sufix);
   }));
-  if (!!((_a = config.extras) === null || _a === void 0 ? void 0 : _a.experimentalImportInjection) && !isBrowserBuild) {
+  if ((!!((_a = config.extras) === null || _a === void 0 ? void 0 : _a.experimentalImportInjection) || !!((_b = config.extras) === null || _b === void 0 ? void 0 : _b.enableImportInjection)) && !isBrowserBuild) {
     addStaticImports(rollupResults, bundleModules);
   }
   await Promise.all(chunkResults.map((rollupResult) => {
@@ -73676,10 +73725,12 @@ const transpileModule = (config, input, transformOpts) => {
       return normalizePath$2(fileName) === normalizePath$2(sourceFilePath) ? sourceFile : undefined;
     },
     writeFile: (name, text) => {
-      if (name.endsWith('.js.map')) {
+      if (name.endsWith('.js.map') || name.endsWith('.mjs.map')) {
         results.map = text;
       }
-      else if (name.endsWith('.js')) {
+      else if (name.endsWith('.js') || name.endsWith('.mjs')) {
+        // if the source file is an ES module w/ `.mjs` extension then
+        // TypeScript will output a `.mjs` file
         results.code = text;
       }
     },