diff --git a/src/script/katescriptdocument.h b/src/script/katescriptdocument.h
--- a/src/script/katescriptdocument.h
+++ b/src/script/katescriptdocument.h
@@ -60,41 +60,33 @@
     Q_INVOKABLE bool isModified();
     Q_INVOKABLE QString text();
     Q_INVOKABLE QString text(int fromLine, int fromColumn, int toLine, int toColumn);
-    QString text(const KTextEditor::Cursor &from, const KTextEditor::Cursor &to);
-    QString text(const KTextEditor::Range &range);
+    Q_INVOKABLE QString text(const QJSValue &jsfrom, const QJSValue &jsto);
     Q_INVOKABLE QString text(const QJSValue &jsrange);
     Q_INVOKABLE QString line(int line);
     Q_INVOKABLE QString wordAt(int line, int column);
-    QString wordAt(const KTextEditor::Cursor &cursor);
+    Q_INVOKABLE QString wordAt(const QJSValue &jscursor);
     Q_INVOKABLE QJSValue wordRangeAt(int line, int column);
-    QJSValue wordRangeAt(const KTextEditor::Cursor &cursor);
+    Q_INVOKABLE QJSValue wordRangeAt(const QJSValue &jscursor);
     Q_INVOKABLE QString charAt(int line, int column);
-    QString charAt(const KTextEditor::Cursor &cursor);
-    Q_INVOKABLE QString charAt(const QJSValue &cursor);
+    Q_INVOKABLE QString charAt(const QJSValue &jscursor);
     Q_INVOKABLE QString firstChar(int line);
     Q_INVOKABLE QString lastChar(int line);
     Q_INVOKABLE bool isSpace(int line, int column);
