@gamely/gly-engine-lite 0.0.16 → 0.0.18

package/dist/main.lua

@@ -1,48 +1,94 @@
 local math = ((function() local x, y = pcall(require, 'math'); return x and y end)()) or _G.math
-local core_src_version = nil
-local core_src_lib_common_module = nil
-local core_src_lib_engine_api_encoder = nil
-local core_src_lib_engine_api_app = nil
-local core_src_lib_engine_api_hash = nil
-local core_src_lib_engine_api_http = nil
-local core_src_lib_engine_api_i18n = nil
-local core_src_lib_engine_api_key = nil
-local core_src_lib_engine_api_math = nil
-local core_src_lib_engine_draw_fps = nil
-local core_src_lib_engine_draw_text = nil
-local core_src_lib_engine_draw_poly = nil
-local core_src_lib_engine_raw_memory = nil
-local core_src_lib_object_root = nil
-local core_src_lib_object_color = nil
-local core_src_lib_object_std = nil
-local core_src_lib_util_pipeline = nil
-local core_src_lib_util_decorator = nil
-local function main()
-local version = core_src_version()
-local zeebo_module = core_src_lib_common_module()
-local engine_encoder = core_src_lib_engine_api_encoder()
-local engine_game = core_src_lib_engine_api_app()
-local engine_hash = core_src_lib_engine_api_hash()
-local engine_http = core_src_lib_engine_api_http()
-local engine_i18n = core_src_lib_engine_api_i18n()
-local engine_key = core_src_lib_engine_api_key()
-local engine_math = core_src_lib_engine_api_math()
-local engine_draw_fps = core_src_lib_engine_draw_fps()
-local engine_draw_text = core_src_lib_engine_draw_text()
-local engine_draw_poly = core_src_lib_engine_draw_poly()
-local engine_raw_memory = core_src_lib_engine_raw_memory()
-local application_default = core_src_lib_object_root()
-local color = core_src_lib_object_color()
-local std = core_src_lib_object_std()
+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 application = application_default
 local engine = {
 keyboard = function(a, b, c, d) end,
 current = application_default,
 root = application_default
 }
+local cfg_system = {
+exit = native_system_exit,
+reset = native_system_reset,
+title = native_system_title,
+get_fps = native_system_get_fps,
+get_secret = native_system_get_secret,
+get_language = native_system_get_language
+}
+local cfg_media = {
+position=native_media_position,
+resize=native_media_resize,
+pause=native_media_pause,
+load=native_media_load,
+play=native_media_play
+}
+local cfg_poly = {
+repeats = {
+native_cfg_poly_repeat_0 or false,
+native_cfg_poly_repeat_1 or false,
+native_cfg_poly_repeat_2 or false
+},
+triangle = native_draw_triangle,
+poly2 = native_draw_poly2,
+poly = native_draw_poly,
+line = native_draw_line
+}
 local cfg_text = {
 font_previous = native_text_font_previous
 }
+local cfg_http = {
+ssl = native_http_has_ssl,
+handler = native_http_handler
+}
+local cfg_base64 = {
+decode = native_base64_decode,
+encode = native_base64_encode
+}
+local cfg_json = {
+decode = native_json_decode,
+encode = native_json_encode
+}
+local cfg_xml = {
+decode = native_xml_decode,
+encode = native_xml_encode
+}
 function native_callback_loop(dt)
 std.milis = std.milis + dt
 std.delta = dt
@@ -89,27 +135,30 @@ std.text.font_default=native_text_font_default
 std.draw.clear=function(tint)
 native_draw_clear(tint, 0, 0, application.data.width, application.data.height)
 end
+engine.root = application
 zeebo_module.require(std, application, engine)
 :package('@memory', engine_raw_memory)
-:package('@game', engine_game, native_dict_game)
+:package('@game', engine_game, cfg_system)
 :package('@math', engine_math)
+:package('@array', engine_array)
 :package('@key', engine_key, {})
 :package('@draw.fps', engine_draw_fps)
 :package('@draw.text', engine_draw_text, cfg_text)
-:package('@draw.poly', engine_draw_poly, native_dict_poly)
+:package('@draw.poly', engine_draw_poly, cfg_poly)
 :package('@color', color)
 :package('math', engine_math.clib)
 :package('math.random', engine_math.clib_random)
