@seniorsistemas/angular-components 17.31.2 → 18.0.0-develop-ae6477c0

package/esm2022/code-editor/lib/code-editor/code-editor.module.mjs

@@ -0,0 +1,32 @@
+import { CommonModule } from "@angular/common";
+import { NgModule } from "@angular/core";
+import { CodeEditorComponent } from "./code-editor.component";
+import { CoreFacade } from "./core/facades/core-facade";
+import { CodeMirror6Core } from "./infra/cores/codemirror-6/codemirror-6-core";
+import { CustomTranslationsModule } from "./infra/utils/custom-translations/custom-translations.module";
+import * as i0 from "@angular/core";
+export class CodeEditorModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CodeEditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: CodeEditorModule, declarations: [CodeEditorComponent], imports: [CommonModule, CustomTranslationsModule], exports: [CodeEditorComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CodeEditorModule, providers: [
+            {
+                provide: CoreFacade,
+                useClass: CodeMirror6Core,
+            },
+        ], imports: [CommonModule, CustomTranslationsModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CodeEditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, CustomTranslationsModule],
+                    declarations: [CodeEditorComponent],
+                    exports: [CodeEditorComponent],
+                    providers: [
+                        {
+                            provide: CoreFacade,
+                            useClass: CodeMirror6Core,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/code-editor/lib/code-editor/core/facades/core-facade.mjs

@@ -0,0 +1,91 @@
+import { ReplaySubject, Subject } from 'rxjs';
+import { Languages, Themes } from '../../models';
+import { CoreLinters } from '../use-cases/core-linters';
+export class CoreFacade {
+    $onCoreFinishLoad = new ReplaySubject(1);
+    $onCodeChange = new Subject();
+    $onCodeValidityChange = new Subject();
+    _completionItems = [];
+    _lastCodeEmitted = '';
+    _lastCodeValidityEmitted;
+    _linter;
+    changeEditorOptions(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);
+        }
+    }
+    changeCode(code) {
+        const safeCode = this.getSafeCode(code);
+        if (safeCode !== this._lastCodeEmitted) {
+            this.setCode(safeCode);
+        }
+    }
+    setPayload(payload) {
+        const safeCode = this.getSafeCode(payload);
+        // Força a atualização sem verificar _lastCodeEmitted,
+        // mas preserva o cursor verificando no nível do editor
+        this.setCodeWithCursorPreservation(safeCode);
+    }
+    getOnCoreFinishLoadObservable() {
+        return this.$onCoreFinishLoad.asObservable();
+    }
+    getOnCodeChangeObservable() {
+        return this.$onCodeChange.asObservable();
+    }
+    getOnCodeValidityChangeObservable() {
+        return this.$onCodeValidityChange.asObservable();
+    }
+    notifyCoreFinishLoad() {
+        this.$onCoreFinishLoad.next();
+    }
+    notifyCodeChange(code) {
+        const safeCode = this.getSafeCode(code);
+        if (safeCode !== this._lastCodeEmitted) {
+            this._lastCodeEmitted = safeCode;
+            this.$onCodeChange.next(safeCode);
+            this.validateCode(safeCode);
+        }
+    }
+    updateCompletionItems(items) {
+        this._completionItems = items || [];
+        this.validateCode(this._lastCodeEmitted);
+    }
+    setLinter(language) {
+        this._linter = CoreLinters.getLinter(language);
+    }
+    async validateCode(code) {
+        if (this._linter) {
+            const markers = await this._linter.lint(code, this._completionItems);
+            this.highlightCode(markers);
+            this.notifyCodeValidityChange(!markers.length);
+        }
+    }
+    notifyCodeValidityChange(validity) {
+        if (validity !== this._lastCodeValidityEmitted) {
+            this._lastCodeValidityEmitted = validity;
+            this.$onCodeValidityChange.next(validity);
+        }
+    }
+    validateLanguage(language) {
+        const languages = Object.values(Languages);
+        if (language && !languages.includes(language)) {
+            throw new Error(`The informed language "${language}" is not supported`);
+        }
+    }
+    validateTheme(theme) {
+        const themes = Object.values(Themes);
+        if (theme && !themes.includes(theme)) {
+            throw new Error(`The informed theme "${theme}" is not supported`);
+        }
+    }
+    getSafeCode(code) {
+        return typeof code === 'string' ? code : '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core-facade.js","sourceRoot":"","sources":["../../../../../../../projects/angular-components/code-editor/src/lib/code-editor/core/facades/core-facade.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, ReplaySubject, Subject } from 'rxjs';\n\nimport { EditorOptions, Languages, Themes } from '../../models';\nimport { Marker } from '../models';\nimport { CoreLinters } from '../use-cases/core-linters';\nimport { LinterFacade } from './linter-facade';\n\nexport abstract class CoreFacade {\n    private readonly $onCoreFinishLoad: ReplaySubject<void> = new ReplaySubject(1);\n    private readonly $onCodeChange: Subject<string> = new Subject();\n    private readonly $onCodeValidityChange: Subject<boolean> = new Subject();\n    private _completionItems: string[] = [];\n    private _lastCodeEmitted = '';\n    private _lastCodeValidityEmitted!: boolean;\n    private _linter!: LinterFacade;\n\n    public changeEditorOptions(options: EditorOptions): void {\n        if (options) {\n            if (typeof options !== 'object') {\n                throw new Error(\"Editor's options must be an EditorOptions object\");\n            }\n\n            this.validateLanguage(options.language as Languages);\n            this.validateTheme(options.theme as Themes);\n            this.setLinter(options.language as Languages);\n\n            this.setCoreEditorOptions(options);\n        }\n    }\n\n    public changeCode(code: string): void {\n        const safeCode = this.getSafeCode(code);\n        if (safeCode !== this._lastCodeEmitted) {\n            this.setCode(safeCode);\n        }\n    }\n\n    public setPayload(payload: string): void {\n        const safeCode = this.getSafeCode(payload);\n        // Força a atualização sem verificar _lastCodeEmitted,\n        // mas preserva o cursor verificando no nível do editor\n        this.setCodeWithCursorPreservation(safeCode);\n    }\n\n    protected abstract setCodeWithCursorPreservation(code: string): void;\n\n    public abstract initCore(): void;\n    public abstract destroyCore(): void;\n\n    public abstract setCoreWrapperElement(element: HTMLDivElement): void;\n    public abstract setCode(code: string): void;\n\n    public getOnCoreFinishLoadObservable(): Observable<void> {\n        return this.$onCoreFinishLoad.asObservable();\n    }\n\n    public getOnCodeChangeObservable(): Observable<string> {\n        return this.$onCodeChange.asObservable();\n    }\n\n    public getOnCodeValidityChangeObservable(): Observable<boolean> {\n        return this.$onCodeValidityChange.asObservable();\n    }\n\n    protected abstract setCoreEditorOptions(options: EditorOptions): void;\n    protected abstract highlightCode(markers: Marker[]): void;\n\n    protected notifyCoreFinishLoad(): void {\n        this.$onCoreFinishLoad.next();\n    }\n\n    protected notifyCodeChange(code: string): void {\n        const safeCode = this.getSafeCode(code);\n        if (safeCode !== this._lastCodeEmitted) {\n            this._lastCodeEmitted = safeCode;\n            this.$onCodeChange.next(safeCode);\n            this.validateCode(safeCode);\n        }\n    }\n\n    protected updateCompletionItems(items: string[]): void {\n        this._completionItems = items || [];\n        this.validateCode(this._lastCodeEmitted);\n    }\n\n    private setLinter(language: Languages): void {\n        this._linter = CoreLinters.getLinter(language) as LinterFacade;\n    }\n\n    private async validateCode(code: string): Promise<void> {\n        if (this._linter) {\n            const markers: Marker[] = await this._linter.lint(code, this._completionItems);\n            this.highlightCode(markers);\n            this.notifyCodeValidityChange(!markers.length);\n        }\n    }\n\n    private notifyCodeValidityChange(validity: boolean): void {\n        if (validity !== this._lastCodeValidityEmitted) {\n            this._lastCodeValidityEmitted = validity;\n            this.$onCodeValidityChange.next(validity);\n        }\n    }\n\n    private validateLanguage(language: Languages): void {\n        const languages = Object.values(Languages);\n        if (language && !languages.includes(language)) {\n            throw new Error(`The informed language \"${language}\" is not supported`);\n        }\n    }\n\n    private validateTheme(theme: Themes): void {\n        const themes = Object.values(Themes);\n        if (theme && !themes.includes(theme)) {\n            throw new Error(`The informed theme \"${theme}\" is not supported`);\n        }\n    }\n\n    private getSafeCode(code: string): string {\n        return typeof code === 'string' ? code : '';\n    }\n}\n"]}

package/esm2022/code-editor/lib/code-editor/core/facades/linter-facade.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGludGVyLWZhY2FkZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9jb2RlLWVkaXRvci9zcmMvbGliL2NvZGUtZWRpdG9yL2NvcmUvZmFjYWRlcy9saW50ZXItZmFjYWRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNYXJrZXIgfSBmcm9tIFwiLi4vbW9kZWxzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTGludGVyRmFjYWRlIHtcbiAgICBsaW50OiAoY29kZTogc3RyaW5nLCBjb21wbGV0aW9uSXRlbXM/OiBzdHJpbmdbXSkgPT4gUHJvbWlzZTxNYXJrZXJbXT47XG59XG4iXX0=

package/esm2022/code-editor/lib/code-editor/core/models/enums/marker-severity.mjs

@@ -0,0 +1,7 @@
+export var MarkerSeverity;
+(function (MarkerSeverity) {
+    MarkerSeverity[MarkerSeverity["Error"] = 0] = "Error";
+    MarkerSeverity[MarkerSeverity["Info"] = 1] = "Info";
+    MarkerSeverity[MarkerSeverity["Warning"] = 2] = "Warning";
+})(MarkerSeverity || (MarkerSeverity = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFya2VyLXNldmVyaXR5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL2NvZGUtZWRpdG9yL3NyYy9saWIvY29kZS1lZGl0b3IvY29yZS9tb2RlbHMvZW51bXMvbWFya2VyLXNldmVyaXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGNBSVg7QUFKRCxXQUFZLGNBQWM7SUFDdEIscURBQUssQ0FBQTtJQUNMLG1EQUFJLENBQUE7SUFDSix5REFBTyxDQUFBO0FBQ1gsQ0FBQyxFQUpXLGNBQWMsS0FBZCxjQUFjLFFBSXpCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gTWFya2VyU2V2ZXJpdHkge1xuICAgIEVycm9yLFxuICAgIEluZm8sXG4gICAgV2FybmluZ1xufVxuIl19

package/esm2022/code-editor/lib/code-editor/core/models/index.mjs

@@ -0,0 +1,5 @@
+/* Interfaces */
+export * from "./interfaces/marker";
+/* Enums */
+export * from "./enums/marker-severity";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvY29kZS1lZGl0b3Ivc3JjL2xpYi9jb2RlLWVkaXRvci9jb3JlL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxnQkFBZ0I7QUFDaEIsY0FBYyxxQkFBcUIsQ0FBQztBQUVwQyxXQUFXO0FBQ1gsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIEludGVyZmFjZXMgKi9cbmV4cG9ydCAqIGZyb20gXCIuL2ludGVyZmFjZXMvbWFya2VyXCI7XG5cbi8qIEVudW1zICovXG5leHBvcnQgKiBmcm9tIFwiLi9lbnVtcy9tYXJrZXItc2V2ZXJpdHlcIjtcbiJdfQ==

package/esm2022/code-editor/lib/code-editor/core/models/interfaces/marker.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFya2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL2NvZGUtZWRpdG9yL3NyYy9saWIvY29kZS1lZGl0b3IvY29yZS9tb2RlbHMvaW50ZXJmYWNlcy9tYXJrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1hcmtlclNldmVyaXR5IH0gZnJvbSBcIi4uL2luZGV4XCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWFya2VyIHtcbiAgICBzdGFydD86IG51bWJlcjtcbiAgICBlbmQ/OiBudW1iZXI7XG4gICAgc2V2ZXJpdHk6IE1hcmtlclNldmVyaXR5O1xuICAgIG1lc3NhZ2U6IHN0cmluZztcbn1cbiJdfQ==

package/esm2022/code-editor/lib/code-editor/core/use-cases/core-linters.mjs

@@ -0,0 +1,11 @@
+export class CoreLinters {
+    static _LINTERS = new Map([]);
+    static getLinter(language) {
+        const languageLinterFactory = CoreLinters._LINTERS.get(language);
+        if (languageLinterFactory) {
+            return languageLinterFactory();
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZS1saW50ZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL2NvZGUtZWRpdG9yL3NyYy9saWIvY29kZS1lZGl0b3IvY29yZS91c2UtY2FzZXMvY29yZS1saW50ZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLE1BQU0sT0FBTyxXQUFXO0lBRVosTUFBTSxDQUFVLFFBQVEsR0FBd0MsSUFBSSxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7SUFFN0UsTUFBTSxDQUFDLFNBQVMsQ0FBQyxRQUFtQjtRQUN2QyxNQUFNLHFCQUFxQixHQUFHLFdBQVcsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ2pFLElBQUkscUJBQXFCLEVBQUUsQ0FBQztZQUN4QixPQUFPLHFCQUFxQixFQUFFLENBQUM7UUFDbkMsQ0FBQztRQUNELE9BQU8sU0FBUyxDQUFDO0lBQ3JCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMYW5ndWFnZXMgfSBmcm9tIFwiLi4vLi4vbW9kZWxzXCI7XG5pbXBvcnQgeyBMaW50ZXJGYWNhZGUgfSBmcm9tIFwiLi4vZmFjYWRlcy9saW50ZXItZmFjYWRlXCI7XG5cbnR5cGUgTGludGVyRmFjYWRlRmFjdG9yeSA9ICgpID0+IExpbnRlckZhY2FkZTtcblxuZXhwb3J0IGNsYXNzIENvcmVMaW50ZXJzIHtcblxuICAgIHByaXZhdGUgc3RhdGljIHJlYWRvbmx5IF9MSU5URVJTOiBNYXA8TGFuZ3VhZ2VzLCBMaW50ZXJGYWNhZGVGYWN0b3J5PiA9IG5ldyBNYXAoW10pO1xuXG4gICAgcHVibGljIHN0YXRpYyBnZXRMaW50ZXIobGFuZ3VhZ2U6IExhbmd1YWdlcyk6IExpbnRlckZhY2FkZSB8IHVuZGVmaW5lZCB7XG4gICAgICAgIGNvbnN0IGxhbmd1YWdlTGludGVyRmFjdG9yeSA9IENvcmVMaW50ZXJzLl9MSU5URVJTLmdldChsYW5ndWFnZSk7XG4gICAgICAgIGlmIChsYW5ndWFnZUxpbnRlckZhY3RvcnkpIHtcbiAgICAgICAgICAgIHJldHVybiBsYW5ndWFnZUxpbnRlckZhY3RvcnkoKTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gdW5kZWZpbmVkO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/codemirror-6-core.mjs

@@ -0,0 +1,113 @@
+import { setDiagnostics } from '@codemirror/lint';
+import { EditorState, StateEffect } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { CoreFacade } from '../../../core/facades/core-facade';
+import { EditorLanguages } from './languages/editor-languages';
+import { EditorThemes } from './themes/editor-themes';
+import { convertMarkersToDiagnostics } from './utils';
+export class CodeMirror6Core extends CoreFacade {
+    static $onCompletionItemsUpdate = new Subject();
+    static _ngUnsubscribe = new Subject();
+    static _editorView = null;
+    /* These are necessary for the setCode and setEditorOptions can be called before view has been created */
+    _codeReceivedBeforeViewCreation = '';
+    _editorOptionsReceivedBeforeViewCreation = [];
+    constructor() {
+        super();
+    }
+    static getEditorView() {
+        return CodeMirror6Core._editorView;
+    }
+    static updateEditorView(...transactionSpecs) {
+        CodeMirror6Core._editorView?.dispatch(...transactionSpecs);
+    }
+    setCoreWrapperElement(element) {
+        this.createEditorView(element);
+    }
+    setCode(code) {
+        this.changeEditorContent(code);
+    }
+    initCore() {
+        this.setObservablesListeners();
+    }
+    destroyCore() {
+        this._codeReceivedBeforeViewCreation = '';
+        CodeMirror6Core._editorView = null;
+        CodeMirror6Core._ngUnsubscribe.next();
+        CodeMirror6Core._ngUnsubscribe.complete();
+    }
+    setCoreEditorOptions(options) {
+        const language = EditorLanguages.getLanguage(options.language);
+        const theme = EditorThemes.getTheme(options.theme);
+        if (CodeMirror6Core._editorView) {
+            CodeMirror6Core.updateEditorView({
+                effects: StateEffect.reconfigure.of([language, theme, this.getCodeChangeListenerExtension()]),
+            });
+        }
+        else {
+            this._editorOptionsReceivedBeforeViewCreation = [language, theme];
+        }
+    }
+    highlightCode(markers) {
+        const diagnostics = convertMarkersToDiagnostics(markers, CodeMirror6Core._editorView?.state.doc.length);
+        CodeMirror6Core.updateEditorView(setDiagnostics(CodeMirror6Core._editorView?.state, diagnostics));
+    }
+    setObservablesListeners() {
+        CodeMirror6Core.$onCompletionItemsUpdate
+            .pipe(takeUntil(CodeMirror6Core._ngUnsubscribe))
+            .subscribe((items) => this.updateCompletionItems(items));
+    }
+    createEditorView(parentElement) {
+        CodeMirror6Core._editorView = new EditorView({
+            parent: parentElement,
+            state: EditorState.create({
+                doc: this._codeReceivedBeforeViewCreation,
+                extensions: [this._editorOptionsReceivedBeforeViewCreation, this.getCodeChangeListenerExtension()],
+            }),
+        });
+        this.notifyCoreFinishLoad();
+    }
+    getCodeChangeListenerExtension() {
+        return EditorView.updateListener.of((update) => update.docChanged && this.notifyCodeChange(update.state.doc.toString()));
+    }
+    changeEditorContent(code) {
+        if (CodeMirror6Core._editorView) {
+            CodeMirror6Core.updateEditorView({
+                changes: {
+                    from: 0,
+                    to: CodeMirror6Core._editorView.state.doc.length,
+                    insert: code,
+                },
+            });
+        }
+        else {
+            this._codeReceivedBeforeViewCreation = code;
+        }
+    }
+    setCodeWithCursorPreservation(code) {
+        if (CodeMirror6Core._editorView) {
+            const currentCode = CodeMirror6Core._editorView.state.doc.toString();
+            // Só atualiza se o conteúdo for realmente diferente
+            if (currentCode !== code) {
+                const currentSelection = CodeMirror6Core._editorView.state.selection.main;
+                CodeMirror6Core.updateEditorView({
+                    changes: {
+                        from: 0,
+                        to: CodeMirror6Core._editorView.state.doc.length,
+                        insert: code,
+                    },
+                    selection: {
+                        anchor: Math.min(currentSelection.anchor, code.length),
+                        head: Math.min(currentSelection.head, code.length),
+                    },
+                });
+            }
+        }
+        else {
+            this._codeReceivedBeforeViewCreation = code;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codemirror-6-core.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-components/code-editor/src/lib/code-editor/infra/cores/codemirror-6/codemirror-6-core.ts"],"names":[],"mappings":"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","sourcesContent":["import { setDiagnostics } from '@codemirror/lint';\nimport { EditorState, Extension, StateEffect, TransactionSpec } from '@codemirror/state';\nimport { EditorView } from '@codemirror/view';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { CoreFacade } from '../../../core/facades/core-facade';\nimport { Marker } from '../../../core/models';\nimport { EditorOptions, Languages, Themes } from '../../../models';\nimport { EditorLanguages } from './languages/editor-languages';\nimport { EditorThemes } from './themes/editor-themes';\nimport { convertMarkersToDiagnostics } from './utils';\n\nexport class CodeMirror6Core extends CoreFacade {\n    public static readonly $onCompletionItemsUpdate: Subject<string[]> = new Subject();\n    private static readonly _ngUnsubscribe: Subject<void> = new Subject();\n    private static _editorView: EditorView | null = null;\n\n    /* These are necessary for the setCode and setEditorOptions can be called before view has been created */\n    private _codeReceivedBeforeViewCreation = '';\n    private _editorOptionsReceivedBeforeViewCreation: Extension = [];\n\n    constructor() {\n        super();\n    }\n\n    public static getEditorView(): EditorView {\n        return CodeMirror6Core._editorView as EditorView;\n    }\n\n    public static updateEditorView(...transactionSpecs: TransactionSpec[]): void {\n        CodeMirror6Core._editorView?.dispatch(...transactionSpecs);\n    }\n\n    public setCoreWrapperElement(element: HTMLDivElement): void {\n        this.createEditorView(element);\n    }\n\n    public setCode(code: string): void {\n        this.changeEditorContent(code);\n    }\n\n    public initCore(): void {\n        this.setObservablesListeners();\n    }\n\n    public destroyCore(): void {\n        this._codeReceivedBeforeViewCreation = '';\n        CodeMirror6Core._editorView = null;\n        CodeMirror6Core._ngUnsubscribe.next();\n        CodeMirror6Core._ngUnsubscribe.complete();\n    }\n\n    protected setCoreEditorOptions(options: EditorOptions): void {\n        const language = EditorLanguages.getLanguage(options.language as Languages);\n        const theme = EditorThemes.getTheme(options.theme as Themes);\n\n        if (CodeMirror6Core._editorView) {\n            CodeMirror6Core.updateEditorView({\n                effects: StateEffect.reconfigure.of([language, theme, this.getCodeChangeListenerExtension()]),\n            });\n        } else {\n            this._editorOptionsReceivedBeforeViewCreation = [language, theme];\n        }\n    }\n\n    protected highlightCode(markers: Marker[]): void {\n        const diagnostics = convertMarkersToDiagnostics(\n            markers,\n            CodeMirror6Core._editorView?.state.doc.length as number,\n        );\n\n        CodeMirror6Core.updateEditorView(\n            setDiagnostics(CodeMirror6Core._editorView?.state as EditorState, diagnostics),\n        );\n    }\n\n    private setObservablesListeners(): void {\n        CodeMirror6Core.$onCompletionItemsUpdate\n            .pipe(takeUntil(CodeMirror6Core._ngUnsubscribe))\n            .subscribe((items) => this.updateCompletionItems(items));\n    }\n\n    private createEditorView(parentElement: HTMLElement): void {\n        CodeMirror6Core._editorView = new EditorView({\n            parent: parentElement,\n            state: EditorState.create({\n                doc: this._codeReceivedBeforeViewCreation,\n                extensions: [this._editorOptionsReceivedBeforeViewCreation, this.getCodeChangeListenerExtension()],\n            }),\n        });\n\n        this.notifyCoreFinishLoad();\n    }\n\n    private getCodeChangeListenerExtension(): Extension {\n        return EditorView.updateListener.of(\n            (update) => update.docChanged && this.notifyCodeChange(update.state.doc.toString()),\n        );\n    }\n\n    private changeEditorContent(code: string): void {\n        if (CodeMirror6Core._editorView) {\n            CodeMirror6Core.updateEditorView({\n                changes: {\n                    from: 0,\n                    to: CodeMirror6Core._editorView.state.doc.length,\n                    insert: code,\n                },\n            });\n        } else {\n            this._codeReceivedBeforeViewCreation = code;\n        }\n    }\n\n    protected setCodeWithCursorPreservation(code: string): void {\n        if (CodeMirror6Core._editorView) {\n            const currentCode = CodeMirror6Core._editorView.state.doc.toString();\n\n            // Só atualiza se o conteúdo for realmente diferente\n            if (currentCode !== code) {\n                const currentSelection = CodeMirror6Core._editorView.state.selection.main;\n\n                CodeMirror6Core.updateEditorView({\n                    changes: {\n                        from: 0,\n                        to: CodeMirror6Core._editorView.state.doc.length,\n                        insert: code,\n                    },\n                    selection: {\n                        anchor: Math.min(currentSelection.anchor, code.length),\n                        head: Math.min(currentSelection.head, code.length),\n                    },\n                });\n            }\n        } else {\n            this._codeReceivedBeforeViewCreation = code;\n        }\n    }\n}\n"]}

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/editor-languages.mjs

@@ -0,0 +1,17 @@
+import { Languages } from "../../../../models";
+/* Languages */
+import { TaxCalculation } from "./tax-calculation/tax-calculation.language";
+import { Json } from "./json/json.language";
+export class EditorLanguages {
+    static _LANGUAGES = new Map([
+        [Languages.TaxCalculation, TaxCalculation],
+        [Languages.Json, Json]
+    ]);
+    static getLanguage(language) {
+        const languageSupportFactory = EditorLanguages._LANGUAGES.get(language);
+        if (languageSupportFactory)
+            return languageSupportFactory();
+        return [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/json/json.language.mjs

@@ -0,0 +1,67 @@
+import { LanguageSupport, LRLanguage } from "@codemirror/language";
+import { buildParser } from "@lezer/generator";
+import { styleTags, tags } from "@codemirror/highlight";
+const jsonGrammar = `
+@top JsonDocument { JsonValue }
+
+JsonValue {
+    JsonObject |
+    JsonArray |
+    JsonString |
+    JsonNumber |
+    JsonBoolean |
+    JsonNull
+}
+
+JsonObject {
+    "{" (JsonPair ("," JsonPair)*)? "}"
+}
+
+JsonPair {
+    JsonString ":" JsonValue
+}
+
+JsonArray {
+    "[" (JsonValue ("," JsonValue)*)? "]"
+}
+
+@tokens {
+    JsonString { '"' (![\\n"])* '"'? }
+    JsonNumber {
+        '-'? std.digit+
+        ('.' std.digit+)?
+        (("e" | "E") ("+" | "-")? std.digit+)?
+    }
+    JsonBoolean { "true" | "false" }
+    JsonNull { "null" }
+    space { $[ \t\n\r]+ }
+    "{" "}"
+    "[" "]"
+    ":" ","
+}
+
+@skip { space }
+
+@detectDelim
+`;
+const jsonLanguage = LRLanguage.define({
+    parser: buildParser(jsonGrammar).configure({
+        props: [
+            styleTags({
+                JsonString: tags.string,
+                JsonNumber: tags.number,
+                "JsonBoolean JsonNull": tags.keyword,
+                '"{"': tags.brace,
+                '"}"': tags.brace,
+                '"["': tags.brace,
+                '"]"': tags.brace,
+                '":"': tags.operator,
+                '","': tags.punctuation,
+            }),
+        ],
+    }),
+});
+export function Json() {
+    return new LanguageSupport(jsonLanguage);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/autocomplete-empty-state.mjs

@@ -0,0 +1,29 @@
+import { CustomTranslationsService } from "../../../../../../../utils";
+import { autocompleteStateWrapper, showAutocompleteStateWrapper } from "./autocomplete-state-wrapper/autocomplete-state-wrapper";
+let autocompleteEmptyStateHTMLElement;
+/**
+ * Adds an empty-state over the autocomplete
+ * @returns An extension containing everything needed to add the empty-state
+ */
+export 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
+ */
+export function showAutocompleteEmptyState() {
+    if (!autocompleteEmptyStateHTMLElement) {
+        autocompleteEmptyStateHTMLElement = getAutocompleteEmptyStateHTMLElement();
+    }
+    showAutocompleteStateWrapper(autocompleteEmptyStateHTMLElement);
+}
+function getAutocompleteEmptyStateHTMLElement() {
+    const emptyStateSpanWrapper = document.createElement("span");
+    emptyStateSpanWrapper.innerText = CustomTranslationsService.translate("core_language_tax_calculation_no_suggestions");
+    return emptyStateSpanWrapper;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/autocomplete-loading-state.mjs

@@ -0,0 +1,29 @@
+import { CustomTranslationsService } from "../../../../../../../utils";
+import { autocompleteStateWrapper, showAutocompleteStateWrapper } from "./autocomplete-state-wrapper/autocomplete-state-wrapper";
+let autocompleteLoadingStateHTMLElement;
+/**
+ * Adds a loading-state over the autocomplete
+ * @returns An extension containing everything needed to add the loading-state
+ */
+export 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
+ */
+export function showAutocompleteLoadingState() {
+    if (!autocompleteLoadingStateHTMLElement) {
+        autocompleteLoadingStateHTMLElement = getAutocompleteLoadingStateHTMLElement();
+    }
+    showAutocompleteStateWrapper(autocompleteLoadingStateHTMLElement);
+}
+function getAutocompleteLoadingStateHTMLElement() {
+    const loadingStateSpanWrapper = document.createElement("span");
+    loadingStateSpanWrapper.innerText = CustomTranslationsService.translate("core_language_tax_calculation_fetching_suggestions");
+    return loadingStateSpanWrapper;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/autocomplete-state-wrapper/autocomplete-state-wrapper-style.mjs

@@ -0,0 +1,17 @@
+import { EditorView } from "@codemirror/view";
+/**
+ * Adds style to autocomplete's state-wrapper
+ * @returns An extension containing the style
+ */
+export 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",
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLXN0YXRlLXdyYXBwZXItc3R5bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvY29kZS1lZGl0b3Ivc3JjL2xpYi9jb2RlLWVkaXRvci9pbmZyYS9jb3Jlcy9jb2RlbWlycm9yLTYvbGFuZ3VhZ2VzL3RheC1jYWxjdWxhdGlvbi9leHRlbnNpb25zL2F1dG9jb21wbGV0ZS9hdXRvY29tcGxldGUtc3RhdGVzL2F1dG9jb21wbGV0ZS1zdGF0ZS13cmFwcGVyL2F1dG9jb21wbGV0ZS1zdGF0ZS13cmFwcGVyLXN0eWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU5Qzs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsS0FBSztJQUNqQixPQUFPLFVBQVUsQ0FBQyxLQUFLLENBQUM7UUFDcEIsK0NBQStDLEVBQUU7WUFDN0MsU0FBUyxFQUFFLG1CQUFtQjtTQUNqQztRQUVELCtDQUErQyxFQUFFO1lBQzdDLE1BQU0sRUFBRSxvQkFBb0I7WUFDNUIsYUFBYSxFQUFFLG9CQUFvQjtTQUN0QztLQUNKLENBQUMsQ0FBQztBQUNQLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFeHRlbnNpb24gfSBmcm9tIFwiQGNvZGVtaXJyb3Ivc3RhdGVcIjtcbmltcG9ydCB7IEVkaXRvclZpZXcgfSBmcm9tIFwiQGNvZGVtaXJyb3Ivdmlld1wiO1xuXG4vKipcbiAqIEFkZHMgc3R5bGUgdG8gYXV0b2NvbXBsZXRlJ3Mgc3RhdGUtd3JhcHBlclxuICogQHJldHVybnMgQW4gZXh0ZW5zaW9uIGNvbnRhaW5pbmcgdGhlIHN0eWxlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzdHlsZSgpOiBFeHRlbnNpb24ge1xuICAgIHJldHVybiBFZGl0b3JWaWV3LnRoZW1lKHtcbiAgICAgICAgXCIucy1jb2RlLWVkaXRvci10YXhDYWxjdWxhdGlvbi1hdXRvY29tcGxldGUtdWxcIjoge1xuICAgICAgICAgICAgXCJwYWRkaW5nXCI6IFwiLjc1cmVtICFpbXBvcnRhbnRcIixcbiAgICAgICAgfSxcblxuICAgICAgICBcIi5zLWNvZGUtZWRpdG9yLXRheENhbGN1bGF0aW9uLWF1dG9jb21wbGV0ZS1saVwiOiB7XG4gICAgICAgICAgICBjdXJzb3I6IFwiZGVmYXVsdCAhaW1wb3J0YW50XCIsXG4gICAgICAgICAgICBcImxpbmUtaGVpZ2h0XCI6IFwiMS4zNzVlbSAhaW1wb3J0YW50XCIsXG4gICAgICAgIH0sXG4gICAgfSk7XG59XG4iXX0=

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/autocomplete-state-wrapper/autocomplete-state-wrapper.mjs

@@ -0,0 +1,77 @@
+import { StateField } from '@codemirror/state';
+import { showTooltip } from '@codemirror/tooltip';
+import { CodeMirror6Core } from '../../../../../../codemirror-6-core';
+import { style } from './autocomplete-state-wrapper-style';
+let 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
+ */
+export 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
+ */
+export function showAutocompleteStateWrapper(element) {
+    htmlElementToBeWrapped = element;
+    CodeMirror6Core.updateEditorView();
+}
+/**
+ * Removes a possible showed autocomplete state
+ */
+export 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(_, transaction) {
+            return getAutocompleteStateWrapper(transaction.state);
+        },
+        provide(field) {
+            return showTooltip.compute([field], state => 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 undefined;
+    }
+    const htmlElementToBeWrappedString = htmlElementToBeWrapped.outerHTML;
+    const stateWrapper = {
+        pos: state.selection.ranges[0].head,
+        create: () => ({ dom: getAutocompleteStateWrapperDomElement(htmlElementToBeWrappedString) })
+    };
+    htmlElementToBeWrapped = null;
+    return stateWrapper;
+}
+function getAutocompleteStateWrapperDomElement(elementToBeWrappedString) {
+    const wrapperDiv = document.createElement('div');
+    wrapperDiv.className = 'cm-tooltip-autocomplete cm-tooltip';
+    wrapperDiv.innerHTML =
+        `
+        <ul class="s-code-editor-taxCalculation-autocomplete-ul">
+            <li class="s-code-editor-taxCalculation-autocomplete-li">
+                ${elementToBeWrappedString}
+            </li>
+        </ul>
+
+    `;
+    return wrapperDiv;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLXN0YXRlLXdyYXBwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvY29kZS1lZGl0b3Ivc3JjL2xpYi9jb2RlLWVkaXRvci9pbmZyYS9jb3Jlcy9jb2RlbWlycm9yLTYvbGFuZ3VhZ2VzL3RheC1jYWxjdWxhdGlvbi9leHRlbnNpb25zL2F1dG9jb21wbGV0ZS9hdXRvY29tcGxldGUtc3RhdGVzL2F1dG9jb21wbGV0ZS1zdGF0ZS13cmFwcGVyL2F1dG9jb21wbGV0ZS1zdGF0ZS13cmFwcGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFHSCxVQUFVLEVBQ2IsTUFBTSxtQkFBbUIsQ0FBQztBQUMzQixPQUFPLEVBQUUsV0FBVyxFQUFXLE1BQU0scUJBQXFCLENBQUM7QUFFM0QsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUUzRCxJQUFJLHNCQUFzQixHQUF1QixJQUFJLENBQUM7QUFFdEQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLHdCQUF3QjtJQUNwQyxPQUFPO1FBQ0gsa0NBQWtDLEVBQUU7UUFDcEMsS0FBSyxFQUFFO0tBQ1YsQ0FBQztBQUNOLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsNEJBQTRCLENBQUMsT0FBb0I7SUFDN0Qsc0JBQXNCLEdBQUcsT0FBTyxDQUFDO0lBQ2pDLGVBQWUsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0FBQ3ZDLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSw0QkFBNEI7SUFDeEMsc0JBQXNCLEdBQUcsSUFBSSxDQUFDO0lBQzlCLGVBQWUsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0FBQ3ZDLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxTQUFTLGtDQUFrQztJQUN2QyxPQUFPLFVBQVUsQ0FBQyxNQUFNLENBQUM7UUFDckIsTUFBTSxFQUFFLDJCQUEyQjtRQUNuQyxNQUFNLENBQUMsQ0FBQyxFQUFFLFdBQVc7WUFDakIsT0FBTywyQkFBMkIsQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDMUQsQ0FBQztRQUNELE9BQU8sQ0FBQyxLQUFVO1lBQ2QsT0FBTyxXQUFXLENBQUMsT0FBTyxDQUN0QixDQUFDLEtBQUssQ0FBQyxFQUNQLEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FDOUIsQ0FBQztRQUNOLENBQUM7S0FDSixDQUFDLENBQUM7QUFDUCxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILFNBQVMsMkJBQTJCLENBQUMsS0FBa0I7SUFDbkQsSUFBSSxDQUFDLHNCQUFzQixFQUFFLENBQUM7UUFDMUIsT0FBTyxTQUFTLENBQUM7SUFDckIsQ0FBQztJQUVELE1BQU0sNEJBQTRCLEdBQUcsc0JBQXNCLENBQUMsU0FBUyxDQUFDO0lBQ3RFLE1BQU0sWUFBWSxHQUFZO1FBQzFCLEdBQUcsRUFBRSxLQUFLLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJO1FBQ25DLE1BQU0sRUFBRSxHQUFHLEVBQUUsQ0FBQyxDQUFDLEVBQUUsR0FBRyxFQUFFLHFDQUFxQyxDQUFDLDRCQUE0QixDQUFDLEVBQUUsQ0FBQztLQUMvRixDQUFDO0lBRUYsc0JBQXNCLEdBQUcsSUFBSSxDQUFDO0lBQzlCLE9BQU8sWUFBWSxDQUFDO0FBQ3hCLENBQUM7QUFFRCxTQUFTLHFDQUFxQyxDQUFDLHdCQUFnQztJQUMzRSxNQUFNLFVBQVUsR0FBRyxRQUFRLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2pELFVBQVUsQ0FBQyxTQUFTLEdBQUcsb0NBQW9DLENBQUM7SUFDNUQsVUFBVSxDQUFDLFNBQVM7UUFDaEI7OztrQkFHVSx3QkFBd0I7Ozs7S0FJckMsQ0FBQztJQUVGLE9BQU8sVUFBVSxDQUFDO0FBQ3RCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICAgIEVkaXRvclN0YXRlLFxuICAgIEV4dGVuc2lvbixcbiAgICBTdGF0ZUZpZWxkXG59IGZyb20gJ0Bjb2RlbWlycm9yL3N0YXRlJztcbmltcG9ydCB7IHNob3dUb29sdGlwLCBUb29sdGlwIH0gZnJvbSAnQGNvZGVtaXJyb3IvdG9vbHRpcCc7XG5cbmltcG9ydCB7IENvZGVNaXJyb3I2Q29yZSB9IGZyb20gJy4uLy4uLy4uLy4uLy4uLy4uL2NvZGVtaXJyb3ItNi1jb3JlJztcbmltcG9ydCB7IHN0eWxlIH0gZnJvbSAnLi9hdXRvY29tcGxldGUtc3RhdGUtd3JhcHBlci1zdHlsZSc7XG5cbmxldCBodG1sRWxlbWVudFRvQmVXcmFwcGVkOiBIVE1MRWxlbWVudCB8IG51bGwgPSBudWxsO1xuXG4vKipcbiAqIEFkZHMgYSB2aWV3IHVwZGF0ZXMncyBsaXN0ZW5lciB0aGF0IGNyZWF0ZXMgYW4gc3RhdGUgb3ZlciB0aGUgYXV0b2NvbXBsZXRlXG4gKiBAcmV0dXJucyBBbiBleHRlbnNpb24gY29udGFpbmluZyBldmVyeXRoaW5nIG5lZWRlZCB0byBsaXN0ZW4gdGhlIHVwZGF0ZXMgYW5kIGNyZWF0ZSB0aGUgYXV0b2NvbXBsZXRlJ3Mgc3RhdGVcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGF1dG9jb21wbGV0ZVN0YXRlV3JhcHBlcigpOiBFeHRlbnNpb24ge1xuICAgIHJldHVybiBbXG4gICAgICAgIGF1dG9jb21wbGV0ZVN0YXRlV3JhcHBlclN0YXRlRmllbGQoKSxcbiAgICAgICAgc3R5bGUoKVxuICAgIF07XG59XG5cbi8qKlxuICogU2hvd3MgYSBzdGF0ZSBvbiBhIG5vbi1jbGlja2FibGUgYXV0b2NvbXBsZXRlIGl0ZW0ncyBmb3JtYXQgd2l0aCBhbiBIVE1MRWxlbWVudCBpbnNpZGVcbiAqIEBwYXJhbSBlbGVtZW50IFRoZSBIVE1MRWxlbWVudCB0byBzaG93IGluc2lkZSB0aGUgc3RhdGVcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNob3dBdXRvY29tcGxldGVTdGF0ZVdyYXBwZXIoZWxlbWVudDogSFRNTEVsZW1lbnQpOiB2b2lkIHtcbiAgICBodG1sRWxlbWVudFRvQmVXcmFwcGVkID0gZWxlbWVudDtcbiAgICBDb2RlTWlycm9yNkNvcmUudXBkYXRlRWRpdG9yVmlldygpO1xufVxuXG4vKipcbiAqIFJlbW92ZXMgYSBwb3NzaWJsZSBzaG93ZWQgYXV0b2NvbXBsZXRlIHN0YXRlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBoaWRlQXV0b2NvbXBsZXRlU3RhdGVXcmFwcGVyKCk6IHZvaWQge1xuICAgIGh0bWxFbGVtZW50VG9CZVdyYXBwZWQgPSBudWxsO1xuICAgIENvZGVNaXJyb3I2Q29yZS51cGRhdGVFZGl0b3JWaWV3KCk7XG59XG5cbi8qXG4gKiBDcmVhdGVzIGFuZCByZXR1cm5zIGEgU3RhdGVGaWVsZCByZXNwb25zaWJsZSBmb3IgbGlzdGVuaW5nIHRoZSB2aWV3J3MgY2hhbmdlIGFuZCB0byBhZGQgdGhlIGF1dG9jb21wbGV0ZVxuICogc3RhdGUncyB3cmFwcGVyXG4gKi9cbmZ1bmN0aW9uIGF1dG9jb21wbGV0ZVN0YXRlV3JhcHBlclN0YXRlRmllbGQoKTogU3RhdGVGaWVsZDxUb29sdGlwPiB7XG4gICAgcmV0dXJuIFN0YXRlRmllbGQuZGVmaW5lKHtcbiAgICAgICAgY3JlYXRlOiBnZXRBdXRvY29tcGxldGVTdGF0ZVdyYXBwZXIsXG4gICAgICAgIHVwZGF0ZShfLCB0cmFuc2FjdGlvbikge1xuICAgICAgICAgICAgcmV0dXJuIGdldEF1dG9jb21wbGV0ZVN0YXRlV3JhcHBlcih0cmFuc2FjdGlvbi5zdGF0ZSk7XG4gICAgICAgIH0sXG4gICAgICAgIHByb3ZpZGUoZmllbGQ6IGFueSkge1xuICAgICAgICAgICAgcmV0dXJuIHNob3dUb29sdGlwLmNvbXB1dGUoXG4gICAgICAgICAgICAgICAgW2ZpZWxkXSxcbiAgICAgICAgICAgICAgICBzdGF0ZSA9PiBzdGF0ZS5maWVsZChmaWVsZCksXG4gICAgICAgICAgICApO1xuICAgICAgICB9XG4gICAgfSk7XG59XG5cbi8qXG4gKiBGdW5jdGlvbiByZXNwb25zaWJsZSBmb3IgY3JlYXRpbmcgdGhlIHN0YXRlJ3Mgd3JhcHBlciBhbmQgcmV0dXJuaW5nIHRoZSBzYW1lIGFzIGEgVG9vbHRpcCBmcm9tIFwiQGNvZGVtaXJyb3IvdG9vbHRpcFwiO1xuICogT25seSBjcmVhdGVzIHRoZSBUb29sdGlwIGlmIHRoZSB0aGVyZXMgaXMgZWxlbWVudCBvbiB0aGUgXCJodG1sRWxlbWVudFRvQmVXcmFwcGVkXCIgdmFyaWFibGU7XG4gKiBUaGUgc2FtZSB3aWxsIGFsc28gYmUgcmVtb3ZlZCB3aGVuIGFueSB2aWV3IHVwZGF0ZSBpcyBlbWl0dGVkO1xuICovXG5mdW5jdGlvbiBnZXRBdXRvY29tcGxldGVTdGF0ZVdyYXBwZXIoc3RhdGU6IEVkaXRvclN0YXRlKTogVG9vbHRpcCB8IHVuZGVmaW5lZCB7XG4gICAgaWYgKCFodG1sRWxlbWVudFRvQmVXcmFwcGVkKSB7XG4gICAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgfVxuXG4gICAgY29uc3QgaHRtbEVsZW1lbnRUb0JlV3JhcHBlZFN0cmluZyA9IGh0bWxFbGVtZW50VG9CZVdyYXBwZWQub3V0ZXJIVE1MO1xuICAgIGNvbnN0IHN0YXRlV3JhcHBlcjogVG9vbHRpcCA9IHtcbiAgICAgICAgcG9zOiBzdGF0ZS5zZWxlY3Rpb24ucmFuZ2VzWzBdLmhlYWQsXG4gICAgICAgIGNyZWF0ZTogKCkgPT4gKHsgZG9tOiBnZXRBdXRvY29tcGxldGVTdGF0ZVdyYXBwZXJEb21FbGVtZW50KGh0bWxFbGVtZW50VG9CZVdyYXBwZWRTdHJpbmcpIH0pXG4gICAgfTtcblxuICAgIGh0bWxFbGVtZW50VG9CZVdyYXBwZWQgPSBudWxsO1xuICAgIHJldHVybiBzdGF0ZVdyYXBwZXI7XG59XG5cbmZ1bmN0aW9uIGdldEF1dG9jb21wbGV0ZVN0YXRlV3JhcHBlckRvbUVsZW1lbnQoZWxlbWVudFRvQmVXcmFwcGVkU3RyaW5nOiBzdHJpbmcpOiBIVE1MRWxlbWVudCB7XG4gICAgY29uc3Qgd3JhcHBlckRpdiA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpO1xuICAgIHdyYXBwZXJEaXYuY2xhc3NOYW1lID0gJ2NtLXRvb2x0aXAtYXV0b2NvbXBsZXRlIGNtLXRvb2x0aXAnO1xuICAgIHdyYXBwZXJEaXYuaW5uZXJIVE1MID1cbiAgICAgICAgYFxuICAgICAgICA8dWwgY2xhc3M9XCJzLWNvZGUtZWRpdG9yLXRheENhbGN1bGF0aW9uLWF1dG9jb21wbGV0ZS11bFwiPlxuICAgICAgICAgICAgPGxpIGNsYXNzPVwicy1jb2RlLWVkaXRvci10YXhDYWxjdWxhdGlvbi1hdXRvY29tcGxldGUtbGlcIj5cbiAgICAgICAgICAgICAgICAke2VsZW1lbnRUb0JlV3JhcHBlZFN0cmluZ31cbiAgICAgICAgICAgIDwvbGk+XG4gICAgICAgIDwvdWw+XG5cbiAgICBgO1xuXG4gICAgcmV0dXJuIHdyYXBwZXJEaXY7XG59XG4iXX0=

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/index.mjs

@@ -0,0 +1,4 @@
+export * from "./autocomplete-state-wrapper/autocomplete-state-wrapper";
+export * from "./autocomplete-loading-state";
+export * from "./autocomplete-empty-state";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvY29kZS1lZGl0b3Ivc3JjL2xpYi9jb2RlLWVkaXRvci9pbmZyYS9jb3Jlcy9jb2RlbWlycm9yLTYvbGFuZ3VhZ2VzL3RheC1jYWxjdWxhdGlvbi9leHRlbnNpb25zL2F1dG9jb21wbGV0ZS9hdXRvY29tcGxldGUtc3RhdGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseURBQXlELENBQUM7QUFDeEUsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYXV0b2NvbXBsZXRlLXN0YXRlLXdyYXBwZXIvYXV0b2NvbXBsZXRlLXN0YXRlLXdyYXBwZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2F1dG9jb21wbGV0ZS1sb2FkaW5nLXN0YXRlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9hdXRvY29tcGxldGUtZW1wdHktc3RhdGVcIjtcbiJdfQ==