flow-type-def-lodash.js

var select = (elem, selection) => Array.from(elem.querySelectorAll(selection))
var flatten = array => array.reduce((agg, item) => agg.concat(item), [])

var transformType = type => type.replace("(", "").replace(")", "").replace("*", "any").replace("Array", "[]").replace("Object", "{}").replace("…", "...")
var transformArgument = argument => {
  argument.type = transformType(argument.type)
  if (argument.type.indexOf("...") === 0) {
    argument.isRest = true
    argument.name = "..."+argument.name
    argument.type = argument.type.slice(3) + "[]"
  }
  if (argument.type === "[][]") {
    argument.type = "Array[]"
  }
  argument.name = argument.name.replace("[", "").replace("]", "") 
  if (~argument.name.indexOf("=")) {
    const nameParts = argument.name.split("=")
    argument.name = nameParts[0]
    argument.default = argument.type === "number" ? parseFloat(nameParts[1]) : nameParts[1]
  }
  return argument
}

var container = document.getElementsByClassName("doc-container")[0].children[0]

var funcs = select(container, "div")

var parts = funcs.map(func => select(func, "h4"))
var argElements = parts.map(part => part.filter(item => item.textContent === "Arguments")[0].nextElementSibling)
var returnElements = parts.map(part => part.filter(item => item.textContent === "Returns")[0].nextElementSibling)    

var titles = funcs.map(func => select(func, ".me1")[0].textContent)

var arguments = argElements
  .map(argElement => select(argElement, "li")
    .map(arg => ({
      name: select(arg, "code")[0].textContent,
      type: select(arg, "em")[0].textContent,
    }))
    .map(transformArgument)
  )
  .reduce((all, funcArgs) => {
    const notLastRestArg = funcArgs.find((arg, i) => arg.isRest && i !== funcArgs.length - 1)
    if (notLastRestArg) {
      const notLastRestArgIndex = funcArgs.indexOf(notLastRestArg)
      const argWithoutRest = Object.assign(
        {}, 
        notLastRestArg,
        { name:  notLastRestArg.name.slice(3), isRest: null }
      )
      const transformed = [
        funcArgs.slice(0, notLastRestArgIndex + 1),
        funcArgs
          .slice(0, notLastRestArgIndex)
          .concat(argWithoutRest)
          .concat(funcArgs.slice(notLastRestArgIndex + 1)),
      ]
      all.push(transformed)

    }
    else {
      all.push([funcArgs])
    }
    return all
  }, [])

var returns = returnElements.map( returnElement => 
  transformType(select(returnElement, "em")[0].textContent)
)

var aggregate = flatten(arguments.map((args, index) => (args.map( arg => ({
  title: titles[index],
  arguments: arg,
  returns: returns[index],
})))))

var mapArgs = arguments => arguments.map(argument => 
  `${argument.name}:${argument.type}`
).join(", ")

var typeDef = `
  declare module lodash {
    ${aggregate.map(func => `declare function ${func.title} (${mapArgs(func.arguments)}) : ${func.returns}`).join("\n    ")}
  }
`