codecharta-visualization 1.119.1 → 1.120.0

package/app/codeCharta/util/nodeDecorator.ts

@@ -1,358 +0,0 @@
-import { hierarchy } from "d3-hierarchy"
-import { AttributeTypes, AttributeTypeValue, BlacklistItem, CCFile, CodeMapNode, MetricData } from "../codeCharta.model"
-import { isLeaf, isNodeExcludedOrFlattened } from "./codeMapHelper"
-import { UNARY_METRIC } from "../state/selectors/accumulatedData/metricData/nodeMetricData.calculator"
-
-const enum MedianSelectors {
-	MEDIAN = "MEDIAN",
-	DELTA = "DELTA",
-	INCOMING = "INCOMING",
-	OUTGOING = "OUTGOING"
-}
-
-const enum EdgeAttributeType {
-	INCOMING = "incoming",
-	OUTGOING = "outgoing"
-}
-
-export const NodeDecorator = {
-	decorateMap(map: CodeMapNode, metricData: Pick<MetricData, "nodeMetricData" | "edgeMetricData">, blacklist: BlacklistItem[]) {
-		for (const { data } of hierarchy(map)) {
-			data.isFlattened = false
-			data.isExcluded = false
-
-			for (const item of blacklist) {
-				if (item.type === "flatten") {
-					data.isFlattened = data.isFlattened || isNodeExcludedOrFlattened(data, item.path)
-				} else {
-					data.isExcluded = data.isExcluded || (isNodeExcludedOrFlattened(data, item.path) && isLeaf(data))
-				}
-			}
-		}
-		map.isExcluded = false
-		this.decorateMapWithMetricData(map, metricData)
-	},
-
-	decorateMapWithMetricData(map: CodeMapNode, metricData: Pick<MetricData, "nodeMetricData" | "edgeMetricData">) {
-		const { nodeMetricData, edgeMetricData } = metricData
-		let id = 0
-		for (const { data } of hierarchy(map)) {
-			data.id = id
-			id++
-
-			if (data.attributes === undefined) {
-				data.attributes = {}
-			}
-
-			if (isLeaf(data)) {
-				data.attributes[UNARY_METRIC] = 1
-			}
-
-			for (const metric of nodeMetricData) {
-				if (data.attributes[metric.name] === undefined) {
-					data.attributes[metric.name] = 0
-				}
-
-				if (data.deltas !== undefined && data.deltas[metric.name] === undefined) {
-					data.deltas[metric.name] = 0
-				}
-			}
-
-			if (data.edgeAttributes === undefined) {
-				data.edgeAttributes = {}
-			}
-
-			for (const metric of edgeMetricData) {
-				if (data.edgeAttributes[metric.name] === undefined) {
-					data.edgeAttributes[metric.name] = { incoming: 0, outgoing: 0 }
-				}
-			}
-
-			mergeFolderChain(data)
-		}
-	},
-
-	decorateMapWithPathAttribute(file: CCFile) {
-		for (const node of hierarchy(file.map)) {
-			node.data.path = node.parent ? `${node.parent.data.path}/${node.data.name}` : `/${node.data.name}`
-		}
-		return file
-	},
-
-	decorateParentNodesWithAggregatedAttributes(map: CodeMapNode, isDeltaState: boolean, attributeTypes: AttributeTypes) {
-		const medians: Map<string, number[]> = new Map()
-		// TODO: Combine decorateMap, decorateMapWithPathAttribute and this one and
-		// remove the Object.keys calls from then on. They are identical to the
-		// `nodeMetricData` and `edgeMetricData` names.
-		const attributeKeys = Object.keys(map.attributes)
-
-		const edgeKeys = Object.keys(map.edgeAttributes)
-		hierarchy(map).eachAfter(function decorateNode({ data, parent }) {
-			// skip root
-			if (data.isExcluded || !parent) {
-				return
-			}
-
-			for (const name of attributeKeys) {
-				const selector = `${name}${data.path}`
-				const parentSelector = `${name}${parent.data.path}`
-				if (attributeTypes.nodes[name] === AttributeTypeValue.relative) {
-					setNodeMediansToParent(medians, selector, parentSelector, data, name, isDeltaState)
-					collectNodeMediansOnParent(medians, parentSelector, data, name, isDeltaState)
-				} else {
-					parent.data.attributes[name] += data.attributes[name]
-					if (isDeltaState && parent.data.deltas) {
-						parent.data.deltas[name] = parent.data.deltas[name] ?? 0
-						parent.data.deltas[name] += data.deltas[name] ?? 0
-					}
-				}
-			}
-
-			if (isDeltaState && parent.data.fileCount) {
-				parent.data.fileCount.added += data.fileCount.added
-				parent.data.fileCount.changed += data.fileCount.changed
-				parent.data.fileCount.removed += data.fileCount.removed
-			}
-
-			for (const name of edgeKeys) {
-				const value = data.edgeAttributes[name]
-
-				if (!value) {
-					continue
-				}
-
-				const selector = `${name}${data.path}`
-				const parentSelector = `${name}${parent.data.path}`
-				if (attributeTypes.edges[name] === AttributeTypeValue.relative) {
-					setEdgeMediansToParent(
-						medians,
-						`${MedianSelectors.INCOMING}${selector}`,
-						`${MedianSelectors.INCOMING}${parentSelector}`,
-						data,
-						name,
-						EdgeAttributeType.INCOMING
-					)
-					setEdgeMediansToParent(
-						medians,
-						`${MedianSelectors.OUTGOING}${selector}`,
-						`${MedianSelectors.OUTGOING}${parentSelector}`,
-						data,
-						name,
-						EdgeAttributeType.OUTGOING
-					)
-					collectEdgeMediansOnParent(
-						medians,
-						`${MedianSelectors.INCOMING}${parentSelector}`,
-						data,
-						name,
-						EdgeAttributeType.INCOMING
-					)
-					collectEdgeMediansOnParent(
-						medians,
-						`${MedianSelectors.OUTGOING}${parentSelector}`,
-						data,
-						name,
-						EdgeAttributeType.OUTGOING
-					)
-				} else {
-					parent.data.edgeAttributes[name].incoming += value.incoming
-					parent.data.edgeAttributes[name].outgoing += value.outgoing
-				}
-			}
-		})
-
-		// Set Median for root node
-		for (const name of edgeKeys) {
-			if (attributeTypes.edges[name] === AttributeTypeValue.relative) {
-				map.edgeAttributes[name].incoming = getMedian(medians.get(`${MedianSelectors.INCOMING}${name}${map.path}`))
-				map.edgeAttributes[name].outgoing = getMedian(medians.get(`${MedianSelectors.OUTGOING}${name}${map.path}`))
-			}
-		}
-
-		for (const name of attributeKeys) {
-			if (attributeTypes.nodes[name] === AttributeTypeValue.relative) {
-				map.attributes[name] = getMedian(medians.get(`${MedianSelectors.MEDIAN}${name}${map.path}`))
-				if (isDeltaState && map.deltas) {
-					map.deltas[name] = getMedian(medians.get(`${MedianSelectors.DELTA}${name}${map.path}`))
-				}
-			}
-		}
-	}
-}
-
-function mergeFolderChain(data: CodeMapNode) {
-	// Nodes with only one child which also have children are merged into one node
-	// e.g. a /folder which includes anotherFolder that includes other files or folders
-	// will be merged to a node with path /folder/anotherFolder and children are set accordingly
-	if (data.children?.length === 1 && data.children[0]?.fixedPosition) {
-		return
-	}
-
-	if (data.children?.length === 1 && data.children[0].children?.length > 0) {
-		const [child] = data.children
-		data.children = child.children
-		data.name += `/${child.name}`
-		data.path += `/${child.name}`
-		if (child.link) {
-			data.link = child.link
-		}
-	}
-}
-
-function collectEdgeMediansOnParent(
-	medians: Map<string, number[]>,
-	selector: string,
-	child: CodeMapNode,
-	metricName: string,
-	type: EdgeAttributeType
-) {
-	if (child.edgeAttributes[metricName][type] !== 0) {
-		collectMedians(medians, selector, child, child.edgeAttributes[metricName][type])
-	}
-}
-
-function collectNodeMediansOnParent(
-	medians: Map<string, number[]>,
-	parentSelector: string,
-	child: CodeMapNode,
-	metricName: string,
-	isDeltaState: boolean
-) {
-	if (child.attributes[metricName] !== 0) {
-		collectMedians(medians, `${MedianSelectors.MEDIAN}${parentSelector}`, child, child.attributes[metricName])
-	}
-
-	if (isDeltaState && child.deltas && child.deltas[metricName] !== 0) {
-		collectMedians(medians, `${MedianSelectors.DELTA}${parentSelector}`, child, child.deltas[metricName])
-	}
-}
-
-function setNodeMediansToParent(
-	medians: Map<string, number[]>,
-	selector: string,
-	parentSelector: string,
-	child: CodeMapNode,
-	metricName: string,
-	isDeltaState: boolean
-) {
-	if (isLeaf(child)) {
-		return
-	}
-
-	const numbers = medians.get(`${MedianSelectors.MEDIAN}${selector}`)
-	if (numbers !== undefined) {
-		child.attributes[metricName] = getMedian(numbers)
-		setMediansToParents(medians, `${MedianSelectors.MEDIAN}${parentSelector}`, numbers)
-	}
-
-	if (isDeltaState && child.deltas) {
-		const deltaNumbers = medians.get(`${MedianSelectors.DELTA}${selector}`)
-		if (deltaNumbers !== undefined) {
-			child.deltas[metricName] = getMedian(deltaNumbers)
-			setMediansToParents(medians, `${MedianSelectors.DELTA}${parentSelector}`, deltaNumbers)
-		}
-	}
-}
-
-function setEdgeMediansToParent(
-	medians: Map<string, number[]>,
-	selector: string,
-	parentSelector: string,
-	child: CodeMapNode,
-	metricName: string,
-	type: EdgeAttributeType
-) {
-	if (isLeaf(child)) {
-		return
-	}
-
-	const numbers = medians.get(selector)
-	if (numbers !== undefined) {
-		child.edgeAttributes[metricName][type] = getMedian(numbers)
-		setMediansToParents(medians, parentSelector, numbers)
-	}
-}
-
-function setMediansToParents(medians: Map<string, number[]>, parentSelector: string, numbers: number[]) {
-	const median = medians.get(parentSelector)
-	if (median === undefined) {
-		medians.set(parentSelector, numbers)
-	} else {
-		pushSortedArray(median, numbers)
-	}
-}
-
-function collectMedians(medians: Map<string, number[]>, selector: string, child: CodeMapNode, value: number) {
-	// TODO: Check if this should be set if it's not a leaf.
-	const median = medians.get(selector)
-	if (median === undefined) {
-		medians.set(selector, [value])
-	} else if (isLeaf(child)) {
-		pushSorted(median, value)
-	}
-}
-
-// TODO: Evaluate if sorting in `getMedian` is not better than using a
-// pre-sorted array. It's a lot less code and should roughly have the same
-// performance.
-export function getMedian(numbers: number[]) {
-	if (numbers === undefined || numbers.length === 0) {
-		return 0
-	}
-
-	const middle = (numbers.length - 1) / 2
-	return (numbers[Math.floor(middle)] + numbers[Math.ceil(middle)]) / 2
-}
-
-export function pushSorted(numbers: number[], number: number) {
-	let min = 0
-	let max = numbers.length - 1
-	let guess = 0
-
-	if (max < 0 || numbers[max] <= number) {
-		numbers.push(number)
-		return
-	}
-	if (numbers[0] >= number) {
-		numbers.unshift(number)
-		return
-	}
-
-	// Use a binary search to find the correct entry.
-	while (min <= max) {
-		guess = Math.floor((min + max) / 2)
-
-		if (numbers[guess] < number) {
-			min = guess + 1
-		} else {
-			max = guess - 1
-			if (numbers[max] <= number) {
-				numbers.splice(guess, 0, number)
-				return
-			}
-		}
-	}
-}
-
-function pushSortedArray(numbers: number[], toPush: number[]) {
-	let totalPushes = 0
-	for (let index = 0; index < numbers.length; index++) {
-		let pushCount = 0
-
-		while (numbers[index] > toPush[totalPushes]) {
-			pushCount++
-			totalPushes++
-			if (totalPushes === toPush.length) {
-				break
-			}
-		}
-
-		if (pushCount > 0) {
-			numbers.splice(index, 0, ...toPush.slice(totalPushes - pushCount, totalPushes))
-			if (totalPushes === toPush.length) {
-				return
-			}
-		}
-	}
-	numbers.push(...toPush.slice(totalPushes))
-}

