@lightningjs/blits 1.32.1 → 1.33.0

package/src/components/FPScounter.js

@@ -25,110 +25,116 @@ export default () =>
     code: {
       render: function anonymous(parent, component, context, components, effect, getRaw, Log) {
         const elms = []
+        const elementConfigs = []
+        const forloops = []
+        const props = []
+        const created = []
+        const skips = []
         let componentType
-        const rootComponent = component
+        let rootComponent = component
         let propData
         let slotComponent
         let inSlot = false
         let slotChildCounter = 0
-        const elementConfig0 = {}
+        let cmps = []
+        elementConfigs[0] = {}
 
         elms[0] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elms[0].populate(elementConfig0)
+        elms[0].populate(elementConfigs[0])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[0]
-        const elementConfig1 = {}
+        elementConfigs[1] = {}
 
         elms[1] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig1['y'] = 15
-        elementConfig1['x'] = 20
-        elms[1].populate(elementConfig1)
+        elementConfigs[1]['y'] = 15
+        elementConfigs[1]['x'] = 20
+        elms[1].populate(elementConfigs[1])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[1]
-        const elementConfig2 = {}
+        elementConfigs[2] = {}
 
         elms[2] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elms[2].populate(elementConfig2)
+        elms[2].populate(elementConfigs[2])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
-        const cmp3 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[3] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[2]
-        const elementConfig3 = {}
+        elementConfigs[3] = {}
 
         elms[3] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig3['image'] = component.image
-        elementConfig3['w'] = 43
-        elementConfig3['h'] = 25
-        elementConfig3['map'] = component.sprite
-        elementConfig3['frame'] = 'fps'
-
-        const skip3 = []
-        if (typeof cmp3 !== 'undefined') {
-          for (let key in cmp3[Symbol.for('config')].props) {
-            delete elementConfig3[cmp3[Symbol.for('config')].props[key]]
-            skip3.push(cmp3[Symbol.for('config')].props[key])
+        elementConfigs[3]['image'] = component.image
+        elementConfigs[3]['w'] = 43
+        elementConfigs[3]['h'] = 25
+        elementConfigs[3]['map'] = component.sprite
+        elementConfigs[3]['frame'] = 'fps'
+
+        skips[3] = []
+        if (typeof cmps[3] !== 'undefined') {
+          for (let key in cmps[3][Symbol.for('config')].props) {
+            delete elementConfigs[3][cmps[3][Symbol.for('config')].props[key]]
+            skips[3].push(cmps[3][Symbol.for('config')].props[key])
           }
         }
 
-        elms[3].populate(elementConfig3)
+        elms[3].populate(elementConfigs[3])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[3]
-        const props4 = {}
-        props4['image'] = component.image
-        props4['w'] = 43
-        props4['h'] = 25
-        props4['map'] = component.sprite
-        props4['frame'] = 'fps'
+        props[4] = {}
+        props[4]['image'] = component.image
+        props[4]['w'] = 43
+        props[4]['h'] = 25
+        props[4]['map'] = component.sprite
+        props[4]['frame'] = 'fps'
 
-        componentType = props4['is'] || 'Sprite'
+        componentType = props[4]['is'] || 'Sprite'
 
-        let component4
+        components[4]
         if (typeof componentType === 'string') {
-          component4 =
+          components[4] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component4) {
+          if (!components[4]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component4 = componentType
+          components[4] = componentType
         }
 
-        elms[4] = component4.call(null, { props: props4 }, elms[3], component)
+        elms[4] = components[4].call(null, { props: props[4] }, elms[3], component)
 
         if (elms[4][Symbol.for('slots')][0]) {
           parent = elms[4][Symbol.for('slots')][0]
@@ -143,83 +149,83 @@ export default () =>
         }
 
         parent = elms[2]
-        const elementConfig5 = {}
+        elementConfigs[5] = {}
 
         elms[5] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig5['x'] = 58
-        elementConfig5['y'] = 2
-        elms[5].populate(elementConfig5)
+        elementConfigs[5]['x'] = 58
+        elementConfigs[5]['y'] = 2
+        elms[5].populate(elementConfigs[5])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
-        const cmp6 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[6] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[5]
-        const elementConfig6 = {}
+        elementConfigs[6] = {}
 
         elms[6] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig6['image'] = component.image
-        elementConfig6['x'] = 0
-        elementConfig6['h'] = 20
-        elementConfig6['w'] = 20
-        elementConfig6['map'] = component.sprite
-        elementConfig6['frame'] = component.fps[0]
-
-        const skip6 = []
-        if (typeof cmp6 !== 'undefined') {
-          for (let key in cmp6[Symbol.for('config')].props) {
-            delete elementConfig6[cmp6[Symbol.for('config')].props[key]]
-            skip6.push(cmp6[Symbol.for('config')].props[key])
+        elementConfigs[6]['image'] = component.image
+        elementConfigs[6]['x'] = 0
+        elementConfigs[6]['h'] = 20
+        elementConfigs[6]['w'] = 20
+        elementConfigs[6]['map'] = component.sprite
+        elementConfigs[6]['frame'] = component.fps[0]
+
+        skips[6] = []
+        if (typeof cmps[6] !== 'undefined') {
+          for (let key in cmps[6][Symbol.for('config')].props) {
+            delete elementConfigs[6][cmps[6][Symbol.for('config')].props[key]]
+            skips[6].push(cmps[6][Symbol.for('config')].props[key])
           }
         }
 
-        elms[6].populate(elementConfig6)
+        elms[6].populate(elementConfigs[6])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[6]
-        const props7 = {}
-        props7['image'] = component.image
-        props7['x'] = 0
-        props7['h'] = 20
-        props7['w'] = 20
-        props7['map'] = component.sprite
+        props[7] = {}
+        props[7]['image'] = component.image
+        props[7]['x'] = 0
+        props[7]['h'] = 20
+        props[7]['w'] = 20
+        props[7]['map'] = component.sprite
 
         propData = component.fps[0]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props7['frame'] = propData
+        props[7]['frame'] = propData
 
-        componentType = props7['is'] || 'Sprite'
+        componentType = props[7]['is'] || 'Sprite'
 
-        let component7
+        components[7]
         if (typeof componentType === 'string') {
-          component7 =
+          components[7] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component7) {
+          if (!components[7]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component7 = componentType
+          components[7] = componentType
         }
 
-        elms[7] = component7.call(null, { props: props7 }, elms[6], component)
+        elms[7] = components[7].call(null, { props: props[7] }, elms[6], component)
 
         if (elms[7][Symbol.for('slots')][0]) {
           parent = elms[7][Symbol.for('slots')][0]
@@ -233,68 +239,68 @@ export default () =>
           inSlot = false
         }
 
-        const cmp8 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[8] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[5]
-        const elementConfig8 = {}
+        elementConfigs[8] = {}
 
         elms[8] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig8['image'] = component.image
-        elementConfig8['x'] = 18
-        elementConfig8['h'] = 20
-        elementConfig8['w'] = 20
-        elementConfig8['map'] = component.sprite
-        elementConfig8['frame'] = component.fps[1]
-
-        const skip8 = []
-        if (typeof cmp8 !== 'undefined') {
-          for (let key in cmp8[Symbol.for('config')].props) {
-            delete elementConfig8[cmp8[Symbol.for('config')].props[key]]
-            skip8.push(cmp8[Symbol.for('config')].props[key])
+        elementConfigs[8]['image'] = component.image
+        elementConfigs[8]['x'] = 18
+        elementConfigs[8]['h'] = 20
+        elementConfigs[8]['w'] = 20
+        elementConfigs[8]['map'] = component.sprite
+        elementConfigs[8]['frame'] = component.fps[1]
+
+        skips[8] = []
+        if (typeof cmps[8] !== 'undefined') {
+          for (let key in cmps[8][Symbol.for('config')].props) {
+            delete elementConfigs[8][cmps[8][Symbol.for('config')].props[key]]
+            skips[8].push(cmps[8][Symbol.for('config')].props[key])
           }
         }
 
-        elms[8].populate(elementConfig8)
+        elms[8].populate(elementConfigs[8])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[8]
-        const props9 = {}
-        props9['image'] = component.image
-        props9['x'] = 18
-        props9['h'] = 20
-        props9['w'] = 20
-        props9['map'] = component.sprite
+        props[9] = {}
+        props[9]['image'] = component.image
+        props[9]['x'] = 18
+        props[9]['h'] = 20
+        props[9]['w'] = 20
+        props[9]['map'] = component.sprite
 
         propData = component.fps[1]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props9['frame'] = propData
+        props[9]['frame'] = propData
 
-        componentType = props9['is'] || 'Sprite'
+        componentType = props[9]['is'] || 'Sprite'
 
-        let component9
+        components[9]
         if (typeof componentType === 'string') {
-          component9 =
+          components[9] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component9) {
+          if (!components[9]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component9 = componentType
+          components[9] = componentType
         }
 
-        elms[9] = component9.call(null, { props: props9 }, elms[8], component)
+        elms[9] = components[9].call(null, { props: props[9] }, elms[8], component)
 
         if (elms[9][Symbol.for('slots')][0]) {
           parent = elms[9][Symbol.for('slots')][0]
@@ -308,68 +314,68 @@ export default () =>
           inSlot = false
         }
 
-        const cmp10 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[10] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[5]
-        const elementConfig10 = {}
+        elementConfigs[10] = {}
 
         elms[10] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig10['image'] = component.image
-        elementConfig10['x'] = 36
-        elementConfig10['h'] = 20
-        elementConfig10['w'] = 20
-        elementConfig10['map'] = component.sprite
-        elementConfig10['frame'] = component.fps[2]
-
-        const skip10 = []
-        if (typeof cmp10 !== 'undefined') {
-          for (let key in cmp10[Symbol.for('config')].props) {
-            delete elementConfig10[cmp10[Symbol.for('config')].props[key]]
-            skip10.push(cmp10[Symbol.for('config')].props[key])
+        elementConfigs[10]['image'] = component.image
+        elementConfigs[10]['x'] = 36
+        elementConfigs[10]['h'] = 20
+        elementConfigs[10]['w'] = 20
+        elementConfigs[10]['map'] = component.sprite
+        elementConfigs[10]['frame'] = component.fps[2]
+
+        skips[10] = []
+        if (typeof cmps[10] !== 'undefined') {
+          for (let key in cmps[10][Symbol.for('config')].props) {
+            delete elementConfigs[10][cmps[10][Symbol.for('config')].props[key]]
+            skips[10].push(cmps[10][Symbol.for('config')].props[key])
           }
         }
 
-        elms[10].populate(elementConfig10)
+        elms[10].populate(elementConfigs[10])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[10]
-        const props11 = {}
-        props11['image'] = component.image
-        props11['x'] = 36
-        props11['h'] = 20
-        props11['w'] = 20
-        props11['map'] = component.sprite
+        props[11] = {}
+        props[11]['image'] = component.image
+        props[11]['x'] = 36
+        props[11]['h'] = 20
+        props[11]['w'] = 20
+        props[11]['map'] = component.sprite
 
         propData = component.fps[2]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props11['frame'] = propData
+        props[11]['frame'] = propData
 
-        componentType = props11['is'] || 'Sprite'
+        componentType = props[11]['is'] || 'Sprite'
 
-        let component11
+        components[11]
         if (typeof componentType === 'string') {
-          component11 =
+          components[11] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component11) {
+          if (!components[11]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component11 = componentType
+          components[11] = componentType
         }
 
-        elms[11] = component11.call(null, { props: props11 }, elms[10], component)
+        elms[11] = components[11].call(null, { props: props[11] }, elms[10], component)
 
         if (elms[11][Symbol.for('slots')][0]) {
           parent = elms[11][Symbol.for('slots')][0]
@@ -384,77 +390,77 @@ export default () =>
         }
 
         parent = elms[1]
-        const elementConfig12 = {}
+        elementConfigs[12] = {}
 
         elms[12] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig12['x'] = 150
-        elms[12].populate(elementConfig12)
+        elementConfigs[12]['x'] = 150
+        elms[12].populate(elementConfigs[12])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
-        const cmp13 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[13] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[12]
-        const elementConfig13 = {}
+        elementConfigs[13] = {}
 
         elms[13] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig13['image'] = component.image
-        elementConfig13['y'] = 2
-        elementConfig13['w'] = 48
-        elementConfig13['h'] = 25
-        elementConfig13['map'] = component.sprite
-        elementConfig13['frame'] = 'avg'
-
-        const skip13 = []
-        if (typeof cmp13 !== 'undefined') {
-          for (let key in cmp13[Symbol.for('config')].props) {
-            delete elementConfig13[cmp13[Symbol.for('config')].props[key]]
-            skip13.push(cmp13[Symbol.for('config')].props[key])
+        elementConfigs[13]['image'] = component.image
+        elementConfigs[13]['y'] = 2
+        elementConfigs[13]['w'] = 48
+        elementConfigs[13]['h'] = 25
+        elementConfigs[13]['map'] = component.sprite
+        elementConfigs[13]['frame'] = 'avg'
+
+        skips[13] = []
+        if (typeof cmps[13] !== 'undefined') {
+          for (let key in cmps[13][Symbol.for('config')].props) {
+            delete elementConfigs[13][cmps[13][Symbol.for('config')].props[key]]
+            skips[13].push(cmps[13][Symbol.for('config')].props[key])
           }
         }
 
-        elms[13].populate(elementConfig13)
+        elms[13].populate(elementConfigs[13])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[13]
-        const props14 = {}
-        props14['image'] = component.image
-        props14['y'] = 2
-        props14['w'] = 48
-        props14['h'] = 25
-        props14['map'] = component.sprite
-        props14['frame'] = 'avg'
+        props[14] = {}
+        props[14]['image'] = component.image
+        props[14]['y'] = 2
+        props[14]['w'] = 48
+        props[14]['h'] = 25
+        props[14]['map'] = component.sprite
+        props[14]['frame'] = 'avg'
 
-        componentType = props14['is'] || 'Sprite'
+        componentType = props[14]['is'] || 'Sprite'
 
-        let component14
+        components[14]
         if (typeof componentType === 'string') {
-          component14 =
+          components[14] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component14) {
+          if (!components[14]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component14 = componentType
+          components[14] = componentType
         }
 
-        elms[14] = component14.call(null, { props: props14 }, elms[13], component)
+        elms[14] = components[14].call(null, { props: props[14] }, elms[13], component)
 
         if (elms[14][Symbol.for('slots')][0]) {
           parent = elms[14][Symbol.for('slots')][0]
@@ -469,83 +475,83 @@ export default () =>
         }
 
         parent = elms[12]
-        const elementConfig15 = {}
+        elementConfigs[15] = {}
 
         elms[15] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig15['x'] = 63
-        elementConfig15['y'] = 2
-        elms[15].populate(elementConfig15)
+        elementConfigs[15]['x'] = 63
+        elementConfigs[15]['y'] = 2
+        elms[15].populate(elementConfigs[15])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
-        const cmp16 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[16] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[15]
-        const elementConfig16 = {}
+        elementConfigs[16] = {}
 
         elms[16] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig16['image'] = component.image
-        elementConfig16['x'] = 0
-        elementConfig16['h'] = 20
-        elementConfig16['w'] = 20
-        elementConfig16['map'] = component.sprite
-        elementConfig16['frame'] = component.avgFps[0]
-
-        const skip16 = []
-        if (typeof cmp16 !== 'undefined') {
-          for (let key in cmp16[Symbol.for('config')].props) {
-            delete elementConfig16[cmp16[Symbol.for('config')].props[key]]
-            skip16.push(cmp16[Symbol.for('config')].props[key])
+        elementConfigs[16]['image'] = component.image
+        elementConfigs[16]['x'] = 0
+        elementConfigs[16]['h'] = 20
+        elementConfigs[16]['w'] = 20
+        elementConfigs[16]['map'] = component.sprite
+        elementConfigs[16]['frame'] = component.avgFps[0]
+
+        skips[16] = []
+        if (typeof cmps[16] !== 'undefined') {
+          for (let key in cmps[16][Symbol.for('config')].props) {
+            delete elementConfigs[16][cmps[16][Symbol.for('config')].props[key]]
+            skips[16].push(cmps[16][Symbol.for('config')].props[key])
           }
         }
 
-        elms[16].populate(elementConfig16)
+        elms[16].populate(elementConfigs[16])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[16]
-        const props17 = {}
-        props17['image'] = component.image
-        props17['x'] = 0
-        props17['h'] = 20
-        props17['w'] = 20
-        props17['map'] = component.sprite
+        props[17] = {}
+        props[17]['image'] = component.image
+        props[17]['x'] = 0
+        props[17]['h'] = 20
+        props[17]['w'] = 20
+        props[17]['map'] = component.sprite
 
         propData = component.avgFps[0]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props17['frame'] = propData
+        props[17]['frame'] = propData
 
-        componentType = props17['is'] || 'Sprite'
+        componentType = props[17]['is'] || 'Sprite'
 
-        let component17
+        components[17]
         if (typeof componentType === 'string') {
-          component17 =
+          components[17] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component17) {
+          if (!components[17]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component17 = componentType
+          components[17] = componentType
         }
 
-        elms[17] = component17.call(null, { props: props17 }, elms[16], component)
+        elms[17] = components[17].call(null, { props: props[17] }, elms[16], component)
 
         if (elms[17][Symbol.for('slots')][0]) {
           parent = elms[17][Symbol.for('slots')][0]
@@ -559,68 +565,68 @@ export default () =>
           inSlot = false
         }
 
-        const cmp18 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[18] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[15]
-        const elementConfig18 = {}
+        elementConfigs[18] = {}
 
         elms[18] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig18['image'] = component.image
-        elementConfig18['x'] = 18
-        elementConfig18['h'] = 20
-        elementConfig18['w'] = 20
-        elementConfig18['map'] = component.sprite
-        elementConfig18['frame'] = component.avgFps[1]
-
-        const skip18 = []
-        if (typeof cmp18 !== 'undefined') {
-          for (let key in cmp18[Symbol.for('config')].props) {
-            delete elementConfig18[cmp18[Symbol.for('config')].props[key]]
-            skip18.push(cmp18[Symbol.for('config')].props[key])
+        elementConfigs[18]['image'] = component.image
+        elementConfigs[18]['x'] = 18
+        elementConfigs[18]['h'] = 20
+        elementConfigs[18]['w'] = 20
+        elementConfigs[18]['map'] = component.sprite
+        elementConfigs[18]['frame'] = component.avgFps[1]
+
+        skips[18] = []
+        if (typeof cmps[18] !== 'undefined') {
+          for (let key in cmps[18][Symbol.for('config')].props) {
+            delete elementConfigs[18][cmps[18][Symbol.for('config')].props[key]]
+            skips[18].push(cmps[18][Symbol.for('config')].props[key])
           }
         }
 
-        elms[18].populate(elementConfig18)
+        elms[18].populate(elementConfigs[18])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[18]
-        const props19 = {}
-        props19['image'] = component.image
-        props19['x'] = 18
-        props19['h'] = 20
-        props19['w'] = 20
-        props19['map'] = component.sprite
+        props[19] = {}
+        props[19]['image'] = component.image
+        props[19]['x'] = 18
+        props[19]['h'] = 20
+        props[19]['w'] = 20
+        props[19]['map'] = component.sprite
 
         propData = component.avgFps[1]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props19['frame'] = propData
+        props[19]['frame'] = propData
 
-        componentType = props19['is'] || 'Sprite'
+        componentType = props[19]['is'] || 'Sprite'
 
-        let component19
+        components[19]
         if (typeof componentType === 'string') {
-          component19 =
+          components[19] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component19) {
+          if (!components[19]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component19 = componentType
+          components[19] = componentType
         }
 
-        elms[19] = component19.call(null, { props: props19 }, elms[18], component)
+        elms[19] = components[19].call(null, { props: props[19] }, elms[18], component)
 
         if (elms[19][Symbol.for('slots')][0]) {
           parent = elms[19][Symbol.for('slots')][0]
@@ -634,68 +640,68 @@ export default () =>
           inSlot = false
         }
 
-        const cmp20 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[20] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[15]
-        const elementConfig20 = {}
+        elementConfigs[20] = {}
 
         elms[20] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig20['image'] = component.image
-        elementConfig20['x'] = 36
-        elementConfig20['h'] = 20
-        elementConfig20['w'] = 20
-        elementConfig20['map'] = component.sprite
-        elementConfig20['frame'] = component.avgFps[2]
-
-        const skip20 = []
-        if (typeof cmp20 !== 'undefined') {
-          for (let key in cmp20[Symbol.for('config')].props) {
-            delete elementConfig20[cmp20[Symbol.for('config')].props[key]]
-            skip20.push(cmp20[Symbol.for('config')].props[key])
+        elementConfigs[20]['image'] = component.image
+        elementConfigs[20]['x'] = 36
+        elementConfigs[20]['h'] = 20
+        elementConfigs[20]['w'] = 20
+        elementConfigs[20]['map'] = component.sprite
+        elementConfigs[20]['frame'] = component.avgFps[2]
+
+        skips[20] = []
+        if (typeof cmps[20] !== 'undefined') {
+          for (let key in cmps[20][Symbol.for('config')].props) {
+            delete elementConfigs[20][cmps[20][Symbol.for('config')].props[key]]
+            skips[20].push(cmps[20][Symbol.for('config')].props[key])
           }
         }
 
-        elms[20].populate(elementConfig20)
+        elms[20].populate(elementConfigs[20])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[20]
-        const props21 = {}
-        props21['image'] = component.image
-        props21['x'] = 36
-        props21['h'] = 20
-        props21['w'] = 20
-        props21['map'] = component.sprite
+        props[21] = {}
+        props[21]['image'] = component.image
+        props[21]['x'] = 36
+        props[21]['h'] = 20
+        props[21]['w'] = 20
+        props[21]['map'] = component.sprite
 
         propData = component.avgFps[2]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props21['frame'] = propData
+        props[21]['frame'] = propData
 
-        componentType = props21['is'] || 'Sprite'
+        componentType = props[21]['is'] || 'Sprite'
 
-        let component21
+        components[21]
         if (typeof componentType === 'string') {
-          component21 =
+          components[21] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component21) {
+          if (!components[21]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component21 = componentType
+          components[21] = componentType
         }
 
-        elms[21] = component21.call(null, { props: props21 }, elms[20], component)
+        elms[21] = components[21].call(null, { props: props[21] }, elms[20], component)
 
         if (elms[21][Symbol.for('slots')][0]) {
           parent = elms[21][Symbol.for('slots')][0]
@@ -710,78 +716,78 @@ export default () =>
         }
 
         parent = elms[1]
-        const elementConfig22 = {}
+        elementConfigs[22] = {}
 
         elms[22] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig22['x'] = 0
-        elementConfig22['y'] = 40
-        elms[22].populate(elementConfig22)
+        elementConfigs[22]['x'] = 0
+        elementConfigs[22]['y'] = 40
+        elms[22].populate(elementConfigs[22])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
-        const cmp23 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[23] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[22]
-        const elementConfig23 = {}
+        elementConfigs[23] = {}
 
         elms[23] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig23['image'] = component.image
-        elementConfig23['x'] = '-2'
-        elementConfig23['w'] = 47
-        elementConfig23['h'] = 25
-        elementConfig23['map'] = component.sprite
-        elementConfig23['frame'] = 'min'
-
-        const skip23 = []
-        if (typeof cmp23 !== 'undefined') {
-          for (let key in cmp23[Symbol.for('config')].props) {
-            delete elementConfig23[cmp23[Symbol.for('config')].props[key]]
-            skip23.push(cmp23[Symbol.for('config')].props[key])
+        elementConfigs[23]['image'] = component.image
+        elementConfigs[23]['x'] = '-2'
+        elementConfigs[23]['w'] = 47
+        elementConfigs[23]['h'] = 25
+        elementConfigs[23]['map'] = component.sprite
+        elementConfigs[23]['frame'] = 'min'
+
+        skips[23] = []
+        if (typeof cmps[23] !== 'undefined') {
+          for (let key in cmps[23][Symbol.for('config')].props) {
+            delete elementConfigs[23][cmps[23][Symbol.for('config')].props[key]]
+            skips[23].push(cmps[23][Symbol.for('config')].props[key])
           }
         }
 
-        elms[23].populate(elementConfig23)
+        elms[23].populate(elementConfigs[23])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[23]
-        const props24 = {}
-        props24['image'] = component.image
-        props24['x'] = '-2'
-        props24['w'] = 47
-        props24['h'] = 25
-        props24['map'] = component.sprite
-        props24['frame'] = 'min'
+        props[24] = {}
+        props[24]['image'] = component.image
+        props[24]['x'] = '-2'
+        props[24]['w'] = 47
+        props[24]['h'] = 25
+        props[24]['map'] = component.sprite
+        props[24]['frame'] = 'min'
 
-        componentType = props24['is'] || 'Sprite'
+        componentType = props[24]['is'] || 'Sprite'
 
-        let component24
+        components[24]
         if (typeof componentType === 'string') {
-          component24 =
+          components[24] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component24) {
+          if (!components[24]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component24 = componentType
+          components[24] = componentType
         }
 
-        elms[24] = component24.call(null, { props: props24 }, elms[23], component)
+        elms[24] = components[24].call(null, { props: props[24] }, elms[23], component)
 
         if (elms[24][Symbol.for('slots')][0]) {
           parent = elms[24][Symbol.for('slots')][0]
@@ -796,83 +802,83 @@ export default () =>
         }
 
         parent = elms[22]
-        const elementConfig25 = {}
+        elementConfigs[25] = {}
 
         elms[25] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig25['x'] = 58
-        elementConfig25['y'] = 2
-        elms[25].populate(elementConfig25)
+        elementConfigs[25]['x'] = 58
+        elementConfigs[25]['y'] = 2
+        elms[25].populate(elementConfigs[25])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
-        const cmp26 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[26] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[25]
-        const elementConfig26 = {}
+        elementConfigs[26] = {}
 
         elms[26] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig26['image'] = component.image
-        elementConfig26['x'] = 0
-        elementConfig26['h'] = 20
-        elementConfig26['w'] = 20
-        elementConfig26['map'] = component.sprite
-        elementConfig26['frame'] = component.minFps[0]
-
-        const skip26 = []
-        if (typeof cmp26 !== 'undefined') {
-          for (let key in cmp26[Symbol.for('config')].props) {
-            delete elementConfig26[cmp26[Symbol.for('config')].props[key]]
-            skip26.push(cmp26[Symbol.for('config')].props[key])
+        elementConfigs[26]['image'] = component.image
+        elementConfigs[26]['x'] = 0
+        elementConfigs[26]['h'] = 20
+        elementConfigs[26]['w'] = 20
+        elementConfigs[26]['map'] = component.sprite
+        elementConfigs[26]['frame'] = component.minFps[0]
+
+        skips[26] = []
+        if (typeof cmps[26] !== 'undefined') {
+          for (let key in cmps[26][Symbol.for('config')].props) {
+            delete elementConfigs[26][cmps[26][Symbol.for('config')].props[key]]
+            skips[26].push(cmps[26][Symbol.for('config')].props[key])
           }
         }
 
-        elms[26].populate(elementConfig26)
+        elms[26].populate(elementConfigs[26])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[26]
-        const props27 = {}
-        props27['image'] = component.image
-        props27['x'] = 0
-        props27['h'] = 20
-        props27['w'] = 20
-        props27['map'] = component.sprite
+        props[27] = {}
+        props[27]['image'] = component.image
+        props[27]['x'] = 0
+        props[27]['h'] = 20
+        props[27]['w'] = 20
+        props[27]['map'] = component.sprite
 
         propData = component.minFps[0]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props27['frame'] = propData
+        props[27]['frame'] = propData
 
-        componentType = props27['is'] || 'Sprite'
+        componentType = props[27]['is'] || 'Sprite'
 
-        let component27
+        components[27]
         if (typeof componentType === 'string') {
-          component27 =
+          components[27] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component27) {
+          if (!components[27]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component27 = componentType
+          components[27] = componentType
         }
 
-        elms[27] = component27.call(null, { props: props27 }, elms[26], component)
+        elms[27] = components[27].call(null, { props: props[27] }, elms[26], component)
 
         if (elms[27][Symbol.for('slots')][0]) {
           parent = elms[27][Symbol.for('slots')][0]
@@ -886,68 +892,68 @@ export default () =>
           inSlot = false
         }
 
-        const cmp28 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[28] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[25]
-        const elementConfig28 = {}
+        elementConfigs[28] = {}
 
         elms[28] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig28['image'] = component.image
-        elementConfig28['x'] = 18
-        elementConfig28['h'] = 20
-        elementConfig28['w'] = 20
-        elementConfig28['map'] = component.sprite
-        elementConfig28['frame'] = component.minFps[1]
-
-        const skip28 = []
-        if (typeof cmp28 !== 'undefined') {
-          for (let key in cmp28[Symbol.for('config')].props) {
-            delete elementConfig28[cmp28[Symbol.for('config')].props[key]]
-            skip28.push(cmp28[Symbol.for('config')].props[key])
+        elementConfigs[28]['image'] = component.image
+        elementConfigs[28]['x'] = 18
+        elementConfigs[28]['h'] = 20
+        elementConfigs[28]['w'] = 20
+        elementConfigs[28]['map'] = component.sprite
+        elementConfigs[28]['frame'] = component.minFps[1]
+
+        skips[28] = []
+        if (typeof cmps[28] !== 'undefined') {
+          for (let key in cmps[28][Symbol.for('config')].props) {
+            delete elementConfigs[28][cmps[28][Symbol.for('config')].props[key]]
+            skips[28].push(cmps[28][Symbol.for('config')].props[key])
           }
         }
 
-        elms[28].populate(elementConfig28)
+        elms[28].populate(elementConfigs[28])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[28]
-        const props29 = {}
-        props29['image'] = component.image
-        props29['x'] = 18
-        props29['h'] = 20
-        props29['w'] = 20
-        props29['map'] = component.sprite
+        props[29] = {}
+        props[29]['image'] = component.image
+        props[29]['x'] = 18
+        props[29]['h'] = 20
+        props[29]['w'] = 20
+        props[29]['map'] = component.sprite
 
         propData = component.minFps[1]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props29['frame'] = propData
+        props[29]['frame'] = propData
 
-        componentType = props29['is'] || 'Sprite'
+        componentType = props[29]['is'] || 'Sprite'
 
-        let component29
+        components[29]
         if (typeof componentType === 'string') {
-          component29 =
+          components[29] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component29) {
+          if (!components[29]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component29 = componentType
+          components[29] = componentType
         }
 
-        elms[29] = component29.call(null, { props: props29 }, elms[28], component)
+        elms[29] = components[29].call(null, { props: props[29] }, elms[28], component)
 
         if (elms[29][Symbol.for('slots')][0]) {
           parent = elms[29][Symbol.for('slots')][0]
@@ -961,68 +967,68 @@ export default () =>
           inSlot = false
         }
 
-        const cmp30 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[30] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[25]
-        const elementConfig30 = {}
+        elementConfigs[30] = {}
 
         elms[30] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig30['image'] = component.image
-        elementConfig30['x'] = 36
-        elementConfig30['h'] = 20
-        elementConfig30['w'] = 20
-        elementConfig30['map'] = component.sprite
-        elementConfig30['frame'] = component.minFps[2]
-
-        const skip30 = []
-        if (typeof cmp30 !== 'undefined') {
-          for (let key in cmp30[Symbol.for('config')].props) {
-            delete elementConfig30[cmp30[Symbol.for('config')].props[key]]
-            skip30.push(cmp30[Symbol.for('config')].props[key])
+        elementConfigs[30]['image'] = component.image
+        elementConfigs[30]['x'] = 36
+        elementConfigs[30]['h'] = 20
+        elementConfigs[30]['w'] = 20
+        elementConfigs[30]['map'] = component.sprite
+        elementConfigs[30]['frame'] = component.minFps[2]
+
+        skips[30] = []
+        if (typeof cmps[30] !== 'undefined') {
+          for (let key in cmps[30][Symbol.for('config')].props) {
+            delete elementConfigs[30][cmps[30][Symbol.for('config')].props[key]]
+            skips[30].push(cmps[30][Symbol.for('config')].props[key])
           }
         }
 
-        elms[30].populate(elementConfig30)
+        elms[30].populate(elementConfigs[30])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[30]
-        const props31 = {}
-        props31['image'] = component.image
-        props31['x'] = 36
-        props31['h'] = 20
-        props31['w'] = 20
-        props31['map'] = component.sprite
+        props[31] = {}
+        props[31]['image'] = component.image
+        props[31]['x'] = 36
+        props[31]['h'] = 20
+        props[31]['w'] = 20
+        props[31]['map'] = component.sprite
 
         propData = component.minFps[2]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props31['frame'] = propData
+        props[31]['frame'] = propData
 
-        componentType = props31['is'] || 'Sprite'
+        componentType = props[31]['is'] || 'Sprite'
 
-        let component31
+        components[31]
         if (typeof componentType === 'string') {
-          component31 =
+          components[31] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component31) {
+          if (!components[31]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component31 = componentType
+          components[31] = componentType
         }
 
-        elms[31] = component31.call(null, { props: props31 }, elms[30], component)
+        elms[31] = components[31].call(null, { props: props[31] }, elms[30], component)
 
         if (elms[31][Symbol.for('slots')][0]) {
           parent = elms[31][Symbol.for('slots')][0]
@@ -1037,76 +1043,76 @@ export default () =>
         }
 
         parent = elms[1]
-        const elementConfig32 = {}
+        elementConfigs[32] = {}
 
         elms[32] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig32['x'] = 150
-        elementConfig32['y'] = 40
-        elms[32].populate(elementConfig32)
+        elementConfigs[32]['x'] = 150
+        elementConfigs[32]['y'] = 40
+        elms[32].populate(elementConfigs[32])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
-        const cmp33 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[33] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[32]
-        const elementConfig33 = {}
+        elementConfigs[33] = {}
 
         elms[33] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig33['image'] = component.image
-        elementConfig33['w'] = 53
-        elementConfig33['h'] = 25
-        elementConfig33['map'] = component.sprite
-        elementConfig33['frame'] = 'max'
-
-        const skip33 = []
-        if (typeof cmp33 !== 'undefined') {
-          for (let key in cmp33[Symbol.for('config')].props) {
-            delete elementConfig33[cmp33[Symbol.for('config')].props[key]]
-            skip33.push(cmp33[Symbol.for('config')].props[key])
+        elementConfigs[33]['image'] = component.image
+        elementConfigs[33]['w'] = 53
+        elementConfigs[33]['h'] = 25
+        elementConfigs[33]['map'] = component.sprite
+        elementConfigs[33]['frame'] = 'max'
+
+        skips[33] = []
+        if (typeof cmps[33] !== 'undefined') {
+          for (let key in cmps[33][Symbol.for('config')].props) {
+            delete elementConfigs[33][cmps[33][Symbol.for('config')].props[key]]
+            skips[33].push(cmps[33][Symbol.for('config')].props[key])
           }
         }
 
-        elms[33].populate(elementConfig33)
+        elms[33].populate(elementConfigs[33])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[33]
-        const props34 = {}
-        props34['image'] = component.image
-        props34['w'] = 53
-        props34['h'] = 25
-        props34['map'] = component.sprite
-        props34['frame'] = 'max'
+        props[34] = {}
+        props[34]['image'] = component.image
+        props[34]['w'] = 53
+        props[34]['h'] = 25
+        props[34]['map'] = component.sprite
+        props[34]['frame'] = 'max'
 
-        componentType = props34['is'] || 'Sprite'
+        componentType = props[34]['is'] || 'Sprite'
 
-        let component34
+        components[34]
         if (typeof componentType === 'string') {
-          component34 =
+          components[34] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component34) {
+          if (!components[34]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component34 = componentType
+          components[34] = componentType
         }
 
-        elms[34] = component34.call(null, { props: props34 }, elms[33], component)
+        elms[34] = components[34].call(null, { props: props[34] }, elms[33], component)
 
         if (elms[34][Symbol.for('slots')][0]) {
           parent = elms[34][Symbol.for('slots')][0]
@@ -1121,83 +1127,83 @@ export default () =>
         }
 
         parent = elms[32]
-        const elementConfig35 = {}
+        elementConfigs[35] = {}
 
         elms[35] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig35['x'] = 63
-        elementConfig35['y'] = 2
-        elms[35].populate(elementConfig35)
+        elementConfigs[35]['x'] = 63
+        elementConfigs[35]['y'] = 2
+        elms[35].populate(elementConfigs[35])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
-        const cmp36 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[36] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[35]
-        const elementConfig36 = {}
+        elementConfigs[36] = {}
 
         elms[36] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig36['image'] = component.image
-        elementConfig36['x'] = 0
-        elementConfig36['h'] = 20
-        elementConfig36['w'] = 20
-        elementConfig36['map'] = component.sprite
-        elementConfig36['frame'] = component.maxFps[0]
-
-        const skip36 = []
-        if (typeof cmp36 !== 'undefined') {
-          for (let key in cmp36[Symbol.for('config')].props) {
-            delete elementConfig36[cmp36[Symbol.for('config')].props[key]]
-            skip36.push(cmp36[Symbol.for('config')].props[key])
+        elementConfigs[36]['image'] = component.image
+        elementConfigs[36]['x'] = 0
+        elementConfigs[36]['h'] = 20
+        elementConfigs[36]['w'] = 20
+        elementConfigs[36]['map'] = component.sprite
+        elementConfigs[36]['frame'] = component.maxFps[0]
+
+        skips[36] = []
+        if (typeof cmps[36] !== 'undefined') {
+          for (let key in cmps[36][Symbol.for('config')].props) {
+            delete elementConfigs[36][cmps[36][Symbol.for('config')].props[key]]
+            skips[36].push(cmps[36][Symbol.for('config')].props[key])
           }
         }
 
-        elms[36].populate(elementConfig36)
+        elms[36].populate(elementConfigs[36])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[36]
-        const props37 = {}
-        props37['image'] = component.image
-        props37['x'] = 0
-        props37['h'] = 20
-        props37['w'] = 20
-        props37['map'] = component.sprite
+        props[37] = {}
+        props[37]['image'] = component.image
+        props[37]['x'] = 0
+        props[37]['h'] = 20
+        props[37]['w'] = 20
+        props[37]['map'] = component.sprite
 
         propData = component.maxFps[0]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props37['frame'] = propData
+        props[37]['frame'] = propData
 
-        componentType = props37['is'] || 'Sprite'
+        componentType = props[37]['is'] || 'Sprite'
 
-        let component37
+        components[37]
         if (typeof componentType === 'string') {
-          component37 =
+          components[37] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component37) {
+          if (!components[37]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component37 = componentType
+          components[37] = componentType
         }
 
-        elms[37] = component37.call(null, { props: props37 }, elms[36], component)
+        elms[37] = components[37].call(null, { props: props[37] }, elms[36], component)
 
         if (elms[37][Symbol.for('slots')][0]) {
           parent = elms[37][Symbol.for('slots')][0]
@@ -1211,68 +1217,68 @@ export default () =>
           inSlot = false
         }
 
-        const cmp38 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[38] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[35]
-        const elementConfig38 = {}
+        elementConfigs[38] = {}
 
         elms[38] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig38['image'] = component.image
-        elementConfig38['x'] = 18
-        elementConfig38['h'] = 20
-        elementConfig38['w'] = 20
-        elementConfig38['map'] = component.sprite
-        elementConfig38['frame'] = component.maxFps[1]
-
-        const skip38 = []
-        if (typeof cmp38 !== 'undefined') {
-          for (let key in cmp38[Symbol.for('config')].props) {
-            delete elementConfig38[cmp38[Symbol.for('config')].props[key]]
-            skip38.push(cmp38[Symbol.for('config')].props[key])
+        elementConfigs[38]['image'] = component.image
+        elementConfigs[38]['x'] = 18
+        elementConfigs[38]['h'] = 20
+        elementConfigs[38]['w'] = 20
+        elementConfigs[38]['map'] = component.sprite
+        elementConfigs[38]['frame'] = component.maxFps[1]
+
+        skips[38] = []
+        if (typeof cmps[38] !== 'undefined') {
+          for (let key in cmps[38][Symbol.for('config')].props) {
+            delete elementConfigs[38][cmps[38][Symbol.for('config')].props[key]]
+            skips[38].push(cmps[38][Symbol.for('config')].props[key])
           }
         }
 
-        elms[38].populate(elementConfig38)
+        elms[38].populate(elementConfigs[38])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[38]
-        const props39 = {}
-        props39['image'] = component.image
-        props39['x'] = 18
-        props39['h'] = 20
-        props39['w'] = 20
-        props39['map'] = component.sprite
+        props[39] = {}
+        props[39]['image'] = component.image
+        props[39]['x'] = 18
+        props[39]['h'] = 20
+        props[39]['w'] = 20
+        props[39]['map'] = component.sprite
 
         propData = component.maxFps[1]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props39['frame'] = propData
+        props[39]['frame'] = propData
 
-        componentType = props39['is'] || 'Sprite'
+        componentType = props[39]['is'] || 'Sprite'
 
-        let component39
+        components[39]
         if (typeof componentType === 'string') {
-          component39 =
+          components[39] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component39) {
+          if (!components[39]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component39 = componentType
+          components[39] = componentType
         }
 
-        elms[39] = component39.call(null, { props: props39 }, elms[38], component)
+        elms[39] = components[39].call(null, { props: props[39] }, elms[38], component)
 
         if (elms[39][Symbol.for('slots')][0]) {
           parent = elms[39][Symbol.for('slots')][0]
@@ -1286,68 +1292,68 @@ export default () =>
           inSlot = false
         }
 
-        const cmp40 = (context.components && context.components['Sprite']) || components['Sprite']
+        cmps[40] = (context.components && context.components['Sprite']) || components['Sprite']
 
         parent = elms[35]
-        const elementConfig40 = {}
+        elementConfigs[40] = {}
 
         elms[40] = this.element(
           { parent: parent || 'root' },
           inSlot === true ? slotComponent : component
         )
 
-        elementConfig40['image'] = component.image
-        elementConfig40['x'] = 36
-        elementConfig40['h'] = 20
-        elementConfig40['w'] = 20
-        elementConfig40['map'] = component.sprite
-        elementConfig40['frame'] = component.maxFps[2]
-
-        const skip40 = []
-        if (typeof cmp40 !== 'undefined') {
-          for (let key in cmp40[Symbol.for('config')].props) {
-            delete elementConfig40[cmp40[Symbol.for('config')].props[key]]
-            skip40.push(cmp40[Symbol.for('config')].props[key])
+        elementConfigs[40]['image'] = component.image
+        elementConfigs[40]['x'] = 36
+        elementConfigs[40]['h'] = 20
+        elementConfigs[40]['w'] = 20
+        elementConfigs[40]['map'] = component.sprite
+        elementConfigs[40]['frame'] = component.maxFps[2]
+
+        skips[40] = []
+        if (typeof cmps[40] !== 'undefined') {
+          for (let key in cmps[40][Symbol.for('config')].props) {
+            delete elementConfigs[40][cmps[40][Symbol.for('config')].props[key]]
+            skips[40].push(cmps[40][Symbol.for('config')].props[key])
           }
         }
 
-        elms[40].populate(elementConfig40)
+        elms[40].populate(elementConfigs[40])
 
         if (inSlot === true) {
           slotChildCounter -= 1
         }
 
         parent = elms[40]
-        const props41 = {}
-        props41['image'] = component.image
-        props41['x'] = 36
-        props41['h'] = 20
-        props41['w'] = 20
-        props41['map'] = component.sprite
+        props[41] = {}
+        props[41]['image'] = component.image
+        props[41]['x'] = 36
+        props[41]['h'] = 20
+        props[41]['w'] = 20
+        props[41]['map'] = component.sprite
 
         propData = component.maxFps[2]
         if (Array.isArray(propData) === true) {
           propData = getRaw(propData).slice(0)
         }
-        props41['frame'] = propData
+        props[41]['frame'] = propData
 
-        componentType = props41['is'] || 'Sprite'
+        componentType = props[41]['is'] || 'Sprite'
 
-        let component41
+        components[41]
         if (typeof componentType === 'string') {
-          component41 =
+          components[41] =
             (context.components && context.components[componentType]) || components[componentType]
-          if (!component41) {
+          if (!components[41]) {
             throw new Error('Component "Sprite" not found')
           }
         } else if (
           typeof componentType === 'function' &&
           componentType[Symbol.for('isComponent')] === true
         ) {
-          component41 = componentType
+          components[41] = componentType
         }
 
-        elms[41] = component41.call(null, { props: props41 }, elms[40], component)
+        elms[41] = components[41].call(null, { props: props[41] }, elms[40], component)
 
         if (elms[41][Symbol.for('slots')][0]) {
           parent = elms[41][Symbol.for('slots')][0]
@@ -1361,88 +1367,232 @@ export default () =>
           inSlot = false
         }
 
-        return elms
+        return {
+          elms,
+          cleanup: () => {
+            rootComponent = null
+            propData = null
+            slotComponent = null
+            component = null
+            parent = null
+
+            cmps[3] = null
+
+            props[4] = null
+            components[4] = null
+
+            cmps[6] = null
+
+            props[7] = null
+            components[7] = null
+
+            cmps[8] = null
+
+            props[9] = null
+            components[9] = null
+
+            cmps[10] = null
+
+            props[11] = null
+            components[11] = null
+
+            cmps[13] = null
+
+            props[14] = null
+            components[14] = null
+
+            cmps[16] = null
+
+            props[17] = null
+            components[17] = null
+
+            cmps[18] = null
+
+            props[19] = null
+            components[19] = null
+
+            cmps[20] = null
+
+            props[21] = null
+            components[21] = null
+
+            cmps[23] = null
+
+            props[24] = null
+            components[24] = null
+
+            cmps[26] = null
+
+            props[27] = null
+            components[27] = null
+
+            cmps[28] = null
+
+            props[29] = null
+            components[29] = null
+
+            cmps[30] = null
+
+            props[31] = null
+            components[31] = null
+
+            cmps[33] = null
+
+            props[34] = null
+            components[34] = null
+
+            cmps[36] = null
+
+            props[37] = null
+            components[37] = null
+
+            cmps[38] = null
+
+            props[39] = null
+            components[39] = null
+
+            cmps[40] = null
+
+            props[41] = null
+            components[41] = null
+            cmps.length = 0
+            elms.length = 0
+            components.length = 0
+            elementConfigs.length = 0
+            forloops.length = 0
+            props.length = 0
+            skips.length = 0
+          },
+        }
       },
       effects: [
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip6 === 'undefined' || skip6.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[6] === 'undefined' ||
+            skips[6].indexOf('frame') === -1
+          )
             elms[6].set('frame', component.fps[0])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[7][Symbol.for('props')]['frame'] = component.fps[0]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip8 === 'undefined' || skip8.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[8] === 'undefined' ||
+            skips[8].indexOf('frame') === -1
+          )
             elms[8].set('frame', component.fps[1])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[9][Symbol.for('props')]['frame'] = component.fps[1]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip10 === 'undefined' || skip10.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[10] === 'undefined' ||
+            skips[10].indexOf('frame') === -1
+          )
             elms[10].set('frame', component.fps[2])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[11][Symbol.for('props')]['frame'] = component.fps[2]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip16 === 'undefined' || skip16.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[16] === 'undefined' ||
+            skips[16].indexOf('frame') === -1
+          )
             elms[16].set('frame', component.avgFps[0])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[17][Symbol.for('props')]['frame'] = component.avgFps[0]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip18 === 'undefined' || skip18.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[18] === 'undefined' ||
+            skips[18].indexOf('frame') === -1
+          )
             elms[18].set('frame', component.avgFps[1])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[19][Symbol.for('props')]['frame'] = component.avgFps[1]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip20 === 'undefined' || skip20.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[20] === 'undefined' ||
+            skips[20].indexOf('frame') === -1
+          )
             elms[20].set('frame', component.avgFps[2])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[21][Symbol.for('props')]['frame'] = component.avgFps[2]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip26 === 'undefined' || skip26.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[26] === 'undefined' ||
+            skips[26].indexOf('frame') === -1
+          )
             elms[26].set('frame', component.minFps[0])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[27][Symbol.for('props')]['frame'] = component.minFps[0]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip28 === 'undefined' || skip28.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[28] === 'undefined' ||
+            skips[28].indexOf('frame') === -1
+          )
             elms[28].set('frame', component.minFps[1])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[29][Symbol.for('props')]['frame'] = component.minFps[1]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip30 === 'undefined' || skip30.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[30] === 'undefined' ||
+            skips[30].indexOf('frame') === -1
+          )
             elms[30].set('frame', component.minFps[2])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[31][Symbol.for('props')]['frame'] = component.minFps[2]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip36 === 'undefined' || skip36.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[36] === 'undefined' ||
+            skips[36].indexOf('frame') === -1
+          )
             elms[36].set('frame', component.maxFps[0])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[37][Symbol.for('props')]['frame'] = component.maxFps[0]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip38 === 'undefined' || skip38.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[38] === 'undefined' ||
+            skips[38].indexOf('frame') === -1
+          )
             elms[38].set('frame', component.maxFps[1])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
           elms[39][Symbol.for('props')]['frame'] = component.maxFps[1]
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {
-          if (typeof skip40 === 'undefined' || skip40.indexOf('frame') === -1)
+          if (
+            typeof skips === 'undefined' ||
+            typeof skips[40] === 'undefined' ||
+            skips[40].indexOf('frame') === -1
+          )
             elms[40].set('frame', component.maxFps[2])
         },
         function anonymous(component, elms, context, components, rootComponent, effect) {