@@ -5,15 +5,15 @@

 (defun read-block (stream)

   (when (char= (read-char stream) #\{)

     (loop

-       with block = (make-string-output-stream)

-       with count = 0

-       for char = (read-char stream)

-       until (and (char= char #\}) (= count 0))

-       when (char= char #\{) do (incf count)

-       when (char= char #\}) do (decf count)

-       do (write-char char block)

-       finally

-	 (return (get-output-stream-string block)))))

+      with block = (make-string-output-stream)

+      with count = 0

+      for char = (read-char stream)

+      until (and (char= char #\}) (= count 0))

+      when (char= char #\{) do (incf count)

+        when (char= char #\}) do (decf count)

+          do (write-char char block)

+      finally

+         (return (get-output-stream-string block)))))

 (defun read-to-block (stream)

   (with-output-to-string (s)

@@ -24,10 +24,10 @@

 (defun partition (char string &key from-end)

   (let ((pos (position char string :from-end from-end)))

     (if pos

-	(list (subseq string 0 pos)

-	      (subseq string (1+ pos)))

-	(list nil

-	      string))))

+        (list (subseq string 0 pos)

+              (subseq string (1+ pos)))

+        (list nil

+              string))))

 (defun parse-rule (block)

   (remove-if-not #'car

@@ -50,24 +50,24 @@

 (defun parse-file (stream)

   (loop with result = (list)

-     with done = nil

-     until done

-     do

-       (handler-case (push (read-rule stream)

-			   result)

-	 (end-of-file (c) c (setf done t)))

-     finally

-       (return (nreverse result))))

+        with done = nil

+        until done

+        do

+           (handler-case (push (read-rule stream)

+                               result)

+             (end-of-file (c) c (setf done t)))

+        finally

+           (return (nreverse result))))

 (defun collapse-rule (rule)

   (let ((selector (car rule)))

     (mapcan (serapeum:op (mapcar (lambda (x) (list x _))

-				 selector))

-	    (cdr rule))))

+                                 selector))

+            (cdr rule))))

 (defun reconstitute (rules)

   (loop for (selector (property value)) in rules

-       collect (format nil "~a { ~a: ~a; }" selector property value)))

+        collect (format nil "~a { ~a: ~a; }" selector property value)))

 (defun normalize-file (stream)

   (fw.lu:let-each (:be *)