text: 'use strict';
  
  const loaderUtils = require('loader-utils');
  const babel = require('@babel/core');
  const {default: generate} = require('@babel/generator');
  
  const DYNAMIC_REQUIRES_OK = Symbol.for("ok");
  const DYNAMIC_REQUIRES_WARN = Symbol.for("warn");
  const DYNAMIC_REQUIRES_ERROR = Symbol.for("error");
  const DYNAMIC_REQUIRES_VALUES = [
    DYNAMIC_REQUIRES_OK,
    DYNAMIC_REQUIRES_WARN,
    DYNAMIC_REQUIRES_ERROR
  ].map(s => Symbol.keyFor(s));
  
  const loader = function(source, inputSourceMap) {
    this.cacheable && this.cacheable();
  
    const config = loaderUtils.getOptions(this);
    config.dynamicRequires = config.dynamicRequires || 'warn';
  
    if(!(config.hasOwnProperty('module') &&
         config.hasOwnProperty('tagger'))) {
      this.emitError("Please configure module and tagger to use this loader.");
    }
  
    if (!DYNAMIC_REQUIRES_VALUES.includes(config.dynamicRequires)) {
      this.emitError(`Expecting dynamicRequires to be one of
                      ${DYNAMIC_REQUIRES_VALUES.join(' | ')}.
                      You gave me: ${config.dynamicRequires}`);
    }
  
    const packageName = config['package'] || 'author/project';
    const taggerName =  [
      packageName.replace(/-/g, '_').replace(/\//g, '$'),
      config.module.replace(/\./g, '$'),
      config.tagger
    ].join('$');
  
    const transformerOptions = {
      taggerName: taggerName,
      dynamicRequires: Symbol.for(config.dynamicRequires),
      localPath: config.localPath
    };
  
    const webpackRemainingChain = loaderUtils.getRemainingRequest(this).split("!");
    const filename  = webpackRemainingChain[webpackRemainingChain.length - 1];
    const babelOptions = {
      inputSourceMap: inputSourceMap,
      sourceRoot: process.cwd(),
      filename: filename,
      compact: false,
      babelrc: false
    };
  
    const result = transform(source, this, transformerOptions, babelOptions);
  
    this.callback(null, result.code, result.map);
  };
  
  const transform = function(source, loaderContext, transformerOptions, babelOptions) {
    babelOptions.plugins = [
      assetTransformer(loaderContext, transformerOptions)
    ];
  
    const result = babel.transform(source, babelOptions);
    const code = result.code;
    const map = result.map;
  
    if (map && (!map.sourcesContent || !map.sourcesContent.length)) {
      map.sourcesContent = [source];
    }
  
    return {
      code: code,
      map: map
    };
  }
  
  const assetTransformer = function(loaderContext, options) {
    const plugin = function({ types: t }) {
      return {
        visitor: {
          CallExpression: callExpressionVisitor(t, loaderContext, options)
        }
      }
    };
  
    return plugin;
  }
  
  const REPLACED_NODE = Symbol('elmAssetsLoaderReplaced');
  
  const callExpressionVisitor = function(t, loaderContext, options) {
    const visitor = function(path) {
      // avoid infinite recursion
      if (path.node[REPLACED_NODE]) {
        return;
      }
  
      // calling the tagger we want?
  
      if (!t.isIdentifier(path.node.callee)) {
        return;
      }
  
      if (path.node.callee.name !== options.taggerName) {
        return;
      }
  
      // check for multiple args.
      // though this isn't likely to happen in practice, since multiple
      // argument calls get compiled to something like:
      //
      //     A2(author$project$MultiArg$Asset, 'elm_logo.svg', 'elm_logo.svg');
      if (path.node.arguments.length > 1) {
        loaderContext.emitError("Tagger that tags multiple strings is currently not supported.");
      }
  
      // check for zero args.
      // though this isn't likely to happen in practice, since zero
      // argument calls mean:
      //
      //     var author$project$NoArg$assetPath = 'star.png';
      if (path.node.arguments.length === 0) {
        loaderContext.emitError("Tagger must tag only one string.");
      }
  
      const argument = path.node.arguments[0];
  
      // check for non-string-literals
      if (!(t.isLiteral(argument) && typeof argument.value === 'string')) {
        const actualCode = generate(path.node).code;
  
        if (options.dynamicRequires === DYNAMIC_REQUIRES_ERROR) {
          loaderContext.emitError("Failing hard to make sure all assets are run through webpack. Dynamically constructed asset path like this is not supported:" + actualCode);
        } else if (options.dynamicRequires === DYNAMIC_REQUIRES_WARN) {
          loaderContext.emitWarning("This asset path, which is dynamically constructed, will not be run through webpack: " + actualCode);
        }
  
        /*
          Trying to webpackify non-string-literals is like opening a can of bad things.
          Even a simple string concatenation like:
  
              ComplexCallAsset ("elm_logo" ++ ".svg")
  
          results in a function call in compiled JavaScript code:
  
              author$project$ComplexCall$ComplexCallAsset(
                  A2(elm$core$Basics_ops[\'++\'], \'elm_logo\', \'.svg\'))
  
          If we wrap this in a call to `require`, webpack will create a
          [context module][context-module].
  
              author$project$ComplexCall$ComplexCallAsset(
                  require(A2(elm$core$Basics_ops[\'++\'], \'elm_logo\', \'.svg\')))
  
         Which "contains references to all modules in that directory that can be
         required with a request matching the regular expression." Since webpack
         can't predict what will come out of the `A2` function call, webpack
         will try to include all possible modules in the context module. This
         leads to bloated bundles and lots of warnings from trying to load every
         file in the directory where the Elm file is in.
  
            [context-module]: https://webpack.github.io/docs/context.html#context-module
        */
        return;
      }
  
      // transform argument value to local path if desired
  
      if (typeof options.localPath === 'function') {
        argument.value = options.localPath(argument.value);
        if (typeof argument.value !== 'string') {
          loaderContext.emitError('localPath returned something not a string: ' + argument.value);
        }
      }
  
      const requireExpression = t.callExpression(t.Identifier('require'), [argument]);
      const replacement = t.callExpression(path.node.callee, [requireExpression]);
      replacement[REPLACED_NODE] = true;
  
      path.replaceWith(replacement);
    }
  
    return visitor;
  }
  
  module.exports = loader;
  