From c514e1abf7518a8114c862f15c8d3964e5acffac Mon Sep 17 00:00:00 2001 From: choibk Date: Sun, 1 Feb 2026 07:29:02 +0900 Subject: [PATCH] Last Sync: 2026-02-01 07:28 (Mobile) --- .obsidian_mobi/workspace-mobile.json | 44 ++- .../Drawing 2026-01-29 22.24.35.excalidraw.md | 196 +++++++++- .../Scripts/Downloaded/Mindmap format.md | 370 ++++++++++++++++++ .../Scripts/Downloaded/Mindmap format.svg | 1 + 4 files changed, 592 insertions(+), 19 deletions(-) create mode 100644 Excalidraw/Scripts/Downloaded/Mindmap format.md create mode 100644 Excalidraw/Scripts/Downloaded/Mindmap format.svg diff --git a/.obsidian_mobi/workspace-mobile.json b/.obsidian_mobi/workspace-mobile.json index 8840977..fdf7e68 100644 --- a/.obsidian_mobi/workspace-mobile.json +++ b/.obsidian_mobi/workspace-mobile.json @@ -36,6 +36,34 @@ "title": "Drawing 2026-01-29 22.24.35.excalidraw" } }, + { + "id": "47721403cdbbd14c", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "일일결산.md", + "mode": "source", + "source": false + }, + "icon": "lucide-file", + "title": "일일결산" + } + }, + { + "id": "869a31f07a6a0f8d", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "일일 무기,탄약 결산.md", + "mode": "source", + "source": false + }, + "icon": "lucide-file", + "title": "일일 무기,탄약 결산" + } + }, { "id": "9b570f0768099caa", "type": "leaf", @@ -203,12 +231,16 @@ }, "active": "a5db20d587c16ef5", "lastOpenFiles": [ - "Excalidraw/Drawing 2026-01-29 22.24.35.excalidraw.md", - "2026년 월력형 메모형 일정(1월).canvas", "일일결산.md", + "Excalidraw/Drawing 2026-01-29 22.24.35.excalidraw.md", + "일일 무기,탄약 결산.md", + "Excalidraw/Scripts/Downloaded/Mindmap format.svg", + "Excalidraw/Scripts/Downloaded/Mindmap format.md", + "Excalidraw/Scripts/Downloaded", + "Excalidraw/Scripts", + "2026년 월력형 메모형 일정(1월).canvas", "일일 무기,탄약결산.md", "일일 무기.md", - "일일 무기,탄약 결산.md", "일일 무기/#.md", "일일 무기", "26냉난방기 세척 현황.md", @@ -240,7 +272,6 @@ "무기탄약 및 전투장비 확인검열 준비 계획.md", "inbox/소형냉장고.md", "desktop_hp_obsidian/inbox/소형냉장고.md", - "inbox/소형냉장고-1.md", "20251213_174118 1.jpg", "1696485474353.jpg", "출입인원 보고서.pdf", @@ -248,15 +279,12 @@ "월별 주차구하기코드.txt", "수험표.pdf", "새로운 7.txt", - "새로운 6.txt", - "새로운 5.txt", "temp_1764374020200.-1440744867.png", "temp_1764224320966.-2040280101.jpeg", "temp_1764224265321.-2040280101.jpeg", "temp_1763986624781.-1344914328.jpeg", "temp_1763983212319.144536212.jpeg", "Resized_20251127_141053.jpeg", - "Resized_20251127_141040.jpeg", - "files/포트포워딩.JPG" + "Resized_20251127_141040.jpeg" ] } \ No newline at end of file diff --git a/Excalidraw/Drawing 2026-01-29 22.24.35.excalidraw.md b/Excalidraw/Drawing 2026-01-29 22.24.35.excalidraw.md index 6d78dbf..5200074 100644 --- a/Excalidraw/Drawing 2026-01-29 22.24.35.excalidraw.md +++ b/Excalidraw/Drawing 2026-01-29 22.24.35.excalidraw.md @@ -12,29 +12,203 @@ tags: [excalidraw] ## Text Elements ㄷㄱㅈㄴㅈㅂㄷㄱ지ㅂㅈ ^xYeOn6T0 +2026.1.22(월) ^YsiIaHRZ + +## Element Links +vSMA6Uwx: [[일일결산]] + +## Embedded Files +cd6d81b262223b93cf1e47009b086d46ce5a487d: [[일일 무기,탄약 결산]] + %% ## Drawing ```compressed-json -N4KAkARALgngDgUwgLgAQQQDwMYEMA2AlgCYBOuA7hADTgQBuCpAzoQPYB2KqATLZMzYBXUtiRoIACyhQ4zZAHoFAc0JRJQgEYA6bGwC2CgF7N6hbEcK4OCtptbErHALRY8RMpWdx8Q1TdIEfARcZgRmBShcZQUebR4ABm0ARho6IIR9BA4oZm4AbXAwUDBSiBJuCEwATQQAeQ4ANgAVBLTSyFhESqgsKHayzG5k5IAObQBWABZkxonGqYBOGamE +N4KAkARALgngDgUwgLgAQQQDwMYEMA2AlgCYBOuA7hADTgQBuCpAzoQPYB2KqATLZMzYBXUtiRoIACyhQ4zZAHoFAc0JRJQgEYA6bGwC2CgF7N6hbEcK4OCtptbErHALRY8RMpWdx8Q1TdIEfARcZgRmBShcZQUebR4ABm0ARho6IIR9BA4oZm4AbXAwUDBSiBJuCEwATQQAeQ4ANgAVBLTSyFhESqgsKHayzG5knjiAZgBWZImAThnkhLGAdkaJ -xr4iyBhhxqTFgHYeMYBmHh59iePFtf4yihJ1bh5FicnF0ePG08bF5ITkia3SCSBCEZTSbhXFKNGHzJYrNbHIEQazKYLcBLI5hQUhsADWCAAwmx8GxSJUAMTJBDU6kDSCaXDYPHKXFCDjEYmk8kSHHWZhwXCBHL0iAAM0I+HwAGVYOiJIIPKLsbiCQB1B6SJ5YnH4hCymDy9CKirItngjjhPJoZLItiC7BqbY2hKYzYQVnCOAASWI1tQ+QAusixeQ +iYAOfjKYYZmkxpnGpZn1pdP1gBYZ0a3IChJ1bh4Zie0E9cWJnjOxxLHk25SBCEZTSbhjGYpRrQiaNK4XZIXBKzQHWZTBbgJQHMKCkNgAawQAGE2Pg2KRKgBiZIIGk0gaQTS4bD45R4oQcYgkskUiS46zMOC4QI5BkQABmhHw+AAyrAMRJBB4xTi8YSAOoPSRPbG4gkIOUwBXoJUVQHs0EccJ5NAAoqQNhC7BqHa2hJY+0QNnCOAASWINtQ+QAuoD -sr7uBwhFLkYQOVhKrhUmbhBzLcx/VGY+6wghiMMeKNkvsEqNRtdkYwWOwuDaYZWmKxOAA5ThibhTCazfbHKb7Uax5gAEQyvXzaDFBDCyM0qeIAFFglkcpno/hkUI4MRcGPhvsfuWLmMpmXkaTmXnuJP8NP3b1MP0JIB2RkAjIyACUZACyMb8AQoyvwADk9+b6iuQFDNH0lSvp+P7/oBopipwUDSoQRjiKgxzJNoxxYacXYvOhPB9hsHTighABiuD +xeQsv7uBwhNLAYROVhKrhUubhJyrcxAzG456wghiMMeOtkkt3us9oDGCx2Fw0Dw4VWmKxOAA5ThiYZlpY8ZLrS58T2EZgAEQyvULaHFBDCgM06eIAFFglkcoGQ4ChHBiLgJ12DhX1r8Dt9AWSWQXuNP8LPPb1MP0JIB2RkAjIyACUZACyMb8AQoyvwADk9+b5iuQFDNH0lSvp+P7/oBYripwUAyoQRjiKg/zaGMmG/FMLz/DwFw9mGCEAGK4PoUq -6JKzqoICd59AAgkQyi1ugwRiv0DakFA5gEIxYIsdA9qinoOS4HGTARmgWbru6ZJgnGBBgQ+EHvl+v4vgBQHIrgQhQGwABK4TIahOJCAgZ7iQAEqC4KPqgGE8LRxGSKESlQAAMnGeJXlOCBFAAvrcJRlBUEiNAAQmq2D0WKpFDMiXSoSipC4lQyJDGgUxnNoCRYTwXwTBMvzFskSLutRBHHNo+xjACZx/McCQ1U5dyanujTaFl1xzI1eWnGVzk2RC +uqgEyAveUAAIJEModboME4r9E2pBQOYBAMSCzHQI6Yp6DkuAJkwUZoDm+CAuSIIJgQYEPhB75fr+L4AUBqJCFAbAAErhMhqG4kICBnmJAASwKgo+qDJPE1GepIoSKVAAAyCb4leM6mZ6RAcJ5kmxvgRQAL5bCUZQVBIjQAELqtgdHisRQw0fAqEQMKeJUICQxoBciRvNhSKNMkiK9i8gKUfhYzaEsfbTKMCxjAkdUOR0ED3MQjy2is2j5XsqzNZh -NqLDl+wHDVySrEWZznNpHBoqhbrESqepcmSlK0jSSAzkyLJshy608ugfIcAKQrZBx7oSlKBpGhAJr5jqqoIBqxCPGgRFlKtBJ3Ulj3AcIFpWsMdoOk6wyusinqbr6/pBiGYYIJJqDSbG8YZeguA8ID7LEOm/rBWUiVPJsgU5ggl42uNhYljwvacU2LHJPljM1q2HDtp9iKFfshxfZAhDDqOVOoNet7EbOeOLpkl2rtmxGbtuu7UweByXIsuyNBZH +PC/GMgKSFZYK2pCLUzEsdWIu8IyjEsqIcOiqEeu1qr6ty5JUnStJIHOzKsuynJ7by6D8hwgrCtk7GepK0qGsaECmoWupqggmpddq9Zffqr3pR9wHCJa1rDDJTousM7qAt6W7+uuoZPRGCASagUnxomuXoLgPBgxyxCZoGEVlF0qE8PaYV5ggl49dcpwJCNFwcS2zGIo07O1u2HCdvWCyLKcXzc0Oo7jgzqDXre7XzsTy6ZA9KObtuu5S6WB5zZcE -DeVJa5nmwF7jmLvnInAbBxrkBSbGAhQdKUy0OwktvBrb9sO8WHVdWsly5f19NAqUzjJKNTUTSM00s2c+yu5sbsrVEXHhXGjgLZGBvutkxApxycbKBnCvfUnUD0SlbAUCCuAm2jWccmXqVVybyWpaKQSzhQovi35pTk6URPlM3+k8JoUCWccABqhKiiTvLgel3CLIsyIVeWnVTBvWX7EsCT0xvyL3O9WpoAO7ogmCw28C1kCokaTsCLqBJHZt210r +wETMZn+dGQVnmwF6TtL3mAnAbAJrkBT2mAhQdKUW3OwkDuo87TvO5rfXPAkg2LKNI23KUzjJDNxzzaVSIlqM3we/antlDiwpQDFCaOOtRu5u12TEBnnIJsoOfSXmUScXRpBZRNuDm9jnr51XNchObGXV2w2WN/g84UFLMs+e1TnMC57mG1O3mheFQ5t3oABSdEAI6kK24pipTlSBNgUTrRiOVPOh/b4bMg1HIimyepRazaEcaz5bCLUJHM6xtWUn -tzIw4dJIbby5BnYKworrERujKOU/0SSmhzI/V6bVPrPT1H9SoAMUx+EkATUGslwawEhvfD0bIfR+gKAnMooYKLIxrpnYiqcEwSFwG0FBaYQb6yLgISmJsewzAmGcdYbNOCQl4RwDmXN7IXHWIWUYNx3RCxHMEFWqBTLmXdFLDkMtlzW2YTJRWW4dyiy9u8A4SxRiFW1u6c8BITbdwSuBCQwFKBuUqHBBCSEUJPFwfBHI5FKL4GotfaADEmICTYkA +XdbZZa1WMSIvOs3wQjmmNRyk0bILAuPEEaEdngXA2HNRog52pomNK7AQepCSXQOkdekJ0WSIwuqSfafJyC3SFCKR67VnqynlCDUkZpy7fV+h/RBKd0EGhoZUUGaY/CSFJlDT0jpmSwzdKgr07I/QBgKMnSA4YyIY3rsbIcuNkwXCJhmSGaByadDSuCGm2J6bm0aHhGYVw+w804AfNmnpqwcz5gLVAcIWq9gRFY9qw4xzBD3BPG8g8yjy05IrVcds -soVZuLuD4sxHoQlkQiSiOJUgKNa7ETkv4RS1j0Cih0npQyrAXFoAUTrBA1kL52Qcr4lyzA3KeV1j5G8PcwD+XAAnFEcA4Cyh0dwYK0AQRZEqExCEtwGCEAQBQcKe1P6cm/sdCAFIxRzPmQMCA2ARCAO9L0fQsoXrPwkFSV+O0ihLJWZdNZmQxkfwOpM7kPQ/7nUAYs5ZKVjnrNIpKUBhpwFKkGQ81Z6zNl6jeh9XgXyjk5BORs6BiCFQQKegc75T +0Abk9FuHcXjP5azOEsWBdUDYBSxoo9q55CTmwHuNZyfQx6JIHlPIo5Nyht2qKwX0uBzK6QAFrrx0XycC+9BZLBvnNfKsTYTTBLBfdqV8mk/2hH8CsxZFj609O/f6tl/61WLI0I8BFkhHDmuNUB4IaoXAQXfaYsIo4rDWhtTEgMMGEKuhAak2DjqeiZHg86XIjk9BIXdchcEpTUKNLQ5UByfpah1AwoGHDFR0M+p6C0vCNG2WhkI2AcNRGIwkSrNG -zMj6SBmgph9lgWPNBesuoWDqJ/Cdoc9FUAwWkTIhRKi3AWr4p+ZkYlORnGoUSGiql+g3IRMCQgdi9yQWEt+SXBuFcm6F00ZAOFGLMjznruXSuIRm5Clboy+F+g+WgXgElC5nKCVEqRoio0SSBDYFxFKAAGpCJIRxGgAnGr2GYjQPgUuYPqkk+BqjDFGHELsCQl7zEaNvCYEivoQCMGwAwnT3T0AIGZDE2gXgnnygFeVor9CIrxugiQarBmshIHS1 +cjMYNzccoiQuB1hqJJqCpFKcDHcH/qMWEEJRE2NrNwCYLVzEcDsahREsDnhLGamLNxEtPH90thchcgTlZSNVhEjWKwTgnDGAcGYEITZmy8j4mi4EJCJAbCkSBAAKQAK2MAEpgKUBcpUOVjQFWjBVeqoiOQkIoSeLq+a7oLjDVgVa/+RqoCkXIvgK+0qHy8SYpUViFCyjVi4u4d1/EdJwCEghUSVpSCIuSWUWS/gFIyvQDqvVPADVilwNpPSBlTVo -x6bSCZt6HAclOaSAAFk2DEAQOK3AmhggWLNgcjNlyf6oAHuFEkzdSDKEZAACiOPsagvBiz9t7f2pIEwACUopDLKGjEKSoHbu300xLwRqQ6V2oFHROuNsKuV/IJFi7inB5ZCvFFq7OTB84huItkKtNbuAFPdNgIgBb8mkDMsiDgZC72vsUck3SRBLRfrfe6fQQoCSkGbJ+l9QHiIgdIGByt1bRYKK3WUOwAArBA2BcjSg/XAUt5aEO3onHWsoTJuK +GMr4yAfkECWRBFNWy9lMkj2yR5SVYR8mlEKVFdA9AZQAFk6KNAAKoUBSneWp6BCD6GiOc9qeMThvHeDCBswrey60quCPsKQCI8A2EHPpExgHtTGWS/sfUlhrFiUYj47oullAmkWmyzU4gEThLA4VEJfgXFcWUZBm0PmYOIQKMhD0xSXLOguV9117kftFGGZ5wNKhOWwBoQIKo2FMPGXababDQP/PeUC8GIKsz8PaoI50kKRHcPURhwKuccVS2LF8 -MGaEG/Al7iYqqQRkLDNZhJCGxAYZodGNGG2NrUiWJDcQbIYweliljTGhFLoxijVHBUocgI4ZgN6iQIT6MW7IQgeM9z7uKSU4ROmNP8kAA=== +FhkASUWLQOS4lzZeYdhpYcHds0TG8vVubTWgqjzJAhPleMLKECRIyZ6GFyMeUcoViublITpEQD8okiA+R8iAB9xlTgAGmsAA0DwZgxilSWyqV8LIwKOI5AYeo9K3eNlmUZ68jKjYGII0YgJZNANnjmMTQorsDihpARd0MxNBjuIGssQExcAXFOIC7a7hULe1KPBjoyQk6AmwHiYNRGy7IuIEmVFMwIA1uKDPSoFBKm6VcrgZoAAFKLFMe3QHqZ6P + +GExeoIiMa1lYOEH2QEoqVJpUwywljWZep+a635fLQEeszyz6yv0gE+/ZPzDk8iwYdL9p18E3OW2+0h90gNPRA38k0ALoOMPG7wD5SGjsofasCvhtpwU4Z6/DUT4jxOybDOjSNpnygovxnRDFd2knffzJx5YrVAF0ZrNRtClLqV4patCBEJwBMeKE1LHNc5OXSbXKXdjkSuOHmFf2f44q0lVtzfVpSEgNWgXjRAOCCETVU1EfBHIjqKJktdfRRi/E + +vVil9dxfAAaeiCRS6GsSEaTOZejaQOSHA41U/QKm9N+lWBZtQBj3yFlpslsXWWiz48LY+IK3WtuzQYAAEUAAac8oCXBqd0OpSkGlUXmtoQ4w1fiHAHEy7Yww50Ws9/Aj4orAQbom0s09TxZsZV3s+xbxJbkSFOat3BP7iZ/ugAB3b3qZEHdeZw47HzYPfIQ99S770i+oZ4YDhLDoYa4dss99qYnJHvaM3ZjLONst4wyjFAHWKo0CFxWgOq+V73Nc + +hxzcEsPGPDAhKVXWCQFgo8lubTXcssdKxx13sJat8cCsJzMl4df5OmzJ1ZintFKg061dT+1TOngs5ImRDnNGufC4kHzjifqeI85F8GmLiJBLl9tLg6LLrGvgHfkrlpDpKroZNwBvmUPmoWtZMMKWo5Fkg+DkuTibkVhIDKKQESI0NgK2IvJgIQPiHPK5EIOsNUJgHULwuqMRA7ulOGAYiBGKHjARDVM4qKrMiVPMiMt0twM4CWLVIsPHKKnAo0AH + +GHmdrxq8Iuv8DwfemWCVBRkCFHj1K8GPvegkARP/GsM1rsigi+knugCnkdGtlcr+hYVnu+jnk8i9IdpXtdqwqdn9KXh4b8gXshvQjdmhrXg9sIk3tCq9m3kGHJrIsZrjkoj3smESAPoRkDmAe9CPrZKKmWAHH5pSsMPerPvzKhFsvMuSnauLKjpEkgYyFvkEtmEPhAOEhxvuNxhCEfKfgpnESkufgZtZpANbLbOuA7HFi7KHGAO7M7NIo7A7OMSk + +AyiMB7ofqsDkWMRMR0FMSMbMUTrCMWPMAcMvkNl1i7B7KHJsUkGsvMPML2McLHKWDuqsSccMTMUkHMCsAHG0T2K1AyqsX1OSmsG1t8E/PhP/EsI8V7DMXZGMOsHCD/HVD2P8AspNi7L8ciISq0kCRFgnJMacRCbVDuhOp8AyussIW7FMscPAgHL2CVAHDMGCR0JsRAvSnKqMJcE/AYS/GMXENCPAiVPumsgYbSdiU8c7GAAsPEAHFzGsiNIcCcKt + +DMZCIuiKi1BCN8HKqCUKeCSKWKVCTAhFgiNMCeHKVqUkGVJMKVP8D2LxrxnSaUJsaVDfBsMcL8IkDMrMKHhCXELxlKf8AscWH2NTBqfSRCTVLMFMBWAcP8ANMiGMYiPELKVahsK1tMPlDadMVqRAiCaGThEeNSSSYlrquPvNHsM8ItM8I0KmXabqqWEePMMLH2AyqNolk0i/LxifocGyX2BWRCU0hodCacKKiMGsByRCZCENgytCZOrMMWBcF2Vq + +ZCNMO6Lxu8ccM8A2JyS8XCHCCtD/GsCcLOc7AVGcPqQcBHHCHNNGTMaMH1NCCVL8KWCMMKqsPuR0FeeRtcLrB8GPokEaQeTVIcEiEjk/LhIjs+aUPhG8Icc8CcH2Vapya8FcGcC8O2VKdcOqesTiSKYuvEOOUiGWN8LhEeJyU0qVIkEeE6QiCfAGehcKQeQWaVJcNcBCKGasEcWAMWNoJcJcGsl8HVJSQgqBWxT2cvnNHVKKsiPwY2aUM1LVLrLM + +AYfepMH8GMAJexbEvMvMn6fevhPcTMb8H7MiJiXsMiIhTOYGbaZeZCFGUYgYbEvNDMj+R0D/PEP6SzM8IylKQJehMZQeJhAsqVHmVJa8BWL1g2RCLEhWBMJ5XEC1FMOsvhFanhWMcsNoKLE/JuTsc1JcJ5TVMiAYY/D2P2AggFWABCFCGsMWPMaVHCGhaUBsbpRAj/Pev/MfjurxhRqUEiLVKKkiJssiEcD2J5UFe6OSmWBHJrBeSKflCkDsaMFC + +TMgiKcOWWZWmc7MlcWOemcPRd+fMmMVajfJ0k4jHGfFRbVRhatfOcvscPMo1YuiWLta8DSXsNMHNN8AiDVWAHVZNS8ZieFZhFkSYqxWsildCWcPJSRXVMpctQyXEGWFcCzHMPevfMVRFikC9QiFBUHNCQJfesDe8F8HJS4rCLNh1ZCLIf8OVQOCWIvtjQWWcP7KLP2INsTWAOSu7mWGGcsK2c8FlVDTMSjdCOfG5v/OjcVV8ClQYcsPhOVK5TugJ + +azahRFjuY4lcL7h0KuhxSYuedCQNC/PenLReicKWLlcCZcWMdfKMOPoMnMLdZMHLYySWJML5cJYeGbbqpMAOTCDZdCUtdRZqc7LCNNTMssO8P1AcaraUM1hxbyS8CNIkPlMiHLesBhB8A1D1csHCMzbMNhUCS/LrFanMD/AJbIRhLxkYnCVKSVKxcXQgjqQKesoYUXZ6d7SxhDVahHGMQghhLCK0rxscBKe9Z9c7EYu7njcsLrK9Xxh3TVKDVabI + +Q/OaUXboXCNdQRFdVeh3a8KXSxuRlKYukXcRUHcxQHEHFXW7QYbJbEg2MVElrzSKTMjfH2A/KYmGTcDMUcH1PRWeSeKKoKb7UGSKV/IiFcVar2NrQiB3UnUIWRmWRFtTbfc7HVBxZOr2OAvMryRAw6RsLMJMBWLEgJQyuLXVMWEeNCciJMB3RdX2ApZhC/JDX/eZQA/BSsBHHErfIsFXZCKFQgmcPjUcPg31orahSzH8T/GMV/OjbNP2B0vSvg6T + +YkH2JGYsBnXXqUIg2yccAcEWRiQJeIf1QHM1qDVCQRGI3ZC8AtBFs1lAidR9WdR0EeHiZhIiKuh7qhWI1yW8V6ZITuvxfA3Y68JMFakcCNCNaVGIyGeRrIXcX1S8Do7qsfpcJaaugiGKjMbEjfCrX8UCWUesDo0nZdQOXrOSvqWI7oYzSWEheOc8Do6ObKW1tCUuosqk7qnsVcM1s1BHJxQJXsBxUMuoVeplSo2AGcPEGPefasPeQNb46UPMGzcT + +vFRCEcAcGI5w9cGspcIpU6dY4PR0NcO7vlOGQHJ8Ro2MeIc1i/DZRsLdTzfQytTsyGVKRsHNYVczfY8sBOcHYSiNF0xAgsKugYTCbMjsjMS/BhIaVMIpYSgPbY9MxAuSr1grauiVEiWAKcMneeXekYS2V0w9fensHMN1Z8IMxWDfM1K5YzQXSVNi31BRc/LS0YszTM8Tgow+QpSzFS0KtkYc32GlWMSYhhOne6MvsMmDl027fNIi2UUiG0by3Eyz + +GDqs8zFCaK+7qMO8IuosHxby0nczLQ5o0iDFV08RVMMiLQ9paExCe6O7h03ulrUYj7adTRTsz2UcP2FMOSvHEcDGSzO7r5cvZMDEvhIayPYtD/M1Gs8i+Ania6QtFMOjTfTc5sSOuWOsieO0r8F62K0VNxelVC469M0naqZSW0ggouu1aKe8BhCayYpcIIV81M2ACOm1QHMLXnVMIM6VCaTuomcQzMiW10wW7IVI//OyYpTGfaUeETgZY4ssKZQm + +/KUnWcAOD/PMFcKIxCbxileshWJhIK73V0/OWJcNBHBU2W4vpu0A8/GsE/JFfW3MN/F6SWHTSMGcGO70n3SFbEsu3Qw637Ts5ZQgvHUYgsJxWO0nXNPMv/A1Nu3ufW0LNuv1ESUK2GzGQVKG6RTKSYgYQJQsHZIsCMHMtIacPNCh3ZDMjFSmzMqWFs9C+W3ZKVOpf5uerhShzlTxR09MtdTk7B8vilYxYeAyvi9Oh6T86cMsHMODYpdh96600vuF + +eGSiB6f42DkB0qUSVJyGa6cJdVC4sVSMLqo+0WU9dAiWFJ7C7JRHG8ewxNT7Oxfs/hDFXiy8LOz+//T7MiA6WaQ1JR+UzGdJRsPigLQJ0/FJ7qtOeM3Ev8ER75zlVVTZcWdcy5ww258RTEtWc1Evmu1qZMCkFAoAj2EAp2dx00n/O8cob1pJaKclTuv8MHFcMxvazY3m+W0nbrPNEiBsCW/iTGZ1QAuUxFlrCYlJwqUcP8xavMisA5fFlNfCQcOj + +f8IsEN80tAtAnnTmd1xmSMHK0W+elx3O8aZw7hR8CNBWGsqWN100pdUIendxZM3t256OXcZ88Kl4918N3sOK0d5MF8Nh2KXK51+fWWO6VqVMF3eJya8tN+T90kPhdMKG/RVaqxbD5uyLARH8yRd+417+/Fvad8CE/JaG0sxCdfBoRoza4Dxj9s9j3ZKHfi8u1Bae5HS/HNFewgu6AVT93ZPiT/XpzkSHET5COSphMa81gmXvbBxu4qUvgglaWszG + +Z3fhB7USj8Fh+LxmU/GstZSw1CZN6KcPaMCVCu3sCWCNT95vbIYkEhUjjqXLz84qRPgjpc9R012e8u5SYdyeeHbr0oT/H2IjuSVjeL7qgYStDyXqY01qdCFCMZcQzAgjT96F9CddQcLIWcITxH00nEvPXMI9Te3d4lqWBxb1ad69d8J7xB+KacPCIeLFT95CCoeB608iCMBG/fYszMiDQtMQ7X+7nsMKu+flA2IRRCQcDlz2LAs7Y1M55j654lgV + +A/CfIEyoU/HL/OYNhWPAiYmg9h72G8JcSNAiV94jyP/VBFq8bN1v7BwVC/LdddTugjRV0IcnYc6KqMC9dv5CQsIJzMvSivxxeWPegeARAGtL+nPCWqNXToqlT2I/F+Pl1XSxJl83Nd/iPWkLp0wyx+GMl/GBLcNqui1M4NvwvT1kr6vwHWNcAwH7A/41VWYAmVtqX8uSJ8E4NCEi5zIMBdHVdsQOXyAJdY2/EMvoxeCSsVgp4bsqR0+DMwWYGlDY + +NwLjIUUnS7wd2qe0QYvwBaj5NSi60kHFQ6asCFOugO7JxAGwPwZ4KujGq7dEutzeLCNF46yEaejpNjDoKmSlsiU/YK1Crzz5mCaoJbZxpLU/LQkMBNUashq1LIwDt+D1FYGsk+KLU8WPgvqO5T2IhCUyl/BPhFQGyLpgO8g1ZCVDqgiowGU/SnqKW+D2Q2slqelPeUiGrBWSLJXyuVW359YAmxhIXnCwf5pNlSP8XWgtXspVDMGm/OEKcBYYRs0m + +k6A9CUSUrb9RyvwFqH11joNCfmY9WamY1WAMpt+SdeylcBrYOc+eWpNJr3XIxMUOs8wy/jNFLDzAQ8qrcPj7DSbtJSwayZYO7WFTDCMIhw5jBPkWiI80mqfZfHPR1LNZbh8waYCsEzJfdmapYTetcEYHgcLUufEwXaWkrED/S3jF/sWAwHwU56JwOARb0ODYdpKEZZfCDX9YlQARO6G+KT0MLzA3WDXHIVaTeDzFRq61fzM8N0K0oAKdNYwrmyx6 + +VdTGxAo8oLzKgIiMIg/SYMqVtTxsIRwZHKtMifjmkX+5RdYYyQYF6DNkFFCnjRy9Lu5HS11eZKN16G6D9GrWEhtVyd4sjFC9kFQgyjUISl5BdkRwQKnJK9g5U6IpQoYNUJ+YNCLAjigk00bW1NuWzZLJ6DgCBAswIgcIPbB9ihwVGIY4MWGIdihiIx4YoMVGNjExj4xiWaMYmLjHJiEx8WJMemJTGZi0xopDMbmKzH5icxkYosXmOLGpjyx2YisY + +WKrFljKxdY6sfWNrENjmxTY1saWPbEFi2xnYjsSWO7F9jexA4msT2KHH9iRxg4xscOInGjipx44lsZOLnHTiFxs4rscuPnErixxG4mcZuKXFVi1i0/AQH2ljDqxKsvo5gP6NwKlBaYtafAugEaCVJcAmAVyIuHVAUALcpAVyJUgADiSwNFDFF9B0QYAzgVgpUHYIFhOCLuWQrqinJa9iGk6GdGgGcAjpZgxOf+GJR2Kq0OoChAvrNQZR41o6iISP + +GgR6hxNNkc1JvvNEmyx49kaAURDtCWxEJLCh0HBBcnWzXJM8N0B5J+mAwuE/CV2AIj4Q1BnZNCdE9hLxLcL8TIAt2UFKfmwyhEhYCMCInCkoSfYpc3eHLPjBHDJF6iwODIvlHhbsM8itoXsIUXsQLl0aLZSie4jXyIFSAJkTHFJm3zBJUieOflFrBrLtEEkXRZAj0XSTsp2oAxHfEGCa6oJji9bZwCaT2CK1hU+NEsJEzLbQ9/YTfIbP5jKJ6iZ+ + +YcJIHNXfb+wGw43azh0ASk8VH2ihS4fhwErhTaoudEIXAiMKP0ficyG8hpWahdsYQ5UyEv2H4IUTZgCwV0j8XULGUY6O7RENaTCmmNRKbXGdoK3hG4klK73BMpkIVFNdnAUEpCul3aQnBF0zNcJmsB96b9ayi6ZkelLADhwaojjKEi0hpLOlPe1Qg4sCOcS6wnGbU4riDUGQxwmqFXFZsn0RbUl/mpImjs4B34D94qTMZBmX3NH+k3mdUZ5oKP3G + +mDjpWFXsOyWtHZEnSZfNwT2Djq8ZOKYOYwbDM2IAyk6jtXuo+U4qV0YyShPTv/DDbHAPgywcqc8G3RqsLa05GOgzxSoc0ywP8DgcNHKnoRXiC0O9JtOqpy9N2mVAiAlWWFzReZDVI3n3wWpGUGhHFIbOpV75blA2YU4VMDXibVcXgKUmMmBz4EG9fhiIQ6Ulw6DOBSqj3JfHDVvQ68Coi6DaQcJ3aHC/pS0hECqxdbsljCr1TkqRwnSykqS8cGGT + +kOcCwIUgzU84UbWPiclfBSZRCsfmgq4yQ5KNHaZ+UFROliOl5CBFdUPSlgjG4LcqWLSb4+8H2RAzklBIUqndhp8wHsOCLxkzFnA18fzvZ2vQ8Mh+mFQme+W5bW0Mh2Q/6VnT+6HAjanM6YElUymtQFqEWPsrrFdksjlp7jDVjxh3SutiqelRWoMmamu8k5/0yPrBJfhU0PugzJynwOnL6sXgt5cqdAIYrjcjRRiMtslVP7cMQGNqGDi4OOkENEad + +xIyhDRKi7UkgNJJcpcTCrXBypvUVZiEPPlqtV0u1LkiNF+HwhOZpsuGc4GOC1QFidXaZA2CB7OwcaJiXCePwOIq1Z5R0sQp6RrrnAn4Fk3asRRrJC1iwBJYhWbLDiXAb41xMisIzIzM0rg8QIxMiLmCrADgsIcqdCWVGrB/OI3fgmbXamtVxyWI97sIoF6J9aUas1ZmbXRlcy22+UXhQHzfmIS/ZnxbXlOQzpm1dCbXCcmsznrlTRUkCSQt8AxmF + +VkWkdWBocFmAMpAeLDKxQ9QcGrBq2oqaEGbVHL78Hyy7OZEgvxmHAoh98RxIKhZjIsSovxVdP7E/41lGFyCuaC6MHaIVjui7KevZBzIuLmG+/PuUtLvazRV0HNd0BbQ3pvAD0aogDtsjamWtBe1VYhlOWKrv19+KpG9FKQRCNLoqHbP6kzFsrtK6+Nlfkv+UwhxDdFTUFKlKzQZds4BzNRBhcNOCv9zpQi0aQYTQW7kVafpIkmEzmKTKDesCZMmE + +obm/Me+HwYdmg0MJiMIErxd4MWTC4RZGlxFUaGQ0/mI4xG5qeEgfN3RfBf6QokUuHArYNg/mzWRMicGMapMWuifHxas11hKtNlM0OYUZxWCMCy2HwDCIu1/i4NJOyKwvoIvhpOM86JzJuvN1gS0ZyU0INqWKVhDc8NCMQnXvYxplb0d0MSIxLSo/7k0U+4lI8Jiv8a3luMRHO4rSt0ENggmVAymi82aa4td0lKhBDoqBXOxw4IwDitmSuJB13aJz + +QmZoN5LvAxRPjaZRuw6k+kmobRZfsC0hBEcuhilBYoCvrnAqY4KVEst8FwYutYEvLanlCRZg0yyMF/Y1ZvXYbhkhGKwD6XEGv4oMI4bRGRqNOmDi0gKEWWJOJ1OC8sfmK7E/tcDmCfC41dI7BuM0ASbJeWrwcessQH7OMWotK0LuAgQGDZVg+EGVgSLPJvkAKCXR1Sqt6yFQvgig2mdB15ak1ioRiMNjXPmi0qLusIflYuiTVukvWuHd4n/AAprM + +zlTqgvn1UnUfk7+unb1uVW/41s2ueDONU0hwmZV2kJ5RHlsvZHFkueq7MdZAmBkDYVapAi1hnw9wxw9B7PQ9RSPbIXDh1GwL1sN0pU9gjgYbJ8nGqgkdd2uD5XcmDNw5XVoSl6ZjMuo7XxqfFAHdVmfIBFqqymJMtknrFpWMlqoeEU8mPjHYPVta5HWSi1GKVzySKvHL4AE3qY7swZF3TDpXzWb7MHVIcjth/RFS/ABObVTDXXwjjdqw2UJUWK8r + +ZorsmKljZqLpx37HsweP8OVC8s2X+MIFx8dFojyvIfAbu1JbqUqvbXmyFgug3EUTXq7wIUOInY7m1nZptUrFiivQZR3vgmFFOPIvBfwXKrs0rF+nNniyU2oQcy+8qOlH/ERXn062uivlkeTEHwCGOAIvIQvh9KJ9uq1GkhdYoWoNhD0YamwVqVs75d32xvUolYs9I2U4ezPAiR6QF4F1cKzWOEYtLnndNNqpQtLi1HNZZckgxo2OIYQsbvArFJpY + +aaqxa3sdfO5ozmYkH02gMUtTC46cSzGFODLmWMxYNF1BY4NjCoSurSQtRYmIZ2WM4EiQ1873LV0N1WTc4mEX6chCPYS1HHHbaazDBsbRqmyRfjCKS11ohHHKyuoAjkq1wSmW0R4KjBhFMshSvij8wVVfOIw+aAs3x7slhFvBaku00+LKEH+7s4RiQw0LiUGwwi3QRFUHIF0Zh3XLktMD7AuKlGo6sKZMndBQk0G81N1aexxp99t68lDgZNuQVYrW + +SenAGh03mDddXg1tEaNCE+5PwkN5s4ZotWXyf9DCbi87rVGWLaUMhw1UBUa0mnIi4anOiEtwr8VjVjCi81JfjPxFSkcOg0omg/xB74siGj7d0Cn1AUPUy6g2ExEMlTVE8IEUrQQpaWJxwhQFGnRqh23KihlyZ3O/Zl8FawHE1g7ut4NGt9U2ovcDPPJuv2DziV5kTOnXeaKGgiU+qhKdtlnTzpYQLaTVOuSHMQY+L5o1oj2tgvzK4dXiNDeEApW1 + +0Nyv4XFMTtrUWIAjO60IKONSuN5NVL5llRQmlXqiuKy+cIP2C3rIbgt/MnevZi4hpIgM85cvAsktCFT8loS6s3ReI3SGYtU+itOXixvN4DRgO/zMfVI0J3eN+ocwOXpAz6Qasg6+EI1cqvNn301+kq7tTXV/7W6MtWi8aWPt4x99+VwdYyd2X2BUM/Sj3WJWPreaAbrKGMs0TyLaYlg2eshHrWFOgHtl4EsIXEem1sG/xK5Q2XdNvKWnLLlSGdDX + +j5UiGDKtyW20xNXuBWIMOssUqkvVB0rrCaoNbflUZS6Gcb/pPYPqH/HPmidxmunAhlcVup005p62qbSgunoskYBh2/8s8OlHDsTlhvCQWFL6HZreexJVracOzlwCFg29L7TgbnlpMjuwleYrlJV3rCHq4CGEkb1QqW7C+PDXygynVYND4KEqoXixVF1pTRDvUTYTVspXT7uy8FYKr8MGhv8lDcTd6fLKIY69ARHFO/pDM/YtRBdYcN3MNS21Wl5u + +aw04VWWWLmkbi1JPQyQuSMTd/izWCOJ8AwFu166vzD3oiHl278cd+gk+HiLdrFlLBNDWOrUYqpFNcWQtXoSRNTlz07i+Rzw0epFjyUrgPR8ow/X6PkS8BkxL0f5NPH+ihiq4xceuK3HrGdxGxtY5sZ2PbG9ja4g46scOMrGTj24/Y0cYuOnGtjxxs4zceuOXHbjDx+41cd2N3HXjTx94y8fOMvG9xcmVgPoCPG9ATx1oc8ZfjwJuI24baJtJIE/H + +rAYApAGAAADU2AbaVsPYGSC6RkglSVsOZAmDASJAoEzwF3CHTcAiqKQPDrzrHSaFKIYhwvqQy5kEGusmErwraD84uJJgsO6doROLSdrOkNxZg/5k0LzYaJ5hLbIxLOQ2F08BCMUw4R2yPJuJLyN6FwgTwl4AYCeCvMqcCI15pJIRRvPJJew+g3sURD7AilUnxF1JGURcFpK8nD4NYLeo+BKsMmoBJRPqejG2Dny2gR9nNNZKvlZTr5bJFOfxEuGx + +xOTsUkAJogfjcltFIOnk3fN0QlSX4rYNsQKSMTOIPEwpmU5qsYTVGXBm+FKZ4iMx+0NQ2ds0EQ8gpeIwGBdCxGLbBQLOhDueqyjQsHUSPHS7I8qhZCoT50XCfiJiGEGg01gi8I49M9mebtZ62VU5p7aal7laaLtFqwc/6adKNoJGBD+6CNncLeFQM3VwfKxSMwFKtI56yMpKuLWb6MVuwBOoY8gvmR0ncRfmG9NOQ7p9RLqcqDpPwUK66Kd+pfCx + +hOh8X9gxGUu4hljLkGul6ZGZOOplWrbXUhOIpbVl21WWroQa2Demc2SUYuJZkRNT1fKRkputfKesPgQnobnoQZ2piKdAVSgtucCRJR1nvh3AS56FzMNH4SYioFlEZkXrd3IjjlQfkHpVqXmaF3IyL6u28JWJChzeD9Jc6KhE2ZyrCmdVztAA7ofRt045VGdE5IPYoPKk40XEAqK+lcW6rdcb4fO6CmJ3noeHkF3Co7viUH7fkoB6qy4Yoy5jWGwp + +18Y4Iktyp6xEqI5R8z7klp86Sdui4uiu3eBFkEKLi32X/zcXwWpGMCMs/jNWAyViR5S7MpyUd2tJEVXFDYKWFAUvE5Uw1R+gB0GZ5DiG3w3YhB3vg2Hrgqrb2ovugRjzIE6Q0WBycsbCL9guoy9Hax/pJVfBjFx+PsTarzmlpILYwuQpFhj9WKms/CCwxaR3kBOvWkunAPqaHAUGnvUqpcPwppVgRq6KxbCx9XJNuhwsMtlNV1guL/Kbw1ZlYoLb + +fDkQghurvdWTr3lWuXskXn0tH5Ok2qrxZFinJOUsx/MYghHo0teBXp0SyQuzlIpSoTdGKxZbuo0sWH3xfDCzWZGbQgSWCBL0hwXlyqiGV16lz7M2k0gfWxSqOoS/DSM2rKxV4ETFDurhxW1/En2b5m/WHCqp4kvgz7eGjqQq4D7T+OHA6b72Mv4z/KIl0vkKyHLDk76IxvdcmW1qKHplBUBBL2zPiKE5hFDZUfBuvYC1P9bUnfr2anREcd016Exk + +rK+mvVtRLZ8OOYNerNrNBbq66YwZdbtN8ozUpfTTdbPgVJ5sdOZACuKq66/F+jHUprSivnKEZQrfsOboDt/rUmF3JXs1SZZTL7bRtqssfHroHSdewzMuuCyuXG87bhm2m/KmNGEpEW/XNPggzkYI8Tw8NeYD7adV5CHm3FAcPoxObtar9HTWEnfAoMdr2KedKhjXTbqYroqfzZquxy9Kq35yRKxfOPWjUnNTpOZZ9uaUub4Wy7B3Dga4utmZzoLm + +9McqUfDsEQ2pUIt4YvqyJQaTmxFACp8CXTUraLS0pcrMsRAcmmoXJq1RYKcSo9KOzgqO2fYWbEX7pkXL1Rkvdb8l81J9mjdJURllQLivdfKTCxdVQJIO4NXq3/f/mNQVO9GqmY2rIp3ENmhVae83etUhK2SKhWEFqxdHECYQd5UVKXfQd9QyK6/fLvi3PXtaWYmgnI4kErWjTpKQJYzfVB97ty3OBtcFmasFb9h+7bwaZCXZuLQKLWf5PsGRTOaC + +KTOo09ivJQFTMYLachC1oyXRXfBmWrSLm77fNQh5Bji+gFV6wRvZ8AEmHEoqrf8YkX0acda2l6yU5lXASqzBAard8HL1nEek8BBmw8vwbWuSTFTRLchLM8Nmy+RZV62xscm2+SIdVobZ5sMo/m+dTWjbf/UiWjZCy45bSpa6L4tbj5MjGO32B99WyvvQxbetgeNU+NqJdtmqsu6hD49IvJu0ZqvPjlYpu9N1qezVV39rKLMTcu3yrUurUSH5akp/ + +rHZuCcGvwypZiSgckK6bfGideJUEaYafmq5hHjVyPi0rud/GxlFHCN5jsNukZPjUqQ0crq/rCAzZEOvY2bONaf3WhXf2Wd3Dm+cddQo81I3xAYBwsUYcVKufbFBy/nL7c05LUBN6OkTa/hee5vxr3nm0jqdaIefnzdyXMpHJJcDXikReTzh6SMDHZB9SiyIvut3UBfnL41Y6bdubqc4RYUXoen8zVr6o+On7wL10h87BfIv121a+C7EtEpwM4Xh2 + +o0cKktJAstSV5/OoNn0bMNHtual0eUyvpjUb0RLua+jX6yNRf74z+NQOTIx91CqURgvjHAWYHWuYpUK578IZtHdylyr6oVCXOaDsm+Mr0Q2e1rLzWlyAVzLj7AL43FopizAna/Ipfc68IMAo3iDVfZ0n+TXuQU1c/lfuvk2+r719W19dAlE49DCAD6JBO+jAxjxr428e+Pxvk3zxlN58bTdJvU3Wb9N9m8zc5v83ebwt4m+LcfGVGvx7EIePwDHj + +FjUGME5eOngQnKgmgSrEsAABW5kVt8oCtx1AI4CAT8aSCMDJBKsvoAAPqEB8T6AQk+BMayknPtx7XnbJSGjwTUARtqXXi20pXEu28hFk5kVn2LsBs83TctybAQjoR1E5CloE9MLx4y8u0ewlYWYlyxWJdhGUxxMAy54JQ+eJU1XhveCSd3wkxDK4U1NlApJKRGSQ3iezhFDTkRUJMpNNM2mfsCRVFCwXwyYoUiYZ9IhrGPoI9bUTp1/iZJpQnlZB + +tZX02jn9N2TJMASEM9pLSIRnXJrRZ+C+y1yG50P+mXyYZn8nJmnJqZ54umd0XQ8LtJ5H4EzW+LPFypSQHYuDqgQI1HmzNPceneOnhMiUwqLRWq1R59SWyYVPKrbpLvCKLBtGAO36V/mXlOD/lx0tSt5JoPanm7Qdg1NjhOWjzp8IaynzhamvLzvSR9h7nCd6uy23Ok2SNmRHPtelo00mhGQln+woSNrjoHE3OAAq3h6K2Y++YjXIi+kKwvTn+f/K + +yVgN6czCPTLdo7PwqPwH4S8wyXPckXwHGp2HAZnAj7Xp3AqjrxWan8PglFAGhV4U+nSEK/ZK9Rs4tbi01m3NbInJUNujWkWj5Yi7nXPWVT8SslBhRWF5mjl4SqFTZADQbXrtR0FnzWvNU+BqX6LB1UNufV+ZjtCzxrZK2lQFe6Kw5hVVZrHERnL5DvmfARS2UL3EPzZKNa9AcMYHj1kcHpCkQBwCbTJWpDl9rXNXcqql5rwloclfrgUAr2jDltIc + +Op6pyV6mvncUur3aS4UxqezlVdfHxQW0kRenAERAjxqyCc6JcsZ6IY2CGijOVJfFAT576nl1ediyppfPOKRSsionXiqsBFkxUKqRRkVK1/nkOMg4hzDar0J40MeBwmgwuggYer0LIJTM8mvrJBsdsnqK5VxYbY6XRPicGQ7V+uV36YQ2kBlFI5fMWFEdx8TW8qiFeF9id+6E3MfQsnxoa9JC7Dl8p6WjiCE9pl1Q21/BXKv7DtlS4quYJ9LJN90J + ++UDcvs57kpZZz1f8nlYRtACC6YOf5ulaUNxA22KDAlAAPLlzFWmNDSDoa5D0ddEZclPvmsCIqzL70J584AOSxeUGMyOZMuj8E5mckLqEhtZuecs9JHQu/zBHh7kj868MRczY67JssVKGaFAe3dGVCZhJVoq+lr3GJdqOa1celK98mgZFKYRxS4rP5pSUi6gLtWRskbglXWZJVYW61buinpa2gLrVztGUgAYrBJUgqE7H4bAgYHB7Sd7W69Kqyqch + +4kqR68fGlUOp60pOqRy5mm3MWQBMFXFCRdU4xhAp4K/8BjpQBe3upSBMOvJ1Q+qMcH/B3k81NDpWs05AiROk/nDAoYQoQs0L7EK/v9rNI/5FOrH0awIMx7UQ8juyDK6NIbYgsy0P2B6EQ0FCTXWtlLTJvUIeAnSk6ZvPujPWVHKPJ80xXOPxyUYKnaxPaUIEIEDkIgVwrWqLZIdolG5UGH5R2LCkg5e4NxHApm0XJLND4c4srNDkBq5E7IWKWRCY + +opUffC1pIUKDAeq6KLKhPpQIR9paoikFPifDVcA2CfhIqDgan7VQeFBoQHSLNnRzLycdEALH0aIkAE1WkftQKrknvAPruGeVImS4SNfiqqoKxIhFSPkyfO3Rv0FcoVRbkRDMoS7+GtMwzF+VzFXTasL1EHRaU/mF74Z8ZHAHYfMUrGIzv+gvFgpYy33KEYksxUGyRX62WggxtmVKmJStkwAsvq6E1mpzSLKSygQKus1oiNQA0NhqqTjGp3nJwHK+ + +PnqzISU8qAqO6ROJ7r5Uq/ggwhkV3hpT9UBckoZuCmgnpLfCPUtdLmGDnOPzYyqQULr0WxAuTRXCi1N8qQI73GCqya/CqAqp+IlBcQAIsStdL72vfqfxcWrnjroAhbXIaQ7c10nkxL+0aoTqfk/weSba0K5PjwHBHQKgpS8/BGzw2U/PhwYdM5VJbwjUNdlYHaUZHECTyMIeoa4AIuPFiKEQwLNTxh845PWqXMBfv6zXEpbB1JEsbZjn5C8hzOVD + +bBj5mNZxwNAc0HAsnpIhodeF1hspjB15EPLB+CPDkHQWsChRRI4QIZ0HL6K0gkwF07KtKzAsvBLEafkJZCazFBqJJGTj077BVz2MNAceD+cWlLdxR2qCv8ILIY5pYyj2eJEtBe0QyAtxv+BIuPya0xlDTInM6asJr1MLZLajwBiqhaSrM3DItrAsGZCui0ylNgHAyBODHiwWMRvCJ5L2JdM/CjmzMFiQOBeTKNRii7TLwwnM3Oo+ze6bhiWFR2Mz + +I/SkMg/DaonMQfFexiaCVBowbWNisIxUCesOQzAsQVA9IRUJZPxpWKR6oa44CCmhVDDhfsEOQCcjgsfiNK/8snyLUB/MBrVhcxBDQAOA/M67yeIKm4KEc1/Fai+UyLCwq4QXztFK3oHfq2YBwPrCHi0Y+pM4jhhdwneSGCOHGcy0qLxBKTZWqPBRLehZ8KqEgkjyvz7mkN8P74yeGzMyow04VGXSwMfpE8G023LjrB86j/mIJkqNSv0jOM8Dujpx + +qdfNMiYuyZHOHQW1PEraEiqyshEO2pjCHjG8fOt2wUhYlKLpCwHTKcCmOIzJcJjCr/PsoshIliLAcmMpC3qq2VZGQ7LE49Ct5kRu/Lgwoy81qKiq2fWLZQ2ay7HcQUh5DotQG8x4BvbjyItJzSAiZ3MCxNWcwgsiw0uDBvamM5pJFyhBnLs7BYq3RjVzQIRShvZeK8VAZT0UZiKkzWquxK/xAUbbOBGayAgvHpwGk+M76qMdfNSrcsDZDbYb2F1B + +Fhz2eEJn4h2zSDxiyEDfCgxtSnVDrDqE+vvWrQqADDHZUC7TgdaVKGUTlRmkMCFrb0cCdg1QgMsdBoy5kGUcEKw0U5MFSEuqTNFQXMwjLDTHsGUX1hkYn3M9zv2b9EnQa8yEnNLw01EeHDcK5ofGG5SE3B3QZkQ8hOpLkEquBEg8V1OPhACtMl9530dkPShDkHXLnSjBT9urTyBPwryFHgmdMRT+YTBhcR8Mo0gHQEh13oOze4aiqjRz2R4MHxXs + +d4eHAU+xtEYyqkp8LtSVaz3KYh320hG1LF0blJSQLE7tHmE4K3OujZEoJdhnRQh5yvLzHsTMp9F3UfNHEC26LpIrQXaZPpeYD6UtMIyUym1ElTWqzoZXqi8CoU/aR8CGolIioq8hdyjUSTCuRlWkMQuxvUNJM4jeMx/tNT78Lit1LHAT0ucQtSULh8A3kSVHtHQgi5NbYnckQdMocGg0F4KqGeUQeQtct1Pmp9m9MYeEXCC4aGwg0VVKxRYUVNCX + +6uUKtOvajSbuNrBXC+LNWxlsc/MLTBMy0JEw0CKsdarfCTzpxRtcGAtZaukrWMCT4R0yqcy0yLpEdxFUZfJvRXKmwhnSqkxMdzb2M+zKiS1kNqJz7fePbFTRjaj1M9602ILO5RcOPqnjS8s01HCS/CEVm4ptSW6NSoToI0IuSuKnJOkyHaKMlWYjAbUt0yRhy7CgY3EYxBVIDYg5Fcyi6GvJ3EWR8CKoQ0BIDgp4yU2vCuyfsbSGwan21igLrhkS + +aiHRtRwKgWS3wcAqDE0yS8TRp8sqesaIt68xP3F18i8eo4HCNDp3Fm8lpH8Chh/cWqrmkDvEYxJkk0cJp4kjgjiKT6zNL9FzEiMvNDeMOmrsLTKESmhwhC6KpPTnKLXEpoXEw+jrAfxESodw6sh7j6YNyV5KSwE6zZmI5/awXr54ZanMlCql0/cVhRg2mHJFaPwmPkZovAqNLsR3kAwi5rAq0lGsxiC5OmRy9mncYwbNsSgt7S4Q/cdlw+88VIIq + +zcOamAm0RCVEkw4csUv3GdUu6sWZERNRqNLEs4Or6raGGIWWyhy3Orjxekf8MdwHx4zluii6mZE5awkyLI3ImkWCpkI0OQ2DXG9IiwHhSjCDZEYj9xYtP5z9hOnHzo1xvFpSRNe/lCfoNyusDEaLQX2npIw+YcQc7lgvOlfrCMriVBIwklSqDTfm4ESCzsMOpHKLRqrFI3ItcUpAHCpRrrFeg1xCNsp7hO/pGswVcy0p2wioJFEzyP0NcX+R381o + +gPy8Kf8fEoJMr9uCxcCyiadK3khnK1SZxW8SGR+eHbA1DlgaMU6qTIqMhuousutP3ExW4xguhyGFOuMkdq4hA2RJMBgsZSXAcycVxg4bxGwEW8kTlioxwOmun4SK/cV/DpCFjOzQRMP0dWQ8K5kvHogk9upQbT0VVC0bwIMcE9IlqsSKjzXsXVpom9QpDM1gsUcBuORPSEahoIdIdXHCQXJpNC4wnkOZLlKQxdfEBZ/ENtkwkqqkyHsBtMbPDHCt + +kkMYiKL4oMV9oGE/cSCwwC8IM1L/wNKZDHU8kLlOhokCCOSkGyLSKUYiUWkQ9G9IV6Cxj1kekp7x6KlUrvRX2Q6tQm026tNKQI0toXPTnxjuvxa90CZGlQZRYHFXIohmtufHNMQ8qeG1k5YI1FRCTNvQryWAqSOgRU+xMsHXoH8e7KFUsJAWqLMT8U0qfWN8uWHwG0ypAEzsKhK5E2omicZpvA/ygKh7eswBvbZyfZC6wZa8jDrxHhvqTCAd25NA + +Zpca0lKCJgqbmOIr2pPzFHAScNQZE75WqFIxaaw1AvakBGX0d3SDsPgU/ZXk9lMTjfCaNH/E9SSstVAkUkfr1i3qLMUHTKWvbPamEyw7JhwGkTwmKrYUJ6gaqHAYivan/sfipFwRUOEI0pxM7NGRwdYl+k/H2kslNxTZqp8PnH3he0WnEtICFM0ILpfgVVJtMVAiAphSESvQpgqA2HTRDhK6hGo7kbvt2oGJohjMyr0AbMKiDGNaVhpPyPDEOSok + +p2rMwj6NxJuq7pPCvWSC8xOCbyk6EalcqpcB6MHwLpc6pdE/0DsnZpKGdfAxSFKlKiawjp9kIAqfAs3AcC1G3MlrSlkxwPak9klzOkbCxysa6G28S6NyRFUG+ucrucKMiqRsBWECslC6e0RAatMnFIlFOqiwNeTS8KpCfj/ExvvEDP+1oqRS8U5iXBzn+s1JuQgkl8otHHwEVAhTEM58SNGcUBLBKrhJUdvEptMAgm8xE2EaREoCkKgaJzlRhcs2 + +Q0BJsjXK3UhwOfEac+ifQ7LybaiHLq0SSXVwAGKpOfHkCYbBKTnwa6aHKk0JsvlwJJzVOSnVC1XGIKpGKwGpb+MHSOUyC8NXBhbAqLCgcL40AQX/BqWwAXjT1+cUVcDkp0POfBL44QpzK8ykDGCp+YTPB1hZJXhpJm8k/gWd5R22XN7paiUKlex/xVBvRw7kBhHnJSyGsjDQAklDpGStMOyekzDKwGuTr6xIchiITq45HnI7EcyTFyTo/VMBo6w9 + +MgWwFUJTq2S4SAqRT5SMbWMp5Ts/Ae+YrOQAglTPc9Ea4mwsonLaiu8UOmFLmCcAltqskyIjpquJEsQMqtQzYTFkPZ1PC6QX2E3JswCpQNHxj0OuUQZT3pl5pwyL4Q6pBzk6/QS95N0MBgda7BsCDXFd0EKmykX6kkSqpzuIKTXInkPwk9IQUBydVSA63ggRZuCQ5I+SCocwtMCQxkCITr+kfxHpqkJdfIWTXoN/rLQPRJLG5hF6uZtgykJLkTQ6 + +zQQTHVBtSuhAFa6GwTFRrFU4cH1jm8KVs5nyZo0s0yQceCt1lpW9qb8Qgii/gjT05yiaHrwWFvHHAgkcySqxJpXuIekQgncSOZTyTslRykJ6THgoaU8OctA/RWFNOxuGtGOoSHeeHDWy90JFKlHrZUul8BCsNqFRoRsuhEfYO0RFmJq8y1PA/AWorSgox2y4nuDwH+i+sny8yJasoFtcLJGMLM08qKhJjWfGldS9gc3guHWURhEZayxUIKNoAsw0 + +knENy03ErqCysDCNb3KAnDQwpeUrGpZVkCJJ0io8KdGuS6UC7K1y5JrlMxhsZYcKZaxUvzGbrushARDqHocdEoqFyqyE1SwOzmpe580BzkJ7sMuVj9GR09ZDKKJkcPLtRgcY/AzZjo7fGKnHS8SsLDxek+MwwVcRcu2S2qxudTaHhA+gNj/EGrIvKOKjukKh5UGQlxT8+99JfQ8YxvKJSu038MeBIspLnqRohUjABTeWpRm/ktcYlHoJ/UuVJNFg + +KD0pVRVSnATMRZ0m1Na5XKIlJDn4yWKgDQL21bK4FD07WqURpWgIkpkz502hTKaWTiPJRls8So1Du0b1I7RS+pYVHTyuPvF0J8FI2u04tazsmyzHpmotnyPyNZDryd0TjGNZyUjFmshWKp0mWRJa1lOjQd0rvo6QSqvFJ+yeKaCskyN8HSMyF30qfpiJ+eCPOiqThMRriwv8KAgZF2FrCqQY3RlOvZp7MjKXHSAk/GG/QRqV9E/LKWfWdMresvCt + +ySL6bwmSlv0vBJcKfOnSA1abKPzE3zvMOHHVJJFlbPryKUhrmQy/WbFr4r2qfrLkojy95GTSSMkNqHoh8I2PFSCCd9NPTdqHTDCC4M1BQxmjkucnKy3oMdLkoBMFfhcKxe4EfaRKMrMiuS/URhSkAauSUj8BXAfaYircUPBEkkBKj5jH4DQjFmnZcasZJSRBwTUPQ4nCatPBRE0xol6RtcXTsfRAU0Uu+QZGatOcTsk6yCUY3CYGpWxdC0ThWk7U + +fNJwwwCFqKZrBcbxe5Sics2TIk/FlUgYzqEvVJxrzGZQNG5+isbiEiluJbgm7IlaJaiUYlGbiiVYl6JTiWYlubtiUEluJUSX4lBboSVklxJRSWklRbpSU0l1JeSV0leJUyUklzJVSWsljJSyWclbJVyUcl3JXyW8lApQyVCltJcKX0llJeW55glbtW4xuqEHkj1uBSDeIQARgK26EA2kEYBjAxJrViO410A1gkmRkpZkUk2OsU7LuKCs2TRO5GBO + +r40MeOHjOmx7tHhXuC2D+6J4Mpve6DofiE+4Z49hK+5OECphqbfuAkp8h/uF2IB7+lkkkEQ6mAiOB5QoCklB5KSNmCpLwemcBaa4An4taZxmJGKDjjGAtC6aUYbpsxAx4VGFSgemaED05CwmhFZJ+mNkuR6b4DknUTwetHpxiH4QqO+QuJvkD5Lk4XODfjmgmqHTgM4xqAgT1gz+Gziv4zqJzh3gfQJ/gsQCAGxD84TAL/hC4/+HyCi4noMJBRAI + +BGaZYYEBPJBQEvZbAQZoauEZABmBsAWg64e0THjmYFaIbhylYAFeKFYjbhIAwAAANIMQ+ANUDKAlWBO6U477njDN8EFIhxWG7TI2QQANJm7gglFpa6SbS27h/CUSJ6ERK8AMeMKaoAtEmwiZ4rpZKYbY7Etnjym+2DxJfu7hGgieEzCMGViSQHmGXamoHrqYQeMZUjDQe0RAmXplkAEmW945SGmXOSdMFLDoqljJPhOmQFYWVw4E2PiifR5WsyiV + +E6OEeUUewZo5LUeLko2VRmQjKIiseHZeOWK49ON2W04KlX2WIQA5bwBDlDqCOUuoyldzh8QnqNOXvuAuP6iLl10MuXtQq5WGjiQG5TLhy4CuDZCqVnoGmhwEmaIeXVlyBNrjaEuuOeVYEbkJZhG41aPKXXi95egDEQ2ABwDEQhABQBNoOwKlDalX5VwRFgZ+m3QB2cJHf6XwohKBV9kl2jWzJCUFeMgwVOuHrhuVceI6UBlqFUxJuljIB6XSmDEr + +KacSe2JQifubyBJLvQMGEJLEVeFZ1UgegYGB4QoVFQaY0VcZTIj0VbFVljJlvoKxXoeIOMMA7SdKK/TtQhZTPjWIeZfxVoQgCXxwkeVROJU1llHlJX1l++HR6E4vZphCk4vRFfi7lQKD2UaVD+NpWJA9qOzijl7+IZWTl8mKZWzlnEILifVQaCGjAE4aKAQyQW5fLg7lD1W5Uq4nlVWUU4KBKeUYEQ8IFU4EdbjeXgAnsBlBwAcAHKDqw3ABFDQA + +E0FkCeoUeFsAMAhAAgAUAMUA1WbYTVZSDig9NQzUDAEANgAiA5CL6C9A+gHKDfQNVRKak1LNdXAPQ7NZkBU1thJ6UvuWFVxJFAzNazWC1HNbFW4VHVTVjS1AtTkBC1nNd1VBlUtfzVs1HNVzW+EfVUrXa1stZkC6Q4ZRRVa1MtarUc1dQFGV4YFtSrVQAatcRAv4TqAZVlARtVbWZAztf2Xq4z1fbU61mQC5CfV3+P7XG16tWnDNwncLXAOVytQH + +X6Ai4JyCR1FANHXJgHcJqWx1YdUnXm4yVdchM1HtY7Vy16MKbXGg2KO9CpYpIPgBW4s6OKRWkZFBaS5FKcOXXSg1QE/i8EDAiHhFUEtA+hKlbAAYB411iAQAmQ6BOyTGaBWBnWe1+gKbXEwgOBAC51pNWyAkAj+IOXz1suMQBygCAOlhUQK9SQBNobANlgJ1uAJoDBAbHtZhiIJAH+iFIMUKSBtwpAMoBMgiqNcTUAvAGdzP1q0EhUpUhqJ6D6Qy + +gEeLHIt9ffUNxT9YA28AzUE/Xie6qGPX51etYSA21XEJwDSVUtTEQIA+kImCy42cJoiNw8uEfViV3lZADYARAJvXVEEAPLhE12aAdXRo2kPmiw1gIP2ikAhICvByI1DZ6C0N9DQfXYNZHggBj1dgK24IA28MwAyg8uHAC71+9Vg3H1SlY+jbwhAIwDNAvdfgD917UBvCKgGQJI0WIKWEIA4gBgNnWoQLHu2WJmaMAYAygyjXA3MQImCkihA9EJI3 + +SNsjaXBj1jgMwCH1wQCSA5AfQE2jZAQgBeJXiH7sEBkwIUCAAhQQAA== ``` %% \ No newline at end of file diff --git a/Excalidraw/Scripts/Downloaded/Mindmap format.md b/Excalidraw/Scripts/Downloaded/Mindmap format.md new file mode 100644 index 0000000..fc753fb --- /dev/null +++ b/Excalidraw/Scripts/Downloaded/Mindmap format.md @@ -0,0 +1,370 @@ +/* + +format **the left to right** mind map + +![](https://raw.githubusercontent.com/zsviczian/obsidian-excalidraw-plugin/master/images/scripts-mindmap-format-1.png) + +# tree + +Mind map is actually a tree, so you must have a **root node**. The script will determine **the leftmost element** of the selected element as the root element (node is excalidraw element, e.g. rectangle, diamond, ellipse, text, image, but it can't be arrow, line, freedraw, **group**) + +The element connecting node and node must be an **arrow** and have the correct direction, e.g. **parent node -> children node** + +# sort + +The order of nodes in the Y axis or vertical direction is determined by **the creation time** of the arrow connecting it + +![](https://raw.githubusercontent.com/zsviczian/obsidian-excalidraw-plugin/master/images/scripts-mindmap-format-2.png) + +So if you want to readjust the order, you can **delete arrows and reconnect them** + +# setting + +Script provides options to adjust the style of mind map, The option is at the bottom of the option of the exalidraw plugin(e.g. Settings -> Community plugins -> Excalidraw -> drag to bottom) + +# problem + +1. since the start bingding and end bingding of the arrow are easily disconnected from the node, so if there are unformatted parts, please **check the connection** and use the script to **reformat** + +```javascript +*/ + +let settings = ea.getScriptSettings(); +//set default values on first run +if (!settings["MindMap Format"]) { + settings = { + "MindMap Format": { + value: "Excalidraw/MindMap Format", + description: + "This is prepared for the namespace of MindMap Format and does not need to be modified", + }, + "default gap": { + value: 10, + description: "Interval size of element", + }, + "curve length": { + value: 40, + description: "The length of the curve part in the mind map line", + }, + "length between element and line": { + value: 50, + description: + "The distance between the tail of the connection and the connecting elements of the mind map", + }, + }; + ea.setScriptSettings(settings); +} + +const sceneElements = ea.getExcalidrawAPI().getSceneElements(); + +// default X coordinate of the middle point of the arc +const defaultDotX = Number(settings["curve length"].value); +// The default length from the middle point of the arc on the X axis +const defaultLengthWithCenterDot = Number( + settings["length between element and line"].value +); +// Initial trimming distance of the end point on the Y axis +const initAdjLength = 4; +// default gap +const defaultGap = Number(settings["default gap"].value); + +const setCenter = (parent, line) => { + // Focus and gap need the api calculation of excalidraw + // e.g. determineFocusDistance, but they are not available now + // so they are uniformly set to 0/1 + line.startBinding.focus = 0; + line.startBinding.gap = 1; + line.endBinding.focus = 0; + line.endBinding.gap = 1; + line.x = parent.x + parent.width; + line.y = parent.y + parent.height / 2; +}; + +/** + * set the middle point of curve + * @param {any} lineEl the line element of excalidraw + * @param {number} height height of dot on Y axis + * @param {number} [ratio=1] ，coefficient of the initial trimming distance of the end point on the Y axis, default is 1 + */ +const setTopCurveDotOnLine = (lineEl, height, ratio = 1) => { + if (lineEl.points.length < 3) { + lineEl.points.splice(1, 0, [defaultDotX, lineEl.points[0][1] - height]); + } else if (lineEl.points.length === 3) { + lineEl.points[1] = [defaultDotX, lineEl.points[0][1] - height]; + } else { + lineEl.points.splice(2, lineEl.points.length - 3); + lineEl.points[1] = [defaultDotX, lineEl.points[0][1] - height]; + } + lineEl.points[2][0] = lineEl.points[1][0] + defaultLengthWithCenterDot; + // adjust the curvature of the second line segment + lineEl.points[2][1] = lineEl.points[1][1] - initAdjLength * ratio * 0.8; +}; + +const setMidCurveDotOnLine = (lineEl) => { + if (lineEl.points.length < 3) { + lineEl.points.splice(1, 0, [defaultDotX, lineEl.points[0][1]]); + } else if (lineEl.points.length === 3) { + lineEl.points[1] = [defaultDotX, lineEl.points[0][1]]; + } else { + lineEl.points.splice(2, lineEl.points.length - 3); + lineEl.points[1] = [defaultDotX, lineEl.points[0][1]]; + } + lineEl.points[2][0] = lineEl.points[1][0] + defaultLengthWithCenterDot; + lineEl.points[2][1] = lineEl.points[1][1]; +}; + +/** + * set the middle point of curve + * @param {any} lineEl the line element of excalidraw + * @param {number} height height of dot on Y axis + * @param {number} [ratio=1] ，coefficient of the initial trimming distance of the end point on the Y axis, default is 1 + */ +const setBottomCurveDotOnLine = (lineEl, height, ratio = 1) => { + if (lineEl.points.length < 3) { + lineEl.points.splice(1, 0, [defaultDotX, lineEl.points[0][1] + height]); + } else if (lineEl.points.length === 3) { + lineEl.points[1] = [defaultDotX, lineEl.points[0][1] + height]; + } else { + lineEl.points.splice(2, lineEl.points.length - 3); + lineEl.points[1] = [defaultDotX, lineEl.points[0][1] + height]; + } + lineEl.points[2][0] = lineEl.points[1][0] + defaultLengthWithCenterDot; + // adjust the curvature of the second line segment + lineEl.points[2][1] = lineEl.points[1][1] + initAdjLength * ratio * 0.8; +}; + +const setTextXY = (rect, text) => { + text.x = rect.x + (rect.width - text.width) / 2; + text.y = rect.y + (rect.height - text.height) / 2; +}; + +const setChildrenXY = (parent, children, line, elementsMap) => { + x = parent.x + parent.width + line.points[2][0]; + y = parent.y + parent.height / 2 + line.points[2][1] - children.height / 2; + distX = children.x - x; + distY = children.y - y; + + ea.getElementsInTheSameGroupWithElement(children, sceneElements).forEach((el) => { + el.x = el.x - distX; + el.y = el.y - distY; + }); + + if ( + ["rectangle", "diamond", "ellipse"].includes(children.type) && + ![null, undefined].includes(children.boundElements) + ) { + const textDesc = children.boundElements.filter( + (el) => el.type === "text" + )[0]; + if (textDesc !== undefined) { + const textEl = elementsMap.get(textDesc.id); + setTextXY(children, textEl); + } + } +}; + +/** + * returns the height of the upper part of all child nodes + * and the height of the lower part of all child nodes + * @param {Number[]} childrenTotalHeightArr + * @returns {Number[]} [topHeight, bottomHeight] + */ +const getNodeCurrentHeight = (childrenTotalHeightArr) => { + if (childrenTotalHeightArr.length <= 0) return [0, 0]; + else if (childrenTotalHeightArr.length === 1) + return [childrenTotalHeightArr[0] / 2, childrenTotalHeightArr[0] / 2]; + const heightArr = childrenTotalHeightArr; + let topHeight = 0, + bottomHeight = 0; + const isEven = heightArr.length % 2 === 0; + const mid = Math.floor(heightArr.length / 2); + const topI = mid - 1; + const bottomI = isEven ? mid : mid + 1; + topHeight = isEven ? 0 : heightArr[mid] / 2; + for (let i = topI; i >= 0; i--) { + topHeight += heightArr[i]; + } + bottomHeight = isEven ? 0 : heightArr[mid] / 2; + for (let i = bottomI; i < heightArr.length; i++) { + bottomHeight += heightArr[i]; + } + return [topHeight, bottomHeight]; +}; + +/** + * handle the height of each point in the single-level tree + * @param {Array} lines + * @param {Map} elementsMap + * @param {Boolean} isEven + * @param {Number} mid 'lines' array midpoint index + * @returns {Array} height array corresponding to 'lines' + */ +const handleDotYValue = (lines, elementsMap, isEven, mid) => { + const getTotalHeight = (line, elementsMap) => { + return elementsMap.get(line.endBinding.elementId).totalHeight; + }; + const getTopHeight = (line, elementsMap) => { + return elementsMap.get(line.endBinding.elementId).topHeight; + }; + const getBottomHeight = (line, elementsMap) => { + return elementsMap.get(line.endBinding.elementId).bottomHeight; + }; + const heightArr = new Array(lines.length).fill(0); + const upI = mid === 0 ? 0 : mid - 1; + const bottomI = isEven ? mid : mid + 1; + let initHeight = isEven ? 0 : getTopHeight(lines[mid], elementsMap); + for (let i = upI; i >= 0; i--) { + heightArr[i] = initHeight + getBottomHeight(lines[i], elementsMap); + initHeight += getTotalHeight(lines[i], elementsMap); + } + initHeight = isEven ? 0 : getBottomHeight(lines[mid], elementsMap); + for (let i = bottomI; i < lines.length; i++) { + heightArr[i] = initHeight + getTopHeight(lines[i], elementsMap); + initHeight += getTotalHeight(lines[i], elementsMap); + } + return heightArr; +}; + +/** + * format single-level tree + * @param {any} parent + * @param {Array} lines + * @param {Map} childrenDescMap + * @param {Map} elementsMap + */ +const formatTree = (parent, lines, childrenDescMap, elementsMap) => { + lines.forEach((item) => setCenter(parent, item)); + + const isEven = lines.length % 2 === 0; + const mid = Math.floor(lines.length / 2); + const heightArr = handleDotYValue(lines, childrenDescMap, isEven, mid); + lines.forEach((item, index) => { + if (isEven) { + if (index < mid) setTopCurveDotOnLine(item, heightArr[index], index + 1); + else setBottomCurveDotOnLine(item, heightArr[index], index - mid + 1); + } else { + if (index < mid) setTopCurveDotOnLine(item, heightArr[index], index + 1); + else if (index === mid) setMidCurveDotOnLine(item); + else setBottomCurveDotOnLine(item, heightArr[index], index - mid); + } + }); + lines.forEach((item) => { + if (item.endBinding !== null) { + setChildrenXY( + parent, + elementsMap.get(item.endBinding.elementId), + item, + elementsMap + ); + } + }); +}; + +const generateTree = (elements) => { + const elIdMap = new Map([[elements[0].id, elements[0]]]); + let minXEl = elements[0]; + for (let i = 1; i < elements.length; i++) { + elIdMap.set(elements[i].id, elements[i]); + if ( + !(elements[i].type === "arrow" || elements[i].type === "line") && + elements[i].x < minXEl.x + ) { + minXEl = elements[i]; + } + } + const root = { + el: minXEl, + totalHeight: minXEl.height, + topHeight: 0, + bottomHeight: 0, + linkChildrensLines: [], + isLeafNode: false, + children: [], + }; + const preIdSet = new Set(); // The id_set of Elements that is already in the tree, avoid a dead cycle + const dfsForTreeData = (root) => { + if (preIdSet.has(root.el.id)) { + return 0; + } + preIdSet.add(root.el.id); + let lines = root.el.boundElements.filter( + (el) => + el.type === "arrow" && + !preIdSet.has(el.id) && + elIdMap.get(el.id)?.startBinding?.elementId === root.el.id + ); + if (lines.length === 0) { + root.isLeafNode = true; + root.totalHeight = root.el.height + 2 * defaultGap; + [root.topHeight, root.bottomHeight] = [ + root.totalHeight / 2, + root.totalHeight / 2, + ]; + return root.totalHeight; + } else { + lines = lines.map((elementDesc) => { + preIdSet.add(elementDesc.id); + return elIdMap.get(elementDesc.id); + }); + } + + const linkChildrensLines = []; + lines.forEach((el) => { + const line = el; + if ( + line && + line.endBinding !== null && + line.endBinding !== undefined && + !preIdSet.has(elIdMap.get(line.endBinding.elementId).id) + ) { + const children = elIdMap.get(line.endBinding.elementId); + linkChildrensLines.push(line); + root.children.push({ + el: children, + totalHeight: 0, + topHeight: 0, + bottomHeight: 0, + linkChildrensLines: [], + isLeafNode: false, + children: [], + }); + } + }); + + let totalHeight = 0; + root.children.forEach((el) => (totalHeight += dfsForTreeData(el))); + + root.linkChildrensLines = linkChildrensLines; + if (root.children.length === 0) { + root.isLeafNode = true; + root.totalHeight = root.el.height + 2 * defaultGap; + [root.topHeight, root.bottomHeight] = [ + root.totalHeight / 2, + root.totalHeight / 2, + ]; + } else if (root.children.length > 0) { + root.totalHeight = Math.max(root.el.height + 2 * defaultGap, totalHeight); + [root.topHeight, root.bottomHeight] = getNodeCurrentHeight( + root.children.map((item) => item.totalHeight) + ); + } + + return totalHeight; + }; + dfsForTreeData(root); + const dfsForFormat = (root) => { + if (root.isLeafNode) return; + const childrenDescMap = new Map( + root.children.map((item) => [item.el.id, item]) + ); + formatTree(root.el, root.linkChildrensLines, childrenDescMap, elIdMap); + root.children.forEach((el) => dfsForFormat(el)); + }; + dfsForFormat(root); +}; + +const elements = ea.getViewSelectedElements(); +generateTree(elements); + +ea.copyViewElementsToEAforEditing(elements); +await ea.addElementsToView(false, false); diff --git a/Excalidraw/Scripts/Downloaded/Mindmap format.svg b/Excalidraw/Scripts/Downloaded/Mindmap format.svg new file mode 100644 index 0000000..27ec6eb --- /dev/null +++ b/Excalidraw/Scripts/Downloaded/Mindmap format.svg @@ -0,0 +1 @@ + \ No newline at end of file