private static void duplicateHighlighters(
MarkupModel to, MarkupModel from, int offset, TextRange textRange) {
for (RangeHighlighter rangeHighlighter : from.getAllHighlighters()) {
if (!rangeHighlighter.isValid()) continue;
Object tooltip = rangeHighlighter.getErrorStripeTooltip();
HighlightInfo highlightInfo =
tooltip instanceof HighlightInfo ? (HighlightInfo) tooltip : null;
if (highlightInfo != null) {
if (highlightInfo.getSeverity() != HighlightSeverity.INFORMATION) continue;
if (highlightInfo.type.getAttributesKey() == EditorColors.IDENTIFIER_UNDER_CARET_ATTRIBUTES)
continue;
}
final int localOffset = textRange.getStartOffset();
final int start = Math.max(rangeHighlighter.getStartOffset(), localOffset) - localOffset;
final int end =
Math.min(rangeHighlighter.getEndOffset(), textRange.getEndOffset()) - localOffset;
if (start > end) continue;
final RangeHighlighter h =
to.addRangeHighlighter(
start + offset,
end + offset,
rangeHighlighter.getLayer(),
rangeHighlighter.getTextAttributes(),
rangeHighlighter.getTargetArea());
((RangeHighlighterEx) h)
.setAfterEndOfLine(((RangeHighlighterEx) rangeHighlighter).isAfterEndOfLine());
}
}
@Nullable
private static PsiElement findParent(
int syncStartOffset, int syncEndOffset, @NotNull AnchorTypeInfo type, PsiElement anchor) {
TextRange range = anchor.getTextRange();
if (range.getStartOffset() != syncStartOffset) return null;
while (range.getEndOffset() < syncEndOffset) {
anchor = anchor.getParent();
if (anchor == null || anchor.getTextRange() == null) {
return null;
}
range = anchor.getTextRange();
}
while (range.getEndOffset() == syncEndOffset) {
if (type.isAcceptable(anchor)) {
return anchor;
}
anchor = anchor.getParent();
if (anchor == null || anchor.getTextRange() == null) break;
range = anchor.getTextRange();
}
return null;
}
@Override
@Deprecated
@Nullable
public TextRange intersectWithEditable(@NotNull TextRange rangeToEdit) {
int startOffset = -1;
int endOffset = -1;
synchronized (myLock) {
int offset = 0;
for (PsiLanguageInjectionHost.Shred shred : myShreds) {
Segment hostRange = shred.getHostRangeMarker();
if (hostRange == null) continue;
offset += shred.getPrefix().length();
int length = hostRange.getEndOffset() - hostRange.getStartOffset();
TextRange intersection =
new ProperTextRange(offset, offset + length).intersection(rangeToEdit);
if (intersection != null) {
if (startOffset == -1) {
startOffset = intersection.getStartOffset();
}
endOffset = intersection.getEndOffset();
}
offset += length;
offset += shred.getSuffix().length();
}
}
if (startOffset == -1) return null;
return new ProperTextRange(startOffset, endOffset);
}
@NotNull
public static HighlightInfo fromAnnotation(
@NotNull Annotation annotation, @Nullable TextRange fixedRange, boolean batchMode) {
final TextAttributes forcedAttributes = annotation.getEnforcedTextAttributes();
final TextAttributesKey forcedAttributesKey =
forcedAttributes == null ? annotation.getTextAttributes() : null;
HighlightInfo info =
new HighlightInfo(
forcedAttributes,
forcedAttributesKey,
convertType(annotation),
fixedRange != null ? fixedRange.getStartOffset() : annotation.getStartOffset(),
fixedRange != null ? fixedRange.getEndOffset() : annotation.getEndOffset(),
annotation.getMessage(),
annotation.getTooltip(),
annotation.getSeverity(),
annotation.isAfterEndOfLine(),
annotation.needsUpdateOnTyping(),
annotation.isFileLevelAnnotation(),
0,
annotation.getProblemGroup(),
annotation.getGutterIconRenderer());
appendFixes(
fixedRange, info, batchMode ? annotation.getBatchFixes() : annotation.getQuickFixes());
return info;
}
@Override
@Nullable
public PsiElement restoreElement() {
long typeAndId = myStubElementTypeAndId;
int stubId = (int) typeAndId;
if (stubId != -1) {
PsiFile file = restoreFile();
if (!(file instanceof PsiFileWithStubSupport)) return null;
short index = (short) (typeAndId >> 32);
IStubElementType stubElementType = (IStubElementType) IElementType.find(index);
return PsiAnchor.restoreFromStubIndex(
(PsiFileWithStubSupport) file, stubId, stubElementType, false);
}
Segment psiRange = getPsiRange();
if (psiRange == null) return null;
PsiFile file = restoreFile();
if (file == null) return null;
PsiElement anchor = file.findElementAt(psiRange.getStartOffset());
if (anchor == null) return null;
TextRange range = anchor.getTextRange();
if (range.getStartOffset() != psiRange.getStartOffset()
|| range.getEndOffset() != psiRange.getEndOffset()) return null;
for (SmartPointerAnchorProvider provider : SmartPointerAnchorProvider.EP_NAME.getExtensions()) {
final PsiElement element = provider.restoreElement(anchor);
if (element != null) return element;
}
return null;
}
private void highlightInjectedSyntax(
@NotNull PsiFile injectedPsi, @NotNull HighlightInfoHolder holder) {
List<Trinity<IElementType, SmartPsiElementPointer<PsiLanguageInjectionHost>, TextRange>>
tokens = InjectedLanguageUtil.getHighlightTokens(injectedPsi);
if (tokens == null) return;
final Language injectedLanguage = injectedPsi.getLanguage();
Project project = injectedPsi.getProject();
SyntaxHighlighter syntaxHighlighter =
SyntaxHighlighterFactory.getSyntaxHighlighter(
injectedLanguage, project, injectedPsi.getVirtualFile());
final TextAttributes defaultAttrs = myGlobalScheme.getAttributes(HighlighterColors.TEXT);
for (Trinity<IElementType, SmartPsiElementPointer<PsiLanguageInjectionHost>, TextRange> token :
tokens) {
ProgressManager.checkCanceled();
IElementType tokenType = token.getFirst();
PsiLanguageInjectionHost injectionHost = token.getSecond().getElement();
if (injectionHost == null) continue;
TextRange textRange = token.getThird();
TextAttributesKey[] keys = syntaxHighlighter.getTokenHighlights(tokenType);
if (textRange.getLength() == 0) continue;
TextRange annRange = textRange.shiftRight(injectionHost.getTextRange().getStartOffset());
// force attribute colors to override host' ones
TextAttributes attributes = null;
for (TextAttributesKey key : keys) {
TextAttributes attrs2 = myGlobalScheme.getAttributes(key);
if (attrs2 != null) {
attributes = attributes == null ? attrs2 : TextAttributes.merge(attributes, attrs2);
}
}
TextAttributes forcedAttributes;
if (attributes == null || attributes.isEmpty() || attributes.equals(defaultAttrs)) {
forcedAttributes = TextAttributes.ERASE_MARKER;
} else {
HighlightInfo info =
HighlightInfo.newHighlightInfo(HighlightInfoType.INJECTED_LANGUAGE_FRAGMENT)
.range(annRange)
.textAttributes(TextAttributes.ERASE_MARKER)
.createUnconditionally();
holder.add(info);
forcedAttributes =
new TextAttributes(
attributes.getForegroundColor(),
attributes.getBackgroundColor(),
attributes.getEffectColor(),
attributes.getEffectType(),
attributes.getFontType());
}
HighlightInfo info =
HighlightInfo.newHighlightInfo(HighlightInfoType.INJECTED_LANGUAGE_FRAGMENT)
.range(annRange)
.textAttributes(forcedAttributes)
.createUnconditionally();
holder.add(info);
}
}
private static void highlightTodos(
@NotNull PsiFile file,
@NotNull CharSequence text,
int startOffset,
int endOffset,
@NotNull ProgressIndicator progress,
@NotNull ProperTextRange priorityRange,
@NotNull Collection<HighlightInfo> result,
@NotNull Collection<HighlightInfo> outsideResult) {
PsiSearchHelper helper = PsiSearchHelper.SERVICE.getInstance(file.getProject());
TodoItem[] todoItems = helper.findTodoItems(file, startOffset, endOffset);
if (todoItems.length == 0) return;
for (TodoItem todoItem : todoItems) {
progress.checkCanceled();
TextRange range = todoItem.getTextRange();
String description =
text.subSequence(range.getStartOffset(), range.getEndOffset()).toString();
TextAttributes attributes = todoItem.getPattern().getAttributes().getTextAttributes();
HighlightInfo info =
HighlightInfo.createHighlightInfo(
HighlightInfoType.TODO, range, description, description, attributes);
assert info != null;
if (priorityRange.containsRange(info.getStartOffset(), info.getEndOffset())) {
result.add(info);
} else {
outsideResult.add(info);
}
}
}
public void initMarkers(Place shreds) {
SmartPointerManager smartPointerManager = SmartPointerManager.getInstance(myProject);
int curOffset = -1;
for (PsiLanguageInjectionHost.Shred shred : shreds) {
final RangeMarker rangeMarker =
myNewDocument.createRangeMarker(
shred.getRange().getStartOffset() + shred.getPrefix().length(),
shred.getRange().getEndOffset() - shred.getSuffix().length());
final TextRange rangeInsideHost = shred.getRangeInsideHost();
PsiLanguageInjectionHost host = shred.getHost();
RangeMarker origMarker =
myOrigDocument.createRangeMarker(
rangeInsideHost.shiftRight(host.getTextRange().getStartOffset()));
SmartPsiElementPointer<PsiLanguageInjectionHost> elementPointer =
smartPointerManager.createSmartPsiElementPointer(host);
Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer> markers =
Trinity.<RangeMarker, RangeMarker, SmartPsiElementPointer>create(
origMarker, rangeMarker, elementPointer);
myMarkers.add(markers);
origMarker.setGreedyToRight(true);
rangeMarker.setGreedyToRight(true);
if (origMarker.getStartOffset() > curOffset) {
origMarker.setGreedyToLeft(true);
rangeMarker.setGreedyToLeft(true);
}
curOffset = origMarker.getEndOffset();
}
initGuardedBlocks(shreds);
}
@NotNull
@Override
public Builder range(@NotNull TextRange textRange) {
assert startOffset == -1 && endOffset == -1 : "Offsets already set";
startOffset = textRange.getStartOffset();
endOffset = textRange.getEndOffset();
return this;
}
@Override
@NotNull
public ProperTextRange injectedToHost(@NotNull TextRange injected) {
int start = injectedToHost(injected.getStartOffset(), false);
int end = injectedToHost(injected.getEndOffset(), true);
if (end < start) {
end = injectedToHost(injected.getEndOffset(), false);
}
return new ProperTextRange(start, end);
}
// finds the first nearest text range
private static TextRange findNearestTextRange(
final DocumentWindow documentWindow, final int startOffset) {
TextRange textRange = null;
for (RangeMarker marker : documentWindow.getHostRanges()) {
TextRange curRange = ProperTextRange.create(marker);
if (curRange.getStartOffset() > startOffset && textRange != null) break;
textRange = curRange;
}
assert textRange != null;
return textRange;
}
// finds the first nearest text range
@Nullable("null means invalid")
private static TextRange findNearestTextRange(
final DocumentWindow documentWindow, final int startOffset) {
TextRange textRange = null;
for (Segment marker : documentWindow.getHostRanges()) {
TextRange curRange = ProperTextRange.create(marker);
if (curRange.getStartOffset() > startOffset && textRange != null) break;
textRange = curRange;
}
return textRange;
}
public boolean changesRange(TextRange range) {
if (myAltFullRange != null) {
return range.intersects(myAltFullRange.getStartOffset(), myAltFullRange.getEndOffset());
} else if (!myMarkers.isEmpty()) {
TextRange hostRange =
TextRange.create(
myMarkers.get(0).first.getStartOffset(),
myMarkers.get(myMarkers.size() - 1).first.getEndOffset());
return range.intersects(hostRange);
}
return false;
}
@Override
public TextRange getHostRange(int hostOffset) {
synchronized (myLock) {
for (PsiLanguageInjectionHost.Shred shred : myShreds) {
Segment currentRange = shred.getHostRangeMarker();
if (currentRange == null) continue;
TextRange textRange = ProperTextRange.create(currentRange);
if (textRange.grown(1).contains(hostOffset)) return textRange;
}
}
return null;
}
@Override
public boolean containsRange(int start, int end) {
synchronized (myLock) {
ProperTextRange query = new ProperTextRange(start, end);
for (PsiLanguageInjectionHost.Shred shred : myShreds) {
Segment hostRange = shred.getHostRangeMarker();
if (hostRange == null) continue;
TextRange textRange = ProperTextRange.create(hostRange);
if (textRange.contains(query)) return true;
}
return false;
}
}
public void setMarkers(List<TextRange> ranges) {
checkWidget();
if (ranges == null) {
SWT.error(SWT.ERROR_NULL_ARGUMENT);
}
this.markers = ranges;
JsonArray values = new JsonArray();
for (TextRange range : ranges) {
values.add(range.getValue());
}
// getRemoteObject().call("addMarker", properties);
getRemoteObject().set("markers", values);
}
private static TextRange calculateLimitRange(
final PsiFile file, final Document doc, final int line) {
final int offset = doc.getLineStartOffset(line);
if (offset > 0) {
PsiMethod method =
PsiTreeUtil.getParentOfType(file.findElementAt(offset), PsiMethod.class, false);
if (method != null) {
final TextRange elemRange = method.getTextRange();
return new TextRange(
doc.getLineNumber(elemRange.getStartOffset()),
doc.getLineNumber(elemRange.getEndOffset()));
}
}
return new TextRange(0, doc.getLineCount() - 1);
}
public static boolean isInInjectedLanguagePrefixSuffix(@NotNull final PsiElement element) {
PsiFile injectedFile = element.getContainingFile();
if (injectedFile == null) return false;
Project project = injectedFile.getProject();
InjectedLanguageManager languageManager = InjectedLanguageManager.getInstance(project);
if (!languageManager.isInjectedFragment(injectedFile)) return false;
TextRange elementRange = element.getTextRange();
List<TextRange> editables =
languageManager.intersectWithAllEditableFragments(injectedFile, elementRange);
int combinedEdiablesLength = 0;
for (TextRange editable : editables) {
combinedEdiablesLength += editable.getLength();
}
return combinedEdiablesLength != elementRange.getLength();
}
@NotNull
public String getText() {
RangeHighlighterEx highlighter = this.highlighter;
if (highlighter == null) throw new RuntimeException("info not applied yet");
if (!highlighter.isValid()) return "";
return highlighter.getDocument().getText(TextRange.create(highlighter));
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
DocumentFoldingInfo info = (DocumentFoldingInfo) o;
if (myFile != null ? !myFile.equals(info.myFile) : info.myFile != null) {
return false;
}
if (!myProject.equals(info.myProject)
|| !myPsiElements.equals(info.myPsiElements)
|| !mySerializedElements.equals(info.mySerializedElements)) {
return false;
}
if (myRangeMarkers.size() != info.myRangeMarkers.size()) return false;
for (int i = 0; i < myRangeMarkers.size(); i++) {
RangeMarker marker = myRangeMarkers.get(i);
RangeMarker other = info.myRangeMarkers.get(i);
if (marker == other || !marker.isValid() || !other.isValid()) {
continue;
}
if (!TextRange.areSegmentsEqual(marker, other)) return false;
FoldingInfo fi = marker.getUserData(FOLDING_INFO_KEY);
FoldingInfo ofi = other.getUserData(FOLDING_INFO_KEY);
if (!Comparing.equal(fi, ofi)) return false;
}
return true;
}
void loadFromEditor(@NotNull Editor editor) {
assertDispatchThread();
LOG.assertTrue(!editor.isDisposed());
clear();
PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
documentManager.commitDocument(editor.getDocument());
PsiFile file = documentManager.getPsiFile(editor.getDocument());
SmartPointerManager smartPointerManager = SmartPointerManager.getInstance(myProject);
EditorFoldingInfo info = EditorFoldingInfo.get(editor);
FoldRegion[] foldRegions = editor.getFoldingModel().getAllFoldRegions();
for (FoldRegion region : foldRegions) {
if (!region.isValid()) continue;
PsiElement element = info.getPsiElement(region);
boolean expanded = region.isExpanded();
boolean collapseByDefault =
element != null
&& FoldingPolicy.isCollapseByDefault(element)
&& !FoldingUtil.caretInsideRange(editor, TextRange.create(region));
if (collapseByDefault == expanded || element == null) {
FoldingInfo fi = new FoldingInfo(region.getPlaceholderText(), expanded);
if (element != null) {
myPsiElements.add(smartPointerManager.createSmartPsiElementPointer(element, file));
element.putUserData(FOLDING_INFO_KEY, fi);
} else if (region.isValid()) {
myRangeMarkers.add(region);
region.putUserData(FOLDING_INFO_KEY, fi);
}
}
}
}
private static void adjustIndentationInRange(
final PsiFile file,
final Document document,
final TextRange[] indents,
final int indentAdjustment) {
final CharSequence charsSequence = document.getCharsSequence();
for (final TextRange indent : indents) {
final String oldIndentStr =
charsSequence.subSequence(indent.getStartOffset() + 1, indent.getEndOffset()).toString();
final int oldIndent =
IndentHelperImpl.getIndent(file.getProject(), file.getFileType(), oldIndentStr, true);
final String newIndentStr =
IndentHelperImpl.fillIndent(
file.getProject(), file.getFileType(), Math.max(oldIndent + indentAdjustment, 0));
document.replaceString(indent.getStartOffset() + 1, indent.getEndOffset(), newIndentStr);
}
}
private static TextRange getFixedTextRange(
@NotNull DocumentWindow documentWindow, int startOffset) {
final TextRange fixedTextRange;
TextRange textRange = documentWindow.getHostRange(startOffset);
if (textRange == null) {
// todo[cdr] check this fix. prefix/suffix code annotation case
textRange = findNearestTextRange(documentWindow, startOffset);
final boolean isBefore = startOffset < textRange.getStartOffset();
fixedTextRange =
new ProperTextRange(
isBefore ? textRange.getStartOffset() - 1 : textRange.getEndOffset(),
isBefore ? textRange.getStartOffset() : textRange.getEndOffset() + 1);
} else {
fixedTextRange = null;
}
return fixedTextRange;
}
private SchemaPrefixReference createPrefixReference(
ASTNode startTagName, String prefix, TagNameReference tagRef) {
return new SchemaPrefixReference(
this,
TextRange.from(startTagName.getStartOffset() - getStartOffset(), prefix.length()),
prefix,
tagRef);
}
@NotNull
public List<BreakpointWithHighlighter> findBreakpoints(
@NotNull Document document, @NotNull TextRange textRange) {
ApplicationManager.getApplication().assertIsDispatchThread();
List<BreakpointWithHighlighter> result = new ArrayList<BreakpointWithHighlighter>();
int startLine = document.getLineNumber(textRange.getStartOffset());
int endLine = document.getLineNumber(textRange.getEndOffset()) + 1;
TextRange lineRange = new TextRange(startLine, endLine);
for (final Breakpoint breakpoint : getBreakpoints()) {
if (breakpoint instanceof BreakpointWithHighlighter
&& lineRange.contains(((BreakpointWithHighlighter) breakpoint).getLineIndex())) {
result.add((BreakpointWithHighlighter) breakpoint);
}
}
return result;
}
public static List<PsiLambdaExpression> collectLambdas(
@NotNull SourcePosition position, final boolean onlyOnTheLine) {
ApplicationManager.getApplication().assertReadAccessAllowed();
PsiFile file = position.getFile();
final int line = position.getLine();
final Document document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file);
if (document == null || line >= document.getLineCount()) {
return Collections.emptyList();
}
PsiElement element = position.getElementAt();
final TextRange lineRange = DocumentUtil.getLineTextRange(document, line);
do {
PsiElement parent = element.getParent();
if (parent == null || (parent.getTextOffset() < lineRange.getStartOffset())) {
break;
}
element = parent;
} while (true);
final List<PsiLambdaExpression> lambdas = new ArrayList<PsiLambdaExpression>(3);
final PsiElementVisitor lambdaCollector =
new JavaRecursiveElementVisitor() {
@Override
public void visitLambdaExpression(PsiLambdaExpression expression) {
super.visitLambdaExpression(expression);
if (!onlyOnTheLine || getFirstElementOnTheLine(expression, document, line) != null) {
lambdas.add(expression);
}
}
};
element.accept(lambdaCollector);
// add initial lambda if we're inside already
PsiElement method = getContainingMethod(element);
if (method instanceof PsiLambdaExpression) {
lambdas.add((PsiLambdaExpression) method);
}
for (PsiElement sibling = getNextElement(element);
sibling != null;
sibling = getNextElement(sibling)) {
if (!intersects(lineRange, sibling)) {
break;
}
sibling.accept(lambdaCollector);
}
return lambdas;
}
public void registerFix(
@Nullable IntentionAction action,
@Nullable List<IntentionAction> options,
@Nullable String displayName,
@Nullable TextRange fixRange,
@Nullable HighlightDisplayKey key) {
if (action == null) return;
if (fixRange == null) fixRange = new TextRange(startOffset, endOffset);
if (quickFixActionRanges == null) {
quickFixActionRanges = ContainerUtil.createLockFreeCopyOnWriteList();
}
IntentionActionDescriptor desc =
new IntentionActionDescriptor(action, options, displayName, null, key, getProblemGroup());
quickFixActionRanges.add(Pair.create(desc, fixRange));
fixStartOffset = Math.min(fixStartOffset, fixRange.getStartOffset());
fixEndOffset = Math.max(fixEndOffset, fixRange.getEndOffset());
if (action instanceof HintAction) {
setHint(true);
}
}
@NotNull
static PsiElement loadTree(@NotNull PsiElement host, @NotNull PsiFile containingFile) {
if (containingFile instanceof DummyHolder) {
PsiElement context = containingFile.getContext();
if (context != null) {
PsiFile topFile = context.getContainingFile();
topFile.getNode(); // load tree
TextRange textRange =
host.getTextRange().shiftRight(context.getTextRange().getStartOffset());
PsiElement inLoadedTree =
PsiTreeUtil.findElementOfClassAtRange(
topFile, textRange.getStartOffset(), textRange.getEndOffset(), host.getClass());
if (inLoadedTree != null) {
host = inLoadedTree;
}
}
}
return host;
}
@Override
public int compare(TextRange o1, TextRange o2) {
if (o1.getStartOffset() == o2.getStartOffset()) {
return o2.getEndOffset() - o1.getEndOffset(); // longer is better
}
return o1.getStartOffset() - o2.getStartOffset();
}
@Override
public void visitReferenceExpression(final PsiReferenceExpression reference) {
if (myLineRange.intersects(reference.getTextRange())) {
final PsiElement psiElement = reference.resolve();
if (psiElement instanceof PsiVariable) {
final PsiVariable var = (PsiVariable) psiElement;
if (var instanceof PsiField) {
if (myCollectExpressions
&& !DebuggerUtils.hasSideEffectsOrReferencesMissingVars(
reference, myVisibleLocals)) {
/*
if (var instanceof PsiEnumConstant && reference.getQualifier() == null) {
final PsiClass enumClass = ((PsiEnumConstant)var).getContainingClass();
if (enumClass != null) {
final PsiExpression expression = JavaPsiFacade.getInstance(var.getProject()).getParserFacade().createExpressionFromText(enumClass.getName() + "." + var.getName(), var);
final PsiReference ref = expression.getReference();
if (ref != null) {
ref.bindToElement(var);
myExpressions.add(new TextWithImportsImpl(expression));
}
}
}
else {
myExpressions.add(new TextWithImportsImpl(reference));
}
*/
final PsiModifierList modifierList = var.getModifierList();
boolean isConstant =
(var instanceof PsiEnumConstant)
|| (modifierList != null
&& modifierList.hasModifierProperty(PsiModifier.STATIC)
&& modifierList.hasModifierProperty(PsiModifier.FINAL));
if (!isConstant) {
myExpressions.add(new TextWithImportsImpl(reference));
}
}
} else {
if (myVisibleLocals.contains(var.getName())) {
myVars.add(var.getName());
} else {
// fix for variables used in inner classes
if (!Comparing.equal(
PsiTreeUtil.getParentOfType(reference, PsiClass.class),
PsiTreeUtil.getParentOfType(var, PsiClass.class))) {
myExpressions.add(new TextWithImportsImpl(reference));
}
}
}
}
}
super.visitReferenceExpression(reference);
}