diff --git a/scour.inkscape.py b/scour.inkscape.py
index f21e223..ad3bfcd 100755
--- a/scour.inkscape.py
+++ b/scour.inkscape.py
@@ -22,12 +22,18 @@ class ScourInkscape (inkex.Effect):
         self.OptionParser.add_option("--enable-id-stripping", type="inkbool",
             action="store", dest="strip_ids", default=False,
             help="remove all un-referenced ID attributes")
+        self.OptionParser.add_option("--shorten-ids", type="inkbool",
+            action="store", dest="shorten_ids", default=False,
+            help="shorten all ID attributes to the least number of letters possible")
         self.OptionParser.add_option("--embed-rasters", type="inkbool",
             action="store", dest="embed_rasters", default=True,
             help="won't embed rasters as base64-encoded data")
         self.OptionParser.add_option("--keep-editor-data", type="inkbool",
             action="store", dest="keep_editor_data", default=False,
             help="won't remove Inkscape, Sodipodi or Adobe Illustrator elements and attributes")
+        self.OptionParser.add_option("--remove-metadata", type="inkbool",
+            action="store", dest="remove_metadata", default=False,
+            help="remove <metadata> elements (which may contain license metadata etc.)")
         self.OptionParser.add_option("--strip-xml-prolog", type="inkbool",
             action="store", dest="strip_xml_prolog", default=False,
             help="won't output the <?xml ?> prolog")
@@ -40,7 +46,12 @@ class ScourInkscape (inkex.Effect):
         self.OptionParser.add_option("--enable-viewboxing", type="inkbool",
             action="store", dest="enable_viewboxing", default=False,
             help="changes document width/height to 100%/100% and creates viewbox coordinates")
-
+        self.OptionParser.add_option("--enable-comment-stripping", type="inkbool",
+            action="store", dest="strip_comments", default=False,
+            help="remove all <!-- --> comments")
+        self.OptionParser.add_option("--renderer-workaround", type="inkbool",
+            action="store", dest="renderer_workaround", default=False,
+            help="work around various renderer bugs (currently only librsvg)")
 
     def effect(self):   
         input = file(sys.argv[12], "r")
diff --git a/scour.inx b/scour.inx
index 63050e8..4254882 100644
--- a/scour.inx
+++ b/scour.inx
@@ -7,16 +7,20 @@
     <dependency type="executable" location="extensions">yocto_css.py</dependency>
     <param name="tab" type="notebook">
         <page name="Options" _gui-text="Options">            
-            <param name="simplify-colors"  type="boolean" _gui-text="Simplify colors">true</param>
-            <param name="style-to-xml"  type="boolean" _gui-text="Style to xml">true</param>
+            <param name="simplify-colors"  type="boolean" _gui-text="Shorten color values">true</param>
+            <param name="style-to-xml"  type="boolean" _gui-text="Convert CSS attributes to XML attributes">true</param>
             <param name="group-collapsing"  type="boolean" _gui-text="Group collapsing">true</param>
-            <param name="enable-id-stripping"  type="boolean" _gui-text="Enable id stripping">false</param>
+            <param name="enable-id-stripping"  type="boolean" _gui-text="Remove unused ID names for elements">false</param>
+            <param name="shorten-ids"  type="boolean" _gui-text="Shorten IDs">false</param>
             <param name="embed-rasters"  type="boolean" _gui-text="Embed rasters">true</param>
             <param name="keep-editor-data"  type="boolean" _gui-text="Keep editor data">false</param>
+            <param name="remove-metadata"  type="boolean" _gui-text="Remove metadata">false</param>
+            <param name="enable-comment-stripping"  type="boolean" _gui-text="Remove comments">false</param>
+            <param name="renderer-workaround"  type="boolean" _gui-text="Work around renderer bugs">false</param>
             <param name="enable-viewboxing" type="boolean" _gui-text="Enable viewboxing">false</param>
-            <param name="strip-xml-prolog"  type="boolean" _gui-text="Strip xml prolog">false</param>
-            <param name="set-precision"  type="int" _gui-text="Set precision">5</param>
-      	    <param name="indent" type="enum" _gui-text="Indent">
+            <param name="strip-xml-prolog"  type="boolean" _gui-text="Remove the <?xml?> declaration">false</param>
+            <param name="set-precision"  type="int" _gui-text="Number of significant digits for coords">5</param>
+      	    <param name="indent" type="enum" _gui-text="XML indentation (pretty-printing)">
                 <_item value="space">Space</_item>
                 <_item value="tab">Tab</_item>
                 <_item value="none">None</_item>
@@ -24,16 +28,19 @@
         </page>
         <page name="Help" _gui-text="Help">
             <_param name="instructions" type="description" xml:space="preserve">This extension optimizes the SVG file according to the following options:
-    * Simplify colors: convert all colors to #RRGGBB format.
-    * Style to xml: convert styles into XML attributes.
-    * Group collapsing: collapse group elements.
-    * Enable id stripping: remove all un-referenced ID attributes.
-    * Embed rasters: embed rasters as base64-encoded data.
+    * Shorten color names: convert all colors to #RRGGBB or #RGB format.
+    * Convert CSS attributes to XML attributes: convert styles from <style> tags and inline style="" declarations into XML attributes.
+    * Group collapsing: removes useless <g> elements, promoting their contents up one level. Requires "Remove unused ID names for elements" to be set.
+    * Remove unused ID names for elements: remove all unreferenced ID attributes.
+    * Shorten IDs: reduce the length of all ID attributes, assigning the shortest to the most-referenced elements. For instance, #linearGradient5621, referenced 100 times, can become #a.
+    * Embed rasters: embed raster images as base64-encoded data URLs.
     * Keep editor data: don't remove Inkscape, Sodipodi or Adobe Illustrator elements and attributes.
-    * Enable viewboxing: size image to 100%/100% and introduce a viewBox
-    * Strip xml prolog: don't output the xml prolog.
-    * Set precision: set number of significant digits (default: 5).
-    * Indent: indentation of the output: none, space, tab (default: space).</_param>
+    * Remove metadata: remove &lt;metadata&gt; tags along with all the information in them, which may include license metadata, alternate versions for non-SVG-enabled browsers, etc.
+    * Remove comments: remove &lt;!-- --&gt; tags.
+    * Work around renderer bugs: emits slightly larger SVG data, but works around a bug in librsvg's renderer, which is used in Eye of GNOME and other various applications.
+    * Enable viewboxing: size image to 100%/100% and introduce a viewBox.
+    * Number of significant digits for coords: all coordinates are output with that number of significant digits. For example, if 3 is specified, the coordinate 3.5153 is output as 3.51 and the coordinate 471.55 is output as 472.
+    * XML indentation (pretty-printing): either None for no indentation, Space to use one space per nesting level, or Tab to use one tab per nesting level.</_param>
         </page>
     </param>        
     <output>
diff --git a/scour.py b/scour.py
index dad3db5..fa42d91 100755
--- a/scour.py
+++ b/scour.py
@@ -39,7 +39,6 @@
 # - investigate point-reducing algorithms
 # - parse transform attribute
 # - if a <g> has only one element in it, collapse the <g> (ensure transform, etc are carried down)
-# - option to remove metadata
 
 # necessary to get true division
 from __future__ import division
@@ -49,10 +48,8 @@ import sys
 import xml.dom.minidom
 import re
 import math
-import base64
-import urllib
 from svg_regex import svg_parser
-import gzip
+from svg_transform import svg_transform_parser
 import optparse
 from yocto_css import parseCssString
 
@@ -60,8 +57,7 @@ from yocto_css import parseCssString
 try:
 	from decimal import *
 except ImportError:
-	from fixedpoint import *
-	Decimal = FixedPoint	
+	print >>sys.stderr, "Scour requires Python 2.4."
 
 # Import Psyco if available
 try:
@@ -276,14 +272,14 @@ colors = {
 	}
 	
 def isSameSign(a,b): return (a <= 0 and b <= 0) or (a >= 0 and b >= 0)
-	
-coord = re.compile("\\-?\\d+\\.?\\d*")
-scinumber = re.compile("[\\-\\+]?(\\d*\\.?)?\\d+[eE][\\-\\+]?\\d+")
-number = re.compile("[\\-\\+]?(\\d*\\.?)?\\d+")
-sciExponent = re.compile("[eE]([\\-\\+]?\\d+)")
-unit = re.compile("(em|ex|px|pt|pc|cm|mm|in|\\%){1,1}$")
+
+scinumber = re.compile(r"[-+]?(\d*\.?)?\d+[eE][-+]?\d+")
+number = re.compile(r"[-+]?(\d*\.?)?\d+")
+sciExponent = re.compile(r"[eE]([-+]?\d+)")
+unit = re.compile("(em|ex|px|pt|pc|cm|mm|in|%){1,1}$")
 
 class Unit(object):
+	# Integer constants for units.
 	INVALID = -1
 	NONE = 0
 	PCT = 1
@@ -296,35 +292,48 @@ class Unit(object):
 	MM = 8
 	IN = 9
 	
+	# String to Unit. Basically, converts unit strings to their integer constants.
+	s2u = {
+		'': NONE,
+		'%': PCT,
+		'px': PX,
+		'pt': PT,
+		'pc': PC,
+		'em': EM,
+		'ex': EX,
+		'cm': CM,
+		'mm': MM,
+		'in': IN,
+	}
+	
+	# Unit to String. Basically, converts unit integer constants to their corresponding strings.
+	u2s = {
+		NONE: '',
+		PCT: '%',
+		PX: 'px',
+		PT: 'pt',
+		PC: 'pc',
+		EM: 'em',
+		EX: 'ex',
+		CM: 'cm',
+		MM: 'mm',
+		IN: 'in',
+	}
+	
 #	@staticmethod
-	def get(str):
-		# GZ: shadowing builtins like 'str' is generally bad form
-		# GZ: encoding stuff like this in a dict makes for nicer code
-		if str == None or str == '': return Unit.NONE
-		elif str == '%': return Unit.PCT
-		elif str == 'px': return Unit.PX
-		elif str == 'pt': return Unit.PT
-		elif str == 'pc': return Unit.PC
-		elif str == 'em': return Unit.EM
-		elif str == 'ex': return Unit.EX
-		elif str == 'cm': return Unit.CM
-		elif str == 'mm': return Unit.MM
-		elif str == 'in': return Unit.IN
-		return Unit.INVALID
+	def get(unitstr):
+		if unitstr is None: return Unit.NONE
+		try:
+			return Unit.s2u[unitstr]
+		except KeyError:
+			return Unit.INVALID
 
 #	@staticmethod
-	def str(u):
-		if u == Unit.NONE: return ''
-		elif u == Unit.PCT: return '%'
-		elif u == Unit.PX: return 'px'
-		elif u == Unit.PT: return 'pt'
-		elif u == Unit.PC: return 'pc'
-		elif u == Unit.EM: return 'em'
-		elif u == Unit.EX: return 'ex'
-		elif u == Unit.CM: return 'cm'
-		elif u == Unit.MM: return 'mm'
-		elif u == Unit.IN: return 'in'
-		return 'INVALID'
+	def str(unitint):
+		try:
+			return Unit.u2s[unitint]
+		except KeyError:
+			return 'INVALID'
 		
 	get = staticmethod(get)
 	str = staticmethod(str)
@@ -371,26 +380,6 @@ class SVGLength(object):
 				self.value = 0 
 				self.units = Unit.INVALID
 
