@zeedhi/common 1.36.0 → 1.39.0

package/dist/zd-common.esm.js

@@ -1,7 +1,5 @@
-import { AccessorManager, Event, KeyMap, Metadata, FormatterParserProvider, Validation, Accessor, DatasourceFactory, I18n, Loader, Mask, Config, dayjs, isEqual, Router, MethodNotAssignedError, InstanceNotFoundError, Http, Cookie, normalize, URL as URL$1 } from '@zeedhi/core';
+import { AccessorManager, Event, KeyMap, Metadata, FormatterParserProvider, Validation, Accessor, DatasourceFactory, I18n, MethodNotAssignedError, Loader, Mask, Config, dayjs, isEqual, Router, InstanceNotFoundError, Http, Cookie, normalize, URL as URL$1 } from '@zeedhi/core';
 import debounce from 'lodash.debounce';
-import Prism$1 from 'prismjs';
-import 'prismjs/themes/prism.css';
 import isUndefined from 'lodash.isundefined';
 import merge from 'lodash.merge';
 import set from 'lodash.set';
@@ -1756,26 +1754,6 @@ class Chip extends Button {
     }
 }
 
-!function(e){e.languages.typescript=e.languages.extend("javascript",{"class-name":{pattern:/(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,lookbehind:!0,greedy:!0,inside:null},builtin:/\b(?:string|Function|any|number|boolean|Array|symbol|console|Promise|unknown|never)\b/}),e.languages.typescript.keyword.push(/\b(?:abstract|as|declare|implements|is|keyof|readonly|require)\b/,/\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,/\btype\b(?=\s*(?:[\{*]|$))/),delete e.languages.typescript.parameter;var s=e.languages.extend("typescript",{});delete s["class-name"],e.languages.typescript["class-name"].inside=s,e.languages.insertBefore("typescript","function",{decorator:{pattern:/@[$\w\xA0-\uFFFF]+/,inside:{at:{pattern:/^@/,alias:"operator"},function:/^[\s\S]+/}},"generic-function":{pattern:/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,greedy:!0,inside:{function:/^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,generic:{pattern:/<[\s\S]+/,alias:"class-name",inside:s}}}}),e.languages.ts=e.languages.typescript;}(Prism);
-
-Prism.languages.json={property:{pattern:/(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,lookbehind:!0,greedy:!0},string:{pattern:/(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,lookbehind:!0,greedy:!0},comment:{pattern:/\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,greedy:!0},number:/-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,punctuation:/[{}[\],]/,operator:/:/,boolean:/\b(?:true|false)\b/,null:{pattern:/\bnull\b/,alias:"keyword"}},Prism.languages.webmanifest=Prism.languages.json;
-
-Prism.languages.jsonp=Prism.languages.extend("json",{punctuation:/[{}[\]();,.]/}),Prism.languages.insertBefore("jsonp","punctuation",{function:/(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/});
-
-!function(e){var t="\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b",n={pattern:/(^(["']?)\w+\2)[ \t]+\S.*/,lookbehind:!0,alias:"punctuation",inside:null},a={bash:n,environment:{pattern:RegExp("\\$"+t),alias:"constant"},variable:[{pattern:/\$?\(\([\s\S]+?\)\)/,greedy:!0,inside:{variable:[{pattern:/(^\$\(\([\s\S]+)\)\)/,lookbehind:!0},/^\$\(\(/],number:/\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,operator:/--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,punctuation:/\(\(?|\)\)?|,|;/}},{pattern:/\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,greedy:!0,inside:{variable:/^\$\(|^`|\)$|`$/}},{pattern:/\$\{[^}]+\}/,greedy:!0,inside:{operator:/:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,punctuation:/[\[\]]/,environment:{pattern:RegExp("(\\{)"+t),lookbehind:!0,alias:"constant"}}},/\$(?:\w+|[#?*!@$])/],entity:/\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|x[0-9a-fA-F]{1,2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})/};e.languages.bash={shebang:{pattern:/^#!\s*\/.*/,alias:"important"},comment:{pattern:/(^|[^"{\\$])#.*/,lookbehind:!0},"function-name":[{pattern:/(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,lookbehind:!0,alias:"function"},{pattern:/\b[\w-]+(?=\s*\(\s*\)\s*\{)/,alias:"function"}],"for-or-select":{pattern:/(\b(?:for|select)\s+)\w+(?=\s+in\s)/,alias:"variable",lookbehind:!0},"assign-left":{pattern:/(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,inside:{environment:{pattern:RegExp("(^|[\\s;|&]|[<>]\\()"+t),lookbehind:!0,alias:"constant"}},alias:"variable",lookbehind:!0},string:[{pattern:/((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,lookbehind:!0,greedy:!0,inside:a},{pattern:/((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,lookbehind:!0,greedy:!0,inside:{bash:n}},{pattern:/(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,lookbehind:!0,greedy:!0,inside:a},{pattern:/(^|[^$\\])'[^']*'/,lookbehind:!0,greedy:!0},{pattern:/\$'(?:[^'\\]|\\[\s\S])*'/,greedy:!0,inside:{entity:a.entity}}],environment:{pattern:RegExp("\\$?"+t),alias:"constant"},variable:a.variable,function:{pattern:/(^|[\s;|&]|[<>]\()(?:add|apropos|apt|aptitude|apt-cache|apt-get|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,lookbehind:!0},keyword:{pattern:/(^|[\s;|&]|[<>]\()(?:if|then|else|elif|fi|for|while|in|case|esac|function|select|do|done|until)(?=$|[)\s;|&])/,lookbehind:!0},builtin:{pattern:/(^|[\s;|&]|[<>]\()(?:\.|:|break|cd|continue|eval|exec|exit|export|getopts|hash|pwd|readonly|return|shift|test|times|trap|umask|unset|alias|bind|builtin|caller|command|declare|echo|enable|help|let|local|logout|mapfile|printf|read|readarray|source|type|typeset|ulimit|unalias|set|shopt)(?=$|[)\s;|&])/,lookbehind:!0,alias:"class-name"},boolean:{pattern:/(^|[\s;|&]|[<>]\()(?:true|false)(?=$|[)\s;|&])/,lookbehind:!0},"file-descriptor":{pattern:/\B&\d\b/,alias:"important"},operator:{pattern:/\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,inside:{"file-descriptor":{pattern:/^\d/,alias:"important"}}},punctuation:/\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,number:{pattern:/(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,lookbehind:!0}},n.inside=e.languages.bash;for(var s=["comment","function-name","for-or-select","assign-left","string","environment","function","keyword","builtin","boolean","file-descriptor","operator","punctuation","number"],i=a.variable[1].inside,o=0;o<s.length;o++)i[s[o]]=e.languages.bash[s[o]];e.languages.shell=e.languages.bash;}(Prism);
-
-!function(e){var t=/\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/,n="(^|[^\\w.])(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*",a={pattern:RegExp(n+"[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b"),lookbehind:!0,inside:{namespace:{pattern:/^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,inside:{punctuation:/\./}},punctuation:/\./}};e.languages.java=e.languages.extend("clike",{"class-name":[a,{pattern:RegExp(n+"[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()])"),lookbehind:!0,inside:a.inside}],keyword:t,function:[e.languages.clike.function,{pattern:/(::\s*)[a-z_]\w*/,lookbehind:!0}],number:/\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,operator:{pattern:/(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,lookbehind:!0}}),e.languages.insertBefore("java","string",{"triple-quoted-string":{pattern:/"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,greedy:!0,alias:"string"}}),e.languages.insertBefore("java","class-name",{annotation:{pattern:/(^|[^.])@\w+(?:\s*\.\s*\w+)*/,lookbehind:!0,alias:"punctuation"},generics:{pattern:/<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,inside:{"class-name":a,keyword:t,punctuation:/[<>(),.:]/,operator:/[?&|]/}},namespace:{pattern:RegExp("(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)(?!<keyword>)[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?".replace(/<keyword>/g,function(){return t.source})),lookbehind:!0,inside:{punctuation:/\./}}});}(Prism);
-
-!function(e){e.languages.kotlin=e.languages.extend("clike",{keyword:{pattern:/(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,lookbehind:!0},function:[{pattern:/(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,greedy:!0},{pattern:/(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,lookbehind:!0,greedy:!0}],number:/\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,operator:/\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/}),delete e.languages.kotlin["class-name"],e.languages.insertBefore("kotlin","string",{"raw-string":{pattern:/("""|''')[\s\S]*?\1/,alias:"string"}}),e.languages.insertBefore("kotlin","keyword",{annotation:{pattern:/\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,alias:"builtin"}}),e.languages.insertBefore("kotlin","function",{label:{pattern:/\b\w+@|@\w+\b/,alias:"symbol"}});var n=[{pattern:/\$\{[^}]+\}/,inside:{delimiter:{pattern:/^\$\{|\}$/,alias:"variable"},rest:e.languages.kotlin}},{pattern:/\$\w+/,alias:"variable"}];e.languages.kotlin.string.inside=e.languages.kotlin["raw-string"].inside={interpolation:n},e.languages.kt=e.languages.kotlin,e.languages.kts=e.languages.kotlin;}(Prism);
-
-!function(e){var n=/[*&][^\s[\]{},]+/,r=/!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/,t="(?:"+r.source+"(?:[ \t]+"+n.source+")?|"+n.source+"(?:[ \t]+"+r.source+")?)",a="(?:[^\\s\\x00-\\x08\\x0e-\\x1f!\"#%&'*,\\-:>?@[\\]`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*".replace(/<PLAIN>/g,function(){return "[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]"}),d="\"(?:[^\"\\\\\r\n]|\\\\.)*\"|'(?:[^'\\\\\r\n]|\\\\.)*'";function o(e,n){n=(n||"").replace(/m/g,"")+"m";var r="([:\\-,[{]\\s*(?:\\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\\]|\\}|(?:[\r\n]\\s*)?#))".replace(/<<prop>>/g,function(){return t}).replace(/<<value>>/g,function(){return e});return RegExp(r,n)}e.languages.yaml={scalar:{pattern:RegExp("([\\-:]\\s*(?:\\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\\S[^\r\n]*(?:\\2[^\r\n]+)*)".replace(/<<prop>>/g,function(){return t})),lookbehind:!0,alias:"string"},comment:/#.*/,key:{pattern:RegExp("((?:^|[:\\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\\s*:\\s)".replace(/<<prop>>/g,function(){return t}).replace(/<<key>>/g,function(){return "(?:"+a+"|"+d+")"})),lookbehind:!0,greedy:!0,alias:"atrule"},directive:{pattern:/(^[ \t]*)%.+/m,lookbehind:!0,alias:"important"},datetime:{pattern:o("\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \t]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?(?:[ \t]*(?:Z|[-+]\\d\\d?(?::\\d{2})?))?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?"),lookbehind:!0,alias:"number"},boolean:{pattern:o("true|false","i"),lookbehind:!0,alias:"important"},null:{pattern:o("null|~","i"),lookbehind:!0,alias:"important"},string:{pattern:o(d),lookbehind:!0,greedy:!0},number:{pattern:o("[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)","i"),lookbehind:!0},tag:r,important:n,punctuation:/---|[:[\]{}\-,|>?]|\.\.\./},e.languages.yml=e.languages.yaml;}(Prism);
-
-!function(e){var r="(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)".replace(/<SP_BS>/g,function(){return "\\\\[\r\n](?:\\s|\\\\[\r\n]|#.*(?!.))*(?![\\s#]|\\\\[\r\n])"}),n="\"(?:[^\"\\\\\r\n]|\\\\(?:\r\n|[^]))*\"|'(?:[^'\\\\\r\n]|\\\\(?:\r\n|[^]))*'",t="--[\\w-]+=(?:<STR>|(?![\"'])(?:[^\\s\\\\]|\\\\.)+)".replace(/<STR>/g,function(){return n}),o={pattern:RegExp(n),greedy:!0},i={pattern:/(^[ \t]*)#.*/m,lookbehind:!0,greedy:!0};function a(e,n){return e=e.replace(/<OPT>/g,function(){return t}).replace(/<SP>/g,function(){return r}),RegExp(e,n)}e.languages.docker={instruction:{pattern:/(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im,lookbehind:!0,greedy:!0,inside:{options:{pattern:a("(^(?:ONBUILD<SP>)?\\w+<SP>)<OPT>(?:<SP><OPT>)*","i"),lookbehind:!0,greedy:!0,inside:{property:{pattern:/(^|\s)--[\w-]+/,lookbehind:!0},string:[o,{pattern:/(=)(?!["'])(?:[^\s\\]|\\.)+/,lookbehind:!0}],operator:/\\$/m,punctuation:/=/}},keyword:[{pattern:a("(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\\b","i"),lookbehind:!0,greedy:!0},{pattern:a("(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\\\]+<SP>)AS","i"),lookbehind:!0,greedy:!0},{pattern:a("(^ONBUILD<SP>)\\w+","i"),lookbehind:!0,greedy:!0},{pattern:/^\w+/,greedy:!0}],comment:i,string:o,variable:/\$(?:\w+|\{[^{}"'\\]*\})/,operator:/\\$/m}},comment:i},e.languages.dockerfile=e.languages.docker;}(Prism);
-
-Prism.languages.sql={comment:{pattern:/(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,lookbehind:!0},variable:[{pattern:/@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,greedy:!0},/@[\w.$]+/],string:{pattern:/(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,greedy:!0,lookbehind:!0},function:/\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,keyword:/\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:_INSERT|COL)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:S|ING)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,boolean:/\b(?:TRUE|FALSE|NULL)\b/i,number:/\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,operator:/[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|IN|ILIKE|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,punctuation:/[;[\]()`,.]/};
-
-Prism.languages.groovy=Prism.languages.extend("clike",{string:[{pattern:/("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,greedy:!0},{pattern:/(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,greedy:!0}],keyword:/\b(?:as|def|in|abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,number:/\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,operator:{pattern:/(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,lookbehind:!0},punctuation:/\.+|[{}[\];(),:$]/}),Prism.languages.insertBefore("groovy","string",{shebang:{pattern:/#!.+/,alias:"comment"}}),Prism.languages.insertBefore("groovy","punctuation",{"spock-block":/\b(?:setup|given|when|then|and|cleanup|expect|where):/}),Prism.languages.insertBefore("groovy","function",{annotation:{pattern:/(^|[^.])@\w+/,lookbehind:!0,alias:"punctuation"}}),Prism.hooks.add("wrap",function(e){if("groovy"===e.language&&"string"===e.type){var t=e.content[0];if("'"!=t){var n=/([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;"$"===t&&(n=/([^\$])(?:\$(?:\{.*?\}|[\w.]+))/),e.content=e.content.replace(/&lt;/g,"<").replace(/&amp;/g,"&"),e.content=Prism.highlight(e.content,{expression:{pattern:n,lookbehind:!0,inside:Prism.languages.groovy}}),e.classes.push("/"===t?"regex":"gstring");}}});
-
 /**
  * The Code Editor component <code>zd-code-editor</code> is used to show code highlighted using one of the
  * language supported by <a href=\"http://prismjs.com\" alt=\"Prism JS\" target=\"_blank\">Prism JS</a>
@@ -1818,6 +1796,9 @@ class CodeEditor extends ComponentRender {
         this.showLineNumbers = this.getInitValue('showLineNumbers', props.showLineNumbers, this.showLineNumbers);
         this.createAccessors();
     }
+    setViewHighlight(fn) {
+        this.viewHighlight = fn;
+    }
     /**
      * Code to be shown. When showing JSON code, the JSON object can be passed instead of the string code.
      */
@@ -1898,7 +1879,10 @@ class CodeEditor extends ComponentRender {
      * Get the code highlighted
      */
     getHighlightedCode() {
-        return Prism$1.highlight(this.code, Prism$1.languages[this.language], this.language);
+        if (!this.viewHighlight) {
+            throw new MethodNotAssignedError('viewHighlight');
+        }
+        return this.viewHighlight(this.code, this.language);
     }
     /**
      * Get the total of lines
@@ -2511,7 +2495,7 @@ class Loading extends Component {
          */
         this.text = 'Loading';
         this.isVisible = false;
-        this.zIndex = '100';
+        this.zIndex = 999;
         this.text = this.getInitValue('text', props.text, this.text);
         this.zIndex = this.getInitValue('zIndex', props.zIndex, this.zIndex);
         this.defaultText = this.text;
@@ -4333,7 +4317,7 @@ class Column extends Component {
         const appliedConditions = {};
         Object.keys(this.factoredConditions).forEach((condition) => {
             const conditionFunction = this.factoredConditions[condition];
-            set(appliedConditions, condition, conditionFunction({ row }));
+            set(appliedConditions, condition, conditionFunction({ row, column: this }));
         });
         return appliedConditions;
     }
@@ -4585,7 +4569,7 @@ FormatterParserProvider.registerFormatter('column_ZdSelect', ({ column, value, r
     let currentRow = row;
     if (dataValue) {
         if (!formatterDataText) {
-            currentRow = column.getLookupData(dataValue, value);
+            currentRow = column.getLookupData(dataValue, value[dataValue] || value);
         }
         else {
             const columns = Array.isArray(formatterDataText) ? formatterDataText : [formatterDataText];
@@ -4601,7 +4585,7 @@ FormatterParserProvider.registerFormatter('column_ZdSelect', ({ column, value, r
         }
     }
     if (!Object.keys(currentRow).length)
-        return value;
+        return typeof value === 'object' ? '' : value;
     const textColumn = formatterDataText || dataText;
     if (textColumn) {
         if (typeof textColumn === 'string') {
@@ -5084,7 +5068,6 @@ class GridEditable extends Grid {
         if (this.editing)
             return;
         if (column.editable) {
-            this.selectedRows = [];
             this.editing = true;
             this.preventRowClick = true;
             this.datasource.currentRow = row;
@@ -5154,7 +5137,7 @@ class GridEditable extends Grid {
         else {
             colValue = row[column.name];
         }
-        const componentProps = merge({}, column.componentProps, cellProps.componentProps);
+        const componentProps = merge({}, column.componentProps, cellProps === null || cellProps === void 0 ? void 0 : cellProps.componentProps);
         let compEvents = {};
         if (componentProps && componentProps.events) {
             compEvents = Event.factory(componentProps.events);
@@ -5188,7 +5171,8 @@ class GridEditable extends Grid {
     checkLookupData(column, row, componentProps) {
         if (row[column.name] && column.lookupData && componentProps.datasource) {
             componentProps.datasource.data = componentProps.datasource.data || [];
-            componentProps.datasource.data.push(column.lookupData[row[column.name]]);
+            const value = typeof row[column.name] === 'object' ? row[column.name][componentProps.dataValue] : row[column.name];
+            componentProps.datasource.data.push(column.lookupData[value]);
         }
     }
     checkCompValidity(component) {
@@ -5863,7 +5847,7 @@ class Select extends TextInput {
      */
     constructor(props) {
         var _a, _b;
-        super(props);
+        super(Object.assign(Object.assign({}, props), { value: undefined }));
         /**
          * Field used to display values
          */
@@ -5946,6 +5930,7 @@ class Select extends TextInput {
         this.cachedData = [];
         this.cachedTotal = 0;
         this.formatterFn = FormatterParserProvider.getFormatter('ZdSelect');
+        this.pushedValue = null;
         this.loadMoreQtty = 0;
         this.debounceSearch = debounce(this.doSearch, 500);
         this.appendIcon = this.getInitValue('appendIcon', props.appendIcon, 'expand');
@@ -5967,7 +5952,13 @@ class Select extends TextInput {
             this.dataText = [this.dataText];
         const defaultDatasource = this.getDefaultDatasource(props);
         this.datasource = DatasourceFactory.factory(defaultDatasource);
-        this.setDefaultValue(props.value, (_b = props.datasource) === null || _b === void 0 ? void 0 : _b.lazyLoad);
+        this.overrideGet();
+        let defaultValue = props.value;
+        if (Accessor.isAccessorDefinition(props.value)) {
+            defaultValue = this.getAccessorValue(props.value);
+            this.getInitValue('value', props.value, this.value);
+        }
+        this.setDefaultValue(defaultValue, (_b = props.datasource) === null || _b === void 0 ? void 0 : _b.lazyLoad);
         this.preventLoadOnFocus = !defaultDatasource.lazyLoad;
         this.preventLoadOnFocus = this.getInitValue('preventLoadOnFocus', props.preventLoadOnFocus, this.preventLoadOnFocus);
         this.loadMoreQtty = this.datasource.limit;
@@ -5976,6 +5967,11 @@ class Select extends TextInput {
         this.createAccessors();
         this.initialized = true;
     }
+    getAccessorValue(accessorName) {
+        const [controller, accessor] = Accessor.getAccessor(accessorName);
+        const instance = Loader.getInstance(controller);
+        return instance[accessor];
+    }
     /**
      * Retrieves datasource structure applying infinity scroll
      * @param field Field structure
@@ -5987,6 +5983,16 @@ class Select extends TextInput {
         const searchIn = (((_a = field.datasource) === null || _a === void 0 ? void 0 : _a.searchIn) || []).concat(searchInDefault);
         return Object.assign(Object.assign({}, field.datasource), { searchIn, lazyLoad: (field.value !== '' && field.value !== undefined) || (field.datasource && field.datasource.lazyLoad) });
     }
+    overrideGet() {
+        const oldGet = this.datasource.get;
+        this.datasource.get = () => __awaiter(this, void 0, void 0, function* () {
+            yield oldGet.call(this.datasource);
+            if (this.indexOf(this.value) !== -1 || this.datasource.search || this.isFocused)
+                return;
+            yield this.setValue(this.value, false);
+            this.removePushedValue();
+        });
+    }
     get search() {
         return this.searchValue;
     }
@@ -6013,7 +6019,7 @@ class Select extends TextInput {
             }
             if (this.manualMode)
                 return;
-            this.cachedData = this.datasource.data;
+            this.cachedData = [...this.datasource.data];
             this.cachedTotal = this.datasource.total;
             if (pushed) {
                 this.pushedValue = this.selectedData;
@@ -6072,10 +6078,14 @@ class Select extends TextInput {
         if (!this.pushedValue && this.isFilledObj(this.selectValue) && this.indexOf(this.selectValue) === -1) {
             this.pushedValue = this.selectValue;
         }
-        if (this.isFilledObj(this.pushedValue) && this.indexOf(this.pushedValue) === -1) {
+        const index = this.indexOf(this.pushedValue);
+        if (this.isFilledObj(this.pushedValue) && index === -1) {
             this.datasource.data.unshift(this.pushedValue);
         }
-        this.cachedData = this.datasource.data;
+        else if (index !== 0) {
+            this.pushedValue = null;
+        }
+        this.cachedData = [...this.datasource.data];
         this.cachedTotal = this.datasource.total;
     }
     /**
@@ -6134,6 +6144,7 @@ class Select extends TextInput {
             }
             if (!searchValue) {
                 this.setFieldRowValue(null);
+                this.selectValue = this.selectedData;
                 return false;
             }
             this.setFieldRowValue(searchValue);
@@ -6244,7 +6255,7 @@ class Select extends TextInput {
             else {
                 this.removePushedValue();
                 this.datasource.search = this.searchValue;
-                this.datasource.data = this.cachedData;
+                this.datasource.data = [...this.cachedData];
                 this.datasource.total = this.cachedTotal;
             }
         });
@@ -6257,6 +6268,11 @@ class Select extends TextInput {
             yield this.datasource.setLimit(this.datasource.limit + this.loadMoreQtty);
             if (!this.datasource.search) {
                 this.afterLoad();
+                const { dataValue } = this;
+                const isSelected = this.selectValue && this.pushedValue && this.selectValue[dataValue] === this.pushedValue[dataValue];
+                if (isSelected)
+                    return;
+                this.removePushedValue();
             }
         });
     }
@@ -6270,7 +6286,7 @@ class Select extends TextInput {
             this.datasource.search = '';
             this.dirtySearchValue = '';
             if (!this.manualMode) {
-                this.datasource.data = this.cachedData;
+                this.datasource.data = [...this.cachedData];
                 this.datasource.total = this.cachedTotal;
             }
             this.checkValueOnBlur();
@@ -6283,13 +6299,17 @@ class Select extends TextInput {
         }
         if (this.manualMode)
             return;
-        if (this.isFilledObj(this.selectValue)) {
-            if (this.indexOf(this.selectValue) === -1) {
-                this.datasource.data.unshift(this.selectValue);
-                this.pushedValue = this.selectValue;
+        if (this.isFilledObj(this.selectValue) && this.indexOf(this.selectValue) === -1) {
+            if (this.pushedValue) {
+                this.removePushedValue();
             }
+            this.datasource.data.unshift(this.selectValue);
+            this.pushedValue = this.selectValue;
             return;
         }
+        const { dataValue } = this;
+        if (this.pushedValue && this.selectValue && this.selectValue[dataValue] === this.pushedValue[dataValue])
+            return;
         this.removePushedValue();
     }
     showLoadMore() {
@@ -7879,7 +7899,6 @@ class SelectMultiple extends Select {
      */
     constructor(props) {
         super(props);
-        this.selectedValue = [];
         /**
          * Selected items that were added to datasource
          */
@@ -7893,6 +7912,9 @@ class SelectMultiple extends Select {
          */
         this.moreChip = 0;
         this.showSelectAll = false;
+        if (!this.selectedValue) {
+            this.selectedValue = [];
+        }
         this.showSelectAll = this.getInitValue('showSelectAll', props.showSelectAll, this.showSelectAll);
         this.createAccessors();
     }
@@ -7932,20 +7954,23 @@ class SelectMultiple extends Select {
     set selectValue(rows) {
         if (!Array.isArray(rows))
             return;
-        if (!this.manualMode && this.insertedValues.length > 0) {
-            this.insertsRemoved = [];
+        if (!this.manualMode) {
             const values = rows.map((row) => row[this.dataValue]);
-            this.insertedValues = this.insertedValues.filter((inserted) => {
-                const removed = !values.includes(inserted[this.dataValue]);
-                if (removed) {
-                    this.insertsRemoved.push(inserted);
-                }
-                return !removed;
-            });
+            this.cutFromAToB(this.insertedValues, this.insertsRemoved, (value) => !values.includes(value[this.dataValue]));
+            this.cutFromAToB(this.insertsRemoved, this.insertedValues, (value) => values.includes(value[this.dataValue]));
         }
         this.selectedValue = rows;
         this.setFieldValue(this.getValues(rows));
     }
+    /**
+     * Removes item from array a and add it to array b if condition is satisfied
+     */
+    cutFromAToB(a, b, condition) {
+        const indices = a.reduce((result, value, index) => (condition(value) ? [...result, index] : result), []);
+        indices.forEach((index) => {
+            b.push(a.splice(index)[0]);
+        });
+    }
     setFieldValue(value) {
         return __awaiter(this, void 0, void 0, function* () {
             const promises = [];
@@ -7975,7 +8000,9 @@ class SelectMultiple extends Select {
                     }));
                 }
             });
-            yield Promise.all(promises);
+            if (promises.length) {
+                yield Promise.all(promises);
+            }
             if (searchValues.length > 0) {
                 this.setFieldRowValue(searchValues);
             }
@@ -8120,7 +8147,7 @@ class SelectMultiple extends Select {
     showLoadMore() {
         return !!this.datasource.data.length
             && !this.datasource.loadAll
-            && (this.datasource.data.length - this.insertedValues.length) < this.datasource.total;
+            && (this.datasource.data.length - this.insertedValues.length - this.insertsRemoved.length) < this.datasource.total;
     }
     /**
      * Load more data
@@ -8128,10 +8155,16 @@ class SelectMultiple extends Select {
     loadMore() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.datasource.setLimit(this.datasource.limit + this.loadMoreQtty);
+            this.insertsRemoved = this.insertsRemoved.filter((insert) => {
+                const value = insert[this.dataValue];
+                const foundInData = this.datasource.data.find(this.getCondition(value));
+                return !foundInData;
+            });
+            this.insertSelected();
             if (!this.datasource.search) {
                 this.setCache();
             }
-            this.insertSelected();
+            this.removePushedValue();
         });
     }
     /**
@@ -8325,6 +8358,9 @@ class TreeDataStructure {
             }
             return item;
         });
+        if (parent) { // remove all existing children to add new ones
+            this.treeData = this.treeData.filter((item) => item.tree__parent !== parent);
+        }
         if (!parent) {
             this.treeData = childData;
         }
@@ -8508,7 +8544,7 @@ class TreeDataStructure {
         this.treeStructure = {};
         const childData = this.originalDatasource.data.map((row) => (Object.assign(Object.assign({}, row), { tree__children: [], tree__opened: false, tree__searched: true, tree__level: 1, tree__parent: undefined })));
         this.treeData = childData;
-        this.treeStructure['no-parent'] = this.originalDatasource.data;
+        this.treeStructure['no-parent'] = childData;
     }
     /**
      * Search value against a memory datasource
@@ -8643,6 +8679,7 @@ class SelectTree extends TextInput {
          * Defines if should wait and not execute GET method when Datasource is created
          */
         this.lazyLoad = true;
+        this.selectValue = null;
         this.nodes = this.getInitValue('nodes', props.nodes, this.nodes);
         this.alwaysOpen = this.getInitValue('alwaysOpen', props.alwaysOpen, this.alwaysOpen);
         this.flattenSearchResults = this.getInitValue('flattenSearchResults', props.flattenSearchResults, this.flattenSearchResults);
@@ -8810,8 +8847,41 @@ class SelectTree extends TextInput {
     get searchValue() {
         return this.lastInputValue;
     }
+    clearRow(row) {
+        const result = Object.assign({}, row);
+        Object.keys(result).forEach((key) => {
+            if (key.indexOf('tree__') === 0) {
+                delete result[key];
+            }
+        });
+        return result;
+    }
+    get value() {
+        if (!this.selectValue)
+            return this.selectValue;
+        if (this.returnObject) {
+            return this.clearRow(this.selectValue.row);
+        }
+        return this.selectValue;
+    }
+    set value(value) {
+        this.selectValue = value;
+    }
     setValue(value) {
-        this.value = value;
+        if (this.returnObject) {
+            if (typeof value !== 'object') {
+                this.value = { id: value };
+            }
+            else {
+                this.value = { id: value[this.dataValue] };
+            }
+        }
+        else if (typeof value === 'object') {
+            this.value = value[this.dataValue];
+        }
+        else {
+            this.value = value;
+        }
     }
 }
 
@@ -8837,6 +8907,7 @@ class SelectTreeMultiple extends SelectTree {
          * Selected Nodes
          */
         this.selectedNodes = [];
+        this.selectValue = [];
         this.flat = this.getInitValue('flat', props.flat, this.flat);
         this.limit = this.getInitValue('limit', props.limit, this.limit);
         this.createAccessors();
@@ -8853,6 +8924,34 @@ class SelectTreeMultiple extends SelectTree {
     deselect(node, element) {
         this.callEvent('onDeselect', { element, component: this, node });
     }
+    get value() {
+        if (this.returnObject) {
+            return this.selectValue.map((value) => this.clearRow(value.row));
+        }
+        return this.selectValue;
+    }
+    set value(value) {
+        this.selectValue = value;
+    }
+    setValue(value) {
+        const arrValue = Array.isArray(value) ? value : [value];
+        if (this.returnObject) {
+            this.value = arrValue.map((item) => {
+                if (typeof item !== 'object') {
+                    return { id: item };
+                }
+                return { id: item[this.dataValue] };
+            });
+        }
+        else {
+            this.value = arrValue.map((item) => {
+                if (typeof item === 'object') {
+                    return item[this.dataValue];
+                }
+                return item;
+            });
+        }
+    }
 }
 
 /**
@@ -10122,7 +10221,6 @@ class TreeGridEditable extends TreeGrid {
         if (this.editing)
             return;
         if (column.editable) {
-            this.selectedRows = [];
             this.editing = true;
             this.preventRowClick = true;
             this.datasource.currentRow = row;
@@ -11071,17 +11169,37 @@ class PDFReport extends BaseReport {
 }
 
 class XLSReport extends BaseReport {
-    constructor() {
-        super(...arguments);
+    constructor(type) {
+        super();
         this.route = '/generateXLS';
+        this.expressionZeedhiToXls = {
+            AVG: 'AVERAGE',
+            COUNT: 'COUNTA',
+            MAX: 'MAX',
+            MIN: 'MIN',
+            SUM: 'SUM',
+        };
+        this.colunmXLS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        this.type = type || 'xls';
     }
-    buildDataset(data, columns) {
+    buildDataset(data, columns, metadata) {
+        let result;
+        if (this.type === 'xls') {
+            result = this.formatRawDataSet(data, columns);
+        }
+        else if (metadata) {
+            result = this.formatDataSet(metadata, data);
+        }
+        return JSON.stringify(result);
+    }
+    // formata o dataset para o formato "cru" xls
+    formatRawDataSet(data, columns) {
         const columnNames = columns.map((col) => col.name);
         const result = data.reduce((reduced, row) => {
             const values = columnNames.map((col) => row[col] || '');
             return [...reduced, values];
         }, [columnNames]);
-        return JSON.stringify(result);
+        return result;
     }
     buildMetadata(name, title, columns, filter) {
         const builtCols = this.buildColumns(columns);
@@ -11110,9 +11228,215 @@ class XLSReport extends BaseReport {
             orientation: 'PORTRAIT',
             columns: builtCols,
             filter: builtFilters,
+            reportXLS: true,
+            xlsMergedCell: [],
         };
         return Promise.resolve(JSON.stringify(metadataObj));
     }
+    isFormat3(format) {
+        return format === 'xls3';
+    }
+    // Ordenar o nome das colunas de acordo com seu index, excluindo o nome das colunas agrupadas
+    getColumnsNameFormat3(columns, metaData) {
+        const columnsNameGroup = metaData.groups.map((row) => row.field);
+        let columnsName = [];
+        Object.entries(columns).forEach((row) => {
+            const columnName = row[0];
+            if (columnsNameGroup.indexOf(columnName) === -1) {
+                const index = row[1].sequence;
+                columnsName[index] = columnName;
+            }
+        });
+        columnsName = columnsName.filter((columnName) => typeof columnName === 'string');
+        return columnsName;
+    }
+    // Ordenar o nome das colunas de acordo com seu index, e sempre deixando as colunas agrupadas nas primeiras posições
+    getColumnsName(columns, metaData, lengthGroup) {
+        const columnsNameGroup = metaData.groups.map((row) => row.field);
+        let columnsName = [];
+        Object.entries(columns).forEach((row) => {
+            const columnName = row[0];
+            const index = row[1].sequence;
+            if (columnsNameGroup.indexOf(columnName) === -1) {
+                columnsName[index + lengthGroup] = columnName;
+            }
+            else {
+                columnsName[index] = columnName;
+            }
+        });
+        columnsName = columnsName.filter((columnName) => typeof columnName === 'string');
+        return columnsName;
+    }
+    // Inicializa alguns valores auxiliares
+    initVars(metaData, type) {
+        metaData.xlsMergedCell = [];
+        const { columns } = metaData;
+        const lengthGroup = metaData.groups.length;
+        const indexLastGroup = lengthGroup - 1;
+        let columnsName = [];
+        if (this.isFormat3(type)) {
+            columnsName = this.getColumnsNameFormat3(columns, metaData);
+        }
+        else {
+            columnsName = this.getColumnsName(columns, metaData, lengthGroup);
+        }
+        const rowValues = [];
+        const formatedDataSet = [];
+        const groups = [];
+        groups.groupEnd = {};
+        groups.groupEnd.cellsfunc = {};
+        return {
+            columns, indexLastGroup, columnsName, rowValues, formatedDataSet, groups,
+        };
+    }
+    // formata a linha do grupo de acordo com o formato xls3
+    setRowGroupFormat3(row, rowValuesParam, groups, formatedDataSet, columnsName, columns, indexLastGroup) {
+        let rowValues = rowValuesParam;
+        const label = `${row.groupLabel}:${row.groupValue}`;
+        const index = row.groupIndex;
+        if (row.groupHeader) {
+            rowValues[index] = label;
+            groups[index] = { init: null, end: null };
+            formatedDataSet.push(rowValues);
+            rowValues = [];
+        }
+        else if (row.groupFooter) {
+            if (!row.groupLabel) {
+                rowValues.push('Total');
+            }
+            else {
+                rowValues.push(`Total (${label})`);
+            }
+            formatedDataSet.push(rowValues);
+            rowValues = [];
+            const funcXls = null;
+            columnsName.forEach((column) => {
+                this.formatRowFunc(column, columns, row, index, rowValues, funcXls, groups, indexLastGroup);
+            });
+        }
+        return rowValues;
+    }
+    // formata as expressões da linha
+    formatRowFunc(column, columns, row, index, rowValues, funcXlsParam, groups, indexLastGroup) {
+        let funcXls = funcXlsParam;
+        if ((row[column] === 0 || row[column]) && index !== undefined) {
+            const letter = this.colunmXLS[rowValues.length];
+            funcXls = this.expressionZeedhiToXls[columns[column].expression];
+            const cellsfunc = `${letter + groups[index].init}:${letter}${groups[index].end}`;
+            let expression = '';
+            if (indexLastGroup === index) {
+                expression = `=${funcXls}(${cellsfunc})`;
+            }
+            else {
+                expression = `=${funcXls}(${groups[index].cellsfunc[column]})`;
+                if (index === 0) {
+                    if (groups.groupEnd.cellsfunc[column]) {
+                        groups.groupEnd.cellsfunc[column] += `,${groups[index].cellsfunc[column]}`;
+                    }
+                    else {
+                        groups.groupEnd.cellsfunc[column] = groups[index].cellsfunc[column];
+                    }
+                }
+                groups[index].cellsfunc[column] = null;
+            }
+            rowValues.push(expression);
+            groups.forEach((group, indexGroup) => {
+                if (indexGroup !== indexLastGroup) {
+                    if (!group.cellsfunc) {
+                        group.cellsfunc = {};
+                    }
+                    if (group.cellsfunc[column]) {
+                        group.cellsfunc[column] += `,${cellsfunc}`;
+                    }
+                    else {
+                        group.cellsfunc[column] = cellsfunc;
+                    }
+                }
+            });
+        }
+        else {
+            let cell = row[column];
+            if (row.groupSummary) {
+                const groupEndFunc = groups.groupEnd.cellsfunc;
+                if (groupEndFunc[column]) {
+                    funcXls = this.expressionZeedhiToXls[columns[column].expression];
+                    cell = `=${funcXls}(${groupEndFunc[column]})`;
+                }
+            }
+            rowValues.push(cell);
+        }
+    }
+    // formata a linha de grupo de acordo com o formato xls2
+    setRowGroup(row, rowValues, groups, metaData, formatedDataSet, columnsName, columns, indexLastGroup) {
+        const label = `${row.groupLabel}:${row.groupValue}`;
+        const index = row.groupIndex;
+        if (row.groupHeader) {
+            rowValues[index] = label;
+            groups[index] = { init: null, end: null };
+        }
+        else if (row.groupFooter) {
+            if (!row.groupLabel) {
+                rowValues.push('Total');
+            }
+            else {
+                rowValues.push(`Total (${label})`);
+            }
+            const funcXls = null;
+            if (groups[index]) {
+                metaData.xlsMergedCell.push({
+                    start_row: groups[index].init,
+                    start_col: this.colunmXLS[index],
+                    end_row: formatedDataSet.length + 2,
+                    end_col: this.colunmXLS[index],
+                });
+            }
+            columnsName.forEach((column, columnIndex) => {
+                if (!(row.groupFooter && columnIndex === 0)) {
+                    this.formatRowFunc(column, columns, row, index, rowValues, funcXls, groups, indexLastGroup);
+                }
+            });
+        }
+        return rowValues;
+    }
+    // Defina o index dos grupos
+    setIndexGroups(groups, formatedDataSet) {
+        groups.forEach((group) => {
+            if (!group.init) {
+                group.init = formatedDataSet.length + 2;
+            }
+            group.end = formatedDataSet.length + 2;
+        });
+    }
+    // Preenche uma linha "normal"
+    setRowNormal(columnsName, rowValues, row) {
+        columnsName.forEach((column) => {
+            rowValues.push(row[column]);
+        });
+    }
+    formatDataSet(metaData, dataSet) {
+        const initVars = this.initVars(metaData, this.type);
+        const { columns, indexLastGroup, columnsName, formatedDataSet, groups, } = initVars;
+        let { rowValues } = initVars;
+        dataSet.forEach((row) => {
+            if (row.group || row.groupFooter) {
+                if (this.isFormat3(this.type)) {
+                    rowValues = this.setRowGroupFormat3(row, rowValues, groups, formatedDataSet, columnsName, columns, indexLastGroup);
+                }
+                else {
+                    rowValues = this.setRowGroup(row, rowValues, groups, metaData, formatedDataSet, columnsName, columns, indexLastGroup);
+                }
+            }
+            else {
+                this.setIndexGroups(groups, formatedDataSet);
+                this.setRowNormal(columnsName, rowValues, row);
+            }
+            if (!row.groupHeader) {
+                formatedDataSet.push(rowValues);
+            }
+            rowValues = [];
+        });
+        return [columnsName].concat(formatedDataSet);
+    }
 }
 
 class Report {
@@ -11148,8 +11472,8 @@ class Report {
         if (type === 'pdf') {
             return new PDFReport();
         }
-        if (type === 'xls') {
-            return new XLSReport();
+        if (type === 'xls' || type === 'xls2' || type === 'xls3') {
+            return new XLSReport(type);
         }
         throw new Error(`Invalid report type: ${type}`);
     }
@@ -11164,9 +11488,18 @@ class Report {
             const reportType = this.getReportType(type);
             const { route } = reportType;
             const { name, columns, datasource } = this.iterable;
+            const { groupedData } = Object.assign({}, this.iterable);
             const formattedColumns = this.removeActionColumns(columns);
-            const dataset = reportType.buildDataset(data, formattedColumns);
             const metadataObj = yield reportType.buildMetadata(name, this.title, formattedColumns, datasource.filter, portrait);
+            let dataset;
+            if ((reportType.type === 'xls2' || reportType.type === 'xls3') && groupedData) {
+                const rowMetadata = rowObj.metaData;
+                const metadataObjClone = merge(rowMetadata, JSON.parse(metadataObj));
+                dataset = reportType.buildDataset(groupedData, formattedColumns, metadataObjClone);
+            }
+            else {
+                dataset = reportType.buildDataset(data, formattedColumns);
+            }
             const filter = '[]';
             let row = {};
             if (rowObj) {