@gamely/gly-engine-lite 0.0.19 → 0.0.21

package/dist/main.lua

@@ -1,48 +1,48 @@
 local math = ((function() local x, y = pcall(require, 'math'); return x and y end)()) or _G.math
-local src_version_55d740741220 = nil
-local src_lib_common_module_55d74078d4c0 = nil
-local src_lib_engine_api_encoder_55d740797c20 = nil
-local src_lib_engine_api_app_55d7407cdb00 = nil
-local src_lib_engine_api_hash_55d740798450 = nil
-local src_lib_engine_api_http_55d74079e880 = nil
-local src_lib_engine_api_i18n_55d74075aa10 = nil
-local src_lib_engine_api_key_55d7407bfbd0 = nil
-local src_lib_engine_api_log_55d7407a7ec0 = nil
-local src_lib_engine_api_math_55d740799d40 = nil
-local src_lib_engine_api_array_55d740779000 = nil
-local src_lib_engine_api_media_55d7407489d0 = nil
-local src_lib_engine_draw_fps_55d740798890 = nil
-local src_lib_engine_draw_text_55d7407c8b90 = nil
-local src_lib_engine_draw_poly_55d740799b40 = nil
-local src_lib_engine_raw_memory_55d74079abd0 = nil
-local src_lib_protocol_http_callback_55d74079bca0 = nil
-local src_lib_object_root_55d7407b5bb0 = nil
-local src_lib_object_color_55d7407a8380 = nil
-local src_lib_object_std_55d74076e7c0 = nil
-local src_lib_util_pipeline_55d7407bc4c0 = nil
-local src_lib_util_decorator_55d7407a7e30 = nil
-local src_lib_util_http_55d74078aa00 = nil
-local function main_55d7407a19d0()
-local version = src_version_55d740741220()
-local zeebo_module = src_lib_common_module_55d74078d4c0()
-local engine_encoder = src_lib_engine_api_encoder_55d740797c20()
-local engine_game = src_lib_engine_api_app_55d7407cdb00()
-local engine_hash = src_lib_engine_api_hash_55d740798450()
-local engine_http = src_lib_engine_api_http_55d74079e880()
-local engine_i18n = src_lib_engine_api_i18n_55d74075aa10()
-local engine_key = src_lib_engine_api_key_55d7407bfbd0()
-local engine_log = src_lib_engine_api_log_55d7407a7ec0()
-local engine_math = src_lib_engine_api_math_55d740799d40()
-local engine_array = src_lib_engine_api_array_55d740779000()
-local engine_media = src_lib_engine_api_media_55d7407489d0()
-local engine_draw_fps = src_lib_engine_draw_fps_55d740798890()
-local engine_draw_text = src_lib_engine_draw_text_55d7407c8b90()
-local engine_draw_poly = src_lib_engine_draw_poly_55d740799b40()
-local engine_raw_memory = src_lib_engine_raw_memory_55d74079abd0()
-local callback_http = src_lib_protocol_http_callback_55d74079bca0()
-local application_default = src_lib_object_root_55d7407b5bb0()
-local color = src_lib_object_color_55d7407a8380()
-local std = src_lib_object_std_55d74076e7c0()
+local src_version_560c51e6c020 = nil
+local src_lib_common_module_560c51e81030 = nil
+local src_lib_engine_api_encoder_560c51e671b0 = nil
+local src_lib_engine_api_app_560c51e67890 = nil
+local src_lib_engine_api_hash_560c51e82110 = nil
+local src_lib_engine_api_http_560c51e8b270 = nil
+local src_lib_engine_api_i18n_560c51e5e8f0 = nil
+local src_lib_engine_api_key_560c51e7f130 = nil
+local src_lib_engine_api_log_560c51e8c2a0 = nil
+local src_lib_engine_api_math_560c51e81c30 = nil
+local src_lib_engine_api_array_560c51e81500 = nil
+local src_lib_engine_api_media_560c51e62230 = nil
+local src_lib_engine_draw_fps_560c51e694a0 = nil
+local src_lib_engine_draw_text_560c51e69bd0 = nil
+local src_lib_engine_draw_poly_560c51e7e7e0 = nil
+local src_lib_engine_raw_memory_560c51e82820 = nil
+local src_lib_protocol_http_callback_560c51e7c810 = nil
+local src_lib_object_root_560c51e6d3f0 = nil
+local src_lib_object_color_560c51e80600 = nil
+local src_lib_object_std_560c51e7d900 = nil
+local src_lib_util_pipeline_560c51e36e60 = nil
+local src_lib_util_decorator_560c51e7fd40 = nil
+local src_lib_util_http_560c51e3c4b0 = nil
+local function main_560c51e83670()
+local version = src_version_560c51e6c020()
+local zeebo_module = src_lib_common_module_560c51e81030()
+local engine_encoder = src_lib_engine_api_encoder_560c51e671b0()
+local engine_game = src_lib_engine_api_app_560c51e67890()
+local engine_hash = src_lib_engine_api_hash_560c51e82110()
+local engine_http = src_lib_engine_api_http_560c51e8b270()
+local engine_i18n = src_lib_engine_api_i18n_560c51e5e8f0()
+local engine_key = src_lib_engine_api_key_560c51e7f130()
+local engine_log = src_lib_engine_api_log_560c51e8c2a0()
+local engine_math = src_lib_engine_api_math_560c51e81c30()
+local engine_array = src_lib_engine_api_array_560c51e81500()
+local engine_media = src_lib_engine_api_media_560c51e62230()
+local engine_draw_fps = src_lib_engine_draw_fps_560c51e694a0()
+local engine_draw_text = src_lib_engine_draw_text_560c51e69bd0()
+local engine_draw_poly = src_lib_engine_draw_poly_560c51e7e7e0()
+local engine_raw_memory = src_lib_engine_raw_memory_560c51e82820()
+local callback_http = src_lib_protocol_http_callback_560c51e7c810()
+local application_default = src_lib_object_root_560c51e6d3f0()
+local color = src_lib_object_color_560c51e80600()
+local std = src_lib_object_std_560c51e7d900()
 local application = application_default
 local engine = {
 keyboard = function(a, b, c, d) end,
@@ -61,9 +61,11 @@ local cfg_media = {
 bootstrap=native_media_bootstrap,
 position=native_media_position,
 resize=native_media_resize,
+resume=native_media_resume,
+source=native_media_source,
 pause=native_media_pause,
-load=native_media_load,
-play=native_media_play
+play=native_media_play,
+stop=native_media_stop
 }
 local cfg_poly = {
 repeats = {
@@ -148,7 +150,9 @@ std.draw.color=native_draw_color
 std.draw.font=native_draw_font
 std.draw.rect=native_draw_rect
 std.draw.line=native_draw_line
-std.draw.image=native_draw_image
+std.draw.image=native_image_draw
+std.image.load=native_image_load
+std.image.draw=native_image_draw
 std.text.print=native_text_print
 std.text.mensure=native_text_mensure
 std.text.font_size=native_text_font_size
@@ -170,6 +174,7 @@ zeebo_module.require(std, application, engine)
 :package('@color', color)
 :package('@log', engine_log, cfg_log)
 :package('math', engine_math.clib)
+:package('math.wave', engine_math.wave)
 :package('math.random', engine_math.clib_random)
 :package('http', engine_http, cfg_http)
 :package('base64', engine_encoder, cfg_base64)
@@ -178,7 +183,6 @@ zeebo_module.require(std, application, engine)
 :package('i18n', engine_i18n, cfg_system)
 :package('hash', engine_hash, cfg_system)
 :package('media.video', engine_media, cfg_media)
-:package('media.audio', engine_media, cfg_media)
 :package('mock.video', engine_media)
 :package('mock.audio', engine_media)
 :run()
@@ -198,13 +202,13 @@ version=version
 }
 return P
 end
-src_version_55d740741220 = function()
-return '0.0.19'
+src_version_560c51e6c020 = function()
+return '0.0.21'
 end
 --
-src_lib_common_module_55d74078d4c0 = function()
-local zeebo_pipeline = src_lib_util_pipeline_55d7407bc4c0()
-local application_default = src_lib_object_root_55d7407b5bb0()
+src_lib_common_module_560c51e81030 = function()
+local zeebo_pipeline = src_lib_util_pipeline_560c51e36e60()
+local application_default = src_lib_object_root_560c51e6d3f0()
 local function default(application, defaults)
 if not application then return nil end
 local index = 1    
@@ -222,6 +226,7 @@ end
 index = index + 1
 end
 normalized_aplication.config.id = tostring(application) 
+normalized_aplication.fonts = application.fonts or {}
 normalized_aplication.assets = application.assets or {}
 if application.callbacks then
 for event, handler in pairs(application.callbacks) do
@@ -244,6 +249,7 @@ end
 local normalized_aplication = {
 data = {},
 meta = {},
+fonts = {},
 assets = {},
 config = {},
 callbacks = {}
@@ -251,6 +257,8 @@ callbacks = {}
 for key, value in pairs(application) do
 if key == 'assets' then
 normalized_aplication.assets = value
+elseif key == 'fonts' then
+normalized_aplication.fonts = value
 elseif application_default.meta[key] then
 normalized_aplication.meta[key] = value
 elseif application_default.config[key] then
@@ -402,7 +410,7 @@ require = require
 return P
 end
 --
-src_lib_engine_api_encoder_55d740797c20 = function()
+src_lib_engine_api_encoder_560c51e671b0 = function()
 local function install(std, engine, library, name)
 std = std or {}
 std[name] = {
@@ -417,8 +425,8 @@ install=install
 return P
 end
 --
-src_lib_engine_api_app_55d7407cdb00 = function()
-local util_decorator = src_lib_util_decorator_55d7407a7e30()
+src_lib_engine_api_app_560c51e67890 = function()
+local util_decorator = src_lib_util_decorator_560c51e7fd40()
 local function reset(std, engine)
 if std.node then
 std.bus.emit('exit')
@@ -458,7 +466,7 @@ install=install
 return P
 end
 --
-src_lib_engine_api_hash_55d740798450 = function()
+src_lib_engine_api_hash_560c51e82110 = function()
 local function djb2(digest)
 local index = 1
 local hash = 5381
@@ -484,26 +492,38 @@ install = install
 return P
 end
 --
-src_lib_engine_api_http_55d74079e880 = function()
-local zeebo_pipeline = src_lib_util_pipeline_55d7407bc4c0()
-local function fast(self)
-self.speed = '_fast'
+src_lib_engine_api_http_560c51e8b270 = function()
+local zeebo_pipeline = src_lib_util_pipeline_560c51e36e60()
+local function json(self)
+self.options['json'] = true
 return self
 end
-local function body(self, content)
-self.body_content=content
+local function noforce(self)
+self.options['noforce'] = true
+return self
+end
+local function fast(self)
+self.speed = '_fast'
 return self
 end
 local function param(self, name, value)
 local index = #self.param_list + 1
-self.param_list[index] = name
-self.param_dict[name] = value
+self.param_list[index] = tostring(name)
+self.param_dict[name] = tostring(value)
 return self
 end
 local function header(self, name, value)
 local index = #self.header_list + 1
-self.header_list[index] = name
-self.header_dict[name] = value
+self.header_list[index] = tostring(name)
+self.header_dict[name] = tostring(value)
+return self
+end
+local function body(self, content, json_encode)
+if type(content) == 'table' then
+header(self, 'Content-Type', 'application/json')
+content = json_encode(content)
+end
+self.body_content=content
 return self
 end
 local function success(self, handler_func)
@@ -530,14 +550,15 @@ return function (url)
 if protocol.has_callback then
 engine.http_count = engine.http_count + 1
 end
-if protocol.force then
-url = url:gsub("^[^:]+://", protocol.force.."://")
-end
+local json_encode = std.json and std.json.encode
+local json_decode = std.json and std.json.decode
+local http_body = function(self, content) return body(self, content, json_encode) end
 local game = engine.current.data
 local self = {
 id = engine.http_count,
 url = url,
 speed = '',
+options = {},
 method = method,
 body_content = '',
 header_list = {},
@@ -548,7 +569,9 @@ success_handler = function (std, game) end,
 failed_handler = function (std, game) end,
 error_handler = function (std, game) end,
 fast = fast,
-body = body,
+json = json,
+noforce = noforce,
+body = http_body,
 param = param,
 header = header,
 success = success,
@@ -567,14 +590,29 @@ std.http[key] = value
 end
 self.pipeline = {
 function()
+if not protocol.force or self.options['noforce'] then return end
+self.url = url:gsub("^[^:]+://", protocol.force.."://")
+end,
+function()
 if protocol.has_callback then engine.http_requests[self.id] = self end
 protocol.handler(self, self.id)
 end,
 function()
+if self.options['json'] and json_decode and std.http.body then
+pcall(function()
+local new_body = json_decode(std.http.body)
+std.http.body = new_body
+end)
+end
+end,
+function()
 callback_handler(std, game)
 if std.http.ok then
 self.success_handler(std, game)
-elseif std.http.error or not std.http.status then
+elseif std.http.error then
+self.error_handler(std, game)
+elseif not std.http.status then
+self.set('error', 'missing protocol response')
 self.error_handler(std, game)
 else
 self.failed_handler(std, game)
@@ -585,6 +623,7 @@ std.http.ok = nil
 std.http.body = nil
 std.http.error = nil
 std.http.status = nil
+std.http.body_is_table = nil
 end,
 function()
 if protocol.has_callback then engine.http_requests[self.id] = nil end
@@ -595,7 +634,7 @@ return self
 end
 end
 local function install(std, engine, protocol)
-assert(protocol.handler, 'missing protocol handler')
+assert(protocol and protocol.handler, 'missing protocol handler')
 if protocol.has_callback then
 engine.http_count = 0
 engine.http_requests = {}
@@ -617,7 +656,7 @@ install=install
 return P
 end
 --
-src_lib_engine_api_i18n_55d74075aa10 = function()
+src_lib_engine_api_i18n_560c51e5e8f0 = function()
 local language = 'en-US'
 local language_default = 'en-US'
 local language_list = {}
@@ -709,7 +748,7 @@ install=install
 return P
 end
 --
-src_lib_engine_api_key_55d7407bfbd0 = function()
+src_lib_engine_api_key_560c51e7f130 = function()
 local function real_key(std, engine, rkey, rvalue)
 local value = rvalue == 1 or rvalue == true
 local key = engine.key_bindings[rkey] or (std.key.axis[rkey] and rkey)
@@ -749,8 +788,8 @@ install = install
 return P
 end
 --
-src_lib_engine_api_log_55d7407a7ec0 = function()
-local util_decorator = src_lib_util_decorator_55d7407a7e30()
+src_lib_engine_api_log_560c51e8c2a0 = function()
+local util_decorator = src_lib_util_decorator_560c51e7fd40()
 local logging_types = {
 'none', 'fatal', 'error', 'warn', 'debug', 'info'
 }
@@ -796,7 +835,7 @@ install = install
 return P
 end
 --
-src_lib_engine_api_math_55d740799d40 = function()
+src_lib_engine_api_math_560c51e81c30 = function()
 local function abs(value)
 if value < 0 then
 return -value
@@ -875,8 +914,31 @@ index = index + 1
 end
 return min_value
 end
+local function sine(t, freq)
+return math.pi and math.sin(2 * math.pi * freq * t) or 1
+end
+local function ramp(t, freq, ratio)
+t = (t / 2) % (1 / freq) * freq
+if t < ratio then
+return 2 * t / ratio - 1
+else
+return (2 * t - ratio - 1) / (ratio - 1)
+end
+end
+local function saw(t, freq)
+return ramp(t, freq, 1)
+end
+local function triangle(t, freq)
+return ramp(t, freq, 1/2)
+end
+local function rect(t, freq, duty)
+duty = 1 - duty * 2
+return saw(t, freq) > duty and 1 or -1
+end
+local function square(t, freq)
+return rect(t, freq, 1/2)
+end
 local function install(std)
-std = std or {}
 std.math = std.math or {}
 std.math.abs=abs
 std.math.clamp=clamp
@@ -889,10 +951,15 @@ std.math.lerp=lerp
 std.math.map=map
 std.math.max=max
 std.math.min=min
-return std.math
+end
+local function install_wave(std)
+std.math = std.math or {}
+std.math.sine=sine
+std.math.saw=saw
+std.math.square=square
+std.math.triangle=triangle
 end
 local function install_clib(std)
-std = std or {}
 std.math = std.math or {}
 std.math.acos=math.acos
 std.math.asin=math.asin
@@ -919,20 +986,20 @@ std.math.sinh=math.sinh
 std.math.sqrt=math.sqrt
 std.math.tan=math.tan
 std.math.tanh=math.tanh
-return std.math
 end
 local function install_clib_random(std)
-std = std or {}
 std.math = std.math or {}
 std.math.random = function(a, b)
 a = a and math.floor(a)
 b = b and math.floor(b)
 return math.random(a, b)
 end
-return std.math
 end
 local P = {
 install = install,
+wave = {
+install = install_wave
+},
 clib = {
 install = install_clib
 },
@@ -943,8 +1010,8 @@ install = install_clib_random
 return P;
 end
 --
-src_lib_engine_api_array_55d740779000 = function()
-local util_decorator = src_lib_util_decorator_55d7407a7e30()
+src_lib_engine_api_array_560c51e81500 = function()
+local util_decorator = src_lib_util_decorator_560c51e7fd40()
 local function array_map(array, func)
 local res = {}
 local index = 1
@@ -1105,77 +1172,45 @@ install = install
 return P
 end
 --
-src_lib_engine_api_media_55d7407489d0 = function()
-local util_decorator = src_lib_util_decorator_55d7407a7e30()
-local function media_add(media, func, self, src)
-func(media - 1, self.id - 1, src)
-return self
-end
-local function media_play(media, func, self)
-func(media - 1, self.id - 1)
+src_lib_engine_api_media_560c51e62230 = function()
+local function media_create(node, channels, handler)
+local decorator = function(func)
+func = func or function() end
+return function(self, a, b, c)
+func(0, a, b, c)
 return self
 end
-local function media_pause(media, func, self)
-func(media - 1, self.id - 1)
-return self
-end
-local function media_resize(media, func, self, width, height)
-func(media - 1, self.id - 1, width, height)
-return self
 end
-local function media_position(media, func, self, pos_x, pos_y)
-func(media - 1, self.id - 1, pos_x, pos_y)
-return self
-end
-local function media_channel(std, handler, mediatype, mediaid, max_channels)
-return function(id)
-local channels = std.media.channels[mediaid]
-id = id or 1
-if 0 >= id or id > max_channels then
-error('Please, do not do that!')
-end
-if not channels[id] then
-channels[id] = {
-id = id,
-add = util_decorator.prefix2(mediaid, handler.load, media_add),
-play = util_decorator.prefix2(mediaid, handler.play, media_play),
-pause = util_decorator.prefix2(mediaid, handler.pause, media_pause),
-resize = util_decorator.prefix2(mediaid, handler.resize, media_resize),
-position = util_decorator.prefix2(mediaid, handler.position, media_position)
+local self = { 
+src = decorator(handler.source),
+play = decorator(handler.play),
+pause = decorator(handler.pause),
+resume = decorator(handler.resume),
+stop = decorator(handler.stop),
+position = decorator(handler.position),
+resize = decorator(handler.resize),
+in_mutex = handler.mutex or function() return false end,
+get_error = handler.error or function() return nil end,
+node = node,
+apply = function() end
 }
-if std.node then
-channels[id].node = std.node.load({})
-channels[id].apply = function()
-local node = channels[id].node
-local depth = 0
-local offset_x = 0
-local offset_y = 0
-while node and depth < 100 do
-offset_x = offset_x + node.config.offset_x
-offset_y = offset_y + node.config.offset_y
-node = node.config.parent
-depth = depth + 1
-end
-media_position(handler.position, channels[id], offset_x, offset_y)
-media_resize(handler.resize, channels[id], channels[id].node.data.width, channels[id].node.data.height)
-end
-end
-end
-return channels[id]
+return function()
+return self
 end
 end
-local function install(std, engine, handlers, name)
-handlers = handlers or {}
+local function install(std, engine, handler, name)
 std.media = std.media or {}
-std.media.types = std.media.types or {}
-std.media.channels = std.media.channels or {}
 local mediatype = name:match('%w+%.(%w+)')
-local mediaid = #std.media.types + 1
+if handler.install then
+handler.install(std, engine, mediatype, name)
+end
 if not std.media[mediatype] then
-local max_channels = handlers.bootstrap and handlers.bootstrap(mediaid - 1, mediatype) or 8
-std.media.channels[mediaid] = {}
-std.media.types[mediaid] = mediatype
-std.media[mediatype] = media_channel(std, handlers, mediatype, mediaid, max_channels)
+local channels = handler.bootstrap and handler.bootstrap(mediatype)
+if (not channels or channels == 0) and handler.bootstrap then
+error('media '..mediatype..' is not supported!')
+end
+local node = std.node and std.node.load({})
+std.media[mediatype] = media_create(node, channels, handler)
 end
 end
 local P = {
@@ -1184,7 +1219,7 @@ install=install
 return P
 end
 --
-src_lib_engine_draw_fps_55d740798890 = function()
+src_lib_engine_draw_fps_560c51e694a0 = function()
 local function draw_fps(std, engine, show, pos_x, pos_y)
 if show < 1 then return end
 local x = engine.current.config.offset_x + pos_x
@@ -1236,8 +1271,8 @@ install=install
 return P
 end
 --
-src_lib_engine_draw_text_55d7407c8b90 = function()
-local util_decorator = src_lib_util_decorator_55d7407a7e30()
+src_lib_engine_draw_text_560c51e69bd0 = function()
+local util_decorator = src_lib_util_decorator_560c51e7fd40()
 local function text_put(std, engine, font_previous, pos_x, pos_y, text, size)
 size = size or 2
 local hem = engine.current.data.width / 80
@@ -1248,10 +1283,10 @@ std.text.font_size(font_size)
 std.text.print(pos_x * hem, pos_y * vem, text)
 font_previous()
 end
-local function text_print_ex(std, engine, x, y, text, align)
+local function text_print_ex(std, engine, x, y, text, align_x, align_y)
 local w, h = std.text.mensure(text)
-local aligns = {w, w/2, 0}
-std.text.print(x - aligns[(align or 1) + 2], y, text)
+local aligns_x, aligns_y = {w, w/2, 0}, {h, h/2, 0}
+std.text.print(x - aligns_x[(align_x or 1) + 2], y - aligns_y[(align_y or 1) + 2], text)
 return w, h
 end
 local function install(std, engine, config)
@@ -1264,7 +1299,7 @@ install=install
 return P
 end
 --
-src_lib_engine_draw_poly_55d740799b40 = function()
+src_lib_engine_draw_poly_560c51e7e7e0 = function()
 local function decorator_poo(object, func)
 if not object or not func then return func end
 return function(a, b, c, d)
@@ -1371,7 +1406,7 @@ install=install
 return P
 end
 --
-src_lib_engine_raw_memory_55d74079abd0 = function()
+src_lib_engine_raw_memory_560c51e82820 = function()
 local memory_dict_unload = {}
 local memory_dict = {}
 local memory_list = {}
@@ -1426,8 +1461,8 @@ install=install
 return P
 end
 --
-src_lib_protocol_http_callback_55d74079bca0 = function()
-local http_util = src_lib_util_http_55d74078aa00()
+src_lib_protocol_http_callback_560c51e7c810 = function()
+local http_util = src_lib_util_http_560c51e3c4b0()
 local callbacks = {
 ['async-promise'] = function(self)
 return self:promise()
@@ -1494,7 +1529,7 @@ func = native_http_callback
 return P
 end
 --
-src_lib_object_root_55d7407b5bb0 = function()
+src_lib_object_root_560c51e6d3f0 = function()
 local P = {
 data={
 width=1280,
@@ -1524,61 +1559,34 @@ callbacks={
 return P;
 end
 --
-src_lib_object_color_55d7407a8380 = function()
-local white = 0xFFFFFFFF
-local lightgray = 0xC8CCCCFF
-local gray = 0x828282FF
-local darkgray = 0x505050FF
-local yellow = 0xFDF900FF
-local gold = 0xFFCB00FF
-local orange = 0xFFA100FF
-local pink = 0xFF6DC2FF
-local red = 0xE62937FF
-local maroon = 0xBE2137FF
-local green = 0x00E430FF
-local lime = 0x009E2FFF
-local darkgreen = 0x00752CFF
-local skyblue = 0x66BFFFFF
-local blue = 0x0079F1FF
-local darkblue = 0x0052ACFF
-local purple = 0xC87AFFFF
-local violet = 0x873CBEFF
-local darkpurple = 0x701F7EFF
-local beige = 0xD3B083FF
-local brown = 0x7F6A4FFF
-local darkbrown = 0x4C3F2FFF
-local black = 0x000000FF
-local blank = 0x00000000
-local magenta = 0xFF00FFFF
+src_lib_object_color_560c51e80600 = function()
 local function install(std)
-std = std or {}
 std.color = std.color or {}
-std.color.white = white
-std.color.lightgray = lightgray
-std.color.gray = gray
-std.color.darkgray = darkgray
-std.color.yellow = yellow
-std.color.gold = gold
-std.color.orange = orange
-std.color.pink = pink
-std.color.red = red
-std.color.maroon = maroon
-std.color.green = green
-std.color.lime = lime
-std.color.darkgreen = darkgreen
-std.color.skyblue = skyblue
-std.color.blue = blue
-std.color.darkblue = darkblue
-std.color.purple = purple
-std.color.violet = violet
-std.color.darkpurple = darkpurple
-std.color.beige = beige
-std.color.brown = brown
-std.color.darkbrown = darkbrown
-std.color.black = black
-std.color.blank = blank
-std.color.magenta = magenta
-return std.color
+std.color.white = 0xFFFFFFFF
+std.color.lightgray = 0xC8CCCCFF
+std.color.gray = 0x828282FF
+std.color.darkgray = 0x505050FF
+std.color.yellow = 0xFDF900FF
+std.color.gold = 0xFFCB00FF
+std.color.orange = 0xFFA100FF
+std.color.pink = 0xFF6DC2FF
+std.color.red = 0xE62937FF
+std.color.maroon = 0xBE2137FF
+std.color.green = 0x00E430FF
+std.color.lime = 0x009E2FFF
+std.color.darkgreen = 0x00752CFF
+std.color.skyblue = 0x66BFFFFF
+std.color.blue = 0x0079F1FF
+std.color.darkblue = 0x0052ACFF
+std.color.purple = 0xC87AFFFF
+std.color.violet = 0x873CBEFF
+std.color.darkpurple = 0x701F7EFF
+std.color.beige = 0xD3B083FF
+std.color.brown = 0x7F6A4FFF
+std.color.darkbrown = 0x4C3F2FFF
+std.color.black = 0x000000FF
+std.color.blank = 0x00000000
+std.color.magenta = 0xFF00FFFF
 end
 local P = {
 install = install
@@ -1586,7 +1594,7 @@ install = install
 return P
 end
 --
-src_lib_object_std_55d74076e7c0 = function()
+src_lib_object_std_560c51e7d900 = function()
 local P = {
 milis = 0,
 delta = 0,
@@ -1609,6 +1617,10 @@ font_size = function() end,
 font_name = function() end,
 font_default = function() end
 },
+image = {
+load = function() end,
+draw = function() end
+},
 app = {
 width = 1280,
 height = 720,
@@ -1648,7 +1660,7 @@ any=false
 return P;
 end
 --
-src_lib_util_pipeline_55d7407bc4c0 = function()
+src_lib_util_pipeline_560c51e36e60 = function()
 local function pipe(self)
 return function()
 self:run()
@@ -1698,7 +1710,7 @@ run=run
 return P
 end
 --
-src_lib_util_decorator_55d7407a7e30 = function()
+src_lib_util_decorator_560c51e7fd40 = function()
 local function decorator_prefix3(zig, zag, zom, func)
 return function (a, b, c, d, e, f)
 return func(zig, zag, zom, a, b, c, d, e, f)
@@ -1737,18 +1749,26 @@ local y = object.offset_y + b
 return func(x, y, c, d, e, f)
 end
 end
+local function table_prefix1(prefix, fn_table)
+local new_table = {}
+for name, fn in pairs(fn_table) do
+new_table[name] = decorator_prefix1(prefix, fn)
+end
+return new_table
+end
 local P = {
 offset_xy1 = decorator_offset_xy1,
 offset_xy2 = decorator_offset_xy2,
 offset_xyxy1 = decorator_offset_xyxy1,
 prefix3 = decorator_prefix3,
 prefix2 = decorator_prefix2,
-prefix1 = decorator_prefix1
+prefix1 = decorator_prefix1,
+prefix1_t = table_prefix1
 }
 return P
 end
 --
-src_lib_util_http_55d74078aa00 = function()
+src_lib_util_http_560c51e3c4b0 = function()
 local function is_ok(status)
 return (status and 200 <= status and status < 300) or false
 end
@@ -1760,6 +1780,18 @@ end
 local function is_redirect(status)
 return (status and 300 <= status and status < 400) or false
 end
+local function get_content(response)
+local header, body = response:match("^(.-\r\n\r\n)(.*)")
+if not header or not body then return nil end
+local content_length = tonumber(header:match("Content%-Length:%s*(%d+)"))
+if not content_length then return nil end
+if #body < content_length then return nil end
+local content = body:sub(1, content_length)
+return content
+end
+local function get_user_agent()
+return 'Ginga (GlyOS;SmartTv/Linux)'
+end
 local function url_search_param(param_list, param_dict)
 local index, params = 1, ''
 while param_list and param_dict and index <= #param_list do
@@ -1770,7 +1802,7 @@ params = params..'?'
 else
 params = params..'&'
 end
-params = params..param..'='..(value or '')
+params = params..param:gsub(' ', '%20')..'='..(value or ''):gsub(' ', '%20')
 index = index + 1
 end
 return params
@@ -1829,7 +1861,7 @@ return self
 end
 self.to_http_protocol = function ()
 local index = 1
-local request = method..' '..uri..' HTTP/1.1\r\n'
+local request = method..' '..uri..' HTTP/1'..'.1\r\n'
 while index <= #self.header_list do
 local header = self.header_list[index]
 local value = self.header_dict[header]
@@ -1892,9 +1924,11 @@ return {
 is_ok=is_ok,
 is_ok_header=is_ok_header,
 is_redirect=is_redirect,
+get_content=get_content,
+get_user_agent=get_user_agent,
 url_search_param=url_search_param,
 create_request=create_request
 }
 end
 --
-return main_55d7407a19d0()
+return main_560c51e83670()

package/package.json

@@ -1,14 +1,16 @@
 {
     "name": "@gamely/gly-engine-lite",
-    "version": "0.0.19",
+    "version": "0.0.21",
     "author": "RodrigoDornelles",
     "license": "Apache-2.0",
     "homepage": "https://docs.gamely.com.br",
-    "repository": "https://github.com/gamelly/gly-engine",
+    "repository": "https://github.com/gly-engine/gly-engine",
     "funding": "https://github.com/sponsors/RodrigoDornelles",
-    "bugs": "https://github.com/gamelly/gly-engine/issues",
+    "bugs": "https://github.com/gly-engine/gly-engine/issues",
     "description": "Game Engine written in 100% lua that runs in a vacuum.",
     "main": "dist/main.lua",
+    "browser": "dist/main.lua",
+    "types": "types/main.d.ts",
     "keywords": [
         "game engine",
         "game",

package/types/main.d.ts

@@ -0,0 +1,4 @@
+declare module '@gamely/gly-engine-lite' {
+ const content: string;
+ export default content;
+}