-# returns the length of a property
-# TODO: eventually use the above class once it is complete
-def getSVGLength(value):
-	try:
-		v = float(value)
-	except ValueError:
-		coordMatch = coord.match(value)
-		if coordMatch != None:
-			unitMatch = unit.search(value, coordMatch.start(0))
-		v = value
-	return v
-
-def findElementById(node, id):
-	if node == None or node.nodeType != 1: return None
-	if node.getAttribute('id') == id: return node
-	for child in node.childNodes :
-		e = findElementById(child,id)
-		if e != None: return e
-	return None
-
 def findElementsWithId(node, elems=None):
 	"""
 	Returns all elements with id attributes
@@ -499,7 +488,11 @@ numPathSegmentsReduced = 0
 numCurvesStraightened = 0
 numBytesSavedInPathData = 0
 numBytesSavedInColors = 0
+numBytesSavedInIDs = 0
+numBytesSavedInLengths = 0
+numBytesSavedInTransforms = 0
 numPointsRemovedFromPolygon = 0
+numCommentBytes = 0
 
 def removeUnusedDefs(doc, defElem, elemsToRemove=None):
 	if elemsToRemove is None:
@@ -539,7 +532,7 @@ def removeUnreferencedElements(doc):
 
 	for id in identifiedElements:
 		if not id in referencedIDs:
-			goner = findElementById(doc.documentElement, id)
+			goner = identifiedElements[id]
 			if goner != None and goner.parentNode != None and goner.nodeName in removeTags:
 				goner.parentNode.removeChild(goner)
 				num += 1
@@ -556,6 +549,125 @@ def removeUnreferencedElements(doc):
 			num += 1
 	return num
 
+def shortenIDs(doc):
+	"""
+	Shortens ID names used in the document. ID names referenced the most often are assigned the
+	shortest ID names.
+	
+	Returns the number of bytes saved by shortening ID names in the document.
+	"""
+	num = 0
+
+	identifiedElements = findElementsWithId(doc.documentElement)
+	referencedIDs = findReferencedElements(doc.documentElement)
+
+	# Make idList (list of idnames) sorted by reference count
+	# descending, so the highest reference count is first.
+	# First check that there's actually a defining element for the current ID name.
+	# (Cyn: I've seen documents with #id references but no element with that ID!)
+	idList = [(referencedIDs[rid][0], rid)  for rid in referencedIDs  if rid in identifiedElements]
+	idList.sort(reverse=True)
+	idList = [rid for count, rid in idList]
+	
+	curIdNum = 1
+	
+	for rid in idList:
+		curId = intToID(curIdNum)
+		# First make sure that *this* element isn't already using
+		# the ID name we want to give it.
+		if curId != rid:
+			# Then, skip ahead if the new ID is already in identifiedElement.
+			while curId in identifiedElements:
+				curIdNum += 1
+				curId = intToID(curIdNum)
+			# Then go rename it.
+			num += renameID(doc, rid, curId, identifiedElements, referencedIDs)
+		curIdNum += 1
+	
+	return num
+
+def intToID(idnum):
+	"""
+	Returns the ID name for the given ID number, spreadsheet-style, i.e. from a to z,
+	then from aa to az, ba to bz, etc., until zz.
+	"""
+	rid = ''
+	
+	while idnum > 0:
+		idnum -= 1
+		rid = chr((idnum % 26) + ord('a')) + rid
+		idnum = int(idnum / 26)
+	
+	return rid
+
+def renameID(doc, idFrom, idTo, identifiedElements, referencedIDs):
+	"""
+	Changes the ID name from idFrom to idTo, on the declaring element
+	as well as all references in the document doc.
+	
+	Updates identifiedElements and referencedIDs.
+	Does not handle the case where idTo is already the ID name
+	of another element in doc.
+	
+	Returns the number of bytes saved by this replacement.
+	"""
+	
+	num = 0
+	
+	definingNode = identifiedElements[idFrom]
+	definingNode.setAttribute("id", idTo)
+	del identifiedElements[idFrom]
+	identifiedElements[idTo] = definingNode
+	
+	referringNodes = referencedIDs[idFrom]
+	
+	# Look for the idFrom ID name in each of the referencing elements,
+	# exactly like findReferencedElements would. 
+	# Cyn: Duplicated processing!
+
+	for node in referringNodes[1]:
+		# if this node is a style element, parse its text into CSS
+		if node.nodeName == 'style' and node.namespaceURI == NS['SVG']:
+			# node.firstChild will be either a CDATA or a Text node
+			if node.firstChild != None:
+				oldValue = node.firstChild.nodeValue
+				# not going to reparse the whole thing
+				newValue = oldValue.replace('url(#' + idFrom + ')', 'url(#' + idTo + ')')
+				newValue = newValue.replace("url(#'" + idFrom + "')", 'url(#' + idTo + ')')
+				newValue = newValue.replace('url(#"' + idFrom + '")', 'url(#' + idTo + ')')
+				node.firstChild.nodeValue = newValue
+				num += len(oldValue) - len(newValue)
+	
+		# if xlink:href is set to #idFrom, then change the id
+		href = node.getAttributeNS(NS['XLINK'],'href')
+		if href == '#' + idFrom:
+			node.setAttributeNS(NS['XLINK'],'href', '#' + idTo)
+			num += len(idFrom) - len(idTo)
+
+		# if the style has url(#idFrom), then change the id
+		styles = node.getAttribute('style')
+		if styles != '':
+			newValue = styles.replace('url(#' + idFrom + ')', 'url(#' + idTo + ')')
+			newValue = newValue.replace("url(#'" + idFrom + "')", 'url(#' + idTo + ')')
+			newValue = newValue.replace('url(#"' + idFrom + '")', 'url(#' + idTo + ')')
+			node.setAttribute('style', newValue)
+			num += len(styles) - len(newValue)
+			
+		# now try the fill, stroke, filter attributes
+		for attr in referencingProps:
+			oldValue = node.getAttribute(attr)
+			if oldValue != '':
+				newValue = oldValue.replace('url(#' + idFrom + ')', 'url(#' + idTo + ')')
+				newValue = newValue.replace("url(#'" + idFrom + "')", 'url(#' + idTo + ')')
+				newValue = newValue.replace('url(#"' + idFrom + '")', 'url(#' + idTo + ')')
+				node.setAttribute(attr, newValue)
+				num += len(oldValue) - len(newValue)
+				
+	del referencedIDs[idFrom]
+	referencedIDs[idTo] = referringNodes
+	
+	return num
+
 def removeUnreferencedIDs(referencedIDs, identifiedElements):
 	"""
 	Removes the unreferenced ID attributes.
@@ -580,7 +692,7 @@ def removeNamespacedAttributes(node, namespaces):
 		# remove all namespace'd attributes from this element
 		attrList = node.attributes
 		attrsToRemove = []
-		for attrNum in range(attrList.length):
+		for attrNum in xrange(attrList.length):
 			attr = attrList.item(attrNum)
 			if attr != None and attr.namespaceURI in namespaces:
 				attrsToRemove.append(attr.nodeName)
@@ -613,6 +725,19 @@ def removeNamespacedElements(node, namespaces):
 		for child in node.childNodes:
 			num += removeNamespacedElements(child, namespaces)
 	return num
+	
+def removeMetadataElements(doc):
+	global numElemsRemoved
+	num = 0
+	# clone the list, as the tag list is live from the DOM
+	elementsToRemove = [element for element in doc.documentElement.getElementsByTagName('metadata')]
+	
+	for element in elementsToRemove:
+		element.parentNode.removeChild(element)
+		num += 1
+		numElemsRemoved += 1
+	
+	return num
 
 def removeNestedGroups(node):
 	""" 
@@ -676,7 +801,7 @@ def moveCommonAttributesToParentGroup(elem):
 	# its fill attribute is not what we want to look at, we should look for the first
 	# non-animate/set element
 	attrList = childElements[0].attributes
-	for num in range(attrList.length):
+	for num in xrange(attrList.length):
 		attr = attrList.item(num)
 		# this is most of the inheritable properties from http://www.w3.org/TR/SVG11/propidx.html
 		# and http://www.w3.org/TR/SVGTiny12/attributeTable.html
@@ -695,7 +820,7 @@ def moveCommonAttributesToParentGroup(elem):
 			commonAttrs[attr.nodeName] = attr.nodeValue
 	
 	# for each subsequent child element
-	for childNum in range(len(childElements)):
+	for childNum in xrange(len(childElements)):
 		# skip first child
 		if childNum == 0: 
 			continue
@@ -745,7 +870,7 @@ def removeUnusedAttributesOnParent(elem):
 	# get all attribute values on this parent
 	attrList = elem.attributes
 	unusedAttrs = {}
-	for num in range(attrList.length):
+	for num in xrange(attrList.length):
 		attr = attrList.item(num)
 		if attr.nodeName in ['clip-rule',
 					'display-align', 
@@ -761,7 +886,7 @@ def removeUnusedAttributesOnParent(elem):
 			unusedAttrs[attr.nodeName] = attr.nodeValue
 	
 	# for each child, if at least one child inherits the parent's attribute, then remove
-	for childNum in range(len(childElements)):
+	for childNum in xrange(len(childElements)):
 		child = childElements[childNum]
 		inheritedAttrs = []
 		for name in unusedAttrs.keys():
@@ -819,12 +944,16 @@ def collapseSinglyReferencedGradients(doc):
 	global numElemsRemoved
 	num = 0
 	
+	identifiedElements = findElementsWithId(doc.documentElement)
+	
 	# make sure to reset the ref'ed ids for when we are running this in testscour
 	for rid,nodeCount in findReferencedElements(doc.documentElement).iteritems():
 		count = nodeCount[0]
 		nodes = nodeCount[1]
-		if count == 1:
-			elem = findElementById(doc.documentElement,rid)
+		# Make sure that there's actually a defining element for the current ID name.
+		# (Cyn: I've seen documents with #id references but no element with that ID!)
+		if count == 1 and rid in identifiedElements:
+			elem = identifiedElements[rid]
 			if elem != None and elem.nodeType == 1 and elem.nodeName in ['linearGradient', 'radialGradient'] \
 					and elem.namespaceURI == NS['SVG']:
 				# found a gradient that is referenced by only 1 other element
@@ -905,7 +1034,7 @@ def removeDuplicateGradients(doc):
 
 				# now compare stops
 				stopsNotEqual = False
-				for i in range(stops.length):
+				for i in xrange(stops.length):
 					if stopsNotEqual: break
 					stop = stops.item(i)
 					ostop = ostops.item(i)
@@ -1045,8 +1174,8 @@ def repairStyle(node, options):
 
 		# stroke-width: 0
 		if styleMap.has_key('stroke-width') :
-			strokeWidth = getSVGLength(styleMap['stroke-width']) 
-			if strokeWidth == 0.0 :
+			strokeWidth = SVGLength(styleMap['stroke-width']) 
+			if strokeWidth.value == 0.0 :
 				for uselessStrokeStyle in [ 'stroke', 'stroke-linejoin', 'stroke-linecap', 
 							'stroke-dasharray', 'stroke-dashoffset', 'stroke-opacity' ] :
 					if styleMap.has_key(uselessStrokeStyle): 
@@ -1201,8 +1330,8 @@ def removeDefaultAttributeValues(node, options):
 	
 	return num
 
-rgb = re.compile("\\s*rgb\\(\\s*(\\d+)\\s*\\,\\s*(\\d+)\\s*\\,\\s*(\\d+)\\s*\\)\\s*")
-rgbp = re.compile("\\s*rgb\\(\\s*(\\d*\\.?\\d+)\\%\\s*\\,\\s*(\\d*\\.?\\d+)\\%\\s*\\,\\s*(\\d*\\.?\\d+)\\%\\s*\\)\\s*")
+rgb = re.compile(r"\s*rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\s*")
+rgbp = re.compile(r"\s*rgb\(\s*(\d*\.?\d+)%\s*,\s*(\d*\.?\d+)%\s*,\s*(\d*\.?\d+)%\s*\)\s*")
 def convertColor(value):
 	"""
 		Converts the input color string and returns a #RRGGBB (or #RGB if possible) string
@@ -1217,21 +1346,19 @@ def convertColor(value):
 		r = int(float(rgbpMatch.group(1)) * 255.0 / 100.0)
 		g = int(float(rgbpMatch.group(2)) * 255.0 / 100.0)
 		b = int(float(rgbpMatch.group(3)) * 255.0 / 100.0)
-		s  = 'rgb(%d,%d,%d)' % (r,g,b)
+		s  = '#%02x%02x%02x' % (r, g, b)
+	else:
+		rgbMatch = rgb.match(s)
+		if rgbMatch != None :
+			r = int( rgbMatch.group(1) )
+			g = int( rgbMatch.group(2) )
+			b = int( rgbMatch.group(3) )
+			s = '#%02x%02x%02x' % (r, g, b)
 	
-	rgbMatch = rgb.match(s)
-	if rgbMatch != None :
-		r = hex( int( rgbMatch.group(1) ) )[2:].upper()
-		g = hex( int( rgbMatch.group(2) ) )[2:].upper()
-		b = hex( int( rgbMatch.group(3) ) )[2:].upper()
-		if len(r) == 1: r='0'+r
-		if len(g) == 1: g='0'+g
-		if len(b) == 1: b='0'+b
-		s = '#'+r+g+b
-	
-	if s[0] == '#' and len(s)==7 and s[1]==s[2] and s[3]==s[4] and s[5]==s[6]:
-		s = s.upper()
-		s = '#'+s[1]+s[3]+s[5]
+	if s[0] == '#':
+		s = s.lower()
+		if len(s)==7 and s[1]==s[2] and s[3]==s[4] and s[5]==s[6]:
+			s = '#'+s[1]+s[3]+s[5]
 
 	return s
 	
@@ -1273,7 +1400,7 @@ def convertColors(element) :
 # TODO: go over what this method does and see if there is a way to optimize it
 # TODO: go over the performance of this method and see if I can save memory/speed by
 #       reusing data structures, etc
-def cleanPath(element) :
+def cleanPath(element, options) :
 	"""
 		Cleans the path string (d attribute) of the element 
 	"""
@@ -1283,292 +1410,155 @@ def cleanPath(element) :
 	
 	# this gets the parser object from svg_regex.py
 	oldPathStr = element.getAttribute('d')
