@awesome-flow/ecs 0.9.0 → 0.9.2

package/dist/index.js

@@ -43,72 +43,205 @@ var EcsHandleDataType = /* @__PURE__ */ ((EcsHandleDataType2) => {
 })(EcsHandleDataType || {});
 
 // src/nodes/node-entity.tsx
+import { c as _c9 } from "react/compiler-runtime";
 import { NodeContainer } from "@awesome-flow/core/layout";
 import { Badge as Badge7 } from "@mantine/core";
-import { useContext as useContext3, useMemo as useMemo4 } from "react";
+import { useContext as useContext3 } from "react";
 
 // src/components/formatter-camel-case.tsx
-import { memo, useMemo } from "react";
+import { c as _c } from "react/compiler-runtime";
+import { memo } from "react";
 function CamelCaseFormatter(props) {
-  const value = useMemo(
-    () => props.value?.toString().replace(/([a-z])([A-Z])/g, "$1 $2"),
-    [props.value]
-  );
+  const $ = _c(2);
+  let t0;
+  let t1;
+  if ($[0] !== props.value) {
+    t1 = props.value?.toString().replace(/([a-z])([A-Z])/g, "$1 $2");
+    $[0] = props.value;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  t0 = t1;
+  const value = t0;
   return value;
 }
 var formatter_camel_case_default = memo(CamelCaseFormatter);
 
 // src/layout/entity-layout.tsx
+import { c as _c8 } from "react/compiler-runtime";
 import { Accordion as Accordion4, Badge as Badge6, Divider, Group } from "@mantine/core";
 
 // src/components/entity-component-list.tsx
+import { c as _c4 } from "react/compiler-runtime";
 import { Accordion, Badge, Stack } from "@mantine/core";
 import { memo as memo4 } from "react";
 
 // src/components/entity-component-inspector.tsx
+import { c as _c3 } from "react/compiler-runtime";
 import { Box, Button, Collapse } from "@mantine/core";
 import { useDisclosure } from "@mantine/hooks";
-import { memo as memo3, useMemo as useMemo3 } from "react";
+import { memo as memo3 } from "react";
 
 // src/components/object-inspector.tsx
+import { c as _c2 } from "react/compiler-runtime";
 import { useComputedColorScheme } from "@mantine/core";
-import { memo as memo2, useMemo as useMemo2 } from "react";
+import { memo as memo2 } from "react";
 import { Inspector } from "react-inspector";
 import { jsx } from "react/jsx-runtime";
 function ObjectInspector(props) {
+  const $ = _c2(3);
   const colorScheme = useComputedColorScheme();
-  const theme = useMemo2(
-    () => colorScheme === "dark" ? "chromeDark" : "chromeLight",
-    [colorScheme]
-  );
-  return /* @__PURE__ */ jsx(Inspector, { table: false, theme, data: props.data });
+  let t0;
+  t0 = colorScheme === "dark" ? "chromeDark" : "chromeLight";
+  const theme = t0;
+  let t1;
+  if ($[0] !== props.data || $[1] !== theme) {
+    t1 = /* @__PURE__ */ jsx(Inspector, { table: false, theme, data: props.data });
+    $[0] = props.data;
+    $[1] = theme;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
 }
 var object_inspector_default = memo2(ObjectInspector);
 
 // src/components/entity-component-inspector.tsx
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
 function EntityComponentInspector(props) {
-  const [opened, { toggle }] = useDisclosure(false);
-  const buttonColor = useMemo3(() => opened ? "light" : "indigo", [opened]);
-  return /* @__PURE__ */ jsxs(Box, { children: [
-    /* @__PURE__ */ jsx2(Button, { variant: "outline", size: "xs", onClick: toggle, color: buttonColor, fullWidth: true, children: props.component.componentType }),
-    /* @__PURE__ */ jsx2(Collapse, { in: opened, children: opened && /* @__PURE__ */ jsx2(object_inspector_default, { data: props.component }) })
-  ] });
+  const $ = _c3(13);
+  const [opened, t0] = useDisclosure(false);
+  const {
+    toggle
+  } = t0;
+  let t1;
+  t1 = opened ? "light" : "indigo";
+  const buttonColor = t1;
+  let t2;
+  if ($[0] !== buttonColor || $[1] !== props.component.componentType || $[2] !== toggle) {
+    t2 = /* @__PURE__ */ jsx2(Button, { variant: "outline", size: "xs", onClick: toggle, color: buttonColor, fullWidth: true, children: props.component.componentType });
+    $[0] = buttonColor;
+    $[1] = props.component.componentType;
+    $[2] = toggle;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  let t3;
+  if ($[4] !== opened || $[5] !== props.component) {
+    t3 = opened && /* @__PURE__ */ jsx2(object_inspector_default, { data: props.component });
+    $[4] = opened;
+    $[5] = props.component;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== opened || $[8] !== t3) {
+    t4 = /* @__PURE__ */ jsx2(Collapse, { in: opened, children: t3 });
+    $[7] = opened;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] !== t2 || $[11] !== t4) {
+    t5 = /* @__PURE__ */ jsxs(Box, { children: [
+      t2,
+      t4
+    ] });
+    $[10] = t2;
+    $[11] = t4;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  return t5;
 }
 var entity_component_inspector_default = memo3(EntityComponentInspector);
 
 // src/components/entity-component-list.tsx
 import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 function EntityComponentList(props) {
-  const components = Array.from(props.entity.components.values());
-  return /* @__PURE__ */ jsxs2(Accordion.Item, { value: "components", children: [
-    /* @__PURE__ */ jsx3(Accordion.Control, { children: /* @__PURE__ */ jsx3(Badge, { fullWidth: true, variant: "light", rightSection: components.length, children: "Components" }) }),
-    /* @__PURE__ */ jsx3(Accordion.Panel, { children: /* @__PURE__ */ jsx3(Stack, { children: components.map((c, i) => /* @__PURE__ */ jsx3(entity_component_inspector_default, { component: c }, i)) }) })
-  ] }, "components");
+  const $ = _c4(20);
+  let T0;
+  let T1;
+  let T2;
+  let t0;
+  let t1;
+  let t2;
+  let t3;
+  if ($[0] !== props.entity.components) {
+    const components = Array.from(props.entity.components.values());
+    T2 = Accordion.Item;
+    t1 = "components";
+    t2 = "components";
+    t3 = /* @__PURE__ */ jsx3(Accordion.Control, { children: /* @__PURE__ */ jsx3(Badge, { fullWidth: true, variant: "light", rightSection: components.length, children: "Components" }) });
+    T1 = Accordion.Panel;
+    T0 = Stack;
+    t0 = components.map(_temp);
+    $[0] = props.entity.components;
+    $[1] = T0;
+    $[2] = T1;
+    $[3] = T2;
+    $[4] = t0;
+    $[5] = t1;
+    $[6] = t2;
+    $[7] = t3;
+  } else {
+    T0 = $[1];
+    T1 = $[2];
+    T2 = $[3];
+    t0 = $[4];
+    t1 = $[5];
+    t2 = $[6];
+    t3 = $[7];
+  }
+  let t4;
+  if ($[8] !== T0 || $[9] !== t0) {
+    t4 = /* @__PURE__ */ jsx3(T0, { children: t0 });
+    $[8] = T0;
+    $[9] = t0;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  let t5;
+  if ($[11] !== T1 || $[12] !== t4) {
+    t5 = /* @__PURE__ */ jsx3(T1, { children: t4 });
+    $[11] = T1;
+    $[12] = t4;
+    $[13] = t5;
+  } else {
+    t5 = $[13];
+  }
+  let t6;
+  if ($[14] !== T2 || $[15] !== t1 || $[16] !== t2 || $[17] !== t3 || $[18] !== t5) {
+    t6 = /* @__PURE__ */ jsxs2(T2, { value: t2, children: [
+      t3,
+      t5
+    ] }, t1);
+    $[14] = T2;
+    $[15] = t1;
+    $[16] = t2;
+    $[17] = t3;
+    $[18] = t5;
+    $[19] = t6;
+  } else {
+    t6 = $[19];
+  }
+  return t6;
+}
+function _temp(c, i) {
+  return /* @__PURE__ */ jsx3(entity_component_inspector_default, { component: c }, i);
 }
 var entity_component_list_default = memo4(EntityComponentList);
 
 // src/components/entity-proxy-list.tsx
+import { c as _c5 } from "react/compiler-runtime";
 import { Accordion as Accordion2, Badge as Badge3, Stack as Stack2 } from "@mantine/core";
 import { memo as memo6 } from "react";
 
@@ -126,163 +259,594 @@ var badge_list_default = memo5(BadgeList);
 // src/components/entity-proxy-list.tsx
 import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 function EntityProxyList(props) {
-  const proxies = Array.from(props.entity.proxies.values()).map((c) => c.values());
-  const items = proxies.map((p) => Array.from(p).map((k) => EcsIdGenerator.entityProxy(k))).flat();
-  return /* @__PURE__ */ jsxs3(Accordion2.Item, { value: "proxies", children: [
-    /* @__PURE__ */ jsx5(Accordion2.Control, { children: /* @__PURE__ */ jsx5(Badge3, { fullWidth: true, variant: "light", rightSection: items.length, children: "Proxies" }) }),
-    /* @__PURE__ */ jsx5(Accordion2.Panel, { children: /* @__PURE__ */ jsx5(Stack2, { children: /* @__PURE__ */ jsx5(badge_list_default, { items, badge: { variant: "outline" } }) }) })
-  ] }, "proxies");
+  const $ = _c5(10);
+  let t0;
+  if ($[0] !== props.entity.proxies) {
+    const proxies = Array.from(props.entity.proxies.values()).map(_temp4);
+    t0 = proxies.map(_temp3).flat();
+    $[0] = props.entity.proxies;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const items = t0;
+  let t1;
+  if ($[2] !== items.length) {
+    t1 = /* @__PURE__ */ jsx5(Accordion2.Control, { children: /* @__PURE__ */ jsx5(Badge3, { fullWidth: true, variant: "light", rightSection: items.length, children: "Proxies" }) });
+    $[2] = items.length;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  let t2;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = {
+      variant: "outline"
+    };
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] !== items) {
+    t3 = /* @__PURE__ */ jsx5(Accordion2.Panel, { children: /* @__PURE__ */ jsx5(Stack2, { children: /* @__PURE__ */ jsx5(badge_list_default, { items, badge: t2 }) }) });
+    $[5] = items;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== t1 || $[8] !== t3) {
+    t4 = /* @__PURE__ */ jsxs3(Accordion2.Item, { value: "proxies", children: [
+      t1,
+      t3
+    ] }, "proxies");
+    $[7] = t1;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  return t4;
+}
+function _temp3(p) {
+  return Array.from(p).map(_temp2);
+}
+function _temp2(k) {
+  return EcsIdGenerator.entityProxy(k);
+}
+function _temp4(c) {
+  return c.values();
 }
 var entity_proxy_list_default = memo6(EntityProxyList);
 
 // src/components/entity-subscription-list.tsx
+import { c as _c6 } from "react/compiler-runtime";
 import { Accordion as Accordion3, Badge as Badge4, Stack as Stack3 } from "@mantine/core";
 import { memo as memo7, useContext } from "react";
 import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
 function EntitySubscriptionList(props) {
-  const { entityEventsManager } = useContext(EcsFlowContext);
-  const subscriptions = entityEventsManager.getSubscriptionsForEntity(props.entity.myProxy);
-  return /* @__PURE__ */ jsxs4(Accordion3.Item, { value: "subscriptions", children: [
-    /* @__PURE__ */ jsx6(Accordion3.Control, { children: /* @__PURE__ */ jsx6(Badge4, { fullWidth: true, variant: "light", rightSection: subscriptions.length, children: "Events" }) }),
-    /* @__PURE__ */ jsx6(Accordion3.Panel, { children: /* @__PURE__ */ jsx6(Stack3, { children: /* @__PURE__ */ jsx6(badge_list_default, { items: subscriptions, badge: { variant: "outline" } }) }) })
-  ] }, "subscriptions");
+  const $ = _c6(11);
+  const {
+    entityEventsManager
+  } = useContext(EcsFlowContext);
+  let t0;
+  if ($[0] !== entityEventsManager || $[1] !== props.entity.myProxy) {
+    t0 = entityEventsManager.getSubscriptionsForEntity(props.entity.myProxy);
+    $[0] = entityEventsManager;
+    $[1] = props.entity.myProxy;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const subscriptions = t0;
+  let t1;
+  if ($[3] !== subscriptions.length) {
+    t1 = /* @__PURE__ */ jsx6(Accordion3.Control, { children: /* @__PURE__ */ jsx6(Badge4, { fullWidth: true, variant: "light", rightSection: subscriptions.length, children: "Events" }) });
+    $[3] = subscriptions.length;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  let t2;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = {
+      variant: "outline"
+    };
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== subscriptions) {
+    t3 = /* @__PURE__ */ jsx6(Accordion3.Panel, { children: /* @__PURE__ */ jsx6(Stack3, { children: /* @__PURE__ */ jsx6(badge_list_default, { items: subscriptions, badge: t2 }) }) });
+    $[6] = subscriptions;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  let t4;
+  if ($[8] !== t1 || $[9] !== t3) {
+    t4 = /* @__PURE__ */ jsxs4(Accordion3.Item, { value: "subscriptions", children: [
+      t1,
+      t3
+    ] }, "subscriptions");
+    $[8] = t1;
+    $[9] = t3;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  return t4;
 }
 var entity_subscription_list_default = memo7(EntitySubscriptionList);
 
 // src/components/entity-update-counter.tsx
+import { c as _c7 } from "react/compiler-runtime";
 import { Badge as Badge5 } from "@mantine/core";
 import { memo as memo8, useContext as useContext2, useEffect, useState } from "react";
 import { Fragment, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 function EntityUpdateCounter(props) {
+  const $ = _c7(16);
   const [, setRefresh] = useState(0);
-  const { entityUpdateCounter } = useContext2(EcsFlowContext);
-  const updates = entityUpdateCounter.getUpdateCount(props.entityUid) || 0;
-  const removes = entityUpdateCounter.getRemoveCount(props.entityUid) || 0;
-  useEffect(() => {
-    const interval = setInterval(() => {
-      setRefresh((refresh) => refresh + 1);
-    }, 1e3);
-    return () => {
-      console.log("CLEAR INTERVAL");
-      clearInterval(interval);
+  const {
+    entityUpdateCounter
+  } = useContext2(EcsFlowContext);
+  let t0;
+  if ($[0] !== entityUpdateCounter || $[1] !== props.entityUid) {
+    t0 = entityUpdateCounter.getUpdateCount(props.entityUid) || 0;
+    $[0] = entityUpdateCounter;
+    $[1] = props.entityUid;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const updates = t0;
+  let t1;
+  if ($[3] !== entityUpdateCounter || $[4] !== props.entityUid) {
+    t1 = entityUpdateCounter.getRemoveCount(props.entityUid) || 0;
+    $[3] = entityUpdateCounter;
+    $[4] = props.entityUid;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const removes = t1;
+  let t2;
+  if ($[6] !== setRefresh) {
+    t2 = () => {
+      const interval = setInterval(() => {
+        setRefresh(_temp5);
+      }, 1e3);
+      return () => {
+        console.log("CLEAR INTERVAL");
+        clearInterval(interval);
+      };
     };
-  }, []);
-  return /* @__PURE__ */ jsxs5(Fragment, { children: [
-    /* @__PURE__ */ jsx7(Badge5, { variant: "light", children: updates }),
-    /* @__PURE__ */ jsx7(Badge5, { variant: "light", color: "orange", children: removes })
-  ] });
+    $[6] = setRefresh;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  let t3;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = [];
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  useEffect(t2, t3);
+  let t4;
+  if ($[9] !== updates) {
+    t4 = /* @__PURE__ */ jsx7(Badge5, { variant: "light", children: updates });
+    $[9] = updates;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  let t5;
+  if ($[11] !== removes) {
+    t5 = /* @__PURE__ */ jsx7(Badge5, { variant: "light", color: "orange", children: removes });
+    $[11] = removes;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  let t6;
+  if ($[13] !== t4 || $[14] !== t5) {
+    t6 = /* @__PURE__ */ jsxs5(Fragment, { children: [
+      t4,
+      t5
+    ] });
+    $[13] = t4;
+    $[14] = t5;
+    $[15] = t6;
+  } else {
+    t6 = $[15];
+  }
+  return t6;
+}
+function _temp5(refresh) {
+  return refresh + 1;
 }
 var entity_update_counter_default = memo8(EntityUpdateCounter);
 
 // src/layout/entity-layout.tsx
 import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
-function EntityLayout({ entity }) {
-  return /* @__PURE__ */ jsxs6(Fragment2, { children: [
-    /* @__PURE__ */ jsxs6(Group, { children: [
+function EntityLayout(t0) {
+  const $ = _c8(8);
+  const {
+    entity
+  } = t0;
+  let t1;
+  if ($[0] !== entity.myProxy.entityUid) {
+    t1 = /* @__PURE__ */ jsxs6(Group, { children: [
       /* @__PURE__ */ jsx8(Badge6, { variant: "outline", color: "orange", children: entity.myProxy.entityUid }),
       /* @__PURE__ */ jsx8(entity_update_counter_default, { entityUid: entity.myProxy.entityUid })
-    ] }),
-    /* @__PURE__ */ jsx8(Divider, { my: 5 }),
-    /* @__PURE__ */ jsxs6(Accordion4, { children: [
+    ] });
+    $[0] = entity.myProxy.entityUid;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = /* @__PURE__ */ jsx8(Divider, { my: 5 });
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  let t3;
+  if ($[3] !== entity) {
+    t3 = /* @__PURE__ */ jsxs6(Accordion4, { children: [
       /* @__PURE__ */ jsx8(entity_component_list_default, { entity }),
       /* @__PURE__ */ jsx8(entity_proxy_list_default, { entity }),
       /* @__PURE__ */ jsx8(entity_subscription_list_default, { entity })
-    ] })
-  ] });
+    ] });
+    $[3] = entity;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== t1 || $[6] !== t3) {
+    t4 = /* @__PURE__ */ jsxs6(Fragment2, { children: [
+      t1,
+      t2,
+      t3
+    ] });
+    $[5] = t1;
+    $[6] = t3;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  return t4;
 }
 var entity_layout_default = EntityLayout;
 
 // src/nodes/node-entity.tsx
 import { jsx as jsx9 } from "react/jsx-runtime";
-function EntityNode({ id, data, selected, type }) {
-  const { entityRepository } = useContext3(EcsFlowContext);
-  const entity = useMemo4(() => entityRepository.get(data.entity), [data.entity]);
-  return /* @__PURE__ */ jsx9(
-    NodeContainer,
-    {
-      id,
-      selected,
-      data,
-      title: /* @__PURE__ */ jsx9(Badge7, { fullWidth: true, variant: "transparent", children: /* @__PURE__ */ jsx9(formatter_camel_case_default, { value: entity.myProxy.entityType }) }),
-      type,
-      children: /* @__PURE__ */ jsx9(entity_layout_default, { entity })
-    }
-  );
+function EntityNode(t0) {
+  const $ = _c9(14);
+  const {
+    id,
+    data,
+    selected,
+    type
+  } = t0;
+  const {
+    entityRepository
+  } = useContext3(EcsFlowContext);
+  let t1;
+  let t2;
+  if ($[0] !== data.entity || $[1] !== entityRepository) {
+    t2 = entityRepository.get(data.entity);
+    $[0] = data.entity;
+    $[1] = entityRepository;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  t1 = t2;
+  const entity = t1;
+  let t3;
+  if ($[3] !== entity.myProxy.entityType) {
+    t3 = /* @__PURE__ */ jsx9(Badge7, { fullWidth: true, variant: "transparent", children: /* @__PURE__ */ jsx9(formatter_camel_case_default, { value: entity.myProxy.entityType }) });
+    $[3] = entity.myProxy.entityType;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== entity) {
+    t4 = /* @__PURE__ */ jsx9(entity_layout_default, { entity });
+    $[5] = entity;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] !== data || $[8] !== id || $[9] !== selected || $[10] !== t3 || $[11] !== t4 || $[12] !== type) {
+    t5 = /* @__PURE__ */ jsx9(NodeContainer, { id, selected, data, title: t3, type, children: t4 });
+    $[7] = data;
+    $[8] = id;
+    $[9] = selected;
+    $[10] = t3;
+    $[11] = t4;
+    $[12] = type;
+    $[13] = t5;
+  } else {
+    t5 = $[13];
+  }
+  return t5;
 }
 var node_entity_default = EntityNode;
 
 // src/nodes/node-systems-module.tsx
+import { c as _c12 } from "react/compiler-runtime";
 import { NodeContainer as NodeContainer2 } from "@awesome-flow/core/layout";
 import { Badge as Badge9 } from "@mantine/core";
 import { useContext as useContext4 } from "react";
 
 // src/layout/systems-module-layout.tsx
+import { c as _c11 } from "react/compiler-runtime";
 import { SystemType } from "@awesome-ecs/abstract/systems";
 import { Accordion as Accordion6, Text } from "@mantine/core";
-import { useMemo as useMemo5 } from "react";
 
 // src/components/pipeline-middleware-list.tsx
+import { c as _c10 } from "react/compiler-runtime";
 import { Accordion as Accordion5, Badge as Badge8, Stack as Stack4 } from "@mantine/core";
 import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
 function PipelineMiddlewareList(props) {
-  let middleware = [];
+  const $ = _c10(13);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  let middleware = t0;
   if (props.pipeline) {
-    middleware = props.pipeline["middleware"];
+    middleware = props.pipeline.middleware;
   }
-  const components = middleware.map((m) => {
-    return m.name || m.constructor.name;
-  });
-  return /* @__PURE__ */ jsxs7(Accordion5.Item, { value: props.label, children: [
-    /* @__PURE__ */ jsx10(Accordion5.Control, { children: /* @__PURE__ */ jsx10(Badge8, { fullWidth: true, variant: "light", rightSection: components.length, children: props.label }) }),
-    /* @__PURE__ */ jsx10(Accordion5.Panel, { children: /* @__PURE__ */ jsx10(Stack4, { children: /* @__PURE__ */ jsx10(badge_list_default, { items: components, badge: { variant: "outline" } }) }) })
-  ] }, props.label);
+  let t1;
+  if ($[1] !== middleware) {
+    t1 = middleware.map(_temp6);
+    $[1] = middleware;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const components = t1;
+  let t2;
+  if ($[3] !== components.length || $[4] !== props.label) {
+    t2 = /* @__PURE__ */ jsx10(Accordion5.Control, { children: /* @__PURE__ */ jsx10(Badge8, { fullWidth: true, variant: "light", rightSection: components.length, children: props.label }) });
+    $[3] = components.length;
+    $[4] = props.label;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = {
+      variant: "outline"
+    };
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== components) {
+    t4 = /* @__PURE__ */ jsx10(Accordion5.Panel, { children: /* @__PURE__ */ jsx10(Stack4, { children: /* @__PURE__ */ jsx10(badge_list_default, { items: components, badge: t3 }) }) });
+    $[7] = components;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  let t5;
+  if ($[9] !== props.label || $[10] !== t2 || $[11] !== t4) {
+    t5 = /* @__PURE__ */ jsxs7(Accordion5.Item, { value: props.label, children: [
+      t2,
+      t4
+    ] }, props.label);
+    $[9] = props.label;
+    $[10] = t2;
+    $[11] = t4;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  return t5;
+}
+function _temp6(m) {
+  return m.name || m.constructor.name;
 }
 var pipeline_middleware_list_default = PipelineMiddlewareList;
 
 // src/layout/systems-module-layout.tsx
 import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
 function SystemsModuleLayout(props) {
-  const { module } = props;
-  const runtimeContext = module["runtimeContext"];
-  const { systemContext } = runtimeContext;
-  const { status } = useMemo5(() => {
-    return systemContext.runtime;
-  }, [systemContext.runtime.status]);
-  const init = runtimeContext.systemPipelines.get(SystemType.initialize);
-  const update = runtimeContext.systemPipelines.get(SystemType.update);
-  const render = runtimeContext.systemPipelines.get(SystemType.render);
-  const sync = runtimeContext.systemPipelines.get(SystemType.sync);
-  return /* @__PURE__ */ jsxs8(Fragment3, { children: [
-    /* @__PURE__ */ jsxs8(Text, { children: [
+  const $ = _c11(26);
+  const {
+    module
+  } = props;
+  const runtimeContext = module.runtimeContext;
+  const {
+    systemContext
+  } = runtimeContext;
+  let t0;
+  t0 = systemContext.runtime;
+  const {
+    status
+  } = t0;
+  let t1;
+  if ($[0] !== runtimeContext.systemPipelines) {
+    t1 = runtimeContext.systemPipelines.get(SystemType.initialize);
+    $[0] = runtimeContext.systemPipelines;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const init = t1;
+  let t2;
+  if ($[2] !== runtimeContext.systemPipelines) {
+    t2 = runtimeContext.systemPipelines.get(SystemType.update);
+    $[2] = runtimeContext.systemPipelines;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const update = t2;
+  let t3;
+  if ($[4] !== runtimeContext.systemPipelines) {
+    t3 = runtimeContext.systemPipelines.get(SystemType.render);
+    $[4] = runtimeContext.systemPipelines;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const render = t3;
+  let t4;
+  if ($[6] !== runtimeContext.systemPipelines) {
+    t4 = runtimeContext.systemPipelines.get(SystemType.sync);
+    $[6] = runtimeContext.systemPipelines;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const sync = t4;
+  let t5;
+  if ($[8] !== status) {
+    t5 = /* @__PURE__ */ jsxs8(Text, { children: [
       "Status: ",
       status
-    ] }),
-    /* @__PURE__ */ jsxs8(Accordion6, { children: [
-      init && /* @__PURE__ */ jsx11(pipeline_middleware_list_default, { pipeline: init, label: "Initialize" }),
-      update && /* @__PURE__ */ jsx11(pipeline_middleware_list_default, { pipeline: update, label: "Update" }),
-      render && /* @__PURE__ */ jsx11(pipeline_middleware_list_default, { pipeline: render, label: "Render" }),
-      sync && /* @__PURE__ */ jsx11(pipeline_middleware_list_default, { pipeline: sync, label: "Sync" })
-    ] })
-  ] });
+    ] });
+    $[8] = status;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  let t6;
+  if ($[10] !== init) {
+    t6 = init && /* @__PURE__ */ jsx11(pipeline_middleware_list_default, { pipeline: init, label: "Initialize" });
+    $[10] = init;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  let t7;
+  if ($[12] !== update) {
+    t7 = update && /* @__PURE__ */ jsx11(pipeline_middleware_list_default, { pipeline: update, label: "Update" });
+    $[12] = update;
+    $[13] = t7;
+  } else {
+    t7 = $[13];
+  }
+  let t8;
+  if ($[14] !== render) {
+    t8 = render && /* @__PURE__ */ jsx11(pipeline_middleware_list_default, { pipeline: render, label: "Render" });
+    $[14] = render;
+    $[15] = t8;
+  } else {
+    t8 = $[15];
+  }
+  let t9;
+  if ($[16] !== sync) {
+    t9 = sync && /* @__PURE__ */ jsx11(pipeline_middleware_list_default, { pipeline: sync, label: "Sync" });
+    $[16] = sync;
+    $[17] = t9;
+  } else {
+    t9 = $[17];
+  }
+  let t10;
+  if ($[18] !== t6 || $[19] !== t7 || $[20] !== t8 || $[21] !== t9) {
+    t10 = /* @__PURE__ */ jsxs8(Accordion6, { children: [
+      t6,
+      t7,
+      t8,
+      t9
+    ] });
+    $[18] = t6;
+    $[19] = t7;
+    $[20] = t8;
+    $[21] = t9;
+    $[22] = t10;
+  } else {
+    t10 = $[22];
+  }
+  let t11;
+  if ($[23] !== t10 || $[24] !== t5) {
+    t11 = /* @__PURE__ */ jsxs8(Fragment3, { children: [
+      t5,
+      t10
+    ] });
+    $[23] = t10;
+    $[24] = t5;
+    $[25] = t11;
+  } else {
+    t11 = $[25];
+  }
+  return t11;
 }
 var systems_module_layout_default = SystemsModuleLayout;
 
 // src/nodes/node-systems-module.tsx
 import { jsx as jsx12 } from "react/jsx-runtime";
-function SystemsModuleNode({ id, data, selected, type }) {
-  const { systemsModuleRepository } = useContext4(EcsFlowContext);
-  const module = systemsModuleRepository.get(data.entityType);
-  return /* @__PURE__ */ jsx12(
-    NodeContainer2,
-    {
-      id,
-      selected,
-      data,
-      title: /* @__PURE__ */ jsx12(Badge9, { fullWidth: true, color: "indigo", variant: "transparent", children: /* @__PURE__ */ jsx12(formatter_camel_case_default, { value: data.entityType }) }),
-      type,
-      children: /* @__PURE__ */ jsx12(systems_module_layout_default, { type: data.entityType, module })
-    }
-  );
+function SystemsModuleNode(t0) {
+  const $ = _c12(15);
+  const {
+    id,
+    data,
+    selected,
+    type
+  } = t0;
+  const {
+    systemsModuleRepository
+  } = useContext4(EcsFlowContext);
+  let t1;
+  if ($[0] !== data.entityType || $[1] !== systemsModuleRepository) {
+    t1 = systemsModuleRepository.get(data.entityType);
+    $[0] = data.entityType;
+    $[1] = systemsModuleRepository;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const module = t1;
+  let t2;
+  if ($[3] !== data.entityType) {
+    t2 = /* @__PURE__ */ jsx12(Badge9, { fullWidth: true, color: "indigo", variant: "transparent", children: /* @__PURE__ */ jsx12(formatter_camel_case_default, { value: data.entityType }) });
+    $[3] = data.entityType;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] !== data.entityType || $[6] !== module) {
+    t3 = /* @__PURE__ */ jsx12(systems_module_layout_default, { type: data.entityType, module });
+    $[5] = data.entityType;
+    $[6] = module;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  let t4;
+  if ($[8] !== data || $[9] !== id || $[10] !== selected || $[11] !== t2 || $[12] !== t3 || $[13] !== type) {
+    t4 = /* @__PURE__ */ jsx12(NodeContainer2, { id, selected, data, title: t2, type, children: t3 });
+    $[8] = data;
+    $[9] = id;
+    $[10] = selected;
+    $[11] = t2;
+    $[12] = t3;
+    $[13] = type;
+    $[14] = t4;
+  } else {
+    t4 = $[14];
+  }
+  return t4;
 }
 var node_systems_module_default = SystemsModuleNode;
 
@@ -358,154 +922,386 @@ var ecsNodeTemplates = {
 };
 
 // src/flow/flow-ecs-state.tsx
+import { c as _c17 } from "react/compiler-runtime";
 import { FlowAutoLayout } from "@awesome-flow/core/canvas";
 import { memo as memo9, useContext as useContext9, useEffect as useEffect6, useState as useState3 } from "react";
 
 // src/flow/flow-ecs-entities.tsx
+import { c as _c15 } from "react/compiler-runtime";
 import { FlowContext } from "@awesome-flow/core/abstract";
 import { useFlowStore as useFlowStore3 } from "@awesome-flow/core/hooks";
 import { useContext as useContext7, useEffect as useEffect4, useState as useState2 } from "react";
 
 // src/flow/flow-ecs-edge-modules.tsx
+import { c as _c13 } from "react/compiler-runtime";
 import { useFlowStore } from "@awesome-flow/core/hooks";
 import { useContext as useContext5, useEffect as useEffect2 } from "react";
 import { Fragment as Fragment4, jsx as jsx13 } from "react/jsx-runtime";
 function FlowEcsEdgeModules(props) {
-  const { nodesToConnect } = props;
-  const onConnect = useFlowStore((state) => state.onConnect);
-  const { ecsFlowRepository, entityRepository } = useContext5(EcsFlowContext);
-  useEffect2(() => {
-    for (const node of nodesToConnect) {
-      const sourceHandle = node.data.handles.find((h) => h.connection === "source");
-      const entity = entityRepository.get(node.data.entity);
-      const systemModule = ecsFlowRepository.getSystemModuleNode(entity.myProxy.entityType);
-      const targetHandle = systemModule?.data.handles.find((h) => h.connection === "target");
-      if (targetHandle) {
-        onConnect({
-          source: node.id,
-          target: systemModule.id,
-          sourceHandle: sourceHandle.id,
-          targetHandle: targetHandle.id
-        });
+  const $ = _c13(7);
+  const {
+    nodesToConnect
+  } = props;
+  const onConnect = useFlowStore(_temp7);
+  const {
+    ecsFlowRepository,
+    entityRepository
+  } = useContext5(EcsFlowContext);
+  let t0;
+  let t1;
+  if ($[0] !== ecsFlowRepository || $[1] !== entityRepository || $[2] !== nodesToConnect || $[3] !== onConnect) {
+    t0 = () => {
+      for (const node of nodesToConnect) {
+        const sourceHandle = node.data.handles.find(_temp22);
+        const entity = entityRepository.get(node.data.entity);
+        const systemModule = ecsFlowRepository.getSystemModuleNode(entity.myProxy.entityType);
+        const targetHandle = systemModule?.data.handles.find(_temp32);
+        if (targetHandle) {
+          onConnect({
+            source: node.id,
+            target: systemModule.id,
+            sourceHandle: sourceHandle.handleId,
+            targetHandle: targetHandle.handleId
+          });
+        }
       }
-    }
-  }, [nodesToConnect]);
-  return /* @__PURE__ */ jsx13(Fragment4, {});
+    };
+    t1 = [nodesToConnect, ecsFlowRepository, entityRepository, onConnect];
+    $[0] = ecsFlowRepository;
+    $[1] = entityRepository;
+    $[2] = nodesToConnect;
+    $[3] = onConnect;
+    $[4] = t0;
+    $[5] = t1;
+  } else {
+    t0 = $[4];
+    t1 = $[5];
+  }
+  useEffect2(t0, t1);
+  let t2;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = /* @__PURE__ */ jsx13(Fragment4, {});
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  return t2;
+}
+function _temp32(h_0) {
+  return h_0.connection === "target";
+}
+function _temp22(h) {
+  return h.connection === "source";
+}
+function _temp7(state) {
+  return state.onConnect;
 }
 var flow_ecs_edge_modules_default = FlowEcsEdgeModules;
 
 // src/flow/flow-ecs-edge-proxies.tsx
+import { c as _c14 } from "react/compiler-runtime";
 import { useFlowStore as useFlowStore2 } from "@awesome-flow/core/hooks";
 import { useContext as useContext6, useEffect as useEffect3 } from "react";
 import { Fragment as Fragment5, jsx as jsx14 } from "react/jsx-runtime";
 function FlowEcsEdgeProxies(props) {
-  const { nodesToConnect } = props;
-  const onConnect = useFlowStore2((state) => state.onConnect);
-  const { ecsFlowRepository, entityRepository } = useContext6(EcsFlowContext);
-  useEffect3(() => {
-    for (const node of nodesToConnect) {
-      const sourceHandle = node.data.handles.find((h) => h.connection === "source");
-      const entity = entityRepository.get(node.data.entity);
-      for (const [, proxyMap] of entity.proxies) {
-        for (const proxy of proxyMap.values()) {
-          const proxyNode = ecsFlowRepository.getEntityNode(proxy);
-          if (proxyNode) {
-            const targetHandle = proxyNode.data.handles.find((h) => h.connection === "target");
-            onConnect({
-              source: node.id,
-              target: proxyNode.id,
-              sourceHandle: sourceHandle.id,
-              targetHandle: targetHandle.id
-            });
+  const $ = _c14(7);
+  const {
+    nodesToConnect
+  } = props;
+  const onConnect = useFlowStore2(_temp8);
+  const {
+    ecsFlowRepository,
+    entityRepository
+  } = useContext6(EcsFlowContext);
+  let t0;
+  let t1;
+  if ($[0] !== ecsFlowRepository || $[1] !== entityRepository || $[2] !== nodesToConnect || $[3] !== onConnect) {
+    t0 = () => {
+      for (const node of nodesToConnect) {
+        const sourceHandle = node.data.handles.find(_temp23);
+        const entity = entityRepository.get(node.data.entity);
+        for (const [, proxyMap] of entity.proxies) {
+          for (const proxy of proxyMap.values()) {
+            const proxyNode = ecsFlowRepository.getEntityNode(proxy);
+            if (proxyNode) {
+              const targetHandle = proxyNode.data.handles.find(_temp33);
+              onConnect({
+                source: node.id,
+                target: proxyNode.id,
+                sourceHandle: sourceHandle.handleId,
+                targetHandle: targetHandle.handleId
+              });
+            }
           }
         }
       }
-    }
-  }, [nodesToConnect]);
-  return /* @__PURE__ */ jsx14(Fragment5, {});
+    };
+    t1 = [nodesToConnect, ecsFlowRepository, entityRepository, onConnect];
+    $[0] = ecsFlowRepository;
+    $[1] = entityRepository;
+    $[2] = nodesToConnect;
+    $[3] = onConnect;
+    $[4] = t0;
+    $[5] = t1;
+  } else {
+    t0 = $[4];
+    t1 = $[5];
+  }
+  useEffect3(t0, t1);
+  let t2;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = /* @__PURE__ */ jsx14(Fragment5, {});
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  return t2;
+}
+function _temp33(h_0) {
+  return h_0.connection === "target";
+}
+function _temp23(h) {
+  return h.connection === "source";
+}
+function _temp8(state) {
+  return state.onConnect;
 }
 var flow_ecs_edge_proxies_default = FlowEcsEdgeProxies;
 
 // src/flow/flow-ecs-entities.tsx
 import { Fragment as Fragment6, jsx as jsx15, jsxs as jsxs9 } from "react/jsx-runtime";
 function FlowEcsEntities() {
-  const { nodeFactory } = useContext7(FlowContext);
-  const addNodes = useFlowStore3((state) => state.addNodes);
-  const { ecsFlowRepository, entityRepository } = useContext7(EcsFlowContext);
-  const [entityNodes, setEntityNodes] = useState2([]);
-  useEffect4(() => {
-    const entities = entityRepository.listAll();
-    const nodes = [];
-    for (const entity of entities) {
-      if (ecsFlowRepository.getEntityNode(entity.myProxy)) {
-        continue;
+  const $ = _c15(9);
+  const {
+    nodeFactory
+  } = useContext7(FlowContext);
+  const addNodes = useFlowStore3(_temp9);
+  const {
+    ecsFlowRepository,
+    entityRepository
+  } = useContext7(EcsFlowContext);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const [entityNodes, setEntityNodes] = useState2(t0);
+  let t1;
+  let t2;
+  if ($[1] !== addNodes || $[2] !== ecsFlowRepository || $[3] !== entityRepository || $[4] !== nodeFactory) {
+    t1 = () => {
+      const entities = entityRepository.listAll();
+      const nodes = [];
+      for (const entity of entities) {
+        if (ecsFlowRepository.getEntityNode(entity.myProxy)) {
+          continue;
+        }
+        const node = nodeFactory.createNodeFromType("entity-node" /* entity */);
+        node.data.entity = entity.myProxy;
+        node.position = {
+          x: 0,
+          y: 0
+        };
+        ecsFlowRepository.addEntityNode(node);
+        nodes.push(node);
       }
-      const node = nodeFactory.createNodeFromType("entity-node" /* entity */);
-      node.data.entity = entity.myProxy;
-      node.position = { x: 0, y: 0 };
-      ecsFlowRepository.addEntityNode(node);
-      nodes.push(node);
-    }
-    setEntityNodes(nodes);
-    addNodes(nodes);
-  }, [entityRepository.size]);
-  return /* @__PURE__ */ jsxs9(Fragment6, { children: [
-    /* @__PURE__ */ jsx15(flow_ecs_edge_proxies_default, { nodesToConnect: entityNodes }),
-    /* @__PURE__ */ jsx15(flow_ecs_edge_modules_default, { nodesToConnect: entityNodes })
-  ] });
+      setEntityNodes(nodes);
+      addNodes(nodes);
+    };
+    t2 = [entityRepository, entityRepository.size, ecsFlowRepository, nodeFactory, addNodes];
+    $[1] = addNodes;
+    $[2] = ecsFlowRepository;
+    $[3] = entityRepository;
+    $[4] = nodeFactory;
+    $[5] = t1;
+    $[6] = t2;
+  } else {
+    t1 = $[5];
+    t2 = $[6];
+  }
+  useEffect4(t1, t2);
+  let t3;
+  if ($[7] !== entityNodes) {
+    t3 = /* @__PURE__ */ jsxs9(Fragment6, { children: [
+      /* @__PURE__ */ jsx15(flow_ecs_edge_proxies_default, { nodesToConnect: entityNodes }),
+      /* @__PURE__ */ jsx15(flow_ecs_edge_modules_default, { nodesToConnect: entityNodes })
+    ] });
+    $[7] = entityNodes;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  return t3;
+}
+function _temp9(state) {
+  return state.addNodes;
 }
 var flow_ecs_entities_default = FlowEcsEntities;
 
 // src/flow/flow-ecs-modules.tsx
+import { c as _c16 } from "react/compiler-runtime";
 import { FlowContext as FlowContext2 } from "@awesome-flow/core/abstract";
 import { useFlowStore as useFlowStore4 } from "@awesome-flow/core/hooks";
 import { useContext as useContext8, useEffect as useEffect5 } from "react";
 import { Fragment as Fragment7, jsx as jsx16 } from "react/jsx-runtime";
 function FlowEcsModules() {
-  const { nodeFactory } = useContext8(FlowContext2);
-  const addNodes = useFlowStore4((state) => state.addNodes);
-  const { ecsFlowRepository, systemsModuleRepository } = useContext8(EcsFlowContext);
-  useEffect5(() => {
-    const modules = Array.from(systemsModuleRepository.list()).filter((m) => !!m);
-    const keys = Array.from(modules.values()).map((v) => v[0]);
-    const nodesToAdd = [];
-    for (const element of keys) {
-      if (ecsFlowRepository.getSystemModuleNode(element)) {
-        continue;
+  const $ = _c16(7);
+  const {
+    nodeFactory
+  } = useContext8(FlowContext2);
+  const addNodes = useFlowStore4(_temp10);
+  const {
+    ecsFlowRepository,
+    systemsModuleRepository
+  } = useContext8(EcsFlowContext);
+  let t0;
+  let t1;
+  if ($[0] !== addNodes || $[1] !== ecsFlowRepository || $[2] !== nodeFactory || $[3] !== systemsModuleRepository) {
+    t0 = () => {
+      const modules = Array.from(systemsModuleRepository.list()).filter(_temp24);
+      const keys = Array.from(modules.values()).map(_temp34);
+      const nodesToAdd = [];
+      for (const element of keys) {
+        if (ecsFlowRepository.getSystemModuleNode(element)) {
+          continue;
+        }
+        const node = nodeFactory.createNodeFromType("systems-module-node" /* systemsModule */);
+        node.data.entityType = element;
+        node.position = {
+          x: 0,
+          y: 0
+        };
+        ecsFlowRepository.addSystemModuleNode(node);
+        nodesToAdd.push(node);
+      }
+      if (nodesToAdd.length) {
+        addNodes(nodesToAdd);
       }
-      const node = nodeFactory.createNodeFromType("systems-module-node" /* systemsModule */);
-      node.data.entityType = element;
-      node.position = { x: 0, y: 0 };
-      ecsFlowRepository.addSystemModuleNode(node);
-      nodesToAdd.push(node);
-    }
-    if (nodesToAdd.length) {
-      addNodes(nodesToAdd);
-    }
-  }, [systemsModuleRepository.size]);
-  return /* @__PURE__ */ jsx16(Fragment7, {});
+    };
+    t1 = [nodeFactory, addNodes, ecsFlowRepository, ecsFlowRepository.sizeNodes, systemsModuleRepository, systemsModuleRepository.size];
+    $[0] = addNodes;
+    $[1] = ecsFlowRepository;
+    $[2] = nodeFactory;
+    $[3] = systemsModuleRepository;
+    $[4] = t0;
+    $[5] = t1;
+  } else {
+    t0 = $[4];
+    t1 = $[5];
+  }
+  useEffect5(t0, t1);
+  let t2;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = /* @__PURE__ */ jsx16(Fragment7, {});
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  return t2;
+}
+function _temp34(v) {
+  return v[0];
+}
+function _temp24(m) {
+  return !!m;
+}
+function _temp10(state) {
+  return state.addNodes;
 }
 var flow_ecs_modules_default = FlowEcsModules;
 
 // src/flow/flow-ecs-state.tsx
 import { Fragment as Fragment8, jsx as jsx17, jsxs as jsxs10 } from "react/jsx-runtime";
 function FlowEcsState(props) {
+  const $ = _c17(17);
   const [, setUpdates] = useState3(0);
   const [refreshLayout, setRefreshLayout] = useState3(false);
-  const { ecsFlowRepository } = useContext9(EcsFlowContext);
-  useEffect6(() => {
-    setRefreshLayout(true);
-  }, [ecsFlowRepository.sizeNodes]);
-  useEffect6(() => {
-    setInterval(() => {
-      setUpdates((updates) => updates + 1);
-    }, 1e3);
-  }, []);
-  return /* @__PURE__ */ jsxs10(Fragment8, { children: [
-    props.showSystemModules && /* @__PURE__ */ jsx17(flow_ecs_modules_default, {}),
-    props.showEntities && /* @__PURE__ */ jsx17(flow_ecs_entities_default, {}),
-    props.autoLayout && /* @__PURE__ */ jsx17(FlowAutoLayout, { refreshLayout })
-  ] });
+  const {
+    ecsFlowRepository
+  } = useContext9(EcsFlowContext);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = () => {
+      setRefreshLayout(true);
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  let t1;
+  if ($[1] !== ecsFlowRepository.sizeNodes) {
+    t1 = [ecsFlowRepository.sizeNodes];
+    $[1] = ecsFlowRepository.sizeNodes;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  useEffect6(t0, t1);
+  let t2;
+  if ($[3] !== setUpdates) {
+    t2 = () => {
+      setInterval(() => {
+        setUpdates(_temp11);
+      }, 1e3);
+    };
+    $[3] = setUpdates;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = [];
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  useEffect6(t2, t3);
+  let t4;
+  if ($[6] !== props.showSystemModules) {
+    t4 = props.showSystemModules && /* @__PURE__ */ jsx17(flow_ecs_modules_default, {});
+    $[6] = props.showSystemModules;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  let t5;
+  if ($[8] !== props.showEntities) {
+    t5 = props.showEntities && /* @__PURE__ */ jsx17(flow_ecs_entities_default, {});
+    $[8] = props.showEntities;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  let t6;
+  if ($[10] !== props.autoLayout || $[11] !== refreshLayout) {
+    t6 = props.autoLayout && /* @__PURE__ */ jsx17(FlowAutoLayout, { refreshLayout });
+    $[10] = props.autoLayout;
+    $[11] = refreshLayout;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  let t7;
+  if ($[13] !== t4 || $[14] !== t5 || $[15] !== t6) {
+    t7 = /* @__PURE__ */ jsxs10(Fragment8, { children: [
+      t4,
+      t5,
+      t6
+    ] });
+    $[13] = t4;
+    $[14] = t5;
+    $[15] = t6;
+    $[16] = t7;
+  } else {
+    t7 = $[16];
+  }
+  return t7;
+}
+function _temp11(updates) {
+  return updates + 1;
 }
 var flow_ecs_state_default = memo9(FlowEcsState);
 export {