code: function parseArguments (args, state, babel) {
    const {file: {opts: {filename, plugins}}} = state
    const {types: t} = babel
  
    let chunkName, source
    const promises = {}
    const options =
      args.length > 1
      && args[args.length - 1].type !== 'StringLiteral'
      && args[args.length - 1].type !== 'TemplateLiteral'
        ? args[args.length - 1].node
        : void 0
    args = options === void 0 ? args : args.slice(0, -1)
  
    for (let arg of args) {
      let value = ''
  
      switch (arg.type) {
        case 'StringLiteral':
          // string literals are interpreted as module paths that need to be
          // imported and code-split
          // const node = arg.node !== void 0 ? arg.node : arg
          value = arg.node.value
          // if the package source isn't relative it is interpreted as-is,
          // otherwise it is joined to the path of the filename being parsed by
          // Babel
          source =
            value.match(relativePkg) === null
              ? value
              : path.join(path.dirname(filename), value)
          chunkName = chunkNameCache.get(source)
          // duplicate imports are not allowed
          if (promises[chunkName] !== void 0) {
            throw new Error(`[Broker Error] duplicate import: ${source}`)
          }
          // creates a function that returns the import promise
          // SEE: https://babeljs.io/docs/en/babel-types#callexpression
          promises[chunkName] = t.arrowFunctionExpression(
            [],
            t.callExpression(
              t.identifier('import'),
              [t.stringLiteral(source)]
            )
          )
        break;
        default:
          throw new Error(`[Broker Error] Unrecognized argument type: ${arg.type}`)
      }
    }
  
    return {promises, options}
  }
docs: Parses the lazy() macro arguments to determine their type. String literals are converted to require.ensure code-split imports. Arrow functions, Identifers, and plain Functions, are all excluded from code-splitting and are interpreted as-is.