-	pathObj = svg_parser.parse(oldPathStr)
-	
-	# however, this parser object has some ugliness in it (lists of tuples of tuples of 
-	# numbers and booleans).  we just need a list of (cmd,[numbers]):
-	path = []
-	for (cmd,dataset) in pathObj:
-		if cmd in ['M','m','L','l','T','t']:
-			# one or more tuples, each containing two numbers
-			nums = []
-			for t in dataset:
-				# convert to a Decimal
-				nums.append(Decimal(str(t[0])) * Decimal(1))
-				nums.append(Decimal(str(t[1])) * Decimal(1))
-					
-			# only create this segment if it is not empty
-			if nums:
-				path.append( (cmd, nums) )
-			
-		elif cmd in ['V','v','H','h']:
-			# one or more numbers
-			nums = []
-			for n in dataset:
-				nums.append(Decimal(str(n)))
-			if nums:
-				path.append( (cmd, nums) )
-			
-		elif cmd in ['C','c']:
-			# one or more tuples, each containing three tuples of two numbers each
-			nums = []
-			for t in dataset:
-				for pair in t:
-					nums.append(Decimal(str(pair[0])) * Decimal(1))
-					nums.append(Decimal(str(pair[1])) * Decimal(1))
-			path.append( (cmd, nums) )
-			
-		elif cmd in ['S','s','Q','q']:
-			# one or more tuples, each containing two tuples of two numbers each
-			nums = []
-			for t in dataset:
-				for pair in t:
-					nums.append(Decimal(str(pair[0])) * Decimal(1))
-					nums.append(Decimal(str(pair[1])) * Decimal(1))
-			path.append( (cmd, nums) )
-			
-		elif cmd in ['A','a']:
-			# one or more tuples, each containing a tuple of two numbers, a number, a boolean,
-			# another boolean, and a tuple of two numbers
-			nums = []
-			for t in dataset:
-				nums.append( Decimal(str(t[0][0])) * Decimal(1) )
-				nums.append( Decimal(str(t[0][1])) * Decimal(1) )
-				nums.append( Decimal(str(t[1])) * Decimal(1))
-				
-				if t[2]: nums.append( Decimal(1) )
-				else: nums.append( Decimal(0) )
+	path = svg_parser.parse(oldPathStr)
 
-				if t[3]: nums.append( Decimal(1) )
-				else: nums.append( Decimal(0) )
-				
-				nums.append( Decimal(str(t[4][0])) * Decimal(1) )
-				nums.append( Decimal(str(t[4][1])) * Decimal(1) )
-			path.append( (cmd, nums) )
-		
-		elif cmd in ['Z','z']:
-			path.append( (cmd, []) )
-
-	# calculate the starting x,y coord for the second path command
-	if len(path[0][1]) == 2:
-		(x,y) = path[0][1]
-	else:
-		# we have a move and then 1 or more coords for lines
-		N = len(path[0][1])
-		if path[0][0] == 'M':
-			# take the last pair of coordinates for the starting point
-			x = path[0][1][N-2]
-			y = path[0][1][N-1]
-		else: # relative move, accumulate coordinates for the starting point
-			(x,y) = path[0][1][0],path[0][1][1]
-			n = 2
-			while n < N:
-				x += path[0][1][n]
-				y += path[0][1][n+1]
-				n += 2
+	# The first command must be a moveto, and whether it's relative (m)
+	# or absolute (M), the first set of coordinates *is* absolute. So
+	# the first iteration of the loop below will get x,y and startx,starty.
 	
-	# now we have the starting point at x,y so let's save it 
-	(startx,starty) = (x,y)
-	
-	# convert absolute coordinates into relative ones (start with the second subcommand
-	# and leave the first M as absolute)
-	newPath = [path[0]]
-	for (cmd,data) in path[1:]:
+	# convert absolute coordinates into relative ones.
+	# Reuse the data structure 'path', since we're not adding or removing subcommands.
+	# Also reuse the coordinate lists since we're not adding or removing any.
+	for pathIndex in xrange(0, len(path)):
+		cmd, data = path[pathIndex] # Changes to cmd don't get through to the data structure
 		i = 0
-		newCmd = cmd
-		newData = data
 		# adjust abs to rel
 		# only the A command has some values that we don't want to adjust (radii, rotation, flags)
 		if cmd == 'A':
-			newCmd = 'a'
-			newData = []
-			while i < len(data):
-				newData.append(data[i])
-				newData.append(data[i+1])
-				newData.append(data[i+2])
-				newData.append(data[i+3])
-				newData.append(data[i+4])
-				newData.append(data[i+5]-x)
-				newData.append(data[i+6]-y)
-				x = data[i+5]
-				y = data[i+6]
-				i += 7
-		elif cmd == 'a':
-			while i < len(data):
+			for i in xrange(i, len(data), 7):
+				data[i+5] -= x
+				data[i+6] -= y
 				x += data[i+5]
 				y += data[i+6]
-				i += 7			
+			path[pathIndex] = ('a', data)
+		elif cmd == 'a':
+			x += sum(data[5::7])
+			y += sum(data[6::7])
 		elif cmd == 'H':
-			newCmd = 'h'
-			newData = []
-			while i < len(data):
-				newData.append(data[i]-x)
-				x = data[i]
-				i += 1
+			for i in xrange(i, len(data)):
+				data[i] -= x
+				x += data[i]
+			path[pathIndex] = ('h', data)
 		elif cmd == 'h':
-			while i < len(data):
-				x += data[i]
-				i += 1
+			x += sum(data)
 		elif cmd == 'V':
-			newCmd = 'v'
-			newData = []
-			while i < len(data):
-				newData.append(data[i] - y)
-				y = data[i]
-				i += 1
-		elif cmd == 'v':
-			while i < len(data):
+			for i in xrange(i, len(data)):
+				data[i] -= y
 				y += data[i]
-				i += 1
-		elif cmd in ['M']:
-			newCmd = cmd.lower()
-			newData = []
-			startx = data[0]
-			starty = data[1]
-			while i < len(data):
-				newData.append( data[i] - x )
-				newData.append( data[i+1] - y )
-				x = data[i]
-				y = data[i+1]
-				i += 2
+			path[pathIndex] = ('v', data)
+		elif cmd == 'v':
+			y += sum(data)
+		elif cmd == 'M':
+			startx, starty = data[0], data[1]
+			# If this is a path starter, don't convert its first
+			# coordinate to relative; that would just make it (0, 0)
+			if pathIndex != 0:
+				data[0] -= x
+				data[1] -= y
+			
+			x, y = startx, starty
+			i = 2
+			for i in xrange(i, len(data), 2):
+				data[i] -= x
+				data[i+1] -= y
+				x += data[i]
+				y += data[i+1]
+			path[pathIndex] = ('m', data)
 		elif cmd in ['L','T']:
-			newCmd = cmd.lower()
-			newData = []
-			while i < len(data):
-				newData.append( data[i] - x )
-				newData.append( data[i+1] - y )
-				x = data[i]
-				y = data[i+1]
-				i += 2
+			for i in xrange(i, len(data), 2):
+				data[i] -= x
+				data[i+1] -= y
+				x += data[i]
+				y += data[i+1]
+			path[pathIndex] = (cmd.lower(), data)
 		elif cmd in ['m']:
-			startx += data[0]
-			starty += data[1]
-			while i < len(data):
+			if pathIndex == 0:
+				# START OF PATH - this is an absolute moveto
+				# followed by relative linetos
+				startx, starty = data[0], data[1]
+				x, y = startx, starty
+				i = 2
+			else:
+				startx = x + data[0]
+				starty = y + data[1]
+			for i in xrange(i, len(data), 2):
 				x += data[i]
 				y += data[i+1]
-				i += 2
 		elif cmd in ['l','t']:
-			while i < len(data):
-				x += data[i]
-				y += data[i+1]
-				i += 2
+			x += sum(data[0::2])
+			y += sum(data[1::2])
 		elif cmd in ['S','Q']:
-			newCmd = cmd.lower()
-			newData = []
-			while i < len(data):
-				newData.append( data[i] - x )
-				newData.append( data[i+1] - y )
-				newData.append( data[i+2] - x )
-				newData.append( data[i+3] - y )
-				x = data[i+2]
-				y = data[i+3]
-				i += 4
-		elif cmd in ['s','q']:
-			while i < len(data):
+			for i in xrange(i, len(data), 4):
+				data[i] -= x
+				data[i+1] -= y
+				data[i+2] -= x
+				data[i+3] -= y
 				x += data[i+2]
 				y += data[i+3]
-				i += 4
+			path[pathIndex] = (cmd.lower(), data)
+		elif cmd in ['s','q']:
+			x += sum(data[2::4])
+			y += sum(data[3::4])
 		elif cmd == 'C':
-			newCmd = 'c'
-			newData = []
-			while i < len(data):
-				newData.append( data[i] - x )
-				newData.append( data[i+1] - y )
-				newData.append( data[i+2] - x )
-				newData.append( data[i+3] - y )
-				newData.append( data[i+4] - x )
-				newData.append( data[i+5] - y )
-				x = data[i+4]
-				y = data[i+5]
-				i += 6
-		elif cmd == 'c':
-			while i < len(data):
+			for i in xrange(i, len(data), 6):
+				data[i] -= x
+				data[i+1] -= y
+				data[i+2] -= x
+				data[i+3] -= y
+				data[i+4] -= x
+				data[i+5] -= y
 				x += data[i+4]
 				y += data[i+5]
-				i += 6
+			path[pathIndex] = ('c', data)
+		elif cmd == 'c':
+			x += sum(data[4::6])
+			y += sum(data[5::6])
 		elif cmd in ['z','Z']:
-			x = startx
-			y = starty
-			newCmd = 'z'
-		newPath.append( (newCmd, newData) )
-	path = newPath
+			x, y = startx, starty
+			path[pathIndex] = ('z', data)
 	
 	# remove empty segments
-	newPath = [path[0]]
-	for (cmd,data) in path[1:]:
+	# Reuse the data structure 'path' and the coordinate lists, even if we're
+	# deleting items, because these deletions are relatively cheap.
+	for pathIndex in xrange(0, len(path)):
+		cmd, data = path[pathIndex]
+		i = 0
 		if cmd in ['m','l','t']:
-			newData = []
-			i = 0
+			if cmd == 'm': i = 2
 			while i < len(data):
-				if data[i] != 0 or data[i+1] != 0:
-					newData.append(data[i])
-					newData.append(data[i+1])
-				else:
+				if data[i] == data[i+1] == 0:
+					del data[i:i+2]
 					numPathSegmentsReduced += 1
-				i += 2
-			if newData:
-				newPath.append( (cmd,newData) )
+				else:
+					i += 2
 		elif cmd == 'c':
-			newData = []
-			i = 0
 			while i < len(data):
-				if data[i+4] != 0 or data[i+5] != 0:
-					newData.append(data[i])
-					newData.append(data[i+1])
-					newData.append(data[i+2])
-					newData.append(data[i+3])
-					newData.append(data[i+4])
-					newData.append(data[i+5])
-				else:
+				if data[i+4] == data[i+5] == 0:
+					del data[i:i+6]
 					numPathSegmentsReduced += 1
-				i += 6
-			if newData:
-				newPath.append( (cmd,newData) )
+				else:
+					i += 6
 		elif cmd == 'a':
-			newData = []
-			i = 0
 			while i < len(data):
-				if data[i+5] != 0 or data[i+6] != 0:
-					newData.append(data[i])
-					newData.append(data[i+1])
-					newData.append(data[i+2])
-					newData.append(data[i+3])
-					newData.append(data[i+4])
-					newData.append(data[i+5])
-					newData.append(data[i+6])
-				else:
+				if data[i+5] == data[i+6] == 0:
+					del data[i:i+7]
 					numPathSegmentsReduced += 1
-				i += 7
-			if newData:
-				newPath.append( (cmd,newData) )
+				else:
+					i += 7
 		elif cmd == 'q':
-			newData = []
-			i = 0
 			while i < len(data):
-				if data[i+2] != 0 or data[i+3] != 0:
-					newData.append(data[i])
-					newData.append(data[i+1])
-					newData.append(data[i+2])
-					newData.append(data[i+3])
-				else:
+				if data[i+2] == data[i+3] == 0:
+					del data[i:i+4]
 					numPathSegmentsReduced += 1
-				i += 4
-			if newData:
-				newPath.append( (cmd,newData) )
+				else:
+					i += 4
 		elif cmd in ['h','v']:
-			newData = []
-			i = 0
-			while i < len(data):
-				if data[i] != 0:
-					newData.append(data[i])
-				else:
-					numPathSegmentsReduced += 1
-				i += 1
-			if newData:
-				newPath.append( (cmd,newData) )
-		else:
-			newPath.append( (cmd,data) )
-	path = newPath
+			oldLen = len(data)
+			path[pathIndex] = (cmd, [coord for coord in data if coord != 0])
+			numPathSegmentsReduced += len(path[pathIndex][1]) - oldLen
+	
+	# fixup: Delete subcommands having no coordinates.
+	path = [elem for elem in path if len(elem[1]) > 0 or elem[0] == 'z']
 	
 	# convert straight curves into lines
 	newPath = [path[0]]
@@ -1605,12 +1595,7 @@ def cleanPath(element) :
 					newPath.append( ('l', [dx,dy]) )
 					numCurvesStraightened += 1
 				else:
-					newData.append(data[i])
-					newData.append(data[i+1])
-					newData.append(data[i+2])
-					newData.append(data[i+3])
-					newData.append(data[i+4])
-					newData.append(data[i+5])
+					newData.extend(data[i:i+6])
 					
 				i += 6
 		if newData or cmd == 'z' or cmd == 'Z':
