@wavemaker/angular-codegen 11.2.0-next.141005 → 11.2.0-next.23446
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- angular-codegen/angular-app/package.json +1 -1
- angular-codegen/angular-app/src/assets/styles/css/wm-responsive.css +1 -1
- angular-codegen/angular-app/src/assets/styles/css/wm-style.css +1 -1
- angular-codegen/build-angular-app.js +1 -1
- angular-codegen/dependencies/pipe-provider.cjs.js +11 -10
- angular-codegen/dependencies/transpilation-mobile.cjs.js +377 -318
- angular-codegen/dependencies/transpilation-web.cjs.js +377 -318
- angular-codegen/package.json +1 -1
- angular-codegen/src/codegen-args-cli.js +1 -1
- angular-codegen/src/codegen-cli.js +1 -1
- angular-codegen/src/codegen.js +1 -1
- angular-codegen/src/gen-app-routes.js +1 -1
- angular-codegen/src/gen-app-skeleton.js +1 -1
- angular-codegen/src/gen-components.js +1 -1
- angular-codegen/src/gen-layouts.js +1 -0
- angular-codegen/src/handlebar-helpers.js +1 -1
- angular-codegen/src/pages-util.js +1 -1
- angular-codegen/src/project-meta.js +1 -1
- angular-codegen/src/wm-utils.js +1 -1
- angular-codegen/templates/app-routes.ts.hbs +2 -2
- angular-codegen/templates/layout/layout.component.ts.hbs +32 -0
- angular-codegen/templates/layout/layout.module.ts.hbs +42 -0
- angular-codegen/templates/page/page.component.ts.hbs +2 -2
- angular-codegen/templates/partial/partial.component.ts.hbs +1 -0
- angular-codegen/templates/prefab/prefab.component.ts.hbs +1 -0
| @@ -44438,6 +44438,7 @@ const WIDGET_IMPORTS = new Map([ | |
| 44438 44438 | 
             
                ['wm-network-info-toaster', BASIC_MODULE],
         | 
| 44439 44439 | 
             
                ['wm-number', INPUT_MODULE],
         | 
| 44440 44440 | 
             
                ['wm-page', PAGE_MODULE],
         | 
| 44441 | 
            +
                ['wm-layout', PAGE_MODULE],
         | 
| 44441 44442 | 
             
                ['wm-page-content', PAGE_MODULE],
         | 
| 44442 44443 | 
             
                ['wm-pagedialog', PARTIAL_DIALOG_MODULE],
         | 
| 44443 44444 | 
             
                ['wm-pagination', PAGINATION_MODULE],
         | 
| @@ -44966,14 +44967,14 @@ const scopeComponentStyles = (componentName, componentType, styles = '') => { | |
| 44966 44967 |  | 
| 44967 44968 | 
             
            const carouselTagName = 'carousel';
         | 
| 44968 44969 | 
             
            const dataSetKey$5 = 'dataset';
         | 
| 44969 | 
            -
            const idGen$ | 
| 44970 | 
            +
            const idGen$r = new IDGenerator('wm_carousel_ref_');
         | 
| 44970 44971 | 
             
            const isDynamicCarousel = node => node.attrs.find(attr => attr.name === 'type' && attr.value === 'dynamic');
         | 
| 44971 | 
            -
            const ɵ0$ | 
| 44972 | 
            +
            const ɵ0$d$1 = isDynamicCarousel;
         | 
| 44972 44973 | 
             
            register('wm-carousel', () => {
         | 
| 44973 44974 | 
             
                return {
         | 
| 44974 44975 | 
             
                    pre: (attrs, shared) => {
         | 
| 44975 44976 | 
             
                        // generating unique Id for the carousel
         | 
| 44976 | 
            -
                        const counter = idGen$ | 
| 44977 | 
            +
                        const counter = idGen$r.nextUid();
         | 
| 44977 44978 | 
             
                        shared.set('carousel_ref', counter);
         | 
| 44978 44979 | 
             
                        return `<div class="app-carousel carousel"><${carouselTagName} wmCarousel #${counter}="wmCarousel"  ${getAttrMarkup(attrs)} interval="0" [ngClass]="${counter}.navigationClass">`;
         | 
| 44979 44980 | 
             
                    },
         | 
| @@ -45006,7 +45007,7 @@ var carousel_build = () => { }; | |
| 45006 45007 | 
             
            var carousel_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 45007 45008 | 
             
                __proto__: null,
         | 
| 45008 45009 | 
             
                'default': carousel_build,
         | 
| 45009 | 
            -
                'ɵ0': ɵ0$ | 
| 45010 | 
            +
                'ɵ0': ɵ0$d$1
         | 
| 45010 45011 | 
             
            });
         | 
| 45011 45012 |  | 
| 45012 45013 | 
             
            const carouselContentTagName = 'slide';
         | 
| @@ -45040,11 +45041,11 @@ var carouselTemplate_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45040 45041 | 
             
                'default': carouselTemplate_build
         | 
| 45041 45042 | 
             
            });
         | 
| 45042 45043 |  | 
| 45043 | 
            -
            const tagName$ | 
| 45044 | 
            +
            const tagName$1C = 'div';
         | 
| 45044 45045 | 
             
            register('wm-login', () => {
         | 
| 45045 45046 | 
             
                return {
         | 
| 45046 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45047 | 
            -
                    post: () => `</${tagName$ | 
| 45047 | 
            +
                    pre: attrs => `<${tagName$1C} wmLogin ${getAttrMarkup(attrs)} eventsource.bind="Actions.loginAction">`,
         | 
| 45048 | 
            +
                    post: () => `</${tagName$1C}>`,
         | 
| 45048 45049 | 
             
                    provide: () => {
         | 
| 45049 45050 | 
             
                        const provider = new Map();
         | 
| 45050 45051 | 
             
                        provider.set('isLogin', true);
         | 
| @@ -45059,11 +45060,11 @@ var login_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45059 45060 | 
             
                'default': login_build
         | 
| 45060 45061 | 
             
            });
         | 
| 45061 45062 |  | 
| 45062 | 
            -
            const tagName$ | 
| 45063 | 
            +
            const tagName$1B = 'marquee';
         | 
| 45063 45064 | 
             
            register('wm-marquee', () => {
         | 
| 45064 45065 | 
             
                return {
         | 
| 45065 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45066 | 
            -
                    post: () => `</${tagName$ | 
| 45066 | 
            +
                    pre: attrs => `<${tagName$1B} onmouseover="this.stop();" onmouseout="this.start();" wmMarquee role="marquee" aria-live="off" ${getAttrMarkup(attrs)}>`,
         | 
| 45067 | 
            +
                    post: () => `</${tagName$1B}>`
         | 
| 45067 45068 | 
             
                };
         | 
| 45068 45069 | 
             
            });
         | 
| 45069 45070 | 
             
            var marquee_build = () => { };
         | 
| @@ -45073,15 +45074,15 @@ var marquee_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45073 45074 | 
             
                'default': marquee_build
         | 
| 45074 45075 | 
             
            });
         | 
| 45075 45076 |  | 
| 45076 | 
            -
            const tagName$ | 
| 45077 | 
            -
            const idGen$ | 
| 45077 | 
            +
            const tagName$1A = 'a';
         | 
| 45078 | 
            +
            const idGen$q = new IDGenerator('wm_anchor');
         | 
| 45078 45079 | 
             
            register('wm-anchor', () => {
         | 
| 45079 45080 | 
             
                return {
         | 
| 45080 45081 | 
             
                    pre: (attrs) => {
         | 
| 45081 | 
            -
                        const counter = idGen$ | 
| 45082 | 
            -
                        return `<${tagName$ | 
| 45082 | 
            +
                        const counter = idGen$q.nextUid();
         | 
| 45083 | 
            +
                        return `<${tagName$1A} wmAnchor #${counter}="wmAnchor" role="link" data-identifier="anchor" [attr.aria-label]="${counter}.hint || ${counter}.caption || 'Link'" ${getAttrMarkup(attrs)}>`;
         | 
| 45083 45084 | 
             
                    },
         | 
| 45084 | 
            -
                    post: () => `</${tagName$ | 
| 45085 | 
            +
                    post: () => `</${tagName$1A}>`
         | 
| 45085 45086 | 
             
                };
         | 
| 45086 45087 | 
             
            });
         | 
| 45087 45088 | 
             
            var anchor_build = () => { };
         | 
| @@ -45091,11 +45092,11 @@ var anchor_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45091 45092 | 
             
                'default': anchor_build
         | 
| 45092 45093 | 
             
            });
         | 
| 45093 45094 |  | 
| 45094 | 
            -
            const tagName$ | 
| 45095 | 
            +
            const tagName$1z = 'div';
         | 
| 45095 45096 | 
             
            register('wm-audio', () => {
         | 
| 45096 45097 | 
             
                return {
         | 
| 45097 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45098 | 
            -
                    post: () => `</${tagName$ | 
| 45098 | 
            +
                    pre: attrs => `<${tagName$1z} wmAudio ${getAttrMarkup(attrs)}>`,
         | 
| 45099 | 
            +
                    post: () => `</${tagName$1z}>`
         | 
| 45099 45100 | 
             
                };
         | 
| 45100 45101 | 
             
            });
         | 
| 45101 45102 | 
             
            var audio_build = () => { };
         | 
| @@ -45105,15 +45106,15 @@ var audio_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45105 45106 | 
             
                'default': audio_build
         | 
| 45106 45107 | 
             
            });
         | 
| 45107 45108 |  | 
| 45108 | 
            -
            const tagName$ | 
| 45109 | 
            -
            const idGen$ | 
| 45109 | 
            +
            const tagName$1y = 'div';
         | 
| 45110 | 
            +
            const idGen$p = new IDGenerator('wm_html');
         | 
| 45110 45111 | 
             
            register('wm-html', () => {
         | 
| 45111 45112 | 
             
                return {
         | 
| 45112 45113 | 
             
                    pre: (attrs) => {
         | 
| 45113 | 
            -
                        const counter = idGen$ | 
| 45114 | 
            -
                        return `<${tagName$ | 
| 45114 | 
            +
                        const counter = idGen$p.nextUid();
         | 
| 45115 | 
            +
                        return `<${tagName$1y} wmHtml #${counter}="wmHtml" [attr.aria-label]="${counter}.hint || 'HTML content'" ${getAttrMarkup(attrs)}>`;
         | 
| 45115 45116 | 
             
                    },
         | 
| 45116 | 
            -
                    post: () => `</${tagName$ | 
| 45117 | 
            +
                    post: () => `</${tagName$1y}>`
         | 
| 45117 45118 | 
             
                };
         | 
| 45118 45119 | 
             
            });
         | 
| 45119 45120 | 
             
            var html_build = () => { };
         | 
| @@ -45123,11 +45124,11 @@ var html_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45123 45124 | 
             
                'default': html_build
         | 
| 45124 45125 | 
             
            });
         | 
| 45125 45126 |  | 
| 45126 | 
            -
            const tagName$ | 
| 45127 | 
            +
            const tagName$1x = 'span';
         | 
| 45127 45128 | 
             
            register('wm-icon', () => {
         | 
| 45128 45129 | 
             
                return {
         | 
| 45129 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45130 | 
            -
                    post: () => `</${tagName$ | 
| 45130 | 
            +
                    pre: attrs => `<${tagName$1x} wmIcon aria-hidden="true" ${getAttrMarkup(attrs)}>`,
         | 
| 45131 | 
            +
                    post: () => `</${tagName$1x}>`
         | 
| 45131 45132 | 
             
                };
         | 
| 45132 45133 | 
             
            });
         | 
| 45133 45134 | 
             
            var icon_build = () => { };
         | 
| @@ -45137,11 +45138,11 @@ var icon_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45137 45138 | 
             
                'default': icon_build
         | 
| 45138 45139 | 
             
            });
         | 
| 45139 45140 |  | 
| 45140 | 
            -
            const tagName$ | 
| 45141 | 
            +
            const tagName$1w = 'div';
         | 
| 45141 45142 | 
             
            register('wm-iframe', () => {
         | 
| 45142 45143 | 
             
                return {
         | 
| 45143 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45144 | 
            -
                    post: () => `</${tagName$ | 
| 45144 | 
            +
                    pre: attrs => `<${tagName$1w} wmIframe ${getAttrMarkup(attrs)}>`,
         | 
| 45145 | 
            +
                    post: () => `</${tagName$1w}>`
         | 
| 45145 45146 | 
             
                };
         | 
| 45146 45147 | 
             
            });
         | 
| 45147 45148 | 
             
            var iframe_build = () => { };
         | 
| @@ -45151,15 +45152,15 @@ var iframe_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45151 45152 | 
             
                'default': iframe_build
         | 
| 45152 45153 | 
             
            });
         | 
| 45153 45154 |  | 
| 45154 | 
            -
            const tagName$ | 
| 45155 | 
            -
            const idGen$ | 
| 45155 | 
            +
            const tagName$1v = 'label';
         | 
| 45156 | 
            +
            const idGen$o = new IDGenerator('wm_label');
         | 
| 45156 45157 | 
             
            register('wm-label', () => {
         | 
| 45157 45158 | 
             
                return {
         | 
| 45158 45159 | 
             
                    pre: (attrs) => {
         | 
| 45159 | 
            -
                        const counter = idGen$ | 
| 45160 | 
            -
                        return `<${tagName$ | 
| 45160 | 
            +
                        const counter = idGen$o.nextUid();
         | 
| 45161 | 
            +
                        return `<${tagName$1v} wmLabel #${counter}="wmLabel" [attr.aria-label]="${counter}.hint || 'Label text'" ${getAttrMarkup(attrs)}>`;
         | 
| 45161 45162 | 
             
                    },
         | 
| 45162 | 
            -
                    post: () => `</${tagName$ | 
| 45163 | 
            +
                    post: () => `</${tagName$1v}>`
         | 
| 45163 45164 | 
             
                };
         | 
| 45164 45165 | 
             
            });
         | 
| 45165 45166 | 
             
            var label_build = () => { };
         | 
| @@ -45169,13 +45170,13 @@ var label_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45169 45170 | 
             
                'default': label_build
         | 
| 45170 45171 | 
             
            });
         | 
| 45171 45172 |  | 
| 45172 | 
            -
            const tagName$ | 
| 45173 | 
            -
            const idGen$ | 
| 45173 | 
            +
            const tagName$1u = 'img';
         | 
| 45174 | 
            +
            const idGen$n = new IDGenerator('wm_picture');
         | 
| 45174 45175 | 
             
            register('wm-picture', () => {
         | 
| 45175 45176 | 
             
                return {
         | 
| 45176 45177 | 
             
                    pre: (attrs) => {
         | 
| 45177 | 
            -
                        const counter = idGen$ | 
| 45178 | 
            -
                        return `<${tagName$ | 
| 45178 | 
            +
                        const counter = idGen$n.nextUid();
         | 
| 45179 | 
            +
                        return `<${tagName$1u} wmPicture #${counter}="wmPicture" alt="image" wmImageCache="${attrs.get('offline') || 'true'}" [attr.aria-label]="${counter}.hint || 'Image'" ${getAttrMarkup(attrs)}>`;
         | 
| 45179 45180 | 
             
                    }
         | 
| 45180 45181 | 
             
                };
         | 
| 45181 45182 | 
             
            });
         | 
