diff --git a/plugins/org.eclipse.dltk.javascript.formatter/src/org/eclipse/dltk/javascript/formatter/JavaScriptFormatterConstants.java b/plugins/org.eclipse.dltk.javascript.formatter/src/org/eclipse/dltk/javascript/formatter/JavaScriptFormatterConstants.java
index d5c47bf..82418f0 100644
--- a/plugins/org.eclipse.dltk.javascript.formatter/src/org/eclipse/dltk/javascript/formatter/JavaScriptFormatterConstants.java
+++ b/plugins/org.eclipse.dltk.javascript.formatter/src/org/eclipse/dltk/javascript/formatter/JavaScriptFormatterConstants.java
@@ -341,7 +341,7 @@
 	public static Map<String, Object> getDefaults() {
 		Map<String, Object> values = new HashMap<String, Object>();
 		for (Map.Entry<String, OptionInfo> entry : options.entrySet()) {
-			values.put(entry.getKey(), entry.getValue());
+			values.put(entry.getKey(), entry.getValue().defaultValue);
 		}
 		return values;
 	}