@@ -1620,8 +1605,8 @@ def cleanPath(element) :
 	# collapse all consecutive commands of the same type into one command
 	prevCmd = ''
 	prevData = []
-	newPath = [path[0]]
-	for (cmd,data) in path[1:]:
+	newPath = []
+	for (cmd,data) in path:
 		# flush the previous command if it is not the same type as the current command
 		if prevCmd != '':
 			if cmd != prevCmd or cmd == 'm':
@@ -1629,11 +1614,11 @@ def cleanPath(element) :
 				prevCmd = ''
 				prevData = []
 		
-		# if the previous and current commands are the same type, collapse
+		# if the previous and current commands are the same type,
+		# or the previous command is moveto and the current is lineto, collapse,
 		# but only if they are not move commands (since move can contain implicit lineto commands)
-		if cmd == prevCmd and cmd != 'm':
-			for coord in data:
-				prevData.append(coord)
+		if (cmd == prevCmd or (cmd == 'l' and prevCmd == 'm')) and cmd != 'm':
+			prevData.extend(data)
 		
 		# save last command and data
 		else:
@@ -1645,9 +1630,9 @@ def cleanPath(element) :
 	path = newPath
 
 	# convert to shorthand path segments where possible
-	newPath = [path[0]]
-	for (cmd,data) in path[1:]:
-		# convert line segments into h,v where possible	
+	newPath = []
+	for (cmd,data) in path:
+		# convert line segments into h,v where possible
 		if cmd == 'l':
 			i = 0
 			lineTuples = []
@@ -1669,11 +1654,38 @@ def cleanPath(element) :
 					newPath.append( ('h', [data[i]]) )
 					numPathSegmentsReduced += 1
 				else:
-					lineTuples.append(data[i])
-					lineTuples.append(data[i+1])
+					lineTuples.extend(data[i:i+2])
 				i += 2
 			if lineTuples:
 				newPath.append( ('l', lineTuples) )
+		# also handle implied relative linetos
+		elif cmd == 'm':
+			i = 2
+			lineTuples = [data[0], data[1]]
+			while i < len(data):
+				if data[i] == 0:
+					# vertical
+					if lineTuples:
+						# flush the existing m/l command
+						newPath.append( (cmd, lineTuples) )
+						lineTuples = []
+						cmd = 'l' # dealing with linetos now
+					# append the v and then the remaining line coords						
+					newPath.append( ('v', [data[i+1]]) )
+					numPathSegmentsReduced += 1
+				elif data[i+1] == 0:
+					if lineTuples:
+						# flush the m/l command, then append the h and then the remaining line coords
+						newPath.append( (cmd, lineTuples) )
+						lineTuples = []
+						cmd = 'l' # dealing with linetos now
+					newPath.append( ('h', [data[i]]) )
+					numPathSegmentsReduced += 1
+				else:
+					lineTuples.extend(data[i:i+2])
+				i += 2
+			if lineTuples:
+				newPath.append( (cmd, lineTuples) )
 		# convert Bézier curve segments into s where possible	
 		elif cmd == 'c':
 			bez_ctl_pt = (0,0)
@@ -1732,23 +1744,20 @@ def cleanPath(element) :
 		
 	# for each h or v, collapse unnecessary coordinates that run in the same direction
 	# i.e. "h-100-100" becomes "h-200" but "h300-100" does not change
-	newPath = [path[0]]
-	for (cmd,data) in path[1:]:
+	# Reuse the data structure 'path', since we're not adding or removing subcommands.
+	# Also reuse the coordinate lists, even if we're deleting items, because these
+	# deletions are relatively cheap.
+	for pathIndex in xrange(1, len(path)):
+		cmd, data = path[pathIndex]
 		if cmd in ['h','v'] and len(data) > 1:
-			newData = []
-			prevCoord = data[0]
-			for coord in data[1:]:
-				if isSameSign(prevCoord, coord):
-					prevCoord += coord
+			coordIndex = 1
+			while coordIndex < len(data):
+				if isSameSign(data[coordIndex - 1], data[coordIndex]):
+					data[coordIndex - 1] += data[coordIndex]
+					del data[coordIndex]
 					numPathSegmentsReduced += 1
 				else:
-					newData.append(prevCoord)
-					prevCoord = coord
-			newData.append(prevCoord)
-			newPath.append( (cmd, newData) )
-		else:
-			newPath.append( (cmd, data) )
-	path = newPath
+					coordIndex += 1
 	
 	# it is possible that we have consecutive h, v, c, t commands now
 	# so again collapse all consecutive commands of the same type into one command
@@ -1765,8 +1774,7 @@ def cleanPath(element) :
 		
 		# if the previous and current commands are the same type, collapse
 		if cmd == prevCmd and cmd != 'm':
-			for coord in data:
-				prevData.append(coord)
+				prevData.extend(data)
 		
 		# save last command and data
 		else:
@@ -1777,7 +1785,7 @@ def cleanPath(element) :
 		newPath.append( (prevCmd, prevData) )
 	path = newPath
 	
-	newPathStr = serializePath(path)
+	newPathStr = serializePath(path, options)
 	numBytesSavedInPathData += ( len(oldPathStr) - len(newPathStr) )
 	element.setAttribute('d', newPathStr)
 
@@ -1799,7 +1807,7 @@ def parseListOfPoints(s):
 	
 	# also, if 100-100 is found, split it into two also
     #  <polygon points="100,-100,100-100,100-100-100,-100-100" />
-	for i in range(len(ws_nums)):
+	for i in xrange(len(ws_nums)):
 		negcoords = re.split("\\-", ws_nums[i]);
 		
 		# this string didn't have any negative coordinates
@@ -1807,7 +1815,7 @@ def parseListOfPoints(s):
 			nums.append(negcoords[0])
 		# we got negative coords
 		else:
-			for j in range(len(negcoords)):
+			for j in xrange(len(negcoords)):
 				# first number could be positive
 				if j == 0:
 					if negcoords[0] != '':
@@ -1838,7 +1846,7 @@ def parseListOfPoints(s):
 
 	return points
 	
-def cleanPolygon(elem):
+def cleanPolygon(elem, options):
 	"""
 		Remove unnecessary closing point of polygon points attribute
 	"""
@@ -1852,79 +1860,331 @@ def cleanPolygon(elem):
 		if startx == endx and starty == endy:
 			pts = pts[:-2]
 			numPointsRemovedFromPolygon += 1		
-	elem.setAttribute('points', scourCoordinates(pts,True))
+	elem.setAttribute('points', scourCoordinates(pts, options, True))
 
-def cleanPolyline(elem):
+def cleanPolyline(elem, options):
 	"""
 		Scour the polyline points attribute
 	"""
 	pts = parseListOfPoints(elem.getAttribute('points'))		
-	elem.setAttribute('points', scourCoordinates(pts,True))
-	
-def serializePath(pathObj):
+	elem.setAttribute('points', scourCoordinates(pts, options, True))
+
+def serializePath(pathObj, options):
 	"""
 		Reserializes the path data with some cleanups.
 	"""
-	pathStr = ""
-	for (cmd,data) in pathObj:
-		pathStr += cmd
-		# elliptical arc commands must have comma/wsp separating the coordinates
-		# this fixes an issue outlined in Fix https://bugs.launchpad.net/scour/+bug/412754
-		pathStr += scourCoordinates(data, (cmd == 'a'))
-	return pathStr
+	# elliptical arc commands must have comma/wsp separating the coordinates
+	# this fixes an issue outlined in Fix https://bugs.launchpad.net/scour/+bug/412754
+	return ''.join([cmd + scourCoordinates(data, options, (cmd == 'a'))  for cmd, data  in pathObj])
 
-def scourCoordinates(data, forceCommaWsp = False):
+def serializeTransform(transformObj):
+	"""
+		Reserializes the transform data with some cleanups.
+	"""
+	return ' '.join(
+		[command + '(' + ' '.join(
+			[scourUnitlessLength(number) for number in numbers]
+		) + ')'
+		for command, numbers in transformObj]
+	)
+
+def scourCoordinates(data, options, forceCommaWsp = False):
 	"""
 		Serializes coordinate data with some cleanups:
 			- removes all trailing zeros after the decimal
 			- integerize coordinates if possible
 			- removes extraneous whitespace
-			- adds commas between values in a subcommand if required (or if forceCommaWsp is True)
+			- adds spaces between values in a subcommand if required (or if forceCommaWsp is True)
 	"""
-	coordsStr = ""
 	if data != None:
+		newData = []
 		c = 0
+		previousCoord = ''
 		for coord in data:
+			scouredCoord = scourUnitlessLength(coord, needsRendererWorkaround=options.renderer_workaround)
+			# only need the comma if the current number starts with a digit
+			# (numbers can start with - without needing a comma before)
+			# or if forceCommaWsp is True
+			# or if this number starts with a dot and the previous number
+			#   had *no* dot or exponent (so we can go like -5.5.5 for -5.5,0.5
+			#   and 4e4.5 for 40000,0.5)
+			if c > 0 and (forceCommaWsp
+				or scouredCoord[0].isdigit()
+				or (scouredCoord[0] == '.' and not ('.' in previousCoord or 'e' in previousCoord))
+				):
+				newData.append( ' ' )
+				
 			# add the scoured coordinate to the path string
-			coordsStr += scourLength(coord)
-			
-			# only need the comma if the next number is non-negative or if forceCommaWsp is True
-			if c < len(data)-1 and (forceCommaWsp or Decimal(data[c+1]) >= 0):
-				coordsStr += ','
+			newData.append( scouredCoord )
+			previousCoord = scouredCoord
 			c += 1
-	return coordsStr
-
-def scourLength(str):
-	length = SVGLength(str)
-	coord = length.value
 	
+		# What we need to do to work around GNOME bugs 548494, 563933 and
+		# 620565, which are being fixed and unfixed in Ubuntu, is
+		# to make sure that a dot doesn't immediately follow a command
+		# (so 'h50' and 'h0.5' are allowed, but not 'h.5').
+		# Then, we need to add a space character after any coordinates
+		# having an 'e' (scientific notation), so as to have the exponent
+		# separate from the next number.
+		if options.renderer_workaround:
+			if len(newData) > 0:
+				for i in xrange(1, len(newData)):
+					if newData[i][0] == '-' and 'e' in newData[i - 1]:
+						newData[i] += ' '
+				return ''.join(newData)
+		else:
+			return ''.join(newData)
+	
+	return ''
+
+def scourLength(length):
+	"""
+	Scours a length. Accepts units.
+	"""
+	length = SVGLength(length)
+	
+	return scourUnitlessLength(length.value) + Unit.str(length.units)
+
+def scourUnitlessLength(length, needsRendererWorkaround=False): # length is of a numeric type
+	"""
+	Scours the numeric part of a length only. Does not accept units.
+	
+	This is faster than scourLength on elements guaranteed not to
+	contain units.
+	"""
 	# reduce to the proper number of digits
-	coord = Decimal(unicode(coord)) * Decimal(1)
+	if not isinstance(length, Decimal):
+		length = getcontext().create_decimal(str(length))
+	# if the value is an integer, it may still have .0[...] attached to it for some reason
+	# remove those
+	if int(length) == length:
+		length = getcontext().create_decimal(int(length))
 	
-	# integerize if we can
-	if int(coord) == coord: coord = Decimal(unicode(int(coord)))
-
-	# Decimal.trim() is available in Python 2.6+ to trim trailing zeros
-	try:
-		coord = coord.trim()
-	except AttributeError:
-		# trim it ourselves
-		s = unicode(coord)
-		dec = s.find('.')
-		if dec != -1:
-			while s[-1] == '0':
-				s = s[:-1]
-		coord = Decimal(s)
-
-		# Decimal.normalize() will uses scientific notation - if that
-		# string is smaller, then use it
-		normd = coord.normalize()
-		if len(unicode(normd)) < len(unicode(coord)):
-			coord = normd
+	# gather the non-scientific notation version of the coordinate.
+	# this may actually be in scientific notation if the value is
+	# sufficiently large or small, so this is a misnomer.
+	nonsci = unicode(length).lower().replace("e+", "e")
+	if not needsRendererWorkaround:
+		if len(nonsci) > 2 and nonsci[:2] == '0.':
+			nonsci = nonsci[1:] # remove the 0, leave the dot
+		elif len(nonsci) > 3 and nonsci[:3] == '-0.':
+			nonsci = '-' + nonsci[2:] # remove the 0, leave the minus and dot
 	
