qms-angular 1.0.86 → 1.0.89

package/src/assets/qms-ckeditor-plugin/src/plugins/table/commands/insertcolumncommand.js

@@ -0,0 +1,83 @@
+/**
+ * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module table/commands/insertcolumncommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+import { getColumnIndexes, getSelectionAffectedTableCells } from '../utils/selection';
+
+/**
+ * The insert column command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'insertTableColumnLeft'` and
+ * `'insertTableColumnRight'` editor commands.
+ *
+ * To insert a column to the left of the selected cell, execute the following command:
+ *
+ *		editor.execute( 'insertTableColumnLeft' );
+ *
+ * To insert a column to the right of the selected cell, execute the following command:
+ *
+ *		editor.execute( 'insertTableColumnRight' );
+ *
+ * @extends module:core/command~Command
+ */
+export default class InsertColumnCommand extends Command {
+	/**
+	 * Creates a new `InsertColumnCommand` instance.
+	 *
+	 * @param {module:core/editor/editor~Editor} editor An editor on which this command will be used.
+	 * @param {Object} options
+	 * @param {String} [options.order="right"] The order of insertion relative to the column in which the caret is located.
+	 * Possible values: `"left"` and `"right"`.
+	 */
+	constructor( editor, options = {} ) {
+		super( editor );
+
+		/**
+		 * The order of insertion relative to the column in which the caret is located.
+		 *
+		 * @readonly
+		 * @member {String} module:table/commands/insertcolumncommand~InsertColumnCommand#order
+		 */
+		this.order = options.order || 'right';
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const selection = this.editor.model.document.selection;
+
+		const tableParent = selection.getFirstPosition().findAncestor( 'table' );
+
+		this.isEnabled = !!tableParent;
+	}
+
+	/**
+	 * Executes the command.
+	 *
+	 * Depending on the command's {@link #order} value, it inserts a column to the `'left'` or `'right'` of the column
+	 * in which the selection is set.
+	 *
+	 * @fires execute
+	 */
+	execute() {
+		const editor = this.editor;
+		const selection = editor.model.document.selection;
+		const tableUtils = editor.plugins.get( 'TableUtils' );
+		const insertBefore = this.order === 'left';
+
+		const affectedTableCells = getSelectionAffectedTableCells( selection );
+		const columnIndexes = getColumnIndexes( affectedTableCells );
+
+		const column = insertBefore ? columnIndexes.first : columnIndexes.last;
+		const table = affectedTableCells[ 0 ].findAncestor( 'table' );
+
+		tableUtils.insertColumns( table, { columns: 1, at: insertBefore ? column : column + 1 } );
+	}
+}

package/src/assets/qms-ckeditor-plugin/src/plugins/table/commands/insertrowcommand.js

