return function css(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
    const loaders = ['style-loader', `css-loader${sourceMap ? '?sourceMap' : ''}`]

    if (resolveRelativeUrl) {
      loaders.push(`resolve-url-loader${sourceMap ? '?sourceMap' : ''}`)
      sourceMap = true // source maps need to be on for this
    }

    if (additionalLoaders) {
      loaders.push(...additionalLoaders)
    }

    const extractCss = extractText !== false
    const providedInstance = extractText instanceof ExtractTextPlugin
    const extractTextInstances: Map<string, any> = this.metadata.extractTextInstances = this.metadata.extractTextInstances || new Map()

    if (!providedInstance) {
      if (extractCss) {
        extractText = extractTextInstances.get(filename)
        if (!extractText) {
          extractText = new ExtractTextPlugin(extractText instanceof Object ? extractText : { filename, allChunks })
          extractTextInstances.set(filename, extractText)
        }
      } else {
        extractText = null
      }
    }

    const config = {
      module: {
        rules: get(this, 'module.rules', []).concat([{
          test,
          use: extractCss ?
            extractText.extract({ fallback: loaders[0], use: loaders.slice(1) }) :
            loaders
        }])
      },
      metadata: {
        extractTextInstances
      }
    } as WebpackConfigWithMetadata
    const plugins = get(this, 'plugins', [])
    if (extractText && !providedInstance && !(this.plugins || []).find(plugin => (plugin === extractText) || (plugin instanceof ExtractTextPlugin && (plugin as any).id === extractText.id))) {
      config.plugins = [
        /**
         * Plugin: ExtractTextPlugin
         * It moves every import "style.css" in entry chunks into a single concatenated css output file. 
         * So your styles are no longer inlined into the javascript, but separate in a css bundle file (styles.css). 
         * If your total stylesheet volume is big, it will be faster because the stylesheet bundle is loaded in parallel to the javascript bundle.
         */
        extractText
      ].concat(plugins)
    }
    if (resolveRelativeUrl instanceof Object) {
      config['resolveUrlLoader'] = resolveRelativeUrl
    }
    return config
  }

 return function aurelia(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
   return {
     metadata: {
       title,
       baseUrl,
       root,
       src,
     },
     resolve: {
       modules: [src].concat(get(this, 'resolve.modules', ['node_modules']))
     },
     plugins: [
       new AureliaWebpackPlugin(allOptions)
     ].concat(get(this, 'plugins', []))
   }
 }

 return function offline(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
   return {
     plugins: get(this, 'plugins', []).concat([
       new OfflinePlugin(options),
     ])
   }
 }

 return function sourceMapSupport(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
   const config = {
     plugins: [
       new webpack.BannerPlugin({
         banner: `require('source-map-support').install();`,
         raw: true, entryOnly: false
       })
     ].concat(get(this, 'plugins', []))
   } as WebpackConfigWithMetadata
   if (!browser) {
     config.externals = [
       'source-map-support',
     ].concat(get(this, 'externals', []))
   }
   return config
 }

 return function copyFiles(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
   return {
     plugins: [
       new CopyWebpackPlugin(patterns, options)
     ].concat(get(this, 'plugins', []))
   }
 }

  return function bluebird(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
    const config = {
      plugins: [
        new webpack.ProvidePlugin({
          'Promise': 'bluebird',
        })
      ].concat(get(this, 'plugins', []))
    } as WebpackConfigWithMetadata

    if (expose) {
      config.module = {
        rules: get(this, 'module.rules', []).concat([
          { test: /[\/\\]node_modules[\/\\]bluebird[\/\\].+\.js$/, loader: 'expose-loader?Promise' }
        ])
      }
    }
    return config
  }

 return function regenerator(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
   return {
     plugins: [
       new webpack.ProvidePlugin({
         'regeneratorRuntime': 'regenerator-runtime', // required for await-async
       })
     ].concat(get(this, 'plugins', []))
   }
 }

 return function tslint(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
   return {
     module: {
       rules: get(this, 'module.rules', []).concat([
         { test: /\.tsx?$/, loader: 'tslint-loader', enforce: 'pre', exclude: exclude || (this.metadata.root ? [path.join(this.metadata.root, 'node_modules')] : []) }
       ])
     }
   }
 }

 return function html(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
   return {
     module: {
       rules: get(this, 'module.rules', []).concat([{
         test: /\.html$/,
         loader: 'html-loader',
         exclude: exclude || (this.metadata.root ? [path.join(this.metadata.root, 'index.html')] : []),
       }])
     }
   }
 }

 return function json(this: WebpackConfigWithMetadata): WebpackConfigWithMetadata {
   return {
     module: {
       rules: get(this, 'module.rules', []).concat([{
         test: /\.json$/i,
         loader: 'json-loader',
         exclude: exclude || (this.metadata.root ? [path.join(this.metadata.root, 'node_modules')] : []),
       }])
     }
   }
 }