-    bool isSpace(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isSpace(const QJSValue &jscursor);
     Q_INVOKABLE bool matchesAt(int line, int column, const QString &s);
-    bool matchesAt(const KTextEditor::Cursor &cursor, const QString &s);
     Q_INVOKABLE bool matchesAt(const QJSValue &cursor, const QString &s);
     Q_INVOKABLE bool setText(const QString &s);
     Q_INVOKABLE bool clear();
     Q_INVOKABLE bool truncate(int line, int column);
-    bool truncate(const KTextEditor::Cursor &cursor);
-    Q_INVOKABLE bool truncate(const QJSValue &cursor);
+    Q_INVOKABLE bool truncate(const QJSValue &jscursor);
     Q_INVOKABLE bool insertText(int line, int column, const QString &s);
-    bool insertText(const KTextEditor::Cursor &cursor, const QString &s);
     Q_INVOKABLE bool insertText(const QJSValue &jscursor, const QString &s);
     Q_INVOKABLE bool removeText(int fromLine, int fromColumn, int toLine, int toColumn);
-    bool removeText(const KTextEditor::Cursor &from, const KTextEditor::Cursor &to);
-    bool removeText(const KTextEditor::Range &range);
     Q_INVOKABLE bool removeText(const QJSValue &range);
+    Q_INVOKABLE bool removeText(const QJSValue &jsfrom, const QJSValue &jsto);
     Q_INVOKABLE bool insertLine(int line, const QString &s);
     Q_INVOKABLE bool removeLine(int line);
     Q_INVOKABLE bool wrapLine(int line, int column);
-    bool wrapLine(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool wrapLine(const QJSValue &cursor);
     Q_INVOKABLE void joinLines(int startLine, int endLine);
     Q_INVOKABLE int lines();
@@ -109,11 +101,9 @@
     Q_INVOKABLE int firstColumn(int line);
     Q_INVOKABLE int lastColumn(int line);
     Q_INVOKABLE int prevNonSpaceColumn(int line, int column);
-    int prevNonSpaceColumn(const KTextEditor::Cursor &cursor);
-    Q_INVOKABLE int prevNonSpaceColumn(const QJSValue &cursor);
+    Q_INVOKABLE int prevNonSpaceColumn(const QJSValue &jscursor);
     Q_INVOKABLE int nextNonSpaceColumn(int line, int column);
-    int nextNonSpaceColumn(const KTextEditor::Cursor &cursor);
-    Q_INVOKABLE int nextNonSpaceColumn(const QJSValue &cursor);
+    Q_INVOKABLE int nextNonSpaceColumn(const QJSValue &jscursor);
     Q_INVOKABLE int prevNonEmptyLine(int line);
     Q_INVOKABLE int nextNonEmptyLine(int line);
     Q_INVOKABLE bool isInWord(const QString &character, int attribute);
@@ -126,33 +116,30 @@
     Q_INVOKABLE QJSValue documentRange();
     Q_INVOKABLE QJSValue documentEnd();
     Q_INVOKABLE bool isValidTextPosition(int line, int column);
-    bool isValidTextPosition(const KTextEditor::Cursor& cursor);
     Q_INVOKABLE bool isValidTextPosition(const QJSValue& cursor);
 
     /**
      * Get the syntax highlighting attribute at a given position in the document.
      */
     Q_INVOKABLE int attribute(int line, int column);
-    int attribute(const KTextEditor::Cursor &cursor);
+    Q_INVOKABLE int attribute(const QJSValue &jscursor);
 
     /**
      * Return true if the highlight attribute equals @p attr.
      */
     Q_INVOKABLE bool isAttribute(int line, int column, int attr);
-    bool isAttribute(const KTextEditor::Cursor &cursor, int attr);
+    Q_INVOKABLE bool isAttribute(const QJSValue &jscursor, int attr);
 
     /**
      * Get the name of the syntax highlighting attribute at the given position.
      */
     Q_INVOKABLE QString attributeName(int line, int column);
-    QString attributeName(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE QString attributeName(const QJSValue &jscursor);
 
     /**
      * Return true is the name of the syntax attribute equals @p name.
      */
     Q_INVOKABLE bool isAttributeName(int line, int column, const QString &name);
-    bool isAttributeName(const KTextEditor::Cursor &cursor, const QString &name);
     Q_INVOKABLE bool isAttributeName(const QJSValue &cursor, const QString &name);
 
     Q_INVOKABLE QString variable(const QString &s);
@@ -162,12 +149,13 @@
     Q_INVOKABLE int firstVirtualColumn(int line);
     Q_INVOKABLE int lastVirtualColumn(int line);
     Q_INVOKABLE int toVirtualColumn(int line, int column);
-    int toVirtualColumn(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE int toVirtualColumn(const QJSValue &cursor);
-    KTextEditor::Cursor toVirtualCursor(const KTextEditor::Cursor &cursor);
+    Q_INVOKABLE QJSValue toVirtualCursor(int line, int column);
+    Q_INVOKABLE QJSValue toVirtualCursor(const QJSValue &jscursor);
     Q_INVOKABLE int fromVirtualColumn(int line, int virtualColumn);
-    int fromVirtualColumn(const KTextEditor::Cursor &virtualCursor);
-    KTextEditor::Cursor fromVirtualCursor(const KTextEditor::Cursor &virtualCursor);
+    Q_INVOKABLE int fromVirtualColumn(const QJSValue &jscursor);
+    Q_INVOKABLE QJSValue fromVirtualCursor(int line, int column);
+    Q_INVOKABLE QJSValue fromVirtualCursor(const QJSValue &jscursor);
 
     KTextEditor::Cursor anchorInternal(int line, int column, QChar character);
     KTextEditor::Cursor anchor(const KTextEditor::Cursor &cursor, QChar character);
@@ -179,31 +167,23 @@
     Q_INVOKABLE QJSValue rfind(const QJSValue &cursor, const QString &text, int attribute = -1);
 
     Q_INVOKABLE int defStyleNum(int line, int column);
-    int defStyleNum(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE int defStyleNum(const QJSValue &cursor);
     Q_INVOKABLE bool isCode(int line, int column);
-    bool isCode(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isCode(const QJSValue &cursor);
     Q_INVOKABLE bool isComment(int line, int column);
-    bool isComment(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isComment(const QJSValue &cursor);
     Q_INVOKABLE bool isString(int line, int column);
-    bool isString(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isString(const QJSValue &cursor);
     Q_INVOKABLE bool isRegionMarker(int line, int column);
-    bool isRegionMarker(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isRegionMarker(const QJSValue &cursor);
     Q_INVOKABLE bool isChar(int line, int column);
-    bool isChar(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isChar(const QJSValue &cursor);
     Q_INVOKABLE bool isOthers(int line, int column);
-    bool isOthers(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isOthers(const QJSValue &cursor);
 
     Q_INVOKABLE bool startsWith(int line, const QString &pattern, bool skipWhiteSpaces);
     Q_INVOKABLE bool endsWith(int line, const QString &pattern, bool skipWhiteSpaces);
 
-    void indent(KTextEditor::Range range, int change);
     Q_INVOKABLE void indent(const QJSValue &jsrange, int change);
 
 private:
diff --git a/src/script/katescriptdocument.cpp b/src/script/katescriptdocument.cpp
--- a/src/script/katescriptdocument.cpp
+++ b/src/script/katescriptdocument.cpp
@@ -52,14 +52,10 @@
     return m_document->defStyleNum(line, column);
 }
 
-int KateScriptDocument::defStyleNum(const KTextEditor::Cursor &cursor)
-{
-    return defStyleNum(cursor.line(), cursor.column());
-}
-
 int KateScriptDocument::defStyleNum(const QJSValue &jscursor)
 {
-    return defStyleNum(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return defStyleNum(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isCode(int line, int column)
@@ -68,14 +64,10 @@
     return _isCode(defaultStyle);
 }
 
-bool KateScriptDocument::isCode(const KTextEditor::Cursor &cursor)
-{
-    return isCode(cursor.line(), cursor.column());
-}
-
 bool KateScriptDocument::isCode(const QJSValue &jscursor)
 {
-    return isCode(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return isCode(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isComment(int line, int column)
@@ -83,14 +75,10 @@
     return m_document->isComment(line, column);
 }
 
-bool KateScriptDocument::isComment(const KTextEditor::Cursor &cursor)
-{
-    return isComment(cursor.line(), cursor.column());
-}
-
 bool KateScriptDocument::isComment(const QJSValue &jscursor)
 {
-    return isComment(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return isComment(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isString(int line, int column)
@@ -99,14 +87,10 @@
     return defaultStyle == KTextEditor::dsString;
 }
 
-bool KateScriptDocument::isString(const KTextEditor::Cursor &cursor)
-{
-    return isString(cursor.line(), cursor.column());
-}
-
 bool KateScriptDocument::isString(const QJSValue &jscursor)
 {
-    return isString(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return isString(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isRegionMarker(int line, int column)
@@ -115,14 +99,10 @@
     return defaultStyle == KTextEditor::dsRegionMarker;
 }
 
-bool KateScriptDocument::isRegionMarker(const KTextEditor::Cursor &cursor)
-{
-    return isRegionMarker(cursor.line(), cursor.column());
-}
-
 bool KateScriptDocument::isRegionMarker(const QJSValue &jscursor)
 {
-    return isRegionMarker(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return isRegionMarker(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isChar(int line, int column)
@@ -131,14 +111,10 @@
     return defaultStyle == KTextEditor::dsChar;
 }
 
-bool KateScriptDocument::isChar(const KTextEditor::Cursor &cursor)
-{
-    return isChar(cursor.line(), cursor.column());
-}
-
 bool KateScriptDocument::isChar(const QJSValue &jscursor)
 {
-    return isChar(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return isChar(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isOthers(int line, int column)
@@ -147,14 +123,10 @@
     return defaultStyle == KTextEditor::dsOthers;
 }
 
-bool KateScriptDocument::isOthers(const KTextEditor::Cursor &cursor)
-{
-    return isOthers(cursor.line(), cursor.column());
-}
-
 bool KateScriptDocument::isOthers(const QJSValue &jscursor)
 {
-    return isOthers(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return isOthers(cursor.line(), cursor.column());
 }
 
 int KateScriptDocument::firstVirtualColumn(int line)
@@ -189,20 +161,22 @@
     return textLine->toVirtualColumn(column, tabWidth);
 }
 
-int KateScriptDocument::toVirtualColumn(const KTextEditor::Cursor &cursor)
+int KateScriptDocument::toVirtualColumn(const QJSValue &jscursor)
 {
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
     return toVirtualColumn(cursor.line(), cursor.column());
 }
 
-int KateScriptDocument::toVirtualColumn(const QJSValue &jscursor)
+QJSValue KateScriptDocument::toVirtualCursor(int line, int column)
 {
-    return toVirtualColumn(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor(line, toVirtualColumn(line, column));
+    return cursorToScriptValue(m_engine, cursor);
 }
 
-KTextEditor::Cursor KateScriptDocument::toVirtualCursor(const KTextEditor::Cursor &cursor)
+QJSValue KateScriptDocument::toVirtualCursor(const QJSValue &jscursor)
 {
-    return KTextEditor::Cursor(cursor.line(),
-                               toVirtualColumn(cursor.line(), cursor.column()));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return toVirtualCursor(cursor.line(), cursor.column());
 }
 
 int KateScriptDocument::fromVirtualColumn(int line, int virtualColumn)
@@ -215,15 +189,22 @@
     return textLine->fromVirtualColumn(virtualColumn, tabWidth);
 }
 
-int KateScriptDocument::fromVirtualColumn(const KTextEditor::Cursor &virtualCursor)
+int KateScriptDocument::fromVirtualColumn(const QJSValue &jscursor)
 {
-    return fromVirtualColumn(virtualCursor.line(), virtualCursor.column());
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return fromVirtualColumn(cursor.line(), cursor.column());
 }
 
-KTextEditor::Cursor KateScriptDocument::fromVirtualCursor(const KTextEditor::Cursor &virtualCursor)
+QJSValue KateScriptDocument::fromVirtualCursor(int line, int column)
 {
-    return KTextEditor::Cursor(virtualCursor.line(),
-                               fromVirtualColumn(virtualCursor.line(), virtualCursor.column()));
+    const KTextEditor::Cursor cursor(line, fromVirtualColumn(line, column));
+    return cursorToScriptValue(m_engine, cursor);
+}
+
+QJSValue KateScriptDocument::fromVirtualCursor(const QJSValue &jscursor)
+{
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return fromVirtualCursor(cursor.line(), cursor.column());
 }
 
 KTextEditor::Cursor KateScriptDocument::rfindInternal(int line, int column, const QString &text, int attribute)
@@ -380,8 +361,6 @@
     return textLine->endsWith(pattern);
 }
 
-//BEGIN Automatically generated
-
 QString KateScriptDocument::fileName()
 {
     return m_document->documentName();
@@ -429,22 +408,21 @@
 
 QString KateScriptDocument::text(int fromLine, int fromColumn, int toLine, int toColumn)
 {
-    return text(KTextEditor::Range(fromLine, fromColumn, toLine, toColumn));
+    const KTextEditor::Range range(fromLine, fromColumn, toLine, toColumn);
+    return m_document->text(range);
 }
 
-QString KateScriptDocument::text(const KTextEditor::Cursor &from, const KTextEditor::Cursor &to)
+QString KateScriptDocument::text(const QJSValue &jsfrom, const QJSValue &jsto)
 {
-    return text(KTextEditor::Range(from, to));
-}
-
-QString KateScriptDocument::text(const KTextEditor::Range &range)
-{
-    return m_document->text(range);
+    const KTextEditor::Cursor from = cursorFromScriptValue(jsfrom);
+    const KTextEditor::Cursor to = cursorFromScriptValue(jsto);
+    return text(from.line(), from.column(), to.line(), to.column());
 }
 
 QString KateScriptDocument::text(const QJSValue &jsrange)
 {
-    return text(rangeFromScriptValue(jsrange));
+    const KTextEditor::Range range = rangeFromScriptValue(jsrange);
+    return text(range.start().line(), range.start().column(), range.end().line(), range.end().column());
 }
 
 QString KateScriptDocument::line(int line)
@@ -454,38 +432,39 @@
 
 QString KateScriptDocument::wordAt(int line, int column)
 {
-    return wordAt(KTextEditor::Cursor(line, column));
-}
-
-QString KateScriptDocument::wordAt(const KTextEditor::Cursor &cursor)
-{
+    const KTextEditor::Cursor cursor(line, column);
     return m_document->wordAt(cursor);
 }
 
-QJSValue KateScriptDocument::wordRangeAt(int line, int column)
+QString KateScriptDocument::wordAt(const QJSValue &jscursor)
 {
-    return wordRangeAt(KTextEditor::Cursor(line, column));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return wordAt(cursor.line(), cursor.column());
 }
 
-QJSValue KateScriptDocument::wordRangeAt(const KTextEditor::Cursor &cursor)
+QJSValue KateScriptDocument::wordRangeAt(int line, int column)
 {
+    const KTextEditor::Cursor cursor(line, column);
     return rangeToScriptValue(m_engine, m_document->wordRangeAt(cursor));
 }
 
-QString KateScriptDocument::charAt(int line, int column)
+QJSValue KateScriptDocument::wordRangeAt(const QJSValue &jscursor)
 {
-    return charAt(KTextEditor::Cursor(line, column));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return wordRangeAt(cursor.line(), cursor.column());
 }
 
-QString KateScriptDocument::charAt(const KTextEditor::Cursor &cursor)
+QString KateScriptDocument::charAt(int line, int column)
 {
+    const KTextEditor::Cursor cursor(line, column);
     const QChar c = m_document->characterAt(cursor);
     return c.isNull() ? QString() : QString(c);
 }
 
 QString KateScriptDocument::charAt(const QJSValue &jscursor)
 {
-    return charAt(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return charAt(cursor.line(), cursor.column());
 }
 
 QString KateScriptDocument::firstChar(int line)
@@ -512,17 +491,14 @@
 
 bool KateScriptDocument::isSpace(int line, int column)
 {
-    return isSpace(KTextEditor::Cursor(line, column));
-}
-
-bool KateScriptDocument::isSpace(const KTextEditor::Cursor &cursor)
-{
+    const KTextEditor::Cursor cursor(line, column);
     return m_document->characterAt(cursor).isSpace();
 }
 
 bool KateScriptDocument::isSpace(const QJSValue &jscursor)
 {
-    return isSpace(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return isSpace(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::matchesAt(int line, int column, const QString &s)
@@ -531,17 +507,10 @@
     return textLine ? textLine->matchesAt(column, s) : false;
 }
 
-bool KateScriptDocument::matchesAt(const KTextEditor::Cursor &cursor, const QString &s)
-{
-
-    return matchesAt(cursor.line(), cursor.column(), s);
-}
-
 bool KateScriptDocument::matchesAt(const QJSValue &jscursor, const QString &s)
 {
-
-    KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
-    return matchesAt(cursor, s);
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return matchesAt(cursor.line(), cursor.column(), s);
 }
 
 bool KateScriptDocument::setText(const QString &s)
@@ -561,55 +530,44 @@
         return false;
     }
 
-    KTextEditor::Cursor from(line, column), to(line, textLine->text().size() - column);
-    return removeText(KTextEditor::Range(from, to));
+    return removeText(line, column, line, textLine->text().size() - column);
 }
 
-bool KateScriptDocument::truncate(const KTextEditor::Cursor &cursor)
+bool KateScriptDocument::truncate(const QJSValue &jscursor)
 {
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
     return truncate(cursor.line(), cursor.column());
 }
 
-bool KateScriptDocument::truncate(const QJSValue &cursor)
-{
-    return truncate(cursorFromScriptValue(cursor));
-}
-
 bool KateScriptDocument::insertText(int line, int column, const QString &s)
 {
-    return insertText(KTextEditor::Cursor(line, column), s);
-}
-
-bool KateScriptDocument::insertText(const KTextEditor::Cursor &cursor, const QString &s)
-{
+    KTextEditor::Cursor cursor(line, column);
     return m_document->insertText(cursor, s);
 }
 
 bool KateScriptDocument::insertText(const QJSValue &jscursor, const QString &s)
 {
-    KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
-    return insertText(cursor, s);
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return insertText(cursor.line(), cursor.column(), s);
 }
 
 bool KateScriptDocument::removeText(int fromLine, int fromColumn, int toLine, int toColumn)
 {
-    return removeText(KTextEditor::Range(fromLine, fromColumn, toLine, toColumn));
+    const KTextEditor::Range range(fromLine, fromColumn, toLine, toColumn);
+    return m_document->removeText(range);
 }
 
-bool KateScriptDocument::removeText(const KTextEditor::Cursor &from, const KTextEditor::Cursor &to)
+bool KateScriptDocument::removeText(const QJSValue &jsfrom, const QJSValue &jsto)
 {
-    return removeText(KTextEditor::Range(from, to));
-}
-
-bool KateScriptDocument::removeText(const KTextEditor::Range &range)
-{
-    return m_document->removeText(range);
+    const KTextEditor::Cursor from = cursorFromScriptValue(jsfrom);
+    const KTextEditor::Cursor to = cursorFromScriptValue(jsto);
+    return removeText(from.line(), from.column(), to.line(), to.column());
 }
 
 bool KateScriptDocument::removeText(const QJSValue &jsrange)
 {
-    KTextEditor::Range range = rangeFromScriptValue(jsrange);
-    return removeText(range);
+    const KTextEditor::Range range = rangeFromScriptValue(jsrange);
+    return removeText(range.start().line(), range.start().column(), range.end().line(), range.end().column());
 }
 
 bool KateScriptDocument::insertLine(int line, const QString &s)
@@ -627,14 +585,10 @@
     return m_document->editWrapLine(line, column);
 }
 
-bool KateScriptDocument::wrapLine(const KTextEditor::Cursor &cursor)
-{
-    return wrapLine(cursor.line(), cursor.column());
-}
-
 bool KateScriptDocument::wrapLine(const QJSValue &jscursor)
 {
-    return wrapLine(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return wrapLine(cursor.line(), cursor.column());
 }
 
 void KateScriptDocument::joinLines(int startLine, int endLine)
@@ -692,11 +646,6 @@
     return m_document->isValidTextPosition(KTextEditor::Cursor(line, column));
 }
 
-bool KateScriptDocument::isValidTextPosition(const KTextEditor::Cursor& cursor)
-{
-    return m_document->isValidTextPosition(cursor);
-}
-
 bool KateScriptDocument::isValidTextPosition(const QJSValue& cursor)
 {
     return m_document->isValidTextPosition(cursorFromScriptValue(cursor));
@@ -723,16 +672,12 @@
     return textLine->previousNonSpaceChar(column);
 }
 
-int KateScriptDocument::prevNonSpaceColumn(const KTextEditor::Cursor &cursor)
+int KateScriptDocument::prevNonSpaceColumn(const QJSValue &jscursor)
 {
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
     return prevNonSpaceColumn(cursor.line(), cursor.column());
 }
 
-int KateScriptDocument::prevNonSpaceColumn(const QJSValue &cursor)
-{
-    return prevNonSpaceColumn(cursorFromScriptValue(cursor));
-}
-
 int KateScriptDocument::nextNonSpaceColumn(int line, int column)
 {
     Kate::TextLine textLine = m_document->plainKateTextLine(line);
@@ -742,16 +687,12 @@
     return textLine->nextNonSpaceChar(column);
 }
 
-int KateScriptDocument::nextNonSpaceColumn(const KTextEditor::Cursor &cursor)
+int KateScriptDocument::nextNonSpaceColumn(const QJSValue &jscursor)
 {
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
     return nextNonSpaceColumn(cursor.line(), cursor.column());
 }
 
-int KateScriptDocument::nextNonSpaceColumn(const QJSValue &cursor)
-{
-    return nextNonSpaceColumn(cursorFromScriptValue(cursor));
-}
-
 int KateScriptDocument::prevNonEmptyLine(int line)
 {
     const int startLine = line;
@@ -831,8 +772,9 @@
     return textLine->attribute(column);
 }
 
-int KateScriptDocument::attribute(const KTextEditor::Cursor &cursor)
+int KateScriptDocument::attribute(const QJSValue &jscursor)
 {
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
     return attribute(cursor.line(), cursor.column());
 }
 
@@ -841,8 +783,9 @@
     return attr == attribute(line, column);
 }
 
-bool KateScriptDocument::isAttribute(const KTextEditor::Cursor &cursor, int attr)
+bool KateScriptDocument::isAttribute(const QJSValue &jscursor, int attr)
 {
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
     return isAttribute(cursor.line(), cursor.column(), attr);
 }
 
@@ -854,14 +797,10 @@
     return a->name();
 }
 
-QString KateScriptDocument::attributeName(const KTextEditor::Cursor &cursor)
-{
-    return attributeName(cursor.line(), cursor.column());
-}
-
 QString KateScriptDocument::attributeName(const QJSValue &jscursor)
 {
-    return attributeName(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return attributeName(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isAttributeName(int line, int column, const QString &name)
@@ -869,15 +808,10 @@
     return name == attributeName(line, column);
 }
 
-bool KateScriptDocument::isAttributeName(const KTextEditor::Cursor &cursor, const QString &name)
-{
-    return isAttributeName(cursor.line(), cursor.column(), name);
-}
-
 bool KateScriptDocument::isAttributeName(const QJSValue &jscursor, const QString &name)
 {
-    KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
-    return isAttributeName(cursor, name);
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    return isAttributeName(cursor.line(), cursor.column(), name);
 }
 
 QString KateScriptDocument::variable(const QString &s)
@@ -890,8 +824,6 @@
     m_document->setVariable(s, v);
 }
 
-//END
-
 bool KateScriptDocument::_isCode(int defaultStyle)
 {
     return (defaultStyle != KTextEditor::dsComment
@@ -901,13 +833,8 @@
             && defaultStyle != KTextEditor::dsOthers);
 }
 
-void KateScriptDocument::indent(KTextEditor::Range range, int change)
-{
-    m_document->indent(range, change);
-}
-
 void KateScriptDocument::indent(const QJSValue &jsrange, int change)
 {
-    KTextEditor::Range range = rangeFromScriptValue(jsrange);
-    indent(range, change);
+    const KTextEditor::Range range = rangeFromScriptValue(jsrange);
+    m_document->indent(range, change);
 }
diff --git a/src/script/katescriptview.h b/src/script/katescriptview.h
--- a/src/script/katescriptview.h
+++ b/src/script/katescriptview.h
@@ -53,12 +53,10 @@
      * @since 4.4
      */
     Q_INVOKABLE void setCursorPosition(int line, int column);
-     void setCursorPosition(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE void setCursorPosition(const QJSValue &cursor);
 
     Q_INVOKABLE QJSValue virtualCursorPosition();
     Q_INVOKABLE void setVirtualCursorPosition(int line, int column);
-    void setVirtualCursorPosition(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE void setVirtualCursorPosition(const QJSValue &cursor);
 
     Q_INVOKABLE QString selectedText();
@@ -70,7 +68,7 @@
     Q_INVOKABLE void clearSelection();
 
     Q_INVOKABLE void align(const QJSValue &range);
-    
+
 private:
     KTextEditor::ViewPrivate *m_view;
     QJSEngine *m_engine;
diff --git a/src/script/katescriptview.cpp b/src/script/katescriptview.cpp
--- a/src/script/katescriptview.cpp
+++ b/src/script/katescriptview.cpp
@@ -50,18 +50,14 @@
 
 void KateScriptView::setCursorPosition(int line, int column)
 {
-    KTextEditor::Cursor c(line, column);
-    m_view->setCursorPosition(c);
-}
-
-void KateScriptView::setCursorPosition(const KTextEditor::Cursor &cursor)
-{
+    const KTextEditor::Cursor cursor(line, column);
     m_view->setCursorPosition(cursor);
 }
 
 void KateScriptView::setCursorPosition(const QJSValue &jscursor)
 {
-    setCursorPosition(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    m_view->setCursorPosition(cursor);
 }
 
 QJSValue KateScriptView::virtualCursorPosition()
@@ -71,17 +67,14 @@
 
 void KateScriptView::setVirtualCursorPosition(int line, int column)
 {
-    setVirtualCursorPosition(KTextEditor::Cursor(line, column));
-}
-
-void KateScriptView::setVirtualCursorPosition(const KTextEditor::Cursor &cursor)
-{
+    const KTextEditor::Cursor cursor(line, column);
     m_view->setCursorPositionVisual(cursor);
 }
 
 void KateScriptView::setVirtualCursorPosition(const QJSValue &jscursor)
 {
-    setVirtualCursorPosition(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
+    setVirtualCursorPosition(cursor.line(), cursor.column());
 }
 
 QString KateScriptView::selectedText()