@@ -0,0 +1,82 @@
+/**
+ * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module table/commands/insertrowcommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+import { getRowIndexes, getSelectionAffectedTableCells } from '../utils/selection';
+
+/**
+ * The insert row command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'insertTableRowBelow'` and
+ * `'insertTableRowAbove'` editor commands.
+ *
+ * To insert a row below the selected cell, execute the following command:
+ *
+ *		editor.execute( 'insertTableRowBelow' );
+ *
+ * To insert a row above the selected cell, execute the following command:
+ *
+ *		editor.execute( 'insertTableRowAbove' );
+ *
+ * @extends module:core/command~Command
+ */
+export default class InsertRowCommand extends Command {
+	/**
+	 * Creates a new `InsertRowCommand` instance.
+	 *
+	 * @param {module:core/editor/editor~Editor} editor The editor on which this command will be used.
+	 * @param {Object} options
+	 * @param {String} [options.order="below"] The order of insertion relative to the row in which the caret is located.
+	 * Possible values: `"above"` and `"below"`.
+	 */
+	constructor( editor, options = {} ) {
+		super( editor );
+
+		/**
+		 * The order of insertion relative to the row in which the caret is located.
+		 *
+		 * @readonly
+		 * @member {String} module:table/commands/insertrowcommand~InsertRowCommand#order
+		 */
+		this.order = options.order || 'below';
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const selection = this.editor.model.document.selection;
+
+		const tableParent = selection.getFirstPosition().findAncestor( 'table' );
+
+		this.isEnabled = !!tableParent;
+	}
+
+	/**
+	 * Executes the command.
+	 *
+	 * Depending on the command's {@link #order} value, it inserts a row `'below'` or `'above'` the row in which selection is set.
+	 *
+	 * @fires execute
+	 */
+	execute() {
+		const editor = this.editor;
+		const selection = editor.model.document.selection;
+		const tableUtils = editor.plugins.get( 'TableUtils' );
+		const insertAbove = this.order === 'above';
+
+		const affectedTableCells = getSelectionAffectedTableCells( selection );
+		const rowIndexes = getRowIndexes( affectedTableCells );
+
+		const row = insertAbove ? rowIndexes.first : rowIndexes.last;
+		const table = affectedTableCells[ 0 ].findAncestor( 'table' );
+
+		tableUtils.insertRows( table, { at: insertAbove ? row : row + 1, copyStructureFromAbove: !insertAbove } );
+	}
+}

package/src/assets/qms-ckeditor-plugin/src/plugins/table/commands/inserttablecommand.js

@@ -0,0 +1,76 @@
+/**
+ * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module table/commands/inserttablecommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+import { findOptimalInsertionPosition, checkSelectionOnObject } from 'ckeditor5/src/widget';
+
+/**
+ * The insert table command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'insertTable'` editor command.
+ *
+ * To insert a table at the current selection, execute the command and specify the dimensions:
+ *
+ *		editor.execute( 'insertTable', { rows: 20, columns: 5 } );
+ *
+ * @extends module:core/command~Command
+ */
+export default class InsertTableCommand extends Command {
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const model = this.editor.model;
+		const selection = model.document.selection;
+		const schema = model.schema;
+
+		this.isEnabled = isAllowedInParent( selection, schema ) &&
+			!checkSelectionOnObject( selection, schema );
+	}
+
+	/**
+	 * Executes the command.
+	 *
+	 * Inserts a table with the given number of rows and columns into the editor.
+	 *
+	 * @param {Object} options
+	 * @param {Number} [options.rows=2] The number of rows to create in the inserted table.
+	 * @param {Number} [options.columns=2] The number of columns to create in the inserted table.
+	 * @param {Number} [options.headingRows=0] The number of heading rows.
+	 * @param {Number} [options.headingColumns=0] The number of heading columns.
+	 * @fires execute
+	 */
+	execute( options = {} ) {
+		const model = this.editor.model;
+		const selection = model.document.selection;
+		const tableUtils = this.editor.plugins.get( 'TableUtils' );
+
+		const insertPosition = findOptimalInsertionPosition( selection, model );
+
+		model.change( writer => {
+			const table = tableUtils.createTable( writer, options );
+
+			model.insertContent( table, insertPosition );
+
+			writer.setSelection( writer.createPositionAt( table.getNodeByPath( [ 0, 0, 0 ] ), 0 ) );
+		} );
+	}
+}
+
+// Checks if the table is allowed in the parent.
+//
+// @param {module:engine/model/selection~Selection|module:engine/model/documentselection~DocumentSelection} selection
+// @param {module:engine/model/schema~Schema} schema
+// @returns {Boolean}
+function isAllowedInParent( selection, schema ) {
+	const positionParent = selection.getFirstPosition().parent;
+	const validParent = positionParent === positionParent.root ? positionParent : positionParent.parent;
+
+	return schema.checkChild( validParent, 'table' );
+}

package/src/assets/qms-ckeditor-plugin/src/plugins/table/commands/mergecellcommand.js

