~technomancy/antifennel

30134122e50e79805e54f57e872b692c02e89c7d — Phil Hagelberg 2 months ago bb23348
Upgrade to Fennel 1.4.2.
M changelog.md => changelog.md +2 -1
@@ 1,7 1,8 @@
# Summary of user-visible changes

## 0.3.0 / ???
## 0.3.0 / 2024-03-07

* Use version 1.4.2 of Fennel and 0.3.1 of fnlfmt.
* Turn `foo["x"] = y` assignments into multisym `(set foo.x y)` assignments.
* Compile global functions to `(fn _G.f [] ...)` instead of `set-forcibly!`
* Compile `t.f = function` to `(fn t.f [] ...)` without `set`.

M fennel => fennel +1210 -1056
@@ 1,28 1,39 @@
#!/usr/bin/env lua
-- SPDX-License-Identifier: MIT
-- SPDX-FileCopyrightText: Calvin Rose and contributors
package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(...)
  local fennel = require("fennel")
  local _767_ = require("fennel.utils")
  local copy = _767_["copy"]
  local warn = _767_["warn"]
  local _787_ = require("fennel.utils")
  local copy = _787_["copy"]
  local warn = _787_["warn"]
  local function shellout(command)
    local f = io.popen(command)
    local stdout = f:read("*all")
    return (f:close() and stdout)
  end
  local function execute(cmd)
    local _768_0 = os.execute(cmd)
    if (_768_0 == 0) then
    local _788_0 = os.execute(cmd)
    if (_788_0 == 0) then
      return true
    elseif (_768_0 == true) then
    elseif (_788_0 == true) then
      return true
    end
  end
  local function string__3ec_hex_literal(characters)
    local hex = {}
    for character in characters:gmatch(".") do
      table.insert(hex, ("0x%02x"):format(string.byte(character)))
    local _790_
    do
      local tbl_17_ = {}
      local i_18_ = #tbl_17_
      for character in characters:gmatch(".") do
        local val_19_ = ("0x%02x"):format(string.byte(character))
        if (nil ~= val_19_) then
          i_18_ = (i_18_ + 1)
          tbl_17_[i_18_] = val_19_
        end
      end
      _790_ = tbl_17_
    end
    return table.concat(hex, ", ")
    return table.concat(_790_, ", ")
  end
  local c_shim = "#ifdef __cplusplus\nextern \"C\" {\n#endif\n#include <lauxlib.h>\n#include <lua.h>\n#include <lualib.h>\n#ifdef __cplusplus\n}\n#endif\n#include <signal.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#if LUA_VERSION_NUM == 501\n  #define LUA_OK 0\n#endif\n\n/* Copied from lua.c */\n\nstatic lua_State *globalL = NULL;\n\nstatic void lstop (lua_State *L, lua_Debug *ar) {\n  (void)ar;  /* unused arg. */\n  lua_sethook(L, NULL, 0, 0);  /* reset hook */\n  luaL_error(L, \"interrupted!\");\n}\n\nstatic void laction (int i) {\n  signal(i, SIG_DFL); /* if another SIGINT happens, terminate process */\n  lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);\n}\n\nstatic void createargtable (lua_State *L, char **argv, int argc, int script) {\n  int i, narg;\n  if (script == argc) script = 0;  /* no script name? */\n  narg = argc - (script + 1);  /* number of positive indices */\n  lua_createtable(L, narg, script + 1);\n  for (i = 0; i < argc; i++) {\n    lua_pushstring(L, argv[i]);\n    lua_rawseti(L, -2, i - script);\n  }\n  lua_setglobal(L, \"arg\");\n}\n\nstatic int msghandler (lua_State *L) {\n  const char *msg = lua_tostring(L, 1);\n  if (msg == NULL) {  /* is error object not a string? */\n    if (luaL_callmeta(L, 1, \"__tostring\") &&  /* does it have a metamethod */\n        lua_type(L, -1) == LUA_TSTRING)  /* that produces a string? */\n      return 1;  /* that is the message */\n    else\n      msg = lua_pushfstring(L, \"(error object is a %%s value)\",\n                            luaL_typename(L, 1));\n  }\n  /* Call debug.traceback() instead of luaL_traceback() for Lua 5.1 compat. */\n  lua_getglobal(L, \"debug\");\n  lua_getfield(L, -1, \"traceback\");\n  /* debug */\n  lua_remove(L, -2);\n  lua_pushstring(L, msg);\n  /* original msg */\n  lua_remove(L, -3);\n  lua_pushinteger(L, 2);  /* skip this function and traceback */\n  lua_call(L, 2, 1); /* call debug.traceback */\n  return 1;  /* return the traceback */\n}\n\nstatic int docall (lua_State *L, int narg, int nres) {\n  int status;\n  int base = lua_gettop(L) - narg;  /* function index */\n  lua_pushcfunction(L, msghandler);  /* push message handler */\n  lua_insert(L, base);  /* put it under function and args */\n  globalL = L;  /* to be available to 'laction' */\n  signal(SIGINT, laction);  /* set C-signal handler */\n  status = lua_pcall(L, narg, nres, base);\n  signal(SIGINT, SIG_DFL); /* reset C-signal handler */\n  lua_remove(L, base);  /* remove message handler from the stack */\n  return status;\n}\n\nint main(int argc, char *argv[]) {\n lua_State *L = luaL_newstate();\n luaL_openlibs(L);\n createargtable(L, argv, argc, 0);\n\n static const unsigned char lua_loader_program[] = {\n%s\n};\n  if(luaL_loadbuffer(L, (const char*)lua_loader_program,\n                     sizeof(lua_loader_program), \"%s\") != LUA_OK) {\n    fprintf(stderr, \"luaL_loadbuffer: %%s\\n\", lua_tostring(L, -1));\n    lua_close(L);\n    return 1;\n  }\n\n  /* lua_bundle */\n  lua_newtable(L);\n  static const unsigned char lua_require_1[] = {\n  %s\n  };\n  lua_pushlstring(L, (const char*)lua_require_1, sizeof(lua_require_1));\n  lua_setfield(L, -2, \"%s\");\n\n%s\n\n  if (docall(L, 1, LUA_MULTRET)) {\n    const char *errmsg = lua_tostring(L, 1);\n    if (errmsg) {\n      fprintf(stderr, \"%%s\\n\", errmsg);\n    }\n    lua_close(L);\n    return 1;\n  }\n  lua_close(L);\n  return 0;\n}"
  local function compile_fennel(filename, options)


@@ 39,13 50,13 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
  local function module_name(open, rename, used_renames)
    local require_name = nil
    do
      local _771_0 = rename[open]
      if (nil ~= _771_0) then
        local renamed = _771_0
      local _793_0 = rename[open]
      if (nil ~= _793_0) then
        local renamed = _793_0
        used_renames[open] = true
        require_name = renamed
      else
        local _ = _771_0
        local _ = _793_0
        require_name = open
      end
    end


@@ 84,14 95,14 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
    local dotpath = filename:gsub("^%.%/", ""):gsub("[\\/]", ".")
    local dotpath_noextension = (dotpath:match("(.+)%.") or dotpath)
    local fennel_loader = nil
    local _775_
    local _797_
    do
      _775_ = "(do (local bundle_2_ ...) (fn loader_3_ [name_4_] (match (or (. bundle_2_ name_4_) (. bundle_2_ (.. name_4_ \".init\"))) (mod_5_ ? (= \"function\" (type mod_5_))) mod_5_ (mod_5_ ? (= \"string\" (type mod_5_))) (assert (if (= _VERSION \"Lua 5.1\") (loadstring mod_5_ name_4_) (load mod_5_ name_4_))) nil (values nil (: \"\n\\tmodule '%%s' not found in fennel bundle\" \"format\" name_4_)))) (table.insert (or package.loaders package.searchers) 2 loader_3_) ((assert (loader_3_ \"%s\")) ((or unpack table.unpack) arg)))"
      _797_ = "(do (local bundle_2_ ...) (fn loader_3_ [name_4_] (match (or (. bundle_2_ name_4_) (. bundle_2_ (.. name_4_ \".init\"))) (mod_5_ ? (= \"function\" (type mod_5_))) mod_5_ (mod_5_ ? (= \"string\" (type mod_5_))) (assert (if (= _VERSION \"Lua 5.1\") (loadstring mod_5_ name_4_) (load mod_5_ name_4_))) nil (values nil (: \"\n\\tmodule '%%s' not found in fennel bundle\" \"format\" name_4_)))) (table.insert (or package.loaders package.searchers) 2 loader_3_) ((assert (loader_3_ \"%s\")) ((or unpack table.unpack) arg)))"
    end
    fennel_loader = _775_:format(dotpath_noextension)
    fennel_loader = _797_:format(dotpath_noextension)
    local lua_loader = fennel["compile-string"](fennel_loader)
    local _776_ = options
    local rename_modules = _776_["rename-modules"]
    local _798_ = options
    local rename_modules = _798_["rename-modules"]
    return c_shim:format(string__3ec_hex_literal(lua_loader), basename_noextension, string__3ec_hex_literal(compile_fennel(filename, options)), dotpath_noextension, native_loader(native, {["rename-modules"] = rename_modules}))
  end
  local function write_c(filename, native, options)


@@ 104,28 115,28 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
  local function compile_binary(lua_c_path, executable_name, static_lua, lua_include_dir, native)
    local cc = (os.getenv("CC") or "cc")
    local rdynamic, bin_extension, ldl_3f = nil, nil, nil
    local _778_
    local _800_
    do
      local _777_0 = shellout((cc .. " -dumpmachine"))
      if (nil ~= _777_0) then
        _778_ = _777_0:match("mingw")
      local _799_0 = shellout((cc .. " -dumpmachine"))
      if (nil ~= _799_0) then
        _800_ = _799_0:match("mingw")
      else
        _778_ = _777_0
        _800_ = _799_0
      end
    end
    if _778_ then
    if _800_ then
      rdynamic, bin_extension, ldl_3f = "", ".exe", false
    else
      rdynamic, bin_extension, ldl_3f = "-rdynamic", "", true
    end
    local compile_command = nil
    local _781_
    local _803_
    if ldl_3f then
      _781_ = "-ldl"
      _803_ = "-ldl"
    else
      _781_ = ""
      _803_ = ""
    end
    compile_command = {cc, "-Os", lua_c_path, table.concat(native, " "), static_lua, rdynamic, "-lm", _781_, "-o", (executable_name .. bin_extension), "-I", lua_include_dir, os.getenv("CC_OPTS")}
    compile_command = {cc, "-Os", lua_c_path, table.concat(native, " "), static_lua, rdynamic, "-lm", _803_, "-o", (executable_name .. bin_extension), "-I", lua_include_dir, os.getenv("CC_OPTS")}
    if os.getenv("FENNEL_DEBUG") then
      print("Compiling with", table.concat(compile_command, " "))
    end


@@ 143,17 154,17 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
    if (version_extension and (version_extension ~= "") and not version_extension:match("%.%d+")) then
      return false
    else
      local _786_0 = extension
      if (_786_0 == "a") then
      local _808_0 = extension
      if (_808_0 == "a") then
        return path
      elseif (_786_0 == "o") then
      elseif (_808_0 == "o") then
        return path
      elseif (_786_0 == "so") then
      elseif (_808_0 == "so") then
        return path
      elseif (_786_0 == "dylib") then
      elseif (_808_0 == "dylib") then
        return path
      else
        local _ = _786_0
        local _ = _808_0
        return false
      end
    end


