rufus-lua-moon 0.2.6.0 → 0.3.0

data/vendor/leafo/moonscript/parse/literals.lua

@@ -0,0 +1,34 @@
+local safe_module
+safe_module = require("moonscript.util").safe_module
+local S, P, R, C
+do
+  local _obj_0 = require("lpeg")
+  S, P, R, C = _obj_0.S, _obj_0.P, _obj_0.R, _obj_0.C
+end
+local White = S(" \t\r\n") ^ 0
+local plain_space = S(" \t") ^ 0
+local Break = P("\r") ^ -1 * P("\n")
+local Stop = Break + -1
+local Comment = P("--") * (1 - S("\r\n")) ^ 0 * #Stop
+local Space = plain_space * Comment ^ -1
+local SomeSpace = S(" \t") ^ 1 * Comment ^ -1
+local SpaceBreak = Space * Break
+local EmptyLine = SpaceBreak
+local AlphaNum = R("az", "AZ", "09", "__")
+local Name = C(R("az", "AZ", "__") * AlphaNum ^ 0)
+local Num = P("0x") * R("09", "af", "AF") ^ 1 * (S("uU") ^ -1 * S("lL") ^ 2) ^ -1 + R("09") ^ 1 * (S("uU") ^ -1 * S("lL") ^ 2) + (R("09") ^ 1 * (P(".") * R("09") ^ 1) ^ -1 + P(".") * R("09") ^ 1) * (S("eE") * P("-") ^ -1 * R("09") ^ 1) ^ -1
+local Shebang = P("#!") * P(1 - Stop) ^ 0
+return safe_module("moonscript.parse.literals", {
+  White = White,
+  Break = Break,
+  Stop = Stop,
+  Comment = Comment,
+  Space = Space,
+  SomeSpace = SomeSpace,
+  SpaceBreak = SpaceBreak,
+  EmptyLine = EmptyLine,
+  AlphaNum = AlphaNum,
+  Name = Name,
+  Num = Num,
+  Shebang = Shebang
+})

data/vendor/leafo/moonscript/parse/util.lua

