@sap-ux/fiori-annotation-api 0.11.1 → 1.0.0

package/dist/cds/writer.js

@@ -1,28 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CDSWriter = void 0;
-const node_path_1 = require("node:path");
-const node_url_1 = require("node:url");
-const project_access_1 = require("@sap-ux/project-access");
-const odata_annotation_core_1 = require("@sap-ux/odata-annotation-core");
-const ux_cds_compiler_facade_1 = require("@sap/ux-cds-compiler-facade");
-const cds_annotation_parser_1 = require("@sap-ux/cds-annotation-parser");
-const cds_odata_annotation_converter_1 = require("@sap-ux/cds-odata-annotation-converter");
-const utils_1 = require("../utils");
-const error_1 = require("../error");
-const document_1 = require("./document");
-const deletion_1 = require("./deletion");
-const pointer_1 = require("./pointer");
-const change_1 = require("./change");
-const preprocessor_1 = require("./preprocessor");
-const cds_compiler_tokens_1 = require("./cds-compiler-tokens");
-const indent_1 = require("./indent");
-const printOptions = { ...odata_annotation_core_1.printOptions, useSnippetSyntax: false };
+import { relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { toReferenceUri } from '@sap-ux/project-access';
+import { TextEdit, printOptions as defaultPrintOptions, Position, Edm, Range, rangeContained, TEXT_TYPE } from '@sap-ux/odata-annotation-core';
+import cdsCompilerFacade from '@sap/ux-cds-compiler-facade';
+const { createMetadataCollector } = cdsCompilerFacade;
+import { copyRange, ENUM_TYPE, STRING_LITERAL_TYPE, ReservedProperties, ANNOTATION_TYPE, COLLECTION_TYPE, RECORD_PROPERTY_TYPE, RECORD_TYPE, copyPosition, ANNOTATION_GROUP_TYPE, ANNOTATION_GROUP_ITEMS_TYPE } from '@sap-ux/cds-annotation-parser';
+import { TARGET_TYPE, printPrimitiveValue, indent, print, printTarget } from '@sap-ux/cds-odata-annotation-converter';
+import { increaseIndent, compareByRange } from '../utils/index.js';
+import { ApiError } from '../error.js';
+import { CDS_DOCUMENT_TYPE, getChildCount, getItems } from './document.js';
+import { getTextEditsForDeletionRanges, getDeletionRangeForNode } from './deletion.js';
+import { getAstNodesFromPointer } from './pointer.js';
+import { INSERT_PRIMITIVE_VALUE_TYPE, MOVE_COLLECTION_VALUE_CHANGE_TYPE, DELETE_ANNOTATION_CHANGE_TYPE, INSERT_ANNOTATION_CHANGE_TYPE, INSERT_TARGET_CHANGE_TYPE, INSERT_RECORD_CHANGE_TYPE, INSERT_COLLECTION_CHANGE_TYPE, INSERT_EMBEDDED_ANNOTATION_CHANGE_TYPE, INSERT_RECORD_PROPERTY_CHANGE_TYPE, INSERT_QUALIFIER_CHANGE_TYPE, INSERT_REFERENCE_CHANGE_TYPE, DELETE_EMBEDDED_ANNOTATION_CHANGE_TYPE, DELETE_PRIMITIVE_VALUE_CHANGE_TYPE, DELETE_QUALIFIER_CHANGE_TYPE, DELETE_RECORD_CHANGE_TYPE, DELETE_RECORD_PROPERTY_CHANGE_TYPE, REPLACE_NODE_CHANGE_TYPE, REPLACE_RECORD_PROPERTY_CHANGE_TYPE, SET_FLAGS_CHANGE_TYPE, UPDATE_PRIMITIVE_VALUE_CHANGE_TYPE, REPLACE_TEXT_VALUE_CHANGE_TYPE, DELETE_TARGET_CHANGE_TYPE, CONVERT_TO_COMPOUND_ANNOTATION_CHANGE_TYPE, DELETE_ANNOTATION_GROUP_CHANGE_TYPE, DELETE_ANNOTATION_GROUP_ITEMS_CHANGE_TYPE, createDeleteAnnotationChange } from './change.js';
+import { createReferenceElement, preprocessChanges } from './preprocessor.js';
+import { findLastTokenBeforePosition, findFirstTokenAfterPosition, matchTokenByStart, createTokenRange, isOldToken, tokenLine, tokenColumn } from './cds-compiler-tokens.js';
+import { getIndentLevelFromPointer, getIndentLevelFromNode } from './indent.js';
+const printOptions = { ...defaultPrintOptions, useSnippetSyntax: false };
 const ANNOTATION_START_PATTERN = /^@/i;
 /**
  *
  */
-class CDSWriter {
+export class CDSWriter {
     facade;
     vocabularyService;
     document;
@@ -84,9 +82,9 @@ class CDSWriter {
      */
     async getTextEdits() {
         this.resetState();
-        this.processedChanges = (0, preprocessor_1.preprocessChanges)(this.document, this.changes, this.tokens);
+        this.processedChanges = preprocessChanges(this.document, this.changes, this.tokens);
         for (const change of this.processedChanges) {
-            const path = (0, pointer_1.getAstNodesFromPointer)(this.document, change.pointer).reverse();
+            const path = getAstNodesFromPointer(this.document, change.pointer).reverse();
             const handler = this[change.type];
             const result = handler(change, path);
             if (result instanceof Promise) {
@@ -96,12 +94,12 @@ class CDSWriter {
         for (const key of this.deletionRangesMapForTarget.keys()) {
             const deletionRanges = this.deletionRangesMapForTarget.get(key) ?? [];
             if (deletionRanges.length > 0) {
-                const targetDeletions = (0, deletion_1.getTextEditsForDeletionRanges)(deletionRanges, this.vocabularyAliases, this.tokens, this.annotationFile, false);
+                const targetDeletions = getTextEditsForDeletionRanges(deletionRanges, this.vocabularyAliases, this.tokens, this.annotationFile, false);
                 this.edits.push(...targetDeletions);
             }
         }
         this.edits.unshift(...this.referenceEdits);
-        this.edits.sort(utils_1.compareByRange);
+        this.edits.sort(compareByRange);
         return this.edits;
     }
     /**
@@ -121,13 +119,13 @@ class CDSWriter {
         if (cachedValue !== undefined) {
             return cachedValue;
         }
-        const level = (0, indent_1.getIndentLevelFromPointer)(this.document, this.tokens, pointer);
+        const level = getIndentLevelFromPointer(this.document, this.tokens, pointer);
         this.indentLevelCache[pointer] = level;
         return level;
     }
     //#region Inserts
     isFirstInsert(pointer, node, index = -1) {
-        const childCount = (0, document_1.getChildCount)(node);
+        const childCount = getChildCount(node);
         const i = index > -1 ? Math.min(index, childCount) : childCount;
         const insertPositionKey = `${pointer}/${i}`;
         const firstInsert = !this.uniqueInserts.has(insertPositionKey);
@@ -135,7 +133,7 @@ class CDSWriter {
         return firstInsert;
     }
     // Change Handlers
-    [change_1.INSERT_TARGET_CHANGE_TYPE] = (change) => {
+    [INSERT_TARGET_CHANGE_TYPE] = (change) => {
         if (!this.document.range) {
             return;
         }
@@ -145,63 +143,63 @@ class CDSWriter {
             prefix = '\n';
             position.character = 0;
         }
-        const newElements = prefix + (0, cds_odata_annotation_converter_1.printTarget)(change.target, change.complexTypePathSegments) + '\n';
-        const edits = [odata_annotation_core_1.TextEdit.insert(position, newElements)];
+        const newElements = prefix + printTarget(change.target, change.complexTypePathSegments) + '\n';
+        const edits = [TextEdit.insert(position, newElements)];
         this.edits.push(...edits);
     };
-    [change_1.INSERT_RECORD_CHANGE_TYPE] = (change, reversePath) => {
+    [INSERT_RECORD_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
         const indentLevel = this.getIndentLevel(change.pointer);
         // inserting new record as value eg: annotate IncidentService.Incidents with @UI.Chart;
-        if ((astNode?.type === cds_annotation_parser_1.ANNOTATION_TYPE || astNode?.type === cds_annotation_parser_1.RECORD_PROPERTY_TYPE) && astNode.range) {
+        if ((astNode?.type === ANNOTATION_TYPE || astNode?.type === RECORD_PROPERTY_TYPE) && astNode.range) {
             const recordText = ' : ' +
-                (0, cds_odata_annotation_converter_1.indent)((0, cds_odata_annotation_converter_1.print)(change.element, printOptions, { indentResult: false }), {
+                indent(print(change.element, printOptions, { indentResult: false }), {
                     level: indentLevel,
                     skipFirstLine: true
                 });
             const position = astNode.range.end;
-            this.edits.push(odata_annotation_core_1.TextEdit.insert(position, recordText));
+            this.edits.push(TextEdit.insert(position, recordText));
         }
-        if (astNode?.type === cds_annotation_parser_1.COLLECTION_TYPE) {
+        if (astNode?.type === COLLECTION_TYPE) {
             const content = getContainerContent(astNode, this.comments, this.tokens);
             this.insertIntoNodeWithContent(content, astNode, change, indentLevel, this.isFirstInsert(change.pointer, astNode, change.index));
         }
     };
-    [change_1.INSERT_COLLECTION_CHANGE_TYPE] = (change, reversePath) => {
+    [INSERT_COLLECTION_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
         const indentLevel = this.getIndentLevel(change.pointer);
-        const collectionText = change.element.content.length ? (0, cds_odata_annotation_converter_1.print)(change.element) : '[]';
+        const collectionText = change.element.content.length ? print(change.element) : '[]';
         const textWithPrefix = ` : ${collectionText}`;
         const position = astNode?.range?.end;
         if (position) {
-            const text = (0, cds_odata_annotation_converter_1.indent)(textWithPrefix, { level: indentLevel + 1, skipFirstLine: true });
-            this.edits.push(odata_annotation_core_1.TextEdit.insert(position, text));
+            const text = indent(textWithPrefix, { level: indentLevel + 1, skipFirstLine: true });
+            this.edits.push(TextEdit.insert(position, text));
         }
     };
-    [change_1.INSERT_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
+    [INSERT_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
-        if (astNode?.type !== cds_odata_annotation_converter_1.TARGET_TYPE && astNode?.type !== cds_annotation_parser_1.ANNOTATION_GROUP_ITEMS_TYPE) {
+        if (astNode?.type !== TARGET_TYPE && astNode?.type !== ANNOTATION_GROUP_ITEMS_TYPE) {
             return;
         }
         const indentLevel = this.getIndentLevel(change.pointer);
         const content = getContainerContent(astNode, this.comments, this.tokens);
         this.convertInsertNodeToTextEdits(content, astNode, change, indentLevel, this.isFirstInsert(change.pointer, astNode, change.index));
     };
-    [change_1.INSERT_EMBEDDED_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
+    [INSERT_EMBEDDED_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode, parent] = reversePath;
         const indentLevel = this.getIndentLevel(change.pointer);
-        if (astNode?.type === cds_annotation_parser_1.RECORD_TYPE) {
+        if (astNode?.type === RECORD_TYPE) {
             const content = getContainerContent(astNode, this.comments, this.tokens);
             this.insertIntoNodeWithContent(content, astNode, change, indentLevel, this.isFirstInsert(change.pointer, astNode, change.index));
         }
-        else if (astNode?.type === cds_annotation_parser_1.ANNOTATION_TYPE) {
+        else if (astNode?.type === ANNOTATION_TYPE) {
             // we're inserting into the parent, not the value
             let adjustedIndentLevel = indentLevel - 1;
             if (willTargetAnnotationIncreaseIndent(this.processedChanges, change.pointer)) {
                 adjustedIndentLevel++;
             }
             if (astNode.value?.range &&
-                (parent?.type === cds_odata_annotation_converter_1.TARGET_TYPE || parent?.type === cds_annotation_parser_1.ANNOTATION_GROUP_ITEMS_TYPE)) {
+                (parent?.type === TARGET_TYPE || parent?.type === ANNOTATION_GROUP_ITEMS_TYPE)) {
                 const content = getContainerContent(parent, this.comments, this.tokens);
                 this.insertIntoNodeWithContent(content, parent, change, adjustedIndentLevel, 
                 // adjust pointer to match the parent node, because we're inserting into the parent
@@ -209,40 +207,40 @@ class CDSWriter {
             }
         }
     };
-    [change_1.INSERT_RECORD_PROPERTY_CHANGE_TYPE] = (change, reversePath) => {
+    [INSERT_RECORD_PROPERTY_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
         const indentLevel = this.getIndentLevel(change.pointer);
-        if (astNode?.type !== cds_annotation_parser_1.RECORD_TYPE) {
+        if (astNode?.type !== RECORD_TYPE) {
             return;
         }
         const content = getContainerContent(astNode, this.comments, this.tokens);
         this.convertInsertNodeToTextEdits(content, astNode, change, indentLevel, this.isFirstInsert(change.pointer, astNode, change.index));
     };
-    [change_1.INSERT_PRIMITIVE_VALUE_TYPE] = (change, reversePath) => {
+    [INSERT_PRIMITIVE_VALUE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
         const indentLevel = this.getIndentLevel(change.pointer);
-        if (astNode?.type === cds_annotation_parser_1.COLLECTION_TYPE) {
+        if (astNode?.type === COLLECTION_TYPE) {
             const content = getContainerContent(astNode, this.comments, this.tokens);
             this.convertInsertNodeToTextEdits(content, astNode, change, indentLevel, this.isFirstInsert(change.pointer, astNode, change.index));
         }
-        else if ((astNode?.type === cds_annotation_parser_1.RECORD_PROPERTY_TYPE || astNode?.type === cds_annotation_parser_1.ANNOTATION_TYPE) && astNode.range) {
+        else if ((astNode?.type === RECORD_PROPERTY_TYPE || astNode?.type === ANNOTATION_TYPE) && astNode.range) {
             const textNode = change.element.content[0];
-            const value = textNode?.type === odata_annotation_core_1.TEXT_TYPE ? textNode.text : '';
-            const recordText = ' : ' + (0, cds_odata_annotation_converter_1.indent)((0, cds_odata_annotation_converter_1.printPrimitiveValue)(change.element.name, value));
-            this.edits.push(odata_annotation_core_1.TextEdit.insert(astNode.range.end, recordText));
+            const value = textNode?.type === TEXT_TYPE ? textNode.text : '';
+            const recordText = ' : ' + indent(printPrimitiveValue(change.element.name, value));
+            this.edits.push(TextEdit.insert(astNode.range.end, recordText));
         }
     };
-    [change_1.INSERT_QUALIFIER_CHANGE_TYPE] = (change, reversePath) => {
+    [INSERT_QUALIFIER_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
-        if (astNode?.type === cds_annotation_parser_1.ANNOTATION_TYPE && astNode.term.range) {
-            this.edits.push(odata_annotation_core_1.TextEdit.insert(astNode.term.range.end, ` #${change.value}`));
+        if (astNode?.type === ANNOTATION_TYPE && astNode.term.range) {
+            this.edits.push(TextEdit.insert(astNode.term.range.end, ` #${change.value}`));
         }
     };
-    [change_1.INSERT_REFERENCE_CHANGE_TYPE] = async (change) => {
+    [INSERT_REFERENCE_CHANGE_TYPE] = async (change) => {
         const { position, prependNewLine } = getInsertReferencePosition(this.document.references);
         // TODO: this breaks memfs concept
         const text = `${prependNewLine ? '\n' : ''}${await getTextEditForMissingRefs(change.references, this.document.uri, this.projectRoot)}`;
-        this.referenceEdits.push(odata_annotation_core_1.TextEdit.insert(position, text));
+        this.referenceEdits.push(TextEdit.insert(position, text));
     };
     //#endregion
     //#region Deletes
@@ -252,57 +250,57 @@ class CDSWriter {
         const lastIndex = segments.pop();
         deleteValue(this.edits, pointer, astNode, parent, this.comments, this.tokens, lastIndex);
     }
-    [change_1.DELETE_TARGET_CHANGE_TYPE] = (_change, reversePath) => {
+    [DELETE_TARGET_CHANGE_TYPE] = (_change, reversePath) => {
         const [astNode] = reversePath;
-        if (astNode?.type !== cds_odata_annotation_converter_1.TARGET_TYPE || !astNode.range || !astNode.nameRange) {
+        if (astNode?.type !== TARGET_TYPE || !astNode.range || !astNode.nameRange) {
             return;
         }
         // TODO: check if we can relay on target.kind instead of going through edmx conversions
-        const { edmxPath } = this.facade.collectMetadataForAbsolutePath(astNode.name, astNode.kind, (0, ux_cds_compiler_facade_1.createMetadataCollector)(new Map(), this.facade));
+        const { edmxPath } = this.facade.collectMetadataForAbsolutePath(astNode.name, astNode.kind, createMetadataCollector(new Map(), this.facade));
         const ranges = astNode.assignments
-            .flatMap((assignment) => (assignment.type === cds_annotation_parser_1.ANNOTATION_TYPE ? [assignment] : assignment.items.items))
+            .flatMap((assignment) => (assignment.type === ANNOTATION_TYPE ? [assignment] : assignment.items.items))
             .map((annotation, i) => {
-            return (0, deletion_1.getDeletionRangeForNode)(this.vocabularyService, this.vocabularyAliases, i, this.tokens, annotation, edmxPath);
+            return getDeletionRangeForNode(this.vocabularyService, this.vocabularyAliases, i, this.tokens, annotation, edmxPath);
         })
             .filter((range) => !!range);
-        const targetDeletions = (0, deletion_1.getTextEditsForDeletionRanges)(ranges, this.vocabularyAliases, this.tokens, this.annotationFile, true);
+        const targetDeletions = getTextEditsForDeletionRanges(ranges, this.vocabularyAliases, this.tokens, this.annotationFile, true);
         if (targetDeletions) {
             this.edits.push(...targetDeletions);
         }
     };
-    [change_1.DELETE_RECORD_CHANGE_TYPE] = (change, reversePath) => {
+    [DELETE_RECORD_CHANGE_TYPE] = (change, reversePath) => {
         this.deleteNode(change.pointer, reversePath);
     };
-    [change_1.DELETE_RECORD_PROPERTY_CHANGE_TYPE] = (change, reversePath) => {
+    [DELETE_RECORD_PROPERTY_CHANGE_TYPE] = (change, reversePath) => {
         this.deleteNode(change.pointer, reversePath);
     };
-    [change_1.DELETE_ANNOTATION_GROUP_CHANGE_TYPE] = (change, reversePath) => {
+    [DELETE_ANNOTATION_GROUP_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode, parent] = reversePath;
         const segments = change.pointer.split('/');
         const lastIndex = segments.pop() ?? '';
         const index = Number.parseInt(lastIndex, 10);
-        if (Number.isNaN(index) || astNode?.type !== cds_annotation_parser_1.ANNOTATION_GROUP_TYPE || parent?.type !== cds_odata_annotation_converter_1.TARGET_TYPE) {
+        if (Number.isNaN(index) || astNode?.type !== ANNOTATION_GROUP_TYPE || parent?.type !== TARGET_TYPE) {
             return;
         }
         const content = getContainerContent(parent, this.comments, this.tokens);
         const { startContentIndex } = findContentIndices(content, index, index);
         deleteBlock(this.edits, content, startContentIndex);
     };
-    [change_1.DELETE_ANNOTATION_GROUP_ITEMS_CHANGE_TYPE] = () => {
+    [DELETE_ANNOTATION_GROUP_ITEMS_CHANGE_TYPE] = () => {
         // should never be called
         // preprocessor converts these changes to DeleteAnnotationGroup
     };
     getDeletionRange(annotation, target, index) {
-        const { edmxPath } = this.facade.collectMetadataForAbsolutePath(target.name, target.kind, (0, ux_cds_compiler_facade_1.createMetadataCollector)(new Map(), this.facade));
-        return (0, deletion_1.getDeletionRangeForNode)(this.vocabularyService, this.vocabularyAliases, index, this.tokens, annotation, edmxPath);
+        const { edmxPath } = this.facade.collectMetadataForAbsolutePath(target.name, target.kind, createMetadataCollector(new Map(), this.facade));
+        return getDeletionRangeForNode(this.vocabularyService, this.vocabularyAliases, index, this.tokens, annotation, edmxPath);
     }
-    [change_1.DELETE_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
+    [DELETE_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
         const [annotation, parent, , greatGrandParent] = reversePath;
         const segments = change.pointer.split('/');
         const lastIndex = segments.pop();
-        const isInAnnotationGroup = greatGrandParent?.type === cds_odata_annotation_converter_1.TARGET_TYPE;
+        const isInAnnotationGroup = greatGrandParent?.type === TARGET_TYPE;
         const target = isInAnnotationGroup ? greatGrandParent : parent;
-        if (!lastIndex || annotation?.type !== cds_annotation_parser_1.ANNOTATION_TYPE || target.type !== cds_odata_annotation_converter_1.TARGET_TYPE) {
+        if (!lastIndex || annotation?.type !== ANNOTATION_TYPE || target.type !== TARGET_TYPE) {
             return;
         }
         const targetPointer = change.pointer.split('/').slice(0, 3).join('/');
@@ -314,7 +312,7 @@ class CDSWriter {
         // We need to calculate correct indices for the annotations
         for (let i = 0; i < target.assignments.length; i++) {
             const assignment = target.assignments[i];
-            if (assignment.type === cds_annotation_parser_1.ANNOTATION_GROUP_TYPE) {
+            if (assignment.type === ANNOTATION_GROUP_TYPE) {
                 index += assignment.items.items.length;
             }
             else {
@@ -335,43 +333,43 @@ class CDSWriter {
         }
         targetDeletionRanges.push(range);
     };
-    [change_1.DELETE_EMBEDDED_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
+    [DELETE_EMBEDDED_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode, parent] = reversePath;
-        if (astNode?.type === cds_annotation_parser_1.ANNOTATION_TYPE) {
-            if (parent.type === cds_annotation_parser_1.RECORD_TYPE) {
+        if (astNode?.type === ANNOTATION_TYPE) {
+            if (parent.type === RECORD_TYPE) {
                 // Transform $value back to normal primitive value representation if last embedded annotation is being deleted
                 const firstProperty = parent.properties[0];
                 const isTransformPossible = parent.annotations?.length === 1 &&
                     parent.properties.length === 1 &&
-                    firstProperty.name.value === cds_annotation_parser_1.ReservedProperties.Value;
+                    firstProperty.name.value === ReservedProperties.Value;
                 if (isTransformPossible && parent.range && firstProperty.value?.range) {
                     // delete surrounding record parts, leaving property value only
-                    this.edits.push(odata_annotation_core_1.TextEdit.del(odata_annotation_core_1.Range.create(parent.range.start, firstProperty.value.range.start)), odata_annotation_core_1.TextEdit.del(odata_annotation_core_1.Range.create(firstProperty.value.range.end, parent.range.end)));
+                    this.edits.push(TextEdit.del(Range.create(parent.range.start, firstProperty.value.range.start)), TextEdit.del(Range.create(firstProperty.value.range.end, parent.range.end)));
                 }
                 else {
                     this.deleteNode(change.pointer, reversePath);
                 }
             }
             else {
-                this[change_1.DELETE_ANNOTATION_CHANGE_TYPE]((0, change_1.createDeleteAnnotationChange)(change.pointer), reversePath);
+                this[DELETE_ANNOTATION_CHANGE_TYPE](createDeleteAnnotationChange(change.pointer), reversePath);
             }
         }
     };
-    [change_1.DELETE_PRIMITIVE_VALUE_CHANGE_TYPE] = (change, reversePath) => {
+    [DELETE_PRIMITIVE_VALUE_CHANGE_TYPE] = (change, reversePath) => {
         this.deleteNode(change.pointer, reversePath);
     };
-    [change_1.DELETE_QUALIFIER_CHANGE_TYPE] = (change, reversePath) => {
+    [DELETE_QUALIFIER_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
         if (!astNode?.range) {
             return;
         }
-        const range = (0, cds_annotation_parser_1.copyRange)(astNode.range);
+        const range = copyRange(astNode.range);
         range.start.character--; // also include # character
-        this.edits.push(odata_annotation_core_1.TextEdit.del(range));
+        this.edits.push(TextEdit.del(range));
     };
     //#endregion
     //#region Modifications
-    [change_1.REPLACE_NODE_CHANGE_TYPE] = (change, reversePath) => {
+    [REPLACE_NODE_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
         if (!astNode?.range) {
             return;
@@ -380,23 +378,23 @@ class CDSWriter {
         if (willTargetAnnotationIncreaseIndent(this.processedChanges, change.pointer)) {
             indentLevel++;
         }
-        const fragment = (0, cds_odata_annotation_converter_1.print)(change.newElement, printOptions);
-        const indentedFragment = (0, utils_1.increaseIndent)(fragment, indentLevel, true);
-        this.edits.push(odata_annotation_core_1.TextEdit.replace(astNode.range, indentedFragment));
+        const fragment = print(change.newElement, printOptions);
+        const indentedFragment = increaseIndent(fragment, indentLevel, true);
+        this.edits.push(TextEdit.replace(astNode.range, indentedFragment));
     };
-    [change_1.REPLACE_RECORD_PROPERTY_CHANGE_TYPE] = (change, reversePath) => {
+    [REPLACE_RECORD_PROPERTY_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
         const indentLevel = this.getIndentLevel(change.pointer);
         if (!astNode?.range) {
             return;
         }
-        const text = (0, cds_odata_annotation_converter_1.indent)((0, cds_odata_annotation_converter_1.print)(change.newProperty, printOptions, { indentResult: false }), {
+        const text = indent(print(change.newProperty, printOptions, { indentResult: false }), {
             level: indentLevel + 1,
             skipFirstLine: true
         });
-        this.edits.push(odata_annotation_core_1.TextEdit.replace(astNode.range, text));
+        this.edits.push(TextEdit.replace(astNode.range, text));
     };
-    [change_1.REPLACE_TEXT_VALUE_CHANGE_TYPE] = (change, reversePath) => {
+    [REPLACE_TEXT_VALUE_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
         if (!astNode?.range) {
             return;
@@ -409,40 +407,40 @@ class CDSWriter {
             console.warn(`Could not determine expression type for ${JSON.stringify(change, undefined, 2)}. For changing enum flags "set-flags" change should be used.`);
             return;
         }
-        this.edits.push(odata_annotation_core_1.TextEdit.replace(astNode.range, (0, cds_odata_annotation_converter_1.printPrimitiveValue)(expressionType, change.newValue)));
+        this.edits.push(TextEdit.replace(astNode.range, printPrimitiveValue(expressionType, change.newValue)));
     };
-    [change_1.UPDATE_PRIMITIVE_VALUE_CHANGE_TYPE] = (change, reversePath) => {
+    [UPDATE_PRIMITIVE_VALUE_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
         if (!astNode?.range) {
             return;
         }
-        if (astNode.type === cds_annotation_parser_1.STRING_LITERAL_TYPE) {
-            const range = (0, cds_annotation_parser_1.copyRange)(astNode.range);
+        if (astNode.type === STRING_LITERAL_TYPE) {
+            const range = copyRange(astNode.range);
             // string range includes quotes, but we only need to replace content.
             range.start.character++;
             range.end.character--;
-            this.edits.push(odata_annotation_core_1.TextEdit.replace(range, change.newValue));
+            this.edits.push(TextEdit.replace(range, change.newValue));
         }
-        else if (astNode.type === cds_annotation_parser_1.ENUM_TYPE && astNode.path.range) {
-            this.edits.push(odata_annotation_core_1.TextEdit.replace(astNode.range, (0, cds_odata_annotation_converter_1.printPrimitiveValue)("EnumMember" /* Edm.EnumMember */, change.newValue)));
+        else if (astNode.type === ENUM_TYPE && astNode.path.range) {
+            this.edits.push(TextEdit.replace(astNode.range, printPrimitiveValue(Edm.EnumMember, change.newValue)));
         }
         else {
-            this.edits.push(odata_annotation_core_1.TextEdit.replace(astNode.range, change.newValue));
+            this.edits.push(TextEdit.replace(astNode.range, change.newValue));
         }
     };
     //#endregion
-    [change_1.SET_FLAGS_CHANGE_TYPE] = (change, reversePath) => {
+    [SET_FLAGS_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
-        if (astNode?.type === cds_annotation_parser_1.COLLECTION_TYPE && astNode.range) {
-            this.edits.push(odata_annotation_core_1.TextEdit.replace(astNode.range, (0, cds_odata_annotation_converter_1.printPrimitiveValue)("EnumMember" /* Edm.EnumMember */, change.value)));
+        if (astNode?.type === COLLECTION_TYPE && astNode.range) {
+            this.edits.push(TextEdit.replace(astNode.range, printPrimitiveValue(Edm.EnumMember, change.value)));
         }
-        else if (astNode?.type === cds_annotation_parser_1.ENUM_TYPE) {
-            console.warn(`Could not apply change "set-flags". Expected target to be '${cds_annotation_parser_1.COLLECTION_TYPE}, but got ${cds_annotation_parser_1.ENUM_TYPE}. To replace single enum value 'replace-text-value' change should be used`);
+        else if (astNode?.type === ENUM_TYPE) {
+            console.warn(`Could not apply change "set-flags". Expected target to be '${COLLECTION_TYPE}, but got ${ENUM_TYPE}. To replace single enum value 'replace-text-value' change should be used`);
         }
     };
-    [change_1.MOVE_COLLECTION_VALUE_CHANGE_TYPE] = (change, reversePath) => {
+    [MOVE_COLLECTION_VALUE_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
-        if (astNode.type !== cds_annotation_parser_1.COLLECTION_TYPE) {
+        if (astNode.type !== COLLECTION_TYPE) {
             return;
         }
         const content = getContainerContent(astNode, this.comments, this.tokens);
@@ -450,7 +448,7 @@ class CDSWriter {
         const indentLevel = this.getIndentLevel(change.pointer);
         if (anchor) {
             if (anchor.commaPosition) {
-                this.edits.push(odata_annotation_core_1.TextEdit.insert(anchor.commaPosition, ','));
+                this.edits.push(TextEdit.insert(anchor.commaPosition, ','));
             }
             const ranges = createElementRanges(this.document, this.tokens, change.fromPointers);
             const moveEdits = getTextEditsForMove({
@@ -465,13 +463,13 @@ class CDSWriter {
                 astNode.closeToken?.range?.end?.line === astNode.openToken?.range?.end?.line) {
                 // [] is on the same line -> we need to expand this to multiple lines
                 const indent = '    '.repeat(indentLevel);
-                this.edits.push(odata_annotation_core_1.TextEdit.insert(astNode.closeToken.range.start, '\n' + indent));
+                this.edits.push(TextEdit.insert(astNode.closeToken.range.start, '\n' + indent));
             }
         }
     };
-    [change_1.CONVERT_TO_COMPOUND_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
+    [CONVERT_TO_COMPOUND_ANNOTATION_CHANGE_TYPE] = (change, reversePath) => {
         const [astNode] = reversePath;
-        if (astNode?.type !== cds_odata_annotation_converter_1.TARGET_TYPE) {
+        if (astNode?.type !== TARGET_TYPE) {
             return;
         }
         const indentLevel = this.getIndentLevel(change.pointer);
@@ -481,23 +479,23 @@ class CDSWriter {
         }
     };
     insertIntoNodeWithContent(content, parent, change, indentLevel, firstInsert, referenceNode) {
-        const index = getIndexForInsertion((0, document_1.getChildCount)(parent), change.index);
+        const index = getIndexForInsertion(getChildCount(parent), change.index);
         // change.index should not be used in this scope, because changes with indices outside the container size are merged
         // and change.index would not correctly reflect the place where a change needs to be inserted
         if (!change || !parent.range) {
             return;
         }
         const newElements = printChange(parent, referenceNode)(change);
-        if ((0, document_1.getChildCount)(parent) === 0) {
+        if (getChildCount(parent) === 0) {
             const fragments = [];
-            const range = (0, cds_annotation_parser_1.copyRange)(parent.range);
+            const range = copyRange(parent.range);
             // we need to adjust range to exclude boundary characters
             range.start.character++; // range includes '{' or '[' characters
             range.end.character--; // range includes '}' or ']' characters
             fragments.push('\n');
             fragments.push(newElements);
             fragments.push(',');
-            const text = (0, cds_odata_annotation_converter_1.indent)(deIndent(fragments.join('')), {
+            const text = indent(deIndent(fragments.join('')), {
                 level: indentLevel + 1,
                 skipFirstLine: true
             });
@@ -516,22 +514,22 @@ class CDSWriter {
             const fragments = [];
             if (firstInsert && anchor.commaPosition) {
                 // for repeated inserts at the same spot we'll already have the trailing comma
-                this.edits.push(odata_annotation_core_1.TextEdit.insert(anchor.commaPosition, ','));
+                this.edits.push(TextEdit.insert(anchor.commaPosition, ','));
             }
             fragments.push('\n');
             fragments.push(newElements);
             fragments.push(',');
             let finalText = fragments.join('');
             finalText = deIndent(finalText);
-            const text = (0, cds_odata_annotation_converter_1.indent)(finalText, {
+            const text = indent(finalText, {
                 level: indentLevel + 1,
                 skipFirstLine: true
             });
-            this.edits.push(odata_annotation_core_1.TextEdit.insert(anchor.position, text));
+            this.edits.push(TextEdit.insert(anchor.position, text));
         }
     }
     insertFirstText(range, text, indentLevel) {
-        this.edits.push(odata_annotation_core_1.TextEdit.replace(range, text + (0, cds_odata_annotation_converter_1.indent)('\n', { level: indentLevel, skipFirstLine: true })));
+        this.edits.push(TextEdit.replace(range, text + indent('\n', { level: indentLevel, skipFirstLine: true })));
     }
     insertAdditionalText(range, text) {
         // Multiple inserts will have the same replacement range, we need to group them because
@@ -547,17 +545,17 @@ class CDSWriter {
         if (!change) {
             return;
         }
-        if (parent.type !== document_1.CDS_DOCUMENT_TYPE) {
+        if (parent.type !== CDS_DOCUMENT_TYPE) {
             this.insertIntoNodeWithContent(content, parent, change, childIndentLevel, firstInsert);
         }
     }
     findInsertPosition(content, parent, insertionPointer, index = -1) {
-        const childCount = (0, document_1.getChildCount)(parent);
+        const childCount = getChildCount(parent);
         if (childCount === 0) {
             if (!parent.range) {
                 return undefined;
             }
-            const position = (0, cds_annotation_parser_1.copyPosition)(parent.range.start);
+            const position = copyPosition(parent.range.start);
             position.character++; // range includes '{' or '[' characters
             return { position };
         }
@@ -572,7 +570,7 @@ class CDSWriter {
                 if (!skipCommaInsertion(this.changes, content, this.document, previousContentIndex)) {
                     return {
                         position: anchor,
-                        commaPosition: (0, cds_annotation_parser_1.copyPosition)(previousElement.element.range.end)
+                        commaPosition: copyPosition(previousElement.element.range.end)
                     };
                 }
             }
@@ -581,10 +579,9 @@ class CDSWriter {
         return undefined;
     }
 }
-exports.CDSWriter = CDSWriter;
 function willTargetAnnotationIncreaseIndent(changes, pointer) {
     const targetPointer = pointer.split('/').slice(0, 3).join('/');
-    const conversionChange = changes.find((change) => change.pointer === targetPointer && change.type === change_1.CONVERT_TO_COMPOUND_ANNOTATION_CHANGE_TYPE);
+    const conversionChange = changes.find((change) => change.pointer === targetPointer && change.type === CONVERT_TO_COMPOUND_ANNOTATION_CHANGE_TYPE);
     return !!conversionChange;
 }
 function convertToCompoundAnnotation(tokens, node, indentLevel, indentContent) {
@@ -593,7 +590,7 @@ function convertToCompoundAnnotation(tokens, node, indentLevel, indentContent) {
     }
     // All assignments are grouped to the same target, but we only need to replace the last one.
     const startPosition = node.assignments[node.assignments.length - 1]?.range?.start ?? node.range?.start;
-    const startToken = (0, cds_compiler_tokens_1.findLastTokenBeforePosition)(ANNOTATION_START_PATTERN, tokens, startPosition);
+    const startToken = findLastTokenBeforePosition(ANNOTATION_START_PATTERN, tokens, startPosition);
     if (!startToken) {
         return [];
     }
@@ -602,7 +599,7 @@ function convertToCompoundAnnotation(tokens, node, indentLevel, indentContent) {
         return [];
     }
     // there can be trailing comma before the closing token ')' or ';'
-    const afterEndToken = (0, cds_compiler_tokens_1.findFirstTokenAfterPosition)(/[^,]/, tokens, node.range?.end);
+    const afterEndToken = findFirstTokenAfterPosition(/[^,]/, tokens, node.range?.end);
     // there should always be an afterEndToken
     // if it is an annotation on element then it would at least end with '}'
     // if it is an annotation on entity then it would be ';'
@@ -610,37 +607,37 @@ function convertToCompoundAnnotation(tokens, node, indentLevel, indentContent) {
         // either its a compound annotation or there is something else wrong and we should create text edits
         return [];
     }
-    const endToken = (0, cds_compiler_tokens_1.findLastTokenBeforePosition)(undefined, tokens, node.range?.end);
+    const endToken = findLastTokenBeforePosition(undefined, tokens, node.range?.end);
     if (!endToken) {
         return [];
     }
     const indentText = '    '.repeat(indentLevel + 1);
     const closingIndent = '    '.repeat(indentLevel);
     const contentIndent = [];
-    const startTokenLine = (0, cds_compiler_tokens_1.tokenLine)(startToken);
-    const startTokenCharacter = (0, cds_compiler_tokens_1.tokenColumn)(startToken);
-    const endTokenLine = (0, cds_compiler_tokens_1.tokenLine)(endToken);
-    const endTokenCharacter = (0, cds_compiler_tokens_1.tokenColumn)(endToken);
+    const startTokenLine = tokenLine(startToken);
+    const startTokenCharacter = tokenColumn(startToken);
+    const endTokenLine = tokenLine(endToken);
+    const endTokenCharacter = tokenColumn(endToken);
     if (indentContent) {
         for (let index = startTokenLine + 1; index <= endTokenLine; index++) {
-            contentIndent.push(odata_annotation_core_1.TextEdit.insert(odata_annotation_core_1.Position.create(index, 0), '    '));
+            contentIndent.push(TextEdit.insert(Position.create(index, 0), '    '));
         }
     }
     // if annotation ends with ';' we need to insert closing ')' before ';' otherwise we need to insert it after the last token
     // sometimes element annotations many end without ';'
-    const afterEndTokenCharacter = (0, cds_compiler_tokens_1.tokenColumn)(afterEndToken);
-    const afterEndTokenLine = (0, cds_compiler_tokens_1.tokenLine)(afterEndToken);
+    const afterEndTokenCharacter = tokenColumn(afterEndToken);
+    const afterEndTokenLine = tokenLine(afterEndToken);
     const endCharacter = afterEndToken.text === ';' ? afterEndTokenCharacter : endTokenCharacter + endToken.text.length;
-    const endReplaceRangeStart = odata_annotation_core_1.Position.create(endTokenLine, endCharacter);
+    const endReplaceRangeStart = Position.create(endTokenLine, endCharacter);
     // if the closing '}' for element container is in the same line as the value it is likely there will be whitespace between,
     // we need to make sure that this whitespace is removed because `)` will be inserted in the same line
     const endReplaceRangeEnd = endTokenLine === afterEndTokenLine
-        ? odata_annotation_core_1.Position.create(afterEndTokenLine, afterEndTokenCharacter)
+        ? Position.create(afterEndTokenLine, afterEndTokenCharacter)
         : endReplaceRangeStart;
     return [
-        odata_annotation_core_1.TextEdit.insert(odata_annotation_core_1.Position.create(startTokenLine, startTokenCharacter + 1), `(\n${indentText}`),
+        TextEdit.insert(Position.create(startTokenLine, startTokenCharacter + 1), `(\n${indentText}`),
         ...contentIndent,
-        odata_annotation_core_1.TextEdit.replace(odata_annotation_core_1.Range.create(endReplaceRangeStart, endReplaceRangeEnd), `\n${closingIndent})`)
+        TextEdit.replace(Range.create(endReplaceRangeStart, endReplaceRangeEnd), `\n${closingIndent})`)
     ];
 }
 function deleteBlock(edits, content, blockIndex) {
@@ -648,7 +645,7 @@ function deleteBlock(edits, content, blockIndex) {
     if (block?.type !== 'element') {
         return;
     }
-    edits.push(odata_annotation_core_1.TextEdit.del(block.range));
+    edits.push(TextEdit.del(block.range));
     const previous = content[blockIndex - 1];
     const next = content[blockIndex + 1];
     if (previous?.range) {
@@ -658,7 +655,7 @@ function deleteBlock(edits, content, blockIndex) {
     }
     else if (next?.range) {
         // there could be whitespace to the next element which should be removed
-        edits.push(odata_annotation_core_1.TextEdit.del(odata_annotation_core_1.Range.create(block.range.end, next.range.start)));
+        edits.push(TextEdit.del(Range.create(block.range.end, next.range.start)));
     }
 }
 function removeWhitespaceForConsequentDeletes(edits, content, blockIndex, block, next) {
@@ -671,7 +668,7 @@ function removeWhitespaceForConsequentDeletes(edits, content, blockIndex, block,
         }
     }
     if (hasDeleteSequence && next?.range) {
-        const edit = odata_annotation_core_1.TextEdit.del(odata_annotation_core_1.Range.create(block.range.end, next.range.start));
+        const edit = TextEdit.del(Range.create(block.range.end, next.range.start));
         // other deletion edits with the same range may already exist
         if (!edits.some((item) => isRangesEqual(item.range, edit.range))) {
             edits.push(edit);
@@ -679,66 +676,66 @@ function removeWhitespaceForConsequentDeletes(edits, content, blockIndex, block,
     }
 }
 function deletePreviousElementWhiteSpaces(previousElement, currentBlock, edits) {
-    const edit = odata_annotation_core_1.TextEdit.del(odata_annotation_core_1.Range.create(previousElement.range.end, currentBlock.range.start));
+    const edit = TextEdit.del(Range.create(previousElement.range.end, currentBlock.range.start));
     // other deletion edits with the same range may already exist
     if (!edits.some((item) => isRangesEqual(item.range, edit.range))) {
         edits.push(edit);
     }
 }
 function deleteValue(edits, pointer, astNode, parent, comments, tokens, lastIndex) {
-    if (parent.type === cds_annotation_parser_1.COLLECTION_TYPE) {
+    if (parent.type === COLLECTION_TYPE) {
         if (!lastIndex) {
-            throw new error_1.ApiError(`${pointer} is not pointing to a collection element.`);
+            throw new ApiError(`${pointer} is not pointing to a collection element.`);
         }
         const content = getContainerContent(parent, comments, tokens);
         const index = Number.parseInt(lastIndex, 10);
         const { startContentIndex } = findContentIndices(content, index);
         deleteBlock(edits, content, startContentIndex);
     }
-    else if (parent.type === cds_annotation_parser_1.RECORD_TYPE &&
-        (astNode.type === cds_annotation_parser_1.RECORD_PROPERTY_TYPE || astNode.type === cds_annotation_parser_1.ANNOTATION_TYPE)) {
+    else if (parent.type === RECORD_TYPE &&
+        (astNode.type === RECORD_PROPERTY_TYPE || astNode.type === ANNOTATION_TYPE)) {
         if (!lastIndex) {
-            throw new error_1.ApiError(`${pointer} is not pointing to a record property.`);
+            throw new ApiError(`${pointer} is not pointing to a record property.`);
         }
         const content = getContainerContent(parent, comments, tokens);
         const index = Number.parseInt(lastIndex, 10);
         const { startContentIndex } = findContentIndices(content, index, index, astNode.type);
         deleteBlock(edits, content, startContentIndex);
     }
-    else if (parent.type === cds_annotation_parser_1.ANNOTATION_TYPE || parent.type === cds_annotation_parser_1.RECORD_PROPERTY_TYPE) {
+    else if (parent.type === ANNOTATION_TYPE || parent.type === RECORD_PROPERTY_TYPE) {
         // delete record value including ':'
         if (parent.colon?.range && astNode.range) {
-            const range = odata_annotation_core_1.Range.create(parent.colon.range.start, astNode.range.end);
-            edits.push(odata_annotation_core_1.TextEdit.del(range));
+            const range = Range.create(parent.colon.range.start, astNode.range.end);
+            edits.push(TextEdit.del(range));
         }
     }
     else {
-        throw new error_1.ApiError(`Invalid ${pointer} for 'delete-record' change.`);
+        throw new ApiError(`Invalid ${pointer} for 'delete-record' change.`);
     }
 }
 function printChange(parent, referenceNode) {
     return function (change) {
-        if (change.type === change_1.INSERT_EMBEDDED_ANNOTATION_CHANGE_TYPE) {
+        if (change.type === INSERT_EMBEDDED_ANNOTATION_CHANGE_TYPE) {
             if (referenceNode) {
-                const element = (0, preprocessor_1.createReferenceElement)(referenceNode);
+                const element = createReferenceElement(referenceNode);
                 if (element) {
-                    return (0, cds_odata_annotation_converter_1.print)(change.element, printOptions, {
+                    return print(change.element, printOptions, {
                         indentResult: false,
                         annotationContext: [element]
                     });
                 }
             }
-            return '@' + (0, cds_odata_annotation_converter_1.print)(change.element, printOptions);
+            return '@' + print(change.element, printOptions);
         }
-        else if (change.type === change_1.INSERT_PRIMITIVE_VALUE_TYPE) {
-            const text = change.element.content[0]?.type === odata_annotation_core_1.TEXT_TYPE ? change.element.content[0].text : '';
-            return (0, cds_odata_annotation_converter_1.printPrimitiveValue)(change.element.name, text);
+        else if (change.type === INSERT_PRIMITIVE_VALUE_TYPE) {
+            const text = change.element.content[0]?.type === TEXT_TYPE ? change.element.content[0].text : '';
+            return printPrimitiveValue(change.element.name, text);
         }
-        else if (parent?.type === cds_annotation_parser_1.RECORD_TYPE && change.element.name === "Annotation" /* Edm.Annotation */) {
-            return (0, cds_odata_annotation_converter_1.print)(change.element, printOptions);
+        else if (parent?.type === RECORD_TYPE && change.element.name === Edm.Annotation) {
+            return print(change.element, printOptions);
         }
         else {
-            return (0, cds_odata_annotation_converter_1.print)(change.element, printOptions);
+            return print(change.element, printOptions);
         }
     };
 }
@@ -748,7 +745,7 @@ function getIndexForInsertion(containerSize, insertionIndex) {
         : containerSize;
 }
 function getCommas(container, tokens) {
-    if (container.type === cds_odata_annotation_converter_1.TARGET_TYPE) {
+    if (container.type === TARGET_TYPE) {
         if (!container.range) {
             return [];
         }
@@ -761,11 +758,11 @@ function getCommas(container, tokens) {
 function extractCommasFromCompilerTokens(range, items, tokens) {
     const result = [];
     const { start, end } = range;
-    const startTokenIndex = tokens.findIndex((0, cds_compiler_tokens_1.matchTokenByStart)(start));
+    const startTokenIndex = tokens.findIndex(matchTokenByStart(start));
     for (let i = startTokenIndex; i < tokens.length; i++) {
         const token = tokens[i];
-        const tokenRange = (0, cds_compiler_tokens_1.createTokenRange)(token);
-        if (token.text === ',' && !items.some((item) => item.range && (0, odata_annotation_core_1.rangeContained)(item.range, tokenRange))) {
+        const tokenRange = createTokenRange(token);
+        if (token.text === ',' && !items.some((item) => item.range && rangeContained(item.range, tokenRange))) {
             // we are only interested in commas separating items -> ignore commas that are inside an item
             result.push({
                 type: 'token',
@@ -773,7 +770,7 @@ function extractCommasFromCompilerTokens(range, items, tokens) {
                 range: tokenRange
             });
         }
-        if ((0, cds_compiler_tokens_1.isOldToken)(token)) {
+        if (isOldToken(token)) {
             if ((token.line === end.line + 1 && token.column >= end.character) || token.line > end.line + 1) {
                 break;
             }
@@ -790,7 +787,7 @@ function getStartAnchor(content, parent, previous, index) {
     let startPosition = index === 0 ? parent.range?.start : previousElement?.range?.end;
     const element = content[index];
     if (startPosition) {
-        startPosition = (0, cds_annotation_parser_1.copyPosition)(startPosition);
+        startPosition = copyPosition(startPosition);
         if (index === 0) {
             startPosition.character++;
         }
@@ -824,8 +821,8 @@ function serializeReference(data) {
 async function getTextEditForMissingRefs(missingReferences, fileUri, projectRoot) {
     const missingReferencesTexts = [];
     for (const missingRef of missingReferences) {
-        const relativePath = (0, node_path_1.relative)(projectRoot, (0, node_url_1.fileURLToPath)(fileUri));
-        const referenceUri = await (0, project_access_1.toReferenceUri)(projectRoot, relativePath, missingRef);
+        const relativePath = relative(projectRoot, fileURLToPath(fileUri));
+        const referenceUri = await toReferenceUri(projectRoot, relativePath, missingRef);
         missingReferencesTexts.push(serializeReference({ namespace: '', referenceUri }));
     }
     return missingReferencesTexts.join('\n') + '\n';
@@ -842,23 +839,23 @@ function isRangesEqual(range1, range2) {
 function convertCDSAstToEdmType(kind) {
     switch (kind) {
         case 'time':
-            return "TimeOfDay" /* Edm.TimeOfDay */;
+            return Edm.TimeOfDay;
         case 'date':
-            return "Date" /* Edm.Date */;
+            return Edm.Date;
         case 'timestamp':
-            return "DateTimeOffset" /* Edm.DateTimeOffset */;
+            return Edm.DateTimeOffset;
         case 'binary':
-            return "Binary" /* Edm.Binary */;
+            return Edm.Binary;
         case 'path':
-            return "Path" /* Edm.Path */;
+            return Edm.Path;
         case 'boolean':
-            return "Bool" /* Edm.Bool */;
+            return Edm.Bool;
         case 'string':
-            return "String" /* Edm.String */;
+            return Edm.String;
         case 'enum':
-            return "EnumMember" /* Edm.EnumMember */;
+            return Edm.EnumMember;
         case 'number':
-            return "Decimal" /* Edm.Decimal */;
+            return Edm.Decimal;
         default:
             return undefined;
     }
@@ -872,9 +869,9 @@ function deIndent(text) {
 function getInsertReferencePosition(references) {
     const range = references[references.length - 1]?.uriRange;
     if (!range) {
-        return { position: odata_annotation_core_1.Position.create(0, 0), prependNewLine: false };
+        return { position: Position.create(0, 0), prependNewLine: false };
     }
-    const position = (0, cds_annotation_parser_1.copyPosition)(range.end);
+    const position = copyPosition(range.end);
     // reference last position includes its last character, we need to insert after it.
     position.character++;
     return { position, prependNewLine: true };
@@ -896,9 +893,9 @@ function createElementRanges(document, tokens, pointers) {
         return acc;
     }, new Map());
     for (const [containerPath, indices] of groups) {
-        const [parent] = (0, pointer_1.getAstNodesFromPointer)(document, containerPath).reverse();
-        if (parent?.type === cds_annotation_parser_1.COLLECTION_TYPE) {
-            const indentLevel = (0, indent_1.getIndentLevelFromNode)(tokens, parent);
+        const [parent] = getAstNodesFromPointer(document, containerPath).reverse();
+        if (parent?.type === COLLECTION_TYPE) {
+            const indentLevel = getIndentLevelFromNode(tokens, parent);
             indices.sort((index1, index2) => index1 - index2);
             for (let i = 1, start = indices[0], end = indices[0]; i <= indices.length; i++) {
                 const current = indices[i];
@@ -927,7 +924,7 @@ function getTextEditsForMove(writerContext, position, ranges, indentLevel) {
         const sourceContent = getContainerContent(range.parent, writerContext.comments, writerContext.tokens);
         cutRange(writerContext, sourceContent, range, indentLevel, text, edits);
     }
-    edits.push(odata_annotation_core_1.TextEdit.insert(position, ''.concat(...text)));
+    edits.push(TextEdit.insert(position, ''.concat(...text)));
     return edits;
 }
 function findContentIndices(content, start, end = start, nodeType) {
@@ -962,9 +959,9 @@ function isComma(token) {
 function findDeletionChange(document, changes, range) {
     return changes.some((change) => {
         if (change.type.startsWith('delete-')) {
-            const [leaf] = (0, pointer_1.getAstNodesFromPointer)(document, change.pointer).reverse();
+            const [leaf] = getAstNodesFromPointer(document, change.pointer).reverse();
             if (leaf?.range) {
-                return (0, odata_annotation_core_1.rangeContained)(leaf.range, range);
+                return rangeContained(leaf.range, range);
             }
         }
         return false;
@@ -978,10 +975,10 @@ function cutRange(writerContext, content, cutRange, indentLevel, text, edits) {
     let startPosition = start === 0 ? parent.openToken?.range?.end : previousElement?.range?.end;
     let endPosition = endElement?.range?.end;
     if (startPosition) {
-        startPosition = (0, cds_annotation_parser_1.copyPosition)(startPosition);
+        startPosition = copyPosition(startPosition);
     }
     if (endPosition) {
-        endPosition = (0, cds_annotation_parser_1.copyPosition)(endPosition);
+        endPosition = copyPosition(endPosition);
     }
     if (!startPosition || !endPosition) {
         return;
@@ -993,9 +990,9 @@ function cutRange(writerContext, content, cutRange, indentLevel, text, edits) {
             // ___|_______________|
             //  |        |
             // cut    suffix  range
-            const range = (0, cds_annotation_parser_1.copyRange)(odata_annotation_core_1.Range.create(endElement.element.range.end, endElement.trailingComment.range.end));
+            const range = copyRange(Range.create(endElement.element.range.end, endElement.trailingComment.range.end));
             if (!findDeletionChange(writerContext.cdsDocument, writerContext.changes, range)) {
-                edits.push(odata_annotation_core_1.TextEdit.del(range));
+                edits.push(TextEdit.del(range));
             }
             suffix = ',' + writerContext.textDocument.getText(range);
             updatePosition(endPosition, endElement.element.range.end);
@@ -1005,11 +1002,11 @@ function cutRange(writerContext, content, cutRange, indentLevel, text, edits) {
             suffix = ',';
         }
     }
-    const range = (0, cds_annotation_parser_1.copyRange)(odata_annotation_core_1.Range.create(startPosition, endPosition));
+    const range = copyRange(Range.create(startPosition, endPosition));
     const originalText = writerContext.textDocument.getText(range);
     text.push(makeCut(originalText, suffix, cutRange, indentLevel));
     if (!findDeletionChange(writerContext.cdsDocument, writerContext.changes, range)) {
-        edits.push(odata_annotation_core_1.TextEdit.del(range));
+        edits.push(TextEdit.del(range));
     }
 }
 function makeCut(originalText, suffix, cutRange, indentLevel) {
@@ -1038,12 +1035,12 @@ function getContainerContent(collection, comments, tokens) {
     if (!collection.range) {
         return [];
     }
-    const items = (0, document_1.getItems)(collection);
+    const items = getItems(collection);
     const commas = getCommas(collection, tokens);
     const commentsInContent = (collection.range !== undefined
-        ? comments.filter((comment) => (0, odata_annotation_core_1.rangeContained)(collection.range, comment.range))
-        : []).filter((comment) => !items.some((item) => item.range && (0, odata_annotation_core_1.rangeContained)(item.range, comment.range)));
-    const source = [...commas, ...items, ...commentsInContent].sort(utils_1.compareByRange);
+        ? comments.filter((comment) => rangeContained(collection.range, comment.range))
+        : []).filter((comment) => !items.some((item) => item.range && rangeContained(item.range, comment.range)));
+    const source = [...commas, ...items, ...commentsInContent].sort(compareByRange);
     const content = [];
     for (const node of source) {
         processNode(content, node);
@@ -1077,8 +1074,8 @@ function processNode(content, item) {
         const element = {
             type: 'element',
             element: item,
-            elementRange: (0, cds_annotation_parser_1.copyRange)(item.range),
-            range: (0, cds_annotation_parser_1.copyRange)(item.range)
+            elementRange: copyRange(item.range),
+            range: copyRange(item.range)
         };
         const previousLine = element.range.start.line - 1;
         if (previousItem?.type === 'comment' &&
@@ -1095,11 +1092,11 @@ function skipCommaInsertion(changes, content, document, insertAfterIndex) {
         if (!change.type.startsWith('delete')) {
             return false;
         }
-        const astNodes = (0, pointer_1.getAstNodesFromPointer)(document, change.pointer);
+        const astNodes = getAstNodesFromPointer(document, change.pointer);
         const toBeDeletedNodes = astNodes[astNodes.length - 1];
         const node = content[insertAfterIndex];
         if (node.type === 'element' && node?.element === toBeDeletedNodes) {
-            if (toBeDeletedNodes.type === cds_annotation_parser_1.ANNOTATION_TYPE && content.length === 1) {
+            if (toBeDeletedNodes.type === ANNOTATION_TYPE && content.length === 1) {
                 return false;
             }
             return true;