diff --git a/src/script/katescriptdocument.h b/src/script/katescriptdocument.h
--- a/src/script/katescriptdocument.h
+++ b/src/script/katescriptdocument.h
@@ -62,40 +62,43 @@
     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 QJSValue wordRangeAt(int line, int column);
+    Q_INVOKABLE QJSValue wordRangeAt(const QJSValue & jscursor);
     QJSValue wordRangeAt(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE QString charAt(int line, int column);
+    Q_INVOKABLE QString charAt(const QJSValue &jscursor);
     QString charAt(const KTextEditor::Cursor &cursor);
-    Q_INVOKABLE QString charAt(const QJSValue &cursor);
     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);
+    bool isSpace(const KTextEditor::Cursor &cursor);
     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);
+    bool matchesAt(const KTextEditor::Cursor &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);
+    bool truncate(const KTextEditor::Cursor &cursor);
     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);
+    bool insertText(const KTextEditor::Cursor &cursor, const QString &s);
     Q_INVOKABLE bool removeText(int fromLine, int fromColumn, int toLine, int toColumn);
+    Q_INVOKABLE bool removeText(const QJSValue &range);
+    Q_INVOKABLE bool removeText(const QJSValue &jsfrom, const QJSValue &jsto);
     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 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);
+    bool wrapLine(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE void joinLines(int startLine, int endLine);
     Q_INVOKABLE int lines();
     Q_INVOKABLE bool isLineModified(int line);
@@ -109,11 +112,11 @@
     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);