package/app/codeCharta/util/nodePathHelper.ts

@@ -1,30 +0,0 @@
-import { fileRoot } from "../services/loadFile/fileRoot"
-
-export function getUpdatedBlacklistItemPath(fileName: string, path: string) {
-	if (isAbsoluteRootPath(path)) {
-		return getUpdatedPath(fileName, path)
-	}
-	return path
-}
-
-export function getUpdatedPath(fileName: string, path: string) {
-	const length = fileRoot.rootPath.length + 1
-	const end = path.length <= length ? "" : `/${path.slice(length)}`
-	return `${fileRoot.rootPath}/${fileName}${end}`
-}
-
-function isAbsoluteRootPath(path: string) {
-	return path.startsWith(`${fileRoot.rootPath}/`)
-}
-
-export function getParent<T>(hashMap: Map<string, T>, path: string): T {
-	do {
-		// TODO: Check what happens with Windows paths.
-		path = path.slice(0, path.lastIndexOf("/"))
-
-		const node = hashMap.get(path)
-		if (node) {
-			return node
-		}
-	} while (path !== fileRoot.rootPath && path.length > 0)
-}

package/app/codeCharta/util/parseNumberInput.spec.ts

@@ -1,18 +0,0 @@
-import { parseNumberInput } from "./parseNumberInput"
-
-describe("parseNumberInput", () => {
-	it("should get value", () => {
-		const fakeEvent = { target: { value: 42 } } as unknown as InputEvent
-		expect(parseNumberInput(fakeEvent, 0, 100)).toBe(42)
-	})
-
-	it("should return min value in case of too small entered valued", () => {
-		const fakeEvent = { target: { value: 1 } } as unknown as InputEvent
-		expect(parseNumberInput(fakeEvent, 2, 100)).toBe(2)
-	})
-
-	it("should return max value in case of too large entered valued", () => {
-		const fakeEvent = { target: { value: 9999 } } as unknown as InputEvent
-		expect(parseNumberInput(fakeEvent, 0, 9000)).toBe(9000)
-	})
-})