| @@ -45186,15 +45187,15 @@ var picture_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45186 45187 | 
             
                'default': picture_build
         | 
| 45187 45188 | 
             
            });
         | 
| 45188 45189 |  | 
| 45189 | 
            -
            const tagName$ | 
| 45190 | 
            -
            const idGen$ | 
| 45190 | 
            +
            const tagName$1t = 'div';
         | 
| 45191 | 
            +
            const idGen$m = new IDGenerator('wm_spinner');
         | 
| 45191 45192 | 
             
            register('wm-spinner', () => {
         | 
| 45192 45193 | 
             
                return {
         | 
| 45193 45194 | 
             
                    pre: (attrs) => {
         | 
| 45194 | 
            -
                        const counter = idGen$ | 
| 45195 | 
            -
                        return `<${tagName$ | 
| 45195 | 
            +
                        const counter = idGen$m.nextUid();
         | 
| 45196 | 
            +
                        return `<${tagName$1t} wmSpinner #${counter}="wmSpinner" role="alert" [attr.aria-label]="${counter}.hint || 'Loading...'" aria-live="assertive" aria-busy="true" ${getAttrMarkup(attrs)}>`;
         | 
| 45196 45197 | 
             
                    },
         | 
| 45197 | 
            -
                    post: () => `</${tagName$ | 
| 45198 | 
            +
                    post: () => `</${tagName$1t}>`
         | 
| 45198 45199 | 
             
                };
         | 
| 45199 45200 | 
             
            });
         | 
| 45200 45201 | 
             
            var spinner_build = () => { };
         | 
| @@ -45204,16 +45205,16 @@ var spinner_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45204 45205 | 
             
                'default': spinner_build
         | 
| 45205 45206 | 
             
            });
         | 
| 45206 45207 |  | 
| 45207 | 
            -
            const tagName$ | 
| 45208 | 
            +
            const tagName$1s = 'div';
         | 
| 45208 45209 | 
             
            const getAttr = (node, attrName) => node.attrs.find(attr => attr.name === attrName);
         | 
| 45209 | 
            -
            const ɵ0$ | 
| 45210 | 
            +
            const ɵ0$c$1 = getAttr;
         | 
| 45210 45211 | 
             
            const getAttrValue = (node, attrName) => {
         | 
| 45211 45212 | 
             
                const match = getAttr(node, attrName);
         | 
| 45212 45213 | 
             
                if (match) {
         | 
| 45213 45214 | 
             
                    return match.value;
         | 
| 45214 45215 | 
             
                }
         | 
| 45215 45216 | 
             
            };
         | 
| 45216 | 
            -
            const ɵ1$ | 
| 45217 | 
            +
            const ɵ1$8 = getAttrValue;
         | 
| 45217 45218 | 
             
            const getReplaceRegex = (v) => new RegExp(`bind:(${v}|${v}\\[\\$i])\\.`, 'g');
         | 
| 45218 45219 | 
             
            const ɵ2$4$1 = getReplaceRegex;
         | 
| 45219 45220 | 
             
            register('wm-progress-bar', () => {
         | 
| @@ -45235,8 +45236,8 @@ register('wm-progress-bar', () => { | |
| 45235 45236 | 
             
                            }
         | 
| 45236 45237 | 
             
                        }
         | 
| 45237 45238 | 
             
                    },
         | 
| 45238 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45239 | 
            -
                    post: () => `</${tagName$ | 
| 45239 | 
            +
                    pre: attrs => `<${tagName$1s} wmProgressBar ${getAttrMarkup(attrs)}>`,
         | 
| 45240 | 
            +
                    post: () => `</${tagName$1s}>`
         | 
| 45240 45241 | 
             
                };
         | 
| 45241 45242 | 
             
            });
         | 
| 45242 45243 | 
             
            var progressBar_build = () => { };
         | 
| @@ -45244,16 +45245,16 @@ var progressBar_build = () => { }; | |
| 45244 45245 | 
             
            var progressBar_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 45245 45246 | 
             
                __proto__: null,
         | 
| 45246 45247 | 
             
                'default': progressBar_build,
         | 
| 45247 | 
            -
                'ɵ0': ɵ0$ | 
| 45248 | 
            -
                'ɵ1': ɵ1$ | 
| 45248 | 
            +
                'ɵ0': ɵ0$c$1,
         | 
| 45249 | 
            +
                'ɵ1': ɵ1$8,
         | 
| 45249 45250 | 
             
                'ɵ2': ɵ2$4$1
         | 
| 45250 45251 | 
             
            });
         | 
| 45251 45252 |  | 
| 45252 | 
            -
            const tagName$ | 
| 45253 | 
            +
            const tagName$1r = 'div';
         | 
| 45253 45254 | 
             
            register('wm-progress-circle', () => {
         | 
| 45254 45255 | 
             
                return {
         | 
| 45255 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45256 | 
            -
                    post: () => `</${tagName$ | 
| 45256 | 
            +
                    pre: attrs => `<${tagName$1r} wmProgressCircle ${getAttrMarkup(attrs)}>`,
         | 
| 45257 | 
            +
                    post: () => `</${tagName$1r}>`
         | 
| 45257 45258 | 
             
                };
         | 
| 45258 45259 | 
             
            });
         | 
| 45259 45260 | 
             
            var progressCircle_build = () => { };
         | 
| @@ -45263,15 +45264,15 @@ var progressCircle_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45263 45264 | 
             
                'default': progressCircle_build
         | 
| 45264 45265 | 
             
            });
         | 
| 45265 45266 |  | 
| 45266 | 
            -
            const tagName$ | 
| 45267 | 
            -
            const idGen$ | 
| 45267 | 
            +
            const tagName$1q = 'div';
         | 
| 45268 | 
            +
            const idGen$l = new IDGenerator('wm_richtexteditor');
         | 
| 45268 45269 | 
             
            register('wm-richtexteditor', () => {
         | 
| 45269 45270 | 
             
                return {
         | 
| 45270 45271 | 
             
                    pre: (attrs) => {
         | 
| 45271 | 
            -
                        const counter = idGen$ | 
| 45272 | 
            -
                        return `<${tagName$ | 
| 45272 | 
            +
                        const counter = idGen$l.nextUid();
         | 
| 45273 | 
            +
                        return `<${tagName$1q} wmRichTextEditor #${counter}="wmRichTextEditor" role="textbox" [attr.aria-label]="${counter}.hint || 'Richtext editor'" ${getFormMarkupAttr(attrs)}>`;
         | 
| 45273 45274 | 
             
                    },
         | 
| 45274 | 
            -
                    post: () => `</${tagName$ | 
| 45275 | 
            +
                    post: () => `</${tagName$1q}>`
         | 
| 45275 45276 | 
             
                };
         | 
| 45276 45277 | 
             
            });
         | 
| 45277 45278 | 
             
            var richTextEditor_build = () => { };
         | 
| @@ -45281,11 +45282,11 @@ var richTextEditor_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45281 45282 | 
             
                'default': richTextEditor_build
         | 
| 45282 45283 | 
             
            });
         | 
| 45283 45284 |  | 
| 45284 | 
            -
            const tagName$ | 
| 45285 | 
            +
            const tagName$1p = 'div';
         | 
| 45285 45286 | 
             
            register('wm-search', () => {
         | 
| 45286 45287 | 
             
                return {
         | 
| 45287 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45288 | 
            -
                    post: () => `</${tagName$ | 
| 45288 | 
            +
                    pre: attrs => `<${tagName$1p} wmSearch ${getFormMarkupAttr(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 45289 | 
            +
                    post: () => `</${tagName$1p}>`
         | 
| 45289 45290 | 
             
                };
         | 
| 45290 45291 | 
             
            });
         | 
| 45291 45292 | 
             
            var search_build = () => { };
         | 
| @@ -45295,11 +45296,11 @@ var search_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45295 45296 | 
             
                'default': search_build
         | 
| 45296 45297 | 
             
            });
         | 
| 45297 45298 |  | 
| 45298 | 
            -
            const tagName$ | 
| 45299 | 
            +
            const tagName$1o = 'div';
         | 
| 45299 45300 | 
             
            register('wm-tree', () => {
         | 
| 45300 45301 | 
             
                return {
         | 
| 45301 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45302 | 
            -
                    post: () => `</${tagName$ | 
| 45302 | 
            +
                    pre: attrs => `<${tagName$1o} wmTree ${getAttrMarkup(attrs)}>`,
         | 
| 45303 | 
            +
                    post: () => `</${tagName$1o}>`
         | 
| 45303 45304 | 
             
                };
         | 
| 45304 45305 | 
             
            });
         | 
| 45305 45306 | 
             
            var tree_build = () => { };
         | 
| @@ -45309,11 +45310,11 @@ var tree_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45309 45310 | 
             
                'default': tree_build
         | 
| 45310 45311 | 
             
            });
         | 
| 45311 45312 |  | 
| 45312 | 
            -
            const tagName$ | 
| 45313 | 
            +
            const tagName$1n = 'div';
         | 
| 45313 45314 | 
             
            register('wm-card', () => {
         | 
| 45314 45315 | 
             
                return {
         | 
| 45315 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45316 | 
            -
                    post: () => `</${tagName$ | 
| 45316 | 
            +
                    pre: attrs => `<${tagName$1n} wmCard ${getAttrMarkup(attrs)}>`,
         | 
| 45317 | 
            +
                    post: () => `</${tagName$1n}>`
         | 
| 45317 45318 | 
             
                };
         | 
| 45318 45319 | 
             
            });
         | 
| 45319 45320 | 
             
            var card_build = () => { };
         | 
| @@ -45323,11 +45324,11 @@ var card_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45323 45324 | 
             
                'default': card_build
         | 
| 45324 45325 | 
             
            });
         | 
| 45325 45326 |  | 
| 45326 | 
            -
            const tagName$ | 
| 45327 | 
            +
            const tagName$1m = 'div';
         | 
| 45327 45328 | 
             
            register('wm-card-content', () => {
         | 
| 45328 45329 | 
             
                return {
         | 
| 45329 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45330 | 
            -
                    post: () => `</${tagName$ | 
| 45330 | 
            +
                    pre: attrs => `<${tagName$1m} wmCardContent partialContainer ${getAttrMarkup(attrs)}>`,
         | 
| 45331 | 
            +
                    post: () => `</${tagName$1m}>`
         | 
| 45331 45332 | 
             
                };
         | 
| 45332 45333 | 
             
            });
         | 
| 45333 45334 | 
             
            var cardContent_build = () => { };
         | 
| @@ -45337,11 +45338,11 @@ var cardContent_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45337 45338 | 
             
                'default': cardContent_build
         | 
| 45338 45339 | 
             
            });
         | 
| 45339 45340 |  | 
| 45340 | 
            -
            const tagName$ | 
| 45341 | 
            +
            const tagName$1l = 'div';
         | 
| 45341 45342 | 
             
            register('wm-card-actions', () => {
         | 
| 45342 45343 | 
             
                return {
         | 
| 45343 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45344 | 
            -
                    post: () => `</${tagName$ | 
| 45344 | 
            +
                    pre: attrs => `<${tagName$1l} wmCardActions ${getAttrMarkup(attrs)}>`,
         | 
| 45345 | 
            +
                    post: () => `</${tagName$1l}>`
         | 
| 45345 45346 | 
             
                };
         | 
| 45346 45347 | 
             
            });
         | 
| 45347 45348 | 
             
            var cardActions_build = () => { };
         | 
| @@ -45351,11 +45352,11 @@ var cardActions_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45351 45352 | 
             
                'default': cardActions_build
         | 
| 45352 45353 | 
             
            });
         | 
| 45353 45354 |  | 
| 45354 | 
            -
            const tagName$ | 
| 45355 | 
            +
            const tagName$1k = 'div';
         | 
| 45355 45356 | 
             
            register('wm-card-footer', () => {
         | 
| 45356 45357 | 
             
                return {
         | 
| 45357 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45358 | 
            -
                    post: () => `</${tagName$ | 
| 45358 | 
            +
                    pre: attrs => `<${tagName$1k} wmCardFooter ${getAttrMarkup(attrs)}>`,
         | 
| 45359 | 
            +
                    post: () => `</${tagName$1k}>`
         | 
| 45359 45360 | 
             
                };
         | 
| 45360 45361 | 
             
            });
         | 
| 45361 45362 | 
             
            var cardFooter_build = () => { };
         | 
| @@ -45365,11 +45366,11 @@ var cardFooter_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45365 45366 | 
             
                'default': cardFooter_build
         | 
| 45366 45367 | 
             
            });
         | 
| 45367 45368 |  | 
| 45368 | 
            -
            const tagName$ | 
| 45369 | 
            +
            const tagName$1j = 'div';
         | 
| 45369 45370 | 
             
            register('wm-chart', () => {
         | 
| 45370 45371 | 
             
                return {
         | 
| 45371 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45372 | 
            -
                    post: () => `</${tagName$ | 
| 45372 | 
            +
                    pre: attrs => `<${tagName$1j} wmChart redrawable aria-label="${attrs.get('type')} Chart" ${getAttrMarkup(attrs)}>`,
         | 
| 45373 | 
            +
                    post: () => `</${tagName$1j}>`
         | 
| 45373 45374 | 
             
                };
         | 
| 45374 45375 | 
             
            });
         | 
| 45375 45376 | 
             
            var chart_build = () => { };
         | 
| @@ -45379,20 +45380,20 @@ var chart_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45379 45380 | 
             
                'default': chart_build
         | 
| 45380 45381 | 
             
            });
         | 
| 45381 45382 |  | 
| 45382 | 
            -
            const tagName$ | 
| 45383 | 
            +
            const tagName$1i = 'div';
         | 
| 45383 45384 | 
             
            const dataSetKey$4 = 'dataset';
         | 
| 45384 | 
            -
            const idGen$ | 
| 45385 | 
            +
            const idGen$k = new IDGenerator('wm_accordion_ref_');
         | 
| 45385 45386 | 
             
            const isDynamicAccordion = node => node.attrs.find(attr => attr.name === 'type' && attr.value === 'dynamic');
         | 
| 45386 | 
            -
            const ɵ0$ | 
| 45387 | 
            +
            const ɵ0$b$1 = isDynamicAccordion;
         | 
| 45387 45388 | 
             
            register('wm-accordion', () => {
         | 
| 45388 45389 | 
             
                return {
         | 
| 45389 45390 | 
             
                    pre: (attrs, shared) => {
         | 
| 45390 45391 | 
             
                        // generating unique Id for the accordion
         | 
| 45391 | 
            -
                        const counter = idGen$ | 
| 45392 | 
            +
                        const counter = idGen$k.nextUid();
         | 
| 45392 45393 | 
             
                        shared.set('accordion_ref', counter);
         | 
| 45393 | 
            -
                        return `<${tagName$ | 
| 45394 | 
            +
                        return `<${tagName$1i} wmAccordion #${counter}="wmAccordion" role="tablist" aria-multiselectable="true" ${getAttrMarkup(attrs)}>`;
         | 
| 45394 45395 | 
             
                    },
         | 
| 45395 | 
            -
                    post: () => `</${tagName$ | 
| 45396 | 
            +
                    post: () => `</${tagName$1i}>`,
         | 
| 45396 45397 | 
             
                    template: (node, shared) => {
         | 
| 45397 45398 | 
             
                        // check if the accordion is dynamic
         | 
| 45398 45399 | 
             
                        if (isDynamicAccordion(node)) {
         | 
| @@ -45421,14 +45422,14 @@ var accordion_build = () => { }; | |
| 45421 45422 | 
             
            var accordion_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 45422 45423 | 
             
                __proto__: null,
         | 
| 45423 45424 | 
             
                'default': accordion_build,
         | 
| 45424 | 
            -
                'ɵ0': ɵ0$ | 
| 45425 | 
            +
                'ɵ0': ɵ0$b$1
         | 
| 45425 45426 | 
             
            });
         | 
| 45426 45427 |  | 
| 45427 | 
            -
            const tagName$ | 
| 45428 | 
            +
            const tagName$1h = 'div';
         | 
| 45428 45429 | 
             
            register('wm-accordionpane', () => {
         | 
| 45429 45430 | 
             
                return {
         | 
| 45430 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45431 | 
            -
                    post: () => `</${tagName$ | 
| 45431 | 
            +
                    pre: attrs => `<${tagName$1h} wmAccordionPane partialContainer wm-navigable-element="true" role="tab" ${getAttrMarkup(attrs)}>`,
         | 
| 45432 | 
            +
                    post: () => `</${tagName$1h}>`
         | 
| 45432 45433 | 
             
                };
         | 
| 45433 45434 | 
             
            });
         | 
| 45434 45435 | 
             
            var accordionPane_build = () => { };
         | 
| @@ -45438,11 +45439,11 @@ var accordionPane_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45438 45439 | 
             
                'default': accordionPane_build
         | 
| 45439 45440 | 
             
            });
         | 