-	return unicode(coord)+Unit.str(length.units)
+	if len(nonsci) > 3: # avoid calling normalize unless strictly necessary
+		# and then the scientific notation version, with E+NUMBER replaced with
+		# just eNUMBER, since SVG accepts this.
+		sci = unicode(length.normalize()).lower().replace("e+", "e")
+	
+		if len(sci) < len(nonsci): return sci
+		else: return nonsci
+	else: return nonsci
+
+def reducePrecision(element) :
+	"""
+	Because opacities, letter spacings, stroke widths and all that don't need
+	to be preserved in SVG files with 9 digits of precision.
+	
+	Takes all of these attributes, in the given element node and its children,
+	and reduces their precision to the current Decimal context's precision.
+	Also checks for the attributes actually being lengths, not 'inherit', 'none'
+	or anything that isn't an SVGLength.
+	
+	Returns the number of bytes saved after performing these reductions.
+	"""
+	num = 0
+	
+	for lengthAttr in ['opacity', 'flood-opacity', 'fill-opacity', 'stroke-opacity', 'stop-opacity', 'stroke-miterlimit', 'stroke-dashoffset', 'letter-spacing', 'word-spacing', 'kerning', 'font-size-adjust', 'font-size', 'stroke-width']:
+		val = element.getAttribute(lengthAttr)
+		if val != '':
+			valLen = SVGLength(val)
+			if valLen.units != Unit.INVALID: # not an absolute/relative size or inherit, can be % though
+				newVal = scourLength(val)
+				if len(newVal) < len(val):
+					num += len(val) - len(newVal)
+					element.setAttribute(lengthAttr, newVal)
+	
+	for child in element.childNodes:
+		if child.nodeType == 1:
+			num += reducePrecision(child)
+	
+	return num
+
+def optimizeTransform(transform):
+	"""
+	Optimises a series of transformations parsed from a single
+	transform="" attribute.
+	
+	The transformation list is modified in-place.
+	"""
+	# if there's only one transformation and it's a matrix,
+	# try to make it a shorter non-matrix transformation
+	if len(transform) == 1 and transform[0][0] == 'matrix':
+		# |¯  1  0  0  ¯|
+		# |   0  1  0   |  Identity matrix (no transformation)
+		# |_  0  0  1  _|
+		if transform[0][1] == [1, 0, 0, 0, 1, 0]:
+			del transform[0]
+		# |¯  1  0  X  ¯|
+		# |   0  1  Y   |  Translation by (X, Y).
+		# |_  0  0  1  _|
+		if (transform[0][1][0] == 1 and
+		    transform[0][1][1] == 0 and
+		    transform[0][1][3] == 0 and
+		    transform[0][1][4] == 1):
+			transform[0] = ('translate', [
+				transform[0][1][2], transform[0][1][5]
+			])
+		# |¯  X  0  0  ¯|
+		# |   0  Y  0   |  Scaling by (X, Y).
+		# |_  0  0  1  _|
+		elif (transform[0][1][1] == 0 and
+		      transform[0][1][2] == 0 and
+		      transform[0][1][3] == 0 and
+		      transform[0][1][5] == 0):
+			transform[0] = ('scale', [
+				transform[0][1][0], transform[0][1][4]
+			])
+		# |¯  cos(A) -sin(A)    0    ¯|  Rotation by angle A,
+		# |   sin(A)  cos(A)    0     |  clockwise, about the origin.
+		# |_    0       0       1    _|  A is in degrees.
+		elif (transform[0][1][0] ==  transform[0][1][4]                and
+		      transform[0][1][1] == -transform[0][1][3]                and
+		      transform[0][1][0] >=  0                                 and
+		      transform[0][1][0] <=  1                                 and
+		      transform[0][1][3] ==  sqrt(1 - transform[0][1][0] ** 2) and
+		      transform[0][1][2] ==  0                                 and
+		      transform[0][1][5] ==  0):
+			transform[0] = ('rotate', [
+				# What allows us to get the angle from the matrix
+				# is the inverse sine of sin(A), which is the 4th
+				# matrix component, or the inverse cosine of cos(A),
+				# which is the 1st matrix component. I chose sin(A).
+				# math.asin returns radians, so convert.
+				# SVG demands degrees.
+				Decimal(math.degrees(math.asin(transform[0][1][4])))
+			])
+	
+	# Simplify transformations where numbers are optional.
+	for singleTransform in transform:
+		if singleTransform[0] == 'translate':
+			# Only the X coordinate is required for translations.
+			# If the Y coordinate is unspecified, it's 0.
+			if (len(singleTransform[1]) == 2 and
+			    singleTransform[1][1] == 0):
+				del singleTransform[1][1]
+		elif singleTransform[0] == 'rotate':
+			# Only the angle is required for rotations.
+			# If the coordinates are unspecified, it's the origin (0, 0).
+			if (len(singleTransform[1]) == 3 and
+			    singleTransform[1][1] == 0 and
+			    singleTransform[1][2] == 0):
+				del singleTransform[1][1:]
+		elif singleTransform[0] == 'scale':
+			# Only the X scaling factor is required.
+			# If the Y factor is unspecified, it's the same as X.
+			if (len(singleTransform[1]) == 2 and
+			    singleTransform[1][0] == singleTransform[1][1]):
+				del singleTransform[1][1]
+	
+	# Attempt to coalesce runs of the same transformation.
+	# Translations followed immediately by other translations,
+	# rotations followed immediately by other rotations,
+	# scaling followed immediately by other scaling,
+	# are safe to add.
+	# A matrix followed immediately by another matrix
+	# would be safe to multiply together, too.
+	i = 1
+	while i < len(transform):
+		if transform[i][0] == transform[i - 1][0] == 'translate':
+			transform[i - 1][1][0] += transform[i][1][0] # x
+			# for y, only add if the second translation has an explicit y
+			if len(transform[i][1]) == 2:
+				if len(transform[i - 1][1]) == 2:
+					transform[i - 1][1][1] += transform[i][1][1] # y
+				elif len(transform[i - 1][1]) == 1:
+					transform[i - 1][1].append(transform[i][1][1]) # y
+			del transform[i]
+			if transform[i - 1][1][0] == transform[i - 1][1][1] == 0:
+				# Identity translation!
+				i -= 1
+				del transform[i]
+		elif (transform[i][0] == transform[i - 1][0] == 'rotate'
+		      and len(transform[i - 1][1]) == len(transform[i][1]) == 1):
+			# Only coalesce if both rotations are from the origin.
+			transform[i - 1][1][0] += transform[i][1][0] # angle
+			del transform[i]
+		elif transform[i][0] == transform[i - 1][0] == 'scale':
+			transform[i - 1][1][0] *= transform[i][1][0] # x
+			# handle an implicit y
+			if len(transform[i - 1][1]) == 2 and len(transform[i][1]) == 2:
+				# y1 * y2
+				transform[i - 1][1][1] *= transform[i][1][1]
+			elif len(transform[i - 1][1]) == 1 and len(transform[i][1]) == 2:
+				# create y2 = uniformscalefactor1 * y2
+				transform[i - 1][1].append(transform[i - 1][1][0] * transform[i][1][1])
+			elif len(transform[i - 1][1]) == 2 and len(transform[i][1]) == 1:
+				# y1 * uniformscalefactor2
+				transform[i - 1][1][1] *= transform[i][1][0]
+			del transform[i]
+			if transform[i - 1][1][0] == transform[i - 1][1][1] == 1:
+				# Identity scale!
+				i -= 1
+				del transform[i]
+		else:
+			i += 1
+
+def optimizeTransforms(element, options) :
+	"""
+	Attempts to optimise transform specifications on the given node and its children.
+	
+	Returns the number of bytes saved after performing these reductions.
+	"""
+	num = 0
+	
+	for transformAttr in ['transform', 'patternTransform', 'gradientTransform']:
+		val = element.getAttribute(transformAttr)
+		if val != '':
+			transform = svg_transform_parser.parse(val)
+			
+			optimizeTransform(transform)
+			
+			newVal = serializeTransform(transform)
+			
+			if len(newVal) < len(val):
+				element.setAttribute(transformAttr, newVal)
+				num += len(val) - len(newVal)
+	
+	for child in element.childNodes:
+		if child.nodeType == 1:
+			num += optimizeTransforms(child, options)
+	
+	return num
+
+def removeComments(element) :
+	"""
+		Removes comments from the element and its children.
+	"""
+	global numCommentBytes
+
+	if isinstance(element, xml.dom.minidom.Document):
+		# must process the document object separately, because its
+		# documentElement's nodes have None as their parentNode
+		for subelement in element.childNodes:
+			if isinstance(element, xml.dom.minidom.Comment):
+				numCommentBytes += len(element.data)
+				element.documentElement.removeChild(subelement)
+			else:
+				removeComments(subelement)
+	elif isinstance(element, xml.dom.minidom.Comment):
+		numCommentBytes += len(element.data)
+		element.parentNode.removeChild(element)
+	else:
+		for subelement in element.childNodes:
+			removeComments(subelement)
 
 def embedRasters(element, options) :
