                               (nth site level)
                               (nth counter level)))
                 (inc level))
-         (node triples element))))))
-
-(def secondary-values
-  (juxt :site :counter))
+         (node triples element)))))
 
 (defn compare
-  ([id other] (compare id other (base)))
-  ([id other base]
+  [id other base]
   (let [id-length        (count (:counter id))
         other-length     (count (:counter other))
         min-length       (min id-length other-length)

  (:refer-clojure :exclude  [compare])
  (:require [lseq-tree.base :refer [base bit sum]]
            [lseq-tree.lseq-node :refer [node]]
            [lseq-tree.triple :refer [triple]]))

;; TODO abstract the math away so it is js and java compliant

(defn pow [n x]
  (Math/pow n x))

(defrecord ID [digit site counter])


           (recur (first children)
                  digit (conj id-site site) (conj id-counter counter)
                  (inc level)))
         (id id-digit id-site id-counter)))))

(defn digit->path
  [digit base level bit-length]