-:package('http', engine_http, native_dict_http)
-:package('json', engine_encoder, native_dict_json)
-:package('xml', engine_encoder, native_dict_xml)
-:package('i18n', engine_i18n, native_get_system_lang)
-:package('hash', engine_hash, native_dict_secret)
+:package('http', engine_http, cfg_http)
+:package('base64', engine_encoder, cfg_base64)
+:package('json', engine_encoder, cfg_json)
+:package('xml', engine_encoder, cfg_xml)
+:package('i18n', engine_i18n, cfg_system)
+:package('hash', engine_hash, cfg_system)
+:package('media', engine_media, cfg_media)
 :run()
 application.data.width, std.app.width = width, width
 application.data.height, std.app.height = height, height
 std.app.title(application.meta.title..' - '..application.meta.version)
-engine.root = application
 engine.current = application
 application.callbacks.init(std, application.data)
 end
@@ -123,13 +172,13 @@ version=version
 }
 return P
 end
-core_src_version = function()
-return '0.0.16'
+src_version_561fa16ca630 = function()
+return '0.0.18'
 end
 --
-core_src_lib_common_module = function()
-local zeebo_pipeline = core_src_lib_util_pipeline()
-local application_default = core_src_lib_object_root()
+src_lib_common_module_561fa16cab70 = function()
+local zeebo_pipeline = src_lib_util_pipeline_561fa16c26b0()
+local application_default = src_lib_object_root_561fa16cb030()
 local function default(application, defaults)
 if not application then return nil end
 local index = 1    
@@ -243,9 +292,9 @@ if not system and not self.lib_required[name] then return end
 if not system and self.engine.lib_installed[name] then return end
 if system and self.engine.stdlib_installed[name] then return end
 local try_install = function()
-module.install(self.std, self.engine, custom, module_name)
+module.install(self.std, self.engine, custom, name)
 if module.event_bus then
-module.event_bus(self.std, self.engine, custom, module_name)
+module.event_bus(self.std, self.engine, custom, name)
 end
 end
 local ok, msg = pcall(try_install)
@@ -327,7 +376,7 @@ require = require
 return P
 end
 --
-core_src_lib_engine_api_encoder = function()
+src_lib_engine_api_encoder_561fa16cb2c0 = function()
 local function install(std, engine, library, name)
 std = std or {}
 std[name] = {
@@ -342,8 +391,8 @@ install=install
 return P
 end
 --
-core_src_lib_engine_api_app = function()
-local util_decorator = core_src_lib_util_decorator()
+src_lib_engine_api_app_561fa16cff00 = function()
+local util_decorator = src_lib_util_decorator_561fa16bfce0()
 local function reset(std, engine)
 if std.node then
 std.bus.emit('exit')
@@ -374,7 +423,7 @@ end)
 std.app.title = util_decorator.prefix1(config.set_title, title)
 std.app.exit = util_decorator.prefix1(std, exit)
 std.app.reset = util_decorator.prefix2(std, engine, reset)