+	import base64
+	import urllib
 	"""
 		Converts raster references to inline images.
 		NOTE: there are size limits to base64-encoding handling in browsers 
@@ -2035,7 +2295,7 @@ def remapNamespacePrefix(node, oldprefix, newprefix):
 			
 		# add all the attributes
 		attrList = node.attributes
-		for i in range(attrList.length):
+		for i in xrange(attrList.length):
 			attr = attrList.item(i)
 			newNode.setAttributeNS( attr.namespaceURI, attr.localName, attr.nodeValue)
 	
@@ -2093,7 +2353,7 @@ def serializeXML(element, options, ind = 0, preserveWhitespace = False):
 	
 	# now serialize the other attributes
 	attrList = element.attributes
-	for num in range(attrList.length) :
+	for num in xrange(attrList.length) :
 		attr = attrList.item(num)
 		if attr.nodeName == 'id' or attr.nodeName == 'xml:id': continue
 		# if the attribute value contains a double-quote, use single-quotes
@@ -2172,6 +2432,10 @@ def scourString(in_string, options=None):
 	global numStylePropsFixed
 	global numElemsRemoved
 	global numBytesSavedInColors
+	global numCommentsRemoved
+	global numBytesSavedInIDs
+	global numBytesSavedInLengths
+	global numBytesSavedInTransforms
 	doc = xml.dom.minidom.parseString(in_string)
 
 	# for whatever reason this does not always remove all inkscape/sodipodi attributes/elements
@@ -2186,7 +2450,7 @@ def scourString(in_string, options=None):
 		# remove the xmlns: declarations now
 		xmlnsDeclsToRemove = []
 		attrList = doc.documentElement.attributes
-		for num in range(attrList.length) :
+		for num in xrange(attrList.length) :
 			if attrList.item(num).nodeValue in unwanted_ns :
 				xmlnsDeclsToRemove.append(attrList.item(num).nodeName)
 		
@@ -2204,7 +2468,7 @@ def scourString(in_string, options=None):
 	attrList = doc.documentElement.attributes
 	xmlnsDeclsToRemove = []
 	redundantPrefixes = []
-	for i in range(attrList.length):
+	for i in xrange(attrList.length):
 		attr = attrList.item(i)
 		name = attr.nodeName
 		val = attr.nodeValue
@@ -2218,6 +2482,9 @@ def scourString(in_string, options=None):
 	for prefix in redundantPrefixes:
 		remapNamespacePrefix(doc.documentElement, prefix, '')
 
+	if options.strip_comments:
+		numCommentsRemoved = removeComments(doc)
+
 	# repair style (remove unnecessary style properties and change them into XML attributes)
 	numStylePropsFixed = repairStyle(doc.documentElement, options)
 
@@ -2225,6 +2492,10 @@ def scourString(in_string, options=None):
 	if options.simple_colors:
 		numBytesSavedInColors = convertColors(doc.documentElement)
 	
+	# remove <metadata> if the user wants to
+	if options.remove_metadata:
+		removeMetadataElements(doc)
+	
 	# remove empty defs, metadata, g
 	# NOTE: these elements will be removed even if they have (invalid) text nodes
 	elemsToRemove = []
@@ -2268,37 +2539,51 @@ def scourString(in_string, options=None):
 		pass
 	
 	# move common attributes to parent group
-	numAttrsRemoved += moveCommonAttributesToParentGroup(doc.documentElement)
+	# NOTE: the if the <svg> element's immediate children
+	# all have the same value for an attribute, it must not
+	# get moved to the <svg> element. The <svg> element
+	# doesn't accept fill=, stroke= etc.!
+	for child in doc.documentElement.childNodes:
+		numAttrsRemoved += moveCommonAttributesToParentGroup(child)
 	
 	# remove unused attributes from parent
 	numAttrsRemoved += removeUnusedAttributesOnParent(doc.documentElement)
 
+	# remove unnecessary closing point of polygons and scour points
+	for polygon in doc.documentElement.getElementsByTagName('polygon') :
+		cleanPolygon(polygon, options)
+
+	# scour points of polyline
+	for polyline in doc.documentElement.getElementsByTagName('polyline') :
+		cleanPolygon(polyline, options)
+
 	# clean path data
 	for elem in doc.documentElement.getElementsByTagName('path') :
 		if elem.getAttribute('d') == '':
 			elem.parentNode.removeChild(elem)
 		else:
-			cleanPath(elem)
-
-	# remove unnecessary closing point of polygons and scour points
-	for polygon in doc.documentElement.getElementsByTagName('polygon') :
-		cleanPolygon(polygon)
-
-	# scour points of polyline
-	for polyline in doc.documentElement.getElementsByTagName('polyline') :
-		cleanPolygon(polyline)
+			cleanPath(elem, options)
 	
-	# scour lengths (including coordinates)
-	for type in ['svg', 'image', 'rect', 'circle', 'ellipse', 'line', 'linearGradient', 'radialGradient', 'stop']:
-		for elem in doc.getElementsByTagName(type):
-			for attr in ['x', 'y', 'width', 'height', 'cx', 'cy', 'r', 'rx', 'ry', 
-						'x1', 'y1', 'x2', 'y2', 'fx', 'fy', 'offset', 'opacity',
-						'fill-opacity', 'stroke-opacity', 'stroke-width', 'stroke-miterlimit']:
-				if elem.getAttribute(attr) != '':
-					elem.setAttribute(attr, scourLength(elem.getAttribute(attr)))
+	# shorten ID names as much as possible
+	if options.shorten_ids:
+		numBytesSavedInIDs += shortenIDs(doc)
 
 	# remove default values of attributes
-	numAttrsRemoved += removeDefaultAttributeValues(doc.documentElement, options)		
+	numAttrsRemoved += removeDefaultAttributeValues(doc.documentElement, options)	
+	
+	# scour lengths (including coordinates)
+	for type in ['svg', 'image', 'rect', 'circle', 'ellipse', 'line', 'linearGradient', 'radialGradient', 'stop', 'filter']:
+		for elem in doc.getElementsByTagName(type):
+			for attr in ['x', 'y', 'width', 'height', 'cx', 'cy', 'r', 'rx', 'ry', 
+						'x1', 'y1', 'x2', 'y2', 'fx', 'fy', 'offset']:
+				if elem.getAttribute(attr) != '':
+					elem.setAttribute(attr, scourLength(elem.getAttribute(attr)))	
+	
+	# more length scouring in this function
+	numBytesSavedInLengths = reducePrecision(doc.documentElement)
+	
+	# reduce the length of transformation attributes
+	numBytesSavedInTransforms = optimizeTransforms(doc.documentElement, options)
 	
 	# convert rasters references to base64-encoded strings 
 	if options.embed_rasters:
@@ -2378,12 +2663,24 @@ _options_parser.add_option("--disable-group-collapsing",
 _options_parser.add_option("--enable-id-stripping",
 	action="store_true", dest="strip_ids", default=False,
 	help="remove all un-referenced ID attributes")
+_options_parser.add_option("--enable-comment-stripping",
+	action="store_true", dest="strip_comments", default=False,
+	help="remove all <!-- --> comments")
+_options_parser.add_option("--shorten-ids",
+	action="store_true", dest="shorten_ids", default=False,
+	help="shorten all ID attributes to the least number of letters possible")
 _options_parser.add_option("--disable-embed-rasters",
 	action="store_false", dest="embed_rasters", default=True,
 	help="won't embed rasters as base64-encoded data")
 _options_parser.add_option("--keep-editor-data",
 	action="store_true", dest="keep_editor_data", default=False,
 	help="won't remove Inkscape, Sodipodi or Adobe Illustrator elements and attributes")
+_options_parser.add_option("--remove-metadata",
+	action="store_true", dest="remove_metadata", default=False,
+	help="remove <metadata> elements (which may contain license metadata etc.)")
+_options_parser.add_option("--renderer-workaround",
+	action="store_true", dest="renderer_workaround", default=False,
+	help="work around various renderer bugs (currently only librsvg)")
 _options_parser.add_option("--strip-xml-prolog",
 	action="store_true", dest="strip_xml_prolog", default=False,
 	help="won't output the <?xml ?> prolog")
@@ -2400,12 +2697,16 @@ _options_parser.add_option("-i",
 	action="store", dest="infilename", help=optparse.SUPPRESS_HELP)
 _options_parser.add_option("-o",
 	action="store", dest="outfilename", help=optparse.SUPPRESS_HELP)
+_options_parser.add_option("-q", "--quiet",
+	action="store_true", dest="quiet", default=False,
+	help="suppress non-error output")
 _options_parser.add_option("--indent",
 	action="store", type="string", dest="indent_type", default="space",
 	help="indentation of the output: none, space, tab (default: %default)")
 
 def maybe_gziped_file(filename, mode="r"):
 	if os.path.splitext(filename)[1].lower() in (".svgz", ".gz"):
+		import gzip
 		return gzip.GzipFile(filename, mode)
 	return file(filename, mode)
 
@@ -2443,7 +2744,11 @@ def getReport():
 		' Number of path segments reduced/removed: ' + str(numPathSegmentsReduced) + os.linesep + \
 		' Number of bytes saved in path data: ' + str(numBytesSavedInPathData) + os.linesep + \
 		' Number of bytes saved in colors: ' + str(numBytesSavedInColors) + os.linesep + \
-		' Number of points removed from polygons: ' + str(numPointsRemovedFromPolygon)
+		' Number of points removed from polygons: ' + str(numPointsRemovedFromPolygon) + os.linesep + \
+		' Number of bytes saved in comments: ' + str(numCommentBytes) + os.linesep + \
+		' Number of bytes saved in id attributes: ' + str(numBytesSavedInIDs) + os.linesep + \
+		' Number of bytes saved in lengths: ' + str(numBytesSavedInLengths) + os.linesep + \
+		' Number of bytes saved in transformations: ' + str(numBytesSavedInTransforms)
 
 if __name__ == '__main__':
 	if sys.platform == "win32":
@@ -2457,7 +2762,8 @@ if __name__ == '__main__':
 	
 	options, (input, output) = parse_args()
 	
-	print >>sys.stderr, "%s %s\n%s" % (APP, VER, COPYRIGHT)
+	if not options.quiet:
+		print >>sys.stderr, "%s %s\n%s" % (APP, VER, COPYRIGHT)
 
 	# do the work
 	in_string = input.read()
@@ -2470,14 +2776,14 @@ if __name__ == '__main__':
 
 	end = get_tick()
 
-	# GZ: unless silenced by -q or something?
 	# GZ: not using globals would be good too
-	print >>sys.stderr, ' File:', input.name, \
-		os.linesep + ' Time taken:', str(end-start) + 's' + os.linesep, \
-		getReport()
+	if not options.quiet:
+		print >>sys.stderr, ' File:', input.name, \
+			os.linesep + ' Time taken:', str(end-start) + 's' + os.linesep, \
+			getReport()
 	
-	oldsize = len(in_string)
-	newsize = len(out_string)
-	sizediff = (newsize / oldsize) * 100
-	print >>sys.stderr, ' Original file size:', oldsize, 'bytes;', \
-		'new file size:', newsize, 'bytes (' + str(sizediff)[:5] + '%)'
+		oldsize = len(in_string)
+		newsize = len(out_string)
+		sizediff = (newsize / oldsize) * 100
+		print >>sys.stderr, ' Original file size:', oldsize, 'bytes;', \
+			'new file size:', newsize, 'bytes (' + str(sizediff)[:5] + '%)'
diff --git a/svg_regex.py b/svg_regex.py
index 10fd9c3..282e45d 100644
--- a/svg_regex.py
+++ b/svg_regex.py
@@ -43,6 +43,7 @@ Out[5]: [('M', [(100.0, -200.0)])]
 """
 
 import re
+from decimal import *
 
 
 # Sentinel.
@@ -52,8 +53,8 @@ class _EOF(object):
 EOF = _EOF()
 
 lexicon = [
-    ('float', r'[-\+]?(?:(?:[0-9]*\.[0-9]+)|(?:[0-9]+\.?))(?:[Ee][-\+]?[0-9]+)?'),
-    ('int', r'[-\+]?[0-9]+'),
+    ('float', r'[-+]?(?:(?:[0-9]*\.[0-9]+)|(?:[0-9]+\.?))(?:[Ee][-+]?[0-9]+)?'),
+    ('int', r'[-+]?[0-9]+'),
     ('command', r'[AaCcHhLlMmQqSsTtVvZz]'),
 ]
 
@@ -161,7 +162,7 @@ class SVGPathParser(object):
     def rule_closepath(self, next, token):
         command = token[1]
         token = next()
-        return (command, None), token
+        return (command, []), token
 
     def rule_moveto_or_lineto(self, next, token):
         command = token[1]
@@ -169,7 +170,7 @@ class SVGPathParser(object):
         coordinates = []
         while token[0] in self.number_tokens:
             pair, token = self.rule_coordinate_pair(next, token)
-            coordinates.append(pair)
+            coordinates.extend(pair)
         return (command, coordinates), token
 
     def rule_orthogonal_lineto(self, next, token):
@@ -189,7 +190,9 @@ class SVGPathParser(object):
             pair1, token = self.rule_coordinate_pair(next, token)
             pair2, token = self.rule_coordinate_pair(next, token)
             pair3, token = self.rule_coordinate_pair(next, token)
-            coordinates.append((pair1, pair2, pair3))
+            coordinates.extend(pair1)
+            coordinates.extend(pair2)
+            coordinates.extend(pair3)
         return (command, coordinates), token
 
     def rule_curveto2(self, next, token):
@@ -199,7 +202,8 @@ class SVGPathParser(object):
         while token[0] in self.number_tokens:
             pair1, token = self.rule_coordinate_pair(next, token)
             pair2, token = self.rule_coordinate_pair(next, token)
-            coordinates.append((pair1, pair2))
+            coordinates.extend(pair1)
+            coordinates.extend(pair2)
         return (command, coordinates), token
 
     def rule_curveto1(self, next, token):
@@ -208,7 +212,7 @@ class SVGPathParser(object):
         coordinates = []
         while token[0] in self.number_tokens:
             pair1, token = self.rule_coordinate_pair(next, token)
-            coordinates.append(pair1)
+            coordinates.extend(pair1)
         return (command, coordinates), token
 
     def rule_elliptical_arc(self, next, token):
@@ -216,51 +220,51 @@ class SVGPathParser(object):
         token = next()
         arguments = []
         while token[0] in self.number_tokens:
-            rx = float(token[1])
+            rx = Decimal(token[1]) * 1
             if rx < 0.0:
                 raise SyntaxError("expecting a nonnegative number; got %r" % (token,))
 
             token = next()
             if token[0] not in self.number_tokens:
                 raise SyntaxError("expecting a number; got %r" % (token,))
-            ry = float(token[1])
+            ry = Decimal(token[1]) * 1
             if ry < 0.0:
                 raise SyntaxError("expecting a nonnegative number; got %r" % (token,))
 
             token = next()
             if token[0] not in self.number_tokens:
                 raise SyntaxError("expecting a number; got %r" % (token,))
-            axis_rotation = float(token[1])
+            axis_rotation = Decimal(token[1]) * 1
 
             token = next()
             if token[1] not in ('0', '1'):
                 raise SyntaxError("expecting a boolean flag; got %r" % (token,))
-            large_arc_flag = bool(int(token[1]))
+            large_arc_flag = Decimal(token[1]) * 1
 
             token = next()
             if token[1] not in ('0', '1'):
                 raise SyntaxError("expecting a boolean flag; got %r" % (token,))
-            sweep_flag = bool(int(token[1]))
+            sweep_flag = Decimal(token[1]) * 1
 
             token = next()
             if token[0] not in self.number_tokens:
                 raise SyntaxError("expecting a number; got %r" % (token,))
-            x = float(token[1])
+            x = Decimal(token[1]) * 1
 
             token = next()
             if token[0] not in self.number_tokens:
                 raise SyntaxError("expecting a number; got %r" % (token,))
-            y = float(token[1])
+            y = Decimal(token[1]) * 1
 
             token = next()
-            arguments.append(((rx,ry), axis_rotation, large_arc_flag, sweep_flag, (x,y)))
+            arguments.extend([rx, ry, axis_rotation, large_arc_flag, sweep_flag, x, y])
 
         return (command, arguments), token
 
     def rule_coordinate(self, next, token):
         if token[0] not in self.number_tokens:
             raise SyntaxError("expecting a number; got %r" % (token,))
-        x = float(token[1])
+        x = getcontext().create_decimal(token[1])
         token = next()
         return x, token
 
@@ -269,13 +273,13 @@ class SVGPathParser(object):
         # Inline these since this rule is so common.
         if token[0] not in self.number_tokens:
             raise SyntaxError("expecting a number; got %r" % (token,))
-        x = float(token[1])
+        x = getcontext().create_decimal(token[1])
         token = next()
         if token[0] not in self.number_tokens:
             raise SyntaxError("expecting a number; got %r" % (token,))
-        y = float(token[1])
+        y = getcontext().create_decimal(token[1])
         token = next()
-        return (x,y), token
+        return [x, y], token
 
 
 svg_parser = SVGPathParser()