| 45440 45441 |  | 
| 45441 | 
            -
            const tagName$ | 
| 45442 | 
            +
            const tagName$1g = 'div';
         | 
| 45442 45443 | 
             
            register('wm-container', () => {
         | 
| 45443 45444 | 
             
                return {
         | 
| 45444 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45445 | 
            -
                    post: () => `</${tagName$ | 
| 45445 | 
            +
                    pre: attrs => `<${tagName$1g} wmContainer partialContainer wmSmoothscroll="${attrs.get('smoothscroll') || 'false'}" ${getAttrMarkup(attrs)}>`,
         | 
| 45446 | 
            +
                    post: () => `</${tagName$1g}>`
         | 
| 45446 45447 | 
             
                };
         | 
| 45447 45448 | 
             
            });
         | 
| 45448 45449 | 
             
            var container_build = () => { };
         | 
| @@ -45452,11 +45453,11 @@ var container_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45452 45453 | 
             
                'default': container_build
         | 
| 45453 45454 | 
             
            });
         | 
| 45454 45455 |  | 
| 45455 | 
            -
            const tagName$ | 
| 45456 | 
            +
            const tagName$1f = 'div';
         | 
| 45456 45457 | 
             
            register('wm-gridcolumn', () => {
         | 
| 45457 45458 | 
             
                return {
         | 
| 45458 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45459 | 
            -
                    post: () => `</${tagName$ | 
| 45459 | 
            +
                    pre: attrs => `<${tagName$1f} wmLayoutGridColumn ${getAttrMarkup(attrs)}>`,
         | 
| 45460 | 
            +
                    post: () => `</${tagName$1f}>`
         | 
| 45460 45461 | 
             
                };
         | 
| 45461 45462 | 
             
            });
         | 
| 45462 45463 | 
             
            var layoutGridColumn_build = () => { };
         | 
| @@ -45466,11 +45467,11 @@ var layoutGridColumn_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45466 45467 | 
             
                'default': layoutGridColumn_build
         | 
| 45467 45468 | 
             
            });
         | 
| 45468 45469 |  | 
| 45469 | 
            -
            const tagName$ | 
| 45470 | 
            +
            const tagName$1e = 'div';
         | 
| 45470 45471 | 
             
            register('wm-gridrow', () => {
         | 
| 45471 45472 | 
             
                return {
         | 
| 45472 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45473 | 
            -
                    post: () => `</${tagName$ | 
| 45473 | 
            +
                    pre: attrs => `<${tagName$1e} wmLayoutGridRow ${getAttrMarkup(attrs)}>`,
         | 
| 45474 | 
            +
                    post: () => `</${tagName$1e}>`
         | 
| 45474 45475 | 
             
                };
         | 
| 45475 45476 | 
             
            });
         | 
| 45476 45477 | 
             
            var layoutGridRow_build = () => { };
         | 
| @@ -45480,11 +45481,11 @@ var layoutGridRow_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45480 45481 | 
             
                'default': layoutGridRow_build
         | 
| 45481 45482 | 
             
            });
         | 
| 45482 45483 |  | 
| 45483 | 
            -
            const tagName$ | 
| 45484 | 
            +
            const tagName$1d = 'div';
         | 
| 45484 45485 | 
             
            register('wm-layoutgrid', () => {
         | 
| 45485 45486 | 
             
                return {
         | 
| 45486 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45487 | 
            -
                    post: () => `</${tagName$ | 
| 45487 | 
            +
                    pre: attrs => `<${tagName$1d} wmLayoutGrid ${getAttrMarkup(attrs)}>`,
         | 
| 45488 | 
            +
                    post: () => `</${tagName$1d}>`
         | 
| 45488 45489 | 
             
                };
         | 
| 45489 45490 | 
             
            });
         | 
| 45490 45491 | 
             
            var layoutGrid_build = () => { };
         | 
| @@ -45494,21 +45495,21 @@ var layoutGrid_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45494 45495 | 
             
                'default': layoutGrid_build
         | 
| 45495 45496 | 
             
            });
         | 
| 45496 45497 |  | 
| 45497 | 
            -
            const tagName$ | 
| 45498 | 
            -
            const idGen$ | 
| 45498 | 
            +
            const tagName$1c = 'div';
         | 
| 45499 | 
            +
            const idGen$j = new IDGenerator('wm_panel');
         | 
| 45499 45500 | 
             
            register('wm-panel', () => {
         | 
| 45500 45501 | 
             
                return {
         | 
| 45501 45502 | 
             
                    pre: (attrs) => {
         | 
| 45502 | 
            -
                        const counter = idGen$ | 
| 45503 | 
            -
                        return `<${tagName$ | 
| 45503 | 
            +
                        const counter = idGen$j.nextUid();
         | 
| 45504 | 
            +
                        return `<${tagName$1c} wmPanel #${counter}="wmPanel" partialContainer [attr.aria-label]="${counter}.hint || 'Panel'" wm-navigable-element="true" ${getAttrMarkup(attrs)}>`;
         | 
| 45504 45505 | 
             
                    },
         | 
| 45505 | 
            -
                    post: () => `</${tagName$ | 
| 45506 | 
            +
                    post: () => `</${tagName$1c}>`
         | 
| 45506 45507 | 
             
                };
         | 
| 45507 45508 | 
             
            });
         | 
| 45508 45509 | 
             
            register('wm-panel-footer', () => {
         | 
| 45509 45510 | 
             
                return {
         | 
| 45510 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45511 | 
            -
                    post: () => `</${tagName$ | 
| 45511 | 
            +
                    pre: attrs => `<${tagName$1c} wmPanelFooter ${getAttrMarkup(attrs)}>`,
         | 
| 45512 | 
            +
                    post: () => `</${tagName$1c}>`
         | 
| 45512 45513 | 
             
                };
         | 
| 45513 45514 | 
             
            });
         | 
| 45514 45515 | 
             
            var panel_build = () => { };
         | 
| @@ -45518,11 +45519,11 @@ var panel_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45518 45519 | 
             
                'default': panel_build
         | 
| 45519 45520 | 
             
            });
         | 
| 45520 45521 |  | 
| 45521 | 
            -
            const tagName$ | 
| 45522 | 
            +
            const tagName$1b = 'div';
         | 
| 45522 45523 | 
             
            register('wm-segmented-control', () => {
         | 
| 45523 45524 | 
             
                return {
         | 
| 45524 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45525 | 
            -
                    post: () => `</${tagName$ | 
| 45525 | 
            +
                    pre: attrs => `<${tagName$1b} wmSegmentedControl ${getAttrMarkup(attrs)}>`,
         | 
| 45526 | 
            +
                    post: () => `</${tagName$1b}>`
         | 
| 45526 45527 | 
             
                };
         | 
| 45527 45528 | 
             
            });
         | 
| 45528 45529 | 
             
            var segmentedControl_build = () => { };
         | 
| @@ -45532,11 +45533,11 @@ var segmentedControl_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45532 45533 | 
             
                'default': segmentedControl_build
         | 
| 45533 45534 | 
             
            });
         | 
| 45534 45535 |  | 
| 45535 | 
            -
            const tagName$ | 
| 45536 | 
            +
            const tagName$1a = 'li';
         | 
| 45536 45537 | 
             
            register('wm-segment-content', () => {
         | 
| 45537 45538 | 
             
                return {
         | 
| 45538 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45539 | 
            -
                    post: () => `</${tagName$ | 
| 45539 | 
            +
                    pre: attrs => `<${tagName$1a} wmSegmentContent partialContainer wmSmoothscroll=${attrs.get('smoothscroll') || 'false'} wm-navigable-element="true" ${getAttrMarkup(attrs)}>`,
         | 
| 45540 | 
            +
                    post: () => `</${tagName$1a}>`
         | 
| 45540 45541 | 
             
                };
         | 
| 45541 45542 | 
             
            });
         | 
| 45542 45543 | 
             
            var segmentContent_build = () => { };
         | 
| @@ -45572,20 +45573,20 @@ var repeatTemplate_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45572 45573 | 
             
                'default': repeatTemplate_build
         | 
| 45573 45574 | 
             
            });
         | 
| 45574 45575 |  | 
| 45575 | 
            -
            const tagName$ | 
| 45576 | 
            +
            const tagName$19 = 'div';
         | 
| 45576 45577 | 
             
            const dataSetKey$3 = 'dataset';
         | 
| 45577 | 
            -
            const idGen$ | 
| 45578 | 
            +
            const idGen$i = new IDGenerator('wm_tabs_ref_');
         | 
| 45578 45579 | 
             
            const isDynamicTabs = node => node.attrs.find(attr => attr.name === 'type' && attr.value === 'dynamic');
         | 
| 45579 | 
            -
            const ɵ0$ | 
| 45580 | 
            +
            const ɵ0$a$1 = isDynamicTabs;
         | 
| 45580 45581 | 
             
            register('wm-tabs', () => {
         | 
| 45581 45582 | 
             
                return {
         | 
| 45582 45583 | 
             
                    pre: (attrs, shared) => {
         | 
| 45583 45584 | 
             
                        // generating unique Id for the tabs
         | 
| 45584 | 
            -
                        const counter = idGen$ | 
| 45585 | 
            +
                        const counter = idGen$i.nextUid();
         | 
| 45585 45586 | 
             
                        shared.set('tabs_ref', counter);
         | 
| 45586 | 
            -
                        return `<${tagName$ | 
| 45587 | 
            +
                        return `<${tagName$19} wmTabs #${counter}="wmTabs" ${getAttrMarkup(attrs)}>`;
         | 
| 45587 45588 | 
             
                    },
         | 
| 45588 | 
            -
                    post: () => `</${tagName$ | 
| 45589 | 
            +
                    post: () => `</${tagName$19}>`,
         | 
| 45589 45590 | 
             
                    template: (node, shared) => {
         | 
| 45590 45591 | 
             
                        // check if the tab widget is dynamic
         | 
| 45591 45592 | 
             
                        if (isDynamicTabs(node)) {
         | 
| @@ -45614,14 +45615,14 @@ var tabs_build = () => { }; | |
| 45614 45615 | 
             
            var tabs_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 45615 45616 | 
             
                __proto__: null,
         | 
| 45616 45617 | 
             
                'default': tabs_build,
         | 
| 45617 | 
            -
                'ɵ0': ɵ0$ | 
| 45618 | 
            +
                'ɵ0': ɵ0$a$1
         | 
| 45618 45619 | 
             
            });
         | 
| 45619 45620 |  | 
| 45620 | 
            -
            const tagName$ | 
| 45621 | 
            +
            const tagName$18 = 'div';
         | 
| 45621 45622 | 
             
            register('wm-tabpane', () => {
         | 
| 45622 45623 | 
             
                return {
         | 
| 45623 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45624 | 
            -
                    post: () => `</${tagName$ | 
| 45624 | 
            +
                    pre: attrs => `<${tagName$18} wmTabPane  partialContainer ${getAttrMarkup(attrs)} wm-navigable-element="true" role="tabpanel">`,
         | 
| 45625 | 
            +
                    post: () => `</${tagName$18}>`
         | 
| 45625 45626 | 
             
                };
         | 
| 45626 45627 | 
             
            });
         | 
| 45627 45628 | 
             
            var tabPane_build = () => { };
         | 
| @@ -45631,11 +45632,11 @@ var tabPane_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45631 45632 | 
             
                'default': tabPane_build
         | 
| 45632 45633 | 
             
            });
         | 
| 45633 45634 |  | 
| 45634 | 
            -
            const tagName$ | 
| 45635 | 
            +
            const tagName$17 = 'div';
         | 
| 45635 45636 | 
             
            register('wm-tile', () => {
         | 
| 45636 45637 | 
             
                return {
         | 
| 45637 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45638 | 
            -
                    post: () => `</${tagName$ | 
| 45638 | 
            +
                    pre: attrs => `<${tagName$17} wmTile aria-describedby="Tile" wm-navigable-element="true" ${getAttrMarkup(attrs)}>`,
         | 
| 45639 | 
            +
                    post: () => `</${tagName$17}>`
         | 
| 45639 45640 | 
             
                };
         | 
| 45640 45641 | 
             
            });
         | 
| 45641 45642 | 
             
            var tile_build = () => { };
         | 
| @@ -45645,11 +45646,11 @@ var tile_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45645 45646 | 
             
                'default': tile_build
         | 
| 45646 45647 | 
             
            });
         | 
| 45647 45648 |  | 
| 45648 | 
            -
            const tagName$ | 
| 45649 | 
            +
            const tagName$16 = 'div';
         | 
| 45649 45650 | 
             
            register('wm-wizard', () => {
         | 
| 45650 45651 | 
             
                return {
         | 
| 45651 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45652 | 
            -
                    post: () => `</${tagName$ | 
| 45652 | 
            +
                    pre: attrs => `<${tagName$16} wmWizard role="tablist" ${getAttrMarkup(attrs)}>`,
         | 
| 45653 | 
            +
                    post: () => `</${tagName$16}>`
         | 
| 45653 45654 | 
             
                };
         | 
| 45654 45655 | 
             
            });
         | 
| 45655 45656 | 
             
            var wizard_build = () => { };
         | 
| @@ -45659,16 +45660,16 @@ var wizard_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45659 45660 | 
             
                'default': wizard_build
         | 
| 45660 45661 | 
             
            });
         | 
| 45661 45662 |  | 
| 45662 | 
            -
            const tagName$ | 
| 45663 | 
            -
            const idGen$ | 
