@seniorsistemas/angular-components 14.9.14 → 14.10.1

package/bundles/seniorsistemas-angular-components.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('primeng/breadcrumb'), require('@angular/router'), require('rxjs'), require('rxjs/operators'), require('primeng/tieredmenu'), require('primeng/tooltip'), require('primeng/dom'), require('primeng/calendar'), require('@angular/animations'), require('@angular/forms'), require('@angular/common/http'), require('angular2-hotkeys'), require('bignumber.js'), require('primeng/autocomplete'), require('primeng/dialog'), require('primeng/table'), require('@seniorsistemas/ng2-currency-mask'), require('@seniorsistemas/senior-platform-data'), require('moment'), require('ngx-cookie-service'), require('ng2-currency-mask'), require('primeng/button'), require('primeng/checkbox'), require('primeng/chips'), require('primeng/dropdown'), require('primeng/fieldset'), require('primeng/inputmask'), require('primeng/inputtext'), require('primeng/inputtextarea'), require('primeng/keyfilter'), require('primeng/multiselect'), require('primeng/panel'), require('primeng/radiobutton'), require('@angular/platform-browser'), require('primeng/progressbar'), require('@ngx-translate/core'), require('cropperjs'), require('element-resize-detector'), require('@angular/cdk/a11y'), require('primeng/scrollpanel'), require('primeng/sidebar')) :
-    typeof define === 'function' && define.amd ? define('@seniorsistemas/angular-components', ['exports', '@angular/core', '@angular/common', 'primeng/breadcrumb', '@angular/router', 'rxjs', 'rxjs/operators', 'primeng/tieredmenu', 'primeng/tooltip', 'primeng/dom', 'primeng/calendar', '@angular/animations', '@angular/forms', '@angular/common/http', 'angular2-hotkeys', 'bignumber.js', 'primeng/autocomplete', 'primeng/dialog', 'primeng/table', '@seniorsistemas/ng2-currency-mask', '@seniorsistemas/senior-platform-data', 'moment', 'ngx-cookie-service', 'ng2-currency-mask', 'primeng/button', 'primeng/checkbox', 'primeng/chips', 'primeng/dropdown', 'primeng/fieldset', 'primeng/inputmask', 'primeng/inputtext', 'primeng/inputtextarea', 'primeng/keyfilter', 'primeng/multiselect', 'primeng/panel', 'primeng/radiobutton', '@angular/platform-browser', 'primeng/progressbar', '@ngx-translate/core', 'cropperjs', 'element-resize-detector', '@angular/cdk/a11y', 'primeng/scrollpanel', 'primeng/sidebar'], factory) :
-    (global = global || self, factory((global.seniorsistemas = global.seniorsistemas || {}, global.seniorsistemas['angular-components'] = {}), global.ng.core, global.ng.common, global.breadcrumb, global.ng.router, global.rxjs, global.rxjs.operators, global.tieredmenu, global.tooltip, global.dom, global.calendar, global.ng.animations, global.ng.forms, global.ng.common.http, global.angular2Hotkeys, global.BigNumber, global.autocomplete, global.dialog, global.table, global.ng2CurrencyMask, global.seniorPlatformData, global.moment_, global.ngxCookieService, global.ng2CurrencyMask$1, global.button, global.checkbox, global.chips, global.dropdown, global.fieldset, global.inputmask, global.inputtext, global.inputtextarea, global.keyfilter, global.multiselect, global.panel, global.radiobutton, global.ng.platformBrowser, global.progressbar, global.core$1, global.Cropper, global.elementResizeDetectorMaker_, global.ng.cdk.a11y, global.scrollpanel, global.sidebar));
-}(this, (function (exports, core, common, breadcrumb, router, rxjs, operators, tieredmenu, tooltip, dom, calendar, animations, forms, http, angular2Hotkeys, BigNumber, autocomplete, dialog, table, ng2CurrencyMask, seniorPlatformData, moment_, ngxCookieService, ng2CurrencyMask$1, button, checkbox, chips, dropdown, fieldset, inputmask, inputtext, inputtextarea, keyfilter, multiselect, panel, radiobutton, platformBrowser, progressbar, core$1, Cropper, elementResizeDetectorMaker_, a11y, scrollpanel, sidebar) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('primeng/breadcrumb'), require('@angular/router'), require('rxjs'), require('rxjs/operators'), require('primeng/tieredmenu'), require('primeng/tooltip'), require('primeng/dom'), require('primeng/calendar'), require('@angular/animations'), require('@angular/forms'), require('@angular/common/http'), require('angular2-hotkeys'), require('bignumber.js'), require('primeng/autocomplete'), require('primeng/dialog'), require('primeng/table'), require('@seniorsistemas/ng2-currency-mask'), require('@seniorsistemas/senior-platform-data'), require('moment'), require('ngx-cookie-service'), require('ng2-currency-mask'), require('primeng/button'), require('primeng/checkbox'), require('primeng/chips'), require('primeng/dropdown'), require('primeng/fieldset'), require('primeng/inputmask'), require('primeng/inputtext'), require('primeng/inputtextarea'), require('primeng/keyfilter'), require('primeng/multiselect'), require('primeng/panel'), require('primeng/radiobutton'), require('@angular/platform-browser'), require('primeng/progressbar'), require('@ngx-translate/core'), require('cropperjs'), require('element-resize-detector'), require('@angular/cdk/a11y'), require('primeng/scrollpanel'), require('primeng/sidebar'), require('@codemirror/view'), require('@codemirror/state'), require('@codemirror/lint'), require('@codemirror/language'), require('@lezer/generator'), require('@codemirror/highlight'), require('@codemirror/autocomplete'), require('@codemirror/tooltip'), require('@codemirror/gutter')) :
+    typeof define === 'function' && define.amd ? define('@seniorsistemas/angular-components', ['exports', '@angular/core', '@angular/common', 'primeng/breadcrumb', '@angular/router', 'rxjs', 'rxjs/operators', 'primeng/tieredmenu', 'primeng/tooltip', 'primeng/dom', 'primeng/calendar', '@angular/animations', '@angular/forms', '@angular/common/http', 'angular2-hotkeys', 'bignumber.js', 'primeng/autocomplete', 'primeng/dialog', 'primeng/table', '@seniorsistemas/ng2-currency-mask', '@seniorsistemas/senior-platform-data', 'moment', 'ngx-cookie-service', 'ng2-currency-mask', 'primeng/button', 'primeng/checkbox', 'primeng/chips', 'primeng/dropdown', 'primeng/fieldset', 'primeng/inputmask', 'primeng/inputtext', 'primeng/inputtextarea', 'primeng/keyfilter', 'primeng/multiselect', 'primeng/panel', 'primeng/radiobutton', '@angular/platform-browser', 'primeng/progressbar', '@ngx-translate/core', 'cropperjs', 'element-resize-detector', '@angular/cdk/a11y', 'primeng/scrollpanel', 'primeng/sidebar', '@codemirror/view', '@codemirror/state', '@codemirror/lint', '@codemirror/language', '@lezer/generator', '@codemirror/highlight', '@codemirror/autocomplete', '@codemirror/tooltip', '@codemirror/gutter'], factory) :
+    (global = global || self, factory((global.seniorsistemas = global.seniorsistemas || {}, global.seniorsistemas['angular-components'] = {}), global.ng.core, global.ng.common, global.breadcrumb, global.ng.router, global.rxjs, global.rxjs.operators, global.tieredmenu, global.tooltip, global.dom, global.calendar, global.ng.animations, global.ng.forms, global.ng.common.http, global.angular2Hotkeys, global.BigNumber, global.autocomplete$1, global.dialog, global.table, global.ng2CurrencyMask, global.seniorPlatformData, global.moment_, global.ngxCookieService, global.ng2CurrencyMask$1, global.button, global.checkbox, global.chips, global.dropdown, global.fieldset, global.inputmask, global.inputtext, global.inputtextarea, global.keyfilter, global.multiselect, global.panel, global.radiobutton, global.ng.platformBrowser, global.progressbar, global.core$1, global.Cropper, global.elementResizeDetectorMaker_, global.ng.cdk.a11y, global.scrollpanel, global.sidebar, global.view, global.state, global.lint, global.language, global.generator, global.highlight, global.autocomplete$2, global.tooltip$1, global.gutter));
+}(this, (function (exports, core, common, breadcrumb, router, rxjs, operators, tieredmenu, tooltip, dom, calendar, animations, forms, http, angular2Hotkeys, BigNumber, autocomplete$1, dialog, table, ng2CurrencyMask, seniorPlatformData, moment_, ngxCookieService, ng2CurrencyMask$1, button, checkbox, chips, dropdown, fieldset, inputmask, inputtext, inputtextarea, keyfilter, multiselect, panel, radiobutton, platformBrowser, progressbar, core$1, Cropper, elementResizeDetectorMaker_, a11y, scrollpanel, sidebar, view, state, lint, language, generator, highlight, autocomplete$2, tooltip$1, gutter) { 'use strict';
 
     var BigNumber__default = 'default' in BigNumber ? BigNumber['default'] : BigNumber;
     Cropper = Cropper && Object.prototype.hasOwnProperty.call(Cropper, 'default') ? Cropper['default'] : Cropper;
@@ -2505,7 +2505,7 @@
             core.ViewChild(dialog.Dialog, { static: false })
         ], LookupComponent.prototype, "dialog", void 0);
         __decorate([
-            core.ViewChild(autocomplete.AutoComplete, { static: false })
+            core.ViewChild(autocomplete$1.AutoComplete, { static: false })
         ], LookupComponent.prototype, "autocomplete", void 0);
         LookupComponent = LookupComponent_1 = __decorate([
             core.Component({
@@ -3877,6 +3877,29 @@
         EnumBadgeColors["BLUE"] = "sds-semantic-blue";
     })(exports.EnumBadgeColors || (exports.EnumBadgeColors = {}));
 
+    var HostProjectConfigsInjectionToken = new core.InjectionToken("hostProjectConfigs");
+    var AngularComponentsModule = /** @class */ (function () {
+        function AngularComponentsModule() {
+        }
+        AngularComponentsModule_1 = AngularComponentsModule;
+        AngularComponentsModule.forRoot = function (config) {
+            return {
+                ngModule: AngularComponentsModule_1,
+                providers: [
+                    {
+                        provide: HostProjectConfigsInjectionToken,
+                        useValue: config
+                    }
+                ]
+            };
+        };
+        var AngularComponentsModule_1;
+        AngularComponentsModule = AngularComponentsModule_1 = __decorate([
+            core.NgModule({})
+        ], AngularComponentsModule);
+        return AngularComponentsModule;
+    }());
+
     var TableColumnsComponent = /** @class */ (function () {
         function TableColumnsComponent(viewContainerRef, translate, hostProjectConfigs) {
             this.viewContainerRef = viewContainerRef;
@@ -4068,7 +4091,7 @@
         TableColumnsComponent.ctorParameters = function () { return [
             { type: core.ViewContainerRef },
             { type: core$1.TranslateService },
-            { type: undefined, decorators: [{ type: core.Inject, args: ["hostProjectConfigs",] }] }
+            { type: undefined, decorators: [{ type: core.Inject, args: [HostProjectConfigsInjectionToken,] }] }
         ]; };
         __decorate([
             core.ViewChild("columnsTemplate", { static: true })
@@ -4088,7 +4111,7 @@
                 selector: "s-table-columns",
                 styles: [":host{display:none}"]
             }),
-            __param(2, core.Inject("hostProjectConfigs"))
+            __param(2, core.Inject(HostProjectConfigsInjectionToken))
         ], TableColumnsComponent);
         return TableColumnsComponent;
     }());
@@ -4948,7 +4971,7 @@
                     LocalizedNumberInputModule,
                     ControlErrorsModule,
                     LocaleModule,
-                    autocomplete.AutoCompleteModule,
+                    autocomplete$1.AutoCompleteModule,
                     multiselect.MultiSelectModule,
                     button.ButtonModule,
                     ButtonModule,
@@ -7227,26 +7250,1489 @@
         return GlobalSearchModule;
     }());
 