@@ 178,17 189,17 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
        table.remove(args, i)
      end
    end
    if (0 < #args) then
    if next(args) then
      print(table.concat(args, " "))
      error(("Unknown args: " .. table.concat(args, " ")))
    end
    return native
  end
  local function compile(filename, executable_name, static_lua, lua_include_dir, options, args)
    local _793_ = extract_native_args(args)
    local libraries = _793_["libraries"]
    local modules = _793_["modules"]
    local rename_modules = _793_["rename-modules"]
    local _815_ = extract_native_args(args)
    local libraries = _815_["libraries"]
    local modules = _815_["modules"]
    local rename_modules = _815_["rename-modules"]
    local opts = {["rename-modules"] = rename_modules}
    copy(options, opts)
    return compile_binary(write_c(filename, modules, opts), executable_name, static_lua, lua_include_dir, libraries)


@@ 203,16 214,16 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
  local compiler = require("fennel.compiler")
  local specials = require("fennel.specials")
  local view = require("fennel.view")
  local unpack = (table.unpack or _G.unpack)
  local function default_read_chunk(parser_state)
    local function _604_()
      if (0 < parser_state["stack-size"]) then
        return ".."
      else
        return ">> "
      end
  local depth = 0
  local function prompt_for(top_3f)
    if top_3f then
      return (string.rep(">", (depth + 1)) .. " ")
    else
      return (string.rep(".", (depth + 1)) .. " ")
    end
    io.write(_604_())
  end
  local function default_read_chunk(parser_state)
    io.write(prompt_for((0 == parser_state["stack-size"])))
    io.flush()
    local input = io.read()
    return (input and (input .. "\n"))


@@ 222,18 233,18 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    return io.write("\n")
  end
  local function default_on_error(errtype, err, lua_source)
    local function _606_()
      local _605_0 = errtype
      if (_605_0 == "Lua Compile") then
    local function _616_()
      local _615_0 = errtype
      if (_615_0 == "Lua Compile") then
        return ("Bad code generated - likely a bug with the compiler:\n" .. "--- Generated Lua Start ---\n" .. lua_source .. "--- Generated Lua End ---\n")
      elseif (_605_0 == "Runtime") then
      elseif (_615_0 == "Runtime") then
        return (compiler.traceback(tostring(err), 4) .. "\n")
      else
        local _ = _605_0
        local _ = _615_0
        return ("%s error: %s\n"):format(errtype, tostring(err))
      end
    end
    return io.write(_606_())
    return io.write(_616_())
  end
  local function splice_save_locals(env, lua_source, scope)
    local saves = nil


@@ 241,7 252,7 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
      local tbl_17_ = {}
      local i_18_ = #tbl_17_
      for name in pairs(env.___replLocals___) do
        local val_19_ = ("local %s = ___replLocals___['%s']"):format((scope.manglings[name] or name), name)
        local val_19_ = ("local %s = ___replLocals___[%q]"):format((scope.manglings[name] or name), name)
        if (nil ~= val_19_) then
          i_18_ = (i_18_ + 1)
          tbl_17_[i_18_] = val_19_


@@ 256,7 267,7 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
      for raw, name in pairs(scope.manglings) do
        local val_19_ = nil
        if not scope.gensyms[name] then
          val_19_ = ("___replLocals___['%s'] = %s"):format(raw, name)
          val_19_ = ("___replLocals___[%q] = %s"):format(raw, name)
        else
        val_19_ = nil
        end


@@ 273,25 284,25 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    else
      gap = " "
    end
    local function _612_()
    local function _622_()
      if next(saves) then
        return (table.concat(saves, " ") .. gap)
      else
        return ""
      end
    end
    local function _615_()
      local _613_0, _614_0 = lua_source:match("^(.*)[\n ](return .*)$")
      if ((nil ~= _613_0) and (nil ~= _614_0)) then
        local body = _613_0
        local _return = _614_0
    local function _625_()
      local _623_0, _624_0 = lua_source:match("^(.*)[\n ](return .*)$")
      if ((nil ~= _623_0) and (nil ~= _624_0)) then
        local body = _623_0
        local _return = _624_0
        return (body .. gap .. table.concat(binds, " ") .. gap .. _return)
      else
        local _ = _613_0
        local _ = _623_0
        return lua_source
      end
    end
    return (_612_() .. _615_())
    return (_622_() .. _625_())
  end
  local function completer(env, scope, text)
    local max_items = 2000


@@ 303,14 314,14 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
      local scope_first_3f = ((tbl == env) or (tbl == env.___replLocals___))
      local tbl_17_ = matches
      local i_18_ = #tbl_17_
      local function _617_()
      local function _627_()
        if scope_first_3f then
          return scope.manglings
        else
          return tbl
        end
      end
      for k, is_mangled in utils.allpairs(_617_()) do
      for k, is_mangled in utils.allpairs(_627_()) do
        if (max_items <= #matches) then break end
        local val_19_ = nil
        do


@@ 378,7 389,7 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    return input:match("^%s*,")
  end
  local function command_docs()
    local _626_
    local _636_
    do
      local tbl_17_ = {}
      local i_18_ = #tbl_17_


@@ 389,18 400,18 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
          tbl_17_[i_18_] = val_19_
        end
      end
      _626_ = tbl_17_
      _636_ = tbl_17_
    end
    return table.concat(_626_, "\n")
    return table.concat(_636_, "\n")
  end
  commands.help = function(_, _0, on_values)
    return on_values({("Welcome to Fennel.\nThis is the REPL where you can enter code to be evaluated.\nYou can also run these repl commands:\n\n" .. command_docs() .. "\n  ,exit - Leave the repl.\n\nUse ,doc something to see descriptions for individual macros and special forms.\n\nFor more information about the language, see https://fennel-lang.org/reference")})
    return on_values({("Welcome to Fennel.\nThis is the REPL where you can enter code to be evaluated.\nYou can also run these repl commands:\n\n" .. command_docs() .. "\n  ,return FORM - Evaluate FORM and return its value to the REPL's caller.\n  ,exit - Leave the repl.\n\nUse ,doc something to see descriptions for individual macros and special forms.\nValues from previous inputs are kept in *1, *2, and *3.\n\nFor more information about the language, see https://fennel-lang.org/reference")})
  end
  do end (compiler.metadata):set(commands.help, "fnl/docstring", "Show this message.")
  local function reload(module_name, env, on_values, on_error)
    local _628_0, _629_0 = pcall(specials["load-code"]("return require(...)", env), module_name)
    if ((_628_0 == true) and (nil ~= _629_0)) then
      local old = _629_0
    local _638_0, _639_0 = pcall(specials["load-code"]("return require(...)", env), module_name)
    if ((_638_0 == true) and (nil ~= _639_0)) then
      local old = _639_0
      local _ = nil
      package.loaded[module_name] = nil
      _ = nil


@@ 425,8 436,8 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
        package.loaded[module_name] = old
      end
      return on_values({"ok"})
    elseif ((_628_0 == false) and (nil ~= _629_0)) then
      local msg = _629_0
    elseif ((_638_0 == false) and (nil ~= _639_0)) then
      local msg = _639_0
      if msg:match("loop or previous error loading module") then
        package.loaded[module_name] = nil
        return reload(module_name, env, on_values, on_error)


@@ 434,32 445,32 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
        specials["macro-loaded"][module_name] = nil
        return nil
      else
        local function _634_()
          local _633_0 = msg:gsub("\n.*", "")
          return _633_0
        local function _644_()
          local _643_0 = msg:gsub("\n.*", "")
          return _643_0
        end
        return on_error("Runtime", _634_())
        return on_error("Runtime", _644_())
      end
    end
  end
  local function run_command(read, on_error, f)
    local _637_0, _638_0, _639_0 = pcall(read)
    if ((_637_0 == true) and (_638_0 == true) and (nil ~= _639_0)) then
      local val = _639_0
      local _640_0, _641_0 = pcall(f, val)
      if ((_640_0 == false) and (nil ~= _641_0)) then
        local msg = _641_0
    local _647_0, _648_0, _649_0 = pcall(read)
    if ((_647_0 == true) and (_648_0 == true) and (nil ~= _649_0)) then
      local val = _649_0
      local _650_0, _651_0 = pcall(f, val)
      if ((_650_0 == false) and (nil ~= _651_0)) then
        local msg = _651_0
        return on_error("Runtime", msg)
      end
    elseif (_637_0 == false) then
    elseif (_647_0 == false) then
      return on_error("Parse", "Couldn't parse input.")
    end
  end
  commands.reload = function(env, read, on_values, on_error)
    local function _644_(_241)
    local function _654_(_241)
      return reload(tostring(_241), env, on_values, on_error)
    end
    return run_command(read, on_error, _644_)
    return run_command(read, on_error, _654_)
  end
  do end (compiler.metadata):set(commands.reload, "fnl/docstring", "Reload the specified module.")
  commands.reset = function(env, _, on_values)


@@ 468,28 479,28 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
  end
  do end (compiler.metadata):set(commands.reset, "fnl/docstring", "Erase all repl-local scope.")
  commands.complete = function(env, read, on_values, on_error, scope, chars)
    local function _645_()
    local function _655_()
      return on_values(completer(env, scope, table.concat(chars):gsub(",complete +", ""):sub(1, -2)))
    end
    return run_command(read, on_error, _645_)
    return run_command(read, on_error, _655_)
  end
  do end (compiler.metadata):set(commands.complete, "fnl/docstring", "Print all possible completions for a given input symbol.")
  local function apropos_2a(pattern, tbl, prefix, seen, names)
    for name, subtbl in pairs(tbl) do
      if (("string" == type(name)) and (package ~= subtbl)) then
        local _646_0 = type(subtbl)
        if (_646_0 == "function") then
        local _656_0 = type(subtbl)
        if (_656_0 == "function") then
          if ((prefix .. name)):match(pattern) then
            table.insert(names, (prefix .. name))
          end
        elseif (_646_0 == "table") then
        elseif (_656_0 == "table") then
          if not seen[subtbl] then
            local _648_
            local _658_
            do
              seen[subtbl] = true
              _648_ = seen
              _658_ = seen
            end
            apropos_2a(pattern, subtbl, (prefix .. name:gsub("%.", "/") .. "."), _648_, names)
            apropos_2a(pattern, subtbl, (prefix .. name:gsub("%.", "/") .. "."), _658_, names)
          end
        end
      end


@@ 510,10 521,10 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    return tbl_17_
  end
  commands.apropos = function(_env, read, on_values, on_error, _scope)
    local function _653_(_241)
    local function _663_(_241)
      return on_values(apropos(tostring(_241)))
    end
    return run_command(read, on_error, _653_)
    return run_command(read, on_error, _663_)
  end
  do end (compiler.metadata):set(commands.apropos, "fnl/docstring", "Print all functions matching a pattern in all loaded modules.")
  local function apropos_follow_path(path)


@@ 533,12 544,12 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    local tgt = package.loaded
    for _, path0 in ipairs(paths) do
      if (nil == tgt) then break end
      local _656_
      local _666_
      do
        local _655_0 = path0:gsub("%/", ".")
        _656_ = _655_0
        local _665_0 = path0:gsub("%/", ".")
        _666_ = _665_0
      end
      tgt = tgt[_656_]
      tgt = tgt[_666_]
    end
    return tgt
  end


@@ 550,9 561,9 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
      do
        local tgt = apropos_follow_path(path)
        if ("function" == type(tgt)) then
          local _657_0 = (compiler.metadata):get(tgt, "fnl/docstring")
          if (nil ~= _657_0) then
            local docstr = _657_0
          local _667_0 = (compiler.metadata):get(tgt, "fnl/docstring")
          if (nil ~= _667_0) then
            local docstr = _667_0
            val_19_ = (docstr:match(pattern) and path)
          else
          val_19_ = nil


@@ 569,125 580,125 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    return tbl_17_
  end
  commands["apropos-doc"] = function(_env, read, on_values, on_error, _scope)
    local function _661_(_241)
    local function _671_(_241)
      return on_values(apropos_doc(tostring(_241)))
    end
    return run_command(read, on_error, _661_)
    return run_command(read, on_error, _671_)
  end
  do end (compiler.metadata):set(commands["apropos-doc"], "fnl/docstring", "Print all functions that match the pattern in their docs")
  local function apropos_show_docs(on_values, pattern)
    for _, path in ipairs(apropos(pattern)) do
      local tgt = apropos_follow_path(path)
      if (("function" == type(tgt)) and (compiler.metadata):get(tgt, "fnl/docstring")) then
        on_values(specials.doc(tgt, path))
        on_values()
        on_values({specials.doc(tgt, path)})
        on_values({})
      end
    end
    return nil
  end
  commands["apropos-show-docs"] = function(_env, read, on_values, on_error)
    local function _663_(_241)
    local function _673_(_241)
      return apropos_show_docs(on_values, tostring(_241))
    end
    return run_command(read, on_error, _663_)
    return run_command(read, on_error, _673_)
  end
  do end (compiler.metadata):set(commands["apropos-show-docs"], "fnl/docstring", "Print all documentations matching a pattern in function name")
  local function resolve(identifier, _664_0, scope)
    local _665_ = _664_0
    local env = _665_
    local ___replLocals___ = _665_["___replLocals___"]
  local function resolve(identifier, _674_0, scope)
    local _675_ = _674_0
    local env = _675_
    local ___replLocals___ = _675_["___replLocals___"]
    local e = nil
    local function _666_(_241, _242)
    local function _676_(_241, _242)
      return (___replLocals___[scope.unmanglings[_242]] or env[_242])
    end
    e = setmetatable({}, {__index = _666_})
    local function _667_(...)
      local _668_0, _669_0 = ...
      if ((_668_0 == true) and (nil ~= _669_0)) then
        local code = _669_0
        local function _670_(...)
          local _671_0, _672_0 = ...
          if ((_671_0 == true) and (nil ~= _672_0)) then
            local val = _672_0
    e = setmetatable({}, {__index = _676_})
    local function _677_(...)
      local _678_0, _679_0 = ...
      if ((_678_0 == true) and (nil ~= _679_0)) then
        local code = _679_0
        local function _680_(...)
          local _681_0, _682_0 = ...
          if ((_681_0 == true) and (nil ~= _682_0)) then
            local val = _682_0
            return val
          else
            local _ = _671_0
            local _ = _681_0
            return nil
          end
        end
        return _670_(pcall(specials["load-code"](code, e)))
        return _680_(pcall(specials["load-code"](code, e)))
      else
        local _ = _668_0
        local _ = _678_0
        return nil
      end
    end
    return _667_(pcall(compiler["compile-string"], tostring(identifier), {scope = scope}))
    return _677_(pcall(compiler["compile-string"], tostring(identifier), {scope = scope}))
  end
  commands.find = function(env, read, on_values, on_error, scope)
    local function _675_(_241)
      local _676_0 = nil
    local function _685_(_241)
      local _686_0 = nil
      do
        local _677_0 = utils["sym?"](_241)
        if (nil ~= _677_0) then
          local _678_0 = resolve(_677_0, env, scope)
          if (nil ~= _678_0) then
            _676_0 = debug.getinfo(_678_0)
        local _687_0 = utils["sym?"](_241)
        if (nil ~= _687_0) then
          local _688_0 = resolve(_687_0, env, scope)
          if (nil ~= _688_0) then
            _686_0 = debug.getinfo(_688_0)
          else
            _676_0 = _678_0
            _686_0 = _688_0
          end
        else
          _676_0 = _677_0
          _686_0 = _687_0
        end
      end
      if ((_G.type(_676_0) == "table") and (nil ~= _676_0.linedefined) and (nil ~= _676_0.short_src) and (nil ~= _676_0.source) and (_676_0.what == "Lua")) then
        local line = _676_0.linedefined
        local src = _676_0.short_src
        local source = _676_0.source
      if ((_G.type(_686_0) == "table") and (nil ~= _686_0.linedefined) and (nil ~= _686_0.short_src) and (nil ~= _686_0.source) and (_686_0.what == "Lua")) then
        local line = _686_0.linedefined
        local src = _686_0.short_src
        local source = _686_0.source
        local fnlsrc = nil
        do
          local _681_0 = compiler.sourcemap
          if (nil ~= _681_0) then
            _681_0 = _681_0[source]
          local _691_0 = compiler.sourcemap
          if (nil ~= _691_0) then
            _691_0 = _691_0[source]
          end
          if (nil ~= _681_0) then
            _681_0 = _681_0[line]
          if (nil ~= _691_0) then
            _691_0 = _691_0[line]
          end
          if (nil ~= _681_0) then
            _681_0 = _681_0[2]
          if (nil ~= _691_0) then
            _691_0 = _691_0[2]
          end
          fnlsrc = _681_0
          fnlsrc = _691_0
        end
        return on_values({string.format("%s:%s", src, (fnlsrc or line))})
      elseif (_676_0 == nil) then
      elseif (_686_0 == nil) then
        return on_error("Repl", "Unknown value")
      else
        local _ = _676_0
        local _ = _686_0
        return on_error("Repl", "No source info")
      end
    end
    return run_command(read, on_error, _675_)
    return run_command(read, on_error, _685_)
  end
  do end (compiler.metadata):set(commands.find, "fnl/docstring", "Print the filename and line number for a given function")
  commands.doc = function(env, read, on_values, on_error, scope)
    local function _686_(_241)
    local function _696_(_241)
      local name = tostring(_241)
      local path = (utils["multi-sym?"](name) or {name})
      local ok_3f, target = nil, nil
      local function _687_()
      local function _697_()
        return (utils["get-in"](scope.specials, path) or utils["get-in"](scope.macros, path) or resolve(name, env, scope))
      end
      ok_3f, target = pcall(_687_)
      ok_3f, target = pcall(_697_)
      if ok_3f then
        return on_values({specials.doc(target, name)})
      else
        return on_error("Repl", ("Could not find " .. name .. " for docs."))
      end
    end
    return run_command(read, on_error, _686_)
    return run_command(read, on_error, _696_)
  end
  do end (compiler.metadata):set(commands.doc, "fnl/docstring", "Print the docstring and arglist for a function, macro, or special form.")
  commands.compile = function(env, read, on_values, on_error, scope)
    local function _689_(_241)
    local function _699_(_241)
      local allowedGlobals = specials["current-global-names"](env)
      local ok_3f, result = pcall(compiler.compile, _241, {allowedGlobals = allowedGlobals, env = env, scope = scope})
      if ok_3f then


@@ 696,16 707,16 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
        return on_error("Repl", ("Error compiling expression: " .. result))
      end
    end
    return run_command(read, on_error, _689_)
    return run_command(read, on_error, _699_)
  end
  do end (compiler.metadata):set(commands.compile, "fnl/docstring", "compiles the expression into lua and prints the result.")
  local function load_plugin_commands(plugins)
    for _, plugin in ipairs((plugins or {})) do
      for name, f in pairs(plugin) do
        local _691_0 = name:match("^repl%-command%-(.*)")
        if (nil ~= _691_0) then
          local cmd_name = _691_0
          commands[cmd_name] = (commands[cmd_name] or f)
    for i = #(plugins or {}), 1, -1 do
      for name, f in pairs(plugins[i]) do
        local _701_0 = name:match("^repl%-command%-(.*)")
        if (nil ~= _701_0) then
          local cmd_name = _701_0
          commands[cmd_name] = f
        end
      end
    end


@@ 714,19 725,19 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
  local function run_command_loop(input, read, loop, env, on_values, on_error, scope, chars)
    local command_name = input:match(",([^%s/]+)")
    do
      local _693_0 = commands[command_name]
      if (nil ~= _693_0) then
        local command = _693_0
      local _703_0 = commands[command_name]
      if (nil ~= _703_0) then
        local command = _703_0
        command(env, read, on_values, on_error, scope, chars)
      else
        local _ = _693_0
        if ("exit" ~= command_name) then
        local _ = _703_0
        if ((command_name ~= "exit") and (command_name ~= "return")) then
          on_values({"Unknown command", command_name})
        end
      end
    end
    if ("exit" ~= command_name) then
      return loop()
      return loop((command_name == "return"))
    end
  end
  local function try_readline_21(opts, ok, readline)


@@ 769,9 780,9 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
  end
  local function repl(_3foptions)
    local old_root_options = utils.root.options
    local _702_ = utils.copy(_3foptions)
    local opts = _702_
    local _3ffennelrc = _702_["fennelrc"]
    local _712_ = utils.copy(_3foptions)
    local opts = _712_
    local _3ffennelrc = _712_["fennelrc"]
    local _ = nil
    opts.fennelrc = nil
    _ = nil


@@ 786,35 797,42 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    local callbacks = {env = env, onError = (opts.onError or default_on_error), onValues = (opts.onValues or default_on_values), pp = (opts.pp or view), readChunk = (opts.readChunk or default_read_chunk)}
    local save_locals_3f = (opts.saveLocals ~= false)
    local byte_stream, clear_stream = nil, nil
    local function _704_(_241)
    local function _714_(_241)
      return callbacks.readChunk(_241)
    end
    byte_stream, clear_stream = parser.granulate(_704_)
    byte_stream, clear_stream = parser.granulate(_714_)
    local chars = {}
    local read, reset = nil, nil
    local function _705_(parser_state)
    local function _715_(parser_state)
      local b = byte_stream(parser_state)
      if b then
        table.insert(chars, string.char(b))
      end
      return b
    end
    read, reset = parser.parser(_705_)
    read, reset = parser.parser(_715_)
    depth = (depth + 1)
    if opts.message then
      callbacks.onValues({opts.message})
    end
    env.___repl___ = callbacks
    opts.env, opts.scope = env, compiler["make-scope"]()
    opts.useMetadata = (opts.useMetadata ~= false)
    if (opts.allowedGlobals == nil) then
      opts.allowedGlobals = specials["current-global-names"](env)
    end
    if opts.init then
      opts.init(opts, depth)
    end
    if opts.registerCompleter then
      local function _709_()
        local _708_0 = opts.scope
        local function _710_(...)
          return completer(env, _708_0, ...)
      local function _721_()
        local _720_0 = opts.scope
        local function _722_(...)
          return completer(env, _720_0, ...)
        end
        return _710_
        return _722_
      end
      opts.registerCompleter(_709_())
      opts.registerCompleter(_721_())
    end
    load_plugin_commands(opts.plugins)
    if save_locals_3f then


@@ 835,12 853,21 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
      end
      return callbacks.onValues(out)
    end
    local function loop()
    local function save_value(...)
      env.___replLocals___["*3"] = env.___replLocals___["*2"]
      env.___replLocals___["*2"] = env.___replLocals___["*1"]
      env.___replLocals___["*1"] = ...
      return ...
    end
    opts.scope.manglings["*1"], opts.scope.unmanglings._1 = "_1", "*1"
    opts.scope.manglings["*2"], opts.scope.unmanglings._2 = "_2", "*2"
    opts.scope.manglings["*3"], opts.scope.unmanglings._3 = "_3", "*3"
    local function loop(exit_next_3f)
      for k in pairs(chars) do
        chars[k] = nil
      end
      reset()
      local ok, parser_not_eof_3f, x = pcall(read)
      local ok, parser_not_eof_3f, form = pcall(read)
      local src_string = table.concat(chars)
      local readline_not_eof_3f = (not readline or (src_string ~= "(null)"))
      local not_eof_3f = (readline_not_eof_3f and parser_not_eof_3f)


@@ 852,54 879,71 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
        return run_command_loop(src_string, read, loop, env, callbacks.onValues, callbacks.onError, opts.scope, chars)
      else
        if not_eof_3f then
          do
            local _714_0, _715_0 = nil, nil
            local function _716_()
              opts["source"] = src_string
              return opts
            end
            _714_0, _715_0 = pcall(compiler.compile, x, _716_())
            if ((_714_0 == false) and (nil ~= _715_0)) then
              local msg = _715_0
              clear_stream()
              callbacks.onError("Compile", msg)
            elseif ((_714_0 == true) and (nil ~= _715_0)) then
              local src = _715_0
              local src0 = nil
              if save_locals_3f then
                src0 = splice_save_locals(env, src, opts.scope)
              else
                src0 = src
              end
              local _718_0, _719_0 = pcall(specials["load-code"], src0, env)
              if ((_718_0 == false) and (nil ~= _719_0)) then
                local msg = _719_0
                clear_stream()
                callbacks.onError("Lua Compile", msg, src0)
              elseif (true and (nil ~= _719_0)) then
                local _1 = _718_0
                local chunk = _719_0
                local function _720_()
                  return print_values(chunk())
          local function _726_(...)
            local _727_0, _728_0 = ...
            if ((_727_0 == true) and (nil ~= _728_0)) then
              local src = _728_0
              local function _729_(...)
                local _730_0, _731_0 = ...
                if ((_730_0 == true) and (nil ~= _731_0)) then
                  local chunk = _731_0
                  local function _732_()
                    return print_values(save_value(chunk()))
                  end
                  local function _733_(...)
                    return callbacks.onError("Runtime", ...)
                  end
                  return xpcall(_732_, _733_)
                elseif ((_730_0 == false) and (nil ~= _731_0)) then
                  local msg = _731_0
                  clear_stream()
                  return callbacks.onError("Compile", msg)
                end
                local function _721_(...)
                  return callbacks.onError("Runtime", ...)
              end
              local function _736_(...)
                local src0 = nil
                if save_locals_3f then
                  src0 = splice_save_locals(env, src, opts.scope)
                else
                  src0 = src
                end
                xpcall(_720_, _721_)
                return pcall(specials["load-code"], src0, env)
              end
              return _729_(_736_(...))
            elseif ((_727_0 == false) and (nil ~= _728_0)) then
              local msg = _728_0
              clear_stream()
              return callbacks.onError("Compile", msg)
            end
          end
          local function _738_()
            opts["source"] = src_string
            return opts
          end
          _726_(pcall(compiler.compile, form, _738_()))
          utils.root.options = old_root_options
          return loop()
          if exit_next_3f then
            return env.___replLocals___["*1"]
          else
            return loop()
          end
        end
      end
    end
    loop()
    local value = loop()
    depth = (depth - 1)
    if readline then
      return readline.save_history()
      readline.save_history()
    end
    if opts.exit then
      opts.exit(opts, depth)
    end
    return value
  end
  return repl
  local function _744_(overrides, _3fopts)
    return repl(utils.copy(_3fopts, utils.copy(overrides)))
  end
  return setmetatable({}, {__call = _744_, __index = {repl = repl}})
end
package.preload["fennel.specials"] = package.preload["fennel.specials"] or function(...)
  local utils = require("fennel.utils")


@@ 909,14 953,14 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  local unpack = (table.unpack or _G.unpack)
  local SPECIALS = compiler.scopes.global.specials
  local function wrap_env(env)
    local function _415_(_, key)
    local function _420_(_, key)
      if utils["string?"](key) then
        return env[compiler["global-unmangling"](key)]
      else
        return env[key]
      end
    end
    local function _417_(_, key, value)
    local function _422_(_, key, value)
      if utils["string?"](key) then
        env[compiler["global-unmangling"](key)] = value
        return nil


@@ 925,26 969,29 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
        return nil
      end
    end
    local function _419_()
    local function _424_()
      local function putenv(k, v)
        local _420_
        local _425_
        if utils["string?"](k) then
          _420_ = compiler["global-unmangling"](k)
          _425_ = compiler["global-unmangling"](k)
        else
          _420_ = k
          _425_ = k
        end
        return _420_, v
        return _425_, v
      end
      return next, utils.kvmap(env, putenv), nil
    end
    return setmetatable({}, {__index = _415_, __newindex = _417_, __pairs = _419_})
    return setmetatable({}, {__index = _420_, __newindex = _422_, __pairs = _424_})
  end
  local function fennel_module_name()
    return (utils.root.options.moduleName or "fennel")
  end
  local function current_global_names(_3fenv)
    local mt = nil
    do
      local _422_0 = getmetatable(_3fenv)
      if ((_G.type(_422_0) == "table") and (nil ~= _422_0.__pairs)) then
        local mtpairs = _422_0.__pairs
      local _427_0 = getmetatable(_3fenv)
      if ((_G.type(_427_0) == "table") and (nil ~= _427_0.__pairs)) then
        local mtpairs = _427_0.__pairs
        local tbl_14_ = {}
        for k, v in mtpairs(_3fenv) do
          local k_15_, v_16_ = k, v


@@ 953,7 1000,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
          end
        end
        mt = tbl_14_
      elseif (_422_0 == nil) then
      elseif (_427_0 == nil) then
        mt = (_3fenv or _G)
      else
      mt = nil


@@ 963,15 1010,15 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  end
  local function load_code(code, _3fenv, _3ffilename)
    local env = (_3fenv or rawget(_G, "_ENV") or _G)
    local _425_0, _426_0 = rawget(_G, "setfenv"), rawget(_G, "loadstring")
    if ((nil ~= _425_0) and (nil ~= _426_0)) then
      local setfenv = _425_0
      local loadstring = _426_0
    local _430_0, _431_0 = rawget(_G, "setfenv"), rawget(_G, "loadstring")
    if ((nil ~= _430_0) and (nil ~= _431_0)) then
      local setfenv = _430_0
      local loadstring = _431_0
      local f = assert(loadstring(code, _3ffilename))
      setfenv(f, env)
      return f
    else
      local _ = _425_0
      local _ = _430_0
      return assert(load(code, _3ffilename, "t", env))
    end
  end


@@ 983,13 1030,13 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
      local mt = getmetatable(tgt)
      if ((type(tgt) == "function") or ((type(mt) == "table") and (type(mt.__call) == "function"))) then
        local arglist = table.concat(((compiler.metadata):get(tgt, "fnl/arglist") or {"#<unknown-arguments>"}), " ")
        local _428_
        local _433_
        if (0 < #arglist) then
          _428_ = " "
          _433_ = " "
        else
          _428_ = ""
          _433_ = ""
        end
        return string.format("(%s%s%s)\n  %s", name, _428_, arglist, docstring)
        return string.format("(%s%s%s)\n  %s", name, _433_, arglist, docstring)
      else
        return string.format("%s\n  %s", name, docstring)
      end


@@ 1014,17 1061,14 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    local chunk = (_3fchunk or {})
    local len = #ast
    local retexprs = {returned = true}
    utils.hook("pre-do", ast, sub_scope)
    local function compile_body(outer_target, outer_tail, outer_retexprs)
      if (len < start) then
        compiler.compile1(nil, sub_scope, chunk, {tail = outer_tail, target = outer_target})
      else
        for i = start, len do
          local subopts = {nval = (((i ~= len) and 0) or opts.nval), tail = (((i == len) and outer_tail) or nil), target = (((i == len) and outer_target) or nil)}
          local _ = utils["propagate-options"](opts, subopts)
          local subexprs = compiler.compile1(ast[i], sub_scope, chunk, subopts)
          if (i ~= len) then
            compiler["keep-side-effects"](subexprs, parent, nil, ast[i])
          end
      for i = start, len do
        local subopts = {nval = (((i ~= len) and 0) or opts.nval), tail = (((i == len) and outer_tail) or nil), target = (((i == len) and outer_target) or nil)}
        local _ = utils["propagate-options"](opts, subopts)
        local subexprs = compiler.compile1(ast[i], sub_scope, chunk, subopts)
        if (i ~= len) then
          compiler["keep-side-effects"](subexprs, parent, nil, ast[i])
        end
      end
      compiler.emit(parent, chunk, ast)


@@ 1102,9 1146,9 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    local opts = {nval = 1, tail = false}
    local scope = compiler["make-scope"]()
    local chunk = {}
    local _439_ = compiler.compile1(v, scope, chunk, opts)
    local _440_ = _439_[1]
    local v0 = _440_[1]
    local _443_ = compiler.compile1(v, scope, chunk, opts)
    local _444_ = _443_[1]
    local v0 = _444_[1]
    return v0
  end
  local function insert_meta(meta, k, v)


@@ 1112,23 1156,23 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    compiler.assert((type(k) == "string"), ("expected string keys in metadata table, got: %s"):format(view(k, view_opts)))
    compiler.assert(literal_3f(v), ("expected literal value in metadata table, got: %s %s"):format(view(k, view_opts), view(v, view_opts)))
    table.insert(meta, view(k))
    local function _441_()
    local function _445_()
      if ("string" == type(v)) then
        return view(v, view_opts)
      else
        return compile_value(v)
      end
    end
    table.insert(meta, _441_())
    table.insert(meta, _445_())
    return meta
  end
  local function insert_arglist(meta, arg_list)
    local view_opts = {["escape-newlines?"] = true, ["line-length"] = math.huge, ["one-line?"] = true}
    table.insert(meta, "\"fnl/arglist\"")
    local function _442_(_241)
    local function _446_(_241)
      return view(view(_241, view_opts))
    end
    table.insert(meta, ("{" .. table.concat(utils.map(arg_list, _442_), ", ") .. "}"))
    table.insert(meta, ("{" .. table.concat(utils.map(arg_list, _446_), ", ") .. "}"))
    return meta
  end
  local function set_fn_metadata(f_metadata, parent, fn_name)


@@ 1141,34 1185,35 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
          insert_meta(meta_fields, k, v)
        end
      end
      local meta_str = ("require(\"%s\").metadata"):format((utils.root.options.moduleName or "fennel"))
      local meta_str = ("require(\"%s\").metadata"):format(fennel_module_name())
      return compiler.emit(parent, ("pcall(function() %s:setall(%s, %s) end)"):format(meta_str, fn_name, table.concat(meta_fields, ", ")))
    end
  end
  local function get_fn_name(ast, scope, fn_name, multi)
    if (fn_name and (fn_name[1] ~= "nil")) then
      local _445_
      local _449_
      if not multi then
        _445_ = compiler["declare-local"](fn_name, {}, scope, ast)
        _449_ = compiler["declare-local"](fn_name, {}, scope, ast)
      else
        _445_ = compiler["symbol-to-expression"](fn_name, scope)[1]
        _449_ = compiler["symbol-to-expression"](fn_name, scope)[1]
      end
      return _445_, not multi, 3
      return _449_, not multi, 3
    else
      return nil, true, 2
    end
  end
  local function compile_named_fn(ast, f_scope, f_chunk, parent, index, fn_name, local_3f, arg_name_list, f_metadata)
    utils.hook("pre-fn", ast, f_scope)
    for i = (index + 1), #ast do
      compiler.compile1(ast[i], f_scope, f_chunk, {nval = (((i ~= #ast) and 0) or nil), tail = (i == #ast)})
    end
    local _448_
    local _452_
    if local_3f then
      _448_ = "local function %s(%s)"
      _452_ = "local function %s(%s)"
    else
      _448_ = "%s = function(%s)"
      _452_ = "%s = function(%s)"
    end
    compiler.emit(parent, string.format(_448_, fn_name, table.concat(arg_name_list, ", ")), ast)
    compiler.emit(parent, string.format(_452_, fn_name, table.concat(arg_name_list, ", ")), ast)
    compiler.emit(parent, f_chunk, ast)
    compiler.emit(parent, "end", ast)
    set_fn_metadata(f_metadata, parent, fn_name)


@@ 1190,7 1235,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    end
  end
  local function get_function_metadata(ast, arg_list, index)
    local function _451_(_241, _242)
    local function _455_(_241, _242)
      local tbl_14_ = _241
      for k, v in pairs(_242) do
        local k_15_, v_16_ = k, v


@@ 1200,18 1245,18 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
      end
      return tbl_14_
    end
    local function _453_(_241, _242)
    local function _457_(_241, _242)
      _241["fnl/docstring"] = _242
      return _241
    end
    return maybe_metadata(ast, utils["kv-table?"], _451_, maybe_metadata(ast, utils["string?"], _453_, {["fnl/arglist"] = arg_list}, index))
    return maybe_metadata(ast, utils["kv-table?"], _455_, maybe_metadata(ast, utils["string?"], _457_, {["fnl/arglist"] = arg_list}, index))
  end
  SPECIALS.fn = function(ast, scope, parent)
    local f_scope = nil
    do
      local _454_0 = compiler["make-scope"](scope)
      _454_0["vararg"] = false
      f_scope = _454_0
      local _458_0 = compiler["make-scope"](scope)
      _458_0["vararg"] = false
      f_scope = _458_0
    end
    local f_chunk = {}
    local fn_sym = utils["sym?"](ast[2])


@@ 1271,36 1316,37 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  doc_special("fn", {"name?", "args", "docstring?", "..."}, "Function syntax. May optionally include a name and docstring or a metadata table.\nIf a name is provided, the function will be bound in the current scope.\nWhen called with the wrong number of args, excess args will be discarded\nand lacking args will be nil, use lambda for arity-checked functions.", true)
  SPECIALS.lua = function(ast, _, parent)
    compiler.assert(((#ast == 2) or (#ast == 3)), "expected 1 or 2 arguments", ast)
    local _459_
    local _463_
    do
      local _458_0 = utils["sym?"](ast[2])
      if (nil ~= _458_0) then
        _459_ = tostring(_458_0)
      local _462_0 = utils["sym?"](ast[2])
      if (nil ~= _462_0) then
        _463_ = tostring(_462_0)
      else
        _459_ = _458_0
        _463_ = _462_0
      end
    end
    if ("nil" ~= _459_) then
    if ("nil" ~= _463_) then
      table.insert(parent, {ast = ast, leaf = tostring(ast[2])})
    end
    local _463_
    local _467_
    do
      local _462_0 = utils["sym?"](ast[3])
      if (nil ~= _462_0) then
        _463_ = tostring(_462_0)
      local _466_0 = utils["sym?"](ast[3])
      if (nil ~= _466_0) then
        _467_ = tostring(_466_0)
      else
        _463_ = _462_0
        _467_ = _466_0
      end
    end
    if ("nil" ~= _463_) then
    if ("nil" ~= _467_) then
      return tostring(ast[3])
    end
  end
  local function dot(ast, scope, parent)
    compiler.assert((1 < #ast), "expected table argument", ast)
    local len = #ast
    local _466_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
    local lhs = _466_[1]
    local lhs_node = compiler.macroexpand(ast[2], scope)
    local _470_ = compiler.compile1(lhs_node, scope, parent, {nval = 1})
    local lhs = _470_[1]
    if (len == 2) then
      return tostring(lhs)
    else


@@ 1310,12 1356,12 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
        if (utils["string?"](index) and utils["valid-lua-identifier?"](index)) then
          table.insert(indices, ("." .. index))
        else
          local _467_ = compiler.compile1(index, scope, parent, {nval = 1})
          local index0 = _467_[1]
          local _471_ = compiler.compile1(index, scope, parent, {nval = 1})
          local index0 = _471_[1]
          table.insert(indices, ("[" .. tostring(index0) .. "]"))
        end
      end
      if (tostring(lhs):find("[{\"0-9]") or ("nil" == tostring(lhs))) then
      if (not (utils["sym?"](lhs_node) or utils["list?"](lhs_node)) or ("nil" == tostring(lhs_node))) then
        return ("(" .. tostring(lhs) .. ")" .. table.concat(indices))
      else
        return (tostring(lhs) .. table.concat(indices))


@@ 1356,7 1402,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  end
  doc_special("var", {"name", "val"}, "Introduce new mutable local.")
  local function kv_3f(t)
    local _471_
    local _475_
    do
      local tbl_17_ = {}
      local i_18_ = #tbl_17_


@@ 1372,9 1418,9 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
          tbl_17_[i_18_] = val_19_
        end
      end
      _471_ = tbl_17_
      _475_ = tbl_17_
    end
    return _471_[1]
    return _475_[1]
  end
  SPECIALS.let = function(ast, scope, parent, opts)
    local bindings = ast[2]


@@ 1401,22 1447,22 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    end
  end
  local function disambiguate_3f(rootstr, parent)
    local function _476_()
      local _475_0 = get_prev_line(parent)
      if (nil ~= _475_0) then
        local prev_line = _475_0
    local function _480_()
      local _479_0 = get_prev_line(parent)
      if (nil ~= _479_0) then
        local prev_line = _479_0
        return prev_line:match("%)$")
      end
    end
    return (rootstr:match("^{") or rootstr:match("^%(") or _476_())
    return (rootstr:match("^{") or rootstr:match("^%(") or _480_())
  end
  SPECIALS.tset = function(ast, scope, parent)
    compiler.assert((3 < #ast), "expected table, key, and value arguments", ast)
    local root = compiler.compile1(ast[2], scope, parent, {nval = 1})[1]
    local keys = {}
    for i = 3, (#ast - 1) do
      local _478_ = compiler.compile1(ast[i], scope, parent, {nval = 1})
      local key = _478_[1]
      local _482_ = compiler.compile1(ast[i], scope, parent, {nval = 1})
      local key = _482_[1]
      table.insert(keys, tostring(key))
    end
    local value = compiler.compile1(ast[#ast], scope, parent, {nval = 1})[1]


@@ 1430,7 1476,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    return compiler.emit(parent, fmtstr:format(rootstr, table.concat(keys, "]["), tostring(value)), ast)
  end
  doc_special("tset", {"tbl", "key1", "...", "keyN", "val"}, "Set the value of a table field. Can take additional keys to set\nnested values, but all parents must contain an existing table.")
  local function calculate_target(scope, opts)
  local function calculate_if_target(scope, opts)
    if not (opts.tail or opts.target or opts.nval) then
      return "iife", true, nil
    elseif (opts.nval and (opts.nval ~= 0) and not opts.target) then


@@ 1448,111 1494,142 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  end
  local function if_2a(ast, scope, parent, opts)
    compiler.assert((2 < #ast), "expected condition and body", ast)
    local do_scope = compiler["make-scope"](scope)
    local branches = {}
    local wrapper, inner_tail, inner_target, target_exprs = calculate_target(scope, opts)
    local body_opts = {nval = opts.nval, tail = inner_tail, target = inner_target}
    local function compile_body(i)
      local chunk = {}
      local cscope = compiler["make-scope"](do_scope)
      compiler["keep-side-effects"](compiler.compile1(ast[i], cscope, chunk, body_opts), chunk, nil, ast[i])
      return {chunk = chunk, scope = cscope}
    if ((1 == (#ast % 2)) and (ast[(#ast - 1)] == true)) then
      table.remove(ast, (#ast - 1))
    end
    if (1 == (#ast % 2)) then
      table.insert(ast, utils.sym("nil"))
    end
    for i = 2, (#ast - 1), 2 do
      local condchunk = {}
      local res = compiler.compile1(ast[i], do_scope, condchunk, {nval = 1})
      local cond = res[1]
      local branch = compile_body((i + 1))
      branch.cond = cond
      branch.condchunk = condchunk
      branch.nested = ((i ~= 2) and (next(condchunk, nil) == nil))
      table.insert(branches, branch)
    end
    local else_branch = compile_body(#ast)
    local s = compiler.gensym(scope)
    local buffer = {}
    local last_buffer = buffer
    for i = 1, #branches do
      local branch = branches[i]
      local fstr = nil
      if not branch.nested then
        fstr = "if %s then"
      else
        fstr = "elseif %s then"
      end
      local cond = tostring(branch.cond)
      local cond_line = fstr:format(cond)
      if branch.nested then
        compiler.emit(last_buffer, branch.condchunk, ast)
      else
        for _, v in ipairs(branch.condchunk) do
          compiler.emit(last_buffer, v, ast)
        end
      end
      compiler.emit(last_buffer, cond_line, ast)
      compiler.emit(last_buffer, branch.chunk, ast)
      if (i == #branches) then
        compiler.emit(last_buffer, "else", ast)
        compiler.emit(last_buffer, else_branch.chunk, ast)
        compiler.emit(last_buffer, "end", ast)
      elseif not branches[(i + 1)].nested then
        local next_buffer = {}
        compiler.emit(last_buffer, "else", ast)
        compiler.emit(last_buffer, next_buffer, ast)
        compiler.emit(last_buffer, "end", ast)
        last_buffer = next_buffer
      end
    end
    if (wrapper == "iife") then
      local iifeargs = ((scope.vararg and "...") or "")
      compiler.emit(parent, ("local function %s(%s)"):format(tostring(s), iifeargs), ast)
      compiler.emit(parent, buffer, ast)
      compiler.emit(parent, "end", ast)
      return utils.expr(("%s(%s)"):format(tostring(s), iifeargs), "statement")
    elseif (wrapper == "none") then
      for i = 1, #buffer do
        compiler.emit(parent, buffer[i], ast)
      end
      return {returned = true}
    if (#ast == 2) then
      return SPECIALS["do"](utils.list(utils.sym("do"), ast[2]), scope, parent, opts)
    else
      compiler.emit(parent, ("local %s"):format(inner_target), ast)
      for i = 1, #buffer do
        compiler.emit(parent, buffer[i], ast)
      local do_scope = compiler["make-scope"](scope)
      local branches = {}
      local wrapper, inner_tail, inner_target, target_exprs = calculate_if_target(scope, opts)
      local body_opts = {nval = opts.nval, tail = inner_tail, target = inner_target}
      local function compile_body(i)
        local chunk = {}
        local cscope = compiler["make-scope"](do_scope)
        compiler["keep-side-effects"](compiler.compile1(ast[i], cscope, chunk, body_opts), chunk, nil, ast[i])
        return {chunk = chunk, scope = cscope}
      end
      for i = 2, (#ast - 1), 2 do
        local condchunk = {}
        local res = compiler.compile1(ast[i], do_scope, condchunk, {nval = 1})
        local cond = res[1]
        local branch = compile_body((i + 1))
        branch.cond = cond
        branch.condchunk = condchunk
        branch.nested = ((i ~= 2) and (next(condchunk, nil) == nil))
        table.insert(branches, branch)
      end
      local else_branch = compile_body(#ast)
      local s = compiler.gensym(scope)
      local buffer = {}
      local last_buffer = buffer
      for i = 1, #branches do
        local branch = branches[i]
        local fstr = nil
        if not branch.nested then
          fstr = "if %s then"
        else
          fstr = "elseif %s then"
        end
        local cond = tostring(branch.cond)
        local cond_line = fstr:format(cond)
        if branch.nested then
          compiler.emit(last_buffer, branch.condchunk, ast)
        else
          for _, v in ipairs(branch.condchunk) do
            compiler.emit(last_buffer, v, ast)
          end
        end
        compiler.emit(last_buffer, cond_line, ast)
        compiler.emit(last_buffer, branch.chunk, ast)
        if (i == #branches) then
          compiler.emit(last_buffer, "else", ast)
          compiler.emit(last_buffer, else_branch.chunk, ast)
          compiler.emit(last_buffer, "end", ast)
        elseif not branches[(i + 1)].nested then
          local next_buffer = {}
          compiler.emit(last_buffer, "else", ast)
          compiler.emit(last_buffer, next_buffer, ast)
          compiler.emit(last_buffer, "end", ast)
          last_buffer = next_buffer
        end
      end
      if (wrapper == "iife") then
        local iifeargs = ((scope.vararg and "...") or "")
        compiler.emit(parent, ("local function %s(%s)"):format(tostring(s), iifeargs), ast)
        compiler.emit(parent, buffer, ast)
        compiler.emit(parent, "end", ast)
        return utils.expr(("%s(%s)"):format(tostring(s), iifeargs), "statement")
      elseif (wrapper == "none") then
        for i = 1, #buffer do
          compiler.emit(parent, buffer[i], ast)
        end
        return {returned = true}
      else
        compiler.emit(parent, ("local %s"):format(inner_target), ast)
        for i = 1, #buffer do
          compiler.emit(parent, buffer[i], ast)
        end
        return target_exprs
      end
      return target_exprs
    end
  end
  SPECIALS["if"] = if_2a
  doc_special("if", {"cond1", "body1", "...", "condN", "bodyN"}, "Conditional form.\nTakes any number of condition/body pairs and evaluates the first body where\nthe condition evaluates to truthy. Similar to cond in other lisps.")
  local function remove_until_condition(bindings)
    local last_item = bindings[(#bindings - 1)]
    if ((utils["sym?"](last_item) and (tostring(last_item) == "&until")) or ("until" == last_item)) then
      table.remove(bindings, (#bindings - 1))
      return table.remove(bindings)
    end
  end
  local function compile_until(condition, scope, chunk)
    if condition then
      local _487_ = compiler.compile1(condition, scope, chunk, {nval = 1})
      local condition_lua = _487_[1]
      return compiler.emit(chunk, ("if %s then break end"):format(tostring(condition_lua)), utils.expr(condition, "expression"))
  local function clause_3f(v)
    return (utils["string?"](v) or (utils["sym?"](v) and not utils["multi-sym?"](v) and tostring(v):match("^&(.+)")))
  end
  local function remove_until_condition(bindings, ast)
    local _until = nil
    for i = (#bindings - 1), 3, -1 do
      local _492_0 = clause_3f(bindings[i])
      if ((_492_0 == false) or (_492_0 == nil)) then
      elseif (nil ~= _492_0) then
        local clause = _492_0
        compiler.assert(((clause == "until") and not _until), ("unexpected iterator clause: " .. clause), ast)
        table.remove(bindings, i)
        _until = table.remove(bindings, i)
      end
    end
    return _until
  end
  local function compile_until(_3fcondition, scope, chunk)
    if _3fcondition then
      local _494_ = compiler.compile1(_3fcondition, scope, chunk, {nval = 1})
      local condition_lua = _494_[1]
      return compiler.emit(chunk, ("if %s then break end"):format(tostring(condition_lua)), utils.expr(_3fcondition, "expression"))
    end
  end
  local function iterator_bindings(ast)
    local bindings = utils.copy(ast)
    local _3funtil = remove_until_condition(bindings, ast)
    local iter = table.remove(bindings)
    local bindings0 = nil
    if (1 == #bindings) then
      bindings0 = (utils["list?"](bindings[1]) or bindings)
    else
      for _, b in ipairs(bindings) do
        if utils["list?"](b) then
          utils.warn("unexpected parens in iterator", b)
        end
      end
      bindings0 = bindings
    end
    return bindings0, iter, _3funtil
  end
  SPECIALS.each = function(ast, scope, parent)
    compiler.assert((3 <= #ast), "expected body expression", ast[1])
    compiler.assert(utils["table?"](ast[2]), "expected binding table", ast)
    compiler.assert((2 <= #ast[2]), "expected binding and iterator", ast)
    local binding = setmetatable(utils.copy(ast[2]), getmetatable(ast[2]))
    local until_condition = remove_until_condition(binding)
    local iter = table.remove(binding, #binding)
    local sub_scope = compiler["make-scope"](scope)
    local binding, iter, _3funtil_condition = iterator_bindings(ast[2])
    local destructures = {}
    local new_manglings = {}
    local sub_scope = compiler["make-scope"](scope)
    utils.hook("pre-each", ast, sub_scope, binding, iter, _3funtil_condition)
    local function destructure_binding(v)
      compiler.assert(not utils["string?"](v), ("unexpected iterator clause " .. tostring(v)), binding)
      if utils["sym?"](v) then
        return compiler["declare-local"](v, {}, sub_scope, ast, new_manglings)
      else


@@ 1565,12 1642,13 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    local vals = compiler.compile1(iter, scope, parent)
    local val_names = utils.map(vals, tostring)
    local chunk = {}
    compiler.assert(bind_vars[1], "expected binding and iterator", ast)
    compiler.emit(parent, ("for %s in %s do"):format(table.concat(bind_vars, ", "), table.concat(val_names, ", ")), ast)
    for raw, args in utils.stablepairs(destructures) do
      compiler.destructure(args, raw, ast, sub_scope, chunk, {declaration = true, nomulti = true, symtype = "each"})
    end
    compiler["apply-manglings"](sub_scope, new_manglings, ast)
    compile_until(until_condition, sub_scope, chunk)
    compile_until(_3funtil_condition, sub_scope, chunk)
    compile_do(ast, sub_scope, chunk, 3)
    compiler.emit(parent, chunk, ast)
    return compiler.emit(parent, "end", ast)


@@ 1600,7 1678,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  local function for_2a(ast, scope, parent)
    compiler.assert(utils["table?"](ast[2]), "expected binding table", ast)
    local ranges = setmetatable(utils.copy(ast[2]), getmetatable(ast[2]))
    local until_condition = remove_until_condition(ranges)
    local until_condition = remove_until_condition(ranges, ast)
    local binding_sym = table.remove(ranges, 1)
    local sub_scope = compiler["make-scope"](scope)
    local range_args = {}


@@ 1609,6 1687,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    compiler.assert((3 <= #ast), "expected body expression", ast[1])
    compiler.assert((#ranges <= 3), "unexpected arguments", ranges)
    compiler.assert((1 < #ranges), "expected range to include start and stop", ranges)
    utils.hook("pre-for", ast, sub_scope, binding_sym)
    for i = 1, math.min(#ranges, 3) do
      range_args[i] = tostring(compiler.compile1(ranges[i], scope, parent, {nval = 1})[1])
    end


@@ 1621,10 1700,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  SPECIALS["for"] = for_2a
  doc_special("for", {"[index start stop step?]", "..."}, "Numeric loop construct.\nEvaluates body once for each value between start and stop (inclusive).", true)
  local function native_method_call(ast, _scope, _parent, target, args)
    local _491_ = ast
    local _ = _491_[1]
    local _0 = _491_[2]
    local method_string = _491_[3]
    local _500_ = ast
    local _ = _500_[1]
    local _0 = _500_[2]
    local method_string = _500_[3]
    local call_string = nil
    if ((target.type == "literal") or (target.type == "varg") or (target.type == "expression")) then
      call_string = "(%s):%s(%s)"


@@ 1646,18 1725,18 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  end
  local function method_call(ast, scope, parent)
    compiler.assert((2 < #ast), "expected at least 2 arguments", ast)
    local _493_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
    local target = _493_[1]
    local _502_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
    local target = _502_[1]
    local args = {}
    for i = 4, #ast do
      local subexprs = nil
      local _494_
      local _503_
      if (i ~= #ast) then
        _494_ = 1
        _503_ = 1
      else
      _494_ = nil
      _503_ = nil
      end
      subexprs = compiler.compile1(ast[i], scope, parent, {nval = _494_})
      subexprs = compiler.compile1(ast[i], scope, parent, {nval = _503_})
      utils.map(subexprs, tostring, args)
    end
    if (utils["string?"](ast[3]) and utils["valid-lua-identifier?"](ast[3])) then


@@ 1672,14 1751,14 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  doc_special(":", {"tbl", "method-name", "..."}, "Call the named method on tbl with the provided args.\nMethod name doesn't have to be known at compile-time; if it is, use\n(tbl:method-name ...) instead.")
  SPECIALS.comment = function(ast, _, parent)
    local c = nil
    local _497_
    local _506_
    do
      local tbl_17_ = {}
      local i_18_ = #tbl_17_
      for i, elt in ipairs(ast) do
        local val_19_ = nil
        if (i ~= 1) then
          val_19_ = view(ast[i], {["one-line?"] = true})
          val_19_ = view(elt, {["one-line?"] = true})
        else
        val_19_ = nil
        end


@@ 1688,9 1767,9 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
          tbl_17_[i_18_] = val_19_
        end
      end
      _497_ = tbl_17_
      _506_ = tbl_17_
    end
    c = table.concat(_497_, " "):gsub("%]%]", "]\\]")
    c = table.concat(_506_, " "):gsub("%]%]", "]\\]")
    return compiler.emit(parent, ("--[[ " .. c .. " ]]"), ast)
  end
  doc_special("comment", {"..."}, "Comment which will be emitted in Lua output.", true)


@@ 1711,10 1790,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    compiler.assert((#ast == 2), "expected one argument", ast)
    local f_scope = nil
    do
      local _502_0 = compiler["make-scope"](scope)
      _502_0["vararg"] = false
      _502_0["hashfn"] = true
      f_scope = _502_0
      local _511_0 = compiler["make-scope"](scope)
      _511_0["vararg"] = false
      _511_0["hashfn"] = true
      f_scope = _511_0
    end
    local f_chunk = {}
    local name = compiler.gensym(scope)


@@ 1755,17 1834,17 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    return utils.expr(name, "sym")
  end
  doc_special("hashfn", {"..."}, "Function literal shorthand; args are either $... OR $1, $2, etc.")
  local function maybe_short_circuit_protect(ast, i, name, _507_0)
    local _508_ = _507_0
    local mac = _508_["macros"]
  local function maybe_short_circuit_protect(ast, i, name, _516_0)
    local _517_ = _516_0
    local mac = _517_["macros"]
    local call = (utils["list?"](ast) and tostring(ast[1]))
    if ((("or" == name) or ("and" == name)) and (1 < i) and (mac[call] or ("set" == call) or ("tset" == call) or ("global" == call))) then
      return utils.list(utils.sym("do"), ast)
      return utils.list(utils.list(utils.sym("fn"), utils.sequence(utils.varg()), ast))
    else
      return ast
    end
  end
  local function arithmetic_special(name, zero_arity, unary_prefix, ast, scope, parent)
  local function operator_special(name, zero_arity, unary_prefix, ast, scope, parent)
    local len = #ast
    local operands = {}
    local padded_op = (" " .. name .. " ")


@@ 1778,15 1857,15 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
        table.insert(operands, tostring(subexprs[1]))
      end
    end
    local _511_0 = #operands
    if (_511_0 == 0) then
      local _512_
    local _520_0 = #operands
    if (_520_0 == 0) then
      local _521_
      do
        compiler.assert(zero_arity, "Expected more than 0 arguments", ast)
        _512_ = zero_arity
        _521_ = zero_arity
      end
      return utils.expr(_512_, "literal")
    elseif (_511_0 == 1) then
      return utils.expr(_521_, "literal")
    elseif (_520_0 == 1) then
      if utils["varg?"](ast[2]) then
        return compiler.assert(false, "tried to use vararg with operator", ast)
      elseif unary_prefix then


@@ 1795,20 1874,20 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
        return operands[1]
      end
    else
      local _ = _511_0
      local _ = _520_0
      return ("(" .. table.concat(operands, padded_op) .. ")")
    end
  end
  local function define_arithmetic_special(name, zero_arity, unary_prefix, _3flua_name)
    local _516_
    local _525_
    do
      local _515_0 = (_3flua_name or name)
      local function _517_(...)
        return arithmetic_special(_515_0, zero_arity, unary_prefix, ...)
      local _524_0 = (_3flua_name or name)
      local function _526_(...)
        return operator_special(_524_0, zero_arity, unary_prefix, ...)
      end
      _516_ = _517_
      _525_ = _526_
    end
    SPECIALS[name] = _516_
    SPECIALS[name] = _525_
    return doc_special(name, {"a", "b", "..."}, "Arithmetic operator; works the same as Lua but accepts more arguments.")
  end
  define_arithmetic_special("+", "0")


@@ 1820,10 1899,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  define_arithmetic_special("/", nil, "1")
  define_arithmetic_special("//", nil, "1")
  SPECIALS["or"] = function(ast, scope, parent)
    return arithmetic_special("or", "false", nil, ast, scope, parent)
    return operator_special("or", "false", nil, ast, scope, parent)
  end
  SPECIALS["and"] = function(ast, scope, parent)
    return arithmetic_special("and", "true", nil, ast, scope, parent)
    return operator_special("and", "true", nil, ast, scope, parent)
  end
  doc_special("and", {"a", "b", "..."}, "Boolean operator; works the same as Lua but accepts more arguments.")
  doc_special("or", {"a", "b", "..."}, "Boolean operator; works the same as Lua but accepts more arguments.")


@@ 1837,13 1916,13 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
      local prefixed_lib_name = ("bit." .. lib_name)
      for i = 2, len do
        local subexprs = nil
        local _518_
        local _527_
        if (i ~= len) then
          _518_ = 1
          _527_ = 1
        else
        _518_ = nil
        _527_ = nil
        end
        subexprs = compiler.compile1(ast[i], scope, parent, {nval = _518_})
        subexprs = compiler.compile1(ast[i], scope, parent, {nval = _527_})
        utils.map(subexprs, tostring, operands)
      end
      if (#operands == 1) then


@@ 1862,15 1941,15 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    end
  end
  local function define_bitop_special(name, zero_arity, unary_prefix, native)
    local function _524_(...)
    local function _533_(...)
      return bitop_special(native, name, zero_arity, unary_prefix, ...)
    end
    SPECIALS[name] = _524_
    SPECIALS[name] = _533_
    return nil
  end
  define_bitop_special("lshift", nil, "1", "<<")
  define_bitop_special("rshift", nil, "1", ">>")
  define_bitop_special("band", "0", "0", "&")
  define_bitop_special("band", "-1", "-1", "&")
  define_bitop_special("bor", "0", "0", "|")
  define_bitop_special("bxor", "0", "0", "~")
  doc_special("lshift", {"x", "n"}, "Bitwise logical left shift of x by n bits.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")


@@ 1880,8 1959,8 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  doc_special("bxor", {"x1", "x2", "..."}, "Bitwise XOR of any number of arguments.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
  SPECIALS.bnot = function(ast, scope, parent)
    compiler.assert((#ast == 2), "expected one argument", ast)
    local _525_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
    local value = _525_[1]
    local _534_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
    local value = _534_[1]
    if utils.root.options.useBitLib then
      return ("bit.bnot(" .. tostring(value) .. ")")
    else


@@ 1890,15 1969,15 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  end
  doc_special("bnot", {"x"}, "Bitwise negation; only works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
  doc_special("..", {"a", "b", "..."}, "String concatenation operator; works the same as Lua but accepts more arguments.")
  local function native_comparator(op, _527_0, scope, parent)
    local _528_ = _527_0
    local _ = _528_[1]
    local lhs_ast = _528_[2]
    local rhs_ast = _528_[3]
    local _529_ = compiler.compile1(lhs_ast, scope, parent, {nval = 1})
    local lhs = _529_[1]
    local _530_ = compiler.compile1(rhs_ast, scope, parent, {nval = 1})
    local rhs = _530_[1]
  local function native_comparator(op, _536_0, scope, parent)
    local _537_ = _536_0
    local _ = _537_[1]
    local lhs_ast = _537_[2]
    local rhs_ast = _537_[3]
    local _538_ = compiler.compile1(lhs_ast, scope, parent, {nval = 1})
    local lhs = _538_[1]
    local _539_ = compiler.compile1(rhs_ast, scope, parent, {nval = 1})
    local rhs = _539_[1]
    return string.format("(%s %s %s)", tostring(lhs), op, tostring(rhs))
  end
  local function idempotent_comparator(op, chain_op, ast, scope, parent)


@@ 2011,21 2090,21 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  end
  local safe_require = nil
  local function safe_compiler_env()
    local _537_
    local _546_
    do
      local _536_0 = rawget(_G, "utf8")
      if (nil ~= _536_0) then
        _537_ = utils.copy(_536_0)
      local _545_0 = rawget(_G, "utf8")
      if (nil ~= _545_0) then
        _546_ = utils.copy(_545_0)
      else
        _537_ = _536_0
        _546_ = _545_0
      end
    end
    return {_VERSION = _VERSION, assert = assert, bit = rawget(_G, "bit"), error = error, getmetatable = safe_getmetatable, ipairs = ipairs, math = utils.copy(math), next = next, pairs = utils.stablepairs, pcall = pcall, print = print, rawequal = rawequal, rawget = rawget, rawlen = rawget(_G, "rawlen"), rawset = rawset, require = safe_require, select = select, setmetatable = setmetatable, string = utils.copy(string), table = utils.copy(table), tonumber = tonumber, tostring = tostring, type = type, utf8 = _537_, xpcall = xpcall}
    return {_VERSION = _VERSION, assert = assert, bit = rawget(_G, "bit"), error = error, getmetatable = safe_getmetatable, ipairs = ipairs, math = utils.copy(math), next = next, pairs = utils.stablepairs, pcall = pcall, print = print, rawequal = rawequal, rawget = rawget, rawlen = rawget(_G, "rawlen"), rawset = rawset, require = safe_require, select = select, setmetatable = setmetatable, string = utils.copy(string), table = utils.copy(table), tonumber = tonumber, tostring = tostring, type = type, utf8 = _546_, xpcall = xpcall}
  end
  local function combined_mt_pairs(env)
    local combined = {}
    local _539_ = getmetatable(env)
    local __index = _539_["__index"]
    local _548_ = getmetatable(env)
    local __index = _548_["__index"]
    if ("table" == type(__index)) then
      for k, v in pairs(__index) do
        combined[k] = v


@@ 2039,40 2118,40 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  local function make_compiler_env(ast, scope, parent, _3fopts)
    local provided = nil
    do
      local _541_0 = (_3fopts or utils.root.options)
      if ((_G.type(_541_0) == "table") and (_541_0["compiler-env"] == "strict")) then
      local _550_0 = (_3fopts or utils.root.options)
      if ((_G.type(_550_0) == "table") and (_550_0["compiler-env"] == "strict")) then
        provided = safe_compiler_env()
      elseif ((_G.type(_541_0) == "table") and (nil ~= _541_0.compilerEnv)) then
        local compilerEnv = _541_0.compilerEnv
      elseif ((_G.type(_550_0) == "table") and (nil ~= _550_0.compilerEnv)) then
        local compilerEnv = _550_0.compilerEnv
        provided = compilerEnv
      elseif ((_G.type(_541_0) == "table") and (nil ~= _541_0["compiler-env"])) then
        local compiler_env = _541_0["compiler-env"]
      elseif ((_G.type(_550_0) == "table") and (nil ~= _550_0["compiler-env"])) then
        local compiler_env = _550_0["compiler-env"]
        provided = compiler_env
      else
        local _ = _541_0
        provided = safe_compiler_env(false)
        local _ = _550_0
        provided = safe_compiler_env()
      end
    end
    local env = nil
    local function _543_()
    local function _552_()
      return compiler.scopes.macro
    end
    local function _544_(symbol)
    local function _553_(symbol)
      compiler.assert(compiler.scopes.macro, "must call from macro", ast)
      return compiler.scopes.macro.manglings[tostring(symbol)]
    end
    local function _545_(base)
    local function _554_(base)
      return utils.sym(compiler.gensym((compiler.scopes.macro or scope), base))
    end
    local function _546_(form)
    local function _555_(form)
      compiler.assert(compiler.scopes.macro, "must call from macro", ast)
      return compiler.macroexpand(form, compiler.scopes.macro)
    end
    env = {["assert-compile"] = compiler.assert, ["ast-source"] = utils["ast-source"], ["comment?"] = utils["comment?"], ["get-scope"] = _543_, ["in-scope?"] = _544_, ["list?"] = utils["list?"], ["macro-loaded"] = macro_loaded, ["multi-sym?"] = utils["multi-sym?"], ["sequence?"] = utils["sequence?"], ["sym?"] = utils["sym?"], ["table?"] = utils["table?"], ["varg?"] = utils["varg?"], _AST = ast, _CHUNK = parent, _IS_COMPILER = true, _SCOPE = scope, _SPECIALS = compiler.scopes.global.specials, _VARARG = utils.varg(), comment = utils.comment, gensym = _545_, list = utils.list, macroexpand = _546_, metadata = compiler.metadata, sequence = utils.sequence, sym = utils.sym, unpack = unpack, version = utils.version, view = view}
    env = {["assert-compile"] = compiler.assert, ["ast-source"] = utils["ast-source"], ["comment?"] = utils["comment?"], ["fennel-module-name"] = fennel_module_name, ["get-scope"] = _552_, ["in-scope?"] = _553_, ["list?"] = utils["list?"], ["macro-loaded"] = macro_loaded, ["multi-sym?"] = utils["multi-sym?"], ["sequence?"] = utils["sequence?"], ["sym?"] = utils["sym?"], ["table?"] = utils["table?"], ["varg?"] = utils["varg?"], _AST = ast, _CHUNK = parent, _IS_COMPILER = true, _SCOPE = scope, _SPECIALS = compiler.scopes.global.specials, _VARARG = utils.varg(), comment = utils.comment, gensym = _554_, list = utils.list, macroexpand = _555_, sequence = utils.sequence, sym = utils.sym, unpack = unpack, version = utils.version, view = view}
    env._G = env
    return setmetatable(env, {__index = provided, __newindex = provided, __pairs = combined_mt_pairs})
  end
  local function _547_(...)
  local function _556_(...)
    local tbl_17_ = {}
    local i_18_ = #tbl_17_
    for c in string.gmatch((package.config or ""), "([^\n]+)") do


@@ 2084,10 2163,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    end
    return tbl_17_
  end
  local _549_ = _547_(...)
  local dirsep = _549_[1]
  local pathsep = _549_[2]
  local pathmark = _549_[3]
  local _558_ = _556_(...)
  local dirsep = _558_[1]
  local pathsep = _558_[2]
  local pathmark = _558_[3]
  local pkg_config = {dirsep = (dirsep or "/"), pathmark = (pathmark or "?"), pathsep = (pathsep or ";")}
  local function escapepat(str)
    return string.gsub(str, "[^%w]", "%%%1")


@@ 2100,36 2179,36 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    local function try_path(path)
      local filename = path:gsub(escapepat(pkg_config.pathmark), no_dot_module)
      local filename2 = path:gsub(escapepat(pkg_config.pathmark), modulename)
      local _550_0 = (io.open(filename) or io.open(filename2))
      if (nil ~= _550_0) then
        local file = _550_0
      local _559_0 = (io.open(filename) or io.open(filename2))
      if (nil ~= _559_0) then
        local file = _559_0
        file:close()
        return filename
      else
        local _ = _550_0
        local _ = _559_0
        return nil, ("no file '" .. filename .. "'")
      end
    end
    local function find_in_path(start, _3ftried_paths)
      local _552_0 = fullpath:match(pattern, start)
      if (nil ~= _552_0) then
        local path = _552_0
        local _553_0, _554_0 = try_path(path)
        if (nil ~= _553_0) then
          local filename = _553_0
      local _561_0 = fullpath:match(pattern, start)
      if (nil ~= _561_0) then
        local path = _561_0
        local _562_0, _563_0 = try_path(path)
        if (nil ~= _562_0) then
          local filename = _562_0
          return filename
        elseif ((_553_0 == nil) and (nil ~= _554_0)) then
          local error = _554_0
          local function _556_()
            local _555_0 = (_3ftried_paths or {})
            table.insert(_555_0, error)
            return _555_0
        elseif ((_562_0 == nil) and (nil ~= _563_0)) then
          local error = _563_0
          local function _565_()
            local _564_0 = (_3ftried_paths or {})
            table.insert(_564_0, error)
            return _564_0
          end
          return find_in_path((start + #path + 1), _556_())
          return find_in_path((start + #path + 1), _565_())
        end
      else
        local _ = _552_0
        local function _558_()
        local _ = _561_0
        local function _567_()
          local tried_paths = table.concat((_3ftried_paths or {}), "\n\9")
          if (_VERSION < "Lua 5.4") then
            return ("\n\9" .. tried_paths)


@@ 2137,31 2216,31 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
            return tried_paths
          end
        end
        return nil, _558_()
        return nil, _567_()
      end
    end
    return find_in_path(1)
  end
  local function make_searcher(_3foptions)
    local function _561_(module_name)
    local function _570_(module_name)
      local opts = utils.copy(utils.root.options)
      for k, v in pairs((_3foptions or {})) do
        opts[k] = v
      end
      opts["module-name"] = module_name
      local _562_0, _563_0 = search_module(module_name)
      if (nil ~= _562_0) then
        local filename = _562_0
        local function _564_(...)
      local _571_0, _572_0 = search_module(module_name)
      if (nil ~= _571_0) then
        local filename = _571_0
        local function _573_(...)
          return utils["fennel-module"].dofile(filename, opts, ...)
        end
        return _564_, filename
      elseif ((_562_0 == nil) and (nil ~= _563_0)) then
        local error = _563_0
        return _573_, filename
      elseif ((_571_0 == nil) and (nil ~= _572_0)) then
        local error = _572_0
        return error
      end
    end
    return _561_
    return _570_
  end
  local function dofile_with_searcher(fennel_macro_searcher, filename, opts, ...)
    local searchers = (package.loaders or package.searchers or {})


@@ 2173,35 2252,35 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  local function fennel_macro_searcher(module_name)
    local opts = nil
    do
      local _566_0 = utils.copy(utils.root.options)
      _566_0["module-name"] = module_name
      _566_0["env"] = "_COMPILER"
      _566_0["requireAsInclude"] = false
      _566_0["allowedGlobals"] = nil
      opts = _566_0
    end
    local _567_0 = search_module(module_name, utils["fennel-module"]["macro-path"])
    if (nil ~= _567_0) then
      local filename = _567_0
      local _568_
      local _575_0 = utils.copy(utils.root.options)
      _575_0["module-name"] = module_name
      _575_0["env"] = "_COMPILER"
      _575_0["requireAsInclude"] = false
      _575_0["allowedGlobals"] = nil
      opts = _575_0
    end
    local _576_0 = search_module(module_name, utils["fennel-module"]["macro-path"])
    if (nil ~= _576_0) then
      local filename = _576_0
      local _577_
      if (opts["compiler-env"] == _G) then
        local function _569_(...)
        local function _578_(...)
          return dofile_with_searcher(fennel_macro_searcher, filename, opts, ...)
        end
        _568_ = _569_
        _577_ = _578_
      else
        local function _570_(...)
        local function _579_(...)
          return utils["fennel-module"].dofile(filename, opts, ...)
        end
        _568_ = _570_
        _577_ = _579_
      end
      return _568_, filename
      return _577_, filename
    end
  end
  local function lua_macro_searcher(module_name)
    local _573_0 = search_module(module_name, package.path)
    if (nil ~= _573_0) then
      local filename = _573_0
    local _582_0 = search_module(module_name, package.path)
    if (nil ~= _582_0) then
      local filename = _582_0
      local code = nil
      do
        local f = io.open(filename)


@@ 2213,10 2292,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
            return error(..., 0)
          end
        end
        local function _575_()
        local function _584_()
          return assert(f:read("*a"))
        end
        code = close_handlers_10_(_G.xpcall(_575_, (package.loaded.fennel or debug).traceback))
        code = close_handlers_10_(_G.xpcall(_584_, (package.loaded.fennel or debug).traceback))
      end
      local chunk = load_code(code, make_compiler_env(), filename)
      return chunk, filename


@@ 2224,35 2303,38 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
  end
  local macro_searchers = {fennel_macro_searcher, lua_macro_searcher}
  local function search_macro_module(modname, n)
    local _577_0 = macro_searchers[n]
    if (nil ~= _577_0) then
      local f = _577_0
      local _578_0, _579_0 = f(modname)
      if ((nil ~= _578_0) and true) then
        local loader = _578_0
        local _3ffilename = _579_0
    local _586_0 = macro_searchers[n]
    if (nil ~= _586_0) then
      local f = _586_0
      local _587_0, _588_0 = f(modname)
      if ((nil ~= _587_0) and true) then
        local loader = _587_0
        local _3ffilename = _588_0
        return loader, _3ffilename
      else
        local _ = _578_0
        local _ = _587_0
        return search_macro_module(modname, (n + 1))
      end
    end
  end
  local function sandbox_fennel_module(modname)
    if ((modname == "fennel.macros") or (package and package.loaded and ("table" == type(package.loaded[modname])) and (package.loaded[modname].metadata == compiler.metadata))) then
      return {metadata = compiler.metadata, view = view}
      local function _591_(_, ...)
        return (compiler.metadata):setall(...)
      end
      return {metadata = {setall = _591_}, view = view}
    end
  end
  local function _583_(modname)
    local function _584_()
  local function _593_(modname)
    local function _594_()
      local loader, filename = search_macro_module(modname, 1)
      compiler.assert(loader, (modname .. " module not found."))
      macro_loaded[modname] = loader(modname, filename)
      return macro_loaded[modname]
    end
    return (macro_loaded[modname] or sandbox_fennel_module(modname) or _584_())
    return (macro_loaded[modname] or sandbox_fennel_module(modname) or _594_())
  end
  safe_require = _583_
  safe_require = _593_
  local function add_macros(macros_2a, ast, scope)
    compiler.assert(utils["table?"](macros_2a), "expected macros to be table", ast)
    for k, v in pairs(macros_2a) do


@@ 2262,10 2344,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    end
    return nil
  end
  local function resolve_module_name(_585_0, _scope, _parent, opts)
    local _586_ = _585_0
    local second = _586_[2]
    local filename = _586_["filename"]
  local function resolve_module_name(_595_0, _scope, _parent, opts)
    local _596_ = _595_0
    local second = _596_[2]
    local filename = _596_["filename"]
    local filename0 = (filename or (utils["table?"](second) and second.filename))
    local module_name = utils.root.options["module-name"]
    local modexpr = compiler.compile(second, opts)


@@ 2284,7 2366,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    if ("import-macros" == tostring(ast[1])) then
      return macro_loaded[modname]
    else
      return add_macros(macro_loaded[modname], ast, scope, parent)
      return add_macros(macro_loaded[modname], ast, scope)
    end
  end
  doc_special("require-macros", {"macro-module-name"}, "Load given module and use its contents as macro definitions in current scope.\nMacro module should return a table of macro functions with string keys.\nConsider using import-macros instead as it is more flexible.")


@@ 2322,10 2404,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
          return error(..., 0)
        end
      end
      local function _592_()
      local function _602_()
        return assert(f:read("*all")):gsub("[\13\n]*$", "")
      end
      src = close_handlers_10_(_G.xpcall(_592_, (package.loaded.fennel or debug).traceback))
      src = close_handlers_10_(_G.xpcall(_602_, (package.loaded.fennel or debug).traceback))
    end
    local ret = utils.expr(("require(\"" .. mod .. "\")"), "statement")
    local target = ("package.preload[%q]"):format(mod)


@@ 2355,12 2437,12 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    compiler.assert((#ast == 2), "expected one argument", ast)
    local modexpr = nil
    do
      local _595_0, _596_0 = pcall(resolve_module_name, ast, scope, parent, opts)
      if ((_595_0 == true) and (nil ~= _596_0)) then
        local modname = _596_0
      local _605_0, _606_0 = pcall(resolve_module_name, ast, scope, parent, opts)
      if ((_605_0 == true) and (nil ~= _606_0)) then
        local modname = _606_0
        modexpr = utils.expr(string.format("%q", modname), "literal")
      else
        local _ = _595_0
        local _ = _605_0
        modexpr = compiler.compile1(ast[2], scope, parent, {nval = 1})[1]
      end
    end


@@ 2377,13 2459,13 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
      utils.root.options["module-name"] = mod
      _ = nil
      local res = nil
      local function _600_()
        local _599_0 = search_module(mod)
        if (nil ~= _599_0) then
          local fennel_path = _599_0
      local function _610_()
        local _609_0 = search_module(mod)
        if (nil ~= _609_0) then
          local fennel_path = _609_0
          return include_path(ast, opts, fennel_path, mod, true)
        else
          local _0 = _599_0
          local _0 = _609_0
          local lua_path = search_module(mod, package.path)
          if lua_path then
            return include_path(ast, opts, lua_path, mod, false)


@@ 2394,7 2476,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
          end
        end
      end
      res = ((utils["member?"](mod, (utils.root.options.skipInclude or {})) and opts.fallback(modexpr, true)) or include_circular_fallback(mod, modexpr, opts.fallback, ast) or utils.root.scope.includes[mod] or _600_())
      res = ((utils["member?"](mod, (utils.root.options.skipInclude or {})) and opts.fallback(modexpr, true)) or include_circular_fallback(mod, modexpr, opts.fallback, ast) or utils.root.scope.includes[mod] or _610_())
      utils.root.options["module-name"] = oldmod
      return res
    end


@@ 2411,9 2493,18 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    compiler.assert((#ast == 2), "Expected one table argument", ast)
    local macro_tbl = eval_compiler_2a(ast[2], scope, parent)
    compiler.assert(utils["table?"](macro_tbl), "Expected one table argument", ast)
    return add_macros(macro_tbl, ast, scope, parent)
    return add_macros(macro_tbl, ast, scope)
  end
  doc_special("macros", {"{:macro-name-1 (fn [...] ...) ... :macro-name-N macro-body-N}"}, "Define all functions in the given table as macros local to the current scope.")
  SPECIALS["tail!"] = function(ast, scope, parent, opts)
    compiler.assert((#ast == 2), "Expected one argument", ast)
    local call = utils["list?"](compiler.macroexpand(ast[2], scope))
    local callee = tostring((call and utils["sym?"](call[1])))
    compiler.assert((call and not scope.specials[callee]), "Expected a function call as argument", ast)
    compiler.assert(opts.tail, "Must be in tail position", ast)
    return compiler.compile1(call, scope, parent, opts)
  end
  doc_special("tail!", {"body"}, "Assert that the body being called is in tail position.")
  SPECIALS["eval-compiler"] = function(ast, scope, parent)
    local old_first = ast[1]
    ast[1] = utils.sym("do")


@@ 2426,23 2517,23 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
    return compiler.assert(false, "tried to use unquote outside quote", ast)
  end
  doc_special("unquote", {"..."}, "Evaluate the argument even if it's in a quoted form.")
  return {["current-global-names"] = current_global_names, ["load-code"] = load_code, ["macro-loaded"] = macro_loaded, ["macro-searchers"] = macro_searchers, ["make-compiler-env"] = make_compiler_env, ["make-searcher"] = make_searcher, ["search-module"] = search_module, ["wrap-env"] = wrap_env, doc = doc_2a}
  return {["current-global-names"] = current_global_names, ["get-function-metadata"] = get_function_metadata, ["load-code"] = load_code, ["macro-loaded"] = macro_loaded, ["macro-searchers"] = macro_searchers, ["make-compiler-env"] = make_compiler_env, ["make-searcher"] = make_searcher, ["search-module"] = search_module, ["wrap-env"] = wrap_env, doc = doc_2a}
end
package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or function(...)
  local utils = require("fennel.utils")
  local parser = require("fennel.parser")
  local friend = require("fennel.friend")
  local unpack = (table.unpack or _G.unpack)
  local scopes = {}
  local scopes = {compiler = nil, global = nil, macro = nil}
  local function make_scope(_3fparent)
    local parent = (_3fparent or scopes.global)
    local _260_
    local _264_
    if parent then
      _260_ = ((parent.depth or 0) + 1)
      _264_ = ((parent.depth or 0) + 1)
    else
      _260_ = 0
      _264_ = 0
    end
    return {["gensym-base"] = setmetatable({}, {__index = (parent and parent["gensym-base"])}), autogensyms = setmetatable({}, {__index = (parent and parent.autogensyms)}), depth = _260_, gensyms = setmetatable({}, {__index = (parent and parent.gensyms)}), hashfn = (parent and parent.hashfn), includes = setmetatable({}, {__index = (parent and parent.includes)}), macros = setmetatable({}, {__index = (parent and parent.macros)}), manglings = setmetatable({}, {__index = (parent and parent.manglings)}), parent = parent, refedglobals = {}, specials = setmetatable({}, {__index = (parent and parent.specials)}), symmeta = setmetatable({}, {__index = (parent and parent.symmeta)}), unmanglings = setmetatable({}, {__index = (parent and parent.unmanglings)}), vararg = (parent and parent.vararg)}
    return {["gensym-base"] = setmetatable({}, {__index = (parent and parent["gensym-base"])}), autogensyms = setmetatable({}, {__index = (parent and parent.autogensyms)}), depth = _264_, gensyms = setmetatable({}, {__index = (parent and parent.gensyms)}), hashfn = (parent and parent.hashfn), includes = setmetatable({}, {__index = (parent and parent.includes)}), macros = setmetatable({}, {__index = (parent and parent.macros)}), manglings = setmetatable({}, {__index = (parent and parent.manglings)}), parent = parent, refedglobals = {}, specials = setmetatable({}, {__index = (parent and parent.specials)}), symmeta = setmetatable({}, {__index = (parent and parent.symmeta)}), unmanglings = setmetatable({}, {__index = (parent and parent.unmanglings)}), vararg = (parent and parent.vararg)}
  end
  local function assert_msg(ast, msg)
    local ast_tbl = nil


@@ 2456,14 2547,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    local line = ((m and m.line) or ast_tbl.line or "?")
    local col = ((m and m.col) or ast_tbl.col or "?")
    local target = tostring((utils["sym?"](ast_tbl[1]) or ast_tbl[1] or "()"))
    return string.format("%s:%s:%s Compile error in '%s': %s", filename, line, col, target, msg)
    return string.format("%s:%s:%s: Compile error in '%s': %s", filename, line, col, target, msg)
  end
  local function assert_compile(condition, msg, ast, _3ffallback_ast)
    if not condition then
      local _263_ = (utils.root.options or {})
      local error_pinpoint = _263_["error-pinpoint"]
      local source = _263_["source"]
      local unfriendly = _263_["unfriendly"]
      local _267_ = (utils.root.options or {})
      local error_pinpoint = _267_["error-pinpoint"]
      local source = _267_["source"]
      local unfriendly = _267_["unfriendly"]
      local ast0 = nil
      if next(utils["ast-source"](ast)) then
        ast0 = ast


@@ 2487,33 2578,33 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
  scopes.macro = scopes.global
  local serialize_subst = {["\11"] = "\\v", ["\12"] = "\\f", ["\7"] = "\\a", ["\8"] = "\\b", ["\9"] = "\\t", ["\n"] = "n"}
  local function serialize_string(str)
    local function _268_(_241)
    local function _272_(_241)
      return ("\\" .. _241:byte())
    end
    return string.gsub(string.gsub(string.format("%q", str), ".", serialize_subst), "[\128-\255]", _268_)
    return string.gsub(string.gsub(string.format("%q", str), ".", serialize_subst), "[\128-\255]", _272_)
  end
  local function global_mangling(str)
    if utils["valid-lua-identifier?"](str) then
      return str
    else
      local function _269_(_241)
      local function _273_(_241)
        return string.format("_%02x", _241:byte())
      end
      return ("__fnl_global__" .. str:gsub("[^%w]", _269_))
      return ("__fnl_global__" .. str:gsub("[^%w]", _273_))
    end
  end
  local function global_unmangling(identifier)
    local _271_0 = string.match(identifier, "^__fnl_global__(.*)$")
    if (nil ~= _271_0) then
      local rest = _271_0
      local _272_0 = nil
      local function _273_(_241)
    local _275_0 = string.match(identifier, "^__fnl_global__(.*)$")
    if (nil ~= _275_0) then
      local rest = _275_0
      local _276_0 = nil
      local function _277_(_241)
        return string.char(tonumber(_241:sub(2), 16))
      end
      _272_0 = string.gsub(rest, "_[%da-f][%da-f]", _273_)
      return _272_0
      _276_0 = string.gsub(rest, "_[%da-f][%da-f]", _277_)
      return _276_0
    else
      local _ = _271_0
      local _ = _275_0
      return identifier
    end
  end


@@ 2537,10 2628,10 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
      raw = str
    end
    local mangling = nil
    local function _277_(_241)
    local function _281_(_241)
      return string.format("_%02x", _241:byte())
    end
    mangling = string.gsub(string.gsub(raw, "-", "_"), "[^%w_]", _277_)
    mangling = string.gsub(string.gsub(raw, "-", "_"), "[^%w_]", _281_)
    local unique = unique_mangling(mangling, mangling, scope, 0)
    scope.unmanglings[unique] = (scope["gensym-base"][str] or str)
    do


@@ 2595,31 2686,31 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    return table.concat(parts, ".")
  end
  local function autogensym(base, scope)
    local _281_0 = utils["multi-sym?"](base)
    if (nil ~= _281_0) then
      local parts = _281_0
    local _285_0 = utils["multi-sym?"](base)
    if (nil ~= _285_0) then
      local parts = _285_0
      return combine_auto_gensym(parts, autogensym(parts[1], scope))
    else
      local _ = _281_0
      local function _282_()
        local mangling = gensym(scope, base:sub(1, ( - 2)), "auto")
      local _ = _285_0
      local function _286_()
        local mangling = gensym(scope, base:sub(1, -2), "auto")
        scope.autogensyms[base] = mangling
        return mangling
      end
      return (scope.autogensyms[base] or _282_())
      return (scope.autogensyms[base] or _286_())
    end
  end
  local function check_binding_valid(symbol, scope, ast, _3fopts)
    local name = tostring(symbol)
    local macro_3f = nil
    do
      local _284_0 = _3fopts
      if (nil ~= _284_0) then
        _284_0 = _284_0["macro?"]
      local _288_0 = _3fopts
      if (nil ~= _288_0) then
        _288_0 = _288_0["macro?"]
      end
      macro_3f = _284_0
      macro_3f = _288_0
    end
    assert_compile(not name:find("&"), "invalid character: &", symbol)
    assert_compile(("&" ~= name:match("[&.:]")), "invalid character: &", symbol)
    assert_compile(not name:find("^%."), "invalid character: .", symbol)
    assert_compile(not (scope.specials[name] or (not macro_3f and scope.macros[name])), ("local %s was overshadowed by a special form or macro"):format(name), ast)
    return assert_compile(not utils["quoted?"](symbol), string.format("macro tried to bind %s without gensym", name), symbol)


@@ 2693,7 2784,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
        out[last_line0] = ((out[last_line0] or "") .. " " .. chunk.leaf)
      else
        for _, subchunk in ipairs(chunk) do
          if (subchunk.leaf or (0 < #subchunk)) then
          if (subchunk.leaf or next(subchunk)) then
            local source = utils["ast-source"](subchunk.ast)
            if (file == source.filename) then
              last_line0 = math.max(last_line0, (source.line or 0))


@@ 2715,29 2806,29 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
  end
  local function flatten_chunk(file_sourcemap, chunk, tab, depth)
    if chunk.leaf then
      local _296_ = utils["ast-source"](chunk.ast)
      local filename = _296_["filename"]
      local line = _296_["line"]
      local _300_ = utils["ast-source"](chunk.ast)
      local filename = _300_["filename"]
      local line = _300_["line"]
      table.insert(file_sourcemap, {filename, line})
      return chunk.leaf
    else
      local tab0 = nil
      do
        local _297_0 = tab
        if (_297_0 == true) then
        local _301_0 = tab
        if (_301_0 == true) then
          tab0 = "  "
        elseif (_297_0 == false) then
        elseif (_301_0 == false) then
          tab0 = ""
        elseif (_297_0 == tab) then
        elseif (_301_0 == tab) then
          tab0 = tab
        elseif (_297_0 == nil) then
        elseif (_301_0 == nil) then
          tab0 = ""
        else
        tab0 = nil
        end
      end
      local function parter(c)
        if (c.leaf or (0 < #c)) then
        if (c.leaf or next(c)) then
          local sub = flatten_chunk(file_sourcemap, c, tab0, (depth + 1))
          if (0 < depth) then
            return (tab0 .. sub:gsub("\n", ("\n" .. tab0)))


@@ 2776,7 2867,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    end
  end
  local function make_metadata()
    local function _305_(self, tgt, _3fkey)
    local function _309_(self, tgt, _3fkey)
      if self[tgt] then
        if (nil ~= _3fkey) then
          return self[tgt][_3fkey]


@@ 2785,12 2876,12 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
        end
      end
    end
    local function _308_(self, tgt, key, value)
    local function _312_(self, tgt, key, value)
      self[tgt] = (self[tgt] or {})
      self[tgt][key] = value
      return tgt
    end
    local function _309_(self, tgt, ...)
    local function _313_(self, tgt, ...)
      local kv_len = select("#", ...)
      local kvs = {...}
      if ((kv_len % 2) ~= 0) then


@@ 2802,7 2893,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
      end
      return tgt
    end
    return setmetatable({}, {__index = {get = _305_, set = _308_, setall = _309_}, __mode = "k"})
    return setmetatable({}, {__index = {get = _309_, set = _312_, setall = _313_}, __mode = "k"})
  end
  local function exprs1(exprs)
    return table.concat(utils.map(exprs, tostring), ", ")


@@ 2848,14 2939,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    end
    if opts.target then
      local result = exprs1(exprs)
      local function _317_()
      local function _321_()
        if (result == "") then
          return "nil"
        else
          return result
        end
      end
      emit(parent, string.format("%s = %s", opts.target, _317_()), ast)
      emit(parent, string.format("%s = %s", opts.target, _321_()), ast)
    end
    if (opts.tail or opts.target) then
      return {returned = true}


@@ 2867,16 2958,16 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
  local function find_macro(ast, scope)
    local macro_2a = nil
    do
      local _320_0 = utils["sym?"](ast[1])
      if (_320_0 ~= nil) then
        local _321_0 = tostring(_320_0)
        if (_321_0 ~= nil) then
          macro_2a = scope.macros[_321_0]
      local _324_0 = utils["sym?"](ast[1])
      if (_324_0 ~= nil) then
        local _325_0 = tostring(_324_0)
        if (_325_0 ~= nil) then
          macro_2a = scope.macros[_325_0]
        else
          macro_2a = _321_0
          macro_2a = _325_0
        end
      else
        macro_2a = _320_0
        macro_2a = _324_0
      end
    end
    local multi_sym_parts = utils["multi-sym?"](ast[1])


@@ 2888,12 2979,12 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
      return macro_2a
    end
  end
  local function propagate_trace_info(_325_0, _index, node)
    local _326_ = _325_0
    local byteend = _326_["byteend"]
    local bytestart = _326_["bytestart"]
    local filename = _326_["filename"]
    local line = _326_["line"]
  local function propagate_trace_info(_329_0, _index, node)
    local _330_ = _329_0
    local byteend = _330_["byteend"]
    local bytestart = _330_["bytestart"]
    local filename = _330_["filename"]
    local line = _330_["line"]
    do
      local src = utils["ast-source"](node)
      if (("table" == type(node)) and (filename ~= src.filename)) then


@@ 2906,8 2997,8 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
  local function quote_literal_nils(index, node, parent)
    if (parent and utils["list?"](parent)) then
      for i = 1, utils.maxn(parent) do
        local _328_0 = parent[i]
        if (_328_0 == nil) then
        local _332_0 = parent[i]
        if (_332_0 == nil) then
          parent[i] = utils.sym("nil")
        end
      end


@@ 2915,10 3006,10 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    return index, node, parent
  end
  local function comp(f, g)
    local function _331_(...)
    local function _335_(...)
      return f(g(...))
    end
    return _331_
    return _335_
  end
  local function built_in_3f(m)
    local found_3f = false


@@ 2929,45 3020,46 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    return found_3f
  end
  local function macroexpand_2a(ast, scope, _3fonce)
    local _332_0 = nil
    local _336_0 = nil
    if utils["list?"](ast) then
      _332_0 = find_macro(ast, scope)
      _336_0 = find_macro(ast, scope)
    else
    _332_0 = nil
    _336_0 = nil
    end
    if (_332_0 == false) then
    if (_336_0 == false) then
      return ast
    elseif (nil ~= _332_0) then
      local macro_2a = _332_0
    elseif (nil ~= _336_0) then
      local macro_2a = _336_0
      local old_scope = scopes.macro
      local _ = nil
      scopes.macro = scope
      _ = nil
      local ok, transformed = nil, nil
      local function _334_()
      local function _338_()
        return macro_2a(unpack(ast, 2))
      end
      local function _335_()
      local function _339_()
        if built_in_3f(macro_2a) then
          return tostring
        else
          return debug.traceback
        end
      end
      ok, transformed = xpcall(_334_, _335_())
      local function _336_(...)
      ok, transformed = xpcall(_338_, _339_())
      local function _340_(...)
        return propagate_trace_info(ast, ...)
      end
      utils["walk-tree"](transformed, comp(_336_, quote_literal_nils))
      utils["walk-tree"](transformed, comp(_340_, quote_literal_nils))
      scopes.macro = old_scope
      assert_compile(ok, transformed, ast)
      utils.hook("macroexpand", ast, transformed, scope)
      if (_3fonce or not transformed) then
        return transformed
      else
        return macroexpand_2a(transformed, scope)
      end
    else
      local _ = _332_0
      local _ = _336_0
      return ast
    end
  end


@@ 2999,13 3091,13 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    assert_compile((utils["sym?"](ast[1]) or utils["list?"](ast[1]) or ("string" == type(ast[1]))), ("cannot call literal value " .. tostring(ast[1])), ast)
    for i = 2, len do
      local subexprs = nil
      local _342_
      local _346_
      if (i ~= len) then
        _342_ = 1
        _346_ = 1
      else
      _342_ = nil
      _346_ = nil
      end
      subexprs = compile1(ast[i], scope, parent, {nval = _342_})
      subexprs = compile1(ast[i], scope, parent, {nval = _346_})
      table.insert(fargs, subexprs[1])
      if (i == len) then
        for j = 2, #subexprs do


@@ 3043,13 3135,13 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    end
  end
  local function compile_varg(ast, scope, parent, opts)
    local _347_
    local _351_
    if scope.hashfn then
      _347_ = "use $... in hashfn"
      _351_ = "use $... in hashfn"
    else
      _347_ = "unexpected vararg"
      _351_ = "unexpected vararg"
    end
    assert_compile(scope.vararg, _347_, ast)
    assert_compile(scope.vararg, _351_, ast)
    return handle_compile_opts({utils.expr("...", "varg")}, parent, opts, ast)
  end
  local function compile_sym(ast, scope, parent, opts)


@@ 3064,20 3156,20 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    return handle_compile_opts({e}, parent, opts, ast)
  end
  local function serialize_number(n)
    local _350_0 = string.gsub(tostring(n), ",", ".")
    return _350_0
    local _354_0 = string.gsub(tostring(n), ",", ".")
    return _354_0
  end
  local function compile_scalar(ast, _scope, parent, opts)
    local serialize = nil
    do
      local _351_0 = type(ast)
      if (_351_0 == "nil") then
      local _355_0 = type(ast)
      if (_355_0 == "nil") then
        serialize = tostring
      elseif (_351_0 == "boolean") then
      elseif (_355_0 == "boolean") then
        serialize = tostring
      elseif (_351_0 == "string") then
      elseif (_355_0 == "string") then
        serialize = serialize_string
      elseif (_351_0 == "number") then
      elseif (_355_0 == "number") then
        serialize = serialize_number
      else
      serialize = nil


@@ 3090,8 3182,8 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
      if ((type(k) == "string") and utils["valid-lua-identifier?"](k)) then
        return k
      else
        local _353_ = compile1(k, scope, parent, {nval = 1})
        local compiled = _353_[1]
        local _357_ = compile1(k, scope, parent, {nval = 1})
        local compiled = _357_[1]
        return ("[" .. tostring(compiled) .. "]")
      end
    end


@@ 3117,12 3209,12 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    do
      local tbl_17_ = buffer
      local i_18_ = #tbl_17_
      for k, v in utils.stablepairs(ast) do
      for k in utils.stablepairs(ast) do
        local val_19_ = nil
        if not keys[k] then
          local _356_ = compile1(ast[k], scope, parent, {nval = 1})
          local v0 = _356_[1]
          val_19_ = string.format("%s = %s", escape_key(k), tostring(v0))
          local _360_ = compile1(ast[k], scope, parent, {nval = 1})
          local v = _360_[1]
          val_19_ = string.format("%s = %s", escape_key(k), tostring(v))
        else
        val_19_ = nil
        end


@@ 3153,12 3245,12 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
  end
  local function destructure(to, from, ast, scope, parent, opts)
    local opts0 = (opts or {})
    local _360_ = opts0
    local declaration = _360_["declaration"]
    local forceglobal = _360_["forceglobal"]
    local forceset = _360_["forceset"]
    local isvar = _360_["isvar"]
    local symtype = _360_["symtype"]
    local _364_ = opts0
    local declaration = _364_["declaration"]
    local forceglobal = _364_["forceglobal"]
    local forceset = _364_["forceset"]
    local isvar = _364_["isvar"]
    local symtype = _364_["symtype"]
    local symtype0 = ("_" .. (symtype or "dst"))
    local setter = nil
    if declaration then


@@ 3174,8 3266,8 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
        return declare_local(symbol, nil, scope, symbol, new_manglings)
      else
        local parts = (utils["multi-sym?"](raw) or {raw})
        local _362_ = parts
        local first = _362_[1]
        local _366_ = parts
        local first = _366_[1]
        local meta = scope.symmeta[first]
        assert_compile(not raw:find(":"), "cannot set method sym", symbol)
        if ((#parts == 1) and not forceset) then


@@ 3196,14 3288,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    end
    local function compile_top_target(lvalues)
      local inits = nil
      local function _367_(_241)
      local function _371_(_241)
        if scope.manglings[_241] then
          return _241
        else
          return "nil"
        end
      end
      inits = utils.map(lvalues, _367_)
      inits = utils.map(lvalues, _371_)
      local init = table.concat(inits, ", ")
      local lvalue = table.concat(lvalues, ", ")
      local plast = parent[#parent]


@@ 3241,7 3333,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    local unpack_fn = "function (t, k, e)\n                        local mt = getmetatable(t)\n                        if 'table' == type(mt) and mt.__fennelrest then\n                          return mt.__fennelrest(t, k)\n                        elseif e then\n                          local rest = {}\n                          for k, v in pairs(t) do\n                            if not e[k] then rest[k] = v end\n                          end\n                          return rest\n                        else\n                          return {(table.unpack or unpack)(t, k)}\n                        end\n                      end"
    local function destructure_kv_rest(s, v, left, excluded_keys, destructure1)
      local exclude_str = nil
      local _374_
      local _378_
      do
        local tbl_17_ = {}
        local i_18_ = #tbl_17_


@@ 3252,9 3344,9 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
            tbl_17_[i_18_] = val_19_
          end
        end
        _374_ = tbl_17_
        _378_ = tbl_17_
      end
      exclude_str = table.concat(_374_, ", ")
      exclude_str = table.concat(_378_, ", ")
      local subexpr = utils.expr(string.format(string.gsub(("(" .. unpack_fn .. ")(%s, %s, {%s})"), "\n%s*", " "), s, tostring(v), exclude_str), "expression")
      return destructure1(v, {subexpr}, left)
    end


@@ 3269,16 3361,16 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
      local s = gensym(scope, symtype0)
      local right = nil
      do
        local _376_0 = nil
        local _380_0 = nil
        if top_3f then
          _376_0 = exprs1(compile1(from, scope, parent))
          _380_0 = exprs1(compile1(from, scope, parent))
        else
          _376_0 = exprs1(rightexprs)
          _380_0 = exprs1(rightexprs)
        end
        if (_376_0 == "") then
        if (_380_0 == "") then
          right = "nil"
        elseif (nil ~= _376_0) then
          local right0 = _376_0
        elseif (nil ~= _380_0) then
          local right0 = _380_0
          right = right0
        else
        right = nil


@@ 3363,7 3455,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
  local function require_include(ast, scope, parent, opts)
    opts.fallback = function(e, no_warn)
      if (not no_warn and ("literal" == e.type)) then
        utils.warn(("include module not found, falling back to require: %s"):format(tostring(e)))
        utils.warn(("include module not found, falling back to require: %s"):format(tostring(e)), ast)
      end
      return utils.expr(string.format("require(%s)", tostring(e)), "statement")
    end


@@ 3383,8 3475,11 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    if opts.requireAsInclude then
      scope.specials.require = require_include
    end
    local _390_ = utils.root
    _390_["set-reset"](_390_)
    if opts.assertAsRepl then
      scope.macros.assert = scope.macros["assert-repl"]
    end
    local _395_ = utils.root
    _395_["set-reset"](_395_)
    utils.root.chunk, utils.root.scope, utils.root.options = chunk, scope, opts
    for i = 1, #asts do
      local exprs = compile1(asts[i], scope, chunk, {nval = (((i < #asts) and 0) or nil), tail = (i == #asts)})


@@ 3397,7 3492,8 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    utils.root.reset()
    return flatten(chunk, opts)
  end
  local function compile_stream(stream, opts)
  local function compile_stream(stream, _3fopts)
    local opts = (_3fopts or {})
    local asts = nil
    do
      local tbl_17_ = {}


@@ 3414,16 3510,16 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    return compile_asts(asts, opts)
  end
  local function compile_string(str, _3fopts)
    return compile_stream(parser["string-stream"](str, (_3fopts or {})), (_3fopts or {}))
    return compile_stream(parser["string-stream"](str, _3fopts), _3fopts)
  end
  local function compile(ast, _3fopts)
    return compile_asts({ast}, _3fopts)
  end
  local function traceback_frame(info)
    if ((info.what == "C") and info.name) then
      return string.format("  [C]: in function '%s'", info.name)
      return string.format("\9[C]: in function '%s'", info.name)
    elseif (info.what == "C") then
      return "  [C]: in ?"
      return "\9[C]: in ?"
    else
      local remap = sourcemap[info.source]
      if (remap and remap[info.currentline]) then


@@ 3435,18 3531,18 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
        info.currentline = (remap[info.currentline][2] or -1)
      end
      if (info.what == "Lua") then
        local function _395_()
        local function _400_()
          if info.name then
            return ("'" .. info.name .. "'")
          else
            return "?"
          end
        end
        return string.format("  %s:%d: in function %s", info.short_src, info.currentline, _395_())
        return string.format("\9%s:%d: in function %s", info.short_src, info.currentline, _400_())
      elseif (info.short_src == "(tail call)") then
        return "  (tail call)"
      else
        return string.format("  %s:%d: in main chunk", info.short_src, info.currentline)
        return string.format("\9%s:%d: in main chunk", info.short_src, info.currentline)
      end
    end
  end


@@ 3466,11 3562,11 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
      local done_3f, level = false, (_3fstart or 2)
      while not done_3f do
        do
          local _399_0 = debug.getinfo(level, "Sln")
          if (_399_0 == nil) then
          local _404_0 = debug.getinfo(level, "Sln")
          if (_404_0 == nil) then
            done_3f = true
          elseif (nil ~= _399_0) then
            local info = _399_0
          elseif (nil ~= _404_0) then
            local info = _404_0
            table.insert(lines, traceback_frame(info))
          end
        end


@@ 3480,14 3576,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
    end
  end
  local function entry_transform(fk, fv)
    local function _402_(k, v)
    local function _407_(k, v)
      if (type(k) == "number") then
        return k, fv(v)
      else
        return fk(k), fv(v)
      end
    end
    return _402_
    return _407_
  end
  local function mixed_concat(t, joiner)
    local seen = {}


@@ 3532,10 3628,10 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
      return res[1]
    elseif utils["list?"](form) then
      local mapped = nil
      local function _407_()
      local function _412_()
        return nil
      end
      mapped = utils.kvmap(form, entry_transform(_407_, q))
      mapped = utils.kvmap(form, entry_transform(_412_, q))
      local filename = nil
      if form.filename then
        filename = string.format("%q", form.filename)


@@ 3553,13 3649,13 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
      else
        filename = "nil"
      end
      local _410_
      local _415_
      if source then
        _410_ = source.line
        _415_ = source.line
      else
        _410_ = "nil"
        _415_ = "nil"
      end
      return string.format("setmetatable({%s}, {filename=%s, line=%s, sequence=%s})", mixed_concat(mapped, ", "), filename, _410_, "(getmetatable(sequence()))['sequence']")
      return string.format("setmetatable({%s}, {filename=%s, line=%s, sequence=%s})", mixed_concat(mapped, ", "), filename, _415_, "(getmetatable(sequence()))['sequence']")
    elseif (type(form) == "table") then
      local mapped = utils.kvmap(form, entry_transform(q, q))
      local source = getmetatable(form)


@@ 3569,14 3665,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
      else
        filename = "nil"
      end
      local function _413_()
      local function _418_()
        if source then
          return source.line
        else
          return "nil"
        end
      end
      return string.format("setmetatable({%s}, {filename=%s, line=%s})", mixed_concat(mapped, ", "), filename, _413_())
      return string.format("setmetatable({%s}, {filename=%s, line=%s})", mixed_concat(mapped, ", "), filename, _418_())
    elseif (type(form) == "string") then
      return serialize_string(form)
    else


@@ 3595,7 3691,7 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
    for pat, sug in pairs(suggestions) do
      if s then break end
      local matches = {msg:match(pat)}
      if (0 < #matches) then
      if next(matches) then
        local tbl_17_ = {}
        local i_18_ = #tbl_17_
        for _, s0 in ipairs(sug) do


@@ 3629,13 3725,13 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
          return error(..., 0)
        end
      end
      local function _184_()
      local function _187_()
        for _ = 2, line do
          f:read()
        end
        return f:read()
      end
      return close_handlers_10_(_G.xpcall(_184_, (package.loaded.fennel or debug).traceback))
      return close_handlers_10_(_G.xpcall(_187_, (package.loaded.fennel or debug).traceback))
    end
  end
  local function sub(str, start, _end)


@@ 3651,8 3747,8 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
    if ((opts and (false == opts["error-pinpoint"])) or (os and os.getenv and os.getenv("NO_COLOR"))) then
      return codeline
    else
      local _187_ = (opts or {})
      local error_pinpoint = _187_["error-pinpoint"]
      local _190_ = (opts or {})
      local error_pinpoint = _190_["error-pinpoint"]
      local endcol = (_3fendcol or col)
      local eol = nil
      if utf8_ok_3f then


@@ 3660,19 3756,19 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
      else
        eol = string.len(codeline)
      end
      local _189_ = (error_pinpoint or {"\27[7m", "\27[0m"})
      local open = _189_[1]
      local close = _189_[2]
      local _192_ = (error_pinpoint or {"\27[7m", "\27[0m"})
      local open = _192_[1]
      local close = _192_[2]
      return (sub(codeline, 1, col) .. open .. sub(codeline, (col + 1), (endcol + 1)) .. close .. sub(codeline, (endcol + 2), eol))
    end
  end
  local function friendly_msg(msg, _191_0, source, opts)
    local _192_ = _191_0
    local col = _192_["col"]
    local endcol = _192_["endcol"]
    local endline = _192_["endline"]
    local filename = _192_["filename"]
    local line = _192_["line"]
  local function friendly_msg(msg, _194_0, source, opts)
    local _195_ = _194_0
    local col = _195_["col"]
    local endcol = _195_["endcol"]
    local endline = _195_["endline"]
    local filename = _195_["filename"]
    local line = _195_["line"]
    local ok, codeline = pcall(read_line, filename, line, source)
    local endcol0 = nil
    if (ok and codeline and (line ~= endline)) then


@@ 3695,16 3791,16 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
  end
  local function assert_compile(condition, msg, ast, source, opts)
    if not condition then
      local _196_ = utils["ast-source"](ast)
      local col = _196_["col"]
      local filename = _196_["filename"]
      local line = _196_["line"]
      error(friendly_msg(("%s:%s:%s Compile error: %s"):format((filename or "unknown"), (line or "?"), (col or "?"), msg), utils["ast-source"](ast), source, opts), 0)
      local _199_ = utils["ast-source"](ast)
      local col = _199_["col"]
      local filename = _199_["filename"]
      local line = _199_["line"]
      error(friendly_msg(("%s:%s:%s: Compile error: %s"):format((filename or "unknown"), (line or "?"), (col or "?"), msg), utils["ast-source"](ast), source, opts), 0)
    end
    return condition
  end
  local function parse_error(msg, filename, line, col, source, opts)
    return error(friendly_msg(("%s:%s:%s Parse error: %s"):format(filename, line, col, msg), {col = col, filename = filename, line = line}, source, opts), 0)
    return error(friendly_msg(("%s:%s:%s: Parse error: %s"):format(filename, line, col, msg), {col = col, filename = filename, line = line}, source, opts), 0)
  end
  return {["assert-compile"] = assert_compile, ["parse-error"] = parse_error}
end


@@ 3714,36 3810,36 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
  local unpack = (table.unpack or _G.unpack)
  local function granulate(getchunk)
    local c, index, done_3f = "", 1, false
    local function _198_(parser_state)
    local function _201_(parser_state)
      if not done_3f then
        if (index <= #c) then
          local b = c:byte(index)
          index = (index + 1)
          return b
        else
          local _199_0 = getchunk(parser_state)
          local function _200_()
            local char = _199_0
          local _202_0 = getchunk(parser_state)
          local function _203_()
            local char = _202_0
            return (char ~= "")
          end
          if ((nil ~= _199_0) and _200_()) then
            local char = _199_0
          if ((nil ~= _202_0) and _203_()) then
            local char = _202_0
            c = char
            index = 2
            return c:byte()
          else
            local _ = _199_0
            local _ = _202_0
            done_3f = true
            return nil
          end
        end
      end
    end
    local function _204_()
    local function _207_()
      c = ""
      return nil
    end
    return _198_, _204_
    return _201_, _207_
  end
  local function string_stream(str, _3foptions)
    local str0 = str:gsub("^#!", ";;")


@@ 3751,12 3847,12 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
      _3foptions.source = str0
    end
    local index = 1
    local function _206_()
    local function _209_()
      local r = str0:byte(index)
      index = (index + 1)
      return r
    end
    return _206_
    return _209_
  end
  local delims = {[123] = 125, [125] = true, [40] = 41, [41] = true, [91] = 93, [93] = true}
  local function sym_char_3f(b)


@@ 3772,12 3868,12 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
  local function char_starter_3f(b)
    return (((1 < b) and (b < 127)) or ((192 < b) and (b < 247)))
  end
  local function parser_fn(getbyte, filename, _208_0)
    local _209_ = _208_0
    local options = _209_
    local comments = _209_["comments"]
    local source = _209_["source"]
    local unfriendly = _209_["unfriendly"]
  local function parser_fn(getbyte, filename, _211_0)
    local _212_ = _211_0
    local options = _212_
    local comments = _212_["comments"]
    local source = _212_["source"]
    local unfriendly = _212_["unfriendly"]
    local stack = {}
    local line, byteindex, col, prev_col, lastb = 1, 0, 0, 0, nil
    local function ungetb(ub)


@@ 3798,7 3894,9 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
      else
        r = getbyte({["stack-size"] = #stack})
      end
      byteindex = (byteindex + 1)
      if r then
        byteindex = (byteindex + 1)
      end
      if (r and char_starter_3f(r)) then
        col = (col + 1)
      end


@@ 3808,21 3906,21 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
      return r
    end
    local function whitespace_3f(b)
      local function _216_()
        local _215_0 = options.whitespace
        if (nil ~= _215_0) then
          _215_0 = _215_0[b]
      local function _220_()
        local _219_0 = options.whitespace
        if (nil ~= _219_0) then
          _219_0 = _219_0[b]
        end
        return _215_0
        return _219_0
      end
      return ((b == 32) or ((9 <= b) and (b <= 13)) or _216_())
      return ((b == 32) or ((9 <= b) and (b <= 13)) or _220_())
    end
    local function parse_error(msg, _3fcol_adjust)
      local col0 = (col + (_3fcol_adjust or -1))
      if (nil == utils["hook-opts"]("parse-error", options, msg, filename, (line or "?"), col0, source, utils.root.reset)) then
        utils.root.reset()
        if unfriendly then
          return error(string.format("%s:%s:%s Parse error: %s", filename, (line or "?"), col0, msg), 0)
          return error(string.format("%s:%s:%s: Parse error: %s", filename, (line or "?"), col0, msg), 0)
        else
          return friend["parse-error"](msg, filename, (line or "?"), col0, source, options)
        end


@@ 3835,56 3933,60 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
        return nil
      end
      local function dispatch(v)
        local _220_0 = stack[#stack]
        if (_220_0 == nil) then
        local _224_0 = stack[#stack]
        if (_224_0 == nil) then
          retval, done_3f, whitespace_since_dispatch = v, true, false
          return nil
        elseif ((_G.type(_220_0) == "table") and (nil ~= _220_0.prefix)) then
          local prefix = _220_0.prefix
        elseif ((_G.type(_224_0) == "table") and (nil ~= _224_0.prefix)) then
          local prefix = _224_0.prefix
          local source0 = nil
          do
            local _221_0 = table.remove(stack)
            set_source_fields(_221_0)
            source0 = _221_0
            local _225_0 = table.remove(stack)
            set_source_fields(_225_0)
            source0 = _225_0
          end
          local list = utils.list(utils.sym(prefix, source0), v)
          for k, v0 in pairs(source0) do
            list[k] = v0
          end
          return dispatch(list)
        elseif (nil ~= _220_0) then
          local top = _220_0
        elseif (nil ~= _224_0) then
          local top = _224_0
          whitespace_since_dispatch = false
          return table.insert(top, v)
        end
      end
      local function badend()
        local accum = utils.map(stack, "closer")
        local _223_
        local _227_
        if (#stack == 1) then
          _223_ = ""
          _227_ = ""
        else
          _223_ = "s"
          _227_ = "s"
        end
        return parse_error(string.format("expected closing delimiter%s %s", _223_, string.char(unpack(accum))))
        return parse_error(string.format("expected closing delimiter%s %s", _227_, string.char(unpack(accum))))
      end
      local function skip_whitespace(b)
      local function skip_whitespace(b, close_table)
        if (b and whitespace_3f(b)) then
          whitespace_since_dispatch = true
          return skip_whitespace(getb())
        elseif (not b and (0 < #stack)) then
          return badend()
          return skip_whitespace(getb(), close_table)
        elseif (not b and next(stack)) then
          badend()
          for i = #stack, 2, -1 do
            close_table(stack[i].closer)
          end
          return stack[1].closer
        else
          return b
        end
      end
      local function parse_comment(b, contents)
        if (b and (10 ~= b)) then
          local function _226_()
          local function _230_()
            table.insert(contents, string.char(b))
            return contents
          end
          return parse_comment(getb(), _226_())
          return parse_comment(getb(), _230_())
        elseif comments then
          ungetb(10)
          return dispatch(utils.comment(table.concat(contents), {filename = filename, line = line}))


@@ 3910,12 4012,12 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
        return dispatch(setmetatable(tbl, mt))
      end
      local function add_comment_at(comments0, index, node)
        local _230_0 = comments0[index]
        if (nil ~= _230_0) then
          local existing = _230_0
        local _234_0 = comments0[index]
        if (nil ~= _234_0) then
          local existing = _234_0
          return table.insert(existing, node)
        else
          local _ = _230_0
          local _ = _234_0
          comments0[index] = {node}
          return nil
        end


@@ 3994,16 4096,16 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
        end
        local state0 = nil
        do
          local _241_0 = {state, b}
          if ((_G.type(_241_0) == "table") and (_241_0[1] == "base") and (_241_0[2] == 92)) then
          local _245_0 = {state, b}
          if ((_G.type(_245_0) == "table") and (_245_0[1] == "base") and (_245_0[2] == 92)) then
            state0 = "backslash"
          elseif ((_G.type(_241_0) == "table") and (_241_0[1] == "base") and (_241_0[2] == 34)) then
          elseif ((_G.type(_245_0) == "table") and (_245_0[1] == "base") and (_245_0[2] == 34)) then
            state0 = "done"
          elseif ((_G.type(_241_0) == "table") and (_241_0[1] == "backslash") and (_241_0[2] == 10)) then
          elseif ((_G.type(_245_0) == "table") and (_245_0[1] == "backslash") and (_245_0[2] == 10)) then
            table.remove(chars, (#chars - 1))
            state0 = "base"
          else
            local _ = _241_0
            local _ = _245_0
            state0 = "base"
          end
        end


@@ 4025,11 4127,11 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
        table.remove(stack)
        local raw = table.concat(chars)
        local formatted = raw:gsub("[\7-\13]", escape_char)
        local _245_0 = (rawget(_G, "loadstring") or load)(("return " .. formatted))
        if (nil ~= _245_0) then
          local load_fn = _245_0
        local _249_0 = (rawget(_G, "loadstring") or load)(("return " .. formatted))
        if (nil ~= _249_0) then
          local load_fn = _249_0
          return dispatch(load_fn())
        elseif (_245_0 == nil) then
        elseif (_249_0 == nil) then
          return parse_error(("Invalid string: " .. raw))
        end
      end


@@ 4062,13 4164,13 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
          dispatch((tonumber(number_with_stripped_underscores) or parse_error(("could not read number \"" .. rawstr .. "\""))))
          return true
        else
          local _251_0 = tonumber(number_with_stripped_underscores)
          if (nil ~= _251_0) then
            local x = _251_0
          local _255_0 = tonumber(number_with_stripped_underscores)
          if (nil ~= _255_0) then
            local x = _255_0
            dispatch(x)
            return true
          else
            local _ = _251_0
            local _ = _255_0
            return false
          end
        end


@@ 4078,18 4180,15 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
          return (rawstr:find(pat) - utils.len(rawstr) - 1)
        end
        if (rawstr:match("^~") and (rawstr ~= "~=")) then
          return parse_error("invalid character: ~")
        elseif rawstr:match("%.[0-9]") then
          return parse_error(("can't start multisym segment with a digit: " .. rawstr), col_adjust("%.[0-9]"))
          parse_error("invalid character: ~")
        elseif (rawstr:match("[%.:][%.:]") and (rawstr ~= "..") and (rawstr ~= "$...")) then
          return parse_error(("malformed multisym: " .. rawstr), col_adjust("[%.:][%.:]"))
          parse_error(("malformed multisym: " .. rawstr), col_adjust("[%.:][%.:]"))
        elseif ((rawstr ~= ":") and rawstr:match(":$")) then
          return parse_error(("malformed multisym: " .. rawstr), col_adjust(":$"))
          parse_error(("malformed multisym: " .. rawstr), col_adjust(":$"))
        elseif rawstr:match(":.+[%.:]") then
          return parse_error(("method must be last component of multisym: " .. rawstr), col_adjust(":.+[%.:]"))
        else
          return rawstr
          parse_error(("method must be last component of multisym: " .. rawstr), col_adjust(":.+[%.:]"))
        end
        return rawstr
      end
      local function parse_sym(b)
        local source0 = {bytestart = byteindex, col = (col - 1), filename = filename, line = line}


@@ 4116,7 4215,7 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
        elseif delims[b] then
          close_table(b)
        elseif (b == 34) then
          parse_string(b)
          parse_string()
        elseif prefixes[b] then
          parse_prefix(b)
        elseif (sym_char_3f(b) or (b == string.byte("~"))) then


@@ 4129,16 4228,16 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
        elseif done_3f then
          return true, retval
        else
          return parse_loop(skip_whitespace(getb()))
          return parse_loop(skip_whitespace(getb(), close_table))
        end
      end
      return parse_loop(skip_whitespace(getb()))
      return parse_loop(skip_whitespace(getb(), close_table))
    end
    local function _258_()
      stack, line, byteindex, col, lastb = {}, 1, 0, 0, nil
    local function _262_()
      stack, line, byteindex, col, lastb = {}, 1, 0, 0, ((lastb ~= 10) and lastb)
      return nil
    end
    return parse_stream, _258_
    return parse_stream, _262_
  end
  local function parser(stream_or_string, _3ffilename, _3foptions)
    local filename = (_3ffilename or "unknown")


@@ 4763,14 4862,14 @@ package.preload["fennel.view"] = package.preload["fennel.view"] or function(...)
    end
  end
  pp = _93_
  local function view(x, _3foptions)
  local function _view(x, _3foptions)
    return pp(x, make_options(x, _3foptions), 0)
  end
  return view
  return _view
end
package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(...)
  local view = require("fennel.view")
  local version = "1.3.1-dev"
  local version = "1.4.2"
  local function luajit_vm_3f()
    return ((nil ~= _G.jit) and (type(_G.jit) == "table") and (nil ~= _G.jit.on) and (nil ~= _G.jit.off) and (type(_G.jit.version_num) == "number"))
  end


@@ 4805,39 4904,34 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
      return ("Fennel " .. version .. " on " .. lua_vm_version())
    end
  end
  local function warn(message)
    if (_G.io and _G.io.stderr) then
      return (_G.io.stderr):write(("--WARNING: %s\n"):format(tostring(message)))
    end
  end
  local len = nil
  do
    local _104_0, _105_0 = pcall(require, "utf8")
    if ((_104_0 == true) and (nil ~= _105_0)) then
      local utf8 = _105_0
    local _103_0, _104_0 = pcall(require, "utf8")
    if ((_103_0 == true) and (nil ~= _104_0)) then
      local utf8 = _104_0
      len = utf8.len
    else
      local _ = _104_0
      local _ = _103_0
      len = string.len
    end
  end
  local kv_order = {boolean = 2, number = 1, string = 3, table = 4}
  local function kv_compare(a, b)
    local _107_0, _108_0 = type(a), type(b)
    if (((_107_0 == "number") and (_108_0 == "number")) or ((_107_0 == "string") and (_108_0 == "string"))) then
    local _106_0, _107_0 = type(a), type(b)
    if (((_106_0 == "number") and (_107_0 == "number")) or ((_106_0 == "string") and (_107_0 == "string"))) then
      return (a < b)
    else
      local function _109_()
        local a_t = _107_0
        local b_t = _108_0
      local function _108_()
        local a_t = _106_0
        local b_t = _107_0
        return (a_t ~= b_t)
      end
      if (((nil ~= _107_0) and (nil ~= _108_0)) and _109_()) then
        local a_t = _107_0
        local b_t = _108_0
      if (((nil ~= _106_0) and (nil ~= _107_0)) and _108_()) then
        local a_t = _106_0
        local b_t = _107_0
        return ((kv_order[a_t] or 5) < (kv_order[b_t] or 5))
      else
        local _ = _107_0
        local _ = _106_0
        return (tostring(a) < tostring(b))
      end
    end


@@ 4869,20 4963,20 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
  local function stablepairs(t)
    local mt_keys = nil
    do
      local _113_0 = getmetatable(t)
      if (nil ~= _113_0) then
        _113_0 = _113_0.keys
      local _112_0 = getmetatable(t)
      if (nil ~= _112_0) then
        _112_0 = _112_0.keys
      end
      mt_keys = _113_0
      mt_keys = _112_0
    end
    local succ, prev, first_mt = nil, nil, nil
    local function _115_(_241)
    local function _114_(_241)
      return t[_241]
    end
    succ, prev, first_mt = add_stable_keys({}, nil, (mt_keys or {}), _115_)
    succ, prev, first_mt = add_stable_keys({}, nil, (mt_keys or {}), _114_)
    local pairs_keys = nil
    do
      local _116_0 = nil
      local _115_0 = nil
      do
        local tbl_17_ = {}
        local i_18_ = #tbl_17_


@@ 4893,10 4987,10 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
            tbl_17_[i_18_] = val_19_
          end
        end
        _116_0 = tbl_17_
        _115_0 = tbl_17_
      end
      table.sort(_116_0, kv_compare)
      pairs_keys = _116_0
      table.sort(_115_0, kv_compare)
      pairs_keys = _115_0
    end
    local succ0, _, first_after_mt = add_stable_keys(succ, prev, pairs_keys)
    local first = nil


@@ 4906,19 5000,19 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
      first = first_mt
    end
    local function stablenext(tbl, key)
      local _119_0 = nil
      local _118_0 = nil
      if (key == nil) then
        _119_0 = first
        _118_0 = first
      else
        _119_0 = succ0[key]
        _118_0 = succ0[key]
      end
      if (nil ~= _119_0) then
        local next_key = _119_0
        local _121_0 = tbl[next_key]
        if (_121_0 ~= nil) then
          return next_key, _121_0
      if (nil ~= _118_0) then
        local next_key = _118_0
        local _120_0 = tbl[next_key]
        if (_120_0 ~= nil) then
          return next_key, _120_0
        else
          return _121_0
          return _120_0
        end
      end
    end


@@ 4929,25 5023,25 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
    if (0 == #path) then
      return _3ffallback
    else
      local _124_0 = nil
      local _123_0 = nil
      do
        local t = tbl
        for _, k in ipairs(path) do
          if (nil == t) then break end
          local _125_0 = type(t)
          if (_125_0 == "table") then
          local _124_0 = type(t)
          if (_124_0 == "table") then
            t = t[k]
          else
          t = nil
          end
        end
        _124_0 = t
        _123_0 = t
      end
      if (nil ~= _124_0) then
        local res = _124_0
      if (nil ~= _123_0) then
        local res = _123_0
        return res
      else
        local _ = _124_0
        local _ = _123_0
        return _3ffallback
      end
    end


@@ 4958,15 5052,15 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
    if (type(f) == "function") then
      f0 = f
    else
      local function _129_(_241)
      local function _128_(_241)
        return _241[f]
      end
      f0 = _129_
      f0 = _128_
    end
    for _, x in ipairs(t) do
      local _131_0 = f0(x)
      if (nil ~= _131_0) then
        local v = _131_0
      local _130_0 = f0(x)
      if (nil ~= _130_0) then
        local v = _130_0
        table.insert(out, v)
      end
    end


@@ 4978,19 5072,19 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
    if (type(f) == "function") then
      f0 = f
    else
      local function _133_(_241)
      local function _132_(_241)
        return _241[f]
      end
      f0 = _133_
      f0 = _132_
    end
    for k, x in stablepairs(t) do
      local _135_0, _136_0 = f0(k, x)
      if ((nil ~= _135_0) and (nil ~= _136_0)) then
        local key = _135_0
        local value = _136_0
        out[key] = value
      elseif (nil ~= _135_0) then
      local _134_0, _135_0 = f0(k, x)
      if ((nil ~= _134_0) and (nil ~= _135_0)) then
        local key = _134_0
        local value = _135_0
        out[key] = value
      elseif (nil ~= _134_0) then
        local value = _134_0
        table.insert(out, value)
      end
    end


@@ 5007,13 5101,13 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
    return tbl_14_
  end
  local function member_3f(x, tbl, _3fn)
    local _139_0 = tbl[(_3fn or 1)]
    if (_139_0 == x) then
    local _138_0 = tbl[(_3fn or 1)]
    if (_138_0 == x) then
      return true
    elseif (_139_0 == nil) then
    elseif (_138_0 == nil) then
      return nil
    else
      local _ = _139_0
      local _ = _138_0
      return member_3f(x, tbl, ((_3fn or 1) + 1))
    end
  end


@@ 5048,9 5142,9 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
        seen[next_state] = true
        return next_state, value
      else
        local _142_0 = getmetatable(t)
        if ((_G.type(_142_0) == "table") and true) then
          local __index = _142_0.__index
        local _141_0 = getmetatable(t)
        if ((_G.type(_141_0) == "table") and true) then
          local __index = _141_0.__index
          if ("table" == type(__index)) then
            t = __index
            return allpairs_next(t)


@@ 5068,10 5162,10 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
    local safe = {}
    local view0 = nil
    if _3fview then
      local function _146_(_241)
      local function _145_(_241)
        return _3fview(_241, _3foptions, _3findent)
      end
      view0 = _146_
      view0 = _145_
    else
      view0 = view
    end


@@ 5092,19 5186,19 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
  end
  local symbol_mt = {"SYMBOL", __eq = sym_3d, __fennelview = deref, __lt = sym_3c, __tostring = deref}
  local expr_mt = nil
  local function _148_(x)
  local function _147_(x)
    return tostring(deref(x))
  end
  expr_mt = {"EXPR", __tostring = _148_}
  expr_mt = {"EXPR", __tostring = _147_}
  local list_mt = {"LIST", __fennelview = list__3estring, __tostring = list__3estring}
  local comment_mt = {"COMMENT", __eq = sym_3d, __fennelview = comment_view, __lt = sym_3c, __tostring = deref}
  local sequence_marker = {"SEQUENCE"}
  local varg_mt = {"VARARG", __fennelview = deref, __tostring = deref}
  local getenv = nil
  local function _149_()
  local function _148_()
    return nil
  end
  getenv = ((os and os.getenv) or _149_)
  getenv = ((os and os.getenv) or _148_)
  local function debug_on_3f(flag)
    local level = (getenv("FENNEL_DEBUG") or "")
    return ((level == "all") or level:find(flag))


@@ 5113,7 5207,7 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
    return setmetatable({...}, list_mt)
  end
  local function sym(str, _3fsource)
    local _150_
    local _149_
    do
      local tbl_14_ = {str}
      for k, v in pairs((_3fsource or {})) do


@@ 5127,13 5221,13 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
          tbl_14_[k_15_] = v_16_
        end
      end
      _150_ = tbl_14_
      _149_ = tbl_14_
    end
    return setmetatable(_150_, symbol_mt)
    return setmetatable(_149_, symbol_mt)
  end
  nil_sym = sym("nil")
  local function sequence(...)
    local function _153_(seq, view0, inspector, indent)
    local function _152_(seq, view0, inspector, indent)
      local opts = nil
      do
        inspector["empty-as-sequence?"] = {after = inspector["empty-as-sequence?"], once = true}


@@ 5142,19 5236,19 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
      end
      return view0(seq, opts, indent)
    end
    return setmetatable({...}, {__fennelview = _153_, sequence = sequence_marker})
    return setmetatable({...}, {__fennelview = _152_, sequence = sequence_marker})
  end
  local function expr(strcode, etype)
    return setmetatable({strcode, type = etype}, expr_mt)
  end
  local function comment_2a(contents, _3fsource)
    local _154_ = (_3fsource or {})
    local filename = _154_["filename"]
    local line = _154_["line"]
    local _153_ = (_3fsource or {})
    local filename = _153_["filename"]
    local line = _153_["line"]
    return setmetatable({contents, filename = filename, line = line}, comment_mt)
  end
  local function varg(_3fsource)
    local _155_
    local _154_
    do
      local tbl_14_ = {"..."}
      for k, v in pairs((_3fsource or {})) do


@@ 5168,9 5262,9 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
          tbl_14_[k_15_] = v_16_
        end
      end
      _155_ = tbl_14_
      _154_ = tbl_14_
    end
    return setmetatable(_155_, varg_mt)
    return setmetatable(_154_, varg_mt)
  end
  local function expr_3f(x)
    return ((type(x) == "table") and (getmetatable(x) == expr_mt) and x)


@@ 5208,7 5302,11 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
    end
  end
  local function string_3f(x)
    return (type(x) == "string")
    if (type(x) == "string") then
      return x
    else
      return false
    end
  end
  local function multi_sym_3f(str)
    if sym_3f(str) then


@@ 5219,35 5317,27 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
      local function _160_()
        local parts = {}
        for part in str:gmatch("[^%.%:]+[%.%:]?") do
          local last_char = part:sub(( - 1))
          local last_char = part:sub(-1)
          if (last_char == ":") then
            parts["multi-sym-method-call"] = true
          end
          if ((last_char == ":") or (last_char == ".")) then
            parts[(#parts + 1)] = part:sub(1, ( - 2))
            parts[(#parts + 1)] = part:sub(1, -2)
          else
            parts[(#parts + 1)] = part
          end
        end
        return ((0 < #parts) and parts)
        return (next(parts) and parts)
      end
      return ((str:match("%.") or str:match(":")) and not str:match("%.%.") and (str:byte() ~= string.byte(".")) and (str:byte(( - 1)) ~= string.byte(".")) and _160_())
      return ((str:match("%.") or str:match(":")) and not str:match("%.%.") and (str:byte() ~= string.byte(".")) and (str:byte() ~= string.byte(":")) and (str:byte(-1) ~= string.byte(".")) and (str:byte(-1) ~= string.byte(":")) and _160_())
    end
  end
  local function quoted_3f(symbol)
    return symbol.quoted
  end
  local function idempotent_expr_3f(x)
    return ((type(x) == "string") or (type(x) == "integer") or (type(x) == "number") or (sym_3f(x) and not multi_sym_3f(x)))
  end
  local function ast_source(ast)
    if (table_3f(ast) or sequence_3f(ast)) then
      return (getmetatable(ast) or {})
    elseif ("table" == type(ast)) then
      return ast
    else
      return {}
    end
    local t = type(x)
    return ((t == "string") or (t == "integer") or (t == "number") or (t == "boolean") or (sym_3f(x) and not multi_sym_3f(x)))
  end
  local function walk_tree(root, f, _3fcustom_iterator)
    local function walk(iterfn, parent, idx, node)


@@ 5273,27 5363,53 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
    return subopts
  end
  local root = nil
  local function _166_()
  end
  root = {chunk = nil, options = nil, reset = _166_, scope = nil}
  root["set-reset"] = function(_167_0)
    local _168_ = _167_0
    local chunk = _168_["chunk"]
    local options = _168_["options"]
    local reset = _168_["reset"]
    local scope = _168_["scope"]
  local function _165_()
  end
  root = {chunk = nil, options = nil, reset = _165_, scope = nil}
  root["set-reset"] = function(_166_0)
    local _167_ = _166_0
    local chunk = _167_["chunk"]
    local options = _167_["options"]
    local reset = _167_["reset"]
    local scope = _167_["scope"]
    root.reset = function()
      root.chunk, root.scope, root.options, root.reset = chunk, scope, options, reset
      return nil
    end
    return root.reset
  end
  local function ast_source(ast)
    if (table_3f(ast) or sequence_3f(ast)) then
      return (getmetatable(ast) or {})
    elseif ("table" == type(ast)) then
      return ast
    else
      return {}
    end
  end
  local function warn(msg, _3fast)
    if (_G.io and _G.io.stderr) then
      local loc = nil
      do
        local _169_0 = ast_source(_3fast)
        if ((_G.type(_169_0) == "table") and (nil ~= _169_0.filename) and (nil ~= _169_0.line)) then
          local filename = _169_0.filename
          local line = _169_0.line
          loc = (filename .. ":" .. line .. ": ")
        else
          local _ = _169_0
          loc = ""
        end
      end
      return (_G.io.stderr):write(("--WARNING: %s%s\n"):format(loc, tostring(msg)))
    end
  end
  local warned = {}
  local function check_plugin_version(_169_0)
    local _170_ = _169_0
    local plugin = _170_
    local name = _170_["name"]
    local versions = _170_["versions"]
  local function check_plugin_version(_172_0)
    local _173_ = _172_0
    local plugin = _173_
    local name = _173_["name"]
    local versions = _173_["versions"]
    if (not member_3f(version:gsub("-dev", ""), (versions or {})) and not warned[plugin]) then
      warned[plugin] = true
      return warn(string.format("plugin %s does not support Fennel version %s", (name or "unknown"), version))


@@ 5301,29 5417,29 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
  end
  local function hook_opts(event, _3foptions, ...)
    local plugins = nil
    local function _173_(...)
      local _172_0 = _3foptions
      if (nil ~= _172_0) then
        _172_0 = _172_0.plugins
      end
      return _172_0
    end
    local function _176_(...)
      local _175_0 = root.options
      local _175_0 = _3foptions
      if (nil ~= _175_0) then
        _175_0 = _175_0.plugins
      end
      return _175_0
    end
    plugins = (_173_(...) or _176_(...))
    local function _179_(...)
      local _178_0 = root.options
      if (nil ~= _178_0) then
        _178_0 = _178_0.plugins
      end
      return _178_0
    end
    plugins = (_176_(...) or _179_(...))
    if plugins then
      local result = nil
      for _, plugin in ipairs(plugins) do
        if result then break end
        check_plugin_version(plugin)
        local _178_0 = plugin[event]
        if (nil ~= _178_0) then
          local f = _178_0
        local _181_0 = plugin[event]
        if (nil ~= _181_0) then
          local f = _181_0
          result = f(...)
        else
        result = nil


@@ 5335,7 5451,7 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
  local function hook(event, ...)
    return hook_opts(event, root.options, ...)
  end
  return {["ast-source"] = ast_source, ["comment?"] = comment_3f, ["debug-on?"] = debug_on_3f, ["every?"] = every_3f, ["expr?"] = expr_3f, ["get-in"] = get_in, ["hook-opts"] = hook_opts, ["idempotent-expr?"] = idempotent_expr_3f, ["kv-table?"] = kv_table_3f, ["list?"] = list_3f, ["lua-keywords"] = lua_keywords, ["macro-path"] = table.concat({"./?.fnl", "./?/init-macros.fnl", "./?/init.fnl", getenv("FENNEL_MACRO_PATH")}, ";"), ["member?"] = member_3f, ["multi-sym?"] = multi_sym_3f, ["propagate-options"] = propagate_options, ["quoted?"] = quoted_3f, ["runtime-version"] = runtime_version, ["sequence?"] = sequence_3f, ["string?"] = string_3f, ["sym?"] = sym_3f, ["table?"] = table_3f, ["valid-lua-identifier?"] = valid_lua_identifier_3f, ["varg?"] = varg_3f, ["walk-tree"] = walk_tree, allpairs = allpairs, comment = comment_2a, copy = copy, expr = expr, hook = hook, kvmap = kvmap, len = len, list = list, map = map, maxn = maxn, path = table.concat({"./?.fnl", "./?/init.fnl", getenv("FENNEL_PATH")}, ";"), root = root, sequence = sequence, stablepairs = stablepairs, sym = sym, varg = varg, version = version, warn = warn}
  return {["ast-source"] = ast_source, ["comment?"] = comment_3f, ["debug-on?"] = debug_on_3f, ["every?"] = every_3f, ["expr?"] = expr_3f, ["fennel-module"] = nil, ["get-in"] = get_in, ["hook-opts"] = hook_opts, ["idempotent-expr?"] = idempotent_expr_3f, ["kv-table?"] = kv_table_3f, ["list?"] = list_3f, ["lua-keywords"] = lua_keywords, ["macro-path"] = table.concat({"./?.fnl", "./?/init-macros.fnl", "./?/init.fnl", getenv("FENNEL_MACRO_PATH")}, ";"), ["member?"] = member_3f, ["multi-sym?"] = multi_sym_3f, ["propagate-options"] = propagate_options, ["quoted?"] = quoted_3f, ["runtime-version"] = runtime_version, ["sequence?"] = sequence_3f, ["string?"] = string_3f, ["sym?"] = sym_3f, ["table?"] = table_3f, ["valid-lua-identifier?"] = valid_lua_identifier_3f, ["varg?"] = varg_3f, ["walk-tree"] = walk_tree, allpairs = allpairs, comment = comment_2a, copy = copy, expr = expr, hook = hook, kvmap = kvmap, len = len, list = list, map = map, maxn = maxn, path = table.concat({"./?.fnl", "./?/init.fnl", getenv("FENNEL_PATH")}, ";"), root = root, sequence = sequence, stablepairs = stablepairs, sym = sym, varg = varg, version = version, warn = warn}
end
package.preload["fennel"] = package.preload["fennel"] or function(...)
  local utils = require("fennel.utils")


@@ 5373,14 5489,14 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
    local env = eval_env(opts.env, opts)
    local lua_source = compiler["compile-string"](str, opts)
    local loader = nil
    local function _732_(...)
    local function _750_(...)
      if opts.filename then
        return ("@" .. opts.filename)
      else
        return str
      end
    end
    loader = specials["load-code"](lua_source, env, _732_(...))
    loader = specials["load-code"](lua_source, env, _750_(...))
    opts.filename = nil
    return loader(...)
  end


@@ 5396,25 5512,28 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
    local body_3f = {"when", "with-open", "collect", "icollect", "fcollect", "lambda", "\206\187", "macro", "match", "match-try", "case", "case-try", "accumulate", "faccumulate", "doto"}
    local binding_3f = {"collect", "icollect", "fcollect", "each", "for", "let", "with-open", "accumulate", "faccumulate"}
    local define_3f = {"fn", "lambda", "\206\187", "var", "local", "macro", "macros", "global"}
    local deprecated = {"~=", "#", "global", "require-macros", "pick-args"}
    local out = {}
    for k, v in pairs(compiler.scopes.global.specials) do
      local metadata = (compiler.metadata[v] or {})
      out[k] = {["binding-form?"] = utils["member?"](k, binding_3f), ["body-form?"] = metadata["fnl/body-form?"], ["define?"] = utils["member?"](k, define_3f), ["special?"] = true}
      out[k] = {["binding-form?"] = utils["member?"](k, binding_3f), ["body-form?"] = metadata["fnl/body-form?"], ["define?"] = utils["member?"](k, define_3f), ["deprecated?"] = utils["member?"](k, deprecated), ["special?"] = true}
    end
    for k, v in pairs(compiler.scopes.global.macros) do
    for k in pairs(compiler.scopes.global.macros) do
      out[k] = {["binding-form?"] = utils["member?"](k, binding_3f), ["body-form?"] = utils["member?"](k, body_3f), ["define?"] = utils["member?"](k, define_3f), ["macro?"] = true}
    end
    for k, v in pairs(_G) do
      local _733_0 = type(v)
      if (_733_0 == "function") then
      local _751_0 = type(v)
      if (_751_0 == "function") then
        out[k] = {["function?"] = true, ["global?"] = true}
      elseif (_733_0 == "table") then
        for k2, v2 in pairs(v) do
          if (("function" == type(v2)) and (k ~= "_G")) then
            out[(k .. "." .. k2)] = {["function?"] = true, ["global?"] = true}
      elseif (_751_0 == "table") then
        if not k:find("^_") then
          for k2, v2 in pairs(v) do
            if ("function" == type(v2)) then
              out[(k .. "." .. k2)] = {["function?"] = true, ["global?"] = true}
            end
          end
          out[k] = {["global?"] = true}
        end
        out[k] = {["global?"] = true}
      end
    end
    return out


@@ 5428,19 5547,22 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
  do
    local module_name = "fennel.macros"
    local _ = nil
    local function _736_()
    local function _755_()
      return mod
    end
    package.preload[module_name] = _736_
    package.preload[module_name] = _755_
    _ = nil
    local env = nil
    do
      local _737_0 = specials["make-compiler-env"](nil, compiler.scopes.compiler, {})
      _737_0["utils"] = utils
      _737_0["fennel"] = mod
      env = _737_0
      local _756_0 = specials["make-compiler-env"](nil, compiler.scopes.compiler, {})
      _756_0["utils"] = utils
      _756_0["fennel"] = mod
      _756_0["get-function-metadata"] = specials["get-function-metadata"]
      env = _756_0
    end
    local built_ins = eval([===[;; These macros are awkward because their definition cannot rely on the any
    local built_ins = eval([===[;; fennel-ls: macro-file
    
    ;; These macros are awkward because their definition cannot rely on the any
    ;; built-in macros, only special forms. (no when, no icollect, etc)
    
    (fn copy [t]


@@ 5541,7 5663,8 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
                      ,...)
            closer `(fn close-handlers# [ok# ...]
                      (if ok# ... (error ... 0)))
            traceback `(. (or package.loaded.fennel debug) :traceback)]
            traceback `(. (or (. package.loaded ,(fennel-module-name)) debug)
                          :traceback)]
        (for [i 1 (length closable-bindings) 2]
          (assert (sym? (. closable-bindings i))
                  "with-open only allows symbols in bindings")


@@ 5563,7 5686,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
                (table.remove iter-out i)))))
      (assert (or (not found?) (sym? into) (table? into) (list? into))
              "expected table, function call, or symbol in &into clause")
      (values into iter-out))
      (values into iter-out found?))
    
    (fn collect* [iter-tbl key-expr value-expr ...]
      "Return a table made by running an iterator and evaluating an expression that


@@ 5601,17 5724,23 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
      (assert (not= nil value-expr) "expected table value expression")
      (assert (= nil ...)
              "expected exactly one body expression. Wrap multiple expressions in do")
      (let [(into iter) (extract-into iter-tbl)]
        `(let [tbl# ,into]
           ;; believe it or not, using a var here has a pretty good performance
           ;; boost: https://p.hagelb.org/icollect-performance.html
           (var i# (length tbl#))
           (,how ,iter
                 (let [val# ,value-expr]
                   (when (not= nil val#)
                     (set i# (+ i# 1))
                     (tset tbl# i# val#))))
           tbl#)))
      (let [(into iter has-into?) (extract-into iter-tbl)]
        (if has-into?
            `(let [tbl# ,into]
               (,how ,iter (let [val# ,value-expr]
                             (table.insert tbl# val#)))
               tbl#)
            ;; believe it or not, using a var here has a pretty good performance
            ;; boost: https://p.hagelb.org/icollect-performance.html
            ;; but it doesn't always work with &into clauses, so skip if that's used
            `(let [tbl# []]
               (var i# 0)
               (,how ,iter
                     (let [val# ,value-expr]
                       (when (not= nil val#)
                         (set i# (+ i# 1))
                         (tset tbl# i# val#))))
               tbl#))))
    
    (fn icollect* [iter-tbl value-expr ...]
      "Return a sequential table made by running an iterator and evaluating an


@@ 5745,7 5874,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
              (.. "Expected n to be an integer >= 0, got " (tostring n)))
      (let [let-syms (list)
            let-values (if (= 1 (select "#" ...)) ... `(values ,...))]
        (for [i 1 n]
        (for [_ 1 n]
          (table.insert let-syms (gensym)))
        (if (= n 0) `(values)
            `(let [,let-syms ,let-values]


@@ 5760,19 5889,16 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
            has-internal-name? (sym? (. args 1))
            arglist (if has-internal-name? (. args 2) (. args 1))
            metadata-position (if has-internal-name? 3 2)
            has-metadata? (and (< metadata-position args-len)
                               (or (= :string (type (. args metadata-position)))
                                   (utils.kv-table? (. args metadata-position))))
            arity-check-position (- 4 (if has-internal-name? 0 1)
                                    (if has-metadata? 0 1))
            empty-body? (< args-len arity-check-position)]
            (f-metadata check-position) (get-function-metadata [:lambda ...] arglist
                                                               metadata-position)
            empty-body? (< args-len check-position)]
        (fn check! [a]
          (if (table? a)
              (each [_ a (pairs a)] (check! a))
              (let [as (tostring a)]
                (and (not (as:match "^?")) (not= as "&") (not= as "_")
                     (not= as "...") (not= as "&as")))
              (table.insert args arity-check-position
              (table.insert args check-position
                            `(_G.assert (not= nil ,a)
                                        ,(: "Missing argument %s on %s:%s" :format
                                            (tostring a)


@@ 5781,8 5907,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
    
        (assert (= :table (type arglist)) "expected arg list")
        (each [_ a (ipairs arglist)] (check! a))
        (if empty-body?
            (table.insert args (sym :nil)))
        (if empty-body? (table.insert args (sym :nil)))
        `(fn ,(unpack args))))
    
    (fn macro* [name ...]


@@ 5830,6 5955,32 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
                (tset scope.macros import-key (. macros* macro-name))))))
      nil)
    
    (fn assert-repl* [condition ...]
      "Enter into a debug REPL  and print the message when condition is false/nil.
    Works as a drop-in replacement for Lua's `assert`.
    REPL `,return` command returns values to assert in place to continue execution."
      {:fnl/arglist [condition ?message ...]}
      (fn add-locals [{: symmeta : parent} locals]
        (each [name (pairs symmeta)]
          (tset locals name (sym name)))
        (if parent (add-locals parent locals) locals))
      `(let [unpack# (or table.unpack _G.unpack)
             pack# (or table.pack #(doto [$...] (tset :n (select :# $...))))
             ;; need to pack/unpack input args to account for (assert (foo)),
             ;; because assert returns *all* arguments upon success
             vals# (pack# ,condition ,...)
             condition# (. vals# 1)
             message# (or (. vals# 2) "assertion failed, entering repl.")]
         (if (not condition#)
             (let [opts# {:assert-repl? true}
                   fennel# (require ,(fennel-module-name))
                   locals# ,(add-locals (get-scope) [])]
               (set opts#.message (fennel#.traceback message#))
               (set opts#.env (collect [k# v# (pairs _G) &into locals#]
                                (if (= nil (. locals# k#)) (values k# v#))))
               (_G.assert (fennel#.repl opts#)))
             (values (unpack# vals# 1 vals#.n)))))
    
    {:-> ->*
     :->> ->>*
     :-?> -?>*


@@ 5850,14 6001,17 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
     :pick-values pick-values*
     :macro macro*
     :macrodebug macrodebug*
     :import-macros import-macros*}
     :import-macros import-macros*
     :assert-repl assert-repl*}
    ]===], {env = env, filename = "src/fennel/macros.fnl", moduleName = module_name, scope = compiler.scopes.compiler, useMetadata = true})
    local _0 = nil
    for k, v in pairs(built_ins) do
      compiler.scopes.global.macros[k] = v
    end
    _0 = nil
    local match_macros = eval([===[;;; Pattern matching
    local match_macros = eval([===[;; fennel-ls: macro-file
    
    ;;; Pattern matching
    ;; This is separated out so we can use the "core" macros during the
    ;; implementation of pattern matching.
    


@@ 5960,7 6114,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
                       (let [in-pattern (symbols-in-pattern pattern)]
                         (if ?symbols
                           (do
                             (each [name symbol (pairs ?symbols)]
                             (each [name (pairs ?symbols)]
                               (when (not (. in-pattern name))
                                 (tset ?symbols name nil)))
                             ?symbols)


@@ 5972,13 6126,12 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
    
    (fn case-or [vals pattern guards unifications case-pattern opts]
      (let [pattern [(unpack pattern 2)]
            bindings (symbols-in-every-pattern pattern opts.infer-unification?)] ;; TODO opts.infer-unification instead of opts.unification?
            bindings (symbols-in-every-pattern pattern opts.infer-unification?)]
        (if (= 0 (length bindings))
          ;; no bindings special case generates simple code
          (let [condition
                (icollect [i subpattern (ipairs pattern) &into `(or)]
                  (let [(subcondition subbindings) (case-pattern vals subpattern unifications opts)]
                    subcondition))]
                (icollect [_ subpattern (ipairs pattern) &into `(or)]
                  (case-pattern vals subpattern unifications opts))]
            (values
              (if (= 0 (length guards))
                condition


@@ 5989,7 6142,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
                bindings-mangled (icollect [_ binding (ipairs bindings)]
                                   (gensym (tostring binding)))
                pre-bindings `(if)]
            (each [i subpattern (ipairs pattern)]
            (each [_ subpattern (ipairs pattern)]
              (let [(subcondition subbindings) (case-guard vals subpattern guards {} case-pattern opts)]
                (table.insert pre-bindings subcondition)
                (table.insert pre-bindings `(let ,subbindings


@@ 6155,7 6308,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
          (case-condition (list val) clauses match?)
          ;; protect against multiple evaluation of the value, bind against as
          ;; many values as we ever match against in the clauses.
          (let [vals (fcollect [i 1 vals-count &into (list)] (gensym))]
          (let [vals (fcollect [_ 1 vals-count &into (list)] (gensym))]
            (list `let [vals val] (case-condition vals clauses match?))))))
    
    (fn case* [val ...]


@@ 6251,20 6404,20 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
end
fennel = require("fennel")
local unpack = (table.unpack or _G.unpack)
local help = "\nUsage: fennel [FLAG] [FILE]\n\nRun fennel, a lisp programming language for the Lua runtime.\n\n  --repl                   : Command to launch an interactive repl session\n  --compile FILES (-c)     : Command to AOT compile files, writing Lua to stdout\n  --eval SOURCE (-e)       : Command to evaluate source code and print result\n\n  --no-searcher            : Skip installing package.searchers entry\n  --indent VAL             : Indent compiler output with VAL\n  --add-package-path PATH  : Add PATH to package.path for finding Lua modules\n  --add-package-cpath PATH : Add PATH to package.cpath for finding Lua modules\n  --add-fennel-path PATH   : Add PATH to fennel.path for finding Fennel modules\n  --add-macro-path PATH    : Add PATH to fennel.macro-path for macro modules\n  --globals G1[,G2...]     : Allow these globals in addition to standard ones\n  --globals-only G1[,G2]   : Same as above, but exclude standard ones\n  --require-as-include     : Inline required modules in the output\n  --skip-include M1[,M2]   : Omit certain modules from output when included\n  --use-bit-lib            : Use LuaJITs bit library instead of operators\n  --metadata               : Enable function metadata, even in compiled output\n  --no-metadata            : Disable function metadata, even in REPL\n  --correlate              : Make Lua output line numbers match Fennel input\n  --load FILE (-l)         : Load the specified FILE before executing command\n  --lua LUA_EXE            : Run in a child process with LUA_EXE\n  --no-fennelrc            : Skip loading ~/.fennelrc when launching repl\n  --raw-errors             : Disable friendly compile error reporting\n  --plugin FILE            : Activate the compiler plugin in FILE\n  --compile-binary FILE\n      OUT LUA_LIB LUA_DIR  : Compile FILE to standalone binary OUT\n  --compile-binary --help  : Display further help for compiling binaries\n  --no-compiler-sandbox    : Don't limit compiler environment to minimal sandbox\n\n  --help (-h)              : Display this text\n  --version (-v)           : Show version\n\nGlobals are not checked when doing AOT (ahead-of-time) compilation unless\nthe --globals-only or --globals flag is provided. Use --globals \"*\" to disable\nstrict globals checking in other contexts.\n\nMetadata is typically considered a development feature and is not recommended\nfor production. It is used for docstrings and enabled by default in the REPL.\n\nWhen not given a command, runs the file given as the first argument.\nWhen given neither command nor file, launches a repl.\n\nUse the NO_COLOR environment variable to disable escape codes in error messages.\n\nIf ~/.fennelrc exists, it will be loaded before launching a repl."
local help = "Usage: fennel [FLAG] [FILE]\n\nRun fennel, a lisp programming language for the Lua runtime.\n\n  --repl                   : Command to launch an interactive repl session\n  --compile FILES (-c)     : Command to AOT compile files, writing Lua to stdout\n  --eval SOURCE (-e)       : Command to evaluate source code and print result\n\n  --correlate              : Make Lua output line numbers match Fennel input\n  --load FILE (-l)         : Load the specified FILE before executing command\n  --no-compiler-sandbox    : Don't limit compiler environment to minimal sandbox\n  --compile-binary FILE\n      OUT LUA_LIB LUA_DIR  : Compile FILE to standalone binary OUT\n  --compile-binary --help  : Display further help for compiling binaries\n  --add-package-path PATH  : Add PATH to package.path for finding Lua modules\n  --add-package-cpath PATH : Add PATH to package.cpath for finding Lua modules\n  --add-fennel-path PATH   : Add PATH to fennel.path for finding Fennel modules\n  --add-macro-path PATH    : Add PATH to fennel.macro-path for macro modules\n  --globals G1[,G2...]     : Allow these globals in addition to standard ones\n  --globals-only G1[,G2]   : Same as above, but exclude standard ones\n  --assert-as-repl         : Replace assert calls with assert-repl\n  --require-as-include     : Inline required modules in the output\n  --skip-include M1[,M2]   : Omit certain modules from output when included\n  --use-bit-lib            : Use LuaJITs bit library instead of operators\n  --metadata               : Enable function metadata, even in compiled output\n  --no-metadata            : Disable function metadata, even in REPL\n  --lua LUA_EXE            : Run in a child process with LUA_EXE\n  --plugin FILE            : Activate the compiler plugin in FILE\n  --raw-errors             : Disable friendly compile error reporting\n  --no-searcher            : Skip installing package.searchers entry\n  --no-fennelrc            : Skip loading ~/.fennelrc when launching repl\n\n  --help (-h)              : Display this text\n  --version (-v)           : Show version\n\nGlobals are not checked when doing AOT (ahead-of-time) compilation unless\nthe --globals-only or --globals flag is provided. Use --globals \"*\" to disable\nstrict globals checking in other contexts.\n\nMetadata is typically considered a development feature and is not recommended\nfor production. It is used for docstrings and enabled by default in the REPL.\n\nWhen not given a command, runs the file given as the first argument.\nWhen given neither command nor file, launches a repl.\n\nUse the NO_COLOR environment variable to disable escape codes in error messages.\n\nIf ~/.fennelrc exists, it will be loaded before launching a repl."
local options = {plugins = {}}
local function pack(...)
  local _738_0 = {...}
  _738_0["n"] = select("#", ...)
  return _738_0
  local _757_0 = {...}
  _757_0["n"] = select("#", ...)
  return _757_0
end
local function dosafely(f, ...)
  local args = {...}
  local result = nil
  local function _739_()
  local function _758_()
    return f(unpack(args))
  end
  result = pack(xpcall(_739_, fennel.traceback))
  result = pack(xpcall(_758_, fennel.traceback))
  if not result[1] then
    do end (io.stderr):write((result[2] .. "\n"))
    os.exit(1)


@@ 6309,19 6462,18 @@ local function handle_lua(i)
  if (nil == arg[-1]) then
    do end (io.stderr):write("WARNING: --lua argument only works from script, not binary.\n")
  end
  local ok = os.execute(table.concat(cmd, " "))
  local _744_
  if ok then
    _744_ = 0
  local _763_0, _764_0 = os.execute(table.concat(cmd, " "))
  if (((_763_0 == true) and (_764_0 == "exit")) or (_763_0 == 0)) then
    return os.exit(0, true)
  else
    _744_ = 1
    local _ = _763_0
    return os.exit(1, true)
  end
  return os.exit(_744_, true)
end
assert(arg, "Using the launcher from non-CLI context; use fennel.lua instead.")
for i = #arg, 1, -1 do
  local _746_0 = arg[i]
  if (_746_0 == "--lua") then
  local _766_0 = arg[i]
  if (_766_0 == "--lua") then
    handle_lua(i)
  end
end


@@ 6329,55 6481,58 @@ do
  local commands = {["-"] = true, ["--compile"] = true, ["--compile-binary"] = true, ["--eval"] = true, ["--help"] = true, ["--repl"] = true, ["--version"] = true, ["-c"] = true, ["-e"] = true, ["-h"] = true, ["-v"] = true}
  local i = 1
  while (arg[i] and not options["ignore-options"]) do
    local _748_0 = arg[i]
    if (_748_0 == "--no-searcher") then
    local _768_0 = arg[i]
    if (_768_0 == "--no-searcher") then
      options["no-searcher"] = true
      table.remove(arg, i)
    elseif (_748_0 == "--indent") then
    elseif (_768_0 == "--indent") then
      options.indent = table.remove(arg, (i + 1))
      if (options.indent == "false") then
        options.indent = false
      end
      table.remove(arg, i)
    elseif (_748_0 == "--add-package-path") then
    elseif (_768_0 == "--add-package-path") then
      local entry = table.remove(arg, (i + 1))
      package.path = (entry .. ";" .. package.path)
      table.remove(arg, i)
    elseif (_748_0 == "--add-package-cpath") then
    elseif (_768_0 == "--add-package-cpath") then
      local entry = table.remove(arg, (i + 1))
      package.cpath = (entry .. ";" .. package.cpath)
      table.remove(arg, i)
    elseif (_748_0 == "--add-fennel-path") then
    elseif (_768_0 == "--add-fennel-path") then
      local entry = table.remove(arg, (i + 1))
      fennel.path = (entry .. ";" .. fennel.path)
      table.remove(arg, i)
    elseif (_748_0 == "--add-macro-path") then
    elseif (_768_0 == "--add-macro-path") then
      local entry = table.remove(arg, (i + 1))
      fennel["macro-path"] = (entry .. ";" .. fennel["macro-path"])
      table.remove(arg, i)
    elseif (_748_0 == "--load") then
    elseif (_768_0 == "--load") then
      handle_load(i)
    elseif (_748_0 == "-l") then
    elseif (_768_0 == "-l") then
      handle_load(i)
    elseif (_748_0 == "--no-fennelrc") then
    elseif (_768_0 == "--no-fennelrc") then
      options.fennelrc = false
      table.remove(arg, i)
    elseif (_748_0 == "--correlate") then
    elseif (_768_0 == "--correlate") then
      options.correlate = true
      table.remove(arg, i)
    elseif (_748_0 == "--check-unused-locals") then
    elseif (_768_0 == "--check-unused-locals") then
      options.checkUnusedLocals = true
      table.remove(arg, i)
    elseif (_748_0 == "--globals") then
    elseif (_768_0 == "--globals") then
      allow_globals(table.remove(arg, (i + 1)), _G)
      table.remove(arg, i)
    elseif (_748_0 == "--globals-only") then
    elseif (_768_0 == "--globals-only") then
      allow_globals(table.remove(arg, (i + 1)), {})
      table.remove(arg, i)
    elseif (_748_0 == "--require-as-include") then
    elseif (_768_0 == "--require-as-include") then
      options.requireAsInclude = true
      table.remove(arg, i)
    elseif (_748_0 == "--skip-include") then
    elseif (_768_0 == "--assert-as-repl") then
      options.assertAsRepl = true
      table.remove(arg, i)
    elseif (_768_0 == "--skip-include") then
      local skip_names = table.remove(arg, (i + 1))
      local skip = nil
      do


@@ 6394,28 6549,28 @@ do
      end
      options.skipInclude = skip
      table.remove(arg, i)
    elseif (_748_0 == "--use-bit-lib") then
    elseif (_768_0 == "--use-bit-lib") then
      options.useBitLib = true
      table.remove(arg, i)
    elseif (_748_0 == "--metadata") then
    elseif (_768_0 == "--metadata") then
      options.useMetadata = true
      table.remove(arg, i)
    elseif (_748_0 == "--no-metadata") then
    elseif (_768_0 == "--no-metadata") then
      options.useMetadata = false
      table.remove(arg, i)
    elseif (_748_0 == "--no-compiler-sandbox") then
    elseif (_768_0 == "--no-compiler-sandbox") then
      options["compiler-env"] = _G
      table.remove(arg, i)
    elseif (_748_0 == "--raw-errors") then
    elseif (_768_0 == "--raw-errors") then
      options.unfriendly = true
      table.remove(arg, i)
    elseif (_748_0 == "--plugin") then
    elseif (_768_0 == "--plugin") then
      local opts = {["compiler-env"] = _G, env = "_COMPILER", useMetadata = true}
      local plugin = fennel.dofile(table.remove(arg, (i + 1)), opts)
      table.insert(options.plugins, 1, plugin)
      table.remove(arg, i)
    else
      local _ = _748_0
      local _ = _768_0
      if not commands[arg[i]] then
        options["ignore-options"] = true
        i = (i + 1)


@@ 6451,25 6606,25 @@ local function load_initfile()
end
local function repl()
  local readline_3f = (("dumb" ~= os.getenv("TERM")) and pcall(require, "readline"))
  local welcome = {("Welcome to " .. fennel["runtime-version"]() .. "!"), "Use ,help to see available commands."}
  searcher_opts.useMetadata = (false ~= options.useMetadata)
  if (false ~= options.fennelrc) then
    options["fennelrc"] = load_initfile
  end
  print(("Welcome to " .. fennel["runtime-version"]() .. "!"))
  print("Use ,help to see available commands.")
  if (not readline_3f and ("dumb" ~= os.getenv("TERM"))) then
    print("Try installing readline via luarocks for a better repl experience.")
    table.insert(welcome, ("Try installing readline via luarocks for a " .. "better repl experience."))
  end
  options.message = table.concat(welcome, "\n")
  return fennel.repl(options)
end
local function eval(form)
  local _758_
  local _778_
  if (form == "-") then
    _758_ = (io.stdin):read("*a")
    _778_ = (io.stdin):read("*a")
  else
    _758_ = form
    _778_ = form
  end
  return print(dosafely(fennel.eval, _758_, options))
  return print(dosafely(fennel.eval, _778_, options))
end
local function compile(files)
  for _, filename in ipairs(files) do


@@ 6481,17 6636,17 @@ local function compile(files)
      f = assert(io.open(filename, "rb"))
    end
    do
      local _761_0, _762_0 = nil, nil
      local function _763_()
      local _781_0, _782_0 = nil, nil
      local function _783_()
        return fennel["compile-string"](f:read("*a"), options)
      end
      _761_0, _762_0 = xpcall(_763_, fennel.traceback)
      if ((_761_0 == true) and (nil ~= _762_0)) then
        local val = _762_0
      _781_0, _782_0 = xpcall(_783_, fennel.traceback)
      if ((_781_0 == true) and (nil ~= _782_0)) then
        local val = _782_0
        print(val)
      elseif (true and (nil ~= _762_0)) then
        local _0 = _761_0
        local msg = _762_0
      elseif (true and (nil ~= _782_0)) then
        local _0 = _781_0
        local msg = _782_0
        do end (io.stderr):write((msg .. "\n"))
        os.exit(1)
      end


@@ 6500,57 6655,56 @@ local function compile(files)
  end
  return nil
end
local _765_0 = arg
local function _766_(...)
local _785_0 = arg
local function _786_(...)
  return (0 == #arg)
end
if ((_G.type(_765_0) == "table") and _766_(...)) then
if ((_G.type(_785_0) == "table") and _786_(...)) then
  return repl()
elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--repl")) then
elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--repl")) then
  return repl()
elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--compile")) then
  local files = {select(2, (table.unpack or _G.unpack)(_765_0))}
elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--compile")) then
  local files = {select(2, (table.unpack or _G.unpack)(_785_0))}
  return compile(files)
elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "-c")) then
  local files = {select(2, (table.unpack or _G.unpack)(_765_0))}
elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "-c")) then
  local files = {select(2, (table.unpack or _G.unpack)(_785_0))}
  return compile(files)
elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--compile-binary") and (nil ~= _765_0[2]) and (nil ~= _765_0[3]) and (nil ~= _765_0[4]) and (nil ~= _765_0[5])) then
  local filename = _765_0[2]
  local out = _765_0[3]
  local static_lua = _765_0[4]
  local lua_include_dir = _765_0[5]
  local args = {select(6, (table.unpack or _G.unpack)(_765_0))}
elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--compile-binary") and (nil ~= _785_0[2]) and (nil ~= _785_0[3]) and (nil ~= _785_0[4]) and (nil ~= _785_0[5])) then
  local filename = _785_0[2]
  local out = _785_0[3]
  local static_lua = _785_0[4]
  local lua_include_dir = _785_0[5]
  local args = {select(6, (table.unpack or _G.unpack)(_785_0))}
  local bin = require("fennel.binary")
  options.filename = filename
  options.requireAsInclude = true
  return bin.compile(filename, out, static_lua, lua_include_dir, options, args)
elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--compile-binary")) then
elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--compile-binary")) then
  local cmd = (arg[0] or "fennel")
  return print((require("fennel.binary").help):format(cmd, cmd, cmd))
elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--eval") and (nil ~= _765_0[2])) then
  local form = _765_0[2]
elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--eval") and (nil ~= _785_0[2])) then
  local form = _785_0[2]
  return eval(form)
elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "-e") and (nil ~= _765_0[2])) then
  local form = _765_0[2]
elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "-e") and (nil ~= _785_0[2])) then
  local form = _785_0[2]
  return eval(form)
else
  local function _794_(...)
    local a = _765_0[1]
  local function _816_(...)
    local a = _785_0[1]
    return ((a == "-v") or (a == "--version"))
  end
  if (((_G.type(_765_0) == "table") and (nil ~= _765_0[1])) and _794_(...)) then
    local a = _765_0[1]
  if (((_G.type(_785_0) == "table") and (nil ~= _785_0[1])) and _816_(...)) then
    local a = _785_0[1]
    return print(fennel["runtime-version"]())
  elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--help")) then
  elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--help")) then
    return print(help)
  elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "-h")) then
  elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "-h")) then
    return print(help)
  elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "-")) then
    local args = {select(2, (table.unpack or _G.unpack)(_765_0))}
  elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "-")) then
    return dosafely(fennel.eval, (io.stdin):read("*a"))
  elseif ((_G.type(_765_0) == "table") and (nil ~= _765_0[1])) then
    local filename = _765_0[1]
    local args = {select(2, (table.unpack or _G.unpack)(_765_0))}
  elseif ((_G.type(_785_0) == "table") and (nil ~= _785_0[1])) then
    local filename = _785_0[1]
    local args = {select(2, (table.unpack or _G.unpack)(_785_0))}
    arg[-2] = arg[-1]
    arg[-1] = arg[0]
    arg[0] = table.remove(arg, 1)

M fennel.lua => fennel.lua +1078 -934
@@ 1,19 1,21 @@
-- SPDX-License-Identifier: MIT
-- SPDX-FileCopyrightText: Calvin Rose and contributors
package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
  local utils = require("fennel.utils")
  local parser = require("fennel.parser")
  local compiler = require("fennel.compiler")
  local specials = require("fennel.specials")
  local view = require("fennel.view")
  local unpack = (table.unpack or _G.unpack)
  local function default_read_chunk(parser_state)
    local function _604_()
      if (0 < parser_state["stack-size"]) then
        return ".."
      else
        return ">> "
      end
  local depth = 0
  local function prompt_for(top_3f)
    if top_3f then
      return (string.rep(">", (depth + 1)) .. " ")
    else
      return (string.rep(".", (depth + 1)) .. " ")
    end
    io.write(_604_())
  end
  local function default_read_chunk(parser_state)
    io.write(prompt_for((0 == parser_state["stack-size"])))
    io.flush()
    local input = io.read()
    return (input and (input .. "\n"))


@@ 23,18 25,18 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    return io.write("\n")
  end
  local function default_on_error(errtype, err, lua_source)
    local function _606_()
      local _605_0 = errtype
      if (_605_0 == "Lua Compile") then
    local function _616_()
      local _615_0 = errtype
      if (_615_0 == "Lua Compile") then
        return ("Bad code generated - likely a bug with the compiler:\n" .. "--- Generated Lua Start ---\n" .. lua_source .. "--- Generated Lua End ---\n")
      elseif (_605_0 == "Runtime") then
      elseif (_615_0 == "Runtime") then
        return (compiler.traceback(tostring(err), 4) .. "\n")
      else
        local _ = _605_0
        local _ = _615_0
        return ("%s error: %s\n"):format(errtype, tostring(err))
      end
    end
    return io.write(_606_())
    return io.write(_616_())
  end
  local function splice_save_locals(env, lua_source, scope)
    local saves = nil


@@ 42,7 44,7 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
      local tbl_17_ = {}
      local i_18_ = #tbl_17_
      for name in pairs(env.___replLocals___) do
        local val_19_ = ("local %s = ___replLocals___['%s']"):format((scope.manglings[name] or name), name)
        local val_19_ = ("local %s = ___replLocals___[%q]"):format((scope.manglings[name] or name), name)
        if (nil ~= val_19_) then
          i_18_ = (i_18_ + 1)
          tbl_17_[i_18_] = val_19_


@@ 57,7 59,7 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
      for raw, name in pairs(scope.manglings) do
        local val_19_ = nil
        if not scope.gensyms[name] then
          val_19_ = ("___replLocals___['%s'] = %s"):format(raw, name)
          val_19_ = ("___replLocals___[%q] = %s"):format(raw, name)
        else
        val_19_ = nil
        end


@@ 74,25 76,25 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    else
      gap = " "
    end
    local function _612_()
    local function _622_()
      if next(saves) then
        return (table.concat(saves, " ") .. gap)
      else
        return ""
      end
    end
    local function _615_()
      local _613_0, _614_0 = lua_source:match("^(.*)[\n ](return .*)$")
      if ((nil ~= _613_0) and (nil ~= _614_0)) then
        local body = _613_0
        local _return = _614_0
    local function _625_()
      local _623_0, _624_0 = lua_source:match("^(.*)[\n ](return .*)$")
      if ((nil ~= _623_0) and (nil ~= _624_0)) then
        local body = _623_0
        local _return = _624_0
        return (body .. gap .. table.concat(binds, " ") .. gap .. _return)
      else
        local _ = _613_0
        local _ = _623_0
        return lua_source
      end
    end
    return (_612_() .. _615_())
    return (_622_() .. _625_())
  end
  local function completer(env, scope, text)
    local max_items = 2000


@@ 104,14 106,14 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
      local scope_first_3f = ((tbl == env) or (tbl == env.___replLocals___))
      local tbl_17_ = matches
      local i_18_ = #tbl_17_
      local function _617_()
      local function _627_()
        if scope_first_3f then
          return scope.manglings
        else
          return tbl
        end
      end
      for k, is_mangled in utils.allpairs(_617_()) do
      for k, is_mangled in utils.allpairs(_627_()) do
        if (max_items <= #matches) then break end
        local val_19_ = nil
        do


@@ 179,7 181,7 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    return input:match("^%s*,")
  end
  local function command_docs()
    local _626_
    local _636_
    do
      local tbl_17_ = {}
      local i_18_ = #tbl_17_


@@ 190,18 192,18 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
          tbl_17_[i_18_] = val_19_
        end
      end
      _626_ = tbl_17_
      _636_ = tbl_17_
    end
    return table.concat(_626_, "\n")
    return table.concat(_636_, "\n")
  end
  commands.help = function(_, _0, on_values)
    return on_values({("Welcome to Fennel.\nThis is the REPL where you can enter code to be evaluated.\nYou can also run these repl commands:\n\n" .. command_docs() .. "\n  ,exit - Leave the repl.\n\nUse ,doc something to see descriptions for individual macros and special forms.\n\nFor more information about the language, see https://fennel-lang.org/reference")})
    return on_values({("Welcome to Fennel.\nThis is the REPL where you can enter code to be evaluated.\nYou can also run these repl commands:\n\n" .. command_docs() .. "\n  ,return FORM - Evaluate FORM and return its value to the REPL's caller.\n  ,exit - Leave the repl.\n\nUse ,doc something to see descriptions for individual macros and special forms.\nValues from previous inputs are kept in *1, *2, and *3.\n\nFor more information about the language, see https://fennel-lang.org/reference")})
  end
  do end (compiler.metadata):set(commands.help, "fnl/docstring", "Show this message.")
  local function reload(module_name, env, on_values, on_error)
    local _628_0, _629_0 = pcall(specials["load-code"]("return require(...)", env), module_name)
    if ((_628_0 == true) and (nil ~= _629_0)) then
      local old = _629_0
    local _638_0, _639_0 = pcall(specials["load-code"]("return require(...)", env), module_name)
    if ((_638_0 == true) and (nil ~= _639_0)) then
      local old = _639_0
      local _ = nil
      package.loaded[module_name] = nil
      _ = nil


@@ 226,8 228,8 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
        package.loaded[module_name] = old
      end
      return on_values({"ok"})
    elseif ((_628_0 == false) and (nil ~= _629_0)) then
      local msg = _629_0
    elseif ((_638_0 == false) and (nil ~= _639_0)) then
      local msg = _639_0
      if msg:match("loop or previous error loading module") then
        package.loaded[module_name] = nil
        return reload(module_name, env, on_values, on_error)


@@ 235,32 237,32 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
        specials["macro-loaded"][module_name] = nil
        return nil
      else
        local function _634_()
          local _633_0 = msg:gsub("\n.*", "")
          return _633_0
        local function _644_()
          local _643_0 = msg:gsub("\n.*", "")
          return _643_0
        end
        return on_error("Runtime", _634_())
        return on_error("Runtime", _644_())
      end
    end
  end
  local function run_command(read, on_error, f)
    local _637_0, _638_0, _639_0 = pcall(read)
    if ((_637_0 == true) and (_638_0 == true) and (nil ~= _639_0)) then
      local val = _639_0
      local _640_0, _641_0 = pcall(f, val)
      if ((_640_0 == false) and (nil ~= _641_0)) then
        local msg = _641_0
    local _647_0, _648_0, _649_0 = pcall(read)
    if ((_647_0 == true) and (_648_0 == true) and (nil ~= _649_0)) then
      local val = _649_0
      local _650_0, _651_0 = pcall(f, val)
      if ((_650_0 == false) and (nil ~= _651_0)) then
        local msg = _651_0
        return on_error("Runtime", msg)
      end
    elseif (_637_0 == false) then
    elseif (_647_0 == false) then
      return on_error("Parse", "Couldn't parse input.")
    end
  end
  commands.reload = function(env, read, on_values, on_error)
    local function _644_(_241)
    local function _654_(_241)
      return reload(tostring(_241), env, on_values, on_error)
    end
    return run_command(read, on_error, _644_)
    return run_command(read, on_error, _654_)
  end
  do end (compiler.metadata):set(commands.reload, "fnl/docstring", "Reload the specified module.")
  commands.reset = function(env, _, on_values)


@@ 269,28 271,28 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
  end
  do end (compiler.metadata):set(commands.reset, "fnl/docstring", "Erase all repl-local scope.")
  commands.complete = function(env, read, on_values, on_error, scope, chars)
    local function _645_()
    local function _655_()
      return on_values(completer(env, scope, table.concat(chars):gsub(",complete +", ""):sub(1, -2)))
    end
    return run_command(read, on_error, _645_)
    return run_command(read, on_error, _655_)
  end
  do end (compiler.metadata):set(commands.complete, "fnl/docstring", "Print all possible completions for a given input symbol.")
  local function apropos_2a(pattern, tbl, prefix, seen, names)
    for name, subtbl in pairs(tbl) do
      if (("string" == type(name)) and (package ~= subtbl)) then
        local _646_0 = type(subtbl)
        if (_646_0 == "function") then
        local _656_0 = type(subtbl)
        if (_656_0 == "function") then
          if ((prefix .. name)):match(pattern) then
            table.insert(names, (prefix .. name))
          end
        elseif (_646_0 == "table") then
        elseif (_656_0 == "table") then
          if not seen[subtbl] then
            local _648_
            local _658_
            do
              seen[subtbl] = true
              _648_ = seen
              _658_ = seen
            end
            apropos_2a(pattern, subtbl, (prefix .. name:gsub("%.", "/") .. "."), _648_, names)
            apropos_2a(pattern, subtbl, (prefix .. name:gsub("%.", "/") .. "."), _658_, names)
          end
        end
      end


@@ 311,10 313,10 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    return tbl_17_
  end
  commands.apropos = function(_env, read, on_values, on_error, _scope)
    local function _653_(_241)
    local function _663_(_241)
      return on_values(apropos(tostring(_241)))
    end
    return run_command(read, on_error, _653_)
    return run_command(read, on_error, _663_)
  end
  do end (compiler.metadata):set(commands.apropos, "fnl/docstring", "Print all functions matching a pattern in all loaded modules.")
  local function apropos_follow_path(path)


@@ 334,12 336,12 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    local tgt = package.loaded
    for _, path0 in ipairs(paths) do
      if (nil == tgt) then break end
      local _656_
      local _666_
      do
        local _655_0 = path0:gsub("%/", ".")
        _656_ = _655_0
        local _665_0 = path0:gsub("%/", ".")
        _666_ = _665_0
      end
      tgt = tgt[_656_]
      tgt = tgt[_666_]
    end
    return tgt
  end


@@ 351,9 353,9 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
      do
        local tgt = apropos_follow_path(path)
        if ("function" == type(tgt)) then
          local _657_0 = (compiler.metadata):get(tgt, "fnl/docstring")
          if (nil ~= _657_0) then
            local docstr = _657_0
          local _667_0 = (compiler.metadata):get(tgt, "fnl/docstring")
          if (nil ~= _667_0) then
            local docstr = _667_0
            val_19_ = (docstr:match(pattern) and path)
          else
          val_19_ = nil


@@ 370,125 372,125 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    return tbl_17_
  end
  commands["apropos-doc"] = function(_env, read, on_values, on_error, _scope)
    local function _661_(_241)
    local function _671_(_241)
      return on_values(apropos_doc(tostring(_241)))
    end
    return run_command(read, on_error, _661_)
    return run_command(read, on_error, _671_)
  end
  do end (compiler.metadata):set(commands["apropos-doc"], "fnl/docstring", "Print all functions that match the pattern in their docs")
  local function apropos_show_docs(on_values, pattern)
    for _, path in ipairs(apropos(pattern)) do
      local tgt = apropos_follow_path(path)
      if (("function" == type(tgt)) and (compiler.metadata):get(tgt, "fnl/docstring")) then
        on_values(specials.doc(tgt, path))
        on_values()
        on_values({specials.doc(tgt, path)})
        on_values({})
      end
    end
    return nil
  end
  commands["apropos-show-docs"] = function(_env, read, on_values, on_error)
    local function _663_(_241)
    local function _673_(_241)
      return apropos_show_docs(on_values, tostring(_241))
    end
    return run_command(read, on_error, _663_)
    return run_command(read, on_error, _673_)
  end
  do end (compiler.metadata):set(commands["apropos-show-docs"], "fnl/docstring", "Print all documentations matching a pattern in function name")
  local function resolve(identifier, _664_0, scope)
    local _665_ = _664_0
    local env = _665_
    local ___replLocals___ = _665_["___replLocals___"]
  local function resolve(identifier, _674_0, scope)
    local _675_ = _674_0
    local env = _675_
    local ___replLocals___ = _675_["___replLocals___"]
    local e = nil
    local function _666_(_241, _242)
    local function _676_(_241, _242)
      return (___replLocals___[scope.unmanglings[_242]] or env[_242])
    end
    e = setmetatable({}, {__index = _666_})
    local function _667_(...)
      local _668_0, _669_0 = ...
      if ((_668_0 == true) and (nil ~= _669_0)) then
        local code = _669_0
        local function _670_(...)
          local _671_0, _672_0 = ...
          if ((_671_0 == true) and (nil ~= _672_0)) then
            local val = _672_0
    e = setmetatable({}, {__index = _676_})
    local function _677_(...)
      local _678_0, _679_0 = ...
      if ((_678_0 == true) and (nil ~= _679_0)) then
        local code = _679_0
        local function _680_(...)
          local _681_0, _682_0 = ...
          if ((_681_0 == true) and (nil ~= _682_0)) then
            local val = _682_0
            return val
          else
            local _ = _671_0
            local _ = _681_0
            return nil
          end
        end
        return _670_(pcall(specials["load-code"](code, e)))
        return _680_(pcall(specials["load-code"](code, e)))
      else
        local _ = _668_0
        local _ = _678_0
        return nil
      end
    end
    return _667_(pcall(compiler["compile-string"], tostring(identifier), {scope = scope}))
    return _677_(pcall(compiler["compile-string"], tostring(identifier), {scope = scope}))
  end
  commands.find = function(env, read, on_values, on_error, scope)
    local function _675_(_241)
      local _676_0 = nil
    local function _685_(_241)
      local _686_0 = nil
      do
        local _677_0 = utils["sym?"](_241)
        if (nil ~= _677_0) then
          local _678_0 = resolve(_677_0, env, scope)
          if (nil ~= _678_0) then
            _676_0 = debug.getinfo(_678_0)
        local _687_0 = utils["sym?"](_241)
        if (nil ~= _687_0) then
          local _688_0 = resolve(_687_0, env, scope)
          if (nil ~= _688_0) then
            _686_0 = debug.getinfo(_688_0)
          else
            _676_0 = _678_0
            _686_0 = _688_0
          end
        else
          _676_0 = _677_0
          _686_0 = _687_0
        end
      end
      if ((_G.type(_676_0) == "table") and (nil ~= _676_0.linedefined) and (nil ~= _676_0.short_src) and (nil ~= _676_0.source) and (_676_0.what == "Lua")) then
        local line = _676_0.linedefined
        local src = _676_0.short_src
        local source = _676_0.source
      if ((_G.type(_686_0) == "table") and (nil ~= _686_0.linedefined) and (nil ~= _686_0.short_src) and (nil ~= _686_0.source) and (_686_0.what == "Lua")) then
        local line = _686_0.linedefined
        local src = _686_0.short_src
        local source = _686_0.source
        local fnlsrc = nil
        do
          local _681_0 = compiler.sourcemap
          if (nil ~= _681_0) then
            _681_0 = _681_0[source]
          local _691_0 = compiler.sourcemap
          if (nil ~= _691_0) then
            _691_0 = _691_0[source]
          end
          if (nil ~= _681_0) then
            _681_0 = _681_0[line]
          if (nil ~= _691_0) then
            _691_0 = _691_0[line]
          end
          if (nil ~= _681_0) then
            _681_0 = _681_0[2]
          if (nil ~= _691_0) then
            _691_0 = _691_0[2]
          end
          fnlsrc = _681_0
          fnlsrc = _691_0
        end
        return on_values({string.format("%s:%s", src, (fnlsrc or line))})
      elseif (_676_0 == nil) then
      elseif (_686_0 == nil) then
        return on_error("Repl", "Unknown value")
      else
        local _ = _676_0
        local _ = _686_0
        return on_error("Repl", "No source info")
      end
    end
    return run_command(read, on_error, _675_)
    return run_command(read, on_error, _685_)
  end
  do end (compiler.metadata):set(commands.find, "fnl/docstring", "Print the filename and line number for a given function")
  commands.doc = function(env, read, on_values, on_error, scope)
    local function _686_(_241)
    local function _696_(_241)
      local name = tostring(_241)
      local path = (utils["multi-sym?"](name) or {name})
      local ok_3f, target = nil, nil
      local function _687_()
      local function _697_()
        return (utils["get-in"](scope.specials, path) or utils["get-in"](scope.macros, path) or resolve(name, env, scope))
      end
      ok_3f, target = pcall(_687_)
      ok_3f, target = pcall(_697_)
      if ok_3f then
        return on_values({specials.doc(target, name)})
      else
        return on_error("Repl", ("Could not find " .. name .. " for docs."))
      end
    end
    return run_command(read, on_error, _686_)
    return run_command(read, on_error, _696_)
  end
  do end (compiler.metadata):set(commands.doc, "fnl/docstring", "Print the docstring and arglist for a function, macro, or special form.")
  commands.compile = function(env, read, on_values, on_error, scope)
    local function _689_(_241)
    local function _699_(_241)
      local allowedGlobals = specials["current-global-names"](env)
      local ok_3f, result = pcall(compiler.compile, _241, {allowedGlobals = allowedGlobals, env = env, scope = scope})
      if ok_3f then


@@ 497,16 499,16 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
        return on_error("Repl", ("Error compiling expression: " .. result))
      end
    end
    return run_command(read, on_error, _689_)
    return run_command(read, on_error, _699_)
  end
  do end (compiler.metadata):set(commands.compile, "fnl/docstring", "compiles the expression into lua and prints the result.")
  local function load_plugin_commands(plugins)
    for _, plugin in ipairs((plugins or {})) do
      for name, f in pairs(plugin) do
        local _691_0 = name:match("^repl%-command%-(.*)")
        if (nil ~= _691_0) then
          local cmd_name = _691_0
          commands[cmd_name] = (commands[cmd_name] or f)
    for i = #(plugins or {}), 1, -1 do
      for name, f in pairs(plugins[i]) do
        local _701_0 = name:match("^repl%-command%-(.*)")
        if (nil ~= _701_0) then
          local cmd_name = _701_0
          commands[cmd_name] = f
        end
      end
    end


@@ 515,19 517,19 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
  local function run_command_loop(input, read, loop, env, on_values, on_error, scope, chars)
    local command_name = input:match(",([^%s/]+)")
    do
      local _693_0 = commands[command_name]
      if (nil ~= _693_0) then
        local command = _693_0
      local _703_0 = commands[command_name]
      if (nil ~= _703_0) then
        local command = _703_0
        command(env, read, on_values, on_error, scope, chars)
      else
        local _ = _693_0
        if ("exit" ~= command_name) then
        local _ = _703_0
        if ((command_name ~= "exit") and (command_name ~= "return")) then
          on_values({"Unknown command", command_name})
        end
      end
    end
    if ("exit" ~= command_name) then
      return loop()
      return loop((command_name == "return"))
    end
  end
  local function try_readline_21(opts, ok, readline)


@@ 570,9 572,9 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
  end
  local function repl(_3foptions)
    local old_root_options = utils.root.options
    local _702_ = utils.copy(_3foptions)
    local opts = _702_
    local _3ffennelrc = _702_["fennelrc"]
    local _712_ = utils.copy(_3foptions)
    local opts = _712_
    local _3ffennelrc = _712_["fennelrc"]
    local _ = nil
    opts.fennelrc = nil
    _ = nil


@@ 587,35 589,42 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
    local callbacks = {env = env, onError = (opts.onError or default_on_error), onValues = (opts.onValues or default_on_values), pp = (opts.pp or view), readChunk = (opts.readChunk or default_read_chunk)}
    local save_locals_3f = (opts.saveLocals ~= false)
    local byte_stream, clear_stream = nil, nil
    local function _704_(_241)
    local function _714_(_241)
      return callbacks.readChunk(_241)
    end
    byte_stream, clear_stream = parser.granulate(_704_)
    byte_stream, clear_stream = parser.granulate(_714_)
    local chars = {}
    local read, reset = nil, nil
    local function _705_(parser_state)
    local function _715_(parser_state)
      local b = byte_stream(parser_state)
      if b then
        table.insert(chars, string.char(b))
      end
      return b
    end