diff --git a/svg_transform.py b/svg_transform.py
new file mode 100644
index 0000000..4a69d75
--- /dev/null
+++ b/svg_transform.py
@@ -0,0 +1,233 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#  SVG transformation list parser
+#
+#  Copyright 2010 
+#
+#  This file is part of Scour, http://www.codedread.com/scour/
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+""" Small recursive descent parser for SVG transform="" data.
+
+
+In [1]: from svg_transform import svg_transform_parser
+
+In [3]: svg_transform_parser.parse('translate(50, 50)')
+Out[3]: [('translate', [50.0, 50.0])]
+
+In [4]: svg_transform_parser.parse('translate(50)')
+Out[4]: [('translate', [50.0])]
+
+In [5]: svg_transform_parser.parse('rotate(36 50,50)')
+Out[5]: [('rotate', [36.0, 50.0, 50.0])]
+
+In [6]: svg_transform_parser.parse('rotate(36)')
+Out[6]: [('rotate', [36.0])]
+
+In [7]: svg_transform_parser.parse('skewX(20)')
+Out[7]: [('skewX', [20.0])]
+
+In [8]: svg_transform_parser.parse('skewY(40)')
+Out[8]: [('skewX', [20.0])]
+
+In [9]: svg_transform_parser.parse('scale(2 .5)')
+Out[9]: [('scale', [2.0, 0.5])]
+
+In [10]: svg_transform_parser.parse('scale(.5)')
+Out[10]: [('scale', [0.5])]
+
+In [11]: svg_transform_parser.parse('matrix(1 0 50 0 1 80)')
+Out[11]: [('matrix', [1.0, 0.0, 50.0, 0.0, 1.0, 80.0])]
+
+Multiple transformations are supported:
+
+In [12]: svg_transform_parser.parse('translate(30 -30) rotate(36)')
+Out[12]: [('translate', [30.0, -30.0]), ('rotate', [36.0])]
+"""
+
+import re
+from decimal import *
+
+
+# Sentinel.
+class _EOF(object):
+    def __repr__(self):
+        return 'EOF'
+EOF = _EOF()
+
+lexicon = [
+    ('float', r'[-+]?(?:(?:[0-9]*\.[0-9]+)|(?:[0-9]+\.?))(?:[Ee][-+]?[0-9]+)?'),
+    ('int', r'[-+]?[0-9]+'),
+    ('command', r'(?:matrix|translate|scale|rotate|skew[XY])'),
+    ('coordstart', r'\('),
+    ('coordend', r'\)'),
+]
+
+
+class Lexer(object):
+    """ Break SVG path data into tokens.
+
+    The SVG spec requires that tokens are greedy. This lexer relies on Python's
+    regexes defaulting to greediness.
+
+    This style of implementation was inspired by this article:
+
+        http://www.gooli.org/blog/a-simple-lexer-in-python/
+    """
+    def __init__(self, lexicon):
+        self.lexicon = lexicon
+        parts = []
+        for name, regex in lexicon:
+            parts.append('(?P<%s>%s)' % (name, regex))
+        self.regex_string = '|'.join(parts)
+        self.regex = re.compile(self.regex_string)
+
+    def lex(self, text):
+        """ Yield (token_type, str_data) tokens.
+
+        The last token will be (EOF, None) where EOF is the singleton object
+        defined in this module.
+        """
+        for match in self.regex.finditer(text):
+            for name, _ in self.lexicon:
+                m = match.group(name)
+                if m is not None:
+                    yield (name, m)
+                    break
+        yield (EOF, None)
+
+svg_lexer = Lexer(lexicon)
+
+
+class SVGTransformationParser(object):
+    """ Parse SVG transform="" data into a list of commands.
+
+    Each distinct command will take the form of a tuple (type, data). The
+    `type` is the character string that defines the type of transformation in the
+    transform data, so either of "translate", "rotate", "scale", "matrix",
+    "skewX" and "skewY". Data is always a list of numbers contained within the
+    transformation's parentheses.
+
+    See the SVG documentation for the interpretation of the individual elements
+    for each transformation.
+
+    The main method is `parse(text)`. It can only consume actual strings, not
+    filelike objects or iterators.
+    """
+
+    def __init__(self, lexer=svg_lexer):
+        self.lexer = lexer
+
+        self.command_dispatch = {
+            'translate': self.rule_1or2numbers,
+            'scale': self.rule_1or2numbers,
+            'skewX': self.rule_1number,
+            'skewY': self.rule_1number,
+            'rotate': self.rule_1or3numbers,
+            'matrix': self.rule_6numbers,
+        }
+
+#        self.number_tokens = set(['int', 'float'])
+        self.number_tokens = list(['int', 'float'])
+
+    def parse(self, text):
+        """ Parse a string of SVG transform="" data.
+        """
+        next = self.lexer.lex(text).next
+        commands = []
+        token = next()
+        while token[0] is not EOF:
+        	command, token = self.rule_svg_transform(next, token)
+        	commands.append(command)
+        return commands
+
+    def rule_svg_transform(self, next, token):
+        if token[0] != 'command':
+            raise SyntaxError("expecting a transformation type; got %r" % (token,))
+        command = token[1]
+        rule = self.command_dispatch[command]
+        token = next()
+        if token[0] != 'coordstart':
+            raise SyntaxError("expecting '('; got %r" % (token,))
+        numbers, token = rule(next, token)
+        if token[0] != 'coordend':
+            raise SyntaxError("expecting ')'; got %r" % (token,))
+        token = next()
+        return (command, numbers), token
+
+    def rule_1or2numbers(self, next, token):
+        numbers = []
+        # 1st number is mandatory
+        token = next()
+        number, token = self.rule_number(next, token)
+        numbers.append(number)
+        # 2nd number is optional
+        number, token = self.rule_optional_number(next, token)
+        if number is not None:
+            numbers.append(number)
+            
+        return numbers, token
+
+    def rule_1number(self, next, token):
+        # this number is mandatory
+        token = next()
+        number, token = self.rule_number(next, token)
+        numbers = [number]
+        return numbers, token
+
+    def rule_1or3numbers(self, next, token):
+        numbers = []
+        # 1st number is mandatory
+        token = next()
+        number, token = self.rule_number(next, token)
+        numbers.append(number)
+        # 2nd number is optional
+        number, token = self.rule_optional_number(next, token)
+        if number is not None:
+            # but, if the 2nd number is provided, the 3rd is mandatory.
+            # we can't have just 2.
+            numbers.append(number)
+            
+            number, token = self.rule_number(next, token)
+            numbers.append(number)
+            
+        return numbers, token
+
+    def rule_6numbers(self, next, token):
+        numbers = []
+        token = next()
+        # all numbers are mandatory
+        for i in xrange(6):
+            number, token = self.rule_number(next, token)
+            numbers.append(number)
+        return numbers, token
+
+    def rule_number(self, next, token):
+        if token[0] not in self.number_tokens:
+            raise SyntaxError("expecting a number; got %r" % (token,))
+        x = Decimal(token[1]) * 1
+        token = next()
+        return x, token
+
+    def rule_optional_number(self, next, token):
+        if token[0] not in self.number_tokens:
+            return None, token
+        else:
+            x = Decimal(token[1]) * 1
+            token = next()
+            return x, token
+
+
+svg_transform_parser = SVGTransformationParser()
diff --git a/testscour.py b/testscour.py
index c2f8969..d696c99 100755
--- a/testscour.py
+++ b/testscour.py
@@ -48,6 +48,9 @@ class ScourOptions:
 	strip_xml_prolog = False
 	indent_type = "space"
 	enable_viewboxing = False
+	shorten_ids = False
+	strip_comments = False
+	remove_metadata = False
 
 class NoInkscapeElements(unittest.TestCase):
 	def runTest(self):
@@ -445,7 +448,7 @@ class ConvertFillPropertyToAttr(unittest.TestCase):
 class ConvertFillOpacityPropertyToAttr(unittest.TestCase):
 	def runTest(self):
 		doc = scour.scourXmlFile('unittests/fill-none.svg')
