@gamely/gly-engine-lite 0.0.18 → 0.0.19

package/dist/main.lua

@@ -1,43 +1,48 @@
 local math = ((function() local x, y = pcall(require, 'math'); return x and y end)()) or _G.math
-local src_version_561fa16ca630 = nil
-local src_lib_common_module_561fa16cab70 = nil
-local src_lib_engine_api_encoder_561fa16cb2c0 = nil
-local src_lib_engine_api_app_561fa16cff00 = nil
-local src_lib_engine_api_hash_561fa16d0530 = nil
-local src_lib_engine_api_http_561fa16d0b50 = nil
-local src_lib_engine_api_i18n_561fa16d10f0 = nil
-local src_lib_engine_api_key_561fa16d1700 = nil
-local src_lib_engine_api_math_561fa16c5900 = nil
-local src_lib_engine_api_array_561fa16c1450 = nil
-local src_lib_engine_api_media_561fa16cce10 = nil
-local src_lib_engine_draw_fps_561fa16c6900 = nil
-local src_lib_engine_draw_text_561fa16c8d50 = nil
-local src_lib_engine_draw_poly_561fa16ca270 = nil
-local src_lib_engine_raw_memory_561fa16caab0 = nil
-local src_lib_object_root_561fa16cb030 = nil
-local src_lib_object_color_561fa16d0260 = nil
-local src_lib_object_std_561fa16c9dc0 = nil
-local src_lib_util_pipeline_561fa16c26b0 = nil
-local src_lib_util_decorator_561fa16bfce0 = nil
-local function main_561fa16ca3f0()
-local version = src_version_561fa16ca630()
-local zeebo_module = src_lib_common_module_561fa16cab70()
-local engine_encoder = src_lib_engine_api_encoder_561fa16cb2c0()
-local engine_game = src_lib_engine_api_app_561fa16cff00()
-local engine_hash = src_lib_engine_api_hash_561fa16d0530()
-local engine_http = src_lib_engine_api_http_561fa16d0b50()
-local engine_i18n = src_lib_engine_api_i18n_561fa16d10f0()
-local engine_key = src_lib_engine_api_key_561fa16d1700()
-local engine_math = src_lib_engine_api_math_561fa16c5900()
-local engine_array = src_lib_engine_api_array_561fa16c1450()
-local engine_media = src_lib_engine_api_media_561fa16cce10()
-local engine_draw_fps = src_lib_engine_draw_fps_561fa16c6900()
-local engine_draw_text = src_lib_engine_draw_text_561fa16c8d50()
-local engine_draw_poly = src_lib_engine_draw_poly_561fa16ca270()
-local engine_raw_memory = src_lib_engine_raw_memory_561fa16caab0()
-local application_default = src_lib_object_root_561fa16cb030()
-local color = src_lib_object_color_561fa16d0260()
-local std = src_lib_object_std_561fa16c9dc0()
+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 application = application_default
 local engine = {
 keyboard = function(a, b, c, d) end,
@@ -53,6 +58,7 @@ get_secret = native_system_get_secret,
 get_language = native_system_get_language
 }
 local cfg_media = {
+bootstrap=native_media_bootstrap,
 position=native_media_position,
 resize=native_media_resize,
 pause=native_media_pause,
@@ -74,8 +80,18 @@ local cfg_text = {
 font_previous = native_text_font_previous
 }
 local cfg_http = {
-ssl = native_http_has_ssl,
-handler = native_http_handler
+install = native_http_install,
+handler = native_http_handler,
+has_ssl = native_http_has_ssl,
+has_callback = native_http_has_callback,
+force = native_http_force_protocol
+}
+local cfg_log = {
+fatal = native_log_fatal,
+error = native_log_error,
+warn = native_log_warn,
+info = native_log_info,
+debug = native_log_debug
 }
 local cfg_base64 = {
 decode = native_base64_decode,
@@ -108,6 +124,12 @@ end
 function native_callback_keyboard(key, value)
 engine.keyboard(std, engine, key, value)
 end
+function native_callback_http(id, key, data)
+if cfg_http.has_callback then
+return callback_http.func(engine['http_requests'][id], key, data)
+end
+return nil
+end
 function native_callback_init(width, height, game_lua)
 application = zeebo_module.loadgame(game_lua)
 if application then
@@ -146,6 +168,7 @@ zeebo_module.require(std, application, engine)
 :package('@draw.text', engine_draw_text, cfg_text)
 :package('@draw.poly', engine_draw_poly, cfg_poly)
 :package('@color', color)
+:package('@log', engine_log, cfg_log)
 :package('math', engine_math.clib)
 :package('math.random', engine_math.clib_random)
 :package('http', engine_http, cfg_http)
@@ -154,7 +177,10 @@ zeebo_module.require(std, application, engine)
 :package('xml', engine_encoder, cfg_xml)
 :package('i18n', engine_i18n, cfg_system)
 :package('hash', engine_hash, cfg_system)
-:package('media', engine_media, cfg_media)
+: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()
 application.data.width, std.app.width = width, width
 application.data.height, std.app.height = height, height
@@ -172,13 +198,13 @@ version=version
 }
 return P
 end
-src_version_561fa16ca630 = function()
-return '0.0.18'
+src_version_55d740741220 = function()
+return '0.0.19'
 end
 --
-src_lib_common_module_561fa16cab70 = function()
-local zeebo_pipeline = src_lib_util_pipeline_561fa16c26b0()
-local application_default = src_lib_object_root_561fa16cb030()
+src_lib_common_module_55d74078d4c0 = function()
+local zeebo_pipeline = src_lib_util_pipeline_55d7407bc4c0()
+local application_default = src_lib_object_root_55d7407b5bb0()
 local function default(application, defaults)
 if not application then return nil end
 local index = 1    
@@ -376,7 +402,7 @@ require = require
 return P
 end
 --
-src_lib_engine_api_encoder_561fa16cb2c0 = function()
+src_lib_engine_api_encoder_55d740797c20 = function()
 local function install(std, engine, library, name)
 std = std or {}
 std[name] = {
@@ -391,8 +417,8 @@ install=install
 return P
 end
 --
-src_lib_engine_api_app_561fa16cff00 = function()
-local util_decorator = src_lib_util_decorator_561fa16bfce0()
+src_lib_engine_api_app_55d7407cdb00 = function()
+local util_decorator = src_lib_util_decorator_55d7407a7e30()
 local function reset(std, engine)
 if std.node then
 std.bus.emit('exit')
@@ -432,7 +458,7 @@ install=install
 return P
 end
 --
-src_lib_engine_api_hash_561fa16d0530 = function()
+src_lib_engine_api_hash_55d740798450 = function()
 local function djb2(digest)
 local index = 1
 local hash = 5381
@@ -458,8 +484,8 @@ install = install
 return P
 end
 --
-src_lib_engine_api_http_561fa16d0b50 = function()
-local zeebo_pipeline = src_lib_util_pipeline_561fa16c26b0()
+src_lib_engine_api_http_55d74079e880 = function()
+local zeebo_pipeline = src_lib_util_pipeline_55d7407bc4c0()
 local function fast(self)
 self.speed = '_fast'
 return self
@@ -492,13 +518,24 @@ local function http_error(self, handler_func)
 self.error_handler = handler_func
 return self
 end
-local function request(method, std, engine, protocol_handler)
+local function request(method, std, engine, protocol)
 local callback_handler = function()
+if std.node then
 std.node.emit(engine.current, 'http')
+elseif engine.current.callbacks.http then
+engine.current.callbacks.http(std, engine.current.data)
+end
 end
 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 game = engine.current.data
 local self = {
+id = engine.http_count,
 url = url,
 speed = '',
 method = method,
@@ -507,12 +544,9 @@ header_list = {},
 header_dict = {},
 param_list = {},
 param_dict = {},
-callback_handler = callback_handler,
 success_handler = function (std, game) end,
 failed_handler = function (std, game) end,
 error_handler = function (std, game) end,
-std = std,
-game = game,
 fast = fast,
 body = body,
 param = param,
@@ -521,7 +555,6 @@ success = success,
 failed = failed,
 error = http_error,
 run = zeebo_pipeline.run,
-protocol_handler = protocol_handler
 }
 self.promise = function()
 zeebo_pipeline.stop(self)
@@ -530,29 +563,31 @@ self.resolve = function()
 zeebo_pipeline.resume(self)
 end
 self.set = function (key, value)
-self.std.http[key] = value
+std.http[key] = value
 end
 self.pipeline = {
 function()
-self:protocol_handler()
+if protocol.has_callback then engine.http_requests[self.id] = self end
+protocol.handler(self, self.id)
 end,
 function()
-self.callback_handler(self.std, self.game)
-if self.std.http.ok then
-self.success_handler(self.std, self.game)
-elseif self.std.http.error or not self.std.http.status then
-self.error_handler(self.std, self.game)
+callback_handler(std, game)
+if std.http.ok then
+self.success_handler(std, game)
+elseif std.http.error or not std.http.status then
+self.error_handler(std, game)
 else
-self.failed_handler(self.std, self.game)
+self.failed_handler(std, game)
 end
 end,
 function ()
-self.std.http.ok = nil
-self.std.http.body = nil
-self.std.http.error = nil
-self.std.http.status = nil
+std.http.ok = nil
+std.http.body = nil
+std.http.error = nil
+std.http.status = nil
 end,
 function()
+if protocol.has_callback then engine.http_requests[self.id] = nil end
 zeebo_pipeline.reset(self)
 end
 }
@@ -560,23 +595,21 @@ return self
 end
 end
 local function install(std, engine, protocol)
-local protocol_handler = protocol and protocol.handler
-if not protocol_handler then
-error('missing protocol handler')
+assert(protocol.handler, 'missing protocol handler')
+if protocol.has_callback then
+engine.http_count = 0
+engine.http_requests = {}
 end
 std.http = std.http or {}
-std.http.get=request('GET', std, engine, protocol_handler)
-std.http.head=request('HEAD', std, engine, protocol_handler)
-std.http.post=request('POST', std, engine, protocol_handler)
-std.http.put=request('PUT', std, engine, protocol_handler)
-std.http.delete=request('DELETE', std, engine, protocol_handler)
-std.http.patch=request('PATCH', std, engine, protocol_handler)
+std.http.get=request('GET', std, engine, protocol)
+std.http.head=request('HEAD', std, engine, protocol)
+std.http.post=request('POST', std, engine, protocol)
+std.http.put=request('PUT', std, engine, protocol)
+std.http.delete=request('DELETE', std, engine, protocol)
+std.http.patch=request('PATCH', std, engine, protocol)
 if protocol.install then
 protocol.install(std, engine)
 end
-return {
-std={http=std.http}
-}
 end
 local P = {
 install=install
@@ -584,7 +617,7 @@ install=install
 return P
 end
 --
-src_lib_engine_api_i18n_561fa16d10f0 = function()
+src_lib_engine_api_i18n_55d74075aa10 = function()
 local language = 'en-US'
 local language_default = 'en-US'
 local language_list = {}
@@ -676,7 +709,7 @@ install=install
 return P
 end
 --
-src_lib_engine_api_key_561fa16d1700 = function()
+src_lib_engine_api_key_55d7407bfbd0 = 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)
@@ -691,6 +724,8 @@ std.key.axis.y = std.key.axis.down - std.key.axis.up
 end
 std.bus.emit('key')
 end
+local a = std.key.axis
+std.key.press.any = (a.left + a.right + a.down + a.up + a.a + a.b + a.c + a.d + a.menu) > 0
 end
 local function real_keydown(std, engine, key)
 real_key(std, engine, key, 1)
@@ -714,7 +749,54 @@ install = install
 return P
 end
 --
-src_lib_engine_api_math_561fa16c5900 = function()
+src_lib_engine_api_log_55d7407a7ec0 = function()
+local util_decorator = src_lib_util_decorator_55d7407a7e30()
+local logging_types = {
+'none', 'fatal', 'error', 'warn', 'debug', 'info'
+}
+local function level(engine, lpf, lpn, level)
+local l = lpf[level] or lpn[level] or level
+if type(l) ~= 'number' or l <= 0 or l > #logging_types then
+error('logging level not exist: '..tostring(level)) 
+end
+engine.loglevel = l
+end
+local function init(std, engine, printers)
+local index = 1
+local level_per_func = {}
+local level_per_name = {}
+while index <= #logging_types do
+local ltype = logging_types[index]
+local lfunc = function() end
+if index > 1 and printers[ltype] then
+lfunc = (function (level)
+return function(message)
+if engine.loglevel >= level then
+printers[ltype](message)
+end
+end
+end)(index - 1)
+end
+level_per_func[lfunc] = index - 1
+level_per_name[ltype] = index - 1
+std.log[ltype] = lfunc
+index = index + 1
+end
+std.log.level = util_decorator.prefix3(engine, level_per_func, level_per_name, level)
+end
+local function install(std, engine, printers)
+std.log = std.log or {}
+engine.loglevel = #logging_types
+std.log.init = util_decorator.prefix2(std, engine, init)
+std.log.init(printers)
+end
+local P = {
+install = install
+}
+return P
+end
+--
+src_lib_engine_api_math_55d740799d40 = function()
 local function abs(value)
 if value < 0 then
 return -value
@@ -861,8 +943,8 @@ install = install_clib_random
 return P;
 end
 --
-src_lib_engine_api_array_561fa16c1450 = function()
-local util_decorator = src_lib_util_decorator_561fa16bfce0()
+src_lib_engine_api_array_55d740779000 = function()
+local util_decorator = src_lib_util_decorator_55d7407a7e30()
 local function array_map(array, func)
 local res = {}
 local index = 1
@@ -1004,6 +1086,7 @@ return self
 end
 local function install(std, engine, library, name)
 local lib = std[name] or {}
+lib.map = array_map
 lib.filter = array_filter
 lib.unique = array_unique
 lib.each = array_foreach
@@ -1022,43 +1105,43 @@ install = install
 return P
 end
 --
-src_lib_engine_api_media_561fa16cce10 = function()
-local util_decorator = src_lib_util_decorator_561fa16bfce0()
-local function media_add(func, self, src)
-func(self.id - 1, src)
+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(func, self)
-func(self.id - 1)
+local function media_play(media, func, self)
+func(media - 1, self.id - 1)
 return self
 end
-local function media_pause(func, self)
-func(self.id - 1)
+local function media_pause(media, func, self)
+func(media - 1, self.id - 1)
 return self
 end
-local function media_resize(func, self, width, height)
-func(self.id - 1, width, height)
+local function media_resize(media, func, self, width, height)
+func(media - 1, self.id - 1, width, height)
 return self
 end
-local function media_position(func, self, pos_x, pos_y)
-func(self.id - 1, pos_x, pos_y)
+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 channels = {}
-local function media_channel(std, handler)
+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 > 8 then
+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.prefix1(handler.load, media_add),
-play = util_decorator.prefix1(handler.play, media_play),
-pause = util_decorator.prefix1(handler.pause, media_pause),
-resize = util_decorator.prefix1(handler.resize, media_resize),
-position = util_decorator.prefix1(handler.position, media_position)
+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)
 }
 if std.node then
 channels[id].node = std.node.load({})