| 45663 | 
            +
            const tagName$15 = 'form';
         | 
| 45664 | 
            +
            const idGen$h = new IDGenerator('wizard_step_id_');
         | 
| 45664 45665 | 
             
            register('wm-wizardstep', () => {
         | 
| 45665 45666 | 
             
                return {
         | 
| 45666 45667 | 
             
                    pre: attrs => {
         | 
| 45667 | 
            -
                        const counter = idGen$ | 
| 45668 | 
            -
                        return `<${tagName$ | 
| 45668 | 
            +
                        const counter = idGen$h.nextUid();
         | 
| 45669 | 
            +
                        return `<${tagName$15} wmWizardStep #${counter}="wmWizardStep" ${getAttrMarkup(attrs)}>
         | 
| 45669 45670 | 
             
                                   <ng-template [ngIf]="${counter}.isInitialized">`;
         | 
| 45670 45671 | 
             
                    },
         | 
| 45671 | 
            -
                    post: () => `</ng-template></${tagName$ | 
| 45672 | 
            +
                    post: () => `</ng-template></${tagName$15}>`
         | 
| 45672 45673 | 
             
                };
         | 
| 45673 45674 | 
             
            });
         | 
| 45674 45675 | 
             
            var wizardStep_build = () => { };
         | 
| @@ -45678,15 +45679,15 @@ var wizardStep_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45678 45679 | 
             
                'default': wizardStep_build
         | 
| 45679 45680 | 
             
            });
         | 
| 45680 45681 |  | 
| 45681 | 
            -
            const tagName$ | 
| 45682 | 
            -
            const idGen$ | 
| 45682 | 
            +
            const tagName$14 = 'button';
         | 
| 45683 | 
            +
            const idGen$g = new IDGenerator('wm_barcodescanner');
         | 
| 45683 45684 | 
             
            register('wm-barcodescanner', () => {
         | 
| 45684 45685 | 
             
                return {
         | 
| 45685 45686 | 
             
                    pre: (attrs) => {
         | 
| 45686 | 
            -
                        const counter = idGen$ | 
| 45687 | 
            -
                        return `<${tagName$ | 
| 45687 | 
            +
                        const counter = idGen$g.nextUid();
         | 
| 45688 | 
            +
                        return `<${tagName$14} wmBarcodescanner #${counter}="wmBarcodescanner" [attr.aria-label]="${counter}.hint || 'Barcode scanner'"  ${getAttrMarkup(attrs)}>`;
         | 
| 45688 45689 | 
             
                    },
         | 
| 45689 | 
            -
                    post: () => `</${tagName$ | 
| 45690 | 
            +
                    post: () => `</${tagName$14}>`
         | 
| 45690 45691 | 
             
                };
         | 
| 45691 45692 | 
             
            });
         | 
| 45692 45693 | 
             
            var barcodeScanner_build = () => { };
         | 
| @@ -45696,15 +45697,15 @@ var barcodeScanner_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45696 45697 | 
             
                'default': barcodeScanner_build
         | 
| 45697 45698 | 
             
            });
         | 
| 45698 45699 |  | 
| 45699 | 
            -
            const tagName$ | 
| 45700 | 
            -
            const idGen$ | 
| 45700 | 
            +
            const tagName$13 = 'button';
         | 
| 45701 | 
            +
            const idGen$f = new IDGenerator('wm_camera');
         | 
| 45701 45702 | 
             
            register('wm-camera', () => {
         | 
| 45702 45703 | 
             
                return {
         | 
| 45703 45704 | 
             
                    pre: (attrs) => {
         | 
| 45704 | 
            -
                        const counter = idGen$ | 
| 45705 | 
            -
                        return `<${tagName$ | 
| 45705 | 
            +
                        const counter = idGen$f.nextUid();
         | 
| 45706 | 
            +
                        return `<${tagName$13} type='button' wmCamera #${counter}="wmCamera" [attr.aria-label]="${counter}.hint || 'Camera'"  ${getAttrMarkup(attrs)}>`;
         | 
| 45706 45707 | 
             
                    },
         | 
| 45707 | 
            -
                    post: () => `</${tagName$ | 
| 45708 | 
            +
                    post: () => `</${tagName$13}>`
         | 
| 45708 45709 | 
             
                };
         | 
| 45709 45710 | 
             
            });
         | 
| 45710 45711 | 
             
            var camera_build = () => { };
         | 
| @@ -45714,11 +45715,11 @@ var camera_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45714 45715 | 
             
                'default': camera_build
         | 
| 45715 45716 | 
             
            });
         | 
| 45716 45717 |  | 
| 45717 | 
            -
            const tagName$ | 
| 45718 | 
            +
            const tagName$12 = 'div';
         | 
| 45718 45719 | 
             
            register('wm-alertdialog', () => {
         | 
| 45719 45720 | 
             
                return {
         | 
| 45720 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45721 | 
            -
                    post: () => `</${tagName$ | 
| 45721 | 
            +
                    pre: attrs => `<${tagName$12} wmAlertDialog role="alertdialog" wm-navigable-element="true" ${getAttrMarkup(attrs)}>`,
         | 
| 45722 | 
            +
                    post: () => `</${tagName$12}>`
         | 
| 45722 45723 | 
             
                };
         | 
| 45723 45724 | 
             
            });
         | 
| 45724 45725 | 
             
            var alertDialog_build = () => { };
         | 
| @@ -45728,11 +45729,11 @@ var alertDialog_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45728 45729 | 
             
                'default': alertDialog_build
         | 
| 45729 45730 | 
             
            });
         | 
| 45730 45731 |  | 
| 45731 | 
            -
            const tagName | 
| 45732 | 
            +
            const tagName$11 = 'div';
         | 
| 45732 45733 | 
             
            register('wm-confirmdialog', () => {
         | 
| 45733 45734 | 
             
                return {
         | 
| 45734 | 
            -
                    pre: attrs => `<${tagName | 
| 45735 | 
            -
                    post: () => `</${tagName | 
| 45735 | 
            +
                    pre: attrs => `<${tagName$11} wmConfirmDialog wm-navigable-element="true" ${getAttrMarkup(attrs)}>`,
         | 
| 45736 | 
            +
                    post: () => `</${tagName$11}>`
         | 
| 45736 45737 | 
             
                };
         | 
| 45737 45738 | 
             
            });
         | 
| 45738 45739 | 
             
            var confirmDialog_build = () => { };
         | 
| @@ -45742,11 +45743,11 @@ var confirmDialog_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45742 45743 | 
             
                'default': confirmDialog_build
         | 
| 45743 45744 | 
             
            });
         | 
| 45744 45745 |  | 
| 45745 | 
            -
            const tagName$ | 
| 45746 | 
            +
            const tagName$10 = 'div';
         | 
| 45746 45747 | 
             
            register('wm-dialogactions', () => {
         | 
| 45747 45748 | 
             
                return {
         | 
| 45748 | 
            -
                    pre: attrs => `<ng-template #dialogFooter><${tagName$ | 
| 45749 | 
            -
                    post: () => `</${tagName$ | 
| 45749 | 
            +
                    pre: attrs => `<ng-template #dialogFooter><${tagName$10} wmDialogFooter data-identfier="actions" ${getAttrMarkup(attrs)}>`,
         | 
| 45750 | 
            +
                    post: () => `</${tagName$10}></ng-template>`
         | 
| 45750 45751 | 
             
                };
         | 
| 45751 45752 | 
             
            });
         | 
| 45752 45753 | 
             
            var dialogFooter_build = () => { };
         | 
| @@ -45756,11 +45757,11 @@ var dialogFooter_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45756 45757 | 
             
                'default': dialogFooter_build
         | 
| 45757 45758 | 
             
            });
         | 
| 45758 45759 |  | 
| 45759 | 
            -
            const tagName | 
| 45760 | 
            +
            const tagName$$ = 'div';
         | 
| 45760 45761 | 
             
            register('wm-dialog', () => {
         | 
| 45761 45762 | 
             
                return {
         | 
| 45762 | 
            -
                    pre: attrs => `<${tagName | 
| 45763 | 
            -
                    post: () => `</ng-template></${tagName | 
| 45763 | 
            +
                    pre: attrs => `<${tagName$$} wmDialog ${getAttrMarkup(attrs)} aria-modal="true" role="dialog" wm-navigable-element="true"><ng-template #dialogBody>`,
         | 
| 45764 | 
            +
                    post: () => `</ng-template></${tagName$$}>`
         | 
| 45764 45765 | 
             
                };
         | 
| 45765 45766 | 
             
            });
         | 
| 45766 45767 | 
             
            // Todo:vinay remove wm-view in migration
         | 
| @@ -45777,11 +45778,11 @@ var dialog_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45777 45778 | 
             
                'default': dialog_build
         | 
| 45778 45779 | 
             
            });
         | 
| 45779 45780 |  | 
| 45780 | 
            -
            const tagName$ | 
| 45781 | 
            +
            const tagName$_ = 'div';
         | 
