@seniorsistemas/angular-components 17.31.2-feature-sds-110-234267aa → 17.31.3

package/esm2015/components/code-editor/infra/cores/codemirror-6/codemirror-6-core.js

@@ -0,0 +1,120 @@
+import { EditorView } from "@codemirror/view";
+import { EditorState, StateEffect } from "@codemirror/state";
+import { setDiagnostics } from "@codemirror/lint";
+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 {
+    constructor() {
+        super();
+        /* These are necessary for the setCode and setEditorOptions can be called before view has been created */
+        this._codeReceivedBeforeViewCreation = "";
+        this._editorOptionsReceivedBeforeViewCreation = [];
+    }
+    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;
+        }
+    }
+}
+CodeMirror6Core.$onCompletionItemsUpdate = new Subject();
+CodeMirror6Core._ngUnsubscribe = new Subject();
+CodeMirror6Core._editorView = null;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codemirror-6-core.js","sourceRoot":"ng://@seniorsistemas/angular-components/","sources":["components/code-editor/infra/cores/codemirror-6/codemirror-6-core.ts"],"names":[],"mappings":"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","sourcesContent":["import { EditorView } from \"@codemirror/view\";\nimport {\n    EditorState,\n    StateEffect,\n    Extension,\n    TransactionSpec\n} from \"@codemirror/state\";\nimport { setDiagnostics } from \"@codemirror/lint\";\nimport { Subject } from \"rxjs\";\nimport { takeUntil } from \"rxjs/operators\";\n\nimport { CoreFacade } from \"../../../core/facades/core-facade\";\nimport { Marker } from \"../../../core/models\";\nimport { EditorOptions } 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\n    public static $onCompletionItemsUpdate: Subject<string[]> = new Subject();\n    private static _ngUnsubscribe: Subject<void> = new Subject();\n    private static _editorView: EditorView = 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;\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);\n        const theme = EditorThemes.getTheme(options.theme);\n\n        if (CodeMirror6Core._editorView) {\n            CodeMirror6Core.updateEditorView({\n                effects: StateEffect.reconfigure.of([\n                    language,\n                    theme,\n                    this.getCodeChangeListenerExtension()\n                ])\n            });\n        } else {\n            this._editorOptionsReceivedBeforeViewCreation = [language, theme];\n        }\n    }\n\n    protected highlightCode(markers: Marker[]): void {\n        const diagnostics = convertMarkersToDiagnostics(markers, CodeMirror6Core._editorView.state.doc.length);\n        CodeMirror6Core.updateEditorView(setDiagnostics(CodeMirror6Core._editorView.state, diagnostics));\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: [\n                    this._editorOptionsReceivedBeforeViewCreation,\n                    this.getCodeChangeListenerExtension()\n                ]\n            })\n        });\n\n        this.notifyCoreFinishLoad();\n    }\n\n    private getCodeChangeListenerExtension(): Extension {\n        return EditorView.updateListener.of(update => update.docChanged && this.notifyCodeChange(update.state.doc.toString()));\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}\n"]}

package/esm2015/components/code-editor/infra/cores/codemirror-6/languages/editor-languages.js

@@ -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 getLanguage(language) {
+        const languageSupportFactory = EditorLanguages._LANGUAGES.get(language);
+        if (languageSupportFactory)
+            return languageSupportFactory();
+        return [];
+    }
+}
+EditorLanguages._LANGUAGES = new Map([
+    [Languages.TaxCalculation, TaxCalculation],
+    [Languages.Json, Json]
+]);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/code-editor/infra/cores/codemirror-6/languages/json/json.language.js

@@ -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/esm2015/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/autocomplete-empty-state.js

@@ -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/esm2015/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/autocomplete-loading-state.js

@@ -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/esm2015/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/autocomplete-state-wrapper/autocomplete-state-wrapper-style.js

