@tilua/compiler 2.4.0 → 3.0.0

package/dist/index.cjs

@@ -28,8 +28,12 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
 // src/bundle.ts
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 var import_parser3 = require("@tilua/parser");
 var import_luau_parser2 = require("luau-parser");
@@ -57,10 +61,10 @@ var nil = () => ({ type: "NilLiteral", ...span() });
 var boolean = (value) => ({ type: "BooleanLiteral", value, ...span() });
 var number = (value, raw = String(value)) => ({ type: "NumberLiteral", value, raw, ...span() });
 var string = (value) => ({ type: "StringLiteral", value, raw: "", ...span() });
-var member = (object, property) => isLuauName(property) ? { type: "MemberExpression", object, property: identifier(property), ...span() } : index(object, string(property));
-var index = (object, key) => ({ type: "IndexExpression", object, index: key, ...span() });
+var member = (object2, property) => isLuauName(property) ? { type: "MemberExpression", object: object2, property: identifier(property), ...span() } : index(object2, string(property));
+var index = (object2, key) => ({ type: "IndexExpression", object: object2, index: key, ...span() });
 var call = (callee, args) => ({ type: "CallExpression", callee, arguments: args, ...span() });
-var methodCall = (object, method, args) => ({ type: "MethodCallExpression", object, method: identifier(method), arguments: args, ...span() });
+var methodCall = (object2, method, args) => ({ type: "MethodCallExpression", object: object2, method: identifier(method), arguments: args, ...span() });
 var functionExpression = (func) => ({ type: "FunctionExpression", func, ...span() });
 var binary = (operator, left, right) => ({ type: "BinaryExpression", operator, left, right, ...span() });
 var unary = (operator, argument) => ({ type: "UnaryExpression", operator, argument, ...span() });
@@ -176,6 +180,62 @@ var Names = class _Names {
   }
 };
 
