@seniorsistemas/angular-components 14.9.14 → 14.10.0

package/fesm5/seniorsistemas-angular-components.js

@@ -1,15 +1,15 @@
-import { __spread, __assign, __decorate, __extends, __values, __param, __read } from 'tslib';
-import { Input, Component, NgModule, EventEmitter, HostBinding, Output, ViewChild, Renderer2, HostListener, Directive, Injectable, Pipe, forwardRef, ViewEncapsulation, TemplateRef, ViewContainerRef, ComponentFactoryResolver, ChangeDetectorRef, Inject, ContentChild, ApplicationRef, Injector, ElementRef, ContentChildren } from '@angular/core';
+import { __spread, __assign, __decorate, __extends, __values, __param, __read, __awaiter, __generator } from 'tslib';
+import { Input, Component, NgModule, EventEmitter, HostBinding, Output, ViewChild, Renderer2, HostListener, Directive, Injectable, Pipe, forwardRef, ViewEncapsulation, TemplateRef, ViewContainerRef, ComponentFactoryResolver, ChangeDetectorRef, InjectionToken, Inject, ContentChild, ApplicationRef, Injector, ElementRef, ContentChildren } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { BreadcrumbModule as BreadcrumbModule$1 } from 'primeng/breadcrumb';
 import { NavigationEnd, PRIMARY_OUTLET, ActivatedRoute, Router, RouterModule } from '@angular/router';
-import { Subject, of, from, forkJoin, throwError } from 'rxjs';
-import { takeUntil, filter, tap, map, switchMap, catchError, delay, finalize, debounceTime, repeat } from 'rxjs/operators';
+import { Subject, of, from, forkJoin, throwError, ReplaySubject } from 'rxjs';
+import { takeUntil, filter, tap, map, switchMap, catchError, delay, finalize, debounceTime, repeat, take } from 'rxjs/operators';
 import { TieredMenu, TieredMenuModule } from 'primeng/tieredmenu';
 import { TooltipModule } from 'primeng/tooltip';
 import { DomHandler } from 'primeng/dom';
 import { Calendar, CalendarModule } from 'primeng/calendar';
-import { trigger, state, style, transition, animate, group, query, animateChild } from '@angular/animations';
+import { trigger, state, style as style$7, transition, animate, group, query, animateChild } from '@angular/animations';
 import { FormsModule, ReactiveFormsModule, NG_VALUE_ACCESSOR, FormControl, FormGroup, NG_VALIDATORS, Validators, FormArray } from '@angular/forms';
 import { HttpClient, HttpEventType, HttpClientModule } from '@angular/common/http';
 import { Hotkey, HotkeysService, HotkeyModule } from 'angular2-hotkeys';
@@ -18,7 +18,7 @@ import { AutoComplete, AutoCompleteModule } from 'primeng/autocomplete';
 import { Dialog, DialogModule } from 'primeng/dialog';
 import { Table, TableService, RowToggler, TableModule as TableModule$1 } from 'primeng/table';
 import { applyMask, AlignmentOptions, CurrencyMaskDirective as CurrencyMaskDirective$1 } from '@seniorsistemas/ng2-currency-mask';
-import { user } from '@seniorsistemas/senior-platform-data';
+import { user, service } from '@seniorsistemas/senior-platform-data';
 import * as moment_ from 'moment';
 import { CookieService } from 'ngx-cookie-service';
 import { CurrencyMaskDirective } from 'ng2-currency-mask';
@@ -42,6 +42,15 @@ import * as elementResizeDetectorMaker_ from 'element-resize-detector';
 import { FocusTrapFactory, A11yModule } from '@angular/cdk/a11y';
 import { ScrollPanelModule } from 'primeng/scrollpanel';
 import { Sidebar, SidebarModule as SidebarModule$1 } from 'primeng/sidebar';
