isaacscript-common 84.2.3 → 84.2.5

package/src/lib/jsonLua.js

@@ -3,6 +3,990 @@
 
 // cspell: disable
 
+/*
+ Copyright 2011 Maximilian Herkender
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+var lua_print = function () {
+  try {
+    console.log.apply(console, arguments);
+  } catch (a) {}
+  return [];
+};
+function lua_load(a, b) {
+  if (!lua_parser)
+    throw Error(
+      "Lua parser not available, perhaps you're not using the lua+parser.js version of the library?",
+    );
+  eval(
+    "fn = function " +
+      (b || "load") +
+      "() {\nreturn (function () {\n" +
+      lua_parser.parse(a) +
+      "\n})()[0];\n};",
+  );
+}
+function slice(a, b) {
+  return a.slice ? a.slice(b) : Array.prototype.slice.call(a, b);
+}
+function not_supported() {
+  throw Error("Not supported");
+}
+function ensure_arraymode(a) {
+  if (!a.arraymode) {
+    var b = [],
+      c;
+    for (c in a.uints) null != a.uints[c] && (b[c - 1] = a.uints[c]);
+    a.uints = b;
+    a.arraymode = !0;
+  }
+}
+function ensure_notarraymode(a) {
+  if (a.arraymode) {
+    var b = {},
+      c;
+    for (c in a.uints) null != a.uints[c] && (b[c - -1] = a.uints[c]);
+    a.uints = b;
+    delete a.arraymode;
+  }
+}
+function ReturnValues(a) {
+  this.vars = a || [];
+}
+function lua_true(a) {
+  return null != a && !1 !== a;
+}
+function lua_not(a) {
+  return null == a || !1 === a;
+}
+function lua_and(a, b) {
+  return null == a || !1 === a ? a : b();
+}
+function lua_or(a, b) {
+  return null != a && !1 !== a ? a : b();
+}
+function lua_assertfloat(a) {
+  var b = parseFloat(a);
+  if (isNaN(b)) throw Error("Invalid number: " + a);
+  return b;
+}
+function lua_newtable(a) {
+  for (
+    var b = { str: {}, uints: {}, floats: {}, bool: {}, objs: [] }, c = 1;
+    c < arguments.length - 1;
+    c += 2
+  ) {
+    var d = arguments[c + 1];
+    if (null != d) {
+      var e = arguments[c];
+      switch (typeof e) {
+        case "string":
+          b.str[e] = d;
+          break;
+        case "number":
+          if (e != e) throw Error("Table index is NaN");
+          0 < e && (e | 0) == e ? (b.uints[e] = d) : (b.floats[e] = d);
+          break;
+        case "boolean":
+          b.bool[e] = d;
+          break;
+        case "object":
+          if (null == e) throw Error("Table index is nil");
+          var f = !1;
+          for (c in b.objs)
+            if (b.objs[c][0] === e) {
+              null == d ? b.objs.splice(c, 1) : ((f = !0), (b.objs[c][1] = d));
+              break;
+            }
+          f || b.objs.push([e, d]);
+          break;
+        default:
+          throw Error("Unsupported type for table: " + typeof e);
+      }
+    }
+  }
+  if (a)
+    if ((ensure_arraymode(b), 0 == b.uints.length)) b.uints = a;
+    else for (c = a.length; 0 < c--; ) b.uints[c] = a[c];
+  return b;
+}
+function lua_newtable2(a) {
+  var b = {},
+    c;
+  for (c in a) b[c] = a[c];
+  return { str: b, uints: {}, floats: {}, bool: {}, objs: {} };
+}
+function lua_len(a) {
+  if ("string" == typeof a) return a.length;
+  if ("object" == typeof a && null != a) {
+    if (null == a.length) {
+      var b = 0;
+      if (a.arraymode) for (; null != a.uints[b++]; );
+      else for (; null != a.uints[++b]; );
+      return (a.length = b - 1);
+    }
+    return a.length;
+  }
+  if ((b = a.metatable && a.metatable.str.__len)) return lua_rawcall(b, [a])[0];
+  throw Error("Length of <" + a + "> not supported");
+}
+function lua_rawcall(a, b) {
+  try {
+    return a.apply(null, b);
+  } catch (c) {
+    if (c.constructor == ReturnValues) return c.vars;
+    throw c;
+  }
+}
+function lua_tablegetcall(a, b, c) {
+  a = lua_tableget(a, b);
+  if ("function" == typeof a) return lua_rawcall(a, c);
+  if (null == a) throw Error("attempt to call field '" + b + "' (a nil value)");
+  b = a.metatable && a.metatable.str.__call;
+  if (null != b) return lua_rawcall(b, [a].concat(c));
+  throw Error("Could not call " + a + " as function");
+}
+function lua_call(a, b) {
+  if ("function" == typeof a) return lua_rawcall(a, b);
+  if (null == a) throw Error("attempt to call function (a nil value)");
+  var c = a.metatable && a.metatable.str.__call;
+  if (null != c) return lua_rawcall(c, [a].concat(b));
+  throw Error("Could not call " + a + " as function");
+}
+function lua_mcall(a, b, c) {
+  var d = lua_tableget(a, b);
+  if (null == d)
+    throw Error("attempt to call method '" + b + "' (a nil value)");
+  return lua_call(d, [a].concat(c));
+}
+function lua_eq(a, b) {
+  if (typeof a != typeof b) return null == a && null == b ? !0 : !1;
+  if (a == b) return !0;
+  if (null == a || null == b) return !1;
+  var c = a.metatable && a.metatable.str.__eq;
+  return c && c == (b.metatable && b.metatable.str.__eq)
+    ? lua_true(lua_rawcall(c, [a, b])[0])
+    : !1;
+}
+function lua_lt(a, b) {
+  if (
+    ("number" == typeof a && "number" == typeof b) ||
+    ("string" == typeof a && "string" == typeof b)
+  )
+    return a < b;
+  var c = a.metatable && a.metatable.str.__lt;
+  if (c && c == (b.metatable && b.metatable.str.__lt))
+    return lua_true(lua_rawcall(c, [a, b])[0]);
+  throw Error("Unable to compare " + a + " and " + b);
+}
+function lua_lte(a, b) {
+  if (
+    ("number" == typeof a && "number" == typeof b) ||
+    ("string" == typeof a && "string" == typeof b)
+  )
+    return a <= b;
+  var c = a.metatable && a.metatable.str.__le;
+  if (c && c == (b.metatable && b.metatable.str.__le))
+    return lua_true(lua_rawcall(c, [a, b])[0]);
+  if (
+    (c = a.metatable && a.metatable.str.__lt) &&
+    c == (b.metatable && b.metatable.str.__lt)
+  )
+    return lua_not(lua_rawcall(c, [b, a])[0]);
+  throw Error("Unable to compare " + a + " and " + b);
+}
+function lua_unm(a) {
+  var b = parseFloat(a);
+  if (isNaN(b)) {
+    if ((b = a.metatable && a.metatable.str.__unm))
+      return lua_rawcall(b, [a])[0];
+    throw Error("Inverting <" + a + "> not supported");
+  }
+  return -b;
+}
+function lua_add(a, b) {
+  var c = parseFloat(a),
+    d = parseFloat(b);
+  if (isNaN(c) || isNaN(d)) {
+    if (
+      (c =
+        (a.metatable && a.metatable.str.__add) ||
+        (b.metatable && b.metatable.str.__add))
+    )
+      return lua_rawcall(c, [a, b])[0];
+    throw Error("Adding <" + a + "> and <" + b + "> not supported");
+  }
+  return c + d;
+}
+function lua_subtract(a, b) {
+  var c = parseFloat(a),
+    d = parseFloat(b);
+  if (isNaN(c) || isNaN(d)) {
+    if (
+      (c =
+        (a.metatable && a.metatable.str.__sub) ||
+        (b.metatable && b.metatable.str.__sub))
+    )
+      return lua_rawcall(c, [a, b])[0];
+    throw Error("Subtracting <" + a + "> and <" + b + "> not supported");
+  }
+  return c - d;
+}
+function lua_divide(a, b) {
+  var c = parseFloat(a),
+    d = parseFloat(b);
+  if (isNaN(c) || isNaN(d)) {
+    if (
+      (c =
+        (a.metatable && a.metatable.str.__div) ||
+        (b.metatable && b.metatable.str.__div))
+    )
+      return lua_rawcall(c, [a, b])[0];
+    throw Error("Dividing <" + a + "> and <" + b + "> not supported");
+  }
+  return c / d;
+}
+function lua_multiply(a, b) {
+  var c = parseFloat(a),
+    d = parseFloat(b);
+  if (isNaN(c) || isNaN(d)) {
+    if (
+      (c =
+        (a.metatable && a.metatable.str.__mul) ||
+        (b.metatable && b.metatable.str.__mul))
+    )
+      return lua_rawcall(c, [a, b])[0];
+    throw Error("Multiplying <" + a + "> and <" + b + "> not supported");
+  }
+  return c * d;
+}
+function lua_power(a, b) {
+  var c = parseFloat(a),
+    d = parseFloat(b);
+  if (isNaN(c) || isNaN(d)) {
+    if (
+      (c =
+        (a.metatable && a.metatable.str.__pow) ||
+        (b.metatable && b.metatable.str.__pow))
+    )
+      return lua_rawcall(c, [a, b])[0];
+    throw Error("<" + a + "> to the power of <" + b + "> not supported");
+  }
+  return Math.pow(c, d);
+}
+function lua_mod(a, b) {
+  var c = parseFloat(a),
+    d = parseFloat(b);
+  if (isNaN(c) || isNaN(d)) {
+    if (
+      (c =
+        (a.metatable && a.metatable.str.__mod) ||
+        (b.metatable && b.metatable.str.__mod))
+    )
+      return lua_rawcall(c, [a, b])[0];
+    throw Error("Modulo <" + a + "> and <" + b + "> not supported");
+  }
+  return 0 <= c
+    ? 0 <= d
+      ? c % d
+      : (d + (c % d)) % d
+    : 0 <= d
+      ? (d + (c % d)) % d
+      : c % d;
+}
+function lua_rawget(a, b) {
+  switch (typeof b) {
+    case "string":
+      return a.str[b];
+    case "number":
+      if (b != b) throw Error("Table index is NaN");
+      return 0 < b && (b | 0) == b
+        ? a.arraymode
+          ? a.uints[b - 1]
+          : a.uints[b]
+        : a.floats[b];
+    case "boolean":
+      return a.bool[b];
+    case "object":
+      if (null == b) return null;
+      for (var c in a.objs) if (a.objs[c][0] == b) return a.objs[c][1];
+      break;
+    default:
+      throw Error("Unsupported key for table: " + typeof b);
+  }
+}
+function lua_rawset(a, b, c) {
+  delete a.length;
+  switch (typeof b) {
+    case "string":
+      null == c ? delete a.str[b] : (a.str[b] = c);
+      break;
+    case "number":
+      if (b != b) throw Error("Table index is NaN");
+      0 < b && (b | 0) == b
+        ? (ensure_notarraymode(a),
+          null == c ? delete a.uints[b] : (a.uints[b] = c))
+        : null == c
+          ? delete a.floats[b]
+          : (a.floats[b] = c);
+      break;
+    case "boolean":
+      null == c ? delete a.bool[b] : (a.bool[b] = c);
+      break;
+    case "object":
+      if (null == b) throw Error("Table index is nil");
+      var d = !1,
+        e;
+      for (e in a.objs)
+        if (a.objs[e][0] == b) {
+          null == c ? a.objs.splice(e, 1) : ((d = !0), (a.objs[e][1] = c));
+          break;
+        }
+      d || a.objs.push([b, c]);
+      break;
+    default:
+      throw Error("Unsupported key for table: " + typeof b);
+  }
+}
+function lua_tableget(a, b) {
+  if (null == a)
+    throw Error("attempt to index field '" + b + "' in a nil value");
+  if ("object" == typeof a) {
+    var c = lua_rawget(a, b);
+    if (null != c) return c;
+    c = a.metatable && a.metatable.str.__index;
+    if (null == c) return null;
+  } else if (((c = a.metatable && a.metatable.str.__index), null == c))
+    throw Error("Unable to index key " + b + " from " + a);
+  return "function" == typeof c
+    ? lua_rawcall(c, [a, b])[0]
+    : lua_tableget(c, b);
+}
+function lua_tableset(a, b, c) {
+  if (null == a) throw Error("attempt to set field '" + b + "' in a nil value");
+  if ("object" == typeof a) {
+    if (null != lua_rawget(a, b)) {
+      lua_rawset(a, b, c);
+      return;
+    }
+    var d = a.metatable && a.metatable.str.__newindex;
+    if (null == d) {
+      lua_rawset(a, b, c);
+      return;
+    }
+  } else if (((d = a.metatable && a.metatable.str.__newindex), null == d))
+    throw Error("Unable to set key " + b + " in table " + a);
+  "function" == typeof d ? lua_rawcall(d, [a, b, c]) : lua_tableset(d, b, c);
+}
+function lua_concat(a, b) {
+  if ("number" == typeof a && "number" == typeof b)
+    throw Error("number concat not supported yet");
+  if (
+    ("string" == typeof a || "number" == typeof a) &&
+    ("string" == typeof b || "number" == typeof b)
+  )
+    return a + b;
+  var c =
+    (a.metatable && a.metatable.str.__concat) ||
+    (b.metatable && b.metatable.str.__concat);
+  if (c) return lua_rawcall(c, [a, b])[0];
+  throw Error("Unable to concat " + a + " and " + b);
+}
+function _ipairs_next(a, b) {
+  var c;
+  c = a.arraymode ? a.uints[b] : a.uints[b + 1];
+  return null == c ? [null, null] : [b + 1, c];
+}
+var lua_libs = {},
+  lua_core = {
+    assert: function (a, b) {
+      1 > arguments.length && (b = "assertion failed!");
+      if (null != a && !1 !== a) return [a];
+      throw Error(b);
+    },
+    collectgarbage: function () {},
+    dofile: function () {
+      not_supported();
+    },
+    error: function (a) {
+      throw Error(a);
+    },
+    getfenv: function () {
+      not_supported();
+    },
+    getmetatable: function (a) {
+      return [a.metatable && (a.metatable.str.__metatable || a.metatable)];
+    },
+    ipairs: function (a) {
+      return [_ipairs_next, a, 0];
+    },
+    load: function (a, b) {
+      for (var c = "", d; null != (d = a()) && "" != d; ) c += d;
+      try {
+        return [lua_load(c, b)];
+      } catch (e) {
+        return [null, e.message];
+      }
+    },
+    loadfile: function () {
+      not_supported();
+    },
+    loadstring: function (a, b) {
+      try {
+        return [lua_load(a, b)];
+      } catch (c) {
+        return [null, c.message];
+      }
+    },
+    next: function () {
+      not_supported();
+    },
+    pairs: function (a) {
+      var b = [],
+        c;
+      for (c in a.str) b.push(c);
+      if (a.arraymode)
+        for (var d = a.uints.length; 0 < d--; )
+          null != a.uints[d] && b.push(d + 1);
+      else for (c in a.uints) b.push(parseFloat(c));
+      for (c in a.floats) b.push(parseFloat(c));
+      for (c in a.bool) b.push("true" === c ? !0 : !1);
+      for (c in a.objs) b.push(a.objs[c][0]);
+      c = 0;
+      return [
+        function (a, d) {
+          var g;
+          do {
+            if (c >= b.length) return [null, null];
+            d = b[c++];
+            g = lua_rawget(a, d);
+          } while (null == g);
+          return [d, g];
+        },
+        a,
+        null,
+      ];
+    },
+    pcall: function (a) {
+      try {
+        return [!0].concat(a.apply(null, slice(arguments, 1)));
+      } catch (b) {
+        return [!1, b.message];
+      }
+    },
+    print: lua_print,
+    rawequal: function (a, b) {
+      return [a == b || (null == a && null == b)];
+    },
+    rawget: function (a, b) {
+      if ("object" == typeof a && null != a) return [lua_rawget(a, b)];
+      throw Error("Unable to index key " + b + " from " + a);
+    },
+    rawset: function (a, b, c) {
+      if ("object" == typeof a && null != a && null != b)
+        return lua_rawset(a, b, c), [a];
+      throw Error("Unable set key " + b + " in " + a);
+    },
+    select: function (a) {
+      if ("#" === a) return [arguments.length - 1];
+      a = lua_assertfloat(a);
+      if (1 <= a) return slice(arguments, lua_assertfloat(a));
+      throw Error("Index out of range");
+    },
+    setfenv: function () {
+      not_supported();
+    },
+    setmetatable: function (a, b) {
+      if ("object" != typeof a || null == a)
+        throw Error("table expected, got " + a);
+      if (null == b) delete a.metatable;
+      else if ("object" === typeof b) a.metatable = b;
+      else throw Error("table or nil expected, got " + b);
+      return [a];
+    },
+    tonumber: function (a, b) {
+      return "number" == typeof a
+        ? [a]
+        : 10 === b || null == b
+          ? [parseFloat(a)]
+          : [parseInt(a, b)];
+    },
+    tostring: function (a) {
+      if (null == a) return ["nil"];
+      var b = a.metatable && a.metatable.str.__tostring;
+      if (b) return lua_rawcall(b, [a]);
+      switch (typeof a) {
+        case "number":
+        case "boolean":
+          return [a.toString()];
+        case "string":
+          return [a];
+        case "object":
+          return ["table"];
+        case "function":
+          return ["function"];
+        default:
+          return ["nil"];
+      }
+    },
+    type: function (a) {
+      switch (typeof a) {
+        case "number":
+          return ["number"];
+        case "string":
+          return ["string"];
+        case "boolean":
+          return ["boolean"];
+        case "function":
+          return ["function"];
+        case "object":
+          return [null === a ? "nil" : "table"];
+        case "undefined":
+          return ["nil"];
+        default:
+          throw Error("Unepected value of type " + typeof a);
+      }
+    },
+    unpack: function (a, b, c) {
+      ensure_arraymode(a);
+      if (null != a.length) c = a.length;
+      else {
+        for (c = 0; null != a.uints[c++]; );
+        a.length = --c;
+      }
+      if (null == b || 1 > b) b = 1;
+      null == c && (c = a.length);
+      throw new ReturnValues(a.uints.slice(b - 1, c));
+    },
+    _VERSION: "Lua 5.1",
+    xpcall: function () {
+      not_supported();
+    },
+  },
+  _lua_coroutine = (lua_libs.coroutine = {});
+_lua_coroutine.resume =
+  _lua_coroutine.running =
+  _lua_coroutine.status =
+  _lua_coroutine.wrap =
+  _lua_coroutine.yield =
+  _lua_coroutine.create =
+    function () {
+      not_supported();
+    };
+var _lua_debug = (lua_libs.debug = {
+  getmetatable: function (a) {
+    return [a.metatable];
+  },
+});
+_lua_debug.traceback =
+  _lua_debug.getfenv =
+  _lua_debug.gethook =
+  _lua_debug.getinfo =
+  _lua_debug.getlocal =
+  _lua_debug.getregistry =
+  _lua_debug.getupvalue =
+  _lua_debug.setfenv =
+  _lua_debug.sethook =
+  _lua_debug.setlocal =
+  _lua_debug.setupvalue =
+  _lua_debug.debug =
+    function () {
+      not_supported();
+    };
+var _lua_write_buffer = "",
+  _lua_io = (lua_libs.io = {
+    write: function () {
+      _lua_write_buffer += Array.prototype.join.call(arguments, "");
+      for (var a = _lua_write_buffer.split("\n"); 1 < a.length; )
+        _lua_print(a.shift());
+      _lua_write_buffer = a[0];
+      return [];
+    },
+    flush: function () {},
+    stderr: null,
+    stdin: null,
+    stdout: null,
+  });
+_lua_io.close =
+  _lua_io.input =
+  _lua_io.lines =
+  _lua_io.output =
+  _lua_io.popen =
+  _lua_io.read =
+  _lua_io.tmpfile =
+  _lua_io.type =
+  _lua_io.open =
+    function () {
+      not_supported();
+    };
+var _lua_randmax = 4294967296,
+  _lua_randseed = (Math.random() * _lua_randmax) & (_lua_randmax - 1);
+lua_libs.math = {
+  abs: function (a) {
+    return [Math.abs(a)];
+  },
+  acos: function (a) {
+    return [Math.acos(a)];
+  },
+  asin: function (a) {
+    return [Math.asin(a)];
+  },
+  atan: function (a) {
+    return [Math.atan(a)];
+  },
+  atan2: function (a, b) {
+    return [Math.atan2(a, b)];
+  },
+  ceil: function (a) {
+    return [Math.ceil(a)];
+  },
+  cos: function (a) {
+    return [Math.cos(a)];
+  },
+  cosh: function (a) {
+    return [(Math.exp(a) + Math.exp(-a)) / 2];
+  },
+  deg: function (a) {
+    return [a * (180 / Math.PI)];
+  },
+  exp: function (a) {
+    return [Math.exp(a)];
+  },
+  floor: function (a) {
+    return [Math.floor(a)];
+  },
+  fmod: function (a, b) {
+    return [a % b];
+  },
+  frexp: function () {
+    not_supported();
+  },
+  huge: Infinity,
+  ldexp: function (a, b) {
+    return [a * Math.pow(2, b)];
+  },
+  log: function (a) {
+    return [Math.log(a)];
+  },
+  log10: function (a) {
+    return [Math.log(a) / Math.LN10];
+  },
+  max: function () {
+    return [Math.max.apply(null, arguments)];
+  },
+  min: function () {
+    return [Math.min.apply(null, arguments)];
+  },
+  modf: function (a) {
+    var b = a % 1;
+    return [a - b, b];
+  },
+  pi: Math.PI,
+  pow: function (a, b) {
+    return [Math.pow(a, b)];
+  },
+  rad: function (a) {
+    return [a * (Math.PI / 180)];
+  },
+  sin: function (a) {
+    return [Math.sin(a)];
+  },
+  sinh: function (a) {
+    return [(Math.exp(a) - Math.exp(-a)) / 2];
+  },
+  sqrt: function (a) {
+    return [Math.sqrt(a)];
+  },
+  tan: function (a) {
+    return [Math.tan(a)];
+  },
+  tanh: function (a) {
+    var b = Math.exp(a),
+      a = Math.exp(-a);
+    return [(b - a) / (b + a)];
+  },
+  random: function (a, b) {
+    _lua_randseed = ~_lua_randseed + (_lua_randseed << 15);
+    _lua_randseed ^= _lua_randseed >>> 12;
+    _lua_randseed += _lua_randseed << 2;
+    _lua_randseed ^= _lua_randseed >>> 4;
+    _lua_randseed *= 2057;
+    _lua_randseed ^= _lua_randseed >>> 16;
+    var c;
+    c =
+      0 > _lua_randseed
+        ? ((_lua_randseed + _lua_randmax) / _lua_randmax) % 1
+        : (_lua_randseed / _lua_randmax) % 1;
+    if (2 <= arguments.length) {
+      a |= 0;
+      b |= 0;
+      if (a >= b) throw Error("Invalid range");
+      return [Math.floor(c * (b - a + 1) + a)];
+    }
+    return 1 == arguments.length ? [Math.floor(c * (a | 0) + 1)] : [c];
+  },
+  randomseed: function (a) {
+    _lua_randseed = a & (_lua_randmax - 1);
+  },
+};
+var _lua_clock_start = new Date().getTime() / 1e3;
+lua_libs.os = {
+  clock: function () {
+    return [new Date().getTime() / 1e3 - _lua_clock_script];
+  },
+  date: function (a, b) {
+    return ["[" + b + "]" + a];
+  },
+  difftime: function (a, b) {
+    return [a - b];
+  },
+  execute: function () {
+    return 0;
+  },
+  exit: function () {
+    not_supported();
+  },
+  getenv: function () {
+    return [null];
+  },
+  remove: function () {
+    not_supported();
+  },
+  rename: function () {
+    not_supported();
+  },
+  setlocale: function () {
+    not_supported();
+  },
+  time: function (a) {
+    if (a) not_supported();
+    else return [Math.floor(new Date().getTime() / 1e3)];
+  },
+};
+var lua_packages = lua_newtable();
+function lua_createmodule(a, b, c) {
+  var d = lua_tableget(lua_packages, b) || lua_tableget(a, b) || lua_newtable();
+  lua_tableset(a, b, d);
+  lua_tableset(lua_packages, b, d);
+  lua_tableset(d, "_NAME", b);
+  lua_tableset(d, "_M", d);
+  lua_tableset(d, "_PACKAGE", b.split(".").slice(0, -1).join("."));
+  for (a = 0; a < c.length; a++) lua_call(c[a], [d]);
+  return d;
+}
+function lua_module(a) {
+  var b = lua_tableget(lua_packages, a);
+  if (null == b)
+    throw Error(
+      "Module " + a + " not found. Module must be loaded before use.",
+    );
+  return b;
+}
+function lua_require(a, b) {
+  for (
+    var c = lua_module(b), d = a, e = b.split("."), f = 0;
+    f < e.length - 1;
+    f++
+  )
+    if (!lua_tableget(d, e[f])) {
+      var g = lua_newtable();
+      lua_tableset(d, e[f], g);
+      d = g;
+    }
+  lua_tableset(d, e[e.length - 1], c);
+  return c;
+}
+lua_libs["package"] = {
+  path: "",
+  cpath: "",
+  loaded: lua_packages,
+  loaders: lua_newtable(),
+  preload: lua_newtable(),
+  loadlib: function () {
+    not_supported();
+  },
+};
+lua_libs.string = {
+  byte: function (a, b, c) {
+    null == b && (b = 0);
+    null == c && (c = b);
+    for (var d = []; b < c && b < a.length; ) d.push(a.charCodeAt(b));
+    return d;
+  },
+  char: function () {
+    return [String.fromCharCode.apply(null, arguments)];
+  },
+  dump: function () {
+    not_supported();
+  },
+  find: function () {
+    not_supported();
+  },
+  format: function (a) {
+    return ["[" + slice(arguments, 1).join(", ") + "]" + arguments[0]];
+  },
+  gmatch: function () {
+    not_supported();
+  },
+  gsub: function () {
+    not_supported();
+  },
+  len: function (a) {
+    if ("string" == typeof a) return [a.length];
+    throw Error("Input not string");
+  },
+  lower: function (a) {
+    if ("string" == typeof a) return [a.toLowerCase()];
+    throw Error("Input not string");
+  },
+  match: function () {
+    not_supported();
+  },
+  rep: function (a, b) {
+    if ("string" == typeof a && "number" == typeof b) {
+      for (var c = []; 0 < b--; ) c.push(a);
+      return [c.join("")];
+    }
+    throw Error("Input not string and number");
+  },
+  reverse: function (a) {
+    if ("string" == typeof a) return [a.split("").reverse().join("")];
+    throw Error("Input not string");
+  },
+  sub: function (a, b, c) {
+    b = 0 > b ? b + a.length + 1 : 0 <= b ? b : 0;
+    null == c && (c = -1);
+    c = 0 > c ? c + a.length + 1 : 0 <= c ? c : 0;
+    1 > b && (b = 1);
+    c > a.length && (c = a.length);
+    return b <= c ? [a.substr(b - 1, c - b + 1)] : [""];
+  },
+  upper: function (a) {
+    if ("string" == typeof a) return [a.toUpperCase()];
+    throw Error("Input not string");
+  },
+};
+String.prototype.metatable = lua_newtable(
+  null,
+  "__index",
+  lua_newtable2(lua_libs.string),
+);
+lua_libs.table = {
+  concat: function (a, b, c, d) {
+    ensure_arraymode(a);
+    null == b && (b = "");
+    return null != c
+      ? (null == d && (d = a.uints.length), [a.uints.slice(c - 1, d).join(b)])
+      : [a.uints.join(b)];
+  },
+  insert: function (a, b, c) {
+    ensure_arraymode(a);
+    2 == arguments.length && ((c = b), (b = a.uints.length + 1));
+    a.uints.splice(b - 1, 0, c);
+    null != a.length && a.length++;
+    return [];
+  },
+  maxn: function (a) {
+    if (a.arraymode) return [a.uints.length];
+    var b = 0,
+      c;
+    for (c in a.uints) (a = parseFloat(c)), a > b && (b = a);
+    return [b];
+  },
+  remove: function (a, b) {
+    ensure_arraymode(a);
+    b = null == b ? a.uints.length : lua_assertfloat(b);
+    if (a.uints.length) {
+      var c = a.uints[b - 1];
+      a.uints.splice(b - 1, 1);
+      null != a.length && a.length--;
+      return [c];
+    }
+    return [];
+  },
+  sort: function (a, b) {
+    ensure_arraymode(a);
+    b
+      ? a.uints.sort(function (a, d) {
+          return b(a, d)[0] ? -1 : 1;
+        })
+      : a.uints.sort(function (a, b) {
+          return lua_lt(a, b) ? -1 : 1;
+        });
+    return [];
+  },
+};
+lua_libs.bit = {
+  tobit: function (a) {
+    return [a << 0];
+  },
+  tohex: function (a, b) {
+    if (0 < b) {
+      for (var c = a.toString(16).substr(-b); c.length < b; ) c = "0" + c;
+      return [c];
+    }
+    if (0 > b) {
+      for (c = a.toString(16).substr(b).toUpperCase(); c.length < -b; )
+        c = "0" + c;
+      return [c];
+    }
+    return [a.toString(16)];
+  },
+  bnot: function (a) {
+    return [~a];
+  },
+  bor: function (a) {
+    for (var a = lua_assertfloat(a), b = 1; b < arguments.length; b++)
+      a |= arguments[b];
+    return [a];
+  },
+  band: function (a) {
+    for (var a = lua_assertfloat(a), b = 1; b < arguments.length; b++)
+      a &= arguments[b];
+    return [a];
+  },
+  bxor: function (a) {
+    for (var a = lua_assertfloat(a), b = 1; b < arguments.length; b++)
+      a ^= arguments[b];
+    return [a];
+  },
+  lshift: function (a, b) {
+    return [a << b];
+  },
+  rshift: function (a, b) {
+    return [a >>> b];
+  },
+  arshift: function (a, b) {
+    return [a >> b];
+  },
+  rol: function (a, b) {
+    b &= 15;
+    return [(a << b) | (a >>> -b)];
+  },
+  ror: function (a, b) {
+    b &= 15;
+    return [(a >>> b) | (a << -b)];
+  },
+  bswap: function (a) {
+    a = ((a >> 1) & 1431655765) | ((a & 1431655765) << 1);
+    a = ((a >> 2) & 858993459) | ((a & 858993459) << 2);
+    a = ((a >> 4) & 252645135) | ((a & 252645135) << 4);
+    a = ((a >> 8) & 16711935) | ((a & 16711935) << 8);
+    return [(a >> 16) | (a << 16)];
+  },
+};
+
 var lua_script = (function () {
   var tmp;
   var G = lua_newtable2(lua_core);