package/app/codeCharta/util/parseNumberInput.ts

@@ -1,10 +0,0 @@
-export const parseNumberInput = (event: Event, min: number, max: number) => {
-	const value = Number.parseInt((event.target as HTMLInputElement).value)
-	if (value < min) {
-		return min
-	}
-	if (value > max) {
-		return max
-	}
-	return value
-}

package/app/codeCharta/util/pipes/AttributeDescriptorTooltipPipeModule.ts

@@ -1,8 +0,0 @@
-import { NgModule } from "@angular/core"
-import { AttributeDescriptorTooltipPipe } from "./attributeDescriptorTooltip.pipe"
-
-@NgModule({
-	declarations: [AttributeDescriptorTooltipPipe],
-	exports: [AttributeDescriptorTooltipPipe]
-})
-export class AttributeDescriptorTooltipPipeModule {}

package/app/codeCharta/util/pipes/RemoveExtensionPipeModule.ts

@@ -1,8 +0,0 @@
-import { NgModule } from "@angular/core"
-import { RemoveExtensionPipe } from "./removeExtension.pipe"
-
-@NgModule({
-	declarations: [RemoveExtensionPipe],
-	exports: [RemoveExtensionPipe]
-})
-export class RemoveExtensionPipeModule {}

package/app/codeCharta/util/pipes/TruncateTextPipeModule.ts

