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

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

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

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

@@ -0,0 +1,334 @@
+import { autocompletion, pickedCompletion, startCompletion, } from '@codemirror/autocomplete';
+import { CustomTranslationsService } from '../../../../../../utils';
+import { CodeMirror6Core } from '../../../../codemirror-6-core';
+import { isCurrentPositionInsideString } from '../../../../utils';
+import { AutocompleteService } from './autocomplete.service';
+import { autocompleteLoadingState, showAutocompleteLoadingState, autocompleteEmptyState, showAutocompleteEmptyState, } from './autocomplete-states';
+import { RequestTypes, CompletionTypes, MetaType, Keywords, } from '../../models';
+import { getLanguageConfigs, getSafeResponse } from '../../utils';
+import { style } from './autocomplete-style';
+/**
+ * Adds an autocomplete to the editor
+ * @returns An extension containing everything needed to create the autocomplete
+ */
+export function autocomplete() {
+    return [
+        autocompletion({ override: [getCompletionResults] }),
+        autocompleteLoadingState(),
+        autocompleteEmptyState(),
+        style(),
+    ];
+}
+const TRANSLATION_PREFIX = 'core_language_tax_calculation';
+let 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) {
+    const isCursorInsideString = isCurrentPositionInsideString(context.state.doc.toString().substring(0, context.pos));
+    if (isCursorInsideString) {
+        return null;
+    }
+    ;
+    if (completionResults) {
+        const finalCompletionResults = { ...completionResults };
+        const codeLength = context.state.doc.toString().length;
+        finalCompletionResults.from = finalCompletionResults.from > codeLength ? codeLength : finalCompletionResults.from;
+        completionResults = null;
+        return finalCompletionResults;
+    }
+    startCompletionResultsSearch(context);
+    return null;
+}
+let cancelLastCompletionSearch = () => { };
+let codeMirrorViewElement;
+/*
+ * Starts a new completionResults's async search.
+ * Avoids the last search to be finished by calling the "cancelLastCompletionSearch" callback function
+ */
+function startCompletionResultsSearch(context) {
+    const token = new AbortController();
+    setTimeout(() => {
+        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 = () => {
+        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
+ */
+async function searchCompletionResults(context, token) {
+    const codeBeforeCursor = context?.state?.doc?.toString().substring(0, context?.pos ?? 0) ?? '';
+    const filter = getFilter(codeBeforeCursor);
+    const path = getPath(codeBeforeCursor, filter.length);
+    const requests = getRequestsBasedOnPath(path, filter, token.signal);
+    Promise.all(requests).then((responses) => {
+        if (!token.signal.aborted) {
+            const completions = [].concat(getKeywordsCompletions(path), getContextsCompletions(responses), getExpressionsCompletions(responses), getEntitiesCompletions(responses));
+            const filteredCompletions = getFilteredCompletions(completions, filter);
+            if (filteredCompletions.length) {
+                const formattedCompletions = getFormattedCompletions(filteredCompletions, filter);
+                const sortedCompletions = getSortedCompletions(formattedCompletions);
+                completionResults = {
+                    from: context.pos,
+                    filter: false,
+                    options: sortedCompletions,
+                };
+                startCompletion(CodeMirror6Core.getEditorView());
+            }
+            else {
+                showAutocompleteEmptyState();
+            }
+        }
+    });
+}
+/*
+ * 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) {
+    if (string === undefined || string === null) {
+        return '';
+    }
+    const regex = /(#|\.|)\w*$/;
+    const match = regex.exec(string);
+    const filter = match ? match[0] : '';
+    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) {
+    if (string === undefined || string === null) {
+        return '';
+    }
+    const stringWithoutPath = string.substring(0, string.length - filterLength);
+    const regex = /(\w*\.)*$/;
+    const match = regex.exec(stringWithoutPath);
+    const path = match ? match[0] : '';
+    return path.replace(/\.$/, '');
+}
+function getRequestsBasedOnPath(path, filter, abortSignal) {
+    const languageConfigs = getLanguageConfigs();
+    const 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: languageConfigs.subContexts ?? [],
+                name: filter,
+                pageRequest: {
+                    offset: 0,
+                    size: 20,
+                },
+            }, abortSignal),
+        });
+    }
+    else if (path.includes('.')) {
+        const 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((request) => getSafeResponse(request));
+}
+function getKeywordsCompletions(path) {
+    if (path !== '') {
+        return [];
+    }
+    const 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((completionItem) => ({
+        ...completionItem,
+        detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_keyword`),
+        type: CompletionTypes.Keyword,
+    }));
+}
+function getContextsCompletions(responses = []) {
+    const contextsResponse = responses.find((response) => response?.requestType === RequestTypes.ListContextMetadataById);
+    if (contextsResponse) {
+        return (contextsResponse.response?.contextMetadata ?? []).map((contextMetadata) => ({
+            label: contextMetadata.name,
+            detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_context`),
+            apply: contextMetadata.name,
+            type: CompletionTypes.Context,
+        }));
+    }
+    return [];
+}
+function getExpressionsCompletions(responses = []) {
+    const expressionsResponse = responses.find((response) => response?.requestType === RequestTypes.ListExpressionMetadata);
+    if (expressionsResponse) {
+        return (expressionsResponse.response?.expressionMetadata ?? []).map((expressionMetadata) => ({
+            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 = []) {
+    const facadesResponseFromList = responses.find((response) => response?.requestType === RequestTypes.ListFacadeMetadataNames);
+    if (facadesResponseFromList) {
+        return (facadesResponseFromList.response?.facadeMetadataNames ?? []).map((facade) => ({
+            label: facade.name,
+            detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_entity`),
+            apply: facade.name,
+            type: CompletionTypes.Entity,
+        }));
+    }
+    const facadesResponseFromGet = responses.find((response) => response?.requestType === RequestTypes.GetFacadeMetadataByPath);
+    if (facadesResponseFromGet) {
+        return (facadesResponseFromGet.response?.facadeMetadata?.fields ?? []).map((facade) => ({
+            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((completionItem) => 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((completionItem) => ({
+        ...completionItem,
+        apply: getCompletionApply(filter, `${completionItem.apply}`),
+    }));
+}
+function getCompletionApply(filter, oldApplyText) {
+    return (view, completion, from, to) => {
+        const newFrom = from - filter.length;
+        view.dispatch({
+            changes: {
+                to,
+                from: newFrom,
+                insert: oldApplyText,
+            },
+            selection: {
+                anchor: newFrom + oldApplyText.length,
+            },
+            userEvent: 'input.complete',
+            annotations: pickedCompletion.of(completion),
+        });
+    };
+}
+const 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((x, y) => {
+        const xPriority = completionsSortOrder.indexOf(x.type);
+        const yPriority = completionsSortOrder.indexOf(y.type);
+        return xPriority - yPriority;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete.js","sourceRoot":"","sources":["../../../../../../../../../../../../projects/angular-components/code-editor/src/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,cAAc,EAId,gBAAgB,EAChB,eAAe,GAClB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EACH,wBAAwB,EACxB,4BAA4B,EAC5B,sBAAsB,EACtB,0BAA0B,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEH,YAAY,EAKZ,eAAe,EAEf,QAAQ,EAGR,QAAQ,GACX,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE7C;;;GAGG;AACH,MAAM,UAAU,YAAY;IACxB,OAAO;QACH,cAAc,CAAC,EAAE,QAAQ,EAAE,CAAC,oBAAoB,CAAC,EAAE,CAAC;QACpD,wBAAwB,EAAE;QAC1B,sBAAsB,EAAE;QACxB,KAAK,EAAE;KACV,CAAC;AACN,CAAC;AAED,MAAM,kBAAkB,GAAG,+BAA+B,CAAC;AAC3D,IAAI,iBAAoC,CAAC;AAEzC;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,OAA0B;IACpD,MAAM,oBAAoB,GAAG,6BAA6B,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IACnH,IAAI,oBAAoB,EAAE,CAAC;QACvB,OAAO,IAAI,CAAC;IAChB,CAAC;IAAA,CAAC;IAEF,IAAI,iBAAiB,EAAE,CAAC;QACpB,MAAM,sBAAsB,GAAqB,EAAE,GAAG,iBAAiB,EAAE,CAAC;QAC1E,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC;QACvD,sBAAsB,CAAC,IAAI,GAAG,sBAAsB,CAAC,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,sBAAsB,CAAC,IAAI,CAAC;QAClH,iBAAiB,GAAG,IAAmC,CAAC;QACxD,OAAO,sBAAsB,CAAC;IAClC,CAAC;IACD,4BAA4B,CAAC,OAAO,CAAC,CAAC;IACtC,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,IAAI,0BAA0B,GAAe,GAAG,EAAE,GAAG,CAAC,CAAC;AACvD,IAAI,qBAAmC,CAAC;AAExC;;;GAGG;AACH,SAAS,4BAA4B,CAAC,OAA0B;IAC5D,MAAM,KAAK,GAAG,IAAI,eAAe,EAAE,CAAC;IACpC,UAAU,CAAC,GAAG,EAAE;QACZ,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACxB,4BAA4B,EAAE,CAAC;YAC/B,uBAAuB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC5C,CAAC;IACL,CAAC,EAAE,GAAG,CAAC,CAAC;IAER;;;;;;;;;;OAUG;IACH,qBAAqB,GAAG,eAAe,CAAC,aAAa,EAAE,CAAC,UAAU,CAAC;IAEnE,0BAA0B,GAAG,GAAG,EAAE;QAC9B,qBAAqB,CAAC,mBAAmB,CAAC,SAAS,EAAE,0BAA0B,CAAC,CAAC;QACjF,qBAAqB,CAAC,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAAC;QAC/E,KAAK,CAAC,KAAK,EAAE,CAAC;IAClB,CAAC,CAAC;IAEF,qBAAqB,CAAC,gBAAgB,CAAC,SAAS,EAAE,0BAA0B,CAAC,CAAC;IAC9E,qBAAqB,CAAC,gBAAgB,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAAC;AAChF,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,uBAAuB,CAAC,OAA0B,EAAE,KAAsB;IACrF,MAAM,gBAAgB,GAAG,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;IAC/F,MAAM,MAAM,GAAG,SAAS,CAAC,gBAAgB,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,OAAO,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IACtD,MAAM,QAAQ,GAAmB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAEpF,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE;QACrC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACxB,MAAM,WAAW,GAAI,EAAmB,CAAC,MAAM,CAC3C,sBAAsB,CAAC,IAAI,CAAC,EAC5B,sBAAsB,CAAC,SAAuB,CAAC,EAC/C,yBAAyB,CAAC,SAAuB,CAAC,EAClD,sBAAsB,CAAC,SAAuB,CAAC,CAClD,CAAC;YACF,MAAM,mBAAmB,GAAiB,sBAAsB,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;YAEtF,IAAI,mBAAmB,CAAC,MAAM,EAAE,CAAC;gBAC7B,MAAM,oBAAoB,GAAiB,uBAAuB,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;gBAChG,MAAM,iBAAiB,GAAiB,oBAAoB,CAAC,oBAAoB,CAAC,CAAC;gBAEnF,iBAAiB,GAAG;oBAChB,IAAI,EAAE,OAAO,CAAC,GAAG;oBACjB,MAAM,EAAE,KAAK;oBACb,OAAO,EAAE,iBAAiB;iBAC7B,CAAC;gBACF,eAAe,CAAC,eAAe,CAAC,aAAa,EAAE,CAAC,CAAC;YACrD,CAAC;iBAAM,CAAC;gBACJ,0BAA0B,EAAE,CAAC;YACjC,CAAC;QACL,CAAC;IACL,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;GAMG;AACH,SAAS,SAAS,CAAC,MAAc;IAC7B,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QAC1C,OAAO,EAAE,CAAC;IACd,CAAC;IAED,MAAM,KAAK,GAAG,aAAa,CAAC;IAC5B,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACrC,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;AAC1C,CAAC;AAED;;;;;GAKG;AACH,SAAS,OAAO,CAAC,MAAc,EAAE,YAAoB;IACjD,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QAC1C,OAAO,EAAE,CAAC;IACd,CAAC;IAED,MAAM,iBAAiB,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC;IAC5E,MAAM,KAAK,GAAG,WAAW,CAAC;IAC1B,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACnC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,sBAAsB,CAAC,IAAY,EAAE,MAAc,EAAE,WAAwB;IAClF,MAAM,eAAe,GAA0B,kBAAkB,EAAE,CAAC;IACpE,MAAM,QAAQ,GAAkB,EAAE,CAAC;IAEnC,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACd,QAAQ,CAAC,IAAI,CAAC;YACV,WAAW,EAAE,YAAY,CAAC,uBAAuB;YACjD,OAAO,EAAE,mBAAmB,CAAC,uBAAuB,CAChD;gBACI,EAAE,EAAE,eAAe,CAAC,QAAQ;aAC/B,EACD,WAAW,CACd;SACJ,CAAC,CAAC;QACH,QAAQ,CAAC,IAAI,CAAC;YACV,WAAW,EAAE,YAAY,CAAC,sBAAsB;YAChD,OAAO,EAAE,mBAAmB,CAAC,sBAAsB,CAC/C;gBACI,OAAO,EAAE,eAAe,CAAC,QAAQ;gBACjC,UAAU,EAAE,eAAe,CAAC,WAAW,IAAI,EAAE;gBAC7C,IAAI,EAAE,MAAM;gBACZ,WAAW,EAAE;oBACT,MAAM,EAAE,CAAC;oBACT,IAAI,EAAE,EAAE;iBACX;aACJ,EACD,WAAW,CACd;SACJ,CAAC,CAAC;IACP,CAAC;SAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC5B,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrC,QAAQ,CAAC,IAAI,CAAC;YACV,WAAW,EAAE,YAAY,CAAC,uBAAuB;YACjD,OAAO,EAAE,mBAAmB,CAAC,uBAAuB,CAChD;gBACI,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;gBACxB,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC;gBAC3B,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;aAC5E,EACD,WAAW,CACd;SACJ,CAAC,CAAC;IACP,CAAC;SAAM,CAAC;QACJ,QAAQ,CAAC,IAAI,CAAC;YACV,WAAW,EAAE,YAAY,CAAC,uBAAuB;YACjD,OAAO,EAAE,mBAAmB,CAAC,uBAAuB,CAChD;gBACI,OAAO,EAAE,CAAC,IAAI,CAAC;gBACf,IAAI,EAAE,MAAM;gBACZ,WAAW,EAAE;oBACT,MAAM,EAAE,CAAC;oBACT,IAAI,EAAE,EAAE;iBACX;aACJ,EACD,WAAW,CACd;SACJ,CAAC,CAAC;IACP,CAAC;IAED,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,CAAmB,CAAC;AACjF,CAAC;AAED,SAAS,sBAAsB,CAAC,IAAY;IACxC,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACd,OAAO,EAAE,CAAC;IACd,CAAC;IAED,MAAM,WAAW,GAAG;QAChB;YACI,KAAK,EAAE,QAAQ,CAAC,EAAE;YAClB,KAAK,EAAE,8BAA8B;SACxC;QACD;YACI,KAAK,EAAE,QAAQ,CAAC,KAAK;YACrB,KAAK,EAAE,eAAe;SACzB;QACD;YACI,KAAK,EAAE,QAAQ,CAAC,QAAQ;YACxB,KAAK,EAAE,oBAAoB;SAC9B;QACD;YACI,KAAK,EAAE,QAAQ,CAAC,KAAK;YACrB,KAAK,EAAE,eAAe;SACzB;QACD;YACI,KAAK,EAAE,QAAQ,CAAC,MAAM;YACtB,KAAK,EAAE,SAAS;SACnB;QACD;YACI,KAAK,EAAE,QAAQ,CAAC,GAAG;YACnB,KAAK,EAAE,MAAM;SAChB;QACD;YACI,KAAK,EAAE,QAAQ,CAAC,CAAC;YACjB,KAAK,EAAE,IAAI;SACd;QACD;YACI,KAAK,EAAE,QAAQ,CAAC,EAAE;YAClB,KAAK,EAAE,KAAK;SACf;KACJ,CAAC;IAEF,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;QACxC,GAAG,cAAc;QACjB,MAAM,EAAE,yBAAyB,CAAC,SAAS,CAAC,GAAG,kBAAkB,UAAU,CAAC;QAC5E,IAAI,EAAE,eAAe,CAAC,OAAO;KAChC,CAAC,CAAC,CAAC;AACR,CAAC;AAED,SAAS,sBAAsB,CAAC,YAAwB,EAAE;IACtD,MAAM,gBAAgB,GAA0D,SAAS,CAAC,IAAI,CAC1F,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,YAAY,CAAC,uBAAuB,CAC/E,CAAC;IAEF,IAAI,gBAAgB,EAAE,CAAC;QACnB,OAAO,CAAC,gBAAgB,CAAC,QAAQ,EAAE,eAAe,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;YAChF,KAAK,EAAE,eAAe,CAAC,IAAI;YAC3B,MAAM,EAAE,yBAAyB,CAAC,SAAS,CAAC,GAAG,kBAAkB,UAAU,CAAC;YAC5E,KAAK,EAAE,eAAe,CAAC,IAAI;YAC3B,IAAI,EAAE,eAAe,CAAC,OAAO;SAChC,CAAC,CAAC,CAAC;IACR,CAAC;IAED,OAAO,EAAE,CAAC;AACd,CAAC;AAED,SAAS,yBAAyB,CAAC,YAAwB,EAAE;IACzD,MAAM,mBAAmB,GAAyD,SAAS,CAAC,IAAI,CAC5F,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,YAAY,CAAC,sBAAsB,CAC9E,CAAC;IAEF,IAAI,mBAAmB,EAAE,CAAC;QACtB,OAAO,CAAC,mBAAmB,CAAC,QAAQ,EAAE,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;YACzF,KAAK,EAAE,kBAAkB,CAAC,IAAI;YAC9B,MAAM,EAAE,yBAAyB,CAAC,SAAS,CACvC,GAAG,kBAAkB,IAAI,kBAAkB,CAAC,IAAI,KAAK,QAAQ,CAAC,iBAAiB,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,iBACxG,EAAE,CACL;YACD,KAAK,EAAE,kBAAkB,CAAC,IAAI;YAC9B,IAAI,EAAE,kBAAkB,CAAC,WAAW;YACpC,IAAI,EACA,kBAAkB,CAAC,IAAI,KAAK,QAAQ,CAAC,iBAAiB;gBAClD,CAAC,CAAC,eAAe,CAAC,UAAU;gBAC5B,CAAC,CAAC,eAAe,CAAC,cAAc;SAC3C,CAAC,CAAC,CAAC;IACR,CAAC;IAED,OAAO,EAAE,CAAC;AACd,CAAC;AAED,SAAS,sBAAsB,CAAC,YAAwB,EAAE;IACtD,MAAM,uBAAuB,GAA0D,SAAS,CAAC,IAAI,CACjG,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,YAAY,CAAC,uBAAuB,CAC/E,CAAC;IAEF,IAAI,uBAAuB,EAAE,CAAC;QAC1B,OAAO,CAAC,uBAAuB,CAAC,QAAQ,EAAE,mBAAmB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;YAClF,KAAK,EAAE,MAAM,CAAC,IAAI;YAClB,MAAM,EAAE,yBAAyB,CAAC,SAAS,CAAC,GAAG,kBAAkB,SAAS,CAAC;YAC3E,KAAK,EAAE,MAAM,CAAC,IAAI;YAClB,IAAI,EAAE,eAAe,CAAC,MAAM;SAC/B,CAAC,CAAC,CAAC;IACR,CAAC;IAED,MAAM,sBAAsB,GAA0D,SAAS,CAAC,IAAI,CAChG,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,YAAY,CAAC,uBAAuB,CAC/E,CAAC;IAEF,IAAI,sBAAsB,EAAE,CAAC;QACzB,OAAO,CAAC,sBAAsB,CAAC,QAAQ,EAAE,cAAc,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;YACpF,KAAK,EAAE,MAAM,CAAC,IAAI;YAClB,MAAM,EAAE,yBAAyB,CAAC,SAAS,CACvC,GAAG,kBAAkB,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAClF;YACD,KAAK,EAAE,MAAM,CAAC,IAAI;YAClB,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,eAAe,CAAC,UAAU;SAC9F,CAAC,CAAC,CAAC;IACR,CAAC;IAED,OAAO,EAAE,CAAC;AACd,CAAC;AAED;;GAEG;AACH,SAAS,sBAAsB,CAAC,WAAyB,EAAE,MAAc;IACrE,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC,cAAc,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;AACvH,CAAC;AAED;;;GAGG;AACH,SAAS,uBAAuB,CAAC,WAAyB,EAAE,MAAc;IACtE,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;QACxC,GAAG,cAAc;QACjB,KAAK,EAAE,kBAAkB,CAAC,MAAM,EAAE,GAAG,cAAc,CAAC,KAAK,EAAE,CAAC;KAC/D,CAAC,CAAC,CAAC;AACR,CAAC;AAED,SAAS,kBAAkB,CACvB,MAAc,EACd,YAAoB;IAEpB,OAAO,CAAC,IAAgB,EAAE,UAAsB,EAAE,IAAY,EAAE,EAAU,EAAQ,EAAE;QAChF,MAAM,OAAO,GAAG,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC;QAErC,IAAI,CAAC,QAAQ,CAAC;YACV,OAAO,EAAE;gBACL,EAAE;gBACF,IAAI,EAAE,OAAO;gBACb,MAAM,EAAE,YAAY;aACvB;YACD,SAAS,EAAE;gBACP,MAAM,EAAE,OAAO,GAAG,YAAY,CAAC,MAAM;aACxC;YACD,SAAS,EAAE,gBAAgB;YAC3B,WAAW,EAAE,gBAAgB,CAAC,EAAE,CAAC,UAAU,CAAC;SAC/C,CAAC,CAAC;IACP,CAAC,CAAC;AACN,CAAC;AAED,MAAM,oBAAoB,GAAsB;IAC5C,eAAe,CAAC,OAAO;IACvB,eAAe,CAAC,OAAO;IACvB,eAAe,CAAC,cAAc;IAC9B,eAAe,CAAC,UAAU;IAC1B,eAAe,CAAC,MAAM;IACtB,eAAe,CAAC,UAAU;CAC7B,CAAC;AAEF;;GAEG;AACH,SAAS,oBAAoB,CAAC,WAAyB;IACnD,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,CAAa,EAAE,CAAa,EAAE,EAAE;QACrD,MAAM,SAAS,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,IAAuB,CAAC,CAAC;QAC1E,MAAM,SAAS,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,IAAuB,CAAC,CAAC;QAE1E,OAAO,SAAS,GAAG,SAAS,CAAC;IACjC,CAAC,CAAC,CAAC;AACP,CAAC","sourcesContent":["import { Extension } from '@codemirror/state';\nimport { EditorView } from '@codemirror/view';\nimport {\n    autocompletion,\n    Completion,\n    CompletionContext,\n    CompletionResult,\n    pickedCompletion,\n    startCompletion,\n} from '@codemirror/autocomplete';\n\nimport { CustomTranslationsService } from '../../../../../../utils';\nimport { CodeMirror6Core } from '../../../../codemirror-6-core';\nimport { isCurrentPositionInsideString } from '../../../../utils';\nimport { AutocompleteService } from './autocomplete.service';\nimport {\n    autocompleteLoadingState,\n    showAutocompleteLoadingState,\n    autocompleteEmptyState,\n    showAutocompleteEmptyState,\n} from './autocomplete-states';\nimport {\n    TaxCalculationConfigs,\n    RequestTypes,\n    Response,\n    SafeRequest,\n    SafeResponse,\n    ListContextMetadataByIdResponse,\n    CompletionTypes,\n    ListExpressionMetadataResponse,\n    MetaType,\n    GetFacadeMetadataByPathResponse,\n    ListFacadeMetadataNamesResponse,\n    Keywords,\n} from '../../models';\nimport { getLanguageConfigs, getSafeResponse } from '../../utils';\nimport { style } from './autocomplete-style';\n\n/**\n * Adds an autocomplete to the editor\n * @returns An extension containing everything needed to create the autocomplete\n */\nexport function autocomplete(): Extension {\n    return [\n        autocompletion({ override: [getCompletionResults] }),\n        autocompleteLoadingState(),\n        autocompleteEmptyState(),\n        style(),\n    ];\n}\n\nconst TRANSLATION_PREFIX = 'core_language_tax_calculation';\nlet completionResults!: CompletionResult;\n\n/*\n * A function to be called when a key is pressed, the ctrl+space is triggered or when the search for\n * completionResults is done.\n * If there is a completionResult, returns it, otherwise starts a new async search.\n * Will only execute the autocompletion if the current cursor position is not inside a string\n */\nfunction getCompletionResults(context: CompletionContext): CompletionResult | null {\n    const isCursorInsideString = isCurrentPositionInsideString(context.state.doc.toString().substring(0, context.pos));\n    if (isCursorInsideString) {\n        return null;\n    };\n\n    if (completionResults) {\n        const finalCompletionResults: CompletionResult = { ...completionResults };\n        const codeLength = context.state.doc.toString().length;\n        finalCompletionResults.from = finalCompletionResults.from > codeLength ? codeLength : finalCompletionResults.from;\n        completionResults = null as unknown as CompletionResult;\n        return finalCompletionResults;\n    }\n    startCompletionResultsSearch(context);\n    return null;\n}\n\nlet cancelLastCompletionSearch: () => void = () => { };\nlet codeMirrorViewElement!: HTMLElement;\n\n/*\n * Starts a new completionResults's async search.\n * Avoids the last search to be finished by calling the \"cancelLastCompletionSearch\" callback function\n */\nfunction startCompletionResultsSearch(context: CompletionContext): void {\n    const token = new AbortController();\n    setTimeout(() => {\n        if (!token.signal.aborted) {\n            showAutocompleteLoadingState();\n            searchCompletionResults(context, token);\n        }\n    }, 500);\n\n    /*\n     * IMPORTANT: The following lines MUST be the way they are!\n     * Here is being add the listener to any keydown/click event so when any key is downed or mouse clicked, we cancel\n     * the last request.\n     * We do this to not show to the user a completionItem in an incorrect place of text, that can be done by either\n     * pressing the * arrows, home, end, backspace and etc. The flow is:\n     * 1. We add an eventListener to keydown/click when the autocompletion's request is triggered;\n     * 2. When any key/click is pressed, we remove the listener and cancel the last request by changing the\n     * isSearchCanceled on token object to true;\n     * 3. If any key that requires autocompletion is triggered, the flow repeats;\n     */\n    codeMirrorViewElement = CodeMirror6Core.getEditorView().contentDOM;\n\n    cancelLastCompletionSearch = () => {\n        codeMirrorViewElement.removeEventListener('keydown', cancelLastCompletionSearch);\n        codeMirrorViewElement.removeEventListener('click', cancelLastCompletionSearch);\n        token.abort();\n    };\n\n    codeMirrorViewElement.addEventListener('keydown', cancelLastCompletionSearch);\n    codeMirrorViewElement.addEventListener('click', cancelLastCompletionSearch);\n}\n\n/*\n * Requests the necessary items to fill the completionResults, although it only really opens the autocomplete\n * box (by calling the \"startCompletion()\", that calls the \"getCompletionResults\") if the current search\n * was not cancelled by a new one\n */\nasync function searchCompletionResults(context: CompletionContext, token: AbortController): Promise<void> {\n    const codeBeforeCursor = context?.state?.doc?.toString().substring(0, context?.pos ?? 0) ?? '';\n    const filter = getFilter(codeBeforeCursor);\n    const path = getPath(codeBeforeCursor, filter.length);\n    const requests: SafeResponse[] = getRequestsBasedOnPath(path, filter, token.signal);\n\n    Promise.all(requests).then((responses) => {\n        if (!token.signal.aborted) {\n            const completions = ([] as Completion[]).concat(\n                getKeywordsCompletions(path),\n                getContextsCompletions(responses as Response[]),\n                getExpressionsCompletions(responses as Response[]),\n                getEntitiesCompletions(responses as Response[]),\n            );\n            const filteredCompletions: Completion[] = getFilteredCompletions(completions, filter);\n\n            if (filteredCompletions.length) {\n                const formattedCompletions: Completion[] = getFormattedCompletions(filteredCompletions, filter);\n                const sortedCompletions: Completion[] = getSortedCompletions(formattedCompletions);\n\n                completionResults = {\n                    from: context.pos,\n                    filter: false,\n                    options: sortedCompletions,\n                };\n                startCompletion(CodeMirror6Core.getEditorView());\n            } else {\n                showAutocompleteEmptyState();\n            }\n        }\n    });\n}\n\n/*\n * Returns the filter in the code written.\n * For example in the code \"controladoria.empresa\", \"empresa\" would be the filter\n * and in \"controladoria\", \"controladoria\" would be the filter.\n * Allows only alphanumerics, underscore and hashtag on filter's start.\n * Does not allow spaces\n */\nfunction getFilter(string: string): string {\n    if (string === undefined || string === null) {\n        return '';\n    }\n\n    const regex = /(#|\\.|)\\w*$/;\n    const match = regex.exec(string);\n    const filter = match ? match[0] : '';\n    return filter.replace('.', '').trim();\n}\n\n/*\n * Returns the path in the code written based on filter.\n * For example in the code \"controladoria.empresa\", \"controladoria\" would be the path\n * and in \"controladoria\", \"\" would be the path.\n * Does not allow spaces\n */\nfunction getPath(string: string, filterLength: number): string {\n    if (string === undefined || string === null) {\n        return '';\n    }\n\n    const stringWithoutPath = string.substring(0, string.length - filterLength);\n    const regex = /(\\w*\\.)*$/;\n    const match = regex.exec(stringWithoutPath);\n    const path = match ? match[0] : '';\n    return path.replace(/\\.$/, '');\n}\n\nfunction getRequestsBasedOnPath(path: string, filter: string, abortSignal: AbortSignal): SafeResponse[] {\n    const languageConfigs: TaxCalculationConfigs = getLanguageConfigs();\n    const requests: SafeRequest[] = [];\n\n    if (path === '') {\n        requests.push({\n            requestType: RequestTypes.ListContextMetadataById,\n            request: AutocompleteService.listContextMetadataById(\n                {\n                    id: languageConfigs.contexts,\n                },\n                abortSignal,\n            ),\n        });\n        requests.push({\n            requestType: RequestTypes.ListExpressionMetadata,\n            request: AutocompleteService.listExpressionMetadata(\n                {\n                    context: languageConfigs.contexts,\n                    subcontext: languageConfigs.subContexts ?? [],\n                    name: filter,\n                    pageRequest: {\n                        offset: 0,\n                        size: 20,\n                    },\n                },\n                abortSignal,\n            ),\n        });\n    } else if (path.includes('.')) {\n        const splittedPath = path.split('.');\n        requests.push({\n            requestType: RequestTypes.GetFacadeMetadataByPath,\n            request: AutocompleteService.getFacadeMetadataByPath(\n                {\n                    context: splittedPath[0],\n                    entityName: splittedPath[1],\n                    fields: splittedPath[2] === undefined ? undefined : splittedPath.slice(2),\n                },\n                abortSignal,\n            ),\n        });\n    } else {\n        requests.push({\n            requestType: RequestTypes.ListFacadeMetadataNames,\n            request: AutocompleteService.listFacadeMetadataNames(\n                {\n                    context: [path],\n                    name: filter,\n                    pageRequest: {\n                        offset: 0,\n                        size: 30,\n                    },\n                },\n                abortSignal,\n            ),\n        });\n    }\n\n    return requests.map((request) => getSafeResponse(request)) as SafeResponse[];\n}\n\nfunction getKeywordsCompletions(path: string): Completion[] {\n    if (path !== '') {\n        return [];\n    }\n\n    const completions = [\n        {\n            label: Keywords.SE,\n            apply: 'SE ()\\nENTAO\\n\\tacao\\nFIM_SE',\n        },\n        {\n            label: Keywords.SENAO,\n            apply: 'SENAO\\n\\tacao',\n        },\n        {\n            label: Keywords.CONTENHA,\n            apply: 'CONTENHA(condicao)',\n        },\n        {\n            label: Keywords.ENTAO,\n            apply: 'ENTAO\\n\\tacao',\n        },\n        {\n            label: Keywords.FIM_SE,\n            apply: 'FIM_SE ',\n        },\n        {\n            label: Keywords.NAO,\n            apply: 'NAO ',\n        },\n        {\n            label: Keywords.E,\n            apply: 'E ',\n        },\n        {\n            label: Keywords.OU,\n            apply: 'OU ',\n        },\n    ];\n\n    return completions.map((completionItem) => ({\n        ...completionItem,\n        detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_keyword`),\n        type: CompletionTypes.Keyword,\n    }));\n}\n\nfunction getContextsCompletions(responses: Response[] = []): Completion[] {\n    const contextsResponse: Response<ListContextMetadataByIdResponse> | undefined = responses.find(\n        (response) => response?.requestType === RequestTypes.ListContextMetadataById,\n    );\n\n    if (contextsResponse) {\n        return (contextsResponse.response?.contextMetadata ?? []).map((contextMetadata) => ({\n            label: contextMetadata.name,\n            detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_context`),\n            apply: contextMetadata.name,\n            type: CompletionTypes.Context,\n        }));\n    }\n\n    return [];\n}\n\nfunction getExpressionsCompletions(responses: Response[] = []): Completion[] {\n    const expressionsResponse: Response<ListExpressionMetadataResponse> | undefined = responses.find(\n        (response) => response?.requestType === RequestTypes.ListExpressionMetadata,\n    );\n\n    if (expressionsResponse) {\n        return (expressionsResponse.response?.expressionMetadata ?? []).map((expressionMetadata) => ({\n            label: expressionMetadata.name,\n            detail: CustomTranslationsService.translate(\n                `${TRANSLATION_PREFIX}_${expressionMetadata.type === MetaType.PUBLIC_EXPRESSION ? 'senior_expression' : 'user_expression'\n                }`,\n            ),\n            apply: expressionMetadata.name,\n            info: expressionMetadata.description,\n            type:\n                expressionMetadata.type === MetaType.PUBLIC_EXPRESSION\n                    ? CompletionTypes.Expression\n                    : CompletionTypes.UserExpression,\n        }));\n    }\n\n    return [];\n}\n\nfunction getEntitiesCompletions(responses: Response[] = []): Completion[] {\n    const facadesResponseFromList: Response<ListFacadeMetadataNamesResponse> | undefined = responses.find(\n        (response) => response?.requestType === RequestTypes.ListFacadeMetadataNames,\n    );\n\n    if (facadesResponseFromList) {\n        return (facadesResponseFromList.response?.facadeMetadataNames ?? []).map((facade) => ({\n            label: facade.name,\n            detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_entity`),\n            apply: facade.name,\n            type: CompletionTypes.Entity,\n        }));\n    }\n\n    const facadesResponseFromGet: Response<GetFacadeMetadataByPathResponse> | undefined = responses.find(\n        (response) => response?.requestType === RequestTypes.GetFacadeMetadataByPath,\n    );\n\n    if (facadesResponseFromGet) {\n        return (facadesResponseFromGet.response?.facadeMetadata?.fields ?? []).map((facade) => ({\n            label: facade.name,\n            detail: CustomTranslationsService.translate(\n                `${TRANSLATION_PREFIX}_${facade.type === MetaType.ENTITY ? 'entity' : 'field'}`,\n            ),\n            apply: facade.name,\n            type: facade.type === MetaType.ENTITY ? CompletionTypes.Entity : CompletionTypes.FinalValue,\n        }));\n    }\n\n    return [];\n}\n\n/*\n * Filtering the completions to only deal with the necessary items\n */\nfunction getFilteredCompletions(completions: Completion[], filter: string): Completion[] {\n    return completions.filter((completionItem) => completionItem.label.toLowerCase().startsWith(filter.toLowerCase()));\n}\n\n/*\n * Overwriting the completions's apply to remove the entire current written value and apply the the entire\n * completion's apply\n */\nfunction getFormattedCompletions(completions: Completion[], filter: string): Completion[] {\n    return completions.map((completionItem) => ({\n        ...completionItem,\n        apply: getCompletionApply(filter, `${completionItem.apply}`),\n    }));\n}\n\nfunction getCompletionApply(\n    filter: string,\n    oldApplyText: string,\n): (view: EditorView, completion: Completion, from: number, to: number) => void {\n    return (view: EditorView, completion: Completion, from: number, to: number): void => {\n        const newFrom = from - filter.length;\n\n        view.dispatch({\n            changes: {\n                to,\n                from: newFrom,\n                insert: oldApplyText,\n            },\n            selection: {\n                anchor: newFrom + oldApplyText.length,\n            },\n            userEvent: 'input.complete',\n            annotations: pickedCompletion.of(completion),\n        });\n    };\n}\n\nconst completionsSortOrder: CompletionTypes[] = [\n    CompletionTypes.Keyword,\n    CompletionTypes.Context,\n    CompletionTypes.UserExpression,\n    CompletionTypes.Expression,\n    CompletionTypes.Entity,\n    CompletionTypes.FinalValue,\n];\n\n/*\n * Sorts the completions following the \"completionsSortOrder\" priority order\n */\nfunction getSortedCompletions(completions: Completion[]): Completion[] {\n    return completions.sort((x: Completion, y: Completion) => {\n        const xPriority = completionsSortOrder.indexOf(x.type as CompletionTypes);\n        const yPriority = completionsSortOrder.indexOf(y.type as CompletionTypes);\n\n        return xPriority - yPriority;\n    });\n}\n"]}

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

@@ -0,0 +1,25 @@
+import { CustomHttpClient } from "../../../../../../utils";
+export class AutocompleteService {
+    static BASE_URL = "platform/rule_metadata";
+    static async listContextMetadataById(request, abortSignal) {
+        return CustomHttpClient.POST(`${AutocompleteService.BASE_URL}/queries/listContextMetadataById`, request, {
+            signal: abortSignal
+        });
+    }
+    static async listExpressionMetadata(request, abortSignal) {
+        return CustomHttpClient.POST(`${AutocompleteService.BASE_URL}/queries/listExpressionMetadata`, request, {
+            signal: abortSignal
+        });
+    }
+    static async listFacadeMetadataNames(request, abortSignal) {
+        return CustomHttpClient.POST(`${AutocompleteService.BASE_URL}/queries/listFacadeMetadataNames`, request, {
+            signal: abortSignal
+        });
+    }
+    static async getFacadeMetadataByPath(request, abortSignal) {
+        return CustomHttpClient.POST(`${AutocompleteService.BASE_URL}/queries/getFacadeMetadataByPath`, request, {
+            signal: abortSignal
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/base-configs/base-configs.mjs

@@ -0,0 +1,18 @@
+import { LRLanguage } from "@codemirror/language";
+import { buildParser } from "@lezer/generator";
+import { styleTags, tags } from "@codemirror/highlight";
+import parserGrammar from "./grammar";
+import { Keywords } from "../../models";
+export const baseConfigs = LRLanguage.define({
+    parser: buildParser(parserGrammar)
+        .configure({
+        props: [
+            styleTags({
+                [Object.values(Keywords).join(" ")]: tags.keyword,
+                "String": tags.string,
+                "Number": tags.number,
+            })
+        ]
+    })
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1jb25maWdzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL2NvZGUtZWRpdG9yL3NyYy9saWIvY29kZS1lZGl0b3IvaW5mcmEvY29yZXMvY29kZW1pcnJvci02L2xhbmd1YWdlcy90YXgtY2FsY3VsYXRpb24vZXh0ZW5zaW9ucy9iYXNlLWNvbmZpZ3MvYmFzZS1jb25maWdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDL0MsT0FBTyxFQUNILFNBQVMsRUFDVCxJQUFJLEVBQ1AsTUFBTSx1QkFBdUIsQ0FBQztBQUUvQixPQUFPLGFBQWEsTUFBTSxXQUFXLENBQUM7QUFDdEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUV4QyxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsVUFBVSxDQUFDLE1BQU0sQ0FBQztJQUN6QyxNQUFNLEVBQUcsV0FBVyxDQUFDLGFBQWEsQ0FBQztTQUM5QixTQUFTLENBQUM7UUFDUCxLQUFLLEVBQUU7WUFDSCxTQUFTLENBQUM7Z0JBQ04sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLElBQUksQ0FBQyxPQUFPO2dCQUNqRCxRQUFRLEVBQUUsSUFBSSxDQUFDLE1BQU07Z0JBQ3JCLFFBQVEsRUFBRSxJQUFJLENBQUMsTUFBTTthQUN4QixDQUFDO1NBQ0w7S0FDSixDQUFDO0NBQ1QsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTFJMYW5ndWFnZSB9IGZyb20gXCJAY29kZW1pcnJvci9sYW5ndWFnZVwiO1xuaW1wb3J0IHsgYnVpbGRQYXJzZXIgfSBmcm9tIFwiQGxlemVyL2dlbmVyYXRvclwiO1xuaW1wb3J0IHtcbiAgICBzdHlsZVRhZ3MsXG4gICAgdGFnc1xufSBmcm9tIFwiQGNvZGVtaXJyb3IvaGlnaGxpZ2h0XCI7XG5cbmltcG9ydCBwYXJzZXJHcmFtbWFyIGZyb20gXCIuL2dyYW1tYXJcIjtcbmltcG9ydCB7IEtleXdvcmRzIH0gZnJvbSBcIi4uLy4uL21vZGVsc1wiO1xuXG5leHBvcnQgY29uc3QgYmFzZUNvbmZpZ3MgPSBMUkxhbmd1YWdlLmRlZmluZSh7XG4gICAgcGFyc2VyOiAgYnVpbGRQYXJzZXIocGFyc2VyR3JhbW1hcilcbiAgICAgICAgLmNvbmZpZ3VyZSh7XG4gICAgICAgICAgICBwcm9wczogW1xuICAgICAgICAgICAgICAgIHN0eWxlVGFncyh7XG4gICAgICAgICAgICAgICAgICAgIFtPYmplY3QudmFsdWVzKEtleXdvcmRzKS5qb2luKFwiIFwiKV06IHRhZ3Mua2V5d29yZCxcbiAgICAgICAgICAgICAgICAgICAgXCJTdHJpbmdcIjogdGFncy5zdHJpbmcsXG4gICAgICAgICAgICAgICAgICAgIFwiTnVtYmVyXCI6IHRhZ3MubnVtYmVyLFxuICAgICAgICAgICAgICAgIH0pXG4gICAgICAgICAgICBdXG4gICAgICAgIH0pXG59KTtcbiJdfQ==

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/base-configs/grammar.mjs

@@ -0,0 +1,37 @@
+export default `
+@top Script { statement+ }
+
+statement[@isGroup=Statement] {
+    Keyword |
+    String |
+    Number
+}
+
+@tokens {
+    String { '"' (![\\n"])* '"'? }
+
+    Number { std.digit+ }
+
+    identifierChar { std.asciiLetter | $[_$\u{a1}-\u{10ffff}] }
+
+    word { identifierChar (identifierChar | std.digit)* }
+
+    identifier { word }
+}
+
+Keyword {
+    kw<"SE">
+    kw<"ENTAO">
+    kw<"FIM_SE">
+    kw<"SENAO">
+    kw<"NAO">
+    kw<"CONTENHA">
+    kw<"OU">
+    kw<"E">
+}
+
+kw<term> { @specialize[@name={term}]<identifier, term> }
+
+@detectDelim
+`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JhbW1hci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9jb2RlLWVkaXRvci9zcmMvbGliL2NvZGUtZWRpdG9yL2luZnJhL2NvcmVzL2NvZGVtaXJyb3ItNi9sYW5ndWFnZXMvdGF4LWNhbGN1bGF0aW9uL2V4dGVuc2lvbnMvYmFzZS1jb25maWdzL2dyYW1tYXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0FtQ2QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGBcbkB0b3AgU2NyaXB0IHsgc3RhdGVtZW50KyB9XG5cbnN0YXRlbWVudFtAaXNHcm91cD1TdGF0ZW1lbnRdIHtcbiAgICBLZXl3b3JkIHxcbiAgICBTdHJpbmcgfFxuICAgIE51bWJlclxufVxuXG5AdG9rZW5zIHtcbiAgICBTdHJpbmcgeyAnXCInICghW1xcXFxuXCJdKSogJ1wiJz8gfVxuXG4gICAgTnVtYmVyIHsgc3RkLmRpZ2l0KyB9XG5cbiAgICBpZGVudGlmaWVyQ2hhciB7IHN0ZC5hc2NpaUxldHRlciB8ICRbXyRcXHV7YTF9LVxcdXsxMGZmZmZ9XSB9XG5cbiAgICB3b3JkIHsgaWRlbnRpZmllckNoYXIgKGlkZW50aWZpZXJDaGFyIHwgc3RkLmRpZ2l0KSogfVxuXG4gICAgaWRlbnRpZmllciB7IHdvcmQgfVxufVxuXG5LZXl3b3JkIHtcbiAgICBrdzxcIlNFXCI+XG4gICAga3c8XCJFTlRBT1wiPlxuICAgIGt3PFwiRklNX1NFXCI+XG4gICAga3c8XCJTRU5BT1wiPlxuICAgIGt3PFwiTkFPXCI+XG4gICAga3c8XCJDT05URU5IQVwiPlxuICAgIGt3PFwiT1VcIj5cbiAgICBrdzxcIkVcIj5cbn1cblxua3c8dGVybT4geyBAc3BlY2lhbGl6ZVtAbmFtZT17dGVybX1dPGlkZW50aWZpZXIsIHRlcm0+IH1cblxuQGRldGVjdERlbGltXG5gO1xuIl19

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/models/enums/completion-types.mjs

@@ -0,0 +1,10 @@
+export var CompletionTypes;
+(function (CompletionTypes) {
+    CompletionTypes["Keyword"] = "keyword";
+    CompletionTypes["Context"] = "context";
+    CompletionTypes["Expression"] = "expression";
+    CompletionTypes["UserExpression"] = "userExpression";
+    CompletionTypes["Entity"] = "entity";
+    CompletionTypes["FinalValue"] = "finalValue";
+})(CompletionTypes || (CompletionTypes = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGxldGlvbi10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9jb2RlLWVkaXRvci9zcmMvbGliL2NvZGUtZWRpdG9yL2luZnJhL2NvcmVzL2NvZGVtaXJyb3ItNi9sYW5ndWFnZXMvdGF4LWNhbGN1bGF0aW9uL21vZGVscy9lbnVtcy9jb21wbGV0aW9uLXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGVBT1g7QUFQRCxXQUFZLGVBQWU7SUFDdkIsc0NBQW1CLENBQUE7SUFDbkIsc0NBQW1CLENBQUE7SUFDbkIsNENBQXlCLENBQUE7SUFDekIsb0RBQWlDLENBQUE7SUFDakMsb0NBQWlCLENBQUE7SUFDakIsNENBQXlCLENBQUE7QUFDN0IsQ0FBQyxFQVBXLGVBQWUsS0FBZixlQUFlLFFBTzFCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gQ29tcGxldGlvblR5cGVzIHtcbiAgICBLZXl3b3JkID0gXCJrZXl3b3JkXCIsXG4gICAgQ29udGV4dCA9IFwiY29udGV4dFwiLFxuICAgIEV4cHJlc3Npb24gPSBcImV4cHJlc3Npb25cIixcbiAgICBVc2VyRXhwcmVzc2lvbiA9IFwidXNlckV4cHJlc3Npb25cIixcbiAgICBFbnRpdHkgPSBcImVudGl0eVwiLFxuICAgIEZpbmFsVmFsdWUgPSBcImZpbmFsVmFsdWVcIlxufVxuIl19

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/models/enums/enum-type-order.mjs

@@ -0,0 +1,8 @@
+export var EnumTypeOrder;
+(function (EnumTypeOrder) {
+    // Tipo de ordenação - Crescente
+    EnumTypeOrder["ASC"] = "ASC";
+    // Tipo de ordenação - Decrescente
+    EnumTypeOrder["DESC"] = "DESC";
+})(EnumTypeOrder || (EnumTypeOrder = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW51bS10eXBlLW9yZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL2NvZGUtZWRpdG9yL3NyYy9saWIvY29kZS1lZGl0b3IvaW5mcmEvY29yZXMvY29kZW1pcnJvci02L2xhbmd1YWdlcy90YXgtY2FsY3VsYXRpb24vbW9kZWxzL2VudW1zL2VudW0tdHlwZS1vcmRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxhQUtYO0FBTEQsV0FBWSxhQUFhO0lBQ3JCLGdDQUFnQztJQUNoQyw0QkFBVyxDQUFBO0lBQ1gsa0NBQWtDO0lBQ2xDLDhCQUFhLENBQUE7QUFDakIsQ0FBQyxFQUxXLGFBQWEsS0FBYixhQUFhLFFBS3hCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gRW51bVR5cGVPcmRlciB7XG4gICAgLy8gVGlwbyBkZSBvcmRlbmHDp8OjbyAtIENyZXNjZW50ZVxuICAgIEFTQyA9IFwiQVNDXCIsXG4gICAgLy8gVGlwbyBkZSBvcmRlbmHDp8OjbyAtIERlY3Jlc2NlbnRlXG4gICAgREVTQyA9IFwiREVTQ1wiXG59XG4iXX0=

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/models/enums/keywords.mjs

@@ -0,0 +1,12 @@
+export 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 = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5d29yZHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvY29kZS1lZGl0b3Ivc3JjL2xpYi9jb2RlLWVkaXRvci9pbmZyYS9jb3Jlcy9jb2RlbWlycm9yLTYvbGFuZ3VhZ2VzL3RheC1jYWxjdWxhdGlvbi9tb2RlbHMvZW51bXMva2V5d29yZHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksUUFTWDtBQVRELFdBQVksUUFBUTtJQUNoQixxQkFBUyxDQUFBO0lBQ1QsMkJBQWUsQ0FBQTtJQUNmLGlDQUFxQixDQUFBO0lBQ3JCLDJCQUFlLENBQUE7SUFDZiw2QkFBaUIsQ0FBQTtJQUNqQix1QkFBVyxDQUFBO0lBQ1gsbUJBQU8sQ0FBQTtJQUNQLHFCQUFTLENBQUE7QUFDYixDQUFDLEVBVFcsUUFBUSxLQUFSLFFBQVEsUUFTbkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBLZXl3b3JkcyB7XG4gICAgU0UgPSBcIlNFXCIsXG4gICAgU0VOQU8gPSBcIlNFTkFPXCIsXG4gICAgQ09OVEVOSEEgPSBcIkNPTlRFTkhBXCIsXG4gICAgRU5UQU8gPSBcIkVOVEFPXCIsXG4gICAgRklNX1NFID0gXCJGSU1fU0VcIixcbiAgICBOQU8gPSBcIk5BT1wiLFxuICAgIEUgPSBcIkVcIixcbiAgICBPVSA9IFwiT1VcIlxufVxuIl19

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/models/enums/meta-type.mjs

@@ -0,0 +1,36 @@
+export 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";
+    // DateTime
+    MetaType["LOCALDATETIME"] = "LOCALDATETIME";
+    // 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 = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/code-editor/lib/code-editor/infra/cores/codemirror-6/languages/tax-calculation/models/enums/request-types.mjs

@@ -0,0 +1,9 @@
+export var RequestTypes;
+(function (RequestTypes) {
+    RequestTypes[RequestTypes["ListContextMetadataById"] = 0] = "ListContextMetadataById";
+    RequestTypes[RequestTypes["ListBlobMetadata"] = 1] = "ListBlobMetadata";
+    RequestTypes[RequestTypes["ListExpressionMetadata"] = 2] = "ListExpressionMetadata";
+    RequestTypes[RequestTypes["ListFacadeMetadataNames"] = 3] = "ListFacadeMetadataNames";
+    RequestTypes[RequestTypes["GetFacadeMetadataByPath"] = 4] = "GetFacadeMetadataByPath";
+})(RequestTypes || (RequestTypes = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdC10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9jb2RlLWVkaXRvci9zcmMvbGliL2NvZGUtZWRpdG9yL2luZnJhL2NvcmVzL2NvZGVtaXJyb3ItNi9sYW5ndWFnZXMvdGF4LWNhbGN1bGF0aW9uL21vZGVscy9lbnVtcy9yZXF1ZXN0LXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFlBTVg7QUFORCxXQUFZLFlBQVk7SUFDcEIscUZBQXVCLENBQUE7SUFDdkIsdUVBQWdCLENBQUE7SUFDaEIsbUZBQXNCLENBQUE7SUFDdEIscUZBQXVCLENBQUE7SUFDdkIscUZBQXVCLENBQUE7QUFDM0IsQ0FBQyxFQU5XLFlBQVksS0FBWixZQUFZLFFBTXZCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gUmVxdWVzdFR5cGVzIHtcbiAgICBMaXN0Q29udGV4dE1ldGFkYXRhQnlJZCxcbiAgICBMaXN0QmxvYk1ldGFkYXRhLFxuICAgIExpc3RFeHByZXNzaW9uTWV0YWRhdGEsXG4gICAgTGlzdEZhY2FkZU1ldGFkYXRhTmFtZXMsXG4gICAgR2V0RmFjYWRlTWV0YWRhdGFCeVBhdGgsXG59XG4iXX0=