@@ -0,0 +1,267 @@
+local unpack
+unpack = require("moonscript.util").unpack
+local P, C, S, Cp, Cmt, V
+do
+  local _obj_0 = require("lpeg")
+  P, C, S, Cp, Cmt, V = _obj_0.P, _obj_0.C, _obj_0.S, _obj_0.Cp, _obj_0.Cmt, _obj_0.V
+end
+local ntype
+ntype = require("moonscript.types").ntype
+local Space
+Space = require("moonscript.parse.literals").Space
+local Indent = C(S("\t ") ^ 0) / function(str)
+  do
+    local sum = 0
+    for v in str:gmatch("[\t ]") do
+      local _exp_0 = v
+      if " " == _exp_0 then
+        sum = sum + 1
+      elseif "\t" == _exp_0 then
+        sum = sum + 4
+      end
+    end
+    return sum
+  end
+end
+local Cut = P(function()
+  return false
+end)
+local ensure
+ensure = function(patt, finally)
+  return patt * finally + finally * Cut
+end
+local extract_line
+extract_line = function(str, start_pos)
+  str = str:sub(start_pos)
+  do
+    local m = str:match("^(.-)\n")
+    if m then
+      return m
+    end
+  end
+  return str:match("^.-$")
+end
+local mark
+mark = function(name)
+  return function(...)
+    return {
+      name,
+      ...
+    }
+  end
+end
+local pos
+pos = function(patt)
+  return (Cp() * patt) / function(pos, value)
+    if type(value) == "table" then
+      value[-1] = pos
+    end
+    return value
+  end
+end
+local got
+got = function(what)
+  return Cmt("", function(str, pos)
+    print("++ got " .. tostring(what), "[" .. tostring(extract_line(str, pos)) .. "]")
+    return true
+  end)
+end
+local flatten_or_mark
+flatten_or_mark = function(name)
+  return function(tbl)
+    if #tbl == 1 then
+      return tbl[1]
+    end
+    table.insert(tbl, 1, name)
+    return tbl
+  end
+end
+local is_assignable
+do
+  local chain_assignable = {
+    index = true,
+    dot = true,
+    slice = true
+  }
+  is_assignable = function(node)
+    if node == "..." then
+      return false
+    end
+    local _exp_0 = ntype(node)
+    if "ref" == _exp_0 or "self" == _exp_0 or "value" == _exp_0 or "self_class" == _exp_0 or "table" == _exp_0 then
+      return true
+    elseif "chain" == _exp_0 then
+      return chain_assignable[ntype(node[#node])]
+    else
+      return false
+    end
+  end
+end
+local check_assignable
+check_assignable = function(str, pos, value)
+  if is_assignable(value) then
+    return true, value
+  else
+    return false
+  end
+end
+local format_assign
+do
+  local flatten_explist = flatten_or_mark("explist")
+  format_assign = function(lhs_exps, assign)
+    if not (assign) then
+      return flatten_explist(lhs_exps)
+    end
+    for _index_0 = 1, #lhs_exps do
+      local assign_exp = lhs_exps[_index_0]
+      if not (is_assignable(assign_exp)) then
+        error({
+          assign_exp,
+          "left hand expression is not assignable"
+        })
+      end
+    end
+    local t = ntype(assign)
+    local _exp_0 = t
+    if "assign" == _exp_0 then
+      return {
+        "assign",
+        lhs_exps,
+        unpack(assign, 2)
+      }
+    elseif "update" == _exp_0 then
+      return {
+        "update",
+        lhs_exps[1],
+        unpack(assign, 2)
+      }
+    else
+      return error("unknown assign expression: " .. tostring(t))
+    end
+  end
+end
+local format_single_assign
+format_single_assign = function(lhs, assign)
+  if assign then
+    return format_assign({
+      lhs
+    }, assign)
+  else
+    return lhs
+  end
+end
+local sym
+sym = function(chars)
+  return Space * chars
+end
+local symx
+symx = function(chars)
+  return chars
+end
+local simple_string
+simple_string = function(delim, allow_interpolation)
+  local inner = P("\\" .. tostring(delim)) + "\\\\" + (1 - P(delim))
+  if allow_interpolation then
+    local interp = symx('#{') * V("Exp") * sym('}')
+    inner = (C((inner - interp) ^ 1) + interp / mark("interpolate")) ^ 0
+  else
+    inner = C(inner ^ 0)
+  end
+  return C(symx(delim)) * inner * sym(delim) / mark("string")
+end
+local wrap_func_arg
+wrap_func_arg = function(value)
+  return {
+    "call",
+    {
+      value
+    }
+  }
+end
+local flatten_func
+flatten_func = function(callee, args)
+  if #args == 0 then
+    return callee
+  end
+  args = {
+    "call",
+    args
+  }
+  if ntype(callee) == "chain" then
+    local stub = callee[#callee]
+    if ntype(stub) == "colon_stub" then
+      stub[1] = "colon"
+      table.insert(stub, args)
+    else
+      table.insert(callee, args)
+    end
+    return callee
+  end
+  return {
+    "chain",
+    callee,
+    args
+  }
+end
+local flatten_string_chain
+flatten_string_chain = function(str, chain, args)
+  if not (chain) then
+    return str
+  end
+  return flatten_func({
+    "chain",
+    str,
+    unpack(chain)
+  }, args)
+end
+local wrap_decorator
+wrap_decorator = function(stm, dec)
+  if not (dec) then
+    return stm
+  end
+  return {
+    "decorated",
+    stm,
+    dec
+  }
+end
+local check_lua_string
+check_lua_string = function(str, pos, right, left)
+  return #left == #right
+end
+local self_assign
+self_assign = function(name, pos)
+  return {
+    {
+      "key_literal",
+      name
+    },
+    {
+      "ref",
+      name,
+      [-1] = pos
+    }
+  }
+end
+return {
+  Indent = Indent,
+  Cut = Cut,
+  ensure = ensure,
+  extract_line = extract_line,
+  mark = mark,
+  pos = pos,
+  flatten_or_mark = flatten_or_mark,
+  is_assignable = is_assignable,
+  check_assignable = check_assignable,
+  format_assign = format_assign,
+  format_single_assign = format_single_assign,
+  sym = sym,
+  symx = symx,
+  simple_string = simple_string,
+  wrap_func_arg = wrap_func_arg,
+  flatten_func = flatten_func,
+  flatten_string_chain = flatten_string_chain,
+  wrap_decorator = wrap_decorator,
+  check_lua_string = check_lua_string,
+  self_assign = self_assign
+}

data/vendor/leafo/moonscript/parse.lua

@@ -0,0 +1,235 @@
+local debug_grammar = false
+local lpeg = require("lpeg")
+lpeg.setmaxstack(10000)
+local err_msg = "Failed to parse:%s\n [%d] >>    %s"
+local Stack
+Stack = require("moonscript.data").Stack
+local trim, pos_to_line, get_line
+do
+  local _obj_0 = require("moonscript.util")
+  trim, pos_to_line, get_line = _obj_0.trim, _obj_0.pos_to_line, _obj_0.get_line
+end
+local unpack
+unpack = require("moonscript.util").unpack
+local wrap_env
+wrap_env = require("moonscript.parse.env").wrap_env
+local R, S, V, P, C, Ct, Cmt, Cg, Cb, Cc
+R, S, V, P, C, Ct, Cmt, Cg, Cb, Cc = lpeg.R, lpeg.S, lpeg.V, lpeg.P, lpeg.C, lpeg.Ct, lpeg.Cmt, lpeg.Cg, lpeg.Cb, lpeg.Cc
+local White, Break, Stop, Comment, Space, SomeSpace, SpaceBreak, EmptyLine, AlphaNum, Num, Shebang, _Name
+do
+  local _obj_0 = require("moonscript.parse.literals")
+  White, Break, Stop, Comment, Space, SomeSpace, SpaceBreak, EmptyLine, AlphaNum, Num, Shebang, _Name = _obj_0.White, _obj_0.Break, _obj_0.Stop, _obj_0.Comment, _obj_0.Space, _obj_0.SomeSpace, _obj_0.SpaceBreak, _obj_0.EmptyLine, _obj_0.AlphaNum, _obj_0.Num, _obj_0.Shebang, _obj_0.Name
+end
+local SpaceName = Space * _Name
+Num = Space * (Num / function(v)
+  return {
+    "number",
+    v
+  }
+end)
+local Indent, Cut, ensure, extract_line, mark, pos, flatten_or_mark, is_assignable, check_assignable, format_assign, format_single_assign, sym, symx, simple_string, wrap_func_arg, flatten_func, flatten_string_chain, wrap_decorator, check_lua_string, self_assign
+do
+  local _obj_0 = require("moonscript.parse.util")
+  Indent, Cut, ensure, extract_line, mark, pos, flatten_or_mark, is_assignable, check_assignable, format_assign, format_single_assign, sym, symx, simple_string, wrap_func_arg, flatten_func, flatten_string_chain, wrap_decorator, check_lua_string, self_assign = _obj_0.Indent, _obj_0.Cut, _obj_0.ensure, _obj_0.extract_line, _obj_0.mark, _obj_0.pos, _obj_0.flatten_or_mark, _obj_0.is_assignable, _obj_0.check_assignable, _obj_0.format_assign, _obj_0.format_single_assign, _obj_0.sym, _obj_0.symx, _obj_0.simple_string, _obj_0.wrap_func_arg, _obj_0.flatten_func, _obj_0.flatten_string_chain, _obj_0.wrap_decorator, _obj_0.check_lua_string, _obj_0.self_assign
+end
+local build_grammar = wrap_env(debug_grammar, function()
+  local _indent = Stack(0)
+  local _do_stack = Stack(0)
+  local last_pos = 0
+  local check_indent
+  check_indent = function(str, pos, indent)
+    last_pos = pos
+    return _indent:top() == indent
+  end
+  local advance_indent
+  advance_indent = function(str, pos, indent)
+    local top = _indent:top()
+    if top ~= -1 and indent > top then
+      _indent:push(indent)
+      return true
+    end
+  end
+  local push_indent
+  push_indent = function(str, pos, indent)
+    _indent:push(indent)
+    return true
+  end
+  local pop_indent
+  pop_indent = function()
+    assert(_indent:pop(), "unexpected outdent")
+    return true
+  end
+  local check_do
+  check_do = function(str, pos, do_node)
+    local top = _do_stack:top()
+    if top == nil or top then
+      return true, do_node
+    end
+    return false
+  end
+  local disable_do
+  disable_do = function()
+    _do_stack:push(false)
+    return true
+  end
+  local pop_do
+  pop_do = function()
+    assert(_do_stack:pop() ~= nil, "unexpected do pop")
+    return true
+  end
+  local DisableDo = Cmt("", disable_do)
+  local PopDo = Cmt("", pop_do)
+  local keywords = { }
+  local key
+  key = function(chars)
+    keywords[chars] = true
+    return Space * chars * -AlphaNum
+  end
+  local op
+  op = function(chars)
+    local patt = Space * C(chars)
+    if chars:match("^%w*$") then
+      keywords[chars] = true
+      patt = patt * -AlphaNum
+    end
+    return patt
+  end
+  local Name = Cmt(SpaceName, function(str, pos, name)
+    if keywords[name] then
+      return false
+    end
+    return true
+  end) / trim
+  local SelfName = Space * "@" * ("@" * (_Name / mark("self_class") + Cc("self.__class")) + _Name / mark("self") + Cc("self"))
+  local KeyName = SelfName + Space * _Name / mark("key_literal")
+  local VarArg = Space * P("...") / trim
+  local g = P({
+    File,
+    File = Shebang ^ -1 * (Block + Ct("")),
+    Block = Ct(Line * (Break ^ 1 * Line) ^ 0),
+    CheckIndent = Cmt(Indent, check_indent),
+    Line = (CheckIndent * Statement + Space * #Stop),
+    Statement = pos(Import + While + With + For + ForEach + Switch + Return + Local + Export + BreakLoop + Ct(ExpList) * (Update + Assign) ^ -1 / format_assign) * Space * ((key("if") * Exp * (key("else") * Exp) ^ -1 * Space / mark("if") + key("unless") * Exp / mark("unless") + CompInner / mark("comprehension")) * Space) ^ -1 / wrap_decorator,
+    Body = Space ^ -1 * Break * EmptyLine ^ 0 * InBlock + Ct(Statement),
+    Advance = #Cmt(Indent, advance_indent),
+    PushIndent = Cmt(Indent, push_indent),
+    PreventIndent = Cmt(Cc(-1), push_indent),
+    PopIndent = Cmt("", pop_indent),
+    InBlock = Advance * Block * PopIndent,
+    Local = key("local") * ((op("*") + op("^")) / mark("declare_glob") + Ct(NameList) / mark("declare_with_shadows")),
+    Import = key("import") * Ct(ImportNameList) * SpaceBreak ^ 0 * key("from") * Exp / mark("import"),
+    ImportName = (sym("\\") * Ct(Cc("colon_stub") * Name) + Name),
+    ImportNameList = SpaceBreak ^ 0 * ImportName * ((SpaceBreak ^ 1 + sym(",") * SpaceBreak ^ 0) * ImportName) ^ 0,
+    BreakLoop = Ct(key("break") / trim) + Ct(key("continue") / trim),
+    Return = key("return") * (ExpListLow / mark("explist") + C("")) / mark("return"),
+    WithExp = Ct(ExpList) * Assign ^ -1 / format_assign,
+    With = key("with") * DisableDo * ensure(WithExp, PopDo) * key("do") ^ -1 * Body / mark("with"),
+    Switch = key("switch") * DisableDo * ensure(Exp, PopDo) * key("do") ^ -1 * Space ^ -1 * Break * SwitchBlock / mark("switch"),
+    SwitchBlock = EmptyLine ^ 0 * Advance * Ct(SwitchCase * (Break ^ 1 * SwitchCase) ^ 0 * (Break ^ 1 * SwitchElse) ^ -1) * PopIndent,
+    SwitchCase = key("when") * Ct(ExpList) * key("then") ^ -1 * Body / mark("case"),
+    SwitchElse = key("else") * Body / mark("else"),
+    IfCond = Exp * Assign ^ -1 / format_single_assign,
+    If = key("if") * IfCond * key("then") ^ -1 * Body * ((Break * CheckIndent) ^ -1 * EmptyLine ^ 0 * key("elseif") * pos(IfCond) * key("then") ^ -1 * Body / mark("elseif")) ^ 0 * ((Break * CheckIndent) ^ -1 * EmptyLine ^ 0 * key("else") * Body / mark("else")) ^ -1 / mark("if"),
+    Unless = key("unless") * IfCond * key("then") ^ -1 * Body * ((Break * CheckIndent) ^ -1 * EmptyLine ^ 0 * key("else") * Body / mark("else")) ^ -1 / mark("unless"),
+    While = key("while") * DisableDo * ensure(Exp, PopDo) * key("do") ^ -1 * Body / mark("while"),
+    For = key("for") * DisableDo * ensure(Name * sym("=") * Ct(Exp * sym(",") * Exp * (sym(",") * Exp) ^ -1), PopDo) * key("do") ^ -1 * Body / mark("for"),
+    ForEach = key("for") * Ct(AssignableNameList) * key("in") * DisableDo * ensure(Ct(sym("*") * Exp / mark("unpack") + ExpList), PopDo) * key("do") ^ -1 * Body / mark("foreach"),
+    Do = key("do") * Body / mark("do"),
+    Comprehension = sym("[") * Exp * CompInner * sym("]") / mark("comprehension"),
+    TblComprehension = sym("{") * Ct(Exp * (sym(",") * Exp) ^ -1) * CompInner * sym("}") / mark("tblcomprehension"),
+    CompInner = Ct((CompForEach + CompFor) * CompClause ^ 0),
+    CompForEach = key("for") * Ct(NameList) * key("in") * (sym("*") * Exp / mark("unpack") + Exp) / mark("foreach"),
+    CompFor = key("for" * Name * sym("=") * Ct(Exp * sym(",") * Exp * (sym(",") * Exp) ^ -1) / mark("for")),
+    CompClause = CompFor + CompForEach + key("when") * Exp / mark("when"),
+    Assign = sym("=") * (Ct(With + If + Switch) + Ct(TableBlock + ExpListLow)) / mark("assign"),
+    Update = ((sym("..=") + sym("+=") + sym("-=") + sym("*=") + sym("/=") + sym("%=") + sym("or=") + sym("and=")) / trim) * Exp / mark("update"),
+    CharOperators = Space * C(S("+-*/%^><")),
+    WordOperators = op("or") + op("and") + op("<=") + op(">=") + op("~=") + op("!=") + op("==") + op(".."),
+    BinaryOperator = (WordOperators + CharOperators) * SpaceBreak ^ 0,
+    Assignable = Cmt(DotChain + Chain, check_assignable) + Name + SelfName,
+    Exp = Ct(Value * (BinaryOperator * Value) ^ 0) / flatten_or_mark("exp"),
+    SimpleValue = If + Unless + Switch + With + ClassDecl + ForEach + For + While + Cmt(Do, check_do) + sym("-") * -SomeSpace * Exp / mark("minus") + sym("#") * Exp / mark("length") + key("not") * Exp / mark("not") + TblComprehension + TableLit + Comprehension + FunLit + Num,
+    ChainValue = StringChain + ((Chain + DotChain + Callable) * Ct(InvokeArgs ^ -1)) / flatten_func,
+    Value = pos(SimpleValue + Ct(KeyValueList) / mark("table") + ChainValue),
+    SliceValue = SimpleValue + ChainValue,
+    StringChain = String * (Ct((ColonCall + ColonSuffix) * ChainTail ^ -1) * Ct(InvokeArgs ^ -1)) ^ -1 / flatten_string_chain,
+    String = Space * DoubleString + Space * SingleString + LuaString,
+    SingleString = simple_string("'"),
+    DoubleString = simple_string('"', true),
+    LuaString = Cg(LuaStringOpen, "string_open") * Cb("string_open") * Break ^ -1 * C((1 - Cmt(C(LuaStringClose) * Cb("string_open"), check_lua_string)) ^ 0) * LuaStringClose / mark("string"),
+    LuaStringOpen = sym("[") * P("=") ^ 0 * "[" / trim,
+    LuaStringClose = "]" * P("=") ^ 0 * "]",
+    Callable = pos(Name / mark("ref")) + SelfName + VarArg + Parens / mark("parens"),
+    Parens = sym("(") * SpaceBreak ^ 0 * Exp * SpaceBreak ^ 0 * sym(")"),
+    FnArgs = symx("(") * SpaceBreak ^ 0 * Ct(ExpList ^ -1) * SpaceBreak ^ 0 * sym(")") + sym("!") * -P("=") * Ct(""),
+    ChainTail = ChainItem ^ 1 * ColonSuffix ^ -1 + ColonSuffix,
+    Chain = Callable * ChainTail / mark("chain"),
+    DotChain = (sym(".") * Cc(-1) * (_Name / mark("dot")) * ChainTail ^ -1) / mark("chain") + (sym("\\") * Cc(-1) * ((_Name * Invoke / mark("colon")) * ChainTail ^ -1 + (_Name / mark("colon_stub")))) / mark("chain"),
+    ChainItem = Invoke + Slice + symx("[") * Exp / mark("index") * sym("]") + symx(".") * _Name / mark("dot") + ColonCall,
+    Slice = symx("[") * (SliceValue + Cc(1)) * sym(",") * (SliceValue + Cc("")) * (sym(",") * SliceValue) ^ -1 * sym("]") / mark("slice"),
+    ColonCall = symx("\\") * (_Name * Invoke) / mark("colon"),
+    ColonSuffix = symx("\\") * _Name / mark("colon_stub"),
+    Invoke = FnArgs / mark("call") + SingleString / wrap_func_arg + DoubleString / wrap_func_arg,
+    TableValue = KeyValue + Ct(Exp),
+    TableLit = sym("{") * Ct(TableValueList ^ -1 * sym(",") ^ -1 * (SpaceBreak * TableLitLine * (sym(",") ^ -1 * SpaceBreak * TableLitLine) ^ 0 * sym(",") ^ -1) ^ -1) * White * sym("}") / mark("table"),
+    TableValueList = TableValue * (sym(",") * TableValue) ^ 0,
+    TableLitLine = PushIndent * ((TableValueList * PopIndent) + (PopIndent * Cut)) + Space,
+    TableBlockInner = Ct(KeyValueLine * (SpaceBreak ^ 1 * KeyValueLine) ^ 0),
+    TableBlock = SpaceBreak ^ 1 * Advance * ensure(TableBlockInner, PopIndent) / mark("table"),
+    ClassDecl = key("class") * -P(":") * (Assignable + Cc(nil)) * (key("extends") * PreventIndent * ensure(Exp, PopIndent) + C("")) ^ -1 * (ClassBlock + Ct("")) / mark("class"),
+    ClassBlock = SpaceBreak ^ 1 * Advance * Ct(ClassLine * (SpaceBreak ^ 1 * ClassLine) ^ 0) * PopIndent,
+    ClassLine = CheckIndent * ((KeyValueList / mark("props") + Statement / mark("stm") + Exp / mark("stm")) * sym(",") ^ -1),
+    Export = key("export") * (Cc("class") * ClassDecl + op("*") + op("^") + Ct(NameList) * (sym("=") * Ct(ExpListLow)) ^ -1) / mark("export"),
+    KeyValue = (sym(":") * -SomeSpace * Name * lpeg.Cp()) / self_assign + Ct((KeyName + sym("[") * Exp * sym("]") + DoubleString + SingleString) * symx(":") * (Exp + TableBlock + SpaceBreak ^ 1 * Exp)),
+    KeyValueList = KeyValue * (sym(",") * KeyValue) ^ 0,
+    KeyValueLine = CheckIndent * KeyValueList * sym(",") ^ -1,
+    FnArgsDef = sym("(") * Ct(FnArgDefList ^ -1) * (key("using") * Ct(NameList + Space * "nil") + Ct("")) * sym(")") + Ct("") * Ct(""),
+    FnArgDefList = FnArgDef * (sym(",") * FnArgDef) ^ 0 * (sym(",") * Ct(VarArg)) ^ 0 + Ct(VarArg),
+    FnArgDef = Ct((Name + SelfName) * (sym("=") * Exp) ^ -1),
+    FunLit = FnArgsDef * (sym("->") * Cc("slim") + sym("=>") * Cc("fat")) * (Body + Ct("")) / mark("fndef"),
+    NameList = Name * (sym(",") * Name) ^ 0,
+    NameOrDestructure = Name + TableLit,
+    AssignableNameList = NameOrDestructure * (sym(",") * NameOrDestructure) ^ 0,
+    ExpList = Exp * (sym(",") * Exp) ^ 0,
+    ExpListLow = Exp * ((sym(",") + sym(";")) * Exp) ^ 0,
+    InvokeArgs = -P("-") * (ExpList * (sym(",") * (TableBlock + SpaceBreak * Advance * ArgBlock * TableBlock ^ -1) + TableBlock) ^ -1 + TableBlock),
+    ArgBlock = ArgLine * (sym(",") * SpaceBreak * ArgLine) ^ 0 * PopIndent,
+    ArgLine = CheckIndent * ExpList
+  })
+  local file_grammar = White * g * White * -1
+  return {
+    match = function(self, str)
+      local tree
+      local _, err = xpcall((function()
+        tree = file_grammar:match(str)
+      end), function(err)
+        return debug.traceback(err, 2)
+      end)
+      if type(err) == "string" then
+        return nil, err
+      end
+      if not (tree) then
+        local msg
+        pos = last_pos
+        if err then
+          local node
+          node, msg = unpack(err)
+          if msg then
+            msg = " " .. msg
+          end
+          pos = node[-1]
+        end
+        local line_no = pos_to_line(str, pos)
+        local line_str = get_line(str, line_no) or ""
+        return nil, err_msg:format(msg or "", line_no, trim(line_str))
+      end
+      return tree
+    end
+  }
+end)
+return {
+  extract_line = extract_line,
+  string = function(str)
+    return build_grammar():match(str)
+  end
+}

data/vendor/{lua → leafo}/moonscript/transform/destructure.lua

@@ -4,25 +4,13 @@ do
   ntype, mtype, build = _obj_0.ntype, _obj_0.mtype, _obj_0.build
 end
 local NameProxy
-do
-  local _obj_0 = require("moonscript.transform.names")
-  NameProxy = _obj_0.NameProxy
-end
+NameProxy = require("moonscript.transform.names").NameProxy
 local insert
-do
-  local _obj_0 = table
-  insert = _obj_0.insert
-end
+insert = table.insert
 local unpack
-do
-  local _obj_0 = require("moonscript.util")
-  unpack = _obj_0.unpack
-end
+unpack = require("moonscript.util").unpack
 local user_error
-do
-  local _obj_0 = require("moonscript.errors")
-  user_error = _obj_0.user_error
-end
+user_error = require("moonscript.errors").user_error
 local join
 join = function(...)
   do
@@ -124,7 +112,7 @@ build_assign = function(scope, destruct_literal, receiver)
     values
   }
   local obj
-  if scope:is_local(receiver) then
+  if scope:is_local(receiver) or #extracted_names == 1 then
     obj = receiver
   else
     do
@@ -143,7 +131,13 @@ build_assign = function(scope, destruct_literal, receiver)
   for _index_0 = 1, #extracted_names do
     local tuple = extracted_names[_index_0]
     insert(names, tuple[1])
-    insert(values, NameProxy.chain(obj, unpack(tuple[2])))
+    local chain
+    if obj then
+      chain = NameProxy.chain(obj, unpack(tuple[2]))
+    else
+      chain = "nil"
+    end
+    insert(values, chain)
   end
   return build.group({
     {

data/vendor/{lua → leafo}/moonscript/transform/names.lua

@@ -1,13 +1,7 @@
 local build
-do
-  local _obj_0 = require("moonscript.types")
-  build = _obj_0.build
-end
+build = require("moonscript.types").build
 local unpack
-do
-  local _obj_0 = require("moonscript.util")
-  unpack = _obj_0.unpack
-end
+unpack = require("moonscript.util").unpack
 local LocalName
 do
   local _base_0 = {

data/vendor/{lua → leafo}/moonscript/transform.lua

@@ -6,10 +6,7 @@ reversed, unpack = util.reversed, util.unpack
 local ntype, mtype, build, smart_node, is_slice, value_is_singular
 ntype, mtype, build, smart_node, is_slice, value_is_singular = types.ntype, types.mtype, types.build, types.smart_node, types.is_slice, types.value_is_singular
 local insert
-do
-  local _obj_0 = table
-  insert = _obj_0.insert
-end
+insert = table.insert
 local NameProxy, LocalName
 do
   local _obj_0 = require("moonscript.transform.names")

data/vendor/{lua → leafo}/moonscript/types.lua

@@ -1,14 +1,8 @@
 local util = require("moonscript.util")
 local Set
-do
-  local _obj_0 = require("moonscript.data")
-  Set = _obj_0.Set
-end
+Set = require("moonscript.data").Set
 local insert
-do
-  local _obj_0 = table
-  insert = _obj_0.insert
-end
+insert = table.insert
 local unpack
 unpack = util.unpack
 local manual_return = Set({

data/vendor/{lua → leafo}/moonscript/util.lua

@@ -1,8 +1,5 @@
 local concat
-do
-  local _obj_0 = table
-  concat = _obj_0.concat
-end
+concat = table.concat
 local unpack = unpack or table.unpack
 local type = type
 local moon = {
@@ -199,6 +196,14 @@ get_options = function(...)
     return { }, ...
   end
 end
+local safe_module
+safe_module = function(name, tbl)
+  return setmetatable(tbl, {
+    __index = function(self, key)
+      return error("Attempted to import non-existent `" .. tostring(key) .. "` from " .. tostring(name))
+    end
+  })
+end
 return {
   moon = moon,
   pos_to_line = pos_to_line,
@@ -212,5 +217,6 @@ return {
   getfenv = getfenv,
   setfenv = setfenv,
   get_options = get_options,
-  unpack = unpack
+  unpack = unpack,
+  safe_module = safe_module
 }

data/vendor/{lua → leafo}/moonscript/version.lua

@@ -1,4 +1,4 @@
-local version = "0.2.6"
+local version = "0.3.0"
 return {
   version = version,
   print_version = function()