@@ -1,8 +0,0 @@
-import { NgModule } from "@angular/core"
-import { TruncateTextPipe } from "./truncateText.pipe"
-
-@NgModule({
-	declarations: [TruncateTextPipe],
-	exports: [TruncateTextPipe]
-})
-export class TruncateTextPipeModule {}

package/app/codeCharta/util/pipes/attributeDescriptorTooltip.pipe.spec.ts

@@ -1,61 +0,0 @@
-import { AttributeDescriptorTooltipPipe } from "./attributeDescriptorTooltip.pipe"
-import { AttributeDescriptor } from "../../codeCharta.model"
-
-const testKey = "testKey"
-const testTitle = "testTitle"
-const testHighValue = "testHighValue"
-const testLowValue = "testLowValue"
-const testDescription = "testDescription"
-const testLink = "testLink"
-let pipe: AttributeDescriptorTooltipPipe
-let aD: AttributeDescriptor
-
-describe("attributeDescriptorTooltipPipe", () => {
-	beforeEach(() => {
-		aD = {
-			title: null,
-			description: null,
-			hintLowValue: null,
-			hintHighValue: null,
-			link: null
-		}
-		pipe = new AttributeDescriptorTooltipPipe()
-	})
-
-	it("should return empty string for null", () => {
-		expect(pipe.transform(null, "")).toBe("")
-	})
-
-	it("should return empty string for undefined", () => {
-		expect(pipe.transform(undefined, "")).toBe("")
-	})
-
-	it("should be key if only key is present", () => {
-		expect(pipe.transform(aD, testKey)).toBe(testKey)
-	})
-
-	it('should be "title (key)" if present', () => {
-		aD.title = testTitle
-		expect(pipe.transform(aD, testKey)).toBe(`${testTitle} (${testKey})`)
-	})
-
-	it("should contain : if more information available", () => {
-		aD.hintLowValue = testLowValue
-		expect(pipe.transform(aD, testKey)).toContain(":")
-	})
-
-	it("should include full information", () => {
-		aD.title = testTitle
-		aD.description = testDescription
-		aD.hintHighValue = testHighValue
-		aD.hintLowValue = testLowValue
-		const result = `${testTitle} (${testKey}):\n${testDescription}\nHigh Values: ${testHighValue}\nLow Values: ${testLowValue}`
-		expect(pipe.transform(aD, testKey)).toBe(result)
-	})
-
-	it("should not include link", () => {
-		aD.description = testDescription
-		aD.link = testLink
-		expect(pipe.transform(aD, testKey)).toBe(`${testKey}:\n${testDescription}`)
-	})
-})