@@ -1081,9 +1164,19 @@ end
 return channels[id]
 end
 end
-local function install(std, engine, handlers)
+local function install(std, engine, handlers, name)
+handlers = handlers or {}
 std.media = std.media or {}
-std.media.video = media_channel(std, handlers)
+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 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)
+end
 end
 local P = {
 install=install
@@ -1091,7 +1184,7 @@ install=install
 return P
 end
 --
-src_lib_engine_draw_fps_561fa16c6900 = function()
+src_lib_engine_draw_fps_55d740798890 = 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
@@ -1143,8 +1236,8 @@ install=install
 return P
 end
 --
-src_lib_engine_draw_text_561fa16c8d50 = function()
-local util_decorator = src_lib_util_decorator_561fa16bfce0()
+src_lib_engine_draw_text_55d7407c8b90 = function()
+local util_decorator = src_lib_util_decorator_55d7407a7e30()
 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
@@ -1171,7 +1264,7 @@ install=install
 return P
 end
 --
-src_lib_engine_draw_poly_561fa16ca270 = function()
+src_lib_engine_draw_poly_55d740799b40 = function()
 local function decorator_poo(object, func)
 if not object or not func then return func end
 return function(a, b, c, d)
@@ -1278,21 +1371,25 @@ install=install
 return P
 end
 --
-src_lib_engine_raw_memory_561fa16caab0 = function()
+src_lib_engine_raw_memory_55d74079abd0 = function()
 local memory_dict_unload = {}
 local memory_dict = {}
 local memory_list = {}
-local function cache(key, load_func, unload_func)
-if memory_dict[key] then
+local function cache_get(key)
 return memory_dict[key]
 end
-if not load_func then
-return nil
-end
+local function cache_set(key, load_func, unload_func)
 local value = load_func()
 memory_list[#memory_list + 1] = key
 memory_dict_unload[key] = unload_func
 memory_dict[key] = value
+end
+local function cache(key, load_func, unload_func)
+local value = cache_get(key)
+if value == nil then
+cache_set(key, load_func, unload_func)
+value = cache_get(key)
+end    
 return value
 end
 local function unset(key)
@@ -1315,6 +1412,8 @@ local function install(std)
 std = std or {}
 std.mem = std.mem or {}
 std.mem.cache = cache
+std.mem.cache_get = cache_get
+std.mem.cache_set = cache_set
 std.mem.unset = unset
 std.mem.gc_clear_all = gc_clear_all
 return {
@@ -1327,7 +1426,75 @@ install=install
 return P
 end
 --
-src_lib_object_root_561fa16cb030 = function()
+src_lib_protocol_http_callback_55d74079bca0 = function()
+local http_util = src_lib_util_http_55d74078aa00()
+local callbacks = {
+['async-promise'] = function(self)
+return self:promise()
+end,
+['async-resolve'] = function(self)
+return self:resolve()
+end,
+['get-url'] = function(self)
+return self.url
+end,
+['get-fullurl'] = function(self)
+return self.url..http_util.url_search_param(self.param_list, self.param_dict)
+end,
+['get-method'] = function(self)
+return self.method
+end,
+['get-body'] = function(self)
+return self.body_content
+end,
+['get-param-count'] = function(self)
+return #self.param_list
+end,
+['get-param-name'] = function(self, data)
+return self.param_list[self.data]
+end,
+['get-param-data'] = function(self, data)
+return self.param_dict[self.data] or self.param_dict[self.param_list[self.data]]
+end,
+['get-header-count'] = function(self)
+return #self.header_list
+end,
+['get-header-name'] = function(self, data)
+return self.header_list[self.data]
+end,
+['get-header-data'] = function(self, data)
+return self.heeader_dict[self.data] or self.heeader_dict[self.header_list[self.data]]
+end,
+['set-status'] = function(self, data)
+self.set('status', data)
+self.set('ok', http_util.is_ok(data))
+end,
+['set-error'] = function(self, data)
+self.set('error', data)
+end,
+['set-ok'] = function(self, data)
+self.set('ok', data)
+end,
+['set-body'] = function(self, data)
+self.set('body', data)
+end,
+['add-body-data'] = function(self, data, std)
+self.set('body', (std.http.body or '')..data)
+end    
+}
+local function native_http_callback(self, evt, data, std)
+if not callbacks[evt] then
+error('http evt '..evt..' not exist!')
+end
+return callbacks[evt](self, data, std)
+end
+local P = {
+func = native_http_callback
+}
+return P
+end
+--
+src_lib_object_root_55d7407b5bb0 = function()
 local P = {
 data={
 width=1280,
@@ -1357,7 +1524,7 @@ callbacks={
 return P;
 end
 --
-src_lib_object_color_561fa16d0260 = function()
+src_lib_object_color_55d7407a8380 = function()
 local white = 0xFFFFFFFF
 local lightgray = 0xC8CCCCFF
 local gray = 0x828282FF
@@ -1419,7 +1586,7 @@ install = install
 return P
 end
 --
-src_lib_object_std_561fa16c9dc0 = function()
+src_lib_object_std_55d74076e7c0 = function()
 local P = {
 milis = 0,
 delta = 0,
@@ -1473,14 +1640,15 @@ right=false,
 a=false,
 b=false,
 c=false,
-d=false
+d=false,
+any=false
 }
 }
 }
 return P;
 end
 --
-src_lib_util_pipeline_561fa16c26b0 = function()
+src_lib_util_pipeline_55d7407bc4c0 = function()
 local function pipe(self)
 return function()
 self:run()
@@ -1530,7 +1698,7 @@ run=run
 return P
 end
 --
-src_lib_util_decorator_561fa16bfce0 = function()
+src_lib_util_decorator_55d7407a7e30 = 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)
@@ -1580,4 +1748,153 @@ prefix1 = decorator_prefix1
 return P
 end
 --
-return main_561fa16ca3f0()
+src_lib_util_http_55d74078aa00 = function()
+local function is_ok(status)
+return (status and 200 <= status and status < 300) or false
+end
+local function is_ok_header(header)
+local status = tonumber(header:match('HTTP/%d.%d (%d%d%d)'))
+local ok = status and is_ok(status) or false
+return ok, status
+end
+local function is_redirect(status)
+return (status and 300 <= status and status < 400) or false
+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
+local param = param_list[index]
+local value = param_dict[param]
+if #params == 0 then
+params = params..'?'
+else
+params = params..'&'
+end
+params = params..param..'='..(value or '')
+index = index + 1
+end
+return params
+end
+local function create_request(method, uri)
+local self = {
+body_content = '',
+header_list = {},
+header_dict = {},
+header_imutable = {},
+print_http_status = true
+}
+self.add_body_content = function (body)
+self.body_content = self.body_content..(body or '')
+return self
+end
+self.add_imutable_header = function (header, value, cond)
+if cond == false then return self end
+if self.header_imutable[header] == nil then
+self.header_list[#self.header_list + 1] = header
+self.header_dict[header] = value
+elseif self.header_imutable[header] == false then
+self.header_dict[header] = value
+end
+self.header_imutable[header] = true
+return self
+end
+self.add_mutable_header = function (header, value, cond)
+if cond == false then return self end
+if self.header_imutable[header] == nil then
+self.header_list[#self.header_list + 1] = header
+self.header_imutable[header] = false
+self.header_dict[header] = value
+end
+return self
+end
+self.add_custom_headers = function(header_list, header_dict)
+local index = 1
+while header_list and #header_list >= index do
+local header = header_list[index]
+local value = header_dict[header]
+if self.header_imutable[header] == nil then
+self.header_list[#self.header_list + 1] = header
+self.header_imutable[header] = false
+self.header_dict[header] = value
+elseif self.header_imutable[header] == false then
+self.header_dict[header] = value
+end
+index = index + 1
+end
+return self
+end
+self.not_status = function()
+self.print_http_status = false
+return self
+end
+self.to_http_protocol = function ()
+local index = 1
+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]
+request = request..header..': '..value..'\r\n'
+index = index + 1
+end
+request = request..'\r\n'
+if method ~= 'GET' and method ~= 'HEAD' and #self.body_content > 0 then
+request = request..self.body_content..'\r\n\r\n'
+end
+return request, function() end
+end
+self.to_curl_cmd = function ()
+local index = 1
+local request = 'curl -L -'..'-silent -'..'-insecure '
+if self.print_http_status then
+request = request..'-w "\n%{http_code}" '
+end
+if method == 'HEAD' then
+request = request..'-'..'-HEAD '
+else
+request = request..'-X '..method..' '
+end
+while index <= #self.header_list do
+local header = self.header_list[index]
+local value = self.header_dict[header]
+request = request..'-H "'..header..': '..value..'" '
+index = index + 1
+end
+if method ~= 'GET' and method ~= 'HEAD' and #self.body_content > 0 then
+request = request..'-d \''..self.body_content..'\' '
+end
+request = request..uri
+return request, function() end
+end
+self.to_wget_cmd = function ()
+local request = 'wget -'..'-quiet -'..'-output-document=-'
+if method == 'HEAD' then
+request = request..' -'..'-method=HEAD'
+elseif method ~= 'GET' then
+request = request..' -'..'-method='..method
+end
+for index, header in ipairs(self.header_list) do
+local value = self.header_dict[header]
+if value then
+local escaped_value = value:gsub('"', '\\"')
+request = request..' -'..'-header="'..header..': '..escaped_value..'"'
+end
+end
+if method ~= 'GET' and method ~= 'HEAD' and #self.body_content > 0 then
+local escaped_body = self.body_content:gsub('"', '\\"')
+request = request..' -'..'-body-data="'..escaped_body..'"'
+end
+request = request..' '..uri
+return request, function() end
+end
+return self
+end
+return {
+is_ok=is_ok,
+is_ok_header=is_ok_header,
+is_redirect=is_redirect,
+url_search_param=url_search_param,
+create_request=create_request
+}
+end
+--
+return main_55d7407a19d0()

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gamely/gly-engine-lite",
-    "version": "0.0.18",
+    "version": "0.0.19",
     "author": "RodrigoDornelles",
     "license": "Apache-2.0",
     "homepage": "https://docs.gamely.com.br",
@@ -8,7 +8,7 @@
     "funding": "https://github.com/sponsors/RodrigoDornelles",
     "bugs": "https://github.com/gamelly/gly-engine/issues",
     "description": "Game Engine written in 100% lua that runs in a vacuum.",
-    "main": "dist/index.lua",
+    "main": "dist/main.lua",
     "keywords": [
         "game engine",
         "game",