| 45781 45782 | 
             
            register('wm-iframedialog', () => {
         | 
| 45782 45783 | 
             
                return {
         | 
| 45783 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45784 | 
            -
                    post: () => `</${tagName$ | 
| 45784 | 
            +
                    pre: attrs => `<${tagName$_} wmIframeDialog wm-navigable-element="true" ${getAttrMarkup(attrs)}>`,
         | 
| 45785 | 
            +
                    post: () => `</${tagName$_}>`
         | 
| 45785 45786 | 
             
                };
         | 
| 45786 45787 | 
             
            });
         | 
| 45787 45788 | 
             
            var iframeDialog_build = () => { };
         | 
| @@ -45791,11 +45792,11 @@ var iframeDialog_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45791 45792 | 
             
                'default': iframeDialog_build
         | 
| 45792 45793 | 
             
            });
         | 
| 45793 45794 |  | 
| 45794 | 
            -
            const tagName$ | 
| 45795 | 
            +
            const tagName$Z = 'div';
         | 
| 45795 45796 | 
             
            register('wm-logindialog', () => {
         | 
| 45796 45797 | 
             
                return {
         | 
| 45797 | 
            -
                    pre: attrs => `<${tagName$ | 
| 45798 | 
            -
                    post: () => `</ng-template></${tagName$ | 
| 45798 | 
            +
                    pre: attrs => `<${tagName$Z} wmDialog wmLoginDialog ${getAttrMarkup(attrs)} eventsource.bind="Actions.loginAction" wm-navigable-element="true"><ng-template #dialogBody>`,
         | 
| 45799 | 
            +
                    post: () => `</ng-template></${tagName$Z}>`
         | 
| 45799 45800 | 
             
                };
         | 
| 45800 45801 | 
             
            });
         | 
| 45801 45802 | 
             
            var loginDialog_build = () => { };
         | 
| @@ -45805,7 +45806,7 @@ var loginDialog_build$1 = /*#__PURE__*/Object.freeze({ | |
| 45805 45806 | 
             
                'default': loginDialog_build
         | 
| 45806 45807 | 
             
            });
         | 
| 45807 45808 |  | 
| 45808 | 
            -
            const tagName$ | 
| 45809 | 
            +
            const tagName$Y = 'div';
         | 
| 45809 45810 | 
             
            register('wm-pagedialog', () => {
         | 
| 45810 45811 | 
             
                return {
         | 
| 45811 45812 | 
             
                    pre: (attrs, shared) => {
         | 
| @@ -45831,14 +45832,14 @@ register('wm-pagedialog', () => { | |
| 45831 45832 | 
             
                            shared.set('hasPartialContent', true);
         | 
| 45832 45833 | 
             
                            containerMarkup += `<ng-template><div wmContainer #partial partialContainer ${contentMarkup} width="100%" height="100%" ${onLoadEvtMarkup}>`;
         | 
| 45833 45834 | 
             
                        }
         | 
| 45834 | 
            -
                        return `<${tagName$ | 
| 45835 | 
            +
                        return `<${tagName$Y} wmPartialDialog ${getAttrMarkup(attrs)}>${containerMarkup}`;
         | 
| 45835 45836 | 
             
                    },
         | 
| 45836 45837 | 
             
                    post: (attrs, shared) => {
         | 
| 45837 45838 | 
             
                        let preContent = '';
         | 
| 45838 45839 | 
             
                        if (shared.get('hasPartialContent')) {
         | 
| 45839 45840 | 
             
                            preContent = `</div></ng-template>`;
         | 
| 45840 45841 | 
             
                        }
         | 
| 45841 | 
            -
                        return `${preContent}</${tagName$ | 
| 45842 | 
            +
                        return `${preContent}</${tagName$Y}>`;
         | 
| 45842 45843 | 
             
                    }
         | 
| 45843 45844 | 
             
                };
         | 
| 45844 45845 | 
             
            });
         | 
| @@ -45917,8 +45918,8 @@ const getEditModeWidget = colDef => { | |
| 45917 45918 | 
             
                return (fieldTypeWidgetTypeMap[colDef.type] && fieldTypeWidgetTypeMap[colDef.type][0]) || FormWidgetType.TEXT;
         | 
| 45918 45919 | 
             
            };
         | 
| 45919 45920 |  | 
| 45920 | 
            -
            const tagName$ | 
| 45921 | 
            -
            const idGen$ | 
| 45921 | 
            +
            const tagName$X = 'div';
         | 
| 45922 | 
            +
            const idGen$e = new IDGenerator('formfield_');
         | 
| 45922 45923 | 
             
            const getEventsTemplate = (attrs) => {
         | 
| 45923 45924 | 
             
                const eventAttrs = new Map();
         | 
| 45924 45925 | 
             
                if (!attrs.has('focus.event')) {
         | 
| @@ -45941,7 +45942,7 @@ const getEventsTemplate = (attrs) => { | |
| 45941 45942 | 
             
                });
         | 
| 45942 45943 | 
             
                return getFormMarkupAttr(eventAttrs);
         | 
| 45943 45944 | 
             
            };
         | 
| 45944 | 
            -
            const ɵ0$ | 
| 45945 | 
            +
            const ɵ0$9$1 = getEventsTemplate;
         | 
| 45945 45946 | 
             
            const DEFAULT_PLACEHOLDERS = new Map([
         | 
| 45946 45947 | 
             
                [FormWidgetType.SELECT, ['Select Min value', 'Select Max value', 'Select value']],
         | 
| 45947 45948 | 
             
                [FormWidgetType.DATETIME, ['Select Min date time', 'Select Max date time', 'Select date time']],
         | 
| @@ -45968,7 +45969,7 @@ const setDefaultPlaceholder = (attrs, widgetType, index) => { | |
| 45968 45969 | 
             
                    attrs.set(prop, placeholder);
         | 
| 45969 45970 | 
             
                }
         | 
| 45970 45971 | 
             
            };
         | 
| 45971 | 
            -
            const ɵ1$ | 
| 45972 | 
            +
            const ɵ1$7 = setDefaultPlaceholder;
         | 
| 45972 45973 | 
             
            const getWidgetTemplate = (attrs, options) => {
         | 
| 45973 45974 | 
             
                const name = attrs.get('name');
         | 
| 45974 45975 | 
             
                const fieldName = (attrs.get('key') || name || '').trim();
         | 
| @@ -46023,7 +46024,7 @@ const registerFormField = (isFormField) => { | |
| 46023 46024 | 
             
                return {
         | 
| 46024 46025 | 
             
                    requires: ['wm-form', 'wm-liveform', 'wm-livefilter', 'wm-list'],
         | 
| 46025 46026 | 
             
                    pre: (attrs, shared, parentForm, parentLiveForm, parentFilter, parentList) => {
         | 
| 46026 | 
            -
                        const counter = idGen$ | 
| 46027 | 
            +
                        const counter = idGen$e.nextUid();
         | 
| 46027 46028 | 
             
                        const parent = parentForm || parentLiveForm || parentFilter;
         | 
| 46028 46029 | 
             
                        const pCounter = (parent && parent.get('form_reference')) || 'form';
         | 
| 46029 46030 | 
             
                        const widgetType = attrs.get('widget') || FormWidgetType.TEXT;
         | 
| @@ -46044,7 +46045,7 @@ const registerFormField = (isFormField) => { | |
| 46044 46045 | 
             
                        else {
         | 
| 46045 46046 | 
             
                            setDefaultPlaceholder(attrs, widgetType, 2);
         | 
| 46046 46047 | 
             
                        }
         | 
| 46047 | 
            -
                        return `<${tagName$ | 
| 46048 | 
            +
                        return `<${tagName$X} data-role="${dataRole}" [formGroup]="${pCounter}.ngform" wmFormField captionPosition #${counter}="wmFormField" widgettype="${widgetType}" ${getFormMarkupAttr(attrs)}>
         | 
| 46048 46049 | 
             
                                    <div class="live-field form-group app-composite-widget clearfix caption-{{${pCounter}.captionposition}}" widget="${widgetType}">
         | 
| 46049 46050 | 
             
                                        <label [hidden]="!${counter}.displayname" class="app-label control-label formfield-label {{${pCounter}._captionClass}}"
         | 
| 46050 46051 | 
             
                                                    [ngStyle]="{width: ${pCounter}.captionsize}" [ngClass]="{'text-danger': ${counter}._control?.invalid && ${counter}._control?.touched && ${pCounter}.isUpdateMode,
         | 
| @@ -46060,7 +46061,7 @@ const registerFormField = (isFormField) => { | |
| 46060 46061 | 
             
                                        </div>
         | 
| 46061 46062 | 
             
                                    </div>`;
         | 
| 46062 46063 | 
             
                    },
         | 
| 46063 | 
            -
                    post: () => `</${tagName$ | 
| 46064 | 
            +
                    post: () => `</${tagName$X}>`,
         | 
| 46064 46065 | 
             
                    provide: (attrs, shared) => {
         | 
| 46065 46066 | 
             
                        const provider = new Map();
         | 
| 46066 46067 | 
             
                        provider.set('form_reference', shared.get('counter'));
         | 
| @@ -46081,22 +46082,22 @@ var formField_build = () => { }; | |
| 46081 46082 | 
             
            var formField_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 46082 46083 | 
             
                __proto__: null,
         | 
| 46083 46084 | 
             
                'default': formField_build,
         | 
| 46084 | 
            -
                'ɵ0': ɵ0$ | 
| 46085 | 
            -
                'ɵ1': ɵ1$ | 
| 46085 | 
            +
                'ɵ0': ɵ0$9$1,
         | 
| 46086 | 
            +
                'ɵ1': ɵ1$7,
         | 
| 46086 46087 | 
             
                'ɵ2': ɵ2$3$1,
         | 
| 46087 46088 | 
             
                'ɵ3': ɵ3$2$1,
         | 
| 46088 46089 | 
             
                'ɵ4': ɵ4$1$1,
         | 
| 46089 46090 | 
             
                'ɵ5': ɵ5$1$1
         | 
| 46090 46091 | 
             
            });
         | 
| 46091 46092 |  | 
| 46092 | 
            -
            const tagName$ | 
| 46093 | 
            +
            const tagName$W = 'div';
         | 
| 46093 46094 | 
             
            const registerAction = (tmpl) => {
         | 
| 46094 46095 | 
             
                return {
         | 
| 46095 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46096 | 
            -
                    post: () => `</${tagName$ | 
| 46096 | 
            +
                    pre: attrs => `<${tagName$W} wmFormAction name="${attrs.get('name') || attrs.get('key')}" ${getAttrMarkup(attrs)} ${tmpl}>`,
         | 
| 46097 | 
            +
                    post: () => `</${tagName$W}>`
         | 
| 46097 46098 | 
             
                };
         | 
| 46098 46099 | 
             
            };
         | 
| 46099 | 
            -
            const ɵ0$ | 
| 46100 | 
            +
            const ɵ0$8$1 = registerAction;
         | 
| 46100 46101 | 
             
            register('wm-form-action', registerAction.bind(undefined, ''));
         | 
| 46101 46102 | 
             
            register('wm-filter-action', registerAction.bind(undefined, ` update-mode="true" `));
         | 
| 46102 46103 | 
             
            var formAction_build = () => { };
         | 
| @@ -46104,11 +46105,11 @@ var formAction_build = () => { }; | |
| 46104 46105 | 
             
            var formAction_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 46105 46106 | 
             
                __proto__: null,
         | 
| 46106 46107 | 
             
                'default': formAction_build,
         | 
| 46107 | 
            -
                'ɵ0': ɵ0$ | 
| 46108 | 
            +
                'ɵ0': ɵ0$8$1
         | 
| 46108 46109 | 
             
            });
         | 
| 46109 46110 |  | 
| 46110 | 
            -
            const tagName$ | 
| 46111 | 
            -
            const idGen$ | 
| 46111 | 
            +
            const tagName$V = 'form';
         | 
| 46112 | 
            +
            const idGen$d = new IDGenerator('form_');
         | 
| 46112 46113 | 
             
            const formWidgets$1 = new Set([
         | 
| 46113 46114 | 
             
                'wm-text',
         | 
| 46114 46115 | 
             
                'wm-textarea',
         | 
| @@ -46157,7 +46158,7 @@ const addFormControlName = (children = []) => { | |
| 46157 46158 | 
             
                    addFormControlName(childNode.children);
         | 
| 46158 46159 | 
             
                });
         | 
| 46159 46160 | 
             
            };
         | 
| 46160 | 
            -
            const ɵ0$ | 
| 46161 | 
            +
            const ɵ0$7$1 = addFormControlName;
         | 
| 46161 46162 | 
             
            const updateFormDataSource = (attrMap) => {
         | 
| 46162 46163 | 
             
                if (attrMap.get('formdata.bind')) {
         | 
| 46163 46164 | 
             
                    const formDataSource = getDataSource(attrMap.get('formdata.bind'));
         | 
| @@ -46166,7 +46167,7 @@ const updateFormDataSource = (attrMap) => { | |
| 46166 46167 | 
             
                    }
         | 
| 46167 46168 | 
             
                }
         | 
| 46168 46169 | 
             
            };
         | 
| 46169 | 
            -
            const ɵ1$ | 
| 46170 | 
            +
            const ɵ1$6 = updateFormDataSource;
         | 
| 46170 46171 | 
             
            const buildTask = (directiveAttr = '') => {
         | 
| 46171 46172 | 
             
                return {
         | 
| 46172 46173 | 
             
                    requires: ['wm-livetable', 'wm-login'],
         | 
| @@ -46178,12 +46179,12 @@ const buildTask = (directiveAttr = '') => { | |
| 46178 46179 | 
             
                        let tmpl;
         | 
| 46179 46180 | 
             
                        let dialogId;
         | 
| 46180 46181 | 
             
                        const role = parentLoginWidget && parentLoginWidget.get('isLogin') ? 'app-login' : '';
         | 
| 46181 | 
            -
                        const counter = idGen$ | 
| 46182 | 
            +
                        const counter = idGen$d.nextUid();
         | 
| 46182 46183 | 
             
                        const dependsOn = attrs.get('dependson') ? `dependson="${attrs.get('dependson')}"` : '';
         | 
| 46183 46184 | 
             
                        const classProp = attrs.get('formlayout') === 'page' ? 'app-device-liveform panel liveform-inline' : '';
         | 
| 46184 46185 | 
             
                        const dialogAttributes = ['title', 'title.bind', 'iconclass', 'iconclass.bind', 'width'];
         | 
| 46185 46186 | 
             
                        attrs.delete('dependson');
         | 
| 46186 | 
            -
                        const liveFormTmpl = `<${tagName$ | 
| 46187 | 
            +
                        const liveFormTmpl = `<${tagName$V} wmForm data-role="${role}" ${directiveAttr} #${counter} ngNativeValidate [formGroup]="${counter}.ngform" [noValidate]="${counter}.validationtype !== 'html'"
         | 
| 46187 46188 | 
             
                                class="${classProp}" [class]="${counter}.captionAlignClass" [autocomplete]="${counter}.autocomplete ? 'on' : 'off'" captionposition=${attrs.get('captionposition')}`;
         | 
| 46188 46189 | 
             
                        attrs.set('numberOfFields', `${numberOfFields}`);
         | 
| 46189 46190 | 
             
                        shared.set('counter', counter);
         | 
| @@ -46232,9 +46233,9 @@ const buildTask = (directiveAttr = '') => { | |
| 46232 46233 | 
             
                            return '</form></ng-template></div></div>';
         | 
| 46233 46234 | 
             
                        }
         | 
| 46234 46235 | 
             
                        if (attrs.get('formlayout') === 'page') {
         | 
| 46235 | 
            -
                            return `</div></${tagName$ | 
| 46236 | 
            +
                            return `</div></${tagName$V}>`;
         | 
| 46236 46237 | 
             
                        }
         | 
| 46237 | 
            -
                        return `</${tagName$ | 
| 46238 | 
            +
                        return `</${tagName$V}>`;
         | 
| 46238 46239 | 
             
                    },
         | 
| 46239 46240 | 
             
                    provide: (attrs, shared) => {
         | 
| 46240 46241 | 
             
                        const provider = new Map();
         | 
| @@ -46252,19 +46253,19 @@ var form_build = () => { }; | |
| 46252 46253 | 
             
            var form_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 46253 46254 | 
             
                __proto__: null,
         | 
| 46254 46255 | 
             
                'default': form_build,
         | 
| 46255 | 
            -
                'ɵ0': ɵ0$ | 
| 46256 | 
            -
                'ɵ1': ɵ1$ | 
| 46256 | 
            +
                'ɵ0': ɵ0$7$1,
         | 
| 46257 | 
            +
                'ɵ1': ɵ1$6,
         | 
| 46257 46258 | 
             
                'ɵ2': ɵ2$2$1
         | 
| 46258 46259 | 
             
            });
         | 
| 46259 46260 |  | 
| 46260 | 
            -
            const tagName$ | 
| 46261 | 
            +
            const tagName$U = 'div';
         | 
| 46261 46262 | 
             
            register('wm-calendar', () => {
         | 
| 46262 46263 | 
             
                return {
         | 
| 46263 46264 | 
             
                    pre: (attrs) => {
         | 
| 46264 46265 | 
             
                        let viewType = attrs.get('view') ? attrs.get('view') + ' view' : 'month view';
         | 
| 46265 | 
            -
                        return `<${tagName$ | 
| 46266 | 
            +
                        return `<${tagName$U} wmCalendar redrawable style="width:100%" aria-label="${viewType}" ${getAttrMarkup(attrs)}>`;
         | 
| 46266 46267 | 
             
                    },
         | 
| 46267 | 
            -
                    post: () => `</${tagName$ | 
| 46268 | 
            +
                    post: () => `</${tagName$U}>`
         | 
| 46268 46269 | 
             
                };
         | 
| 46269 46270 | 
             
            });
         | 
| 46270 46271 | 
             
            var calendar_build = () => { };
         | 
| @@ -46274,11 +46275,11 @@ var calendar_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46274 46275 | 
             
                'default': calendar_build
         | 
| 46275 46276 | 
             
            });
         | 
| 46276 46277 |  | 
| 46277 | 
            -
            const tagName$ | 
| 46278 | 
            +
            const tagName$T = 'ul';
         | 
| 46278 46279 | 
             
            register('wm-chips', () => {
         | 
| 46279 46280 | 
             
                return {
         | 
| 46280 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46281 | 
            -
                    post: () => `</${tagName$ | 
| 46281 | 
            +
                    pre: attrs => `<${tagName$T} wmChips role="listbox" ${getAttrMarkup(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46282 | 
            +
                    post: () => `</${tagName$T}>`
         | 
| 46282 46283 | 
             
                };
         | 
| 46283 46284 | 
             
            });
         | 
| 46284 46285 | 
             
            var chips_build = () => { };
         | 
| @@ -46288,11 +46289,11 @@ var chips_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46288 46289 | 
             
                'default': chips_build
         | 
| 46289 46290 | 
             
            });
         | 
| 46290 46291 |  | 
| 46291 | 
            -
            const tagName$ | 
| 46292 | 
            +
            const tagName$S = 'div';
         | 
| 46292 46293 | 
             
            register('wm-colorpicker', () => {
         | 
| 46293 46294 | 
             
                return {
         | 
| 46294 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46295 | 
            -
                    post: () => `</${tagName$ | 
| 46295 | 
            +
                    pre: attrs => `<${tagName$S} wmColorPicker ${getAttrMarkup(attrs)} role="input" ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46296 | 
            +
                    post: () => `</${tagName$S}>`
         | 
| 46296 46297 | 
             
                };
         | 
| 46297 46298 | 
             
            });
         | 
| 46298 46299 | 
             
            var colorPicker_build = () => { };
         | 
| @@ -46302,11 +46303,11 @@ var colorPicker_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46302 46303 | 
             
                'default': colorPicker_build
         | 
| 46303 46304 | 
             
            });
         | 
| 46304 46305 |  | 
| 46305 | 
            -
            const tagName$ | 
| 46306 | 
            +
            const tagName$R = 'div';
         | 
| 46306 46307 | 
             
            register('wm-currency', () => {
         | 
| 46307 46308 | 
             
                return {
         | 
| 46308 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46309 | 
            -
                    post: () => `</${tagName$ | 
| 46309 | 
            +
                    pre: attrs => `<${tagName$R} wmCurrency ${getAttrMarkup(attrs)} role="input" ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46310 | 
            +
                    post: () => `</${tagName$R}>`
         | 
| 46310 46311 | 
             
                };
         | 
| 46311 46312 | 
             
            });
         | 
| 46312 46313 | 
             
            var currency_build = () => { };
         | 
| @@ -46316,11 +46317,11 @@ var currency_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46316 46317 | 
             
                'default': currency_build
         | 
| 46317 46318 | 
             
            });
         | 
| 46318 46319 |  | 
| 46319 | 
            -
            const tagName$ | 
| 46320 | 
            +
            const tagName$Q = 'div';
         | 
| 46320 46321 | 
             
            register('wm-buttongroup', () => {
         | 
| 46321 46322 | 
             
                return {
         | 
| 46322 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46323 | 
            -
                    post: () => `</${tagName$ | 
| 46323 | 
            +
                    pre: attrs => `<${tagName$Q} wmButtonGroup role="group" aria-labelledby="button group" ${getAttrMarkup(attrs)}>`,
         | 
| 46324 | 
            +
                    post: () => `</${tagName$Q}>`
         | 
| 46324 46325 | 
             
                };
         | 
| 46325 46326 | 
             
            });
         | 
| 46326 46327 | 
             
            var buttonGroup_build = () => { };
         | 
| @@ -46330,15 +46331,15 @@ var buttonGroup_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46330 46331 | 
             
                'default': buttonGroup_build
         | 
| 46331 46332 | 
             
            });
         | 
| 46332 46333 |  | 
| 46333 | 
            -
            const tagName$ | 
| 46334 | 
            -
            const idGen$ | 
| 46334 | 
            +
            const tagName$P = 'button';
         | 
| 46335 | 
            +
            const idGen$c = new IDGenerator('wm_button');
         | 
| 46335 46336 | 
             
            register('wm-button', () => {
         | 
| 46336 46337 | 
             
                return {
         | 
| 46337 46338 | 
             
                    pre: (attrs) => {
         | 
| 46338 | 
            -
                        const counter = idGen$ | 
| 46339 | 
            -
                        return `<${tagName$ | 
| 46339 | 
            +
                        const counter = idGen$c.nextUid();
         | 
| 46340 | 
            +
                        return `<${tagName$P} wmButton #${counter}="wmButton" [attr.aria-label]="${counter}.hint || ${counter}.caption || 'Button'" ${getAttrMarkup(attrs)}>`;
         | 
| 46340 46341 | 
             
                    },
         | 
| 46341 | 
            -
                    post: () => `</${tagName$ | 
| 46342 | 
            +
                    post: () => `</${tagName$P}>`
         | 
| 46342 46343 | 
             
                };
         | 
| 46343 46344 | 
             
            });
         | 
| 46344 46345 | 
             
            var button_build = () => { };
         | 
| @@ -46348,11 +46349,11 @@ var button_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46348 46349 | 
             
                'default': button_build
         | 
| 46349 46350 | 
             
            });
         | 
| 46350 46351 |  | 
| 46351 | 
            -
            const tagName$ | 
| 46352 | 
            +
            const tagName$O = 'div';
         | 
| 46352 46353 | 
             
            register('wm-checkbox', () => {
         | 
| 46353 46354 | 
             
                return {
         | 
| 46354 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46355 | 
            -
                    post: () => `</${tagName$ | 
| 46355 | 
            +
                    pre: attrs => `<${tagName$O} wmCheckbox ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46356 | 
            +
                    post: () => `</${tagName$O}>`
         | 
| 46356 46357 | 
             
                };
         | 
| 46357 46358 | 
             
            });
         | 
| 46358 46359 | 
             
            var checkbox_build = () => { };
         | 
| @@ -46362,11 +46363,11 @@ var checkbox_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46362 46363 | 
             
                'default': checkbox_build
         | 
| 46363 46364 | 
             
            });
         | 
| 46364 46365 |  | 
| 46365 | 
            -
            const tagName$ | 
| 46366 | 
            +
            const tagName$N = 'ul';
         | 
| 46366 46367 | 
             
            register('wm-checkboxset', () => {
         | 
| 46367 46368 | 
             
                return {
         | 
| 46368 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46369 | 
            -
                    post: () => `</${tagName$ | 
| 46369 | 
            +
                    pre: attrs => `<${tagName$N} wmCheckboxset ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46370 | 
            +
                    post: () => `</${tagName$N}>`
         | 
| 46370 46371 | 
             
                };
         | 
| 46371 46372 | 
             
            });
         | 
| 46372 46373 | 
             
            var checkboxset_build = () => { };
         | 
| @@ -46376,11 +46377,11 @@ var checkboxset_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46376 46377 | 
             
                'default': checkboxset_build
         | 
| 46377 46378 | 
             
            });
         | 
| 46378 46379 |  | 
| 46379 | 
            -
            const tagName$ | 
| 46380 | 
            +
            const tagName$M = 'div';
         | 
| 46380 46381 | 
             
            register('wm-composite', () => {
         | 
| 46381 46382 | 
             
                return {
         | 
| 46382 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46383 | 
            -
                    post: () => `</${tagName$ | 
| 46383 | 
            +
                    pre: attrs => `<${tagName$M} wmComposite captionPosition ${setChildAttrs(attrs)} ${getAttrMarkup(attrs)}>`,
         | 
| 46384 | 
            +
                    post: () => `</${tagName$M}${clearChildAttrs()}>`
         | 
| 46384 46385 | 
             
                };
         | 
| 46385 46386 | 
             
            });
         | 
| 46386 46387 | 
             
            var composite_build = () => { };
         | 
| @@ -46390,11 +46391,11 @@ var composite_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46390 46391 | 
             
                'default': composite_build
         | 
| 46391 46392 | 
             
            });
         | 
| 46392 46393 |  | 
| 46393 | 
            -
            const tagName$ | 
| 46394 | 
            +
            const tagName$L = 'div';
         | 
| 46394 46395 | 
             
            register('wm-number', () => {
         | 
| 46395 46396 | 
             
                return {
         | 
| 46396 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46397 | 
            -
                    post: () => `</${tagName$ | 
| 46397 | 
            +
                    pre: attrs => `<${tagName$L} wmNumber ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46398 | 
            +
                    post: () => `</${tagName$L}>`
         | 
| 46398 46399 | 
             
                };
         | 
| 46399 46400 | 
             
            });
         | 
| 46400 46401 | 
             
            var number_build = () => { };
         | 
| @@ -46404,11 +46405,11 @@ var number_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46404 46405 | 
             
                'default': number_build
         | 
| 46405 46406 | 
             
            });
         | 
| 46406 46407 |  | 
| 46407 | 
            -
            const tagName$ | 
| 46408 | 
            +
            const tagName$K = 'ul';
         | 
| 46408 46409 | 
             
            register('wm-radioset', () => {
         | 
| 46409 46410 | 
             
                return {
         | 
| 46410 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46411 | 
            -
                    post: () => `</${tagName$ | 
| 46411 | 
            +
                    pre: attrs => `<${tagName$K} wmRadioset ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46412 | 
            +
                    post: () => `</${tagName$K}>`
         | 
| 46412 46413 | 
             
                };
         | 
| 46413 46414 | 
             
            });
         | 
| 46414 46415 | 
             
            var radioset_build = () => { };
         | 
| @@ -46418,11 +46419,11 @@ var radioset_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46418 46419 | 
             
                'default': radioset_build
         | 
| 46419 46420 | 
             
            });
         | 
| 46420 46421 |  | 
| 46421 | 
            -
            const tagName$ | 
| 46422 | 
            +
            const tagName$J = 'wm-select';
         | 
| 46422 46423 | 
             
            register('wm-select', () => {
         | 
| 46423 46424 | 
             
                return {
         | 
| 46424 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46425 | 
            -
                    post: () => `</${tagName$ | 
| 46425 | 
            +
                    pre: attrs => `<${tagName$J} ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)}  ${getNgModelAttr(attrs)}>`,
         | 
| 46426 | 
            +
                    post: () => `</${tagName$J}>`
         | 
| 46426 46427 | 
             
                };
         | 
| 46427 46428 | 
             
            });
         | 
| 46428 46429 | 
             
            var select_build = () => { };
         | 
| @@ -46432,15 +46433,15 @@ var select_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46432 46433 | 
             
                'default': select_build
         | 
| 46433 46434 | 
             
            });
         | 
| 46434 46435 |  | 
| 46435 | 
            -
            const tagName$ | 
| 46436 | 
            -
            const idGen$ | 
| 46436 | 
            +
            const tagName$I = 'div';
         | 
| 46437 | 
            +
            const idGen$b = new IDGenerator('wm_switch');
         | 
| 46437 46438 | 
             
            register('wm-switch', () => {
         | 
| 46438 46439 | 
             
                return {
         | 
| 46439 46440 | 
             
                    pre: (attrs) => {
         | 
| 46440 | 
            -
                        const counter = idGen$ | 
| 46441 | 
            -
                        return `<${tagName$ | 
| 46441 | 
            +
                        const counter = idGen$b.nextUid();
         | 
| 46442 | 
            +
                        return `<${tagName$I} wmSwitch #${counter}="wmSwitch" [attr.aria-label]="${counter}.hint || 'Switch button'" ${getFormMarkupAttr(attrs)} ${getNgModelAttr(attrs)}>`;
         | 
| 46442 46443 | 
             
                    },
         | 
| 46443 | 
            -
                    post: () => `</${tagName$ | 
| 46444 | 
            +
                    post: () => `</${tagName$I}>`
         | 
| 46444 46445 | 
             
                };
         | 
| 46445 46446 | 
             
            });
         | 
| 46446 46447 | 
             
            var switch_build = () => { };
         | 
| @@ -46450,11 +46451,11 @@ var switch_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46450 46451 | 
             
                'default': switch_build
         | 
| 46451 46452 | 
             
            });
         | 
| 46452 46453 |  | 
| 46453 | 
            -
            const tagName$ | 
| 46454 | 
            +
            const tagName$H = 'wm-input';
         | 
| 46454 46455 | 
             
            register('wm-text', () => {
         | 
| 46455 46456 | 
             
                return {
         | 
| 46456 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46457 | 
            -
                    post: () => `</${tagName$ | 
| 46457 | 
            +
                    pre: attrs => `<${tagName$H} ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46458 | 
            +
                    post: () => `</${tagName$H}>`
         | 
| 46458 46459 | 
             
                };
         | 
| 46459 46460 | 
             
            });
         | 
| 46460 46461 | 
             
            var text_build = () => { };
         | 
| @@ -46464,11 +46465,11 @@ var text_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46464 46465 | 
             
                'default': text_build
         | 
| 46465 46466 | 
             
            });
         | 
| 46466 46467 |  | 
| 46467 | 
            -
            const tagName$ | 
| 46468 | 
            +
            const tagName$G = 'wm-textarea';
         | 
| 46468 46469 | 
             
            register('wm-textarea', () => {
         | 
| 46469 46470 | 
             
                return {
         | 
| 46470 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46471 | 
            -
                    post: () => `</${tagName$ | 
| 46471 | 
            +
                    pre: attrs => `<${tagName$G} ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46472 | 
            +
                    post: () => `</${tagName$G}>`
         | 
| 46472 46473 | 
             
                };
         | 
| 46473 46474 | 
             
            });
         | 
| 46474 46475 | 
             
            var textarea_build = () => { };
         | 
| @@ -46478,11 +46479,11 @@ var textarea_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46478 46479 | 
             
                'default': textarea_build
         | 
| 46479 46480 | 
             
            });
         | 
| 46480 46481 |  | 
| 46481 | 
            -
            const tagName$ | 
| 46482 | 
            +
            const tagName$F = 'div';
         | 
| 46482 46483 | 
             
            register('wm-datetime', () => {
         | 
| 46483 46484 | 
             
                return {
         | 
| 46484 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46485 | 
            -
                    post: () => `</${tagName$ | 
| 46485 | 
            +
                    pre: attrs => `<${tagName$F} wmDateTime ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46486 | 
            +
                    post: () => `</${tagName$F}>`
         | 
| 46486 46487 | 
             
                };
         | 
| 46487 46488 | 
             
            });
         | 
| 46488 46489 | 
             
            var dateTime_build = () => { };
         | 
| @@ -46492,11 +46493,11 @@ var dateTime_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46492 46493 | 
             
                'default': dateTime_build
         | 
| 46493 46494 | 
             
            });
         | 
| 46494 46495 |  | 
| 46495 | 
            -
            const tagName$ | 
| 46496 | 
            +
            const tagName$E = 'div';
         | 
| 46496 46497 | 
             
            register('wm-date', () => {
         | 
| 46497 46498 | 
             
                return {
         | 
| 46498 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46499 | 
            -
                    post: () => `</${tagName$ | 
| 46499 | 
            +
                    pre: attrs => `<${tagName$E} wmDate ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46500 | 
            +
                    post: () => `</${tagName$E}>`
         | 
| 46500 46501 | 
             
                };
         | 
| 46501 46502 | 
             
            });
         | 
| 46502 46503 | 
             
            var date_build = () => { };
         | 
| @@ -46506,11 +46507,11 @@ var date_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46506 46507 | 
             
                'default': date_build
         | 
| 46507 46508 | 
             
            });
         | 
| 46508 46509 |  | 
| 46509 | 
            -
            const tagName$ | 
| 46510 | 
            +
            const tagName$D = 'div';
         | 
| 46510 46511 | 
             
            register('wm-time', () => {
         | 
| 46511 46512 | 
             
                return {
         | 
| 46512 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46513 | 
            -
                    post: () => `</${tagName$ | 
| 46513 | 
            +
                    pre: attrs => `<${tagName$D} wmTime ${getFormMarkupAttr(attrs)} ${getChildAttrs(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46514 | 
            +
                    post: () => `</${tagName$D}>`
         | 
| 46514 46515 | 
             
                };
         | 
| 46515 46516 | 
             
            });
         | 
| 46516 46517 | 
             
            var time_build = () => { };
         | 
| @@ -46520,7 +46521,7 @@ var time_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46520 46521 | 
             
                'default': time_build
         | 
| 46521 46522 | 
             
            });
         | 
| 46522 46523 |  | 
| 46523 | 
            -
            const tagName$ | 
| 46524 | 
            +
            const tagName$C = 'div';
         | 
| 46524 46525 | 
             
            register('wm-fileupload', () => {
         | 
| 46525 46526 | 
             
                return {
         | 
| 46526 46527 | 
             
                    pre: attrs => {
         | 
| @@ -46528,9 +46529,9 @@ register('wm-fileupload', () => { | |
| 46528 46529 | 
             
                            const onSelectBinding = getDataSource(attrs.get('select.event'));
         | 
| 46529 46530 | 
             
                            attrs.set('datasource.bind', onSelectBinding);
         | 
| 46530 46531 | 
             
                        }
         | 
| 46531 | 
            -
                        return `<${tagName$ | 
| 46532 | 
            +
                        return `<${tagName$C} wmFileUpload ${getAttrMarkup(attrs)} role="input">`;
         | 
| 46532 46533 | 
             
                    },
         | 
| 46533 | 
            -
                    post: () => `</${tagName$ | 
| 46534 | 
            +
                    post: () => `</${tagName$C}>`
         | 
| 46534 46535 | 
             
                };
         | 
| 46535 46536 | 
             
            });
         | 
| 46536 46537 | 
             
            var fileUpload_build = () => { };
         | 
| @@ -46540,11 +46541,11 @@ var fileUpload_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46540 46541 | 
             
                'default': fileUpload_build
         | 
| 46541 46542 | 
             
            });
         | 
| 46542 46543 |  | 
| 46543 | 
            -
            const tagName$ | 
| 46544 | 
            +
            const tagName$B = 'div';
         | 
| 46544 46545 | 
             
            register('wm-rating', () => {
         | 
| 46545 46546 | 
             
                return {
         | 
| 46546 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46547 | 
            -
                    post: () => `</${tagName$ | 
| 46547 | 
            +
                    pre: attrs => `<${tagName$B} wmRating ${getFormMarkupAttr(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46548 | 
            +
                    post: () => `</${tagName$B}>`
         | 
| 46548 46549 | 
             
                };
         | 
| 46549 46550 | 
             
            });
         | 
| 46550 46551 | 
             
            var rating_build = () => { };
         | 
| @@ -46554,11 +46555,11 @@ var rating_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46554 46555 | 
             
                'default': rating_build
         | 
| 46555 46556 | 
             
            });
         | 
| 46556 46557 |  | 
| 46557 | 
            -
            const tagName$ | 
| 46558 | 
            +
            const tagName$A = 'div';
         | 
| 46558 46559 | 
             
            register('wm-slider', () => {
         | 
| 46559 46560 | 
             
                return {
         | 
| 46560 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46561 | 
            -
                    post: () => `</${tagName$ | 
| 46561 | 
            +
                    pre: attrs => `<${tagName$A} wmSlider ${getAttrMarkup(attrs)} ${getNgModelAttr(attrs)}>`,
         | 
| 46562 | 
            +
                    post: () => `</${tagName$A}>`
         | 
| 46562 46563 | 
             
                };
         | 
| 46563 46564 | 
             
            });
         | 
| 46564 46565 | 
             
            var slider_build = () => { };
         | 
| @@ -46569,7 +46570,7 @@ var slider_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46569 46570 | 
             
            });
         | 
| 46570 46571 |  | 
| 46571 46572 | 
             
            const wmlistTag = 'wm-list';
         | 
| 46572 | 
            -
            const tagName$ | 
| 46573 | 
            +
            const tagName$z = 'div';
         | 
| 46573 46574 | 
             
            const dataSetKey$2 = 'dataset';
         | 
| 46574 46575 | 
             
            function copyAttribute$1(from, fromAttrName, to, toAttrName) {
         | 
| 46575 46576 | 
             
                const fromAttr = from.attrs.find(a => a.name === fromAttrName);
         | 
| @@ -46617,8 +46618,8 @@ register('wm-media-list', () => { | |
| 46617 46618 | 
             
                            copyAttribute$1(template, 'height', node, 'thumbnailheight');
         | 
| 46618 46619 | 
             
                        }
         | 
| 46619 46620 | 
             
                    },
         | 
| 46620 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46621 | 
            -
                    post: () => `</${tagName$ | 
| 46621 | 
            +
                    pre: attrs => `<${tagName$z} wmMediaList ${getAttrMarkup(attrs)}>`,
         | 
| 46622 | 
            +
                    post: () => `</${tagName$z}>`
         | 
| 46622 46623 | 
             
                };
         | 
| 46623 46624 | 
             
            });
         | 
| 46624 46625 | 
             
            var mediaList_build = () => { };
         | 
| @@ -46628,11 +46629,11 @@ var mediaList_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46628 46629 | 
             
                'default': mediaList_build
         | 
| 46629 46630 | 
             
            });
         | 
| 46630 46631 |  | 
| 46631 | 
            -
            const tagName$ | 
| 46632 | 
            +
            const tagName$y = 'ng-template';
         | 
| 46632 46633 | 
             
            register('wm-media-template', () => {
         | 
| 46633 46634 | 
             
                return {
         | 
| 46634 | 
            -
                    pre: () => `<${tagName$ | 
| 46635 | 
            -
                    post: () => `</${tagName$ | 
| 46635 | 
            +
                    pre: () => `<${tagName$y} #mediaListTemplate let-item="item" let-index="index">`,
         | 
| 46636 | 
            +
                    post: () => `</${tagName$y}>`
         | 
| 46636 46637 | 
             
                };
         | 
| 46637 46638 | 
             
            });
         | 
| 46638 46639 | 
             
            var mediaListItem_build = () => { };
         | 
| @@ -46716,16 +46717,16 @@ var list_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46716 46717 | 
             
                'default': list_build
         | 
| 46717 46718 | 
             
            });
         | 
| 46718 46719 |  | 
| 46719 | 
            -
            const tagName$ | 
| 46720 | 
            -
            const idGen$ | 
| 46720 | 
            +
            const tagName$x = 'div';
         | 
| 46721 | 
            +
            const idGen$a = new IDGenerator('liveform_dialog_id_');
         | 
| 46721 46722 | 
             
            register('wm-livetable', () => {
         | 
| 46722 46723 | 
             
                return {
         | 
| 46723 46724 | 
             
                    pre: (attrs, shared) => {
         | 
| 46724 | 
            -
                        const counter = idGen$ | 
| 46725 | 
            +
                        const counter = idGen$a.nextUid();
         | 
| 46725 46726 | 
             
                        shared.set('counter', counter);
         | 
| 46726 | 
            -
                        return `<${tagName$ | 
| 46727 | 
            +
                        return `<${tagName$x} wmLiveTable role="table" ${getAttrMarkup(attrs)} dialogid="${counter}">`;
         | 
| 46727 46728 | 
             
                    },
         | 
| 46728 | 
            -
                    post: () => `</${tagName$ | 
| 46729 | 
            +
                    post: () => `</${tagName$x}>`,
         | 
| 46729 46730 | 
             
                    provide: (attrs, shared) => {
         | 
| 46730 46731 | 
             
                        const provider = new Map();
         | 
| 46731 46732 | 
             
                        provider.set('liveform_dialog_id', shared.get('counter'));
         | 
| @@ -46740,15 +46741,15 @@ var liveTable_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46740 46741 | 
             
                'default': liveTable_build
         | 
| 46741 46742 | 
             
            });
         | 
| 46742 46743 |  | 
| 46743 | 
            -
            const tagName$ | 
| 46744 | 
            -
            const idGen$ | 
| 46744 | 
            +
            const tagName$w = 'p';
         | 
| 46745 | 
            +
            const idGen$9 = new IDGenerator('wm_message');
         | 
| 46745 46746 | 
             
            register('wm-message', () => {
         | 
| 46746 46747 | 
             
                return {
         | 
| 46747 46748 | 
             
                    pre: (attrs) => {
         | 
| 46748 | 
            -
                        const counter = idGen$ | 
| 46749 | 
            -
                        return `<${tagName$ | 
| 46749 | 
            +
                        const counter = idGen$9.nextUid();
         | 
| 46750 | 
            +
                        return `<${tagName$w} wmMessage tabindex="0" #${counter}="wmMessage" ${getAttrMarkup(attrs)}>`;
         | 
| 46750 46751 | 
             
                    },
         | 
| 46751 | 
            -
                    post: () => `</${tagName$ | 
| 46752 | 
            +
                    post: () => `</${tagName$w}>`
         | 
| 46752 46753 | 
             
                };
         | 
| 46753 46754 | 
             
            });
         | 
| 46754 46755 | 
             
            var message_build = () => { };
         | 
| @@ -46758,11 +46759,11 @@ var message_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46758 46759 | 
             
                'default': message_build
         | 
| 46759 46760 | 
             
            });
         | 
| 46760 46761 |  | 
| 46761 | 
            -
            const tagName$ | 
| 46762 | 
            +
            const tagName$v = 'ol';
         | 
| 46762 46763 | 
             
            register('wm-breadcrumb', () => {
         | 
| 46763 46764 | 
             
                return {
         | 
| 46764 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46765 | 
            -
                    post: () => `</${tagName$ | 
| 46765 | 
            +
                    pre: attrs => `<${tagName$v} wmBreadcrumb ${getAttrMarkup(attrs)}>`,
         | 
| 46766 | 
            +
                    post: () => `</${tagName$v}>`
         | 
| 46766 46767 | 
             
                };
         | 
| 46767 46768 | 
             
            });
         | 
| 46768 46769 | 
             
            var breadcrumb_build = () => { };
         | 
| @@ -46772,11 +46773,11 @@ var breadcrumb_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46772 46773 | 
             
                'default': breadcrumb_build
         | 
| 46773 46774 | 
             
            });
         | 
| 46774 46775 |  | 
| 46775 | 
            -
            const tagName$ | 
| 46776 | 
            +
            const tagName$u = 'div';
         | 
| 46776 46777 | 
             
            register('wm-menu', () => {
         | 
| 46777 46778 | 
             
                return {
         | 
| 46778 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46779 | 
            -
                    post: () => `</${tagName$ | 
| 46779 | 
            +
                    pre: attrs => `<${tagName$u} wmMenu dropdown ${getAttrMarkup(attrs)}>`,
         | 
| 46780 | 
            +
                    post: () => `</${tagName$u}>`
         | 
| 46780 46781 | 
             
                };
         | 
| 46781 46782 | 
             
            });
         | 
| 46782 46783 | 
             
            var menu_build = () => { };
         | 
| @@ -46786,11 +46787,11 @@ var menu_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46786 46787 | 
             
                'default': menu_build
         | 
| 46787 46788 | 
             
            });
         | 
| 46788 46789 |  | 
| 46789 | 
            -
            const tagName$ | 
| 46790 | 
            +
            const tagName$t = 'li';
         | 
| 46790 46791 | 
             
            register('wm-nav-item', () => {
         | 
| 46791 46792 | 
             
                return {
         | 
| 46792 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46793 | 
            -
                    post: () => `</${tagName$ | 
| 46793 | 
            +
                    pre: attrs => `<${tagName$t} wmNavItem role="listitem" ${getAttrMarkup(attrs)}>`,
         | 
| 46794 | 
            +
                    post: () => `</${tagName$t}>`
         | 
| 46794 46795 | 
             
                };
         | 
| 46795 46796 | 
             
            });
         | 
| 46796 46797 | 
             
            var navItem_build = () => { };
         | 
| @@ -46800,11 +46801,11 @@ var navItem_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46800 46801 | 
             
                'default': navItem_build
         | 
| 46801 46802 | 
             
            });
         | 
| 46802 46803 |  | 
| 46803 | 
            -
            const tagName$ | 
| 46804 | 
            +
            const tagName$s = 'ul';
         | 
| 46804 46805 | 
             
            register('wm-nav', () => {
         | 
| 46805 46806 | 
             
                return {
         | 
| 46806 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46807 | 
            -
                    post: () => `</${tagName$ | 
| 46807 | 
            +
                    pre: attrs => `<${tagName$s} wmNav data-element-type="wmNav" data-role="page-header" role="list" ${getAttrMarkup(attrs)}>`,
         | 
| 46808 | 
            +
                    post: () => `</${tagName$s}>`
         | 
| 46808 46809 | 
             
                };
         | 
| 46809 46810 | 
             
            });
         | 
| 46810 46811 | 
             
            var nav_build = () => { };
         | 
| @@ -46814,11 +46815,11 @@ var nav_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46814 46815 | 
             
                'default': nav_build
         | 
| 46815 46816 | 
             
            });
         | 
| 46816 46817 |  | 
| 46817 | 
            -
            const tagName$ | 
| 46818 | 
            +
            const tagName$r = 'nav';
         | 
| 46818 46819 | 
             
            register('wm-navbar', () => {
         | 
| 46819 46820 | 
             
                return {
         | 
| 46820 | 
            -
                    pre: attrs => `<${tagName$ | 
| 46821 | 
            -
                    post: () => `</${tagName$ | 
| 46821 | 
            +
                    pre: attrs => `<${tagName$r} wmNavbar data-element-type="wmNavbar" role="navigation" ${getAttrMarkup(attrs)}>`,
         | 
| 46822 | 
            +
                    post: () => `</${tagName$r}>`
         | 
| 46822 46823 | 
             
                };
         | 
| 46823 46824 | 
             
            });
         | 
| 46824 46825 | 
             
            var navbar_build = () => { };
         | 
| @@ -46828,7 +46829,7 @@ var navbar_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46828 46829 | 
             
                'default': navbar_build
         | 
| 46829 46830 | 
             
            });
         | 
| 46830 46831 |  | 
| 46831 | 
            -
            const tagName$ | 
| 46832 | 
            +
            const tagName$q = 'wm-popover';
         | 
| 46832 46833 | 
             
            register('wm-popover', () => {
         | 
| 46833 46834 | 
             
                return {
         | 
| 46834 46835 | 
             
                    requires: ['wm-table'],
         | 
| @@ -46848,7 +46849,7 @@ register('wm-popover', () => { | |
| 46848 46849 | 
             
                            popoverTemplate = `<div wmContainer #partial partialContainer ${contentMarkup}>`;
         | 
| 46849 46850 | 
             
                            shared.set('hasPopoverContent', true);
         | 
| 46850 46851 | 
             
                        }
         | 
| 46851 | 
            -
                        let markup = `<${tagName$ | 
| 46852 | 
            +
                        let markup = `<${tagName$q} wmPopover ${getAttrMarkup(attrs)}>`;
         | 
| 46852 46853 | 
             
                        const contextAttrs = table ? `let-row="row"` : ``;
         | 
| 46853 46854 | 
             
                        markup += `<ng-template ${contextAttrs}><button class="popover-start"></button>`;
         | 
| 46854 46855 | 
             
                        // todo keyboard navigation - tab
         | 
| @@ -46862,7 +46863,7 @@ register('wm-popover', () => { | |
| 46862 46863 | 
             
                        if (shared.get('hasPopoverContent')) {
         | 
| 46863 46864 | 
             
                            markup += `</div>`;
         | 
| 46864 46865 | 
             
                        }
         | 
| 46865 | 
            -
                        return `${markup}<button class="popover-end"></button></ng-template></${tagName$ | 
| 46866 | 
            +
                        return `${markup}<button class="popover-end"></button></ng-template></${tagName$q}>`;
         | 
| 46866 46867 | 
             
                    }
         | 
| 46867 46868 | 
             
                };
         | 
| 46868 46869 | 
             
            });
         | 
| @@ -46873,21 +46874,21 @@ var popover_build$1 = /*#__PURE__*/Object.freeze({ | |
| 46873 46874 | 
             
                'default': popover_build
         | 
| 46874 46875 | 
             
            });
         | 
| 46875 46876 |  | 
| 46876 | 
            -
            const tagName$ | 
| 46877 | 
            +
            const tagName$p = 'div';
         | 
| 46877 46878 | 
             
            const findChild = (node, childName) => {
         | 
| 46878 46879 | 
             
                const child = node && node.children.find(e => (e instanceof Element$1$1 && e.name === childName));
         | 
| 46879 46880 | 
             
                return child;
         | 
| 46880 46881 | 
             
            };
         | 
| 46881 | 
            -
            const ɵ0$ | 
| 46882 | 
            -
            const createElement$ | 
| 46883 | 
            -
                return new Element$1$1(name, [], [], noSpan$ | 
| 46882 | 
            +
            const ɵ0$6$1 = findChild;
         | 
| 46883 | 
            +
            const createElement$3 = name => {
         | 
| 46884 | 
            +
                return new Element$1$1(name, [], [], noSpan$3, noSpan$3, noSpan$3);
         | 
| 46884 46885 | 
             
            };
         | 
| 46885 | 
            -
            const ɵ1$ | 
| 46886 | 
            -
            const addAtrribute$ | 
| 46887 | 
            -
                const attr = new Attribute(name, value, noSpan$ | 
| 46886 | 
            +
            const ɵ1$5$1 = createElement$3;
         | 
| 46887 | 
            +
            const addAtrribute$3 = (node, name, value) => {
         | 
| 46888 | 
            +
                const attr = new Attribute(name, value, noSpan$3, noSpan$3, noSpan$3, undefined, undefined);
         | 
| 46888 46889 | 
             
                node.attrs.push(attr);
         | 
| 46889 46890 | 
             
            };
         | 
| 46890 | 
            -
            const ɵ2$1$2 = addAtrribute$ | 
| 46891 | 
            +
            const ɵ2$1$2 = addAtrribute$3;
         | 
| 46891 46892 | 
             
            const getElementNode = (name, node) => {
         | 
| 46892 46893 | 
             
                let elementNode;
         | 
| 46893 46894 | 
             
                if (!node) {
         | 
| @@ -46907,8 +46908,8 @@ const getElementNode = (name, node) => { | |
| 46907 46908 | 
             
                return elementNode;
         | 
| 46908 46909 | 
             
            };
         | 
| 46909 46910 | 
             
            const ɵ3$1$2 = getElementNode;
         | 
| 46910 | 
            -
            const noSpan$ | 
| 46911 | 
            -
            const idGen$ | 
| 46911 | 
            +
            const noSpan$3 = {};
         | 
| 46912 | 
            +
            const idGen$8 = new IDGenerator('wm_page');
         | 
| 46912 46913 | 
             
            register('wm-page', () => {
         | 
| 46913 46914 | 
             
                return {
         | 
| 46914 46915 | 
             
                    template: (node) => {
         | 
| @@ -46917,24 +46918,24 @@ register('wm-page', () => { | |
| 46917 46918 | 
             
                            pageContentNode = getElementNode('wm-page-content', getElementNode('wm-content', node));
         | 
| 46918 46919 | 
             
                        }
         | 
| 46919 46920 | 
             
                        if (pageContentNode) {
         | 
| 46920 | 
            -
                            const conditionalNode = createElement$ | 
| 46921 | 
            -
                            addAtrribute$ | 
| 46921 | 
            +
                            const conditionalNode = createElement$3('ng-container');
         | 
| 46922 | 
            +
                            addAtrribute$3(conditionalNode, '*ngIf', 'compilePageContent');
         | 
| 46922 46923 | 
             
                            conditionalNode.children = conditionalNode.children.concat(pageContentNode.children);
         | 
| 46923 46924 | 
             
                            conditionalNode.children.push(new Text$3('{{onPageContentReady()}}', null, undefined, undefined));
         | 
| 46924 46925 | 
             
                            pageContentNode.children = [conditionalNode];
         | 
| 46925 46926 | 
             
                            if (isMobileApp()) {
         | 
| 46926 | 
            -
                                const loader = createElement$ | 
| 46927 | 
            -
                                addAtrribute$ | 
| 46928 | 
            -
                                addAtrribute$ | 
| 46927 | 
            +
                                const loader = createElement$3('div');
         | 
| 46928 | 
            +
                                addAtrribute$3(loader, 'wmPageContentLoader', '');
         | 
| 46929 | 
            +
                                addAtrribute$3(loader, '*ngIf', '!showPageContent');
         | 
| 46929 46930 | 
             
                                pageContentNode.children.push(loader);
         | 
| 46930 46931 | 
             
                            }
         | 
| 46931 46932 | 
             
                        }
         | 
| 46932 46933 | 
             
                    },
         | 
| 46933 46934 | 
             
                    pre: (attrs) => {
         | 
| 46934 | 
            -
                        const counter = idGen$ | 
| 46935 | 
            -
                        return `<${tagName$ | 
| 46935 | 
            +
                        const counter = idGen$8.nextUid();
         | 
| 46936 | 
            +
                        return `<${tagName$p} wmPage #${counter}="wmPage" data-role="pageContainer" [attr.aria-label]="${counter}.hint || 'Main page content'" ${getAttrMarkup(attrs)}>`;
         | 
| 46936 46937 | 
             
                    },
         | 
| 46937 | 
            -
                    post: () => `</${tagName$ | 
| 46938 | 
            +
                    post: () => `</${tagName$p}>`
         | 
| 46938 46939 | 
             
                };
         | 
| 46939 46940 | 
             
            });
         | 
| 46940 46941 | 
             
            var page_build = () => { };
         | 
| @@ -46942,12 +46943,44 @@ var page_build = () => { }; | |
| 46942 46943 | 
             
            var page_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 46943 46944 | 
             
                __proto__: null,
         | 
| 46944 46945 | 
             
                'default': page_build,
         | 
| 46945 | 
            -
                'ɵ0': ɵ0$ | 
| 46946 | 
            -
                'ɵ1': ɵ1$ | 
| 46946 | 
            +
                'ɵ0': ɵ0$6$1,
         | 
| 46947 | 
            +
                'ɵ1': ɵ1$5$1,
         | 
| 46947 46948 | 
             
                'ɵ2': ɵ2$1$2,
         | 
| 46948 46949 | 
             
                'ɵ3': ɵ3$1$2
         | 
| 46949 46950 | 
             
            });
         | 
| 46950 46951 |  | 
| 46952 | 
            +
            const tagName$o = 'div';
         | 
| 46953 | 
            +
            const idGen$7 = new IDGenerator('wm_layout');
         | 
| 46954 | 
            +
            register('wm-layout', () => {
         | 
| 46955 | 
            +
                return {
         | 
| 46956 | 
            +
                    pre: (attrs) => {
         | 
| 46957 | 
            +
                        const counter = idGen$7.nextUid();
         | 
| 46958 | 
            +
                        return `<${tagName$o} wmLayout #${counter}="wmLayout" data-role="pageContainer" [attr.aria-label]="${counter}.hint || 'Main page content'" ${getAttrMarkup(attrs)}>`;
         | 
| 46959 | 
            +
                    },
         | 
| 46960 | 
            +
                    post: () => `</${tagName$o}>`
         | 
| 46961 | 
            +
                };
         | 
| 46962 | 
            +
            });
         | 
| 46963 | 
            +
            var layout_build = () => { };
         | 
| 46964 | 
            +
             | 
| 46965 | 
            +
            var layout_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 46966 | 
            +
                __proto__: null,
         | 
| 46967 | 
            +
                'default': layout_build
         | 
| 46968 | 
            +
            });
         | 
| 46969 | 
            +
             | 
| 46970 | 
            +
            const tagName$n = 'router-outlet';
         | 
| 46971 | 
            +
            register('wm-router-outlet', () => {
         | 
| 46972 | 
            +
                return {
         | 
| 46973 | 
            +
                    pre: attrs => `<div wmRouterOutlet name="wmRouterOutlet" ${getAttrMarkup(attrs)}><${tagName$n} (activate)="onActivate($event)">`,
         | 
| 46974 | 
            +
                    post: () => `</${tagName$n}></div>`
         | 
| 46975 | 
            +
                };
         | 
| 46976 | 
            +
            });
         | 
| 46977 | 
            +
            var routerOutlet_build = () => { };
         | 
| 46978 | 
            +
             | 
| 46979 | 
            +
            var routerOutlet_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 46980 | 
            +
                __proto__: null,
         | 
| 46981 | 
            +
                'default': routerOutlet_build
         | 
| 46982 | 
            +
            });
         | 
| 46983 | 
            +
             | 
| 46951 46984 | 
             
            const tagName$m = 'nav';
         | 
| 46952 46985 | 
             
            register('wm-pagination', () => {
         | 
| 46953 46986 | 
             
                return {
         | 
| @@ -47063,9 +47096,31 @@ var rightPanel_build$1 = /*#__PURE__*/Object.freeze({ | |
| 47063 47096 | 
             
            });
         | 
| 47064 47097 |  | 
| 47065 47098 | 
             
            const tagName$f = 'div';
         | 
| 47099 | 
            +
            const createElement$2 = name => {
         | 
| 47100 | 
            +
                return new Element$1$1(name, [], [], noSpan$2, noSpan$2, noSpan$2);
         | 
| 47101 | 
            +
            };
         | 
| 47102 | 
            +
            const ɵ0$5$1 = createElement$2;
         | 
| 47103 | 
            +
            const addAtrribute$2 = (node, name, value) => {
         | 
| 47104 | 
            +
                const attr = new Attribute(name, value, noSpan$2, noSpan$2, noSpan$2, undefined, undefined);
         | 
| 47105 | 
            +
                node.attrs.push(attr);
         | 
| 47106 | 
            +
            };
         | 
| 47107 | 
            +
            const ɵ1$4$1 = addAtrribute$2;
         | 
| 47108 | 
            +
            const noSpan$2 = {};
         | 
| 47066 47109 | 
             
            register('wm-page-content', () => {
         | 
| 47067 47110 | 
             
                return {
         | 
| 47068 | 
            -
                     | 
| 47111 | 
            +
                    template: (node) => {
         | 
| 47112 | 
            +
                        for (let attr of node.attrs) {
         | 
| 47113 | 
            +
                            if (attr.name === 'spa' && attr.value === 'true') {
         | 
| 47114 | 
            +
                                const conditionalNode = createElement$2('ng-container');
         | 
| 47115 | 
            +
                                addAtrribute$2(conditionalNode, '*ngIf', 'compilePageContent');
         | 
| 47116 | 
            +
                                conditionalNode.children = conditionalNode.children.concat(node.children);
         | 
| 47117 | 
            +
                                conditionalNode.children.push(new Text$3('{{onPageContentReady()}}', null, undefined, undefined));
         | 
| 47118 | 
            +
                                node.children = [conditionalNode];
         | 
| 47119 | 
            +
                                break;
         | 
| 47120 | 
            +
                            }
         | 
| 47121 | 
            +
                        }
         | 
| 47122 | 
            +
                    },
         | 
| 47123 | 
            +
                    pre: attrs => `<${tagName$f} wmPageContent ${attrs.get('spa') && 'wmSpaPage' || ''} wmSmoothscroll="${attrs.get('smoothscroll') || 'false'}" ${getAttrMarkup(attrs)}>`,
         | 
| 47069 47124 | 
             
                    post: () => `</${tagName$f}>`
         | 
| 47070 47125 | 
             
                };
         | 
| 47071 47126 | 
             
            });
         | 
| @@ -47073,7 +47128,9 @@ var pageContent_build = () => { }; | |
| 47073 47128 |  | 
| 47074 47129 | 
             
            var pageContent_build$1 = /*#__PURE__*/Object.freeze({
         | 
| 47075 47130 | 
             
                __proto__: null,
         | 
| 47076 | 
            -
                'default': pageContent_build
         | 
| 47131 | 
            +
                'default': pageContent_build,
         | 
| 47132 | 
            +
                'ɵ0': ɵ0$5$1,
         | 
| 47133 | 
            +
                'ɵ1': ɵ1$4$1
         | 
| 47077 47134 | 
             
            });
         | 
| 47078 47135 |  | 
| 47079 47136 | 
             
            const tagName$e = 'div';
         | 
| @@ -47170,10 +47227,10 @@ var prefab_build$1 = /*#__PURE__*/Object.freeze({ | |
| 47170 47227 | 
             
            });
         | 
| 47171 47228 |  | 
| 47172 47229 | 
             
            const noSpan = {};
         | 
| 47173 | 
            -
            const createElement$ | 
| 47230 | 
            +
            const createElement$4 = name => {
         | 
| 47174 47231 | 
             
                return new Element$1$1(name, [], [], noSpan, noSpan, noSpan);
         | 
| 47175 47232 | 
             
            };
         | 
| 47176 | 
            -
            const ɵ0$3$2 = createElement$ | 
| 47233 | 
            +
            const ɵ0$3$2 = createElement$4;
         | 
| 47177 47234 | 
             
            const addAtrribute = (node, name, value) => {
         | 
| 47178 47235 | 
             
                const attr = new Attribute(name, value, noSpan, noSpan, noSpan, undefined, undefined);
         | 
| 47179 47236 | 
             
                node.attrs.push(attr);
         | 
| @@ -47183,7 +47240,7 @@ const tagName$9 = 'div'; | |
| 47183 47240 | 
             
            register('wm-prefab-container', () => {
         | 
| 47184 47241 | 
             
                return {
         | 
| 47185 47242 | 
             
                    template: (node) => {
         | 
| 47186 | 
            -
                        const conditionalNode = createElement$ | 
| 47243 | 
            +
                        const conditionalNode = createElement$4('ng-container');
         | 
| 47187 47244 | 
             
                        addAtrribute(conditionalNode, '*ngIf', 'compileContent');
         | 
| 47188 47245 | 
             
                        conditionalNode.children = conditionalNode.children.concat(node.children);
         | 
| 47189 47246 | 
             
                        node.children.length = 0;
         | 
| @@ -47590,7 +47647,7 @@ const getRowActionTmpl = (attrs) => { | |
| 47590 47647 | 
             
                            ${saveCancelTmpl}
         | 
| 47591 47648 | 
             
                        </ng-template>`;
         | 
| 47592 47649 | 
             
            };
         | 
| 47593 | 
            -
            const ɵ1$ | 
| 47650 | 
            +
            const ɵ1$9 = getRowActionTmpl;
         | 
| 47594 47651 | 
             
            register('wm-table-row-action', () => {
         | 
| 47595 47652 | 
             
                return {
         | 
| 47596 47653 | 
             
                    pre: attrs => `<${tagName$4} wmTableRowAction ${getAttrMarkup(attrs)}>
         | 
| @@ -47604,7 +47661,7 @@ var tableRowAction_build$1 = /*#__PURE__*/Object.freeze({ | |
| 47604 47661 | 
             
                __proto__: null,
         | 
| 47605 47662 | 
             
                'default': tableRowAction_build,
         | 
| 47606 47663 | 
             
                'ɵ0': ɵ0$i,
         | 
| 47607 | 
            -
                'ɵ1': ɵ1$ | 
| 47664 | 
            +
                'ɵ1': ɵ1$9
         | 
| 47608 47665 | 
             
            });
         | 
| 47609 47666 |  | 
| 47610 47667 | 
             
            const tagName$3 = 'div';
         | 
| @@ -47793,6 +47850,7 @@ exports.iframeBuild = iframe_build$1; | |
| 47793 47850 | 
             
            exports.iframeDlgBuild = iframeDialog_build$1;
         | 
| 47794 47851 | 
             
            exports.initComponentsBuildTask = initComponentsBuildTask;
         | 
| 47795 47852 | 
             
            exports.labelBuild = label_build$1;
         | 
| 47853 | 
            +
            exports.layoutBuild = layout_build$1;
         | 
| 47796 47854 | 
             
            exports.leftPanelBuild = leftPanel_build$1;
         | 
| 47797 47855 | 
             
            exports.lgBuild = layoutGrid_build$1;
         | 
| 47798 47856 | 
             
            exports.lgcolBuild = layoutGridColumn_build$1;
         | 
| @@ -47830,6 +47888,7 @@ exports.radiosetBuild = radioset_build$1; | |
| 47830 47888 | 
             
            exports.ratingBuild = rating_build$1;
         | 
| 47831 47889 | 
             
            exports.repeatTemplateBuild = repeatTemplate_build$1;
         | 
| 47832 47890 | 
             
            exports.rightPanelBuild = rightPanel_build$1;
         | 
| 47891 | 
            +
            exports.routerOutletBuild = routerOutlet_build$1;
         | 
| 47833 47892 | 
             
            exports.rteBuild = richTextEditor_build$1;
         | 
| 47834 47893 | 
             
            exports.searchBuild = search_build$1;
         | 
| 47835 47894 | 
             
            exports.segContentBuild = segmentContent_build$1;
         |