-    var AngularComponentsModule = /** @class */ (function () {
-        function AngularComponentsModule() {
+
+    (function (Languages) {
+        Languages["TaxCalculation"] = "TaxCalculation";
+    })(exports.Languages || (exports.Languages = {}));
+
+
+    (function (Themes) {
+        Themes["SDSLight"] = "SDSLight";
+    })(exports.Themes || (exports.Themes = {}));
+
+    /* Enums */
+
+    var CoreLinters = /** @class */ (function () {
+        function CoreLinters() {
         }
-        AngularComponentsModule_1 = AngularComponentsModule;
-        AngularComponentsModule.forRoot = function (config) {
-            return {
-                ngModule: AngularComponentsModule_1,
+        CoreLinters.getLinter = function (language) {
+            var languageLinterFactory = CoreLinters._LINTERS.get(language);
+            if (languageLinterFactory)
+                return languageLinterFactory();
+        };
+        CoreLinters._LINTERS = new Map([]);
+        return CoreLinters;
+    }());
+
+    var CoreFacade = /** @class */ (function () {
+        function CoreFacade() {
+            this.$onCoreFinishLoad = new rxjs.ReplaySubject(1);
+            this.$onCodeChange = new rxjs.Subject();
+            this.$onCodeValidityChange = new rxjs.Subject();
+            this._completionItems = [];
+            this._lastCodeEmitted = "";
+        }
+        CoreFacade.prototype.changeEditorOptions = function (options) {
+            if (options) {
+                if (typeof options !== "object")
+                    throw new Error("Editor's options must be an EditorOptions object");
+                this.validateLanguage(options.language);
+                this.validateTheme(options.theme);
+                this.setLinter(options.language);
+                this.setCoreEditorOptions(options);
+            }
+        };
+        CoreFacade.prototype.changeCode = function (code) {
+            var safeCode = this.getSafeCode(code);
+            if (safeCode !== this._lastCodeEmitted) {
+                this.setCode(safeCode);
+            }
+        };
+        CoreFacade.prototype.getOnCoreFinishLoadObservable = function () {
+            return this.$onCoreFinishLoad.asObservable();
+        };
+        CoreFacade.prototype.getOnCodeChangeObservable = function () {
+            return this.$onCodeChange.asObservable();
+        };
+        CoreFacade.prototype.getOnCodeValidityChangeObservable = function () {
+            return this.$onCodeValidityChange.asObservable();
+        };
+        CoreFacade.prototype.notifyCoreFinishLoad = function () {
+            this.$onCoreFinishLoad.next();
+        };
+        CoreFacade.prototype.notifyCodeChange = function (code) {
+            var safeCode = this.getSafeCode(code);
+            if (safeCode !== this._lastCodeEmitted) {
+                this._lastCodeEmitted = safeCode;
+                this.$onCodeChange.next(safeCode);
+                this.validateCode(safeCode);
+            }
+        };
+        CoreFacade.prototype.updateCompletionItems = function (items) {
+            this._completionItems = items || [];
+            this.validateCode(this._lastCodeEmitted);
+        };
+        CoreFacade.prototype.setLinter = function (language) {
+            this._linter = CoreLinters.getLinter(language);
+        };
+        CoreFacade.prototype.validateCode = function (code) {
+            return __awaiter(this, void 0, void 0, function () {
+                var markers;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!this._linter) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this._linter.lint(code, this._completionItems)];
+                        case 1:
+                            markers = _a.sent();
+                            this.highlightCode(markers);
+                            this.notifyCodeValidityChange(!markers.length);
+                            _a.label = 2;
+                        case 2: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        CoreFacade.prototype.notifyCodeValidityChange = function (validity) {
+            if (validity !== this._lastCodeValidityEmitted) {
+                this._lastCodeValidityEmitted = validity;
+                this.$onCodeValidityChange.next(validity);
+            }
+        };
+        CoreFacade.prototype.validateLanguage = function (language) {
+            var languages = Object.values(exports.Languages);
+            if (language && !languages.includes(language))
+                throw new Error("The informed language \"" + language + "\" is not supported");
+        };
+        CoreFacade.prototype.validateTheme = function (theme) {
+            var themes = Object.values(exports.Themes);
+            if (theme && !themes.includes(theme))
+                throw new Error("The informed theme \"" + theme + "\" is not supported");
+        };
+        CoreFacade.prototype.getSafeCode = function (code) {
+            return typeof code === "string" ? code : "";
+        };
+        return CoreFacade;
+    }());
+
+    var CodeEditorComponent = /** @class */ (function () {
+        function CodeEditorComponent(coreFacade) {
+            this.coreFacade = coreFacade;
+            this._ngUnsubscribe = new rxjs.Subject();
+            this.codeChange = new core.EventEmitter();
+            this.isCodeValidChange = new core.EventEmitter();
+            this.onCodeChange = new core.EventEmitter();
+            this.onComponentFinishLoad = new core.EventEmitter();
+        }
+        Object.defineProperty(CodeEditorComponent.prototype, "editorOptions", {
+            set: function (options) {
+                this.coreFacade.changeEditorOptions(options);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(CodeEditorComponent.prototype, "code", {
+            set: function (code) {
+                this.coreFacade.changeCode(code);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        CodeEditorComponent.prototype.ngOnInit = function () {
+            this.coreFacade.initCore();
+            this.setupCoreListeners();
+        };
+        CodeEditorComponent.prototype.ngAfterViewInit = function () {
+            this.setCoreWrapperElement();
+        };
+        CodeEditorComponent.prototype.ngOnDestroy = function () {
+            this.coreFacade.destroyCore();
+            this._ngUnsubscribe.next();
+            this._ngUnsubscribe.complete();
+        };
+        CodeEditorComponent.prototype.setCoreWrapperElement = function () {
+            this.coreFacade.setCoreWrapperElement(this.coreWrapperElement.nativeElement);
+        };
+        CodeEditorComponent.prototype.setupCoreListeners = function () {
+            var _this = this;
+            this.coreFacade
+                .getOnCoreFinishLoadObservable()
+                .pipe(operators.take(1))
+                .subscribe(function () { return _this.onComponentFinishLoad.emit(); });
+            this.coreFacade
+                .getOnCodeChangeObservable()
+                .pipe(operators.takeUntil(this._ngUnsubscribe))
+                .subscribe(function (code) {
+                _this.codeChange.emit(code);
+                _this.onCodeChange.emit(code);
+            });
+            this.coreFacade
+                .getOnCodeValidityChangeObservable()
+                .pipe(operators.takeUntil(this._ngUnsubscribe))
+                .subscribe(function (validity) {
+                _this.isCodeValidChange.emit(validity);
+            });
+        };
+        CodeEditorComponent.ctorParameters = function () { return [
+            { type: CoreFacade }
+        ]; };
+        __decorate([
+            core.ViewChild("coreWrapper")
+        ], CodeEditorComponent.prototype, "coreWrapperElement", void 0);
+        __decorate([
+            core.Input()
+        ], CodeEditorComponent.prototype, "editorOptions", null);
+        __decorate([
+            core.Input()
+        ], CodeEditorComponent.prototype, "code", null);
+        __decorate([
+            core.Output()
+        ], CodeEditorComponent.prototype, "codeChange", void 0);
+        __decorate([
+            core.Input()
+        ], CodeEditorComponent.prototype, "isCodeValid", void 0);
+        __decorate([
+            core.Output()
+        ], CodeEditorComponent.prototype, "isCodeValidChange", void 0);
+        __decorate([
+            core.Output()
+        ], CodeEditorComponent.prototype, "onCodeChange", void 0);
+        __decorate([
+            core.Output()
+        ], CodeEditorComponent.prototype, "onComponentFinishLoad", void 0);
+        CodeEditorComponent = __decorate([
+            core.Component({
+                selector: "s-code-editor",
+                template: "<div #coreWrapper class=\"core-wrapper\"></div>",
+                styles: [".core-wrapper{height:100%}"]
+            })
+        ], CodeEditorComponent);
+        return CodeEditorComponent;
+    }());
+
+    var parserGrammar = "\n@top Script { statement+ }\n\nstatement[@isGroup=Statement] {\n    Keyword |\n    String |\n    Number\n}\n\n@tokens {\n    String { '\"' (![\\n\"])* '\"'? }\n\n    Number { std.digit+ }\n\n    identifierChar { std.asciiLetter | $[_$\u00A1-\uDBFF\uDFFF] }\n\n    word { identifierChar (identifierChar | std.digit)* }\n\n    identifier { word }\n}\n\nKeyword {\n    kw<\"SE\">\n    kw<\"ENTAO\">\n    kw<\"FIM_SE\">\n    kw<\"SENAO\">\n    kw<\"NAO\">\n    kw<\"CONTENHA\">\n    kw<\"OU\">\n    kw<\"E\">\n}\n\nkw<term> { @specialize[@name={term}]<identifier, term> }\n\n@detectDelim\n";
+
+    var EnumTypeOrder;
+    (function (EnumTypeOrder) {
+        // Tipo de ordenação - Crescente
+        EnumTypeOrder["ASC"] = "ASC";
+        // Tipo de ordenação - Decrescente
+        EnumTypeOrder["DESC"] = "DESC";
+    })(EnumTypeOrder || (EnumTypeOrder = {}));
+
+    var MetaType;
+    (function (MetaType) {
+        // Entity
+        MetaType["ENTITY"] = "ENTITY";
+        // String
+        MetaType["STRING"] = "STRING";
+        // Integer
+        MetaType["INTEGER"] = "INTEGER";
+        // Double
+        MetaType["DOUBLE"] = "DOUBLE";
+        // Long
+        MetaType["LONG"] = "LONG";
+        // BigDecimal
+        MetaType["BIGDECIMAL"] = "BIGDECIMAL";
+        // UUID
+        MetaType["UUID"] = "UUID";
+        // Date
+        MetaType["DATE"] = "DATE";
+        // DateTime
+        MetaType["DATETIME"] = "DATETIME";
+        // Time
+        MetaType["TIME"] = "TIME";
+        // Boolean
+        MetaType["BOOLEAN"] = "BOOLEAN";
+        // List
+        MetaType["LIST"] = "LIST";
+        // Enum
+        MetaType["ENUM"] = "ENUM";
+        // CustomExpression
+        MetaType["CUSTOM_EXPRESSION"] = "CUSTOM_EXPRESSION";
+        // PublicExpression
+        MetaType["PUBLIC_EXPRESSION"] = "PUBLIC_EXPRESSION";
+    })(MetaType || (MetaType = {}));
+
+    var RequestTypes;
+    (function (RequestTypes) {
+        RequestTypes[RequestTypes["ListContextMetadataById"] = 0] = "ListContextMetadataById";
+        RequestTypes[RequestTypes["ListExpressionMetadata"] = 1] = "ListExpressionMetadata";
+        RequestTypes[RequestTypes["ListFacadeMetadataNames"] = 2] = "ListFacadeMetadataNames";
+        RequestTypes[RequestTypes["GetFacadeMetadataByPath"] = 3] = "GetFacadeMetadataByPath";
+    })(RequestTypes || (RequestTypes = {}));
+
+    var CompletionTypes;
+    (function (CompletionTypes) {
+        CompletionTypes["Keyword"] = "keyword";
+        CompletionTypes["Context"] = "context";
+        CompletionTypes["Expression"] = "expression";
+        CompletionTypes["UserExpression"] = "userExpression";
+        CompletionTypes["Entity"] = "entity";
+        CompletionTypes["FinalValue"] = "finalValue";
+    })(CompletionTypes || (CompletionTypes = {}));
+
+    var Keywords;
+    (function (Keywords) {
+        Keywords["SE"] = "SE";
+        Keywords["SENAO"] = "SENAO";
+        Keywords["CONTENHA"] = "CONTENHA";
+        Keywords["ENTAO"] = "ENTAO";
+        Keywords["FIM_SE"] = "FIM_SE";
+        Keywords["NAO"] = "NAO";
+        Keywords["E"] = "E";
+        Keywords["OU"] = "OU";
+    })(Keywords || (Keywords = {}));
+
+    /* Enums */
+
+    var _a;
+    var baseConfigs = language.LRLanguage.define({
+        parser: generator.buildParser(parserGrammar)
+            .configure({
+            props: [
+                highlight.styleTags((_a = {},
+                    _a[Object.values(Keywords).join(" ")] = highlight.tags.keyword,
+                    _a["String"] = highlight.tags.string,
+                    _a["Number"] = highlight.tags.number,
+                    _a))
+            ]
+        })
+    });
+
+    /**
+     * Formats a JSON response to a JS object
+     * @param response The response to format
+     * @returns A JS object based on the response's body
+     */
+    function formatJsonResponse(response) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, response.json()];
+            });
+        });
+    }
+
+    /**
+     * Formats a Blob response to a JS object
+     * @param response The response to format
+     * @returns A JS object based on the response's body
+     */
+    function formatBlobResponse(response) {
+        return __awaiter(this, void 0, void 0, function () {
+            var textResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, response.blob()];
+                    case 1: return [4 /*yield*/, (_a.sent()).text()];
+                    case 2:
+                        textResponse = _a.sent();
+                        return [2 /*return*/, JSON.parse(textResponse)];
+                }
+            });
+        });
+    }
+
+    /**
+     * Custom HttpClient for cases when is not possible to use the Angular's HttpClient
+     */
+    var CustomHttpClient = /** @class */ (function () {
+        function CustomHttpClient() {
+        }
+        /**
+         * Executes a Http Get
+         * @param url Url to execute the Get on
+         * @param init Optional additional configs
+         * @returns Whether a Promise<T> on request success or an error in request fail
+         */
+        CustomHttpClient.GET = function (url, init) {
+            if (init === void 0) { init = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.interceptRequest(url, __assign(__assign({}, init), { method: "GET" }))];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, this.formatResponse(response)];
+                    }
+                });
+            });
+        };
+        /**
+         * Executes a Http Post
+         * @param url Url to execute the Post on
+         * @param body Info to send to server on Post
+         * @param init Optional additional configs
+         * @returns Whether a Promise<T> on request success or an error in request fail
+         */
+        CustomHttpClient.POST = function (url, body, init) {
+            if (init === void 0) { init = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var headers, response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            headers = new Headers(init.headers);
+                            headers.append("Content-Type", "application/json");
+                            headers.append("Accept", "application/json");
+                            return [4 /*yield*/, this.interceptRequest(url, __assign(__assign({}, init), { method: "POST", body: JSON.stringify(body), headers: headers }))];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, this.formatResponse(response)];
+                    }
+                });
+            });
+        };
+        /**
+         * Intercepts the original request to add a required header for Senior in case of a internal request
+         * @param url Url from the original request
+         * @param originalReq Configs from the original request
+         * @returns Whether a Promise<Response> if the request was made successfully or an error
+         */
+        CustomHttpClient.interceptRequest = function (url, originalReq) {
+            if (originalReq === void 0) { originalReq = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var restUrl, authHeader, headers, request, err_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 4, , 5]);
+                            if (!!url.includes("://")) return [3 /*break*/, 3];
+                            return [4 /*yield*/, seniorPlatformData.service.getRestUrl()];
+                        case 1:
+                            restUrl = _a.sent();
+                            return [4 /*yield*/, seniorPlatformData.user.getAuthHeader()];
+                        case 2:
+                            authHeader = _a.sent();
+                            headers = new Headers(originalReq.headers);
+                            headers.append("Authorization", authHeader);
+                            request = new Request(restUrl + url, __assign(__assign({}, originalReq), { headers: headers }));
+                            return [2 /*return*/, fetch(request)];
+                        case 3: return [2 /*return*/, fetch(url, originalReq)];
+                        case 4:
+                            err_1 = _a.sent();
+                            throw new Error("Error fetching requested URL: " + err_1);
+                        case 5: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * Formats the request response to an object<T> or {}
+         * @param response The response to be formatted
+         * @returns Whether a Promise<T> if the response status is in the range 200-299 an error
+         */
+        CustomHttpClient.formatResponse = function (response) {
+            return __awaiter(this, void 0, void 0, function () {
+                var contentType, formatter, formattedContentType, _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            contentType = response.headers.get("content-type");
+                            formatter = CustomHttpClient._responseFormatterMap.get(contentType);
+                            if (!formatter) return [3 /*break*/, 2];
+                            return [4 /*yield*/, formatter(response)];
+                        case 1:
+                            _a = _b.sent();
+                            return [3 /*break*/, 3];
+                        case 2:
+                            _a = {};
+                            _b.label = 3;
+                        case 3:
+                            formattedContentType = _a;
+                            if (response.ok)
+                                return [2 /*return*/, formattedContentType];
+                            throw new Error(JSON.stringify(formattedContentType));
+                    }
+                });
+            });
+        };
+        CustomHttpClient._responseFormatterMap = new Map([
+            ["application/json", formatJsonResponse],
+            ["application/octet-stream", formatBlobResponse]
+        ]);
+        return CustomHttpClient;
+    }());
+
+    /**
+     * Custom translator for cases when is not possible to use the "TranslateService" from "@ngx-translate/core"
+     */
+    var CustomTranslationsService = /** @class */ (function () {
+        function CustomTranslationsService() {
+        }
+        /**
+         * Method used to get the translation for an key based on the host project's translations. Always use the first available language
+         * @param key Key used to search the translation
+         * @returns The translation for the informed key or the key in case there is no translation
+         */
+        CustomTranslationsService.translate = function (key) {
+            var _a, _b;
+            if (key === undefined || key === null)
+                return "";
+            var translationKey = "" + CustomTranslationsService._TRANSLATION_PREFIX + key;
+            var firstLanguageTranslations = (_a = Object.values(CustomTranslationsService._translations)[0]) !== null && _a !== void 0 ? _a : {};
+            return (_b = firstLanguageTranslations[translationKey]) !== null && _b !== void 0 ? _b : translationKey;
+        };
+        /**
+         * Method used to set the translations that will be used as base when calling the "translate" method
+         * @param translations Translations to use as base
+         */
+        CustomTranslationsService.setTranslations = function (translations) {
+            CustomTranslationsService._translations = translations !== null && translations !== void 0 ? translations : {};
+        };
+        /**
+         * Method used to set the prefix that will be used when calling the "translate" method
+         * @param hostProjectConfigs The host project's configs used to create the prefix
+         */
+        CustomTranslationsService.setTranslationsPrefix = function (hostProjectConfigs) {
+            var _a = hostProjectConfigs !== null && hostProjectConfigs !== void 0 ? hostProjectConfigs : {}, domain = _a.domain, service = _a.service;
+            var prefix = domain + "." + service + ".";
+            CustomTranslationsService._TRANSLATION_PREFIX = prefix;
+        };
+        CustomTranslationsService._translations = {};
+        CustomTranslationsService._TRANSLATION_PREFIX = "";
+        return CustomTranslationsService;
+    }());
+
+    /**
+     * Responsible for setting up the translations that will be used by the "CustomTranslationsService".
+     * Uses the host project's translations set by using the "TranslationsModule" from "@seniorsistemas/platform-components"
+     */
+    var CustomTranslationsModule = /** @class */ (function () {
+        function CustomTranslationsModule(translate, hostProjectConfigs) {
+            this.translate = translate;
+            this.hostProjectConfigs = hostProjectConfigs;
+            this.factoryTranslations(this.translate, this.hostProjectConfigs);
+        }
+        CustomTranslationsModule.prototype.factoryTranslations = function (translate, hostProjectConfigs) {
+            CustomTranslationsService.setTranslations(translate.translations);
+            CustomTranslationsService.setTranslationsPrefix(hostProjectConfigs);
+        };
+        CustomTranslationsModule.ctorParameters = function () { return [
+            { type: core$1.TranslateService },
+            { type: undefined, decorators: [{ type: core.Inject, args: [HostProjectConfigsInjectionToken,] }] }
+        ]; };
+        CustomTranslationsModule = __decorate([
+            core.NgModule(),
+            __param(1, core.Inject(HostProjectConfigsInjectionToken))
+        ], CustomTranslationsModule);
+        return CustomTranslationsModule;
+    }());
+
+    var MarkerSeverity;
+    (function (MarkerSeverity) {
+        MarkerSeverity[MarkerSeverity["Error"] = 0] = "Error";
+        MarkerSeverity[MarkerSeverity["Info"] = 1] = "Info";
+        MarkerSeverity[MarkerSeverity["Warning"] = 2] = "Warning";
+    })(MarkerSeverity || (MarkerSeverity = {}));
+
+    /* Enums */
+
+    var diagnosticSeverityInMarkerSeverityMap = new Map([
+        [MarkerSeverity.Error, "error"],
+        [MarkerSeverity.Info, "info"],
+        [MarkerSeverity.Warning, "warning"]
+    ]);
+    function convertMarkersToDiagnostics(markers, textLength) {
+        return markers.map(function (marker) {
+            var _a, _b;
+            return ({
+                from: marker.start || 0,
+                to: marker.end || textLength,
+                message: (_a = marker.message) !== null && _a !== void 0 ? _a : "",
+                severity: (_b = diagnosticSeverityInMarkerSeverityMap.get(marker.severity)) !== null && _b !== void 0 ? _b : "error"
+            });
+        });
+    }
+
+    function isCurrentPositionInsideString(stringBeforeCurrentPosition) {
+        var _a;
+        var doubleQuotesQuantity = ((_a = stringBeforeCurrentPosition.match(/"/g)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        return doubleQuotesQuantity % 2 !== 0;
+    }
+
+    var AutocompleteService = /** @class */ (function () {
+        function AutocompleteService() {
+        }
+        AutocompleteService.listContextMetadataById = function (request, abortSignal) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, CustomHttpClient.POST(AutocompleteService.BASE_URL + "/queries/listContextMetadataById", request, {
+                            signal: abortSignal
+                        })];
+                });
+            });
+        };
+        AutocompleteService.listExpressionMetadata = function (request, abortSignal) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, CustomHttpClient.POST(AutocompleteService.BASE_URL + "/queries/listExpressionMetadata", request, {
+                            signal: abortSignal
+                        })];
+                });
+            });
+        };
+        AutocompleteService.listFacadeMetadataNames = function (request, abortSignal) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, CustomHttpClient.POST(AutocompleteService.BASE_URL + "/queries/listFacadeMetadataNames", request, {
+                            signal: abortSignal
+                        })];
+                });
+            });
+        };
+        AutocompleteService.getFacadeMetadataByPath = function (request, abortSignal) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, CustomHttpClient.POST(AutocompleteService.BASE_URL + "/queries/getFacadeMetadataByPath", request, {
+                            signal: abortSignal
+                        })];
+                });
+            });
+        };
+        AutocompleteService.BASE_URL = "platform/rule_metadata";
+        return AutocompleteService;
+    }());
+
+    /**
+     * Adds style to autocomplete's state-wrapper
+     * @returns An extension containing the style
+     */
+    function style() {
+        return view.EditorView.theme({
+            ".s-code-editor-taxCalculation-autocomplete-ul": {
+                "padding": ".75rem !important",
+            },
+            ".s-code-editor-taxCalculation-autocomplete-li": {
+                cursor: "default !important",
+                "line-height": "1.375em !important",
+            },
+        });
+    }
+
+    var htmlElementToBeWrapped = null;
+    /**
+     * Adds a view updates's listener that creates an state over the autocomplete
+     * @returns An extension containing everything needed to listen the updates and create the autocomplete's state
+     */
+    function autocompleteStateWrapper() {
+        return [
+            autocompleteStateWrapperStateField(),
+            style()
+        ];
+    }
+    /**
+     * Shows a state on a non-clickable autocomplete item's format with an HTMLElement inside
+     * @param element The HTMLElement to show inside the state
+     */
+    function showAutocompleteStateWrapper(element) {
+        htmlElementToBeWrapped = element;
+        CodeMirror6Core.updateEditorView();
+    }
+    /**
+     * Removes a possible showed autocomplete state
+     */
+    function hideAutocompleteStateWrapper() {
+        htmlElementToBeWrapped = null;
+        CodeMirror6Core.updateEditorView();
+    }
+    /*
+     * Creates and returns a StateField responsible for listening the view's change and to add the autocomplete state's wrapper
+     */
+    function autocompleteStateWrapperStateField() {
+        return state.StateField.define({
+            create: getAutocompleteStateWrapper,
+            update: function (_, transaction) {
+                return getAutocompleteStateWrapper(transaction.state);
+            },
+            provide: function (field) {
+                return tooltip$1.showTooltip.compute([field], function (state) { return state.field(field); });
+            }
+        });
+    }
+    /*
+     * Function responsible for creating the state's wrapper and returning the same as a Tooltip from "@codemirror/tooltip";
+     * Only creates the Tooltip if the theres is element on the "htmlElementToBeWrapped" variable;
+     * The same will also be removed when any view update is emitted;
+     */
+    function getAutocompleteStateWrapper(state) {
+        if (!htmlElementToBeWrapped)
+            return;
+        var htmlElementToBeWrappedString = htmlElementToBeWrapped.outerHTML;
+        var stateWrapper = {
+            pos: state.selection.ranges[0].head,
+            create: function () { return ({ dom: getAutocompleteStateWrapperDomElement(htmlElementToBeWrappedString) }); }
+        };
+        htmlElementToBeWrapped = null;
+        return stateWrapper;
+    }
+    function getAutocompleteStateWrapperDomElement(elementToBeWrappedString) {
+        var wrapperDiv = document.createElement("div");
+        wrapperDiv.className = "cm-tooltip-autocomplete cm-tooltip";
+        wrapperDiv.innerHTML =
+            "\n        <ul class=\"s-code-editor-taxCalculation-autocomplete-ul\">\n            <li class=\"s-code-editor-taxCalculation-autocomplete-li\">\n                " + elementToBeWrappedString + "\n            </li>\n        </ul>\n\n    ";
+        return wrapperDiv;
+    }
+
+    var autocompleteLoadingStateHTMLElement;
+    /**
+     * Adds a loading-state over the autocomplete
+     * @returns An extension containing everything needed to add the loading-state
+     */
+    function autocompleteLoadingState() {
+        return [autocompleteStateWrapper()];
+    }
+    /**
+     * Activates the loading state on the autocomplete
+     */
+    /*
+     * Must set the "autocompleteLoadingStateHTMLElement" here for when the document is loaded we do not have
+     * yet the "CustomTranslationsService" ready
+     */
+    function showAutocompleteLoadingState() {
+        if (!autocompleteLoadingStateHTMLElement) {
+            autocompleteLoadingStateHTMLElement = getAutocompleteLoadingStateHTMLElement();
+        }
+        showAutocompleteStateWrapper(autocompleteLoadingStateHTMLElement);
+    }
+    function getAutocompleteLoadingStateHTMLElement() {
+        var loadingStateSpanWrapper = document.createElement("span");
+        loadingStateSpanWrapper.innerText = CustomTranslationsService.translate("core_language_tax_calculation_fetching_suggestions");
+        return loadingStateSpanWrapper;
+    }
+
+    var autocompleteEmptyStateHTMLElement;
+    /**
+     * Adds an empty-state over the autocomplete
+     * @returns An extension containing everything needed to add the empty-state
+     */
+    function autocompleteEmptyState() {
+        return [autocompleteStateWrapper()];
+    }
+    /**
+     * Activates the empty-state on the autocomplete
+     */
+    /*
+     * Must set the "autocompleteEmptyStateHTMLElement" here for when the document is loaded we do not have
+     * yet the "CustomTranslationsService" ready
+     */
+    function showAutocompleteEmptyState() {
+        if (!autocompleteEmptyStateHTMLElement) {
+            autocompleteEmptyStateHTMLElement = getAutocompleteEmptyStateHTMLElement();
+        }
+        showAutocompleteStateWrapper(autocompleteEmptyStateHTMLElement);
+    }
+    function getAutocompleteEmptyStateHTMLElement() {
+        var emptyStateSpanWrapper = document.createElement("span");
+        emptyStateSpanWrapper.innerText = CustomTranslationsService.translate("core_language_tax_calculation_no_suggestions");
+        return emptyStateSpanWrapper;
+    }
+
+    var TaxCalculationLanguageConfigs = /** @class */ (function () {
+        function TaxCalculationLanguageConfigs() {
+        }
+        TaxCalculationLanguageConfigs.setConfigs = function (configs) {
+            TaxCalculationLanguageConfigs.CONFIGS = JSON.parse(JSON.stringify(configs));
+        };
+        TaxCalculationLanguageConfigs.getConfigs = function () {
+            return TaxCalculationLanguageConfigs.CONFIGS;
+        };
+        TaxCalculationLanguageConfigs.CONFIGS = { contexts: [] };
+        return TaxCalculationLanguageConfigs;
+    }());
+
+    /**
+     * Gets the configs for the TaxCalculationLanguage
+     * @returns The configs
+     */
+    function getLanguageConfigs() {
+        var _a;
+        var configs = TaxCalculationLanguageConfigs.getConfigs();
+        if (!((_a = configs.contexts) === null || _a === void 0 ? void 0 : _a.length))
+            throw new Error("In order to use the TaxCalculation Language's autocomplete, "
+                + "one must inform at least one context by using the "
+                + "'TaxCalculationLanguageConfigs.setConfigs()'");
+        return configs;
+    }
+
+    /**
+     * Wraps the request to return the same with an identification or undefined in case of error, so the promise will
+     * always trigger the "then"
+     * @param request Request to wrap
+     * @returns The typed request's response
+     */
+    function getSafeResponse(request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 2, , 3]);
+                        _a = [__assign({}, request)];
+                        _b = {};
+                        return [4 /*yield*/, request.request];
+                    case 1: return [2 /*return*/, __assign.apply(void 0, _a.concat([(_b.response = _c.sent(), _b)]))];
+                    case 2:
+                        _1 = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    }
+
+    /**
+     * Adds style to the autocomplete
+     * @returns An extension containing the style
+     */
+    function style$1() {
+        return view.EditorView.theme({
+            ".cm-completionIcon": {
+                "font-family": "'Font Awesome 5 Pro'",
+                "font-weight": "900",
+            },
+            ".cm-completionIcon-keyword::after": {
+                "content": getIconBasedOnUnicode("f084"),
+            },
+            ".cm-completionIcon-context::after": {
+                "content": getIconBasedOnUnicode("f466"),
+            },
+            ".cm-completionIcon-expression::after": {
+                "content": getIconBasedOnUnicode("f505"),
+            },
+            ".cm-completionIcon-userExpression::after": {
+                "content": getIconBasedOnUnicode("f4ff"),
+            },
+            ".cm-completionIcon-entity::after": {
+                "content": getIconBasedOnUnicode("f126"),
+            },
+            ".cm-completionIcon-finalValue::after": {
+                "content": getIconBasedOnUnicode("f192"),
+            },
+        });
+    }
+    function getIconBasedOnUnicode(unicode) {
+        return "\"\\" + unicode + "\"";
+    }
+
+    /**
+     * Adds an autocomplete to the editor
+     * @returns An extension containing everything needed to create the autocomplete
+     */
+    function autocomplete() {
+        return [
+            autocomplete$2.autocompletion({ override: [getCompletionResults] }),
+            autocompleteLoadingState(),
+            autocompleteEmptyState(),
+            style$1(),
+        ];
+    }
+    var TRANSLATION_PREFIX = "core_language_tax_calculation";
+    var completionResults;
+    /*
+     * A function to be called when a key is pressed, the ctrl+space is triggered or when the search for completionResults is done.
+     * If there is a completionResult, returns it, otherwise starts a new async search.
+     * Will only execute the autocompletion if the current cursor position is not inside a string
+     */
+    function getCompletionResults(context) {
+        var isCursorInsideString = isCurrentPositionInsideString(context.state.doc.toString().substring(0, context.pos));
+        if (isCursorInsideString)
+            return;
+        if (completionResults) {
+            var finalCompletionResults = __assign({}, completionResults);
+            var codeLength = context.state.doc.toString().length;
+            finalCompletionResults.from = finalCompletionResults.from > codeLength
+                ? codeLength
+                : finalCompletionResults.from;
+            completionResults = null;
+            return finalCompletionResults;
+        }
+        startCompletionResultsSearch(context);
+    }
+    var cancelLastCompletionSearch = function () { };
+    var ɵ0 = cancelLastCompletionSearch;
+    var codeMirrorViewElement;
+    /*
+     * Starts a new completionResults's async search.
+     * Avoids the last search to be finished by calling the "cancelLastCompletionSearch" callback function
+     */
+    function startCompletionResultsSearch(context) {
+        var token = new AbortController();
+        setTimeout(function () {
+            if (!token.signal.aborted) {
+                showAutocompleteLoadingState();
+                searchCompletionResults(context, token);
+            }
+        }, 500);
+        /*
+         * IMPORTANT: The following lines MUST be the way they are!
+         * Here is being add the listener to any keydown/click event so when any key is downed or mouse clicked, we cancel the last request.
+         * We do this to not show to the user a completionItem in an incorrect place of text, that can be done by either pressing the
+         * arrows, home, end, backspace and etc. The flow is:
+         * 1. We add an eventListener to keydown/click when the autocompletion's request is triggered;
+         * 2. When any key/click is pressed, we remove the listener and cancel the last request by changing the isSearchCanceled on token object
+         *  to true;
+         * 3. If any key that requires autocompletion is triggered, the flow repeats;
+         */
+        codeMirrorViewElement = CodeMirror6Core.getEditorView().contentDOM;
+        cancelLastCompletionSearch = function () {
+            codeMirrorViewElement.removeEventListener("keydown", cancelLastCompletionSearch);
+            codeMirrorViewElement.removeEventListener("click", cancelLastCompletionSearch);
+            token.abort();
+        };
+        codeMirrorViewElement.addEventListener("keydown", cancelLastCompletionSearch);
+        codeMirrorViewElement.addEventListener("click", cancelLastCompletionSearch);
+    }
+    /*
+     * Requests the necessary items to fill the completionResults, although it only really opens the autocomplete
+     * box (by calling the "startCompletion()", that calls the "getCompletionResults") if the current search was not cancelled
+     * by a new one
+     */
+    function searchCompletionResults(context, token) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var codeBeforeCursor, filter, path, requests;
+            return __generator(this, function (_e) {
+                codeBeforeCursor = (_d = (_b = (_a = context === null || context === void 0 ? void 0 : context.state) === null || _a === void 0 ? void 0 : _a.doc) === null || _b === void 0 ? void 0 : _b.toString().substring(0, (_c = context === null || context === void 0 ? void 0 : context.pos) !== null && _c !== void 0 ? _c : 0)) !== null && _d !== void 0 ? _d : "";
+                filter = getFilter(codeBeforeCursor);
+                path = getPath(codeBeforeCursor, filter.length);
+                requests = getRequestsBasedOnPath(path, filter, token.signal);
+                Promise
+                    .all(requests)
+                    .then(function (responses) {
+                    if (!token.signal.aborted) {
+                        var completions = [].concat(getKeywordsCompletions(path), getContextsCompletions(responses), getExpressionsCompletions(responses), getEntitiesCompletions(responses));
+                        var filteredCompletions = getFilteredCompletions(completions, filter);
+                        if (filteredCompletions.length) {
+                            var formattedCompletions = getFormattedCompletions(filteredCompletions, filter);
+                            var sortedCompletions = getSortedCompletions(formattedCompletions);
+                            completionResults = {
+                                from: context.pos,
+                                filter: false,
+                                options: sortedCompletions
+                            };
+                            autocomplete$2.startCompletion(CodeMirror6Core.getEditorView());
+                        }
+                        else {
+                            showAutocompleteEmptyState();
+                        }
+                    }
+                });
+                return [2 /*return*/];
+            });
+        });
+    }
+    /*
+     * Returns the filter in the code written.
+     * For example in the code "controladoria.empresa", "empresa" would be the filter
+     * and in "controladoria", "controladoria" would be the filter.
+     * Allows only alphanumerics, underscore and hashtag on filter's start.
+     * Does not allow spaces
+     */
+    function getFilter(string) {
+        var _a, _b;
+        if (string === undefined || string === null)
+            return "";
+        var filter = (_b = (_a = string.match(/(#|\.|)\w*$/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "";
+        return filter.replace(".", "").trim();
+    }
+    /*
+     * Returns the path in the code written based on filter.
+     * For example in the code "controladoria.empresa", "controladoria" would be the path
+     * and in "controladoria", "" would be the path.
+     * Does not allow spaces
+     */
+    function getPath(string, filterLength) {
+        var _a, _b;
+        if (string === undefined || string === null)
+            return "";
+        var stringWithoutPath = string.substring(0, string.length - filterLength);
+        var path = (_b = (_a = stringWithoutPath.match(/(\w*\.)*$/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "";
+        return path.replace(/\.$/, "");
+    }
+    function getRequestsBasedOnPath(path, filter, abortSignal) {
+        var _a;
+        var languageConfigs = getLanguageConfigs();
+        var requests = [];
+        if (path === "") {
+            requests.push({
+                requestType: RequestTypes.ListContextMetadataById,
+                request: AutocompleteService.listContextMetadataById({
+                    id: languageConfigs.contexts,
+                }, abortSignal)
+            });
+            requests.push({
+                requestType: RequestTypes.ListExpressionMetadata,
+                request: AutocompleteService.listExpressionMetadata({
+                    context: languageConfigs.contexts,
+                    subcontext: (_a = languageConfigs.subContexts) !== null && _a !== void 0 ? _a : [],
+                    name: filter,
+                    pageRequest: {
+                        offset: 0,
+                        size: 20
+                    }
+                }, abortSignal)
+            });
+        }
+        else if (path.includes(".")) {
+            var splittedPath = path.split(".");
+            requests.push({
+                requestType: RequestTypes.GetFacadeMetadataByPath,
+                request: AutocompleteService.getFacadeMetadataByPath({
+                    context: splittedPath[0],
+                    entityName: splittedPath[1],
+                    fields: splittedPath[2] === undefined ? undefined : splittedPath.slice(2)
+                }, abortSignal)
+            });
+        }
+        else {
+            requests.push({
+                requestType: RequestTypes.ListFacadeMetadataNames,
+                request: AutocompleteService.listFacadeMetadataNames({
+                    context: [path],
+                    name: filter,
+                    pageRequest: {
+                        offset: 0,
+                        size: 30
+                    }
+                }, abortSignal)
+            });
+        }
+        return requests.map(function (request) { return getSafeResponse(request); });
+    }
+    function getKeywordsCompletions(path) {
+        if (path !== "")
+            return [];
+        var completions = [
+            {
+                label: Keywords.SE,
+                apply: "SE ()\nENTAO\n\tacao\nFIM_SE",
+            },
+            {
+                label: Keywords.SENAO,
+                apply: "SENAO\n\tacao",
+            },
+            {
+                label: Keywords.CONTENHA,
+                apply: "CONTENHA(condicao)",
+            },
+            {
+                label: Keywords.ENTAO,
+                apply: "ENTAO\n\tacao",
+            },
+            {
+                label: Keywords.FIM_SE,
+                apply: "FIM_SE ",
+            },
+            {
+                label: Keywords.NAO,
+                apply: "NAO ",
+            },
+            {
+                label: Keywords.E,
+                apply: "E ",
+            },
+            {
+                label: Keywords.OU,
+                apply: "OU "
+            },
+        ];
+        return completions.map(function (completionItem) { return (__assign(__assign({}, completionItem), { detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_keyword"), type: CompletionTypes.Keyword })); });
+    }
+    function getContextsCompletions(responses) {
+        var _a, _b;
+        var contextsResponse = responses.find(function (response) {
+            return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.ListContextMetadataById;
+        });
+        if (contextsResponse) {
+            return ((_b = (_a = contextsResponse.response) === null || _a === void 0 ? void 0 : _a.contextMetadata) !== null && _b !== void 0 ? _b : [])
+                .map(function (contextMetadata) { return ({
+                label: contextMetadata.name,
+                detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_context"),
+                apply: contextMetadata.name,
+                type: CompletionTypes.Context
+            }); });
+        }
+        return [];
+    }
+    function getExpressionsCompletions(responses) {
+        var _a, _b;
+        var expressionsResponse = responses.find(function (response) {
+            return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.ListExpressionMetadata;
+        });
+        if (expressionsResponse) {
+            return ((_b = (_a = expressionsResponse.response) === null || _a === void 0 ? void 0 : _a.expressionMetadata) !== null && _b !== void 0 ? _b : [])
+                .map(function (expressionMetadata) { return ({
+                label: expressionMetadata.name,
+                detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_" + (expressionMetadata.type === MetaType.PUBLIC_EXPRESSION
+                    ? "senior_expression"
+                    : "user_expression")),
+                apply: expressionMetadata.name,
+                info: expressionMetadata.description,
+                type: expressionMetadata.type === MetaType.PUBLIC_EXPRESSION ? CompletionTypes.Expression : CompletionTypes.UserExpression
+            }); });
+        }
+        return [];
+    }
+    function getEntitiesCompletions(responses) {
+        var _a, _b, _c, _d, _e;
+        var facadesResponseFromList = responses.find(function (response) {
+            return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.ListFacadeMetadataNames;
+        });
+        if (facadesResponseFromList) {
+            return ((_b = (_a = facadesResponseFromList.response) === null || _a === void 0 ? void 0 : _a.facadeMetadataNames) !== null && _b !== void 0 ? _b : [])
+                .map(function (facade) { return ({
+                label: facade.name,
+                detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_entity"),
+                apply: facade.name,
+                type: CompletionTypes.Entity
+            }); });
+        }
+        var facadesResponseFromGet = responses.find(function (response) {
+            return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.GetFacadeMetadataByPath;
+        });
+        if (facadesResponseFromGet) {
+            return ((_e = (_d = (_c = facadesResponseFromGet.response) === null || _c === void 0 ? void 0 : _c.facadeMetadata) === null || _d === void 0 ? void 0 : _d.fields) !== null && _e !== void 0 ? _e : [])
+                .map(function (facade) { return ({
+                label: facade.name,
+                detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_" + (facade.type === MetaType.ENTITY
+                    ? "entity"
+                    : "field")),
+                apply: facade.name,
+                type: facade.type === MetaType.ENTITY ? CompletionTypes.Entity : CompletionTypes.FinalValue
+            }); });
+        }
+        return [];
+    }
+    /*
+     * Filtering the completions to only deal with the necessary items
+     */
+    function getFilteredCompletions(completions, filter) {
+        return completions
+            .filter(function (completionItem) {
+            return completionItem
+                .label
+                .toLowerCase()
+                .startsWith(filter.toLowerCase());
+        });
+    }
+    /*
+     * Overwriting the completions's apply to remove the entire current written value and apply the the entire completion's apply
+     */
+    function getFormattedCompletions(completions, filter) {
+        return completions
+            .map(function (completionItem) { return (__assign(__assign({}, completionItem), { apply: getCompletionApply(filter, "" + completionItem.apply) })); });
+    }
+    function getCompletionApply(filter, oldApplyText) {
+        return function (view, completion, from, to) {
+            var newFrom = from - filter.length;
+            view.dispatch({
+                changes: {
+                    from: newFrom,
+                    to: to,
+                    insert: oldApplyText
+                },
+                selection: {
+                    anchor: newFrom + oldApplyText.length
+                },
+                userEvent: "input.complete",
+                annotations: autocomplete$2.pickedCompletion.of(completion)
+            });
+        };
+    }
+    var completionsSortOrder = [
+        CompletionTypes.Keyword,
+        CompletionTypes.Context,
+        CompletionTypes.UserExpression,
+        CompletionTypes.Expression,
+        CompletionTypes.Entity,
+        CompletionTypes.FinalValue
+    ];
+    /*
+     * Sorts the completions following the "completionsSortOrder" priority order
+     */
+    function getSortedCompletions(completions) {
+        return completions.sort(function (x, y) {
+            var xPriority = completionsSortOrder.indexOf(x.type);
+            var yPriority = completionsSortOrder.indexOf(y.type);
+            return xPriority - yPriority;
+        });
+    }
+
+    function TaxCalculation() {
+        return new language.LanguageSupport(baseConfigs, [
+            autocomplete(),
+        ]);
+    }
+
+    var EditorLanguages = /** @class */ (function () {
+        function EditorLanguages() {
+        }
+        EditorLanguages.getLanguage = function (language) {
+            var languageSupportFactory = EditorLanguages._LANGUAGES.get(language);
+            if (languageSupportFactory)
+                return languageSupportFactory();
+            return [];
+        };
+        EditorLanguages._LANGUAGES = new Map([
+            [exports.Languages.TaxCalculation, TaxCalculation]
+        ]);
+        return EditorLanguages;
+    }());
+
+    /**
+     * Adds style to the editor in general
+     * @returns An extension containing the style
+     */
+    function style$2() {
+        return view.EditorView.theme({
+            "&.cm-editor.cm-focused": {
+                outline: "none",
+            },
+        });
+    }
+
+    var SDSLightHighlightStyle = highlight.HighlightStyle.define([
+        {
+            tag: highlight.tags.keyword,
+            color: "#008080",
+        },
+        {
+            tag: highlight.tags.string,
+            color: "#9C3A3A",
+        },
+        {
+            tag: highlight.tags.number,
+            color: "#400753",
+        },
+    ]);
+
+    /**
+     * Adds a vertical scrollbar when the editor's height overflows the parent's height
+     * @returns An extension containing everything needed to add the scrollbar
+     */
+    function scrollbars() {
+        return [
+            style$3()
+        ];
+    }
+    function style$3() {
+        return view.EditorView.baseTheme({
+            "&.cm-editor": {
+                "height": "100%"
+            },
+        });
+    }
+
+    /**
+     * Adds style to editor'font
+     * @returns An extension containing everything needed to add the font style
+     */
+    function fontStyle() {
+        return [style$4()];
+    }
+    var generalFontStyle = {
+        "font-family": "'Noto Sans Mono', 'sans-serif'",
+        "font-style": "normal",
+        "font-size": "1rem",
+    };
+    function style$4() {
+        return view.EditorView.theme({
+            ".cm-scroller": __assign(__assign({}, generalFontStyle), { "letter-spacing": "0", "line-height": "1.5em", "font-variation-settings": "'wght' 400", "color": "#333333" }),
+            ".cm-tooltip.cm-tooltip-autocomplete > ul": __assign(__assign({}, generalFontStyle), { "font-variation-settings": "'wght' 300", "color": "#697882" }),
+            ".cm-tooltip.cm-tooltip-autocomplete > ul .cm-completionLabel": {
+                "line-height": "1.5em",
+                "font-variation-settings": "'wght' 500",
+            },
+            ".cm-tooltip.cm-tooltip-autocomplete > ul .cm-completionDetail": {
+                "font-size": "0.875em",
+                "font-style": "normal",
+                "margin-left": "0.75rem",
+            },
+        });
+    }
+
+    /**
+     * Adds a line counter
+     * @returns An extension containing everything needed to add the line counter
+     */
+    function lineCounter() {
+        return [
+            gutter.lineNumbers(),
+            style$5()
+        ];
+    }
+    function style$5() {
+        return view.EditorView.theme({
+            ".cm-gutters": {
+                "background-color": "#fff",
+                "color": "#428BCA",
+                "border-right": "none"
+            },
+            ".cm-gutter": {
+                "padding": "0 2rem 0 2rem"
+            }
+        });
+    }
+
+    /**
+     * Adds styles to the autocomplete's tooltip
+     * @returns An extension containing everything needed to add the style
+     */
+    function autocompleteTooltip() {
+        return [style$6()];
+    }
+    function style$6() {
+        return view.EditorView.baseTheme({
+            ".cm-tooltip": {
+                "border": "none !important",
+                "border-radius": "4px",
+                "background-color": "#E5EAEA !important",
+            },
+            ".cm-tooltip.cm-tooltip-autocomplete > ul[role='listbox']": {
+                "padding": "1rem",
+            },
+            ".cm-tooltip.cm-tooltip-autocomplete > ul .cm-completionDetail": {
+                "margin-left": ".75rem",
+            },
+            ".cm-tooltip.cm-tooltip-autocomplete > ul .cm-completionDetail::before": {
+                "content": "'[ '",
+            },
+            ".cm-tooltip.cm-tooltip-autocomplete > ul .cm-completionDetail::after": {
+                "content": "' ]'",
+            },
+            ".cm-tooltip.cm-tooltip-autocomplete > ul .cm-completionIcon": {
+                "padding-right": 0,
+                "margin-right": ".475rem",
+                "width": "1rem",
+            },
+            ".cm-tooltip-autocomplete ul li[aria-selected]": {
+                "border-radius": "4px",
+                "background-color": "#5D96A2 !important",
+                "color": "#fff !important",
+            },
+            ".cm-tooltip.cm-completionInfo.cm-completionInfo-right": {
+                "border-radius": "3px",
+                "box-shadow": "0 2px 4px -1px rgb(0 0 0 / 20%), 0 4px 5px 0 rgb(0 0 0 / 14%), 0 1px 10px 0 rgb(0 0 0 / 12%)",
+                "background": "#495057 !important",
+                "color": "#fff",
+                "padding": ".5rem",
+                "left": "101.6%",
+            },
+            ".cm-tooltip.cm-completionInfo.cm-completionInfo-right::before": {
+                "content": "''",
+                "position": "absolute",
+                "width": 0,
+                "height": 0,
+                "top": ".8125rem",
+                "left": "-.25rem",
+                "margin-top": "-.25rem",
+                "border-color": "transparent",
+                "border-style": "solid",
+                "border-right-color": "#495057",
+                "border-width": ".25rem .25rem .25rem 0",
+            },
+        });
+    }
+
+    /* General Style */
+    function SDSLight() {
+        return [
+            [
+                style$2(),
+                scrollbars(),
+                fontStyle(),
+                lineCounter(),
+                autocompleteTooltip()
+            ],
+            SDSLightHighlightStyle
+        ];
+    }
+
+    var EditorThemes = /** @class */ (function () {
+        function EditorThemes() {
+        }
+        EditorThemes.getTheme = function (theme) {
+            var EditorThemeFactory = EditorThemes._THEMES.get(theme);
+            if (EditorThemeFactory)
+                return EditorThemeFactory();
+            return [];
+        };
+        EditorThemes._THEMES = new Map([
+            [exports.Themes.SDSLight, SDSLight]
+        ]);
+        return EditorThemes;
+    }());
+
+    var CodeMirror6Core = /** @class */ (function (_super) {
+        __extends(CodeMirror6Core, _super);
+        function CodeMirror6Core() {
+            var _this = _super.call(this) || this;
+            /* These are necessary for the setCode and setEditorOptions can be called before view has been created */
+            _this._codeReceivedBeforeViewCreation = "";
+            _this._editorOptionsReceivedBeforeViewCreation = [];
+            return _this;
+        }
+        CodeMirror6Core.getEditorView = function () {
+            return CodeMirror6Core._editorView;
+        };
+        CodeMirror6Core.updateEditorView = function () {
+            var _a;
+            var transactionSpecs = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                transactionSpecs[_i] = arguments[_i];
+            }
+            (_a = CodeMirror6Core._editorView).dispatch.apply(_a, __spread(transactionSpecs));
+        };
+        CodeMirror6Core.prototype.setCoreWrapperElement = function (element) {
+            this.createEditorView(element);
+        };
+        CodeMirror6Core.prototype.setCode = function (code) {
+            this.changeEditorContent(code);
+        };
+        CodeMirror6Core.prototype.initCore = function () {
+            this.setObservablesListeners();
+        };
+        CodeMirror6Core.prototype.destroyCore = function () {
+            this._codeReceivedBeforeViewCreation = "";
+            CodeMirror6Core._editorView = null;
+            CodeMirror6Core._ngUnsubscribe.next();
+            CodeMirror6Core._ngUnsubscribe.complete();
+        };
+        CodeMirror6Core.prototype.setCoreEditorOptions = function (options) {
+            var language = EditorLanguages.getLanguage(options.language);
+            var theme = EditorThemes.getTheme(options.theme);
+            if (CodeMirror6Core._editorView) {
+                CodeMirror6Core.updateEditorView({
+                    effects: state.StateEffect.reconfigure.of([
+                        language,
+                        theme,
+                        this.getCodeChangeListenerExtension()
+                    ])
+                });
+            }
+            else {
+                this._editorOptionsReceivedBeforeViewCreation = [language, theme];
+            }
+        };
+        CodeMirror6Core.prototype.highlightCode = function (markers) {
+            var diagnostics = convertMarkersToDiagnostics(markers, CodeMirror6Core._editorView.state.doc.length);
+            CodeMirror6Core.updateEditorView(lint.setDiagnostics(CodeMirror6Core._editorView.state, diagnostics));
+        };
+        CodeMirror6Core.prototype.setObservablesListeners = function () {
+            var _this = this;
+            CodeMirror6Core.$onCompletionItemsUpdate
+                .pipe(operators.takeUntil(CodeMirror6Core._ngUnsubscribe))
+                .subscribe(function (items) { return _this.updateCompletionItems(items); });
+        };
+        CodeMirror6Core.prototype.createEditorView = function (parentElement) {
+            CodeMirror6Core._editorView = new view.EditorView({
+                parent: parentElement,
+                state: state.EditorState.create({
+                    doc: this._codeReceivedBeforeViewCreation,
+                    extensions: [
+                        this._editorOptionsReceivedBeforeViewCreation,
+                        this.getCodeChangeListenerExtension()
+                    ]
+                })
+            });
+            this.notifyCoreFinishLoad();
+        };
+        CodeMirror6Core.prototype.getCodeChangeListenerExtension = function () {
+            var _this = this;
+            return view.EditorView.updateListener.of(function (update) { return update.docChanged && _this.notifyCodeChange(update.state.doc.toString()); });
+        };
+        CodeMirror6Core.prototype.changeEditorContent = function (code) {
+            if (CodeMirror6Core._editorView) {
+                CodeMirror6Core.updateEditorView({
+                    changes: {
+                        from: 0,
+                        to: CodeMirror6Core._editorView.state.doc.length,
+                        insert: code
+                    }
+                });
+            }
+            else {
+                this._codeReceivedBeforeViewCreation = code;
+            }
+        };
+        CodeMirror6Core.$onCompletionItemsUpdate = new rxjs.Subject();
+        CodeMirror6Core._ngUnsubscribe = new rxjs.Subject();
+        CodeMirror6Core._editorView = null;
+        return CodeMirror6Core;
+    }(CoreFacade));
+
+    var CodeEditorModule = /** @class */ (function () {
+        function CodeEditorModule() {
+        }
+        CodeEditorModule = __decorate([
+            core.NgModule({
+                imports: [
+                    common.CommonModule,
+                    CustomTranslationsModule,
+                ],
+                declarations: [CodeEditorComponent],
+                exports: [CodeEditorComponent],
                 providers: [
                     {
-                        provide: "hostProjectConfigs",
-                        useValue: config
+                        provide: CoreFacade,
+                        useClass: CodeMirror6Core
                     }
                 ]
-            };
-        };
-        var AngularComponentsModule_1;
-        AngularComponentsModule = AngularComponentsModule_1 = __decorate([
-            core.NgModule({})
-        ], AngularComponentsModule);
-        return AngularComponentsModule;
+            })
+        ], CodeEditorModule);
+        return CodeEditorModule;
     }());
 
     exports.AngularComponentsModule = AngularComponentsModule;
@@ -7266,6 +8752,7 @@
     exports.CalendarMaskDirective = CalendarMaskDirective;
     exports.CalendarMaskModule = CalendarMaskModule;
     exports.ChipsField = ChipsField;
+    exports.CodeEditorModule = CodeEditorModule;
     exports.CollapseLinkComponent = CollapseLinkComponent;
     exports.CollapseLinkModule = CollapseLinkModule;
     exports.ControlErrorsComponent = ControlErrorsComponent;
@@ -7293,6 +8780,7 @@
     exports.GlobalSearchComponent = GlobalSearchComponent;
     exports.GlobalSearchDropdownItemComponent = GlobalSearchDropdownItemComponent;
     exports.GlobalSearchModule = GlobalSearchModule;
+    exports.HostProjectConfigsInjectionToken = HostProjectConfigsInjectionToken;
     exports.ImageCropperComponent = ImageCropperComponent;
     exports.ImageCropperModule = ImageCropperModule;
     exports.ImageCropperService = ImageCropperService;
@@ -7347,6 +8835,7 @@
     exports.TableHeaderCheckboxComponent = TableHeaderCheckboxComponent;
     exports.TableHeaderCheckboxModule = TableHeaderCheckboxModule;
     exports.TableModule = TableModule;
+    exports.TaxCalculationLanguageConfigs = TaxCalculationLanguageConfigs;
     exports.TextAreaField = TextAreaField;
     exports.TextField = TextField;
     exports.ThumbnailComponent = ThumbnailComponent;
@@ -7366,6 +8855,10 @@
     exports.ɵbg = ThumbnailService;
     exports.ɵbh = InfiniteScrollModule;
     exports.ɵbi = InfiniteScrollDirective;
+    exports.ɵbj = CustomTranslationsModule;
+    exports.ɵbk = CodeEditorComponent;
+    exports.ɵbl = CoreFacade;
+    exports.ɵbm = CodeMirror6Core;
     exports.ɵc = LocalizedBignumberImpurePipe;
     exports.ɵd = TokenListModule;
     exports.ɵe = TableColumnsComponent;