@tilua/compiler 3.0.1 → 4.0.0

package/runtime/array.luau

@@ -19,7 +19,7 @@ function __NAME__.findIndex(t, test)
 end
 
 function __NAME__.filter(t, test)
-	local out = {}
+	local out = __ARRAY__({})
 	for i = 1, #t do
 		if test(t[i], i) then
 			out[#out + 1] = t[i]
@@ -29,7 +29,7 @@ function __NAME__.filter(t, test)
 end
 
 function __NAME__.map(t, transform)
-	local out = {}
+	local out = __ARRAY__({})
 	for i = 1, #t do
 		out[i] = transform(t[i], i)
 	end
@@ -95,7 +95,7 @@ function __NAME__.join(t, separator)
 end
 
 function __NAME__.concat(t, ...)
-	local out = {}
+	local out = __ARRAY__({})
 	table.move(t, 1, #t, 1, out)
 	for i = 1, select("#", ...) do
 		local part = select(i, ...)
@@ -114,7 +114,7 @@ function __NAME__.slice(t, start, stop)
 	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 = {}
+	local out = __ARRAY__({})
 	for i = from, to do
 		out[#out + 1] = t[i]
 	end
@@ -123,7 +123,7 @@ end
 
 -- One level, as JavaScript's `flat()` does by default.
 function __NAME__.flat(t)
-	local out = {}
+	local out = __ARRAY__({})
 	for i = 1, #t do
 		local value = t[i]
 		if type(value) == "table" then

package/runtime/object.luau

@@ -5,7 +5,7 @@ local __NAME__ = {}
 -- follow the named ones. With no one order to give (`known` is nil), every
 -- key is listed, in the order `pairs` walks them.
 local function keysOf(known, open, t)
-	local out = {}
+	local out = __ARRAY__({})
 	if known == nil then
 		for key in pairs(t) do
 			out[#out + 1] = key
@@ -37,7 +37,7 @@ end
 -- rather than moving everything after it up one.
 function __NAME__.values(known, open, t)
 	local keys = keysOf(known, open, t)
-	local out = {}
+	local out = __ARRAY__({})
 	for i = 1, #keys do
 		out[i] = t[keys[i]]
 	end
@@ -46,9 +46,48 @@ end
 
 function __NAME__.entries(known, open, t)
 	local keys = keysOf(known, open, t)
-	local out = {}
+	local out = __ARRAY__({})
 	for i = 1, #keys do
-		out[i] = { keys[i], t[keys[i]] }
+		out[i] = __ARRAY__({ keys[i], t[keys[i]] })
 	end
 	return out
 end
+
+-- JavaScript's `Object` functions, as methods of the table they take first.
+-- `known` and `open` are handed to every method here; these need neither.
+
+-- The table's own member, not one its metatable's `__index` lends it.
+function __NAME__.hasOwn(known, open, t, key)
+	return rawget(t, key) ~= nil
+end
+
+function __NAME__.hasOwnProperty(known, open, t, key)
+	return rawget(t, key) ~= nil
+end
+
+-- Each source's members onto `t`, later sources over earlier ones; a `nil`
+-- source is skipped, as JavaScript skips `null`.
+function __NAME__.assign(known, open, t, ...)
+	for i = 1, select("#", ...) do
+		local source = select(i, ...)
+		if source ~= nil then
+			for key, value in pairs(source) do
+				t[key] = value
+			end
+		end
+	end
+	return t
+end
+
+-- Luau freezes a table in place. Lua 5.1 has no way to, and the table is
+-- answered as it is.
+function __NAME__.freeze(known, open, t)
+	if table.freeze ~= nil and not table.isfrozen(t) then
+		table.freeze(t)
+	end
+	return t
+end
+
+function __NAME__.isFrozen(known, open, t)
+	return table.isfrozen ~= nil and table.isfrozen(t)
+end

package/runtime/string.luau

@@ -88,7 +88,7 @@ local function values(...)
 	if select("#", ...) <= 1 and (...) == nil then
 		return nil
 	end
-	return { ... }
+	return __ARRAY__({ ... })
 end
 
 function __NAME__.find(s, pattern, init, plain)
@@ -107,7 +107,7 @@ function __NAME__.byte(s, i, j)
 	if j == nil then
 		return (string.byte(s, i))
 	end
-	return { string.byte(s, i, j) }
+	return __ARRAY__({ string.byte(s, i, j) })
 end
 
 -- An iterator function: each call is one match's captures, as an array.