+import { EditorView, keymap } from '@codemirror/view';
+import { StateField, StateEffect, EditorState } from '@codemirror/state';
+import { setDiagnostics } from '@codemirror/lint';
+import { LRLanguage, LanguageSupport } from '@codemirror/language';
+import { buildParser } from '@lezer/generator';
+import { styleTags, tags, HighlightStyle } from '@codemirror/highlight';
+import { autocompletion, pickedCompletion, startCompletion } from '@codemirror/autocomplete';
+import { showTooltip } from '@codemirror/tooltip';
+import { lineNumbers } from '@codemirror/gutter';
 
 var BreadcrumbComponent = /** @class */ (function () {
     function BreadcrumbComponent(activatedRoute, router) {
@@ -906,11 +915,11 @@ var CollapseLinkComponent = /** @class */ (function () {
             template: "<div *ngIf=\"!collapsed\" @collapseContent (@collapseContent.done)=\"onToggleDone()\">\n    <ng-content></ng-content>\n</div>\n\n<button [id]=\"buttonId\" type=\"button\" class=\"s-collapse-button\" (click)=\"toggle()\" [disabled]=\"disabled\">\n    <span class=\"s-button-icon fa\" [ngClass]=\"{'fa-caret-down': collapsed, 'fa-caret-up': !collapsed}\"\n        aria-hidden=\"true\"></span>\n    <span class=\"s-button-text\">{{ collapsed ? collapsedLabel : expandedLabel }}</span>\n</button>\n",
             animations: [
                 trigger("collapseContent", [
-                    state("void", style({
+                    state("void", style$7({
                         height: 0,
                         opacity: 0,
                     })),
-                    state("*", style({
+                    state("*", style$7({
                         height: "*",
                         opacity: 1,
                     })),
@@ -2338,20 +2347,20 @@ var LookupComponent = /** @class */ (function () {
             encapsulation: ViewEncapsulation.None,
             animations: [
                 trigger("collapseContent", [
-                    state("hidden", style({
+                    state("hidden", style$7({
                         width: "10px",
                         padding: 0,
                     })),
-                    state("visible", style({
+                    state("visible", style$7({
                         width: "*",
                     })),
                     transition("visible <=> hidden", [group([query("@childCollapseContent", animateChild()), animate("{{transitionParams}}")])]),
                 ]),
                 trigger("childCollapseContent", [
-                    state(":leave", style({
+                    state(":leave", style$7({
                         opacity: 0,
                     })),
-                    state(":enter", style({
+                    state(":enter", style$7({
                         opacity: 1,
                     })),
                     transition("* <=> *", animate("{{transitionParams}}")),
@@ -3694,6 +3703,29 @@ var EnumBadgeColors;
     EnumBadgeColors["BLUE"] = "sds-semantic-blue";
 })(EnumBadgeColors || (EnumBadgeColors = {}));
 
+var HostProjectConfigsInjectionToken = new 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([
+        NgModule({})
+    ], AngularComponentsModule);
+    return AngularComponentsModule;
+}());
+
 var TableColumnsComponent = /** @class */ (function () {
     function TableColumnsComponent(viewContainerRef, translate, hostProjectConfigs) {
         this.viewContainerRef = viewContainerRef;
@@ -3885,7 +3917,7 @@ var TableColumnsComponent = /** @class */ (function () {
     TableColumnsComponent.ctorParameters = function () { return [
         { type: ViewContainerRef },
         { type: TranslateService },
-        { type: undefined, decorators: [{ type: Inject, args: ["hostProjectConfigs",] }] }
+        { type: undefined, decorators: [{ type: Inject, args: [HostProjectConfigsInjectionToken,] }] }
     ]; };
     __decorate([
         ViewChild("columnsTemplate", { static: true })
@@ -3905,7 +3937,7 @@ var TableColumnsComponent = /** @class */ (function () {
             selector: "s-table-columns",
             styles: [":host{display:none}"]
         }),
-        __param(2, Inject("hostProjectConfigs"))
+        __param(2, Inject(HostProjectConfigsInjectionToken))
     ], TableColumnsComponent);
     return TableColumnsComponent;
 }());
@@ -6257,13 +6289,13 @@ var ObjectCardComponent = /** @class */ (function () {
             template: "<div [id]=\"id\" class=\"container\">\n    <div\n        [id]=\"id + '-main-container'\"\n        class=\"main-container\"\n        [ngClass]=\"{\n            'with-hidden-fields': fields.length > maxVisibleFields,\n            'with-visible-fields': fields.length && maxVisibleFields\n        }\"\n    >\n        <div class=\"object-content\">\n            <div class=\"s-object-card-main\"><ng-content select=\"s-object-card-main\"></ng-content></div>\n\n            <div class=\"divider\" *ngIf=\"maxVisibleFields && fields.length\"></div>\n\n            <div *ngFor=\"let field of (fields.toArray() | slice: 0:maxVisibleFields)\" class=\"s-object-card-field\">\n                <ng-container *ngTemplateOutlet=\"field.content\"></ng-container>\n            </div>\n        </div>\n\n        <div\n            [id]=\"id + '-expand-icon-container'\"\n            class=\"expand-icon-container\"\n            (click)=\"toggle()\"\n            [pTooltip]=\"expanded ? collapseTooltip : expandTooltip\"\n            tooltipPosition=\"top\"\n            [showDelay]=\"500\"\n        >\n            <span [id]=\"id + '-expand-icon'\" class=\"expand-icon fa\" [ngClass]=\"{ 'fa-minus': expanded, 'fa-plus': !expanded }\"></span>\n        </div>\n    </div>\n\n    <div [id]=\"id + '-expandable-container'\" [@expandableContent]=\"expanded\" class=\"expandable-container\">\n        <div class=\"ui-g ui-g-12\">\n            <ng-container *ngFor=\"let field of (fields.toArray() | slice: maxVisibleFields:fields.length)\">\n                <div class=\"ui-g-{{getExpandedFieldWidth()}}\">\n                    <div class=\"s-object-card-field\"><ng-container *ngTemplateOutlet=\"field.content\"></ng-container></div>\n                </div>\n            </ng-container>\n        </div>\n    </div>\n</div>\n",
             animations: [
                 trigger("expandableContent", [
-                    state("*", style({
+                    state("*", style$7({
                         height: "0",
                     })),
-                    state("false", style({
+                    state("false", style$7({
                         height: "0",
                     })),
-                    state("true", style({
+                    state("true", style$7({
                         height: "*",
                     })),
                     transition("* => true", animate("200ms ease-out")),
@@ -6617,30 +6649,30 @@ var StepsComponent = /** @class */ (function () {
             },
             animations: [
                 trigger("beforeActiveDesative", [
-                    state("active", style({
+                    state("active", style$7({
                         "background-position": "left bottom",
                     })),
-                    state("desactive", style({
+                    state("desactive", style$7({
                         "background-position": "right bottom",
                     })),
                     transition("active => desactive", [animate("50ms 100ms linear")]),
                     transition("desactive => active", [animate("50ms 250ms linear")]),
                 ]),
                 trigger("activeDesative", [
-                    state("active", style({
+                    state("active", style$7({
                         "background-position": "left bottom",
                     })),
-                    state("desactive", style({
+                    state("desactive", style$7({
                         "background-position": "right bottom",
                     })),
                     transition("active => desactive", [animate("100ms 150ms linear")]),
                     transition("desactive => active", [animate("100ms 150ms linear")]),
                 ]),
                 trigger("afterActiveDesative", [
-                    state("active", style({
+                    state("active", style$7({
                         "background-position": "left bottom",
                     })),
-                    state("desactive", style({
+                    state("desactive", style$7({
                         "background-position": "right bottom",
                     })),
                     transition("active => desactive", [animate("50ms 250ms linear")]),
@@ -6940,13 +6972,13 @@ var GlobalSearchComponent = /** @class */ (function () {
             template: "<div class=\"ui-inputgroup\">\n    <input #globalSearch class=\"global-search__input\" [(ngModel)]=\"search\" (ngModelChange)=\"onChange()\" pInputText\n        [placeholder]=\"placeholder\" (focus)=\"focusIn()\" (blur)=\"focusOut()\">\n    <span class=\"ui-inputgroup-addon global-search__span\"><em class=\"fas fa-search\"></em></span>\n    <div class=\"global-search__modal\" *ngIf=\"wasSearched\">\n        <div *sLoadingState=\"isLoading && !isModalLoading\" class=\"global-search__loader\">\n            <div class=\"global-search__container\" *ngIf=\"dropdownItens && dropdownItens.length > 0 || isLoading\">\n                <div *ngIf=\"dropdownItens && dropdownItens.length > 0\">\n                    <div class=\"global-search__modal--total-itens-title\">\n                        <span class=\"ui-g-11 no-space\">{{totalItensLabel}}</span>\n                        <span class=\"ui-g-1 no-space global-search__modal--total-itens-title-icon\" (click)=\"close()\"><em\n                                class=\"fas fa-times\"></em></span>\n                    </div>\n                    <div class=\"no-space global-search__dropdown--itens\"\n                        [@expandableContent]=\"expanded\">\n                        <ng-container *ngFor=\"let item of dropdownItens\">\n                            <div class=\"s-object-card-field no-space global-search__dropdown--itens-container\">\n                                <ng-container *ngTemplateOutlet=\"item.content\"></ng-container>\n                            </div>\n                        </ng-container>\n                    </div>\n                    <div *ngIf=\"showFooter\" class=\"ui-g-12 global-search__modal--footer\">\n                        <s-button class=\"global-search__show-more\" (click)=\"showMore()\" priority=\"link\">\n                            {{showMoreLabel}}\n                        </s-button>\n                    </div>\n                </div>\n            </div>\n            <s-empty-state *ngIf=\"(!dropdownItens || dropdownItens.length==0) && !isLoading\" [title]=\"emptyTitle\"\n                [description]=\"emptyDescription\" ngClass=\"global-search__empty-state--icon\"\n                [iconClass]=\"(emptyIcon ? emptyIcon : 'fas fa-search')\">\n            </s-empty-state>\n        </div>\n    </div>\n    <div *ngIf=\"wasSearched\" class=\"global-search__background\" (click)=\"close()\"></div>\n</div>\n",
             animations: [
                 trigger("expandableContent", [
-                    state("*", style({
+                    state("*", style$7({
                         height: "0",
                     })),
-                    state("false", style({
+                    state("false", style$7({
                         height: "0",
                     })),
-                    state("true", style({
+                    state("true", style$7({
                         height: "*",
                     })),
                     transition("* => true", animate("200ms ease-out")),
@@ -7044,31 +7076,1816 @@ var GlobalSearchModule = /** @class */ (function () {
     return GlobalSearchModule;
 }());
 
-var AngularComponentsModule = /** @class */ (function () {
-    function AngularComponentsModule() {
+var Languages;
+(function (Languages) {
+    Languages["TaxCalculation"] = "TaxCalculation";
+})(Languages || (Languages = {}));
+
+var Themes;
+(function (Themes) {
+    Themes["SDSLight"] = "SDSLight";
+})(Themes || (Themes = {}));
+
+/* Enums */
+
+var ValidationWorkersComposite = /** @class */ (function () {
+    function ValidationWorkersComposite() {
+        this._validations = [];
+    }
+    ValidationWorkersComposite.prototype.validate = function (code, completionItems) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var e_1, _a;
+                        var markers = [];
+                        var finishedWorkers = 0;
+                        try {
+                            for (var _b = __values(_this._validations), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                var worker = _c.value;
+                                worker.onmessage = function (_a) {
+                                    var data = _a.data;
+                                    markers.concat(data);
+                                    finishedWorkers++;
+                                    if (finishedWorkers === _this._validations.length) {
+                                        resolve(markers);
+                                    }
+                                };
+                                worker.postMessage({ code: code, completionItems: completionItems });
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                    })];
+            });
+        });
+    };
+    return ValidationWorkersComposite;
+}());
+
+var ValidationComposite = /** @class */ (function () {
+    function ValidationComposite() {
+        this._validations = [];
+    }
+    ValidationComposite.prototype.validate = function (code, completionItems) {
+        return __awaiter(this, void 0, void 0, function () {
+            var markers, _a, _b, validation, _c, _d, e_1_1;
+            var e_1, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        markers = [];
+                        _f.label = 1;
+                    case 1:
+                        _f.trys.push([1, 6, 7, 8]);
+                        _a = __values(this._validations), _b = _a.next();
+                        _f.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        validation = _b.value;
+                        _d = (_c = markers).concat;
+                        return [4 /*yield*/, validation.validate(code, completionItems)];
+                    case 3:
+                        _d.apply(_c, [_f.sent()]);
+                        _f.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_1_1 = _f.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, markers];
+                }
+            });
+        });
+    };
+    return ValidationComposite;
+}());
+
+/**
+ * Linter for the "TaxCalculation" Language
+ */
+var TaxCalculationLinter = /** @class */ (function () {
+    function TaxCalculationLinter() {
+        this.setValidation();
     }
-    AngularComponentsModule_1 = AngularComponentsModule;
-    AngularComponentsModule.forRoot = function (config) {
+    TaxCalculationLinter.prototype.lint = function (code, completionItems) {
+        return this._validation.validate(code, completionItems || []);
+    };
+    TaxCalculationLinter.prototype.setValidation = function () {
+        var browserSupportsWorkers = typeof Worker !== "undefined";
+        this._validation = browserSupportsWorkers
+            ? new ValidationWorkersComposite()
+            : new ValidationComposite();
+    };
+    return TaxCalculationLinter;
+}());
+
+var CoreLinters = /** @class */ (function () {
+    function CoreLinters() {
+    }
+    CoreLinters.getLinter = function (language) {
+        return CoreLinters._LINTERS.get(language);
+    };
+    CoreLinters._LINTERS = new Map([
+        [Languages.TaxCalculation, new TaxCalculationLinter()]
+    ]);
+    return CoreLinters;
+}());
+
+var CoreFacade = /** @class */ (function () {
+    function CoreFacade() {
+        this.$onCoreFinishLoad = new ReplaySubject(1);
+        this.$onCodeChange = new Subject();
+        this.$onCodeValidityChange = new Subject();
+        this._completionItems = [];
+    }
+    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) {
+        if (code !== this._lastCodeEmitted) {
+            this.setCode(code);
+        }
+    };
+    CoreFacade.prototype.destroyObservables = function () { };
+    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) {
+        if (code !== this._lastCodeEmitted) {
+            this._lastCodeEmitted = code;
+            this.$onCodeChange.next(code);
+            this.validateCode(code);
+        }
+    };
+    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(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(Themes);
+        if (theme && !themes.includes(theme))
+            throw new Error("The informed theme \"" + theme + "\" is not supported");
+    };
+    return CoreFacade;
+}());
+
+var CodeEditorComponent = /** @class */ (function () {
+    function CodeEditorComponent(coreFacade) {
+        this.coreFacade = coreFacade;
+        this._ngUnsubscribe = new Subject();
+        this.codeChange = new EventEmitter();
+        this.isCodeValidChange = new EventEmitter();
+        this.onCodeChange = new EventEmitter();
+        this.onComponentFinishLoad = new 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.setupCoreListeners();
+    };
+    CodeEditorComponent.prototype.ngAfterViewInit = function () {
+        this.setCoreWrapperElement();
+    };
+    CodeEditorComponent.prototype.ngOnDestroy = function () {
+        this.coreFacade.destroyObservables();
+        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(take(1))
+            .subscribe(function () { return _this.onComponentFinishLoad.emit(); });
+        this.coreFacade
+            .getOnCodeChangeObservable()
+            .pipe(takeUntil(this._ngUnsubscribe))
+            .subscribe(function (code) {
+            _this.codeChange.emit(code);
+            _this.onCodeChange.emit(code);
+        });
+        this.coreFacade
+            .getOnCodeValidityChangeObservable()
+            .pipe(takeUntil(this._ngUnsubscribe))
+            .subscribe(function (validity) {
+            _this.isCodeValidChange.emit(validity);
+        });
+    };
+    CodeEditorComponent.ctorParameters = function () { return [
+        { type: CoreFacade }
+    ]; };
+    __decorate([
+        ViewChild("coreWrapper")
+    ], CodeEditorComponent.prototype, "coreWrapperElement", void 0);
+    __decorate([
+        Input()
+    ], CodeEditorComponent.prototype, "editorOptions", null);
+    __decorate([
+        Input()
+    ], CodeEditorComponent.prototype, "code", null);
+    __decorate([
+        Output()
+    ], CodeEditorComponent.prototype, "codeChange", void 0);
+    __decorate([
+        Input()
+    ], CodeEditorComponent.prototype, "isCodeValid", void 0);
+    __decorate([
+        Output()
+    ], CodeEditorComponent.prototype, "isCodeValidChange", void 0);
+    __decorate([
+        Output()
+    ], CodeEditorComponent.prototype, "onCodeChange", void 0);
+    __decorate([
+        Output()
+    ], CodeEditorComponent.prototype, "onComponentFinishLoad", void 0);
+    CodeEditorComponent = __decorate([
+        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 = LRLanguage.define({
+    parser: buildParser(parserGrammar)
+        .configure({
+        props: [
+            styleTags((_a = {},
+                _a[Object.values(Keywords).join(" ")] = tags.keyword,
+                _a["String"] = tags.string,
+                _a["Number"] = 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*/, service.getRestUrl()];
+                    case 1:
+                        restUrl = _a.sent();
+                        return [4 /*yield*/, 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: TranslateService },
+        { type: undefined, decorators: [{ type: Inject, args: [HostProjectConfigsInjectionToken,] }] }
+    ]; };
+    CustomTranslationsModule = __decorate([
+        NgModule(),
+        __param(1, Inject(HostProjectConfigsInjectionToken))
+    ], CustomTranslationsModule);
+    return CustomTranslationsModule;
+}());
+
+/**
+ * Function to get the position of the first occurrence of a regex in a string
+ * @param string The string to search into
+ * @param regex The regex to search into the string
+ * @param position The index at which to begin searching the string. If omitted, search starts at the index 0.
+ * @returns  the position of the first occurrence of the informed regex.
+ */
+function regexIndexOf(string, regex, position) {
+    var indexOf = string.substring(position || 0).search(regex);
+    return (indexOf >= 0) ? (indexOf + (position || 0)) : indexOf;
+}
+
+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 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 StateField.define({
+        create: getAutocompleteStateWrapper,
+        update: function (_, transaction) {
+            return getAutocompleteStateWrapper(transaction.state);
+        },
+        provide: function (field) {
+            return 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*/];
+            }
+        });
+    });
+}
+
+var completionItemsMap = new Map();
+var usefulToCompletionItemsCompletionTypes = [
+    CompletionTypes.Expression,
+    CompletionTypes.UserExpression,
+    CompletionTypes.FinalValue
+];
+/*
+ * Updates the completionItems used by the core.
+ * Utilizes the path and filter to create a key and store the results from the search to the given "path.filter" on a map.
+ * Must save the results to each different filter for the search does not bring all the results, so the user must do a more
+ * specific filter to achieve its objective
+ */
+function updateCoreCompletionItems(completionItem) {
+    var path = completionItem.path, filter = completionItem.filter, completions = completionItem.completions;
+    var mapPath = path + "." + filter;
+    var filteredCompletions = (completions || []).filter(function (completion) {
+        return usefulToCompletionItemsCompletionTypes.includes(completion === null || completion === void 0 ? void 0 : completion.type);
+    });
+    var formattedSearchResults = filteredCompletions.map(function (completion) {
+        return path === "" ? completion === null || completion === void 0 ? void 0 : completion.label : path + "." + (completion === null || completion === void 0 ? void 0 : completion.label);
+    });
+    completionItemsMap.delete(mapPath);
+    if (formattedSearchResults.length) {
+        completionItemsMap.set(mapPath, formattedSearchResults);
+    }
+    var allArraysFromMap = Array.from(completionItemsMap.values());
+    var unrepeatedCompletionItems = new Set(allArraysFromMap.flat());
+    CodeMirror6Core
+        .$onCompletionItemsUpdate
+        .next(Array.from(unrepeatedCompletionItems));
+}
+
+/**
+ * Adds style to the autocomplete
+ * @returns An extension containing the style
+ */
+function style$1() {
+    return 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 [
+        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
+                        };
+                        updateCoreCompletionItems({ path: path, filter: filter, completions: sortedCompletions });
+                        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: 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;
+    });
+}
+
+/**
+ * Adds an watcher to the paste command that updates the core's completions items
+ * @returns An extension containing everything needed to create the the updater
+ */
+function onPasteCompletionItemsUpdater() {
+    return [
+        keymap.of([
+            {
+                key: "Ctrl-v",
+                run: searchCompletionResultsCommand,
+            }
+        ])
+    ];
+}
+var cancelLastCompletionSearch$1 = function () { };
+var ɵ0$1 = cancelLastCompletionSearch$1;
+/*
+ * Must use the setTimeout for we does not have access to the code pasted on the current state, so we need to wait codemirror
+ * remake the state, also it would be way more difficult to work with the clipboard
+ */
+function searchCompletionResultsCommand(view) {
+    cancelLastCompletionSearch$1();
+    var token = new AbortController();
+    setTimeout(function () {
+        if (!token.signal.aborted) {
+            searchCompletionResults$1(view.state.doc.toString(), token);
+        }
+    }, 200);
+    cancelLastCompletionSearch$1 = function () { return token.abort(); };
+    return false;
+}
+/*
+ * Requests the necessary items to update the core's completionItems when the user uses the ctrl+v
+ */
+function searchCompletionResults$1(code, token) {
+    var codeWithoutStrings = getCodeWithoutStringedCode(code);
+    var variablesToVerify = getVariablesToVerify(codeWithoutStrings);
+    var requests = getRequestsBasedOnVariables(variablesToVerify, token.signal);
+    Promise
+        .all(requests)
+        .then(function (responses) {
+        if (!token.signal.aborted) {
+            var expressionsCompletionItems = getExpressionsCompletionsItems(responses);
+            var entitiesCompletionItems = getEntitiesCompletionsItems(responses);
+            var completionItems = expressionsCompletionItems.concat(entitiesCompletionItems);
+            updateCompletionItems(completionItems);
+        }
+    });
+}
+/*
+ * Returns the code itself without its inside double quotes parts, e.g
+ * on string `return this "here not" code`, the return value will be `return this  code`;
+ */
+function getCodeWithoutStringedCode(code) {
+    return (code !== null && code !== void 0 ? code : "").replace(/"([^"])*["]?/g, " ");
+}
+/*
+ * Returns the code's parts that need to be verified by requests, excluding the keywords,
+ * special character (except dot/`.` in middle of two regex's \w and at the end and hashtag in sentence's start)
+ * e.g on string `SE (something.another OU expression E something.another.)`, the variables array would be
+ * ["something.another", "expression", "something.another."]
+ */
+function getVariablesToVerify(code) {
+    var _a;
+    var keywordsRegex = Object
+        .values(Keywords)
+        .map(function (keyword) { return "(?!" + keyword + "\\b)"; })
+        .join("");
+    return (_a = (code !== null && code !== void 0 ? code : "").match(new RegExp("[#]?\\b(" + keywordsRegex + ")(\\w+\\.)*\\w+[\\.]?", "g"))) !== null && _a !== void 0 ? _a : [];
+}
+/*
+ * Only needs to request the expressions and the fields from an entity;
+ * Creates an request to every variable;
+ * Uses the AutocompleteService for the requests needed here are Autocomplete's usage, so we are just
+ * borrowing from it
+ */
+function getRequestsBasedOnVariables(variables, abortSignal) {
+    var e_1, _a;
+    var _b;
+    var languageConfigs = getLanguageConfigs();
+    var requests = [];
+    try {
+        for (var variables_1 = __values(variables), variables_1_1 = variables_1.next(); !variables_1_1.done; variables_1_1 = variables_1.next()) {
+            var variable = variables_1_1.value;
+            var splittedVariable = variable.split(".");
+            if (splittedVariable.length === 1) {
+                var extraInfo = {
+                    path: "",
+                    filter: splittedVariable[0]
+                };
+                requests.push({
+                    requestType: RequestTypes.ListExpressionMetadata,
+                    request: AutocompleteService.listExpressionMetadata({
+                        context: languageConfigs.contexts,
+                        subcontext: (_b = languageConfigs.subContexts) !== null && _b !== void 0 ? _b : [],
+                        name: splittedVariable[0]
+                    }, abortSignal),
+                    extraInfo: extraInfo
+                });
+            }
+            else if (splittedVariable.length > 2) {
+                var extraInfo = {
+                    path: splittedVariable
+                        .slice(0, splittedVariable.length - 1)
+                        .join("."),
+                    filter: ""
+                };
+                requests.push({
+                    requestType: RequestTypes.GetFacadeMetadataByPath,
+                    request: AutocompleteService.getFacadeMetadataByPath({
+                        context: splittedVariable[0],
+                        entityName: splittedVariable[1],
+                        fields: splittedVariable.slice(2, splittedVariable.length - 1)
+                    }, abortSignal),
+                    extraInfo: extraInfo
+                });
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (variables_1_1 && !variables_1_1.done && (_a = variables_1.return)) _a.call(variables_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return requests.map(function (request) { return getSafeResponse(request); });
+}
+function getExpressionsCompletionsItems(responses) {
+    var expressionsResponses = responses.filter(function (response) {
+        return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.ListExpressionMetadata;
+    });
+    return expressionsResponses
+        .map(function (expressionsResponse) {
+        var _a, _b, _c, _d, _e, _f;
         return {
-            ngModule: AngularComponentsModule_1,
+            path: (_b = (_a = expressionsResponse.extraInfo) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : "",
+            filter: (_d = (_c = expressionsResponse.extraInfo) === null || _c === void 0 ? void 0 : _c.filter) !== null && _d !== void 0 ? _d : "",
+            completions: ((_f = (_e = expressionsResponse.response) === null || _e === void 0 ? void 0 : _e.expressionMetadata) !== null && _f !== void 0 ? _f : [])
+                .map(function (expressionMetadata) { return ({
+                label: expressionMetadata.name,
+                type: expressionMetadata.type === MetaType.PUBLIC_EXPRESSION
+                    ? CompletionTypes.Expression
+                    : CompletionTypes.UserExpression
+            }); })
+        };
+    })
+        .flat();
+}
+function getEntitiesCompletionsItems(responses) {
+    var facadesResponsesFromGet = responses.filter(function (response) {
+        return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.GetFacadeMetadataByPath;
+    });
+    return facadesResponsesFromGet
+        .map(function (facadesResponseFromGet) {
+        var _a, _b, _c;
+        return {
+            path: facadesResponseFromGet.extraInfo.path,
+            filter: facadesResponseFromGet.extraInfo.filter,
+            completions: ((_c = (_b = (_a = facadesResponseFromGet.response) === null || _a === void 0 ? void 0 : _a.facadeMetadata) === null || _b === void 0 ? void 0 : _b.fields) !== null && _c !== void 0 ? _c : [])
+                .map(function (facade) { return ({
+                label: facade.name,
+                type: facade.type === MetaType.ENTITY ? CompletionTypes.Entity : CompletionTypes.FinalValue
+            }); })
+        };
+    })
+        .flat();
+}
+function updateCompletionItems(completionItems) {
+    var e_2, _a;
+    try {
+        for (var completionItems_1 = __values(completionItems), completionItems_1_1 = completionItems_1.next(); !completionItems_1_1.done; completionItems_1_1 = completionItems_1.next()) {
+            var completionItem = completionItems_1_1.value;
+            updateCoreCompletionItems(completionItem);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (completionItems_1_1 && !completionItems_1_1.done && (_a = completionItems_1.return)) _a.call(completionItems_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+}
+
+function TaxCalculation() {
+    return new LanguageSupport(baseConfigs, [
+        autocomplete(),
+        onPasteCompletionItemsUpdater(),
+    ]);
+}
+
+var EditorLanguages = /** @class */ (function () {
+    function EditorLanguages() {
+    }
+    EditorLanguages.getLanguage = function (language) {
+        return EditorLanguages._LANGUAGES.get(language) || [];
+    };
+    EditorLanguages._LANGUAGES = new Map([
+        [Languages.TaxCalculation, TaxCalculation()]
+    ]);
+    return EditorLanguages;
+}());
+
+/**
+ * Adds style to the editor in general
+ * @returns An extension containing the style
+ */
+function style$2() {
+    return EditorView.theme({
+        "&.cm-editor.cm-focused": {
+            outline: "none",
+        },
+    });
+}
+
+var SDSLightHighlightStyle = HighlightStyle.define([
+    {
+        tag: tags.keyword,
+        color: "blue",
+    },
+    {
+        tag: tags.string,
+        color: "red",
+    },
+    {
+        tag: tags.number,
+        color: "green",
+    },
+]);
+
+/**
+ * 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 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 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 [
+        lineNumbers(),
+        style$5()
+    ];
+}
+function style$5() {
+    return 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 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) {
+        return EditorThemes._THEMES.get(theme) || [];
+    };
+    EditorThemes._THEMES = new Map([
+        [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 = [];
+        _this.setObservablesListeners();
+        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);
+    };
+    // @Override
+    CodeMirror6Core.prototype.destroyObservables = function () {
+        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: 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(setDiagnostics(CodeMirror6Core._editorView.state, diagnostics));
+    };
+    CodeMirror6Core.prototype.setObservablesListeners = function () {
+        var _this = this;
+        CodeMirror6Core.$onCompletionItemsUpdate
+            .pipe(takeUntil(CodeMirror6Core._ngUnsubscribe))
+            .subscribe(function (items) { return _this.updateCompletionItems(items); });
+    };
+    CodeMirror6Core.prototype.createEditorView = function (parentElement) {
+        CodeMirror6Core._editorView = new EditorView({
+            parent: parentElement,
+            state: EditorState.create({
+                doc: this._codeReceivedBeforeViewCreation,
+                extensions: [
+                    this._editorOptionsReceivedBeforeViewCreation,
+                    this.getCodeChangeListenerExtension()
+                ]
+            })
+        });
+        this.notifyCoreFinishLoad();
+    };
+    CodeMirror6Core.prototype.getCodeChangeListenerExtension = function () {
+        var _this = this;
+        return 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 Subject();
+    CodeMirror6Core._ngUnsubscribe = new Subject();
+    CodeMirror6Core._editorView = null;
+    return CodeMirror6Core;
+}(CoreFacade));
+
+var CodeEditorModule = /** @class */ (function () {
+    function CodeEditorModule() {
+    }
+    CodeEditorModule = __decorate([
+        NgModule({
+            imports: [
+                CommonModule,
+                CustomTranslationsModule,
+            ],
+            declarations: [CodeEditorComponent],
+            exports: [CodeEditorComponent],
             providers: [
                 {
-                    provide: "hostProjectConfigs",
-                    useValue: config
+                    provide: CoreFacade,
+                    useClass: CodeMirror6Core
                 }
             ]
-        };
-    };
-    var AngularComponentsModule_1;
-    AngularComponentsModule = AngularComponentsModule_1 = __decorate([
-        NgModule({})
-    ], AngularComponentsModule);
-    return AngularComponentsModule;
+        })
+    ], CodeEditorModule);
+    return CodeEditorModule;
 }());
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AngularComponentsModule, AutocompleteField, BignumberField, BignumberInputDirective, BignumberInputModule, BooleanField, BooleanOptionsLabel, BreadcrumbComponent, BreadcrumbModule, Breakpoints, ButtonComponent, ButtonModule, ButtonPriority, ButtonSize, CalendarField, CalendarLocaleOptions, CalendarMaskDirective, CalendarMaskModule, ChipsField, CollapseLinkComponent, CollapseLinkModule, ControlErrorsComponent, ControlErrorsModule, CurrencyField, CustomFieldsComponent, CustomFieldsModule, CustomFieldsService, DEFAULT_CALENDAR_LOCALE_OPTIONS, DEFAULT_LOCALE_OPTIONS, DEFAULT_NUMBER_LOCALE_OPTIONS, DynamicConfig, DynamicFormComponent, DynamicFormModule, DynamicType, EditableOverlayDirective, EditableOverlayModule, EmptyStateComponent, EmptyStateModule, EnumBadgeColors, EnumColumnFieldType, ExportUtils, Field, FieldType, Fieldset, FileUploadComponent, FileUploadModule, FormField, GlobalSearchComponent, GlobalSearchDropdownItemComponent, GlobalSearchModule, GlobalSearchSizeEnum, ImageCropperComponent, ImageCropperModule, ImageCropperService, InfoSignDirective, InfoSignModule, LoadingStateComponent, LoadingStateDirective, LoadingStateModule, LocaleModule, LocaleOptions, LocaleService, LocalizedCurrencyPipe, LocalizedCurrencyPipeOptions, LocalizedDateImpurePipe, LocalizedDatePipe, LocalizedNumberInputDirective, LocalizedNumberInputModule, LocalizedNumberPipe, LocalizedTimeImpurePipe, LocalizedTimePipe, LongPressDirective, LookupComponent, LookupField, MaskFormatterModule, MaskFormatterPipe, MouseEventsModule, NavigationDirective, NumberAlignmentOption, NumberField, NumberInputDirective, NumberInputModule, NumberLocaleOptions, ObjectCardComponent, ObjectCardFieldComponent, ObjectCardMainComponent, ObjectCardModule, Option, ProductHeaderComponent, ProductHeaderModule, RadioButtonField, RationButtonOption, RowTogllerDirective, Section, SelectField, SelectOption, SidebarComponent, SidebarModule, StatsCardComponent, StatsCardModule, StepState, StepsComponent, StepsModule, Structure, TableHeaderCheckboxComponent, TableHeaderCheckboxModule, TableModule, TextAreaField, TextField, ThumbnailComponent, ThumbnailModule, ThumbnailSize, TileComponent, TileModule, TokenListComponent, TokenListModule, ValidateErrors, LocalizedCurrencyImpurePipe as ɵa, LocalizedBignumberPipe as ɵb, DecimalField as ɵba, StructureModule as ɵbb, HeaderComponent as ɵbc, FooterComponent as ɵbd, InfoSignComponent as ɵbe, NumberLocaleOptions as ɵbf, ThumbnailService as ɵbg, InfiniteScrollModule as ɵbh, InfiniteScrollDirective as ɵbi, LocalizedBignumberImpurePipe as ɵc, TokenListModule as ɵd, TableColumnsComponent as ɵe, InfoSignModule as ɵf, AutocompleteFieldComponent as ɵg, BooleanFieldComponent as ɵh, CalendarFieldComponent as ɵi, ChipsFieldComponent as ɵj, CurrencyFieldComponent as ɵk, BaseFieldComponent as ɵl, DynamicFieldComponent as ɵm, DynamicFormDirective as ɵn, FieldsetComponent as ɵo, FileUploadComponent$1 as ɵp, LookupFieldComponent as ɵq, NumberFieldComponent as ɵr, BignumberFieldComponent as ɵs, RadioButtonComponent as ɵt, RowComponent as ɵu, SectionComponent as ɵv, SelectFieldComponent as ɵw, TextAreaFieldComponent as ɵx, TextFieldComponent as ɵy };
+export { AngularComponentsModule, AutocompleteField, BignumberField, BignumberInputDirective, BignumberInputModule, BooleanField, BooleanOptionsLabel, BreadcrumbComponent, BreadcrumbModule, Breakpoints, ButtonComponent, ButtonModule, ButtonPriority, ButtonSize, CalendarField, CalendarLocaleOptions, CalendarMaskDirective, CalendarMaskModule, ChipsField, CodeEditorModule, CollapseLinkComponent, CollapseLinkModule, ControlErrorsComponent, ControlErrorsModule, CurrencyField, CustomFieldsComponent, CustomFieldsModule, CustomFieldsService, DEFAULT_CALENDAR_LOCALE_OPTIONS, DEFAULT_LOCALE_OPTIONS, DEFAULT_NUMBER_LOCALE_OPTIONS, DynamicConfig, DynamicFormComponent, DynamicFormModule, DynamicType, EditableOverlayDirective, EditableOverlayModule, EmptyStateComponent, EmptyStateModule, EnumBadgeColors, EnumColumnFieldType, ExportUtils, Field, FieldType, Fieldset, FileUploadComponent, FileUploadModule, FormField, GlobalSearchComponent, GlobalSearchDropdownItemComponent, GlobalSearchModule, GlobalSearchSizeEnum, HostProjectConfigsInjectionToken, ImageCropperComponent, ImageCropperModule, ImageCropperService, InfoSignDirective, InfoSignModule, Languages, LoadingStateComponent, LoadingStateDirective, LoadingStateModule, LocaleModule, LocaleOptions, LocaleService, LocalizedCurrencyPipe, LocalizedCurrencyPipeOptions, LocalizedDateImpurePipe, LocalizedDatePipe, LocalizedNumberInputDirective, LocalizedNumberInputModule, LocalizedNumberPipe, LocalizedTimeImpurePipe, LocalizedTimePipe, LongPressDirective, LookupComponent, LookupField, MaskFormatterModule, MaskFormatterPipe, MouseEventsModule, NavigationDirective, NumberAlignmentOption, NumberField, NumberInputDirective, NumberInputModule, NumberLocaleOptions, ObjectCardComponent, ObjectCardFieldComponent, ObjectCardMainComponent, ObjectCardModule, Option, ProductHeaderComponent, ProductHeaderModule, RadioButtonField, RationButtonOption, RowTogllerDirective, Section, SelectField, SelectOption, SidebarComponent, SidebarModule, StatsCardComponent, StatsCardModule, StepState, StepsComponent, StepsModule, Structure, TableHeaderCheckboxComponent, TableHeaderCheckboxModule, TableModule, TaxCalculationLanguageConfigs, TextAreaField, TextField, Themes, ThumbnailComponent, ThumbnailModule, ThumbnailSize, TileComponent, TileModule, TokenListComponent, TokenListModule, ValidateErrors, LocalizedCurrencyImpurePipe as ɵa, LocalizedBignumberPipe as ɵb, DecimalField as ɵba, StructureModule as ɵbb, HeaderComponent as ɵbc, FooterComponent as ɵbd, InfoSignComponent as ɵbe, NumberLocaleOptions as ɵbf, ThumbnailService as ɵbg, InfiniteScrollModule as ɵbh, InfiniteScrollDirective as ɵbi, CustomTranslationsModule as ɵbj, CodeEditorComponent as ɵbk, CoreFacade as ɵbl, CodeMirror6Core as ɵbm, LocalizedBignumberImpurePipe as ɵc, TokenListModule as ɵd, TableColumnsComponent as ɵe, InfoSignModule as ɵf, AutocompleteFieldComponent as ɵg, BooleanFieldComponent as ɵh, CalendarFieldComponent as ɵi, ChipsFieldComponent as ɵj, CurrencyFieldComponent as ɵk, BaseFieldComponent as ɵl, DynamicFieldComponent as ɵm, DynamicFormDirective as ɵn, FieldsetComponent as ɵo, FileUploadComponent$1 as ɵp, LookupFieldComponent as ɵq, NumberFieldComponent as ɵr, BignumberFieldComponent as ɵs, RadioButtonComponent as ɵt, RowComponent as ɵu, SectionComponent as ɵv, SelectFieldComponent as ɵw, TextAreaFieldComponent as ɵx, TextFieldComponent as ɵy };
 //# sourceMappingURL=seniorsistemas-angular-components.js.map