-		self.assertEquals(doc.getElementsByTagNameNS(SVGNS, 'path')[1].getAttribute('fill-opacity'), '0.5',
+		self.assertEquals(doc.getElementsByTagNameNS(SVGNS, 'path')[1].getAttribute('fill-opacity'), '.5',
 			'fill-opacity property not converted to XML attribute' )
 
 class ConvertFillRuleOpacityPropertyToAttr(unittest.TestCase):
@@ -483,14 +486,14 @@ class RemoveTrailingZerosFromPath(unittest.TestCase):
 	def runTest(self):
 		doc = scour.scourXmlFile('unittests/path-truncate-zeros.svg')
 		path = doc.getElementsByTagNameNS(SVGNS, 'path')[0].getAttribute('d')
-		self.assertEquals(path[:4] == 'M300' and path[4] != '.', True,
+		self.assertEquals(path[:4] == 'm300' and path[4] != '.', True,
 			'Trailing zeros not removed from path data' )
 
 class RemoveTrailingZerosFromPathAfterCalculation(unittest.TestCase):
 	def runTest(self):
 		doc = scour.scourXmlFile('unittests/path-truncate-zeros-calc.svg')
 		path = doc.getElementsByTagNameNS(SVGNS, 'path')[0].getAttribute('d')
-		self.assertEquals(path, 'M5.81,0h0.1',
+		self.assertEquals(path, 'm5.81 0h0.1',
 			'Trailing zeros not removed from path data after calculation' )
 
 class RemoveDelimiterBeforeNegativeCoordsInPath(unittest.TestCase):
@@ -504,7 +507,7 @@ class UseScientificNotationToShortenCoordsInPath(unittest.TestCase):
 	def runTest(self):
 		doc = scour.scourXmlFile('unittests/path-use-scientific-notation.svg')
 		path = doc.getElementsByTagNameNS(SVGNS, 'path')[0].getAttribute('d')
-		self.assertEquals(path, 'M1E+4,0',
+		self.assertEquals(path, 'm1e4 0',
 			'Not using scientific notation for path coord when representation is shorter')
 
 class ConvertAbsoluteToRelativePathCommands(unittest.TestCase):
@@ -513,23 +516,23 @@ class ConvertAbsoluteToRelativePathCommands(unittest.TestCase):
 		path = svg_parser.parse(doc.getElementsByTagNameNS(SVGNS, 'path')[0].getAttribute('d'))
 		self.assertEquals(path[1][0], 'v',
 			'Absolute V command not converted to relative v command')
-		self.assertEquals(path[1][1][0], -20.0,
+		self.assertEquals(float(path[1][1][0]), -20.0,
 			'Absolute V value not converted to relative v value')
 
 class RoundPathData(unittest.TestCase):
 	def runTest(self):
 		doc = scour.scourXmlFile('unittests/path-precision.svg')
 		path = svg_parser.parse(doc.getElementsByTagNameNS(SVGNS, 'path')[0].getAttribute('d'))
-		self.assertEquals(path[0][1][0][0], 100.0,
+		self.assertEquals(float(path[0][1][0]), 100.0,
 			'Not rounding down' )
-		self.assertEquals(path[0][1][0][1], 100.0,
+		self.assertEquals(float(path[0][1][1]), 100.0,
 			'Not rounding up' )
 			
 class LimitPrecisionInPathData(unittest.TestCase):
 	def runTest(self):
 		doc = scour.scourXmlFile('unittests/path-precision.svg')
 		path = svg_parser.parse(doc.getElementsByTagNameNS(SVGNS, 'path')[0].getAttribute('d'))
-		self.assertEquals(path[1][1][0], 100.01,
+		self.assertEquals(float(path[1][1][0]), 100.01,
 			'Not correctly limiting precision on path data' )
 
 class RemoveEmptyLineSegmentsFromPath(unittest.TestCase):
@@ -545,7 +548,7 @@ class ChangeLineToHorizontalLineSegmentInPath(unittest.TestCase):
 		path = svg_parser.parse(doc.getElementsByTagNameNS(SVGNS, 'path')[0].getAttribute('d'))
 		self.assertEquals(path[1][0], 'h',
 			'Did not change line to horizontal line segment in path' )
-		self.assertEquals(path[1][1][0], 200.0,
+		self.assertEquals(float(path[1][1][0]), 200.0,
 			'Did not calculate horizontal line segment in path correctly' )
 
 class ChangeLineToVerticalLineSegmentInPath(unittest.TestCase):
@@ -554,19 +557,19 @@ class ChangeLineToVerticalLineSegmentInPath(unittest.TestCase):
 		path = svg_parser.parse(doc.getElementsByTagNameNS(SVGNS, 'path')[0].getAttribute('d'))
 		self.assertEquals(path[2][0], 'v',
 			'Did not change line to vertical line segment in path' )
-		self.assertEquals(path[2][1][0], 100.0,
+		self.assertEquals(float(path[2][1][0]), 100.0,
 			'Did not calculate vertical line segment in path correctly' )
 
 class ChangeBezierToShorthandInPath(unittest.TestCase):
 	def runTest(self):
 		path = scour.scourXmlFile('unittests/path-bez-optimize.svg').getElementsByTagNameNS(SVGNS, 'path')[0]
-		self.assertEquals(path.getAttribute('d'), 'm10,100c50-50,50,50,100,0s50,50,100,0',
+		self.assertEquals(path.getAttribute('d'), 'm10 100c50-50 50 50 100 0s50 50 100 0',
 			'Did not change bezier curves into shorthand curve segments in path')
 
 class ChangeQuadToShorthandInPath(unittest.TestCase):
 	def runTest(self):
 		path = scour.scourXmlFile('unittests/path-quad-optimize.svg').getElementsByTagNameNS(SVGNS, 'path')[0]
-		self.assertEquals(path.getAttribute('d'), 'm10,100q50-50,100,0t100,0',
+		self.assertEquals(path.getAttribute('d'), 'm10 100q50-50 100 0t100 0',
 			'Did not change quadratic curves into shorthand curve segments in path')
 
 class HandleNonAsciiUtf8(unittest.TestCase):
@@ -585,31 +588,31 @@ class HandleSciNoInPathData(unittest.TestCase):
 class TranslateRGBIntoHex(unittest.TestCase):
 	def runTest(self):
 		elem = scour.scourXmlFile('unittests/color-formats.svg').getElementsByTagNameNS(SVGNS, 'rect')[0]
-		self.assertEquals( elem.getAttribute('fill'), '#0F1011',
+		self.assertEquals( elem.getAttribute('fill'), '#0f1011',
 			'Not converting rgb into hex')
 
 class TranslateRGBPctIntoHex(unittest.TestCase):
 	def runTest(self):
 		elem = scour.scourXmlFile('unittests/color-formats.svg').getElementsByTagNameNS(SVGNS, 'stop')[0]
-		self.assertEquals( elem.getAttribute('stop-color'), '#7F0000',
+		self.assertEquals( elem.getAttribute('stop-color'), '#7f0000',
 			'Not converting rgb pct into hex')
 
 class TranslateColorNamesIntoHex(unittest.TestCase):
 	def runTest(self):
 		elem = scour.scourXmlFile('unittests/color-formats.svg').getElementsByTagNameNS(SVGNS, 'rect')[0]
-		self.assertEquals( elem.getAttribute('stroke'), '#A9A9A9',
+		self.assertEquals( elem.getAttribute('stroke'), '#a9a9a9',
 			'Not converting standard color names into hex')
 
 class TranslateExtendedColorNamesIntoHex(unittest.TestCase):
 	def runTest(self):
 		elem = scour.scourXmlFile('unittests/color-formats.svg').getElementsByTagNameNS(SVGNS, 'solidColor')[0]
-		self.assertEquals( elem.getAttribute('solid-color'), '#FAFAD2',
+		self.assertEquals( elem.getAttribute('solid-color'), '#fafad2',
 			'Not converting extended color names into hex')
 
 class TranslateLongHexColorIntoShortHex(unittest.TestCase):
 	def runTest(self):
 		elem = scour.scourXmlFile('unittests/color-formats.svg').getElementsByTagNameNS(SVGNS, 'ellipse')[0]
-		self.assertEquals( elem.getAttribute('fill'), '#FFF',
+		self.assertEquals( elem.getAttribute('fill'), '#fff',
 			'Not converting long hex color into short hex')
 
 class DoNotConvertShortColorNames(unittest.TestCase):
@@ -633,62 +636,62 @@ class RemoveFontStylesFromNonTextShapes(unittest.TestCase):
 class CollapseConsecutiveHLinesSegments(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/consecutive-hlines.svg').getElementsByTagNameNS(SVGNS, 'path')[0]
-		self.assertEquals( p.getAttribute('d'), 'M100,100h200v100h-200z',
+		self.assertEquals( p.getAttribute('d'), 'm100 100h200v100h-200z',
 			'Did not collapse consecutive hlines segments')
 
 class CollapseConsecutiveHLinesCoords(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/consecutive-hlines.svg').getElementsByTagNameNS(SVGNS, 'path')[1]
-		self.assertEquals( p.getAttribute('d'), 'M100,300h200v100h-200z',
+		self.assertEquals( p.getAttribute('d'), 'm100 300h200v100h-200z',
 			'Did not collapse consecutive hlines coordinates')
 			
 class DoNotCollapseConsecutiveHLinesSegsWithDifferingSigns(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/consecutive-hlines.svg').getElementsByTagNameNS(SVGNS, 'path')[2]
-		self.assertEquals( p.getAttribute('d'), 'M100,500h300-100v100h-200z',
+		self.assertEquals( p.getAttribute('d'), 'm100 500h300-100v100h-200z',
 			'Collapsed consecutive hlines segments with differing signs')
 
 class ConvertStraightCurvesToLines(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/straight-curve.svg').getElementsByTagNameNS(SVGNS, 'path')[0]
-		self.assertEquals(p.getAttribute('d'), 'M10,10l40,40,40-40z', 
+		self.assertEquals(p.getAttribute('d'), 'm10 10l40 40 40-40z', 
 			'Did not convert straight curves into lines')
 			
 class RemoveUnnecessaryPolygonEndPoint(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/polygon.svg').getElementsByTagNameNS(SVGNS, 'polygon')[0]
-		self.assertEquals(p.getAttribute('points'), '50,50,150,50,150,150,50,150',
+		self.assertEquals(p.getAttribute('points'), '50 50 150 50 150 150 50 150',
 			'Unnecessary polygon end point not removed' )
 
 class DoNotRemovePolgonLastPoint(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/polygon.svg').getElementsByTagNameNS(SVGNS, 'polygon')[1]
-		self.assertEquals(p.getAttribute('points'), '200,50,300,50,300,150,200,150',
+		self.assertEquals(p.getAttribute('points'), '200 50 300 50 300 150 200 150',
 			'Last point of polygon removed' )
 			
 class ScourPolygonCoordsSciNo(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/polygon-coord.svg').getElementsByTagNameNS(SVGNS, 'polygon')[0]
-		self.assertEquals(p.getAttribute('points'), '1E+4,50',
+		self.assertEquals(p.getAttribute('points'), '1e4 50',
 			'Polygon coordinates not scoured')
 
 class ScourPolylineCoordsSciNo(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/polyline-coord.svg').getElementsByTagNameNS(SVGNS, 'polyline')[0]
-		self.assertEquals(p.getAttribute('points'), '1E+4,50',
+		self.assertEquals(p.getAttribute('points'), '1e4 50',
 			'Polyline coordinates not scoured')
 
 class ScourPolygonNegativeCoords(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/polygon-coord-neg.svg').getElementsByTagNameNS(SVGNS, 'polygon')[0]
 		#  points="100,-100,100-100,100-100-100,-100-100,200" />
-		self.assertEquals(p.getAttribute('points'), '100,-100,100,-100,100,-100,-100,-100,-100,200',
+		self.assertEquals(p.getAttribute('points'), '100 -100 100 -100 100 -100 -100 -100 -100 200',
 			'Negative polygon coordinates not properly parsed')
 
 class ScourPolylineNegativeCoords(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/polyline-coord-neg.svg').getElementsByTagNameNS(SVGNS, 'polyline')[0]
-		self.assertEquals(p.getAttribute('points'), '100,-100,100,-100,100,-100,-100,-100,-100,200',
+		self.assertEquals(p.getAttribute('points'), '100 -100 100 -100 100 -100 -100 -100 -100 200',
 			'Negative polyline coordinates not properly parsed')
 
 class DoNotRemoveGroupsWithIDsInDefs(unittest.TestCase):
@@ -700,7 +703,7 @@ class DoNotRemoveGroupsWithIDsInDefs(unittest.TestCase):
 class AlwaysKeepClosePathSegments(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/path-with-closepath.svg').getElementsByTagNameNS(SVGNS, 'path')[0]
-		self.assertEquals(p.getAttribute('d'), 'M10,10h100v100h-100z',
+		self.assertEquals(p.getAttribute('d'), 'm10 10h100v100h-100z',
 			'Path with closepath not preserved')
 
 class RemoveDuplicateLinearGradients(unittest.TestCase):
@@ -736,7 +739,7 @@ class RereferenceForRadialGradient(unittest.TestCase):
 class CollapseSamePathPoints(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/collapse-same-path-points.svg').getElementsByTagNameNS(SVGNS, 'path')[0];
-		self.assertEquals(p.getAttribute('d'), "M100,100l100.12,100.12z",
+		self.assertEquals(p.getAttribute('d'), "m100 100l100.12 100.12z",
 			'Did not collapse same path points')
 
 class ScourUnitlessLengths(unittest.TestCase):
@@ -923,7 +926,7 @@ class PropagateCommonAttributesUp(unittest.TestCase):
 class PathEllipticalArcParsingCommaWsp(unittest.TestCase):
 	def runTest(self):
 		p = scour.scourXmlFile('unittests/path-elliptical-arc-parsing.svg').getElementsByTagNameNS(SVGNS, 'path')[0]
-		self.assertEquals( p.getAttribute('d'), 'M100,100a100,100,0,1,1,-50,100z',
+		self.assertEquals( p.getAttribute('d'), 'm100 100a100 100 0 1 1 -50 100z',
 			'Did not parse elliptical arc command properly')
 
 class RemoveUnusedAttributesOnParent(unittest.TestCase):
@@ -1022,14 +1025,49 @@ class DoNotStripDoctype(unittest.TestCase):
 class PathImplicitLineWithMoveCommands(unittest.TestCase):
 	def runTest(self):
 		path = scour.scourXmlFile('unittests/path-implicit-line.svg').getElementsByTagNameNS(SVGNS, 'path')[0]
-		self.assertEquals( path.getAttribute('d'), "M100,100,100,200m200-100-200,0m200,100,0-100",
+		self.assertEquals( path.getAttribute('d'), "m100 100v100m200-100h-200m200 100v-100",
 			"Implicit line segments after move not preserved")
 
+class RemoveMetadataOption(unittest.TestCase):
+	def runTest(self):
+		doc = scour.scourXmlFile('unittests/full-metadata.svg',
+			scour.parse_args(['--remove-metadata'])[0])
+		self.assertEquals(doc.childNodes.length, 1,
+			'Did not remove <metadata> tag with --remove-metadata')
+
+class EnableCommentStrippingOption(unittest.TestCase):
+	def runTest(self):
+		docStr = file('unittests/comment-beside-xml-decl.svg').read()
+		docStr = scour.scourString(docStr,
+			scour.parse_args(['--enable-comment-stripping'])[0])
+		self.assertEquals(docStr.find('<!--'), -1,
+			'Did not remove document-level comment with --enable-comment-stripping')
+
+class StripXmlPrologOption(unittest.TestCase):
+	def runTest(self):
+		docStr = file('unittests/comment-beside-xml-decl.svg').read()
+		docStr = scour.scourString(docStr,
+			scour.parse_args(['--strip-xml-prolog'])[0])
+		self.assertEquals(docStr.find('<?xml'), -1,
+			'Did not remove <?xml?> with --strip-xml-prolog')
+
+class ShortenIDsOption(unittest.TestCase):
+	def runTest(self):
+		doc = scour.scourXmlFile('unittests/shorten-ids.svg',
+			scour.parse_args(['--shorten-ids'])[0])
+		gradientTag = doc.getElementsByTagName('linearGradient')[0]
+		self.assertEquals(gradientTag.getAttribute('id'), 'a',
+			"Did not shorten a linear gradient's ID with --shorten-ids")
+		rectTag = doc.getElementsByTagName('rect')[0]
+		self.assertEquals(rectTag.getAttribute('fill'), 'url(#a)',
+			'Did not update reference to shortened ID')
+
+
 # TODO: write tests for --enable-viewboxing
 # TODO; write a test for embedding rasters
 # TODO: write a test for --disable-embed-rasters
 # TODO: write tests for --keep-editor-data
-# TODO: write tests for --strip-xml-prolog
+# TODO: write tests for scouring transformations
 
 if __name__ == '__main__':
 	testcss = __import__('testcss')
diff --git a/unittests/comment-beside-xml-decl.svg b/unittests/comment-beside-xml-decl.svg
new file mode 100644
index 0000000..416c770
--- /dev/null
+++ b/unittests/comment-beside-xml-decl.svg
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<!-- Oh look a comment -->
+<svg xmlns="http://www.w3.org/2000/svg">
+</svg>
\ No newline at end of file
diff --git a/unittests/full-metadata.svg b/unittests/full-metadata.svg
new file mode 100644
index 0000000..c5e023c
--- /dev/null
+++ b/unittests/full-metadata.svg
@@ -0,0 +1,22 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+    <metadata>
+      <rdf:RDF
+           xmlns:rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:rdfs = "http://www.w3.org/2000/01/rdf-schema#"
+           xmlns:dc = "http://purl.org/dc/elements/1.1/" >
+        <rdf:Description about="http://example.org/myfoo"
+             dc:title="MyFoo"
+             dc:description="Unit test for Scour's --remove-metadata option"
+             dc:publisher="No One"
+             dc:date="2010-06-09"
+             dc:format="image/svg+xml"
+             dc:language="en" >
+          <dc:creator>
+            <rdf:Bag>
+              <rdf:li>No One</rdf:li>
+            </rdf:Bag>
+          </dc:creator>
+        </rdf:Description>
+      </rdf:RDF>
+    </metadata>
+</svg>
\ No newline at end of file
diff --git a/unittests/shorten-ids.svg b/unittests/shorten-ids.svg
new file mode 100644
index 0000000..5e0fdf6
--- /dev/null
+++ b/unittests/shorten-ids.svg
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200">
+	<defs>
+		<linearGradient id="this-abomination-should-be-shortened-to-a-single-letter">
+			<stop offset="0" stop-color="black" />
+			<stop offset="1" stop-color="white" />
+		</linearGradient>
+	</defs>
+	<rect fill="url(#this-abomination-should-be-shortened-to-a-single-letter)" x="20" y="20" width="160" height="160" />
+</svg>
\ No newline at end of file