diff --git a/.gitignore b/.gitignore index 10e2d9ee..0d71973c 100644 --- a/.gitignore +++ b/.gitignore @@ -26,5 +26,4 @@ yarn-error.log* *.local .cache -!.gitkeep - +!.gitkeep \ No newline at end of file diff --git a/extensions/PortFromTurboWarp/mybearworld/xml.js b/extensions/PortFromTurboWarp/mybearworld/xml.js new file mode 100644 index 00000000..3252b44a --- /dev/null +++ b/extensions/PortFromTurboWarp/mybearworld/xml.js @@ -0,0 +1,668 @@ +// Name: XML +// ID: mbwxml +// Description: Create and extract values from XML. +// By: mybearworld +// License: MIT +/* + Adapted and submitted to Gandi-IDE by 多bug的啸天犬 @ CCW + Authorized by the original author + Proof of authorized behavior by the original author: + https://fastly.jsdelivr.net/gh/MoreBugOfDog/PicGo-cdn-files/20240620-204009.jpg +*/ + +/* + 由 多bug的啸天犬 @ CCW 改编后提交到Gandi-IDE + 已获得原作者授权 + 原作者授权行为证明： + https://fastly.jsdelivr.net/gh/MoreBugOfDog/PicGo-cdn-files/20240620-204009.jpg +*/ + +// 多bug的啸天犬 @ CCW 优化了中文翻译，并添加了官方拓展市场的相关配置（window.tempExt）以及绘制Icon和封面。 +/* generated l10n code */ +// 英语I10n写在默认text里，所以只标注一个作者的I10n +// "original"的意思是 原 这里指“原作者”，这样写询问了原作者的意见，取得了同意。 +Scratch.translate.setup({ + en:{ + '_skydogName':'[rearrange]多bug的啸天犬 @ CCW', + '_mybearworldName':'[original]mybearworld @ TurboWarp', + }, + 'zh-cn': { + '_add child [CHILD] to [XML]': '[XML]添加子元素[CHILD]', + '_attribute [ATTR] of [XML]': '[XML]中属性[ATTR]的值', + '_attributes of [XML]': '[XML]的所有属性', + '_child #[NO] of [XML]': '[XML]第[NO]个子元素', + '_children amount of [XML]': '[XML]的子元素数量', + '_does [XML] have attribute [ATTR]?': '[XML]有属性[ATTR]吗？', + '_does [XML] have children?': '[XML]有子元素吗？', + '_error message of [MAYBE_XML]': '[MAYBE_XML]的错误信息', + '_is [MAYBE_XML] valid XML?': '[MAYBE_XML]是合法 XML？', + '_query [QUERY] on [XML]': '[XML]中第一个匹配[QUERY]的元素', + '_query [QUERY] on [XML] matches?': '[XML]能匹配[QUERY]吗？', + '_query all [QUERY] on [XML]': '[XML]中所有匹配[QUERY]的元素', + '_remove attribute [ATTR] of [XML]': '删除[XML]的属性[ATTR]', + '_remove child #[NO] of [XML]': '删除[XML]第[NO]个子元素', + '_replace child #[NO] of [XML] with [CHILD]': + '将[XML]第[NO]子元素替换为[CHILD]', + '_set attribute [ATTR] of [XML] to [VALUE]': + '设置[XML]的属性[ATTR]为[VALUE]', + '_tag name of [XML]': '[XML]的标签名称', + '_text of [XML]': '[XML]的文本', + '_set text of [XML] to [VALUE]': '设置[XML]的内部文本为[VALUE]', + '_skydogName':'[改编]多bug的啸天犬 @ CCW', + '_mybearworldName':'[原作者]mybearworld @ TurboWarp', + } +}) +/* end generated l10n code */ ;(function (Scratch) { + 'use strict' + const xmlIcon = 'data:image/svg+xml;base64,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' + const xmlPicture = 'data:image/svg+xml;base64,<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="686.2208" height="385.9992" viewBox="0,0,686.2208,385.9992"><g transform="translate(23.1104,12.9996)"><g data-paper-data="{&quot;isPaintingLayer&quot;:true}" fill="none" fill-rule="nonzero" stroke-linejoin="miter" stroke-miterlimit="10" stroke-dasharray="" stroke-dashoffset="0" style="mix-blend-mode: normal"><image x="-43.10757" y="-24.24801" transform="scale(0.53611,0.53611)" width="1280" height="720" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABQAAAALQCAYAAADPfd1WAAAAAXNSR0IArs4c6QAAIABJREFUeF7t2EENACAQA0FQiUREIA4SZGzmHHR6r86z9h2OAAECBAgQIECAAAECBAgQIECAAIGkwDQAJnsVigABAgQIECBAgAABAgQIECBAgMAXMAB6BAIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMD5r4TdAAAgAElEQVQA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRmP6swAAAATeSURBVIAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECBgAPQDBAgQIECAAAECBAgQIECAAAECBMICBsBwuaIRIECAAAECBAgQIECAAAECBAgQMAD6AQIECBAgQIAAAQIECBAgQIAAAQJhAQNguFzRCBAgQIAAAQIECBAgQIAAAQIECBgA/QABAgQIECBAgAABAgQIECBAgACBsIABMFyuaAQIECBAgAABAgQIECBAgAABAgQMgH6AAAECBAgQIECAAAECBAgQIECAQFjAABguVzQCBAgQIECAAAECBAgQIECAAAECBkA/QIAAAQIECBAgQIAAAQIECBAgQCAsYAAMlysaAQIECBAgQIAAAQIECBAgQIAAAQOgHyBAgAABAgQIECBAgAABAgQIECAQFjAAhssVjQABAgQIECBAgAABAgQIECBAgIAB0A8QIECAAAECBAgQIECAAAECBAgQCAsYAMPlikaAAAECBAgQIECAAAECBAgQIEDAAOgHCBAgQIAAAQIECBAgQIAAAQIECIQFDIDhckUjQIAAAQIECBAgQIAAAQIECBAgYAD0AwQIECBAgAABAgQIECBAgAABAgTCAgbAcLmiESBAgAABAgQIECBAgAABAgQIEDAA+gECBAgQIECAAAECBAgQIECAAAECYQEDYLhc0QgQIECAAAECBAgQIECAAAECBAgYAP0AAQIECBAgQIAAAQIECBAgQIAAgbCAATBcrmgECBAgQIAAAQIECBAgQIAAAQIEDIB+gAABAgQIECBAgAABAgQIECBAgEBYwAAYLlc0AgQIECBAgAABAgQIECBAgAABAgZAP0CAAAECBAgQIECAAAECBAgQIEAgLGAADJcrGgECBAgQIECAAAECBAgQIECAAAEDoB8gQIAAAQIECBAgQIAAAQIECBAgEBYwAIbLFY0AAQIECBAgQIAAAQIECBAgQICAAdAPECBAgAABAgQIECBAgAABAgQIEAgLGADD5YpGgAABAgQIECBAgAABAgQIECBAwADoBwgQIECAAAECBAgQIECAAAECBAiEBQyA4XJFI0CAAAECBAgQIECAAAECBAgQIGAA9AMECBAgQIAAAQIECBAgQIAAAQIEwgIGwHC5ohEgQIAAAQIECBAgQIAAAQIECBAwAPoBAgQIECBAgAABAgQIECBAgAABAmEBA2C4XNEIECBAgAABAgQIECBAgAABAgQIGAD9AAECBAgQIECAAAECBAgQIECAAIGwgAEwXK5oBAgQIECAAAECBAgQIECAAAECBAyAfoAAAQIECBAgQIAAAQIECBAgQIBAWMAAGC5XNAIECBAgQIAAAQIECBAgQIAAAQIGQD9AgAABAgQIECBAgAABAgQIECBAICxgAAyXKxoBAgQIECBAgAABAgQIECBAgAABA6AfIECAAAECBAgQIECAAAECBAgQIBAWMACGyxWNAAECBAgQIECAAAECBAgQIECAgAHQDxAgQIAAAQIECBAgQIAAAQIECBAICxgAw+WKRoAAAQIECBAgQIAAAQIECBAgQMAA6AcIECBAgAABAgQIECBAgAABAgQIhAUMgOFyRSNAgAABAgQIECBAgAABAgQIECDwAJc7qLrteIYdAAAAAElFTkSuQmCC" stroke="none" stroke-width="0.5" stroke-linecap="butt"/><path d="M185.5,263.50474c0,-58.13908 0,-149.03889 0,-178.48341c0,-18.62023 22.46539,-39.52133 42.07109,-39.52133c31.32583,0 126.95434,0 183.58294,0c25.68444,0 43.34597,28.08095 43.34597,50.99526c0,29.91617 0,108.97355 0,163.18483c0,31.64235 -20.64157,54.81991 -49.72038,54.81991c-56.7464,0 -145.62376,0 -175.93364,0c-20.09156,0 -43.34598,-20.54041 -43.34598,-50.99527z" stroke="#ffffff" stroke-width="40" stroke-linecap="butt"/><path d="M378.25,238.25l-116.5,-116.5" stroke="#ffffff" stroke-width="40" stroke-linecap="round"/><path d="M378.25,121.75l-116.5,116.5" data-paper-data="{&quot;index&quot;:null}" stroke="#ffffff" stroke-width="40" stroke-linecap="round"/></g></g></svg>' + class XML { + constructor() { + this.domParser = new DOMParser() + } + /** + * @param {string} string + * @returns {{xml: null; error: string} | {xml: HTMLElement; error: null}} + */ + stringToXml(string) { + const doc = this.domParser.parseFromString(string, 'application/xml') + const error = doc.querySelector('parsererror') + if (error) { + console.error(error.textContent) + return { xml: null, error: error.textContent } + } + return { xml: doc.documentElement, error: null } + } + /** @param {Element} element */ + xmlToString(element) { + return element.outerHTML + } + + /** @returns {Scratch.Info} */ + getInfo() { + return { + id: 'mbwxml', + name: 'XML', + color1: '#ba48a3', + color2:'#ba48a3', + color2:'#ba48a3', + menuIconURI:xmlIcon, + blockIconURI:xmlIcon, + blocks: [ + // For translations: + // - Block text should be translated + // - Default XML and attributes should NOT be translated because we can't expect translators + // to know how to write valid XML in their language. + { + opcode: 'isValid', + blockType: Scratch.BlockType.BOOLEAN, + text: Scratch.translate('is [MAYBE_XML] valid XML?'), + arguments: { + MAYBE_XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'errorMessage', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('error message of [MAYBE_XML]'), + arguments: { + MAYBE_XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + '---', + { + opcode: 'tagName', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('tag name of [XML]'), + arguments: { + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'textContent', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('text of [XML]'), + arguments: { + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: 'world' + } + } + }, + { + opcode: 'setTextContent', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('set text of [XML] to [VALUE]'), + arguments: { + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: 'world' + }, + VALUE: { + type: Scratch.ArgumentType.STRING, + defaultValue: 'world!' + } + } + }, + '---', + { + opcode: 'attributes', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('attributes of [XML]'), + arguments: { + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'hasAttribute', + blockType: Scratch.BlockType.BOOLEAN, + text: Scratch.translate('does [XML] have attribute [ATTR]?'), + arguments: { + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + }, + ATTR: { + type: Scratch.ArgumentType.STRING, + defaultValue: 'foo' + } + } + }, + { + opcode: 'setAttribute', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('set attribute [ATTR] of [XML] to [VALUE]'), + arguments: { + ATTR: { + type: Scratch.ArgumentType.STRING, + defaultValue: 'apple' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + }, + VALUE: { + type: Scratch.ArgumentType.STRING, + defaultValue: 'foo' + } + } + }, + { + opcode: 'getAttribute', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('attribute [ATTR] of [XML]'), + arguments: { + ATTR: { + type: Scratch.ArgumentType.STRING, + defaultValue: 'apple' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'removeAttribute', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('remove attribute [ATTR] of [XML]'), + arguments: { + ATTR: { + type: Scratch.ArgumentType.STRING, + defaultValue: 'apple' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + '---', + { + opcode: 'hasChildren', + blockType: Scratch.BlockType.BOOLEAN, + text: Scratch.translate('does [XML] have children?'), + arguments: { + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'childrenAmount', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('children amount of [XML]'), + arguments: { + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'addChild', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('add child [CHILD] to [XML]'), + arguments: { + CHILD: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'replaceChild', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + 'replace child #[NO] of [XML] with [CHILD]' + ), + arguments: { + NO: { + type: Scratch.ArgumentType.NUMBER, + defaultValue: '2' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + }, + CHILD: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'getChild', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('child #[NO] of [XML]'), + arguments: { + NO: { + type: Scratch.ArgumentType.NUMBER, + defaultValue: '2' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'removeChild', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('remove child #[NO] of [XML]'), + arguments: { + NO: { + type: Scratch.ArgumentType.NUMBER, + defaultValue: '2' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + '---', + { + opcode: 'querySuccessful', + blockType: Scratch.BlockType.BOOLEAN, + text: Scratch.translate('query [QUERY] on [XML] matches?'), + arguments: { + QUERY: { + type: Scratch.ArgumentType.STRING, + defaultValue: '.foo' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'querySelector', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('query [QUERY] on [XML]'), + arguments: { + QUERY: { + type: Scratch.ArgumentType.STRING, + defaultValue: '.foo' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + }, + { + opcode: 'querySelectorAll', + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate('query all [QUERY] on [XML]'), + arguments: { + QUERY: { + type: Scratch.ArgumentType.STRING, + defaultValue: '.foo' + }, + XML: { + type: Scratch.ArgumentType.STRING, + defaultValue: '' + } + } + } + ] + } + } + + /** + * @param {object} args + * @param {unknown} args.MAYBE_XML + */ + isValid({ MAYBE_XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(MAYBE_XML)) + return xml !== null + } + + /** + * @param {object} args + * @param {unknown} args.MAYBE_XML + */ + errorMessage({ MAYBE_XML }) { + const { xml, error } = this.stringToXml(Scratch.Cast.toString(MAYBE_XML)) + return xml === null ? error : '' + } + + /** + * @param {object} args + * @param {unknown} args.XML + */ + tagName({ XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + return xml.tagName + } + + /** + * @param {object} args + * @param {unknown} args.XML + */ + textContent({ XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + return xml.textContent + } + + /** + * @param {object} args + * @param {unknown} args.XML + * @param {unknown} args.VALUE + */ + setTextContent({ XML, VALUE }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + xml.textContent = VALUE + return this.xmlToString(xml) + } + + /** + * @param {object} args + * @param {unknown} args.XML + */ + attributes({ XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + return JSON.stringify([...xml.attributes].map(attr => attr.name)) + } + + /** + * @param {object} args + * @param {unknown} args.XML + * @param {unknown} args.ATTR + */ + hasAttribute({ XML, ATTR }) { + return this.getAttribute({ XML, ATTR }) !== '' + } + + /** + * @param {object} args + * @param {unknown} args.ATTR + * @param {unknown} args.XML + * @param {unknown} args.VALUE + */ + setAttribute({ ATTR, XML, VALUE }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + xml.setAttribute( + Scratch.Cast.toString(ATTR), + Scratch.Cast.toString(VALUE) + ) + return this.xmlToString(xml) + } + + /** + * @param {object} args + * @param {unknown} args.ATTR + * @param {unknown} args.XML + */ + getAttribute({ ATTR, XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + return xml.getAttribute(Scratch.Cast.toString(ATTR)) ?? '' + } + + /** + * @param {object} args + * @param {unknown} args.ATTR + * @param {unknown} args.XML + */ + removeAttribute({ ATTR, XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + xml.removeAttribute(Scratch.Cast.toString(ATTR)) + return this.xmlToString(xml) + } + + /** + * @param {object} args + * @param {unknown} args.XML + */ + hasChildren({ XML }) { + return this.childrenAmount({ XML }) !== 0 + } + + /** + * @param {object} args + * @param {unknown} args.XML + */ + childrenAmount({ XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return 0 + } + return xml.childElementCount + } + + /** + * @param {object} args + * @param {unknown} args.CHILD + * @param {unknown} args.XML + */ + addChild({ CHILD, XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + const { xml: childXML } = this.stringToXml(Scratch.Cast.toString(CHILD)) + if (childXML === null) { + return this.xmlToString(xml) + } + xml.append(childXML) + return this.xmlToString(xml) + } + + /** + * @param {object} args + * @param {unknown} args.NO + * @param {unknown} args.XML + * @param {unknown} args.CHILD + */ + replaceChild({ NO, XML, CHILD }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + const { xml: childXML } = this.stringToXml(Scratch.Cast.toString(CHILD)) + if (childXML === null) { + return this.xmlToString(xml) + } + const originalChild = + xml.children[Math.floor(Scratch.Cast.toNumber(NO)) - 1] + if (originalChild === undefined) { + return this.xmlToString(xml) + } + xml.replaceChild(childXML, originalChild) + return this.xmlToString(xml) + } + + /** + * @param {object} args + * @param {unknown} args.NO + * @param {unknown} args.XML + */ + getChild({ NO, XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + const child = xml.children[Math.floor(Scratch.Cast.toNumber(NO)) - 1] + if (child === undefined) { + return '' + } + return this.xmlToString(child) + } + + /** + * @param {object} args + * @param {unknown} args.NO + * @param {unknown} args.XML + */ + removeChild({ NO, XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + const child = xml.children[Math.floor(Scratch.Cast.toNumber(NO)) - 1] + if (child === undefined) { + return this.xmlToString(xml) + } + xml.removeChild(child) + return this.xmlToString(xml) + } + + /** + * @param {object} args + * @param {unknown} args.QUERY + * @param {unknown} args.XML + */ + querySuccessful({ QUERY, XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + const child = xml.querySelector(Scratch.Cast.toString(QUERY)) + return child !== null + } + + /** + * @param {object} args + * @param {unknown} args.QUERY + * @param {unknown} args.XML + */ + querySelector({ QUERY, XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + const child = xml.querySelector(Scratch.Cast.toString(QUERY)) + if (child === null) { + return '' + } + return this.xmlToString(child) + } + /** + * @param {object} args + * @param {unknown} args.QUERY + * @param {unknown} args.XML + */ + querySelectorAll({ QUERY, XML }) { + const { xml } = this.stringToXml(Scratch.Cast.toString(XML)) + if (xml === null) { + return '' + } + const child = xml.querySelectorAll(Scratch.Cast.toString(QUERY)) + if (child.length === 0) { + return '' + } + return JSON.stringify([...child].map(this.xmlToString)) + } + } + + window.tempExt = { + Extension: XML, + info: { + name: "xml.name", + description: "xml.descp", + extensionId: "mbwxml", + iconURL: xmlPicture, + insetIconURL: xmlIcon, + disabled: false, + collaboratorList: [{ + collaborator:Scratch.translate({ id:'_mybearworldName', default: '_mybearworldName', description: '_mybearworldName' }), + collaboratorURL: 'https://github.com/Procybit' + }, + { + collaborator: Scratch.translate({ id:'_skydogName', default: '_skydogName', description: '__skydogName' }), + collaboratorURL: 'https://www.ccw.site/student/6200811f05660557606c8b15' + } + ], + }, + l10n: { + "zh-cn": { + "xml.name": 'XML', + "xml.descp": "在 XML 中创建或修改值！" + }, + en: { + "xml.name": "XML", + "xml.descp": "Create and extract values from XML." + } + } + }; +})(Scratch)