package/app/codeCharta/util/pipes/attributeDescriptorTooltip.pipe.ts

@@ -1,19 +0,0 @@
-import { Pipe, PipeTransform } from "@angular/core"
-import { AttributeDescriptor } from "../../codeCharta.model"
-import { metricTitles } from "../metric/metricTitles"
-
-@Pipe({ name: "attributeDescriptorTooltip" })
-export class AttributeDescriptorTooltipPipe implements PipeTransform {
-	transform(attributeDescriptor: AttributeDescriptor, key: string): string {
-		if (attributeDescriptor == null) {
-			return metricTitles.get(key) ?? ""
-		}
-		const title: string = attributeDescriptor.title ? `${attributeDescriptor.title} (${key})` : `${key}`
-
-		let subtitle: string = attributeDescriptor.description ? `\n${attributeDescriptor.description}` : ""
-		subtitle += attributeDescriptor.hintHighValue ? `\nHigh Values: ${attributeDescriptor.hintHighValue}` : ""
-		subtitle += attributeDescriptor.hintLowValue ? `\nLow Values: ${attributeDescriptor.hintLowValue}` : ""
-
-		return subtitle.length > 0 ? `${title}:${subtitle}` : title
-	}
-}

package/app/codeCharta/util/pipes/removeExtension.pipe.spec.ts

@@ -1,15 +0,0 @@
-import { RemoveExtensionPipe } from "./removeExtension.pipe"
-
-describe("removeExtensionPipe", () => {
-	it("should remove file extension .cc.json", () => {
-		expect(new RemoveExtensionPipe().transform("sample.cc.json")).toBe("sample")
-	})
-
-	it("should remove file extension .cc.json.gz", () => {
-		expect(new RemoveExtensionPipe().transform("sample.cc.json.gz")).toBe("sample")
-	})
-
-	it("should remove file extensions once .cc.json.gz", () => {
-		expect(new RemoveExtensionPipe().transform("sample.cc.json.cc.json.gz")).toBe("sample.cc.json")
-	})
-})

package/app/codeCharta/util/pipes/removeExtension.pipe.ts

@@ -1,10 +0,0 @@
-import { Pipe, PipeTransform } from "@angular/core"
-
-import { FileNameHelper } from "../fileNameHelper"
-
-@Pipe({ name: "removeExtension" })
-export class RemoveExtensionPipe implements PipeTransform {
-	transform(fileName: string): string {
-		return FileNameHelper.withoutCCExtension(fileName)
-	}
-}

package/app/codeCharta/util/pipes/truncateText.pipe.ts