+// src/language.ts
+var import_node_fs = require("fs");
+var read = (name) => (0, import_node_fs.readFileSync)(new URL(`../runtime/${name}`, importMetaUrl), "utf8");
+var implemented = (source) => new Set([...source.matchAll(/function __NAME__\.(\w+)/g)].map((m) => m[1]));
+var array = read("array.luau");
+var string2 = read("string.luau");
+var object = read("object.luau");
+var arrayMethods = implemented(array);
+var stringMethods = implemented(string2);
+var objectMethods = implemented(object);
+function every(type, is, seen = /* @__PURE__ */ new Set()) {
+  if (!type || seen.has(type)) return false;
+  seen.add(type);
+  if (type.kind === "union") {
+    return type.types.filter((m) => !(m.kind === "primitive" && m.name === "nil")).every((m) => every(m, is, seen));
+  }
+  if (type.kind === "typeParam") return every(type.constraint, is, seen);
+  return is(type);
+}
+var isArray = (type) => every(type, (t) => t.kind === "array" || t.kind === "tuple");
+var isString = (type) => every(type, (t) => t.kind === "primitive" && t.name === "string" || t.kind === "literal" && t.base === "string" || t.kind === "templateLiteral");
+function objectKeys(type) {
+  const members = type?.kind === "union" ? type.types : type ? [type] : [];
+  const orders = [];
+  let open = false;
+  for (const member2 of members) {
+    const keys = [];
+    for (const part of member2.kind === "intersection" ? member2.types : [member2]) {
+      if (part.kind !== "object") continue;
+      for (const key of part.properties.keys()) if (!keys.includes(key)) keys.push(key);
+      if (part.indexer) open = true;
+    }
+    orders.push(keys);
+  }
+  const order = JSON.stringify(orders[0] ?? []);
+  const known = orders.length && orders.every((keys) => JSON.stringify(keys) === order) ? `{ ${orders[0].map((key) => JSON.stringify(key)).join(", ")} }` : "nil";
+  return { known, open: String(open) };
+}
+var plugin = {
+  runtime: { array, string: string2, object },
+  methodCall({ method, receiver, use }) {
+    if (isString(receiver)) {
+      return stringMethods.has(method) ? { callee: `${use("string")}.${method}` } : void 0;
+    }
+    if (isArray(receiver)) {
+      return arrayMethods.has(method) ? { callee: `${use("array")}.${method}` } : void 0;
+    }
+    if (objectMethods.has(method)) {
+      const keys = objectKeys(receiver);
+      return { callee: `${use("object")}.${method}`, prepend: [keys.known, keys.open] };
+    }
+    return void 0;
+  }
+};
+var languageLowering = { plugin, from: "tilua" };
+
 // src/lower.ts
 function lower(program2, scopes, options = {}) {
   return new Lowerer(program2, scopes, options).run();
@@ -359,21 +419,34 @@ var Lowerer = class {
     if (id === void 0) return node.name;
     return this.scopes.bindings.get(id)?.kind === "global" ? node.name : void 0;
   }
-  /** What a library says `receiver:method(...)` is. The last library
-   *  loaded is asked first, so a project's own library can answer for a
-   *  method an earlier one also claims; no answer leaves an ordinary Luau
-   *  method call, which is what a value that answers to the method itself
-   *  wants (`text:upper()`). */
+  /** The language's own lowering, then each library's, in load order. A
+   *  runtime is named by its lowering's place here (`loweringRuntime`). */
+  get lowerings() {
+    return this.allLowerings ??= [languageLowering, ...this.options.lowerings ?? []];
+  }
+  allLowerings;
+  /** What `receiver:method(...)` becomes, when Luau alone would not run it.
+   *
+   *  A method the receiver's metatable gave it — the analyzer says so, and
+   *  whose metatable it was (`methodSources`) — is asked of whoever declared
+   *  that metatable, and only them: the language lowers its own
+   *  (`names:filter(f)` becomes a call into its runtime), a library its own,
+   *  and one the program declared is taken at its word. Any other method is
+   *  a member of the receiver's own, which a library may still claim
+   *  (`console:log`), the last library loaded first. No answer leaves an
+   *  ordinary Luau method call: `text:upper()` reaches Lua's own. */
   loweredMethodCall(node) {
-    const lowerings = this.options.lowerings;
-    if (!lowerings?.some((l) => l.plugin.methodCall)) return void 0;
+    const lowerings = this.lowerings;
+    const source = this.options.types?.methodSources.get(node);
+    const asked = source?.origin === "language" ? [0] : source?.origin === "library" ? lowerings.flatMap((l, i) => l.library === source.library ? [i] : []) : source?.origin === "program" ? [] : lowerings.map((_, i) => i).slice(1).reverse();
+    if (!asked.some((i) => lowerings[i].plugin.methodCall)) return void 0;
     const receiver = this.options.types?.typeOf.get(node.object);
     const receiverGlobal = this.globalName(node.object);
     const info = this.lazyArguments(node.arguments);
-    for (let i = lowerings.length - 1; i >= 0; i--) {
-      const plugin = lowerings[i].plugin;
-      if (!plugin.methodCall) continue;
-      const answer = plugin.methodCall({
+    for (const i of asked) {
+      const plugin2 = lowerings[i].plugin;
+      if (!plugin2.methodCall) continue;
+      const answer = plugin2.methodCall({
         method: node.method.name,
         receiver,
         receiverGlobal,
@@ -396,15 +469,15 @@ var Lowerer = class {
   }
   /** What a library says a call to a global — `print(x)` — is. */
   loweredGlobalCall(node) {
-    const lowerings = this.options.lowerings;
+    const lowerings = this.lowerings;
     if (!lowerings?.some((l) => l.plugin.globalCall)) return void 0;
     const name = this.globalName(node.callee);
     if (name === void 0) return void 0;
     const info = this.lazyArguments(node.arguments);
     for (let i = lowerings.length - 1; i >= 0; i--) {
-      const plugin = lowerings[i].plugin;
-      if (!plugin.globalCall) continue;
-      const answer = plugin.globalCall({
+      const plugin2 = lowerings[i].plugin;
+      if (!plugin2.globalCall) continue;
+      const answer = plugin2.globalCall({
         name,
         at: this.callSite(node.callee),
         get arguments() {
@@ -418,7 +491,7 @@ var Lowerer = class {
   }
   /** What a library says a global read as a value — `local p = print` — is. */
   loweredGlobalValue(node) {
-    const lowerings = this.options.lowerings;
+    const lowerings = this.lowerings;
     if (!lowerings?.some((l) => l.plugin.globalValue)) return void 0;
     const name = this.globalName(node);
     if (name === void 0) return void 0;
@@ -448,7 +521,7 @@ var Lowerer = class {
     try {
       return (0, import_luau_parser.parseExpressionFromSource)(source);
     } catch (error) {
-      this.report(node, `'${this.options.lowerings[index2].from}' lowered this to Luau that does not parse: ${JSON.stringify(source)} (${error.message})`);
+      this.report(node, `'${this.lowerings[index2].from}' lowered this to Luau that does not parse: ${JSON.stringify(source)} (${error.message})`);
       return void 0;
     }
   }
@@ -469,8 +542,8 @@ var Lowerer = class {
       ], true)));
     }
     for (const { index: index2, runtime: runtime2, name } of this.loweringUsed) {
-      const { plugin, from } = this.options.lowerings[index2];
-      const source = plugin.runtime?.[runtime2];
+      const { plugin: plugin2, from } = this.lowerings[index2];
+      const source = plugin2.runtime?.[runtime2];
       if (source === void 0) {
         this.diagnostics.push({
           message: `'${from}' asked for a runtime it does not have: '${runtime2}'`,
@@ -805,6 +878,7 @@ var Lowerer = class {
       case "ExportTypeAliasStatement":
       case "DeclareStatement":
       case "DeclareClassStatement":
+      case "DeclareMetatableStatement":
       case "ErrorStatement":
         return [];
       case "VariableDeclaration":
@@ -1405,11 +1479,11 @@ end
   callValues(node) {
     const chain = optionalChain(node);
     if (chain) return this.optionalChainExpression(chain);
-    const object = linkObject(node);
-    if (node.type === "CallExpression" && object.type === "Identifier") {
-      return this.link(node, this.reference(object));
+    const object2 = linkObject(node);
+    if (node.type === "CallExpression" && object2.type === "Identifier") {
+      return this.link(node, this.reference(object2));
     }
-    return this.link(node, this.expression(object));
+    return this.link(node, this.expression(object2));
   }
   /** A call is one value in tilua, and Luau would hand on every value one
    *  returns in the last place of an argument list or a `return`: it is
@@ -1448,16 +1522,16 @@ end
     }))];
   }
   /** One link of an access chain, read from `object`. */
-  link(node, object) {
+  link(node, object2) {
     switch (node.type) {
       case "MemberExpression":
-        return member(object, node.property.name);
+        return member(object2, node.property.name);
       case "IndexExpression":
-        return index(object, this.expression(node.index));
+        return index(object2, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
         const args = this.arguments(node.arguments);
-        if (!lowered) return call(object, args);
+        if (!lowered) return call(object2, args);
         return call(calleePath(lowered.callee), [...lowered.prepend, ...args]);
       }
       case "MethodCallExpression": {
@@ -1466,14 +1540,14 @@ end
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
-            ...lowered.passReceiver ? [object] : [],
+            ...lowered.passReceiver ? [object2] : [],
             ...args
           ]);
         }
         if (!isLuauName(node.method.name)) {
           this.report(node.method, `'${node.method.name}' is a Luau keyword and cannot be called with ':'`);
         }
-        return methodCall(object, node.method.name, args);
+        return methodCall(object2, node.method.name, args);
       }
     }
   }
@@ -1494,8 +1568,8 @@ end
     }
     return out;
   }
-  applySegment(segment, object) {
-    return segment.reduce((value, link) => this.link(link, value), object);
+  applySegment(segment, object2) {
+    return segment.reduce((value, link) => this.link(link, value), object2);
   }
   /** `a?.b:m()` as a statement:
    *  `do local ref = a if ref ~= nil then ref.b:m() end end` */
@@ -1571,9 +1645,9 @@ end
     const before = [];
     let target;
     if (node.target.type === "MemberExpression" || node.target.type === "IndexExpression") {
-      const object = this.expression(node.target.object);
+      const object2 = this.expression(node.target.object);
       const objectName = this.names.fresh("target");
-      before.push(local([objectName], [object]));
+      before.push(local([objectName], [object2]));
       if (node.target.type === "MemberExpression") {
         target = member(identifier(objectName), node.target.property.name);
       } else {
@@ -1991,15 +2065,15 @@ async function loadLowerings(modules) {
   for (const module2 of modules) {
     try {
       const loaded = await import((0, import_node_url.pathToFileURL)(module2.file).href);
-      const plugin = loaded.default;
-      if (!plugin || typeof plugin !== "object") {
+      const plugin2 = loaded.default;
+      if (!plugin2 || typeof plugin2 !== "object") {
         problems.push({
           file: module2.file,
           message: `'${module2.from}' lowering module has no default export`
         });
         continue;
       }
-      lowerings.push({ plugin, from: module2.from });
+      lowerings.push({ plugin: plugin2, from: module2.from, library: module2.library });
     } catch (error) {
       problems.push({
         file: module2.file,
@@ -2251,7 +2325,7 @@ ${G} = {
 }
 function stampOf(file) {
   try {
-    const at = (0, import_node_fs.statSync)(file);
+    const at = (0, import_node_fs2.statSync)(file);
     return `${at.size}:${at.mtimeMs}`;
   } catch {
     return void 0;
@@ -2267,7 +2341,7 @@ function parseFile(file, diagnostics, directives) {
   }
   let text;
   try {
-    text = (0, import_node_fs.readFileSync)(file, "utf8");
+    text = (0, import_node_fs2.readFileSync)(file, "utf8");
   } catch {
     diagnostics.push({ file, message: "Cannot read file", line: 1, column: 1, category: "module" });
     return void 0;
@@ -2294,14 +2368,14 @@ var libraryCache = /* @__PURE__ */ new Map();
 function parsedLibrary(file) {
   let stamp;
   try {
-    const at = (0, import_node_fs.statSync)(file);
+    const at = (0, import_node_fs2.statSync)(file);
     stamp = `${at.size}:${at.mtimeMs}`;
   } catch {
     stamp = "";
   }
   const cached = libraryCache.get(file);
   if (cached && cached.stamp === stamp) return cached.program;
-  const program2 = (0, import_parser3.parse)((0, import_node_fs.readFileSync)(file, "utf8"));
+  const program2 = (0, import_parser3.parse)((0, import_node_fs2.readFileSync)(file, "utf8"));
   libraryCache.set(file, { stamp, program: program2 });
   return program2;
 }
@@ -2324,7 +2398,7 @@ function analyzeModules(modules, config) {
     const done = analyzed.get(file);
     if (done) return done;
     const remembered = moduleAnalyses.get(file);
-    if (remembered && remembered.setting === settingFor && libs.length === remembered.libs.length && remembered.libs.every((lib, i) => lib === libs[i]) && remembered.program === program2 && [...remembered.read].every(([read, stamp]) => stampOf(read) === stamp)) {
+    if (remembered && remembered.setting === settingFor && libs.length === remembered.libs.length && remembered.libs.every((lib, i) => lib === libs[i]) && remembered.program === program2 && [...remembered.read].every(([read2, stamp]) => stampOf(read2) === stamp)) {
       analyzed.set(file, remembered.result);
       readWhile.set(file, remembered.read);
       return remembered.result;
@@ -2348,12 +2422,12 @@ function analyzeModules(modules, config) {
     const result = { types, diagnostics: said };
     if (partials === before) {
       analyzed.set(file, result);
-      const read = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
       const own = stampOf(file);
-      if (own !== void 0) read.set(file, own);
-      readWhile.set(file, read);
-      if ([...read.values()].every((stamp) => stamp !== void 0)) {
-        moduleAnalyses.set(file, { setting: settingFor, libs: [...libs], program: program2, read, result });
+      if (own !== void 0) read2.set(file, own);
+      readWhile.set(file, read2);
+      if ([...read2.values()].every((stamp) => stamp !== void 0)) {
+        moduleAnalyses.set(file, { setting: settingFor, libs: [...libs], program: program2, read: read2, result });
       }
     }
     return result;
@@ -2362,11 +2436,11 @@ function analyzeModules(modules, config) {
     const target = (0, import_parser3.resolveModulePath)(file, specifier, config);
     if (!target) return void 0;
     const noteRead = () => {
-      const read = readWhile.get(file) ?? /* @__PURE__ */ new Map();
-      readWhile.set(file, read);
+      const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      readWhile.set(file, read2);
       const stamp = stampOf(target);
-      if (stamp !== void 0) read.set(target, stamp);
-      for (const [below, belowStamp] of readWhile.get(target) ?? []) read.set(below, belowStamp);
+      if (stamp !== void 0) read2.set(target, stamp);
+      for (const [below, belowStamp] of readWhile.get(target) ?? []) read2.set(below, belowStamp);
     };
     if (inProgress.has(target)) {
       partials++;
@@ -2380,7 +2454,7 @@ function analyzeModules(modules, config) {
     let program2 = byFile.get(target)?.program;
     if (!program2) {
       try {
-        program2 = (0, import_parser3.parse)((0, import_node_fs.readFileSync)(target, "utf8"));
+        program2 = (0, import_parser3.parse)((0, import_node_fs2.readFileSync)(target, "utf8"));
       } catch {
         return void 0;
       }
@@ -2422,7 +2496,7 @@ function allStatements(statements) {
 }
 
 // src/compile.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_node_path3 = require("path");
 var import_parser4 = require("@tilua/parser");
 var import_luau_parser3 = require("luau-parser");
@@ -2450,7 +2524,7 @@ async function compile(source, config) {
     diagnostics.push({ message: p.message, line: p.line ?? 1, column: p.column ?? 1 });
   }
   for (const p of loweringProblems) diagnostics.push({ message: p.message, line: 1, column: 1 });
-  const libs = libraries.files.map((file) => (0, import_parser4.parse)((0, import_node_fs2.readFileSync)(file, "utf8")));
+  const libs = libraries.files.map((file) => (0, import_parser4.parse)((0, import_node_fs3.readFileSync)(file, "utf8")));
   const lowered = lower(program2, scopes, {
     types: (0, import_parser4.analyzeTypes)(program2, scopes, { libs, diagnostics: false }),
     lowerings,

package/dist/index.d.cts

@@ -29,6 +29,10 @@ interface LoadedLowering {
     readonly plugin: LoweringPlugin;
     /** The package it came from, for reporting. */
     readonly from: string;
+    /** The package's definitions, as their index in the libraries the
+     *  analyzer was given: a method read from a metatable they declare is
+     *  this lowering's to answer. Absent for the language's own. */
+    readonly library?: number;
 }
 interface LoweringProblem {
     readonly file: string;
@@ -40,6 +44,7 @@ interface LoweringProblem {
 declare function loadLowerings(modules: readonly {
     file: string;
     from: string;
+    library?: number;
 }[]): Promise<{
     lowerings: LoadedLowering[];
     problems: LoweringProblem[];

package/dist/index.d.ts

@@ -29,6 +29,10 @@ interface LoadedLowering {
     readonly plugin: LoweringPlugin;
     /** The package it came from, for reporting. */
     readonly from: string;
+    /** The package's definitions, as their index in the libraries the
+     *  analyzer was given: a method read from a metatable they declare is
+     *  this lowering's to answer. Absent for the language's own. */
+    readonly library?: number;
 }
 interface LoweringProblem {
     readonly file: string;
@@ -40,6 +44,7 @@ interface LoweringProblem {
 declare function loadLowerings(modules: readonly {
     file: string;
     from: string;
+    library?: number;
 }[]): Promise<{
     lowerings: LoadedLowering[];
     problems: LoweringProblem[];

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   lower,
   program,
   resolveConfig
-} from "./chunk-3ZQ3EITC.js";
+} from "./chunk-X4DM2BX2.js";
 
 // src/compile.ts
 import { readFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua/compiler",
-  "version": "2.4.0",
+  "version": "3.0.0",
   "description": "Compiles tilua to Luau: lowers the @tilua/parser AST to a luau-parser AST and prints it",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -9,7 +9,8 @@
     "tilua": "dist/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "runtime"
   ],
   "exports": {
     ".": {
@@ -37,7 +38,7 @@
   "type": "module",
   "dependencies": {
     "luau-parser": "^1.0.3",
-    "@tilua/parser": "^2.4.0"
+    "@tilua/parser": "^3.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.2",

package/runtime/array.luau

@@ -0,0 +1,179 @@
+local __NAME__ = {}
+
+function __NAME__.find(t, test)
+	for i = 1, #t do
+		if test(t[i], i) then
+			return t[i]
+		end
+	end
+	return nil
+end
+
+function __NAME__.findIndex(t, test)
+	for i = 1, #t do
+		if test(t[i], i) then
+			return i
+		end
+	end
+	return nil
+end
+
+function __NAME__.filter(t, test)
+	local out = {}
+	for i = 1, #t do
+		if test(t[i], i) then
+			out[#out + 1] = t[i]
+		end
+	end
+	return out
+end
+
+function __NAME__.map(t, transform)
+	local out = {}
+	for i = 1, #t do
+		out[i] = transform(t[i], i)
+	end
+	return out
+end
+
+function __NAME__.forEach(t, visit)
+	for i = 1, #t do
+		visit(t[i], i)
+	end
+end
+
+function __NAME__.some(t, test)
+	for i = 1, #t do
+		if test(t[i], i) then
+			return true
+		end
+	end
+	return false
+end
+
+function __NAME__.every(t, test)
+	for i = 1, #t do
+		if not test(t[i], i) then
+			return false
+		end
+	end
+	return true
+end
+
+function __NAME__.reduce(t, step, initial)
+	local total = initial
+	for i = 1, #t do
+		total = step(total, t[i], i)
+	end
+	return total
+end
+
+function __NAME__.includes(t, value)
+	for i = 1, #t do
+		if t[i] == value then
+			return true
+		end
+	end
+	return false
+end
+
+function __NAME__.indexOf(t, value, start)
+	for i = start or 1, #t do
+		if t[i] == value then
+			return i
+		end
+	end
+	return nil
+end
+
+function __NAME__.join(t, separator)
+	local out = {}
+	for i = 1, #t do
+		out[i] = tostring(t[i])
+	end
+	return table.concat(out, separator or ",")
+end
+
+function __NAME__.concat(t, ...)
+	local out = {}
+	table.move(t, 1, #t, 1, out)
+	for i = 1, select("#", ...) do
+		local part = select(i, ...)
+		table.move(part, 1, #part, #out + 1, out)
+	end
+	return out
+end
+
+-- An inclusive range, as `string.sub` takes: `slice(2, 3)` is the second and
+-- third elements, and a negative counts back from the last.
+function __NAME__.slice(t, start, stop)
+	local n = #t
+	local from = start or 1
+	local to = stop or n
+	if from < 0 then from = n + from + 1 end
+	if to < 0 then to = n + to + 1 end
+	if from < 1 then from = 1 end
+	if to > n then to = n end
+	local out = {}
+	for i = from, to do
+		out[#out + 1] = t[i]
+	end
+	return out
+end
+
+-- One level, as JavaScript's `flat()` does by default.
+function __NAME__.flat(t)
+	local out = {}
+	for i = 1, #t do
+		local value = t[i]
+		if type(value) == "table" then
+			table.move(value, 1, #value, #out + 1, out)
+		else
+			out[#out + 1] = value
+		end
+	end
+	return out
+end
+
+function __NAME__.reverse(t)
+	local n = #t
+	for i = 1, n // 2 do
+		t[i], t[n - i + 1] = t[n - i + 1], t[i]
+	end
+	return t
+end
+
+function __NAME__.sort(t, compare)
+	if compare then
+		table.sort(t, compare)
+	else
+		table.sort(t)
+	end
+	return t
+end
+
+function __NAME__.push(t, ...)
+	local n = #t
+	for i = 1, select("#", ...) do
+		t[n + i] = select(i, ...)
+	end
+	return #t
+end
+
+function __NAME__.pop(t)
+	local n = #t
+	local last = t[n]
+	t[n] = nil
+	return last
+end
+
+function __NAME__.shift(t)
+	return table.remove(t, 1)
+end
+
+function __NAME__.unshift(t, ...)
+	for i = select("#", ...), 1, -1 do
+		table.insert(t, 1, (select(i, ...)))
+	end
+	return #t
+end