@@ -0,0 +1,272 @@
+/**
+ * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module table/commands/mergecellcommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+import TableWalker from '../tablewalker';
+import { getTableCellsContainingSelection } from '../utils/selection';
+import { isHeadingColumnCell } from '../utils/common';
+import { removeEmptyRowsColumns } from '../utils/structure';
+
+/**
+ * The merge cell command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'mergeTableCellRight'`, `'mergeTableCellLeft'`,
+ * `'mergeTableCellUp'` and `'mergeTableCellDown'` editor commands.
+ *
+ * To merge a table cell at the current selection with another cell, execute the command corresponding with the preferred direction.
+ *
+ * For example, to merge with a cell to the right:
+ *
+ *		editor.execute( 'mergeTableCellRight' );
+ *
+ * **Note**: If a table cell has a different [`rowspan`](https://www.w3.org/TR/html50/tabular-data.html#attr-tdth-rowspan)
+ * (for `'mergeTableCellRight'` and `'mergeTableCellLeft'`) or [`colspan`](https://www.w3.org/TR/html50/tabular-data.html#attr-tdth-colspan)
+ * (for `'mergeTableCellUp'` and `'mergeTableCellDown'`), the command will be disabled.
+ *
+ * @extends module:core/command~Command
+ */
+export default class MergeCellCommand extends Command {
+	/**
+	 * Creates a new `MergeCellCommand` instance.
+	 *
+	 * @param {module:core/editor/editor~Editor} editor The editor on which this command will be used.
+	 * @param {Object} options
+	 * @param {String} options.direction Indicates which cell to merge with the currently selected one.
+	 * Possible values are: `'left'`, `'right'`, `'up'` and `'down'`.
+	 */
+	constructor( editor, options ) {
+		super( editor );
+
+		/**
+		 * The direction that indicates which cell will be merged with the currently selected one.
+		 *
+		 * @readonly
+		 * @member {String} #direction
+		 */
+		this.direction = options.direction;
+
+		/**
+		 * Whether the merge is horizontal (left/right) or vertical (up/down).
+		 *
+		 * @readonly
+		 * @member {Boolean} #isHorizontal
+		 */
+		this.isHorizontal = this.direction == 'right' || this.direction == 'left';
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const cellToMerge = this._getMergeableCell();
+
+		this.value = cellToMerge;
+		this.isEnabled = !!cellToMerge;
+	}
+
+	/**
+	 * Executes the command.
+	 *
+	 * Depending on the command's {@link #direction} value, it will merge the cell that is to the `'left'`, `'right'`, `'up'` or `'down'`.
+	 *
+	 * @fires execute
+	 */
+	execute() {
+		const model = this.editor.model;
+		const doc = model.document;
+		const tableCell = getTableCellsContainingSelection( doc.selection )[ 0 ];
+
+		const cellToMerge = this.value;
+		const direction = this.direction;
+
+		model.change( writer => {
+			const isMergeNext = direction == 'right' || direction == 'down';
+
+			// The merge mechanism is always the same so sort cells to be merged.
+			const cellToExpand = isMergeNext ? tableCell : cellToMerge;
+			const cellToRemove = isMergeNext ? cellToMerge : tableCell;
+
+			// Cache the parent of cell to remove for later check.
+			const removedTableCellRow = cellToRemove.parent;
+
+			mergeTableCells( cellToRemove, cellToExpand, writer );
+
+			const spanAttribute = this.isHorizontal ? 'colspan' : 'rowspan';
+			const cellSpan = parseInt( tableCell.getAttribute( spanAttribute ) || 1 );
+			const cellToMergeSpan = parseInt( cellToMerge.getAttribute( spanAttribute ) || 1 );
+
+			// Update table cell span attribute and merge set selection on merged contents.
+			writer.setAttribute( spanAttribute, cellSpan + cellToMergeSpan, cellToExpand );
+			writer.setSelection( writer.createRangeIn( cellToExpand ) );
+
+			const tableUtils = this.editor.plugins.get( 'TableUtils' );
+			const table = removedTableCellRow.findAncestor( 'table' );
+
+			// Remove empty rows and columns after merging.
+			removeEmptyRowsColumns( table, tableUtils );
+		} );
+	}
+
+	/**
+	 * Returns a cell that can be merged with the current cell depending on the command's direction.
+	 *
+	 * @returns {module:engine/model/element~Element|undefined}
+	 * @private
+	 */
+	_getMergeableCell() {
+		const model = this.editor.model;
+		const doc = model.document;
+		const tableCell = getTableCellsContainingSelection( doc.selection )[ 0 ];
+
+		if ( !tableCell ) {
+			return;
+		}
+
+		const tableUtils = this.editor.plugins.get( 'TableUtils' );
+
+		// First get the cell on proper direction.
+		const cellToMerge = this.isHorizontal ?
+			getHorizontalCell( tableCell, this.direction, tableUtils ) :
+			getVerticalCell( tableCell, this.direction );
+
+		if ( !cellToMerge ) {
+			return;
+		}
+
+		// If found check if the span perpendicular to merge direction is equal on both cells.
+		const spanAttribute = this.isHorizontal ? 'rowspan' : 'colspan';
+		const span = parseInt( tableCell.getAttribute( spanAttribute ) || 1 );
+
+		const cellToMergeSpan = parseInt( cellToMerge.getAttribute( spanAttribute ) || 1 );
+
+		if ( cellToMergeSpan === span ) {
+			return cellToMerge;
+		}
+	}
+}
+
+// Returns the cell that can be merged horizontally.
+//
+// @param {module:engine/model/element~Element} tableCell
+// @param {String} direction
+// @returns {module:engine/model/node~Node|null}
+function getHorizontalCell( tableCell, direction, tableUtils ) {
+	const tableRow = tableCell.parent;
+	const table = tableRow.parent;
+	const horizontalCell = direction == 'right' ? tableCell.nextSibling : tableCell.previousSibling;
+	const hasHeadingColumns = ( table.getAttribute( 'headingColumns' ) || 0 ) > 0;
+
+	if ( !horizontalCell ) {
+		return;
+	}
+
+	// Sort cells:
+	const cellOnLeft = direction == 'right' ? tableCell : horizontalCell;
+	const cellOnRight = direction == 'right' ? horizontalCell : tableCell;
+
+	// Get their column indexes:
+	const { column: leftCellColumn } = tableUtils.getCellLocation( cellOnLeft );
+	const { column: rightCellColumn } = tableUtils.getCellLocation( cellOnRight );
+
+	const leftCellSpan = parseInt( cellOnLeft.getAttribute( 'colspan' ) || 1 );
+
+	const isCellOnLeftInHeadingColumn = isHeadingColumnCell( tableUtils, cellOnLeft, table );
+	const isCellOnRightInHeadingColumn = isHeadingColumnCell( tableUtils, cellOnRight, table );
+
+	// We cannot merge heading columns cells with regular cells.
+	if ( hasHeadingColumns && isCellOnLeftInHeadingColumn != isCellOnRightInHeadingColumn ) {
+		return;
+	}
+
+	// The cell on the right must have index that is distant to the cell on the left by the left cell's width (colspan).
+	const cellsAreTouching = leftCellColumn + leftCellSpan === rightCellColumn;
+
+	// If the right cell's column index is different it means that there are rowspanned cells between them.
+	return cellsAreTouching ? horizontalCell : undefined;
+}
+
+// Returns the cell that can be merged vertically.
+//
+// @param {module:engine/model/element~Element} tableCell
+// @param {String} direction
+// @returns {module:engine/model/node~Node|null}
+function getVerticalCell( tableCell, direction ) {
+	const tableRow = tableCell.parent;
+	const table = tableRow.parent;
+
+	const rowIndex = table.getChildIndex( tableRow );
+
+	// Don't search for mergeable cell if direction points out of the table.
+	if ( ( direction == 'down' && rowIndex === table.childCount - 1 ) || ( direction == 'up' && rowIndex === 0 ) ) {
+		return;
+	}
+
+	const rowspan = parseInt( tableCell.getAttribute( 'rowspan' ) || 1 );
+	const headingRows = table.getAttribute( 'headingRows' ) || 0;
+
+	const isMergeWithBodyCell = direction == 'down' && ( rowIndex + rowspan ) === headingRows;
+	const isMergeWithHeadCell = direction == 'up' && rowIndex === headingRows;
+
+	// Don't search for mergeable cell if direction points out of the current table section.
+	if ( headingRows && ( isMergeWithBodyCell || isMergeWithHeadCell ) ) {
+		return;
+	}
+
+	const currentCellRowSpan = parseInt( tableCell.getAttribute( 'rowspan' ) || 1 );
+	const rowOfCellToMerge = direction == 'down' ? rowIndex + currentCellRowSpan : rowIndex;
+
+	const tableMap = [ ...new TableWalker( table, { endRow: rowOfCellToMerge } ) ];
+
+	const currentCellData = tableMap.find( value => value.cell === tableCell );
+	const mergeColumn = currentCellData.column;
+
+	const cellToMergeData = tableMap.find( ( { row, cellHeight, column } ) => {
+		if ( column !== mergeColumn ) {
+			return false;
+		}
+
+		if ( direction == 'down' ) {
+			// If merging a cell below the mergeRow is already calculated.
+			return row === rowOfCellToMerge;
+		} else {
+			// If merging a cell above calculate if it spans to mergeRow.
+			return rowOfCellToMerge === row + cellHeight;
+		}
+	} );
+
+	return cellToMergeData && cellToMergeData.cell;
+}
+
+// Merges two table cells. It will ensure that after merging cells with an empty paragraph, the resulting table cell will only have one
+// paragraph. If one of the merged table cells is empty, the merged table cell will have the contents of the non-empty table cell.
+// If both are empty, the merged table cell will have only one empty paragraph.
+//
+// @param {module:engine/model/element~Element} cellToRemove
+// @param {module:engine/model/element~Element} cellToExpand
+// @param {module:engine/model/writer~Writer} writer
+function mergeTableCells( cellToRemove, cellToExpand, writer ) {
+	if ( !isEmpty( cellToRemove ) ) {
+		if ( isEmpty( cellToExpand ) ) {
+			writer.remove( writer.createRangeIn( cellToExpand ) );
+		}
+
+		writer.move( writer.createRangeIn( cellToRemove ), writer.createPositionAt( cellToExpand, 'end' ) );
+	}
+
+	// Remove merged table cell.
+	writer.remove( cellToRemove );
+}
+
+// Checks if the passed table cell contains an empty paragraph.
+//
+// @param {module:engine/model/element~Element} tableCell
+// @returns {Boolean}
+function isEmpty( tableCell ) {
+	return tableCell.childCount == 1 && tableCell.getChild( 0 ).is( 'element', 'paragraph' ) && tableCell.getChild( 0 ).isEmpty;
+}