@@ -1,8 +0,0 @@
-import { Pipe, PipeTransform } from "@angular/core"
-
-@Pipe({ name: "truncateText" })
-export class TruncateTextPipe implements PipeTransform {
-	transform(textToTruncate: string, limit, replacerString = "...") {
-		return textToTruncate.length > limit ? textToTruncate.slice(0, limit) + replacerString : textToTruncate
-	}
-}

package/app/codeCharta/util/pipes/truncateText.spec.ts

@@ -1,19 +0,0 @@
-import { TruncateTextPipe } from "./truncateText.pipe"
-
-describe("TruncateTextPipe", () => {
-	it("should return empty placeholder string if no string given", () => {
-		expect(new TruncateTextPipe().transform("", 0)).toBe("")
-	})
-
-	it("should return a shortened string when given string above limit", () => {
-		expect(new TruncateTextPipe().transform("123456", 5)).toBe("12345...")
-	})
-
-	it("should not modify string if below limit", () => {
-		expect(new TruncateTextPipe().transform("12345", 6)).toBe("12345")
-	})
-
-	it("should allow shortening with a custom string", () => {
-		expect(new TruncateTextPipe().transform("12345", 4, "ab")).toBe("1234ab")
-	})
-})

package/app/codeCharta/util/settingsHelper.spec.ts

@@ -1,47 +0,0 @@
-import { RecursivePartial, CcState } from "../codeCharta.model"
-import { convertToVectors } from "./settingsHelper"
-import { Vector3 } from "three"
-
-describe("SettingsHelper", () => {
-	describe("convertToVectors", () => {
-		it("should transform object to Vector3 with smaller state", () => {
-			const partialState = {
-				appSettings: {
-					scaling: { y: 27 }
-				}
-			}
-
-			const expected: RecursivePartial<CcState> = {
-				appSettings: {
-					scaling: new Vector3(1, 27, 1)
-				}
-			}
-
-			convertToVectors(partialState as RecursivePartial<CcState>)
-
-			expect(partialState).toEqual(expected)
-		})
-
-		it("should transform object to Vector3 with larger state", () => {
-			const partialState = {
-				appSettings: {
-					scaling: { y: 27 },
-					invertHeight: false,
-					amountOfTopLabels: 23
-				}
-			}
-
-			const expected: RecursivePartial<CcState> = {
-				appSettings: {
-					scaling: new Vector3(1, 27, 1),
-					invertHeight: false,
-					amountOfTopLabels: 23
-				}
-			}
-
-			convertToVectors(partialState as RecursivePartial<CcState>)
-
-			expect(partialState).toEqual(expected)
-		})
-	})
-})

package/app/codeCharta/util/settingsHelper.ts

@@ -1,17 +0,0 @@
-import { RecursivePartial, Settings } from "../codeCharta.model"
-import { Vector3 } from "three"
-
-export function convertToVectors(settings: RecursivePartial<Settings>) {
-	const DEFAULT_VALUE = 1
-
-	for (const key of Object.keys(settings)) {
-		if (typeof settings[key] === "object" && settings[key] !== null) {
-			const { x, y, z } = settings[key]
-			if (x !== undefined || y !== undefined || z !== undefined) {
-				settings[key] = new Vector3(x ?? DEFAULT_VALUE, y ?? DEFAULT_VALUE, z ?? DEFAULT_VALUE)
-			} else {
-				convertToVectors(settings[key])
-			}
-		}
-	}
-}

package/app/codeCharta/util/testUtils/markdown-transformer.js

@@ -1,11 +0,0 @@
-const marked = require("marked")
-
-module.exports = {
-	process(source) {
-		const html = marked.parse(source)
-		return {
-			module: "commonjs",
-			code: `module.exports = ${JSON.stringify(html)};`
-		}
-	}
-}

package/app/codeCharta/util/testUtils/store.utils.ts

@@ -1,6 +0,0 @@
-import { MockStore } from "@ngrx/store/testing"
-import { firstValueFrom } from "rxjs"
-
-export async function getLastAction(store: MockStore) {
-	return firstValueFrom(store.scannedActions$)
-}

package/app/codeCharta/util/testUtils/wait.ts

@@ -1 +0,0 @@
-export const wait = async (ms: number) => new Promise(resolve => setTimeout(resolve, ms))