@@ -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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLXN0YXRlLXdyYXBwZXItc3R5bGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yc2lzdGVtYXMvYW5ndWxhci1jb21wb25lbnRzLyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9jb2RlLWVkaXRvci9pbmZyYS9jb3Jlcy9jb2RlbWlycm9yLTYvbGFuZ3VhZ2VzL3RheC1jYWxjdWxhdGlvbi9leHRlbnNpb25zL2F1dG9jb21wbGV0ZS9hdXRvY29tcGxldGUtc3RhdGVzL2F1dG9jb21wbGV0ZS1zdGF0ZS13cmFwcGVyL2F1dG9jb21wbGV0ZS1zdGF0ZS13cmFwcGVyLXN0eWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU5Qzs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsS0FBSztJQUNqQixPQUFPLFVBQVUsQ0FBQyxLQUFLLENBQUM7UUFDcEIsK0NBQStDLEVBQUU7WUFDN0MsU0FBUyxFQUFFLG1CQUFtQjtTQUNqQztRQUVELCtDQUErQyxFQUFFO1lBQzdDLE1BQU0sRUFBRSxvQkFBb0I7WUFDNUIsYUFBYSxFQUFFLG9CQUFvQjtTQUN0QztLQUNKLENBQUMsQ0FBQztBQUNQLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFeHRlbnNpb24gfSBmcm9tIFwiQGNvZGVtaXJyb3Ivc3RhdGVcIjtcbmltcG9ydCB7IEVkaXRvclZpZXcgfSBmcm9tIFwiQGNvZGVtaXJyb3Ivdmlld1wiO1xuXG4vKipcbiAqIEFkZHMgc3R5bGUgdG8gYXV0b2NvbXBsZXRlJ3Mgc3RhdGUtd3JhcHBlclxuICogQHJldHVybnMgQW4gZXh0ZW5zaW9uIGNvbnRhaW5pbmcgdGhlIHN0eWxlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzdHlsZSgpOiBFeHRlbnNpb24ge1xuICAgIHJldHVybiBFZGl0b3JWaWV3LnRoZW1lKHtcbiAgICAgICAgXCIucy1jb2RlLWVkaXRvci10YXhDYWxjdWxhdGlvbi1hdXRvY29tcGxldGUtdWxcIjoge1xuICAgICAgICAgICAgXCJwYWRkaW5nXCI6IFwiLjc1cmVtICFpbXBvcnRhbnRcIixcbiAgICAgICAgfSxcblxuICAgICAgICBcIi5zLWNvZGUtZWRpdG9yLXRheENhbGN1bGF0aW9uLWF1dG9jb21wbGV0ZS1saVwiOiB7XG4gICAgICAgICAgICBjdXJzb3I6IFwiZGVmYXVsdCAhaW1wb3J0YW50XCIsXG4gICAgICAgICAgICBcImxpbmUtaGVpZ2h0XCI6IFwiMS4zNzVlbSAhaW1wb3J0YW50XCIsXG4gICAgICAgIH0sXG4gICAgfSk7XG59XG4iXX0=

package/esm2015/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/autocomplete-state-wrapper/autocomplete-state-wrapper.js

@@ -0,0 +1,75 @@
+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;
+    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,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

package/esm2015/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-states/index.js

@@ -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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yc2lzdGVtYXMvYW5ndWxhci1jb21wb25lbnRzLyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9jb2RlLWVkaXRvci9pbmZyYS9jb3Jlcy9jb2RlbWlycm9yLTYvbGFuZ3VhZ2VzL3RheC1jYWxjdWxhdGlvbi9leHRlbnNpb25zL2F1dG9jb21wbGV0ZS9hdXRvY29tcGxldGUtc3RhdGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseURBQXlELENBQUM7QUFDeEUsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYXV0b2NvbXBsZXRlLXN0YXRlLXdyYXBwZXIvYXV0b2NvbXBsZXRlLXN0YXRlLXdyYXBwZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2F1dG9jb21wbGV0ZS1sb2FkaW5nLXN0YXRlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9hdXRvY29tcGxldGUtZW1wdHktc3RhdGVcIjtcbiJdfQ==

package/esm2015/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete-style.js

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