+    int prevNonSpaceColumn(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE int nextNonSpaceColumn(int line, int column);
-    int nextNonSpaceColumn(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE int nextNonSpaceColumn(const QJSValue &cursor);
+    int nextNonSpaceColumn(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE int prevNonEmptyLine(int line);
     Q_INVOKABLE int nextNonEmptyLine(int line);
     Q_INVOKABLE bool isInWord(const QString &character, int attribute);
@@ -126,33 +129,33 @@
     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);
+    Q_INVOKABLE int attribute(const QJSValue &jscursor);
     int attribute(const KTextEditor::Cursor &cursor);
 
     /**
      * Return true if the highlight attribute equals @p attr.
      */
     Q_INVOKABLE bool isAttribute(int line, int column, int attr);
+    Q_INVOKABLE bool isAttribute(const QJSValue &jscursor, int attr);
     bool isAttribute(const KTextEditor::Cursor &cursor, 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);
+    QString attributeName(const KTextEditor::Cursor &cursor);
 
     /**
      * 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,11 +165,14 @@
     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);
+    int toVirtualColumn(const KTextEditor::Cursor &cursor);
+    Q_INVOKABLE QJSValue toVirtualCursor(const QJSValue &jscursor);
     KTextEditor::Cursor toVirtualCursor(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE int fromVirtualColumn(int line, int virtualColumn);
+    Q_INVOKABLE int fromVirtualColumn(const QJSValue &jscursor);
     int fromVirtualColumn(const KTextEditor::Cursor &virtualCursor);
+    Q_INVOKABLE QJSValue fromVirtualCursor(const QJSValue &jscursor);
     KTextEditor::Cursor fromVirtualCursor(const KTextEditor::Cursor &virtualCursor);
 
     KTextEditor::Cursor anchorInternal(int line, int column, QChar character);
@@ -179,26 +185,26 @@
     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);
+    int defStyleNum(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isCode(int line, int column);
-    bool isCode(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isCode(const QJSValue &cursor);
+    bool isCode(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isComment(int line, int column);
-    bool isComment(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isComment(const QJSValue &cursor);
+    bool isComment(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isString(int line, int column);
-    bool isString(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isString(const QJSValue &cursor);
+    bool isString(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isRegionMarker(int line, int column);
-    bool isRegionMarker(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isRegionMarker(const QJSValue &cursor);
+    bool isRegionMarker(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isChar(int line, int column);
-    bool isChar(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isChar(const QJSValue &cursor);
+    bool isChar(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isOthers(int line, int column);
-    bool isOthers(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE bool isOthers(const QJSValue &cursor);
+    bool isOthers(const KTextEditor::Cursor &cursor);
 
     Q_INVOKABLE bool startsWith(int line, const QString &pattern, bool skipWhiteSpaces);
     Q_INVOKABLE bool endsWith(int line, const QString &pattern, bool skipWhiteSpaces);
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,14 @@
     return m_document->defStyleNum(line, column);
 }
 
-int KateScriptDocument::defStyleNum(const KTextEditor::Cursor &cursor)
+int KateScriptDocument::defStyleNum(const QJSValue &jscursor)
 {
-    return defStyleNum(cursor.line(), cursor.column());
+    return defStyleNum(cursorFromScriptValue(jscursor));
 }
 
-int KateScriptDocument::defStyleNum(const QJSValue &jscursor)
+int KateScriptDocument::defStyleNum(const KTextEditor::Cursor &cursor)
 {
-    return defStyleNum(cursorFromScriptValue(jscursor));
+    return defStyleNum(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isCode(int line, int column)
@@ -68,14 +68,14 @@
     return _isCode(defaultStyle);
 }
 
-bool KateScriptDocument::isCode(const KTextEditor::Cursor &cursor)
+bool KateScriptDocument::isCode(const QJSValue &jscursor)
 {
-    return isCode(cursor.line(), cursor.column());
+    return isCode(cursorFromScriptValue(jscursor));
 }
 
-bool KateScriptDocument::isCode(const QJSValue &jscursor)
+bool KateScriptDocument::isCode(const KTextEditor::Cursor &cursor)
 {
-    return isCode(cursorFromScriptValue(jscursor));
+    return isCode(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isComment(int line, int column)
@@ -83,14 +83,14 @@
     return m_document->isComment(line, column);
 }
 
-bool KateScriptDocument::isComment(const KTextEditor::Cursor &cursor)
+bool KateScriptDocument::isComment(const QJSValue &jscursor)
 {
-    return isComment(cursor.line(), cursor.column());
+    return isComment(cursorFromScriptValue(jscursor));
 }
 
-bool KateScriptDocument::isComment(const QJSValue &jscursor)
+bool KateScriptDocument::isComment(const KTextEditor::Cursor &cursor)
 {
-    return isComment(cursorFromScriptValue(jscursor));
+    return isComment(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isString(int line, int column)
@@ -99,14 +99,14 @@
     return defaultStyle == KTextEditor::dsString;
 }
 
-bool KateScriptDocument::isString(const KTextEditor::Cursor &cursor)
+bool KateScriptDocument::isString(const QJSValue &jscursor)
 {
-    return isString(cursor.line(), cursor.column());
+    return isString(cursorFromScriptValue(jscursor));
 }
 
-bool KateScriptDocument::isString(const QJSValue &jscursor)
+bool KateScriptDocument::isString(const KTextEditor::Cursor &cursor)
 {
-    return isString(cursorFromScriptValue(jscursor));
+    return isString(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isRegionMarker(int line, int column)
@@ -115,14 +115,14 @@
     return defaultStyle == KTextEditor::dsRegionMarker;
 }
 
-bool KateScriptDocument::isRegionMarker(const KTextEditor::Cursor &cursor)
+bool KateScriptDocument::isRegionMarker(const QJSValue &jscursor)
 {
-    return isRegionMarker(cursor.line(), cursor.column());
+    return isRegionMarker(cursorFromScriptValue(jscursor));
 }
 
-bool KateScriptDocument::isRegionMarker(const QJSValue &jscursor)
+bool KateScriptDocument::isRegionMarker(const KTextEditor::Cursor &cursor)
 {
-    return isRegionMarker(cursorFromScriptValue(jscursor));
+    return isRegionMarker(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isChar(int line, int column)
@@ -131,14 +131,14 @@
     return defaultStyle == KTextEditor::dsChar;
 }
 
-bool KateScriptDocument::isChar(const KTextEditor::Cursor &cursor)
+bool KateScriptDocument::isChar(const QJSValue &jscursor)
 {
-    return isChar(cursor.line(), cursor.column());
+    return isChar(cursorFromScriptValue(jscursor));
 }
 
-bool KateScriptDocument::isChar(const QJSValue &jscursor)
+bool KateScriptDocument::isChar(const KTextEditor::Cursor &cursor)
 {
-    return isChar(cursorFromScriptValue(jscursor));
+    return isChar(cursor.line(), cursor.column());
 }
 
 bool KateScriptDocument::isOthers(int line, int column)
@@ -147,14 +147,14 @@
     return defaultStyle == KTextEditor::dsOthers;
 }
 
-bool KateScriptDocument::isOthers(const KTextEditor::Cursor &cursor)
+bool KateScriptDocument::isOthers(const QJSValue &jscursor)
 {
-    return isOthers(cursor.line(), cursor.column());
+    return isOthers(cursorFromScriptValue(jscursor));
 }
 
-bool KateScriptDocument::isOthers(const QJSValue &jscursor)
+bool KateScriptDocument::isOthers(const KTextEditor::Cursor &cursor)
 {
-    return isOthers(cursorFromScriptValue(jscursor));
+    return isOthers(cursor.line(), cursor.column());
 }
 
 int KateScriptDocument::firstVirtualColumn(int line)
@@ -189,14 +189,20 @@
     return textLine->toVirtualColumn(column, tabWidth);
 }
 
+int KateScriptDocument::toVirtualColumn(const QJSValue &jscursor)
+{
+    return toVirtualColumn(cursorFromScriptValue(jscursor));
+}
+
 int KateScriptDocument::toVirtualColumn(const KTextEditor::Cursor &cursor)
 {
     return toVirtualColumn(cursor.line(), cursor.column());
 }
 
-int KateScriptDocument::toVirtualColumn(const QJSValue &jscursor)
+QJSValue KateScriptDocument::toVirtualCursor(const QJSValue &jscursor)
 {
-    return toVirtualColumn(cursorFromScriptValue(jscursor));
+    const KTextEditor::Cursor cursor = toVirtualCursor(cursorFromScriptValue(jscursor));
+    return cursorToScriptValue(m_engine, cursor);
 }
 
 KTextEditor::Cursor KateScriptDocument::toVirtualCursor(const KTextEditor::Cursor &cursor)
@@ -215,11 +221,22 @@
     return textLine->fromVirtualColumn(virtualColumn, tabWidth);
 }
 
+int KateScriptDocument::fromVirtualColumn(const QJSValue &jscursor)
+{
+    return fromVirtualColumn(cursorFromScriptValue(jscursor));
+}
+
 int KateScriptDocument::fromVirtualColumn(const KTextEditor::Cursor &virtualCursor)
 {
     return fromVirtualColumn(virtualCursor.line(), virtualCursor.column());
 }
 
+QJSValue KateScriptDocument::fromVirtualCursor(const QJSValue &jscursor)
+{
+    const KTextEditor::Cursor cursor = fromVirtualCursor(cursorFromScriptValue(jscursor));
+    return cursorToScriptValue(m_engine, cursor);
+}
+
 KTextEditor::Cursor KateScriptDocument::fromVirtualCursor(const KTextEditor::Cursor &virtualCursor)
 {
     return KTextEditor::Cursor(virtualCursor.line(),
@@ -442,6 +459,11 @@
     return m_document->text(range);
 }
 
+QString KateScriptDocument::text(const QJSValue &jsfrom, const QJSValue &jsto)
+{
+    return text(cursorFromScriptValue(jsfrom), cursorFromScriptValue(jsto));
+}
+
 QString KateScriptDocument::text(const QJSValue &jsrange)
 {
     return text(rangeFromScriptValue(jsrange));
@@ -467,6 +489,11 @@
     return wordRangeAt(KTextEditor::Cursor(line, column));
 }
 
+QJSValue KateScriptDocument::wordRangeAt(const QJSValue & jscursor)
+{
+    return wordRangeAt(cursorFromScriptValue(jscursor));
+}
+
 QJSValue KateScriptDocument::wordRangeAt(const KTextEditor::Cursor &cursor)
 {
     return rangeToScriptValue(m_engine, m_document->wordRangeAt(cursor));
@@ -477,15 +504,15 @@
     return charAt(KTextEditor::Cursor(line, column));
 }
 
-QString KateScriptDocument::charAt(const KTextEditor::Cursor &cursor)
+QString KateScriptDocument::charAt(const QJSValue &jscursor)
 {
-    const QChar c = m_document->characterAt(cursor);
-    return c.isNull() ? QString() : QString(c);
+    return charAt(cursorFromScriptValue(jscursor));
 }
 
-QString KateScriptDocument::charAt(const QJSValue &jscursor)
+QString KateScriptDocument::charAt(const KTextEditor::Cursor &cursor)
 {
-    return charAt(cursorFromScriptValue(jscursor));
+    const QChar c = m_document->characterAt(cursor);
+    return c.isNull() ? QString() : QString(c);
 }
 
 QString KateScriptDocument::firstChar(int line)
@@ -515,14 +542,14 @@
     return isSpace(KTextEditor::Cursor(line, column));
 }
 
-bool KateScriptDocument::isSpace(const KTextEditor::Cursor &cursor)
+bool KateScriptDocument::isSpace(const QJSValue &jscursor)
 {
-    return m_document->characterAt(cursor).isSpace();
+    return isSpace(cursorFromScriptValue(jscursor));
 }
 
-bool KateScriptDocument::isSpace(const QJSValue &jscursor)
+bool KateScriptDocument::isSpace(const KTextEditor::Cursor &cursor)
 {
-    return isSpace(cursorFromScriptValue(jscursor));
+    return m_document->characterAt(cursor).isSpace();
 }
 
 bool KateScriptDocument::matchesAt(int line, int column, const QString &s)
@@ -565,24 +592,19 @@
     return removeText(KTextEditor::Range(from, to));
 }
 
-bool KateScriptDocument::truncate(const KTextEditor::Cursor &cursor)
-{
-    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)
+bool KateScriptDocument::truncate(const KTextEditor::Cursor &cursor)
 {
-    return insertText(KTextEditor::Cursor(line, column), s);
+    return truncate(cursor.line(), cursor.column());
 }
 
-bool KateScriptDocument::insertText(const KTextEditor::Cursor &cursor, const QString &s)
+bool KateScriptDocument::insertText(int line, int column, const QString &s)
 {
-    return m_document->insertText(cursor, s);
+    return insertText(KTextEditor::Cursor(line, column), s);
 }
 
 bool KateScriptDocument::insertText(const QJSValue &jscursor, const QString &s)
@@ -591,19 +613,19 @@
     return insertText(cursor, s);
 }
 
-bool KateScriptDocument::removeText(int fromLine, int fromColumn, int toLine, int toColumn)
+bool KateScriptDocument::insertText(const KTextEditor::Cursor &cursor, const QString &s)
 {
-    return removeText(KTextEditor::Range(fromLine, fromColumn, toLine, toColumn));
+    return m_document->insertText(cursor, s);
 }
 
-bool KateScriptDocument::removeText(const KTextEditor::Cursor &from, const KTextEditor::Cursor &to)
+bool KateScriptDocument::removeText(int fromLine, int fromColumn, int toLine, int toColumn)
 {
-    return removeText(KTextEditor::Range(from, to));
+    return removeText(KTextEditor::Range(fromLine, fromColumn, toLine, toColumn));
 }
 
-bool KateScriptDocument::removeText(const KTextEditor::Range &range)
+bool KateScriptDocument::removeText(const QJSValue &jsfrom, const QJSValue &jsto)
 {
-    return m_document->removeText(range);
+    return removeText(cursorFromScriptValue(jsfrom), cursorFromScriptValue(jsto));
 }
 
 bool KateScriptDocument::removeText(const QJSValue &jsrange)
@@ -612,6 +634,16 @@
     return removeText(range);
 }
 
+bool KateScriptDocument::removeText(const KTextEditor::Cursor &from, const KTextEditor::Cursor &to)
+{
+    return removeText(KTextEditor::Range(from, to));
+}
+
+bool KateScriptDocument::removeText(const KTextEditor::Range &range)
+{
+    return m_document->removeText(range);
+}
+
 bool KateScriptDocument::insertLine(int line, const QString &s)
 {
     return m_document->insertLine(line, s);
@@ -627,14 +659,14 @@
     return m_document->editWrapLine(line, column);
 }
 
-bool KateScriptDocument::wrapLine(const KTextEditor::Cursor &cursor)
+bool KateScriptDocument::wrapLine(const QJSValue &jscursor)
 {
-    return wrapLine(cursor.line(), cursor.column());
+    return wrapLine(cursorFromScriptValue(jscursor));
 }
 
-bool KateScriptDocument::wrapLine(const QJSValue &jscursor)
+bool KateScriptDocument::wrapLine(const KTextEditor::Cursor &cursor)
 {
-    return wrapLine(cursorFromScriptValue(jscursor));
+    return wrapLine(cursor.line(), cursor.column());
 }
 
 void KateScriptDocument::joinLines(int startLine, int endLine)
@@ -692,11 +724,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,14 +750,14 @@
     return textLine->previousNonSpaceChar(column);
 }
 
-int KateScriptDocument::prevNonSpaceColumn(const KTextEditor::Cursor &cursor)
+int KateScriptDocument::prevNonSpaceColumn(const QJSValue &cursor)
 {
-    return prevNonSpaceColumn(cursor.line(), cursor.column());
+    return prevNonSpaceColumn(cursorFromScriptValue(cursor));
 }
 
-int KateScriptDocument::prevNonSpaceColumn(const QJSValue &cursor)
+int KateScriptDocument::prevNonSpaceColumn(const KTextEditor::Cursor &cursor)
 {
-    return prevNonSpaceColumn(cursorFromScriptValue(cursor));
+    return prevNonSpaceColumn(cursor.line(), cursor.column());
 }
 
 int KateScriptDocument::nextNonSpaceColumn(int line, int column)
@@ -742,14 +769,14 @@
     return textLine->nextNonSpaceChar(column);
 }
 
-int KateScriptDocument::nextNonSpaceColumn(const KTextEditor::Cursor &cursor)
+int KateScriptDocument::nextNonSpaceColumn(const QJSValue &cursor)
 {
-    return nextNonSpaceColumn(cursor.line(), cursor.column());
+    return nextNonSpaceColumn(cursorFromScriptValue(cursor));
 }
 
-int KateScriptDocument::nextNonSpaceColumn(const QJSValue &cursor)
+int KateScriptDocument::nextNonSpaceColumn(const KTextEditor::Cursor &cursor)
 {
-    return nextNonSpaceColumn(cursorFromScriptValue(cursor));
+    return nextNonSpaceColumn(cursor.line(), cursor.column());
 }
 
 int KateScriptDocument::prevNonEmptyLine(int line)
@@ -831,6 +858,11 @@
     return textLine->attribute(column);
 }
 
+int KateScriptDocument::attribute(const QJSValue &jscursor)
+{
+    return attribute(cursorFromScriptValue(jscursor));
+}
+
 int KateScriptDocument::attribute(const KTextEditor::Cursor &cursor)
 {
     return attribute(cursor.line(), cursor.column());
@@ -841,6 +873,11 @@
     return attr == attribute(line, column);
 }
 
+bool KateScriptDocument::isAttribute(const QJSValue &jscursor, int attr)
+{
+    return isAttribute(cursorFromScriptValue(jscursor), attr);
+}
+
 bool KateScriptDocument::isAttribute(const KTextEditor::Cursor &cursor, int attr)
 {
     return isAttribute(cursor.line(), cursor.column(), attr);
@@ -854,30 +891,25 @@
     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));
 }
 
-bool KateScriptDocument::isAttributeName(int line, int column, const QString &name)
+QString KateScriptDocument::attributeName(const KTextEditor::Cursor &cursor)
 {
-    return name == attributeName(line, column);
+    return attributeName(cursor.line(), cursor.column());
 }
 
-bool KateScriptDocument::isAttributeName(const KTextEditor::Cursor &cursor, const QString &name)
+bool KateScriptDocument::isAttributeName(int line, int column, const QString &name)
 {
-    return isAttributeName(cursor.line(), cursor.column(), name);
+    return name == attributeName(line, column);
 }
 
 bool KateScriptDocument::isAttributeName(const QJSValue &jscursor, const QString &name)
 {
     KTextEditor::Cursor cursor = cursorFromScriptValue(jscursor);
-    return isAttributeName(cursor, name);
+    return isAttributeName(cursor.line(), cursor.column(), name);
 }
 
 QString KateScriptDocument::variable(const QString &s)
diff --git a/src/script/katescriptview.h b/src/script/katescriptview.h
--- a/src/script/katescriptview.h
+++ b/src/script/katescriptview.h
@@ -53,13 +53,13 @@
      * @since 4.4
      */
     Q_INVOKABLE void setCursorPosition(int line, int column);
-     void setCursorPosition(const KTextEditor::Cursor &cursor);
     Q_INVOKABLE void setCursorPosition(const QJSValue &cursor);
+     void setCursorPosition(const KTextEditor::Cursor &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);
+    void setVirtualCursorPosition(const KTextEditor::Cursor &cursor);
 
     Q_INVOKABLE QString selectedText();
     Q_INVOKABLE bool hasSelection();
@@ -70,7 +70,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
@@ -54,14 +54,14 @@
     m_view->setCursorPosition(c);
 }
 
-void KateScriptView::setCursorPosition(const KTextEditor::Cursor &cursor)
+void KateScriptView::setCursorPosition(const QJSValue &jscursor)
 {
-    m_view->setCursorPosition(cursor);
+    setCursorPosition(cursorFromScriptValue(jscursor));
 }
 
-void KateScriptView::setCursorPosition(const QJSValue &jscursor)
+void KateScriptView::setCursorPosition(const KTextEditor::Cursor &cursor)
 {
-    setCursorPosition(cursorFromScriptValue(jscursor));
+    m_view->setCursorPosition(cursor);
 }
 
 QJSValue KateScriptView::virtualCursorPosition()
@@ -74,14 +74,14 @@
     setVirtualCursorPosition(KTextEditor::Cursor(line, column));
 }
 
-void KateScriptView::setVirtualCursorPosition(const KTextEditor::Cursor &cursor)
+void KateScriptView::setVirtualCursorPosition(const QJSValue &jscursor)
 {
-    m_view->setCursorPositionVisual(cursor);
+    setVirtualCursorPosition(cursorFromScriptValue(jscursor));
 }
 
-void KateScriptView::setVirtualCursorPosition(const QJSValue &jscursor)
+void KateScriptView::setVirtualCursorPosition(const KTextEditor::Cursor &cursor)
 {
-    setVirtualCursorPosition(cursorFromScriptValue(jscursor));
+    m_view->setCursorPositionVisual(cursor);
 }
 
 QString KateScriptView::selectedText()