-std.app.get_fps = config.fps
+std.app.get_fps = config.get_fps
 return std.app
 end
 local P = {
@@ -383,7 +432,7 @@ install=install
 return P
 end
 --
-core_src_lib_engine_api_hash = function()
+src_lib_engine_api_hash_561fa16d0530 = function()
 local function djb2(digest)
 local index = 1
 local hash = 5381
@@ -396,27 +445,12 @@ hash = string.format('%08x', hash)
 hash = tonumber(hash:sub(#hash - 7), 16)
 return hash
 end
-local function fingerprint(all_your_secrets)
-local index = 1
-local digest = ''
-while index <= #all_your_secrets do
-local value = all_your_secrets[index]
-if type(value) == 'function' then
-digest = digest..tostring(value())
-else
-digest = digest..tostring(value)
-end
-index = index + 1
-end
-return djb2(digest)
-end
-local function install(std, engine, all_your_secrets)
-local id = fingerprint(all_your_secrets or {'not secret!'})
+local function install(std, engine, cfg_system)
+local id = djb2(cfg_system.get_secret())
 std = std or {}
 std.hash = std.hash or {}
 std.hash.djb2 = djb2
 std.hash.fingerprint = function() return id end
-return {hash=std.hash}
 end
 local P = {
 install = install
@@ -424,8 +458,8 @@ install = install
 return P
 end
 --
-core_src_lib_engine_api_http = function()
-local zeebo_pipeline = core_src_lib_util_pipeline()
+src_lib_engine_api_http_561fa16d0b50 = function()
+local zeebo_pipeline = src_lib_util_pipeline_561fa16c26b0()
 local function fast(self)
 self.speed = '_fast'
 return self
@@ -454,7 +488,7 @@ local function failed(self, handler_func)
 self.failed_handler = handler_func
 return self
 end
-local function error(self, handler_func)
+local function http_error(self, handler_func)
 self.error_handler = handler_func
 return self
 end
@@ -485,7 +519,7 @@ param = param,
 header = header,
 success = success,
 failed = failed,
-error = error,
+error = http_error,
 run = zeebo_pipeline.run,
 protocol_handler = protocol_handler
 }
@@ -526,7 +560,10 @@ return self
 end
 end
 local function install(std, engine, protocol)
-local protocol_handler = protocol.handler
+local protocol_handler = protocol and protocol.handler
+if not protocol_handler then
+error('missing protocol handler')
+end
 std.http = std.http or {}
 std.http.get=request('GET', std, engine, protocol_handler)
 std.http.head=request('HEAD', std, engine, protocol_handler)
@@ -547,7 +584,7 @@ install=install
 return P
 end
 --
-core_src_lib_engine_api_i18n = function()
+src_lib_engine_api_i18n_561fa16d10f0 = function()
 local language = 'en-US'
 local language_default = 'en-US'
 local language_list = {}
@@ -604,21 +641,24 @@ return function (x, y, text, a, b, c)
 return func(x, y, get_text(text), a, b, c)
 end
 end
-local function event_bus(std, engine)
-std.bus.listen('ret_i18n', function(result)
-update_languages(result)
-end)
-std.bus.emit_next('i18n')
-end
-local function install(std, engine, system_language)
+local function install(std, engine, cfg)
 if not (std and std.text and std.text.print) then
 error('missing draw text')
 end
 local old_put = std.text.put
 local old_print = std.text.print
 local old_print_ex = std.text.print_ex
-if system_language then
-set_language(system_language())
+local callback_lang = function(result)
+update_languages(result)
+if cfg and cfg.get_language then
+set_language(cfg.get_language())
+end
+end
+if not std.node and engine.root.callbacks.i18n then
+callback_lang(engine.root.callbacks.i18n())
+else
+std.bus.listen('ret_i18n', callback_lang)
+std.bus.emit_next('i18n')
 end
 std.text.put = decorator_draw_text(old_put)
 std.text.print = decorator_draw_text(old_print)
@@ -629,23 +669,14 @@ std.i18n.get_language = get_language
 std.i18n.set_language = set_language
 std.i18n.back = back_language
 std.i18n.next = next_language
-return {
-std={
-i18n=std.i18n,
-draw={
-text=std.draw.text
-}
-}
-}
 end
 local P = {
-event_bus=event_bus,
 install=install
 }
 return P
 end
 --
-core_src_lib_engine_api_key = function()
+src_lib_engine_api_key_561fa16d1700 = 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)
@@ -683,7 +714,7 @@ install = install
 return P
 end
 --
-core_src_lib_engine_api_math = function()
+src_lib_engine_api_math_561fa16c5900 = function()
 local function abs(value)
 if value < 0 then
 return -value
@@ -702,10 +733,6 @@ end
 local function clamp2(value, value_min, value_max)
 return (value - value_min) % (value_max - value_min + 1) + value_min
 end
-local function cycle(passed, duration)
-local endtime = (passed) % duration
-return ((endtime == 0 and (passed % (duration * 2)) or endtime)) / duration
-end
 local function dir(value, alpha)
 alpha = alpha or 0
 if value < -alpha then
@@ -717,11 +744,15 @@ return 0
 end
 end
 local function dis(x1,y1,x2,y2)
-return ((x2 - x1) ^ 2 + (y2 - y1) ^ 2) ^ 0.5
+local sqr = 1/2
+return ((x2 - x1) ^ 2 + (y2 - y1) ^ 2) ^ (sqr ~= 0 and sqr or 1)
 end
 local function dis2(x1,y1,x2,y2)
 return (x2 - x1) ^ 2 + (y2 - y1) ^ 2
 end
+local function dis3(x1,y1,x2,y2)
+return abs(x1 - x2) + abs(x2 - y2)
+end
 local function lerp(a, b, alpha)
 return a + alpha * ( b - a )
 end 
@@ -762,31 +793,20 @@ index = index + 1
 end
 return min_value
 end
-local function saw(value)
-if value < 0.25 then
-return value * 4
-elseif value < 0.50 then
-return 1 - ((value - 0.25) * 4)
-elseif value < 0.75 then
-return ((value - 0.50) * 4) * (-1)
-end
-return ((value - 0.75) * 4) - 1
-end
 local function install(std)
 std = std or {}
 std.math = std.math or {}
 std.math.abs=abs
 std.math.clamp=clamp
 std.math.clamp2=clamp2
-std.math.cycle=cycle
 std.math.dir=dir
 std.math.dis=dis
 std.math.dis2=dis2
+std.math.dis3=dis3
 std.math.lerp=lerp
 std.math.map=map
 std.math.max=max
 std.math.min=min
-std.math.saw=saw
 return std.math
 end
 local function install_clib(std)
@@ -841,7 +861,237 @@ install = install_clib_random
 return P;
 end
 --
-core_src_lib_engine_draw_fps = function()
+src_lib_engine_api_array_561fa16c1450 = function()
+local util_decorator = src_lib_util_decorator_561fa16bfce0()
+local function array_map(array, func)
+local res = {}
+local index = 1
+local length = #array
+while index <= length do
+res[#res + 1] = func(array[index], index)
+index = index + 1
+end
+return res
+end
+local function array_filter(array, func)
+func = func or (function(v) return v and v ~= 0 end)
+local res = {}
+local index = 1
+local length = #array
+while index <= length do
+local value = array[index]
+if func(value, index) then
+res[#res + 1] = value
+end
+index = index + 1
+end
+return res
+end
+local function array_unique(array)
+local res = {}
+local index = 1
+local length = #array
+local setmap = {}
+while index <= length do
+local value = array[index]
+if not setmap[value] then
+res[#res + 1] = value
+end
+setmap[value] = true
+index = index + 1
+end
+return res
+end
+local function array_foreach(array, func)
+local index = 1
+local length = #array
+while index <= length do
+func(array[index], index)
+index = index + 1
+end
+end
+local function array_reducer(array, func, value)
+local index = value and 1 or 2
+local length = #array
+value = value or array[1]
+while index <= length do
+value = func(value, array[index], index)
+index = index + 1
+end
+return value
+end
+local function array_index(array, func, reverse)
+func = func or function() return true end
+local index, inc, final = 1, 1, #array
+if reverse then
+index, inc, final = #array, -1, 1
+end
+repeat
+if func(array[index], index) then
+return index
+end
+index = index + inc
+until (reverse and index < final) or (not reverse and index > final)
+return nil
+end
+local function array_first(array, func)
+local index = array_index(array, func)
+if index then
+return array[index]
+end
+return nil
+end
+local function array_last(array, func)
+local index = array_index(array, func, true)
+if index then
+return array[index]
+end
+return nil
+end
+local function array_some(array, func, reverse)
+local index, inc, final = 1, 1, #array
+if reverse then
+index, inc, final = #array, -1, 1
+end
+repeat
+if func(array[index], index) then
+return true
+end
+index = index + inc
+until (reverse and index < final) or (not reverse and index > final)
+return false
+end
+local function array_every(array, func)
+local index = 1
+local length = #array
+while index <= length do
+if not func(array[index], index) then
+return false
+end
+index = index + 1
+end
+return true
+end
+local function array_pipeline(std, array)
+local decorator_iterator = function(func) 
+return function(self, func2, extra)
+self.array = func(self.array, func2, extra)
+return self
+end
+end
+local decorator_reduce = function(func, return_self)
+return function(self, func2, extra)
+local res = func(self.array, func2, extra)
+return (return_self and self) or res
+end
+end
+local self = {
+array = array,
+map = decorator_iterator(array_map),
+filter = decorator_iterator(array_filter),
+unique = decorator_iterator(array_unique),
+each = decorator_reduce(array_foreach, true),
+reducer = decorator_reduce(array_reducer),
+index = decorator_reduce(array_index),
+first = decorator_reduce(array_first),
+last = decorator_reduce(array_last),
+some = decorator_reduce(array_some),
+every = decorator_reduce(array_every),
+table = function(self) return self.array end,
+json = function(self) return std.json.encode(self.array) end
+}
+return self
+end
+local function install(std, engine, library, name)
+local lib = std[name] or {}
+lib.filter = array_filter
+lib.unique = array_unique
+lib.each = array_foreach
+lib.reducer = array_reducer
+lib.index = array_index
+lib.first = array_first
+lib.last = array_last
+lib.some = array_some
+lib.every = array_every
+lib.from = util_decorator.prefix1(std, array_pipeline)
+std[name] = lib
+end
+local P = {
+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)
+return self
+end
+local function media_play(func, self)
+func(self.id - 1)
+return self
+end
+local function media_pause(func, self)
+func(self.id - 1)
+return self
+end
+local function media_resize(func, self, width, height)
+func(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)
+return self
+end
+local channels = {}
+local function media_channel(std, handler)
+return function(id)
+id = id or 1
+if 0 >= id or id > 8 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)
+}
+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]
+end
+end
+local function install(std, engine, handlers)
+std.media = std.media or {}
+std.media.video = media_channel(std, handlers)
+end
+local P = {
+install=install
+}
+return P
+end
+--
+src_lib_engine_draw_fps_561fa16c6900 = 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
@@ -858,19 +1108,19 @@ if show >= 3 then
 std.draw.rect(0, x + 96, y, 40, 24)
 end
 std.draw.color(0x000000FF)
-std.draw.font('Tiresias', 16)
+std.text.font_size(16)
 if show >= 3 then
 local floor = std.math.floor or math.floor or function() return 'XX' end
 local fps =  floor((1/std.delta) * 1000)
-std.draw.text(x + s, y, fps)
+std.text.print(x + s, y, fps)
 s = s + 46
 end
 if show >= 1 then
-std.draw.text(x + s, y, engine.fps)
+std.text.print(x + s, y, engine.fps)
 s = s + 46
 end
 if show >= 2 then
-std.draw.text(x + s, y, engine.root.config.fps_max)
+std.text.print(x + s, y, engine.root.config.fps_max)
 s = s + 46
 end
 end
@@ -893,8 +1143,8 @@ install=install
 return P
 end
 --
-core_src_lib_engine_draw_text = function()
-local util_decorator = core_src_lib_util_decorator()
+src_lib_engine_draw_text_561fa16c8d50 = function()
+local util_decorator = src_lib_util_decorator_561fa16bfce0()
 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
@@ -921,7 +1171,7 @@ install=install
 return P
 end
 --
-core_src_lib_engine_draw_poly = function()
+src_lib_engine_draw_poly_561fa16ca270 = function()
 local function decorator_poo(object, func)
 if not object or not func then return func end
 return function(a, b, c, d)
@@ -1028,7 +1278,7 @@ install=install
 return P
 end
 --
-core_src_lib_engine_raw_memory = function()
+src_lib_engine_raw_memory_561fa16caab0 = function()
 local memory_dict_unload = {}
 local memory_dict = {}
 local memory_list = {}
@@ -1077,7 +1327,7 @@ install=install
 return P
 end
 --
-core_src_lib_object_root = function()
+src_lib_object_root_561fa16cb030 = function()
 local P = {
 data={
 width=1280,
@@ -1089,13 +1339,14 @@ title='',
 author='',
 company='',
 description='',
+tizen_package='',
 version=''
 },
 config = {
 offset_x = 0,
 offset_y = 0,
 require = '',
-fps_max = 100,
+fps_max = 60,
 fps_show = 0,
 fps_drop = 5,
 fps_time = 5
@@ -1106,7 +1357,7 @@ callbacks={
 return P;
 end
 --
-core_src_lib_object_color = function()
+src_lib_object_color_561fa16d0260 = function()
 local white = 0xFFFFFFFF
 local lightgray = 0xC8CCCCFF
 local gray = 0x828282FF
@@ -1168,7 +1419,7 @@ install = install
 return P
 end
 --
-core_src_lib_object_std = function()
+src_lib_object_std_561fa16c9dc0 = function()
 local P = {
 milis = 0,
 delta = 0,
@@ -1229,7 +1480,7 @@ d=false
 return P;
 end
 --
-core_src_lib_util_pipeline = function()
+src_lib_util_pipeline_561fa16c26b0 = function()
 local function pipe(self)
 return function()
 self:run()
@@ -1279,7 +1530,7 @@ run=run
 return P
 end
 --
-core_src_lib_util_decorator = function()
+src_lib_util_decorator_561fa16bfce0 = 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)
@@ -1329,4 +1580,4 @@ prefix1 = decorator_prefix1
 return P
 end
 --
-return main()
+return main_561fa16ca3f0()

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gamely/gly-engine-lite",
-    "version": "0.0.16",
+    "version": "0.0.18",
     "author": "RodrigoDornelles",
     "license": "Apache-2.0",
     "homepage": "https://docs.gamely.com.br",