package/src/assets/qms-ckeditor-plugin/src/plugins/table/commands/mergecellscommand.js

@@ -0,0 +1,122 @@
+/**
+ * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module table/commands/mergecellscommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+import TableUtils from '../tableutils';
+import { getSelectedTableCells, isSelectionRectangular } from '../utils/selection';
+import { updateNumericAttribute } from '../utils/common';
+import { removeEmptyRowsColumns } from '../utils/structure';
+
+/**
+ * The merge cells command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'mergeTableCells'` editor command.
+ *
+ * For example, to merge selected table cells:
+ *
+ *		editor.execute( 'mergeTableCells' );
+ *
+ * @extends module:core/command~Command
+ */
+export default class MergeCellsCommand extends Command {
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const selectedTableCells = getSelectedTableCells( this.editor.model.document.selection );
+		this.isEnabled = isSelectionRectangular( selectedTableCells, this.editor.plugins.get( TableUtils ) );
+	}
+
+	/**
+	 * Executes the command.
+	 *
+	 * @fires execute
+	 */
+	execute() {
+		const model = this.editor.model;
+		const tableUtils = this.editor.plugins.get( TableUtils );
+
+		model.change( writer => {
+			const selectedTableCells = getSelectedTableCells( model.document.selection );
+
+			// All cells will be merged into the first one.
+			const firstTableCell = selectedTableCells.shift();
+
+			// Update target cell dimensions.
+			const { mergeWidth, mergeHeight } = getMergeDimensions( firstTableCell, selectedTableCells, tableUtils );
+			updateNumericAttribute( 'colspan', mergeWidth, firstTableCell, writer );
+			updateNumericAttribute( 'rowspan', mergeHeight, firstTableCell, writer );
+
+			for ( const tableCell of selectedTableCells ) {
+				mergeTableCells( tableCell, firstTableCell, writer );
+			}
+
+			const table = firstTableCell.findAncestor( 'table' );
+
+			// Remove rows and columns that become empty (have no anchored cells).
+			removeEmptyRowsColumns( table, tableUtils );
+
+			writer.setSelection( firstTableCell, 'in' );
+		} );
+	}
+}
+
+// Merges two table cells. It will ensure that after merging cells with empty paragraphs the resulting table cell will only have one
+// paragraph. If one of the merged table cells is empty, the merged table cell will have contents of the non-empty table cell.
+// If both are empty, the merged table cell will have only one empty paragraph.
+//
+// @param {module:engine/model/element~Element} cellBeingMerged
+// @param {module:engine/model/element~Element} targetCell
+// @param {module:engine/model/writer~Writer} writer
+function mergeTableCells( cellBeingMerged, targetCell, writer ) {
+	if ( !isEmpty( cellBeingMerged ) ) {
+		if ( isEmpty( targetCell ) ) {
+			writer.remove( writer.createRangeIn( targetCell ) );
+		}
+
+		writer.move( writer.createRangeIn( cellBeingMerged ), writer.createPositionAt( targetCell, 'end' ) );
+	}
+
+	// Remove merged table cell.
+	writer.remove( cellBeingMerged );
+}
+
+// Checks if the passed table cell contains an empty paragraph.
+//
+// @param {module:engine/model/element~Element} tableCell
+// @returns {Boolean}
+function isEmpty( tableCell ) {
+	return tableCell.childCount == 1 && tableCell.getChild( 0 ).is( 'element', 'paragraph' ) && tableCell.getChild( 0 ).isEmpty;
+}
+
+function getMergeDimensions( firstTableCell, selectedTableCells, tableUtils ) {
+	let maxWidthOffset = 0;
+	let maxHeightOffset = 0;
+
+	for ( const tableCell of selectedTableCells ) {
+		const { row, column } = tableUtils.getCellLocation( tableCell );
+
+		maxWidthOffset = getMaxOffset( tableCell, column, maxWidthOffset, 'colspan' );
+		maxHeightOffset = getMaxOffset( tableCell, row, maxHeightOffset, 'rowspan' );
+	}
+
+	// Update table cell span attribute and merge set selection on a merged contents.
+	const { row: firstCellRow, column: firstCellColumn } = tableUtils.getCellLocation( firstTableCell );
+
+	const mergeWidth = maxWidthOffset - firstCellColumn;
+	const mergeHeight = maxHeightOffset - firstCellRow;
+
+	return { mergeWidth, mergeHeight };
+}
+
+function getMaxOffset( tableCell, start, currentMaxOffset, which ) {
+	const dimensionValue = parseInt( tableCell.getAttribute( which ) || 1 );
+
+	return Math.max( currentMaxOffset, start + dimensionValue );
+}