@calcit/procs 0.5.29 → 0.5.32

package/lib/calcit.procs.mjs

@@ -1,6 +1,6 @@
 var _a;
 // CALCIT VERSION
-export const calcit_version = "0.5.29";
+export const calcit_version = "0.5.32";
 import "@calcit/ternary-tree";
 import { parse } from "@cirru/parser.ts";
 import { writeCirruCode } from "@cirru/writer.ts";
@@ -16,6 +16,7 @@ export * from "./js-primes.mjs";
 export * from "./js-tuple.mjs";
 export * from "./custom-formatter.mjs";
 export * from "./js-cirru.mjs";
+export { _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList, foldl } from "./js-list.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet } from "./js-set.mjs";
@@ -1212,106 +1213,6 @@ export let _$n_map_$o_to_list = (m) => {
         throw new Error("&map:to-list expected a Map");
     }
 };
-var PseudoTypeIndex;
-(function (PseudoTypeIndex) {
-    PseudoTypeIndex[PseudoTypeIndex["nil"] = 0] = "nil";
-    PseudoTypeIndex[PseudoTypeIndex["bool"] = 1] = "bool";
-    PseudoTypeIndex[PseudoTypeIndex["number"] = 2] = "number";
-    PseudoTypeIndex[PseudoTypeIndex["symbol"] = 3] = "symbol";
-    PseudoTypeIndex[PseudoTypeIndex["keyword"] = 4] = "keyword";
-    PseudoTypeIndex[PseudoTypeIndex["string"] = 5] = "string";
-    PseudoTypeIndex[PseudoTypeIndex["ref"] = 6] = "ref";
-    PseudoTypeIndex[PseudoTypeIndex["tuple"] = 7] = "tuple";
-    PseudoTypeIndex[PseudoTypeIndex["recur"] = 8] = "recur";
-    PseudoTypeIndex[PseudoTypeIndex["list"] = 9] = "list";
-    PseudoTypeIndex[PseudoTypeIndex["set"] = 10] = "set";
-    PseudoTypeIndex[PseudoTypeIndex["map"] = 11] = "map";
-    PseudoTypeIndex[PseudoTypeIndex["record"] = 12] = "record";
-    PseudoTypeIndex[PseudoTypeIndex["fn"] = 13] = "fn";
-})(PseudoTypeIndex || (PseudoTypeIndex = {}));
-let typeAsInt = (x) => {
-    // based on order used in Ord traint
-    if (x == null)
-        return PseudoTypeIndex.nil;
-    let t = typeof x;
-    if (t === "boolean")
-        return PseudoTypeIndex.bool;
-    if (t === "number")
-        return PseudoTypeIndex.number;
-    if (x instanceof CalcitSymbol)
-        return PseudoTypeIndex.symbol;
-    if (x instanceof CalcitKeyword)
-        return PseudoTypeIndex.keyword;
-    if (t === "string")
-        return PseudoTypeIndex.string;
-    if (x instanceof CalcitRef)
-        return PseudoTypeIndex.ref;
-    if (x instanceof CalcitTuple)
-        return PseudoTypeIndex.tuple;
-    if (x instanceof CalcitRecur)
-        return PseudoTypeIndex.recur;
-    if (x instanceof CalcitList || x instanceof CalcitSliceList)
-        return PseudoTypeIndex.list;
-    if (x instanceof CalcitSet)
-        return PseudoTypeIndex.set;
-    if (x instanceof CalcitMap || x instanceof CalcitSliceMap)
-        return PseudoTypeIndex.map;
-    if (x instanceof CalcitRecord)
-        return PseudoTypeIndex.record;
-    // proc, fn, macro, syntax, not distinguished
-    if (t === "function")
-        return PseudoTypeIndex.fn;
-    throw new Error("unknown type to compare");
-};
-let rawCompare = (x, y) => {
-    if (x < y) {
-        return -1;
-    }
-    else if (x > y) {
-        return 1;
-    }
-    else {
-        return 0;
-    }
-};
-export let _$n_compare = (a, b) => {
-    if (a === b)
-        return 0;
-    let ta = typeAsInt(a);
-    let tb = typeAsInt(b);
-    if (ta === tb) {
-        switch (ta) {
-            case PseudoTypeIndex.nil:
-                return 0;
-            case PseudoTypeIndex.bool:
-                return rawCompare(a, b);
-            case PseudoTypeIndex.number:
-                return rawCompare(a, b);
-            case PseudoTypeIndex.keyword:
-                return a.cmp(b);
-            case PseudoTypeIndex.symbol:
-                return rawCompare(a, b);
-            case PseudoTypeIndex.string:
-                return rawCompare(a, b);
-            case PseudoTypeIndex.ref:
-                return rawCompare(a.path, b.path);
-            default:
-                // TODO, need more accurate solution
-                if (a < b) {
-                    return -1;
-                }
-                else if (a > b) {
-                    return 1;
-                }
-                else {
-                    return 0;
-                }
-        }
-    }
-    else {
-        return rawCompare(ta, tb);
-    }
-};
 export let _$n_map_$o_diff_new = (a, b) => {
     if ((a instanceof CalcitMap || a instanceof CalcitSliceMap) && (b instanceof CalcitMap || b instanceof CalcitSliceMap)) {
         return a.diffNew(b);
@@ -1372,6 +1273,22 @@ export let _$n_str_$o_pad_right = (s, size, pattern) => {
 export let _$n_get_os = () => {
     return kwd("js-engine");
 };
+export let _$n_buffer = (...xs) => {
+    let buf = new Uint8Array(xs.length);
+    for (let idx = 0; idx < xs.length; idx++) {
+        let x = xs[idx];
+        if (typeof x === "number") {
+            buf[idx] = x;
+        }
+        else if (typeof x === "string") {
+            buf[idx] = parseInt(x, 16);
+        }
+        else {
+            throw new Error("invalid value for buffer");
+        }
+    }
+    return buf;
+};
 // special procs have to be defined manually
 export let reduce = foldl;
 let unavailableProc = (...xs) => {

package/lib/custom-formatter.mjs

@@ -53,6 +53,13 @@ export let load_console_formatter_$x_ = () => {
                         }
                         return ret;
                     }
+                    if (obj instanceof CalcitTuple) {
+                        let ret = ["div", {}];
+                        ret.push(["div", { style: "display: inline-block; color: hsl(300, 100%, 40%); " }, "::"]);
+                        ret.push(["div", { style: "margin-left: 6px; display: inline-block;" }, embedObject(obj.fst)]);
+                        ret.push(["div", { style: "margin-left: 6px; display: inline-block;" }, embedObject(obj.snd)]);
+                        return ret;
+                    }
                     if (obj instanceof CalcitRef) {
                         return [
                             "div",
@@ -95,12 +102,6 @@ export let load_console_formatter_$x_ = () => {
                         }
                         return ret;
                     }
-                    if (obj instanceof CalcitTuple) {
-                        let ret = ["div", { style: "color: hsl(200, 90%, 60%)" }];
-                        ret.push(["div", { style: "margin-left: 8px; display: inline-block;" }, embedObject(obj.fst)]);
-                        ret.push(["div", { style: "margin-left: 8px; display: inline-block;" }, embedObject(obj.snd)]);
-                        return ret;
-                    }
                     if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
                         let ret = ["div", { style: "color: hsl(280, 80%, 60%)" }];
                         let pairs = obj.pairs();

package/lib/js-cirru.mjs

@@ -1,6 +1,6 @@
 import "@calcit/ternary-tree";
 import { writeCirruCode } from "@cirru/writer.ts";
-import "./js-primes.mjs";
+import { _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitRecord } from "./js-record.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
@@ -45,7 +45,14 @@ export let to_cirru_edn = (x) => {
     }
     if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
         let buffer = ["{}"];
-        for (let [k, v] of x.pairs()) {
+        let pairs = [];
+        for (let pair of x.pairs()) {
+            pairs.push(pair);
+        }
+        pairs.sort((a, b) => {
+            return _$n_compare(a[0], b[0]);
+        });
+        for (let [k, v] of pairs) {
             buffer.push([to_cirru_edn(k), to_cirru_edn(v)]);
         }
         return buffer;
@@ -60,6 +67,9 @@ export let to_cirru_edn = (x) => {
     if (x instanceof CalcitSet) {
         let buffer = ["#{}"];
         let values = x.values();
+        values.sort((a, b) => {
+            return _$n_compare(a, b);
+        });
         for (let idx = 0; idx < values.length; idx++) {
             let y = values[idx];
             buffer.push(to_cirru_edn(y));

package/lib/js-primes.mjs

@@ -1,6 +1,106 @@
-import "./calcit-data.mjs";
-import "./js-list.mjs";
-import "./js-record.mjs";
-import "./js-map.mjs";
-import "./js-set.mjs";
-import "./js-tuple.mjs";
+import { CalcitKeyword, CalcitSymbol, CalcitRef, CalcitRecur } from "./calcit-data.mjs";
+import { CalcitList, CalcitSliceList } from "./js-list.mjs";
+import { CalcitRecord } from "./js-record.mjs";
+import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
+import { CalcitSet as CalcitSet } from "./js-set.mjs";
+import { CalcitTuple } from "./js-tuple.mjs";
+var PseudoTypeIndex;
+(function (PseudoTypeIndex) {
+    PseudoTypeIndex[PseudoTypeIndex["nil"] = 0] = "nil";
+    PseudoTypeIndex[PseudoTypeIndex["bool"] = 1] = "bool";
+    PseudoTypeIndex[PseudoTypeIndex["number"] = 2] = "number";
+    PseudoTypeIndex[PseudoTypeIndex["symbol"] = 3] = "symbol";
+    PseudoTypeIndex[PseudoTypeIndex["keyword"] = 4] = "keyword";
+    PseudoTypeIndex[PseudoTypeIndex["string"] = 5] = "string";
+    PseudoTypeIndex[PseudoTypeIndex["ref"] = 6] = "ref";
+    PseudoTypeIndex[PseudoTypeIndex["tuple"] = 7] = "tuple";
+    PseudoTypeIndex[PseudoTypeIndex["recur"] = 8] = "recur";
+    PseudoTypeIndex[PseudoTypeIndex["list"] = 9] = "list";
+    PseudoTypeIndex[PseudoTypeIndex["set"] = 10] = "set";
+    PseudoTypeIndex[PseudoTypeIndex["map"] = 11] = "map";
+    PseudoTypeIndex[PseudoTypeIndex["record"] = 12] = "record";
+    PseudoTypeIndex[PseudoTypeIndex["fn"] = 13] = "fn";
+})(PseudoTypeIndex || (PseudoTypeIndex = {}));
+let typeAsInt = (x) => {
+    // based on order used in Ord traint
+    if (x == null)
+        return PseudoTypeIndex.nil;
+    let t = typeof x;
+    if (t === "boolean")
+        return PseudoTypeIndex.bool;
+    if (t === "number")
+        return PseudoTypeIndex.number;
+    if (x instanceof CalcitSymbol)
+        return PseudoTypeIndex.symbol;
+    if (x instanceof CalcitKeyword)
+        return PseudoTypeIndex.keyword;
+    if (t === "string")
+        return PseudoTypeIndex.string;
+    if (x instanceof CalcitRef)
+        return PseudoTypeIndex.ref;
+    if (x instanceof CalcitTuple)
+        return PseudoTypeIndex.tuple;
+    if (x instanceof CalcitRecur)
+        return PseudoTypeIndex.recur;
+    if (x instanceof CalcitList || x instanceof CalcitSliceList)
+        return PseudoTypeIndex.list;
+    if (x instanceof CalcitSet)
+        return PseudoTypeIndex.set;
+    if (x instanceof CalcitMap || x instanceof CalcitSliceMap)
+        return PseudoTypeIndex.map;
+    if (x instanceof CalcitRecord)
+        return PseudoTypeIndex.record;
+    // proc, fn, macro, syntax, not distinguished
+    if (t === "function")
+        return PseudoTypeIndex.fn;
+    throw new Error("unknown type to compare");
+};
+let rawCompare = (x, y) => {
+    if (x < y) {
+        return -1;
+    }
+    else if (x > y) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
+};
+export let _$n_compare = (a, b) => {
+    if (a === b)
+        return 0;
+    let ta = typeAsInt(a);
+    let tb = typeAsInt(b);
+    if (ta === tb) {
+        switch (ta) {
+            case PseudoTypeIndex.nil:
+                return 0;
+            case PseudoTypeIndex.bool:
+                return rawCompare(a, b);
+            case PseudoTypeIndex.number:
+                return rawCompare(a, b);
+            case PseudoTypeIndex.keyword:
+                return rawCompare(a.value, b.value);
+            case PseudoTypeIndex.symbol:
+                return rawCompare(a, b);
+            case PseudoTypeIndex.string:
+                return rawCompare(a, b);
+            case PseudoTypeIndex.ref:
+                return rawCompare(a.path, b.path);
+            default:
+                // TODO, need more accurate solution
+                if (a < b) {
+                    return -1;
+                }
+                else if (a > b) {
+                    return 1;
+                }
+                else {
+                    return 0;
+                }
+        }
+    }
+    else {
+        return rawCompare(ta, tb);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.5.29",
+  "version": "0.5.32",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^17.0.23",

package/ts-src/calcit.procs.mts

@@ -1,5 +1,5 @@
 // CALCIT VERSION
-export const calcit_version = "0.5.29";
+export const calcit_version = "0.5.32";
 
 import { overwriteComparator, initTernaryTreeMap } from "@calcit/ternary-tree";
 import { parse, ICirruNode } from "@cirru/parser.ts";
@@ -31,6 +31,7 @@ export * from "./js-primes.mjs";
 export * from "./js-tuple.mjs";
 export * from "./custom-formatter.mjs";
 export * from "./js-cirru.mjs";
+export { _$n_compare } from "./js-primes.mjs";
 
 import { CalcitList, CalcitSliceList, foldl } from "./js-list.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
@@ -1298,89 +1299,6 @@ export let _$n_map_$o_to_list = (m: CalcitValue): CalcitSliceList => {
   }
 };
 
-enum PseudoTypeIndex {
-  nil,
-  bool,
-  number,
-  symbol,
-  keyword,
-  string,
-  ref,
-  tuple,
-  recur,
-  list,
-  set,
-  map,
-  record,
-  fn,
-}
-
-let typeAsInt = (x: CalcitValue): number => {
-  // based on order used in Ord traint
-  if (x == null) return PseudoTypeIndex.nil;
-  let t = typeof x;
-  if (t === "boolean") return PseudoTypeIndex.bool;
-  if (t === "number") return PseudoTypeIndex.number;
-  if (x instanceof CalcitSymbol) return PseudoTypeIndex.symbol;
-  if (x instanceof CalcitKeyword) return PseudoTypeIndex.keyword;
-  if (t === "string") return PseudoTypeIndex.string;
-  if (x instanceof CalcitRef) return PseudoTypeIndex.ref;
-  if (x instanceof CalcitTuple) return PseudoTypeIndex.tuple;
-  if (x instanceof CalcitRecur) return PseudoTypeIndex.recur;
-  if (x instanceof CalcitList || x instanceof CalcitSliceList) return PseudoTypeIndex.list;
-  if (x instanceof CalcitSet) return PseudoTypeIndex.set;
-  if (x instanceof CalcitMap || x instanceof CalcitSliceMap) return PseudoTypeIndex.map;
-  if (x instanceof CalcitRecord) return PseudoTypeIndex.record;
-  // proc, fn, macro, syntax, not distinguished
-  if (t === "function") return PseudoTypeIndex.fn;
-  throw new Error("unknown type to compare");
-};
-
-let rawCompare = (x: any, y: any): number => {
-  if (x < y) {
-    return -1;
-  } else if (x > y) {
-    return 1;
-  } else {
-    return 0;
-  }
-};
-
-export let _$n_compare = (a: CalcitValue, b: CalcitValue): number => {
-  if (a === b) return 0;
-  let ta = typeAsInt(a);
-  let tb = typeAsInt(b);
-  if (ta === tb) {
-    switch (ta) {
-      case PseudoTypeIndex.nil:
-        return 0;
-      case PseudoTypeIndex.bool:
-        return rawCompare(a, b);
-      case PseudoTypeIndex.number:
-        return rawCompare(a, b);
-      case PseudoTypeIndex.keyword:
-        return (a as CalcitKeyword).cmp(b as CalcitKeyword);
-      case PseudoTypeIndex.symbol:
-        return rawCompare(a, b);
-      case PseudoTypeIndex.string:
-        return rawCompare(a, b);
-      case PseudoTypeIndex.ref:
-        return rawCompare((a as CalcitRef).path, (b as CalcitRef).path);
-      default:
-        // TODO, need more accurate solution
-        if (a < b) {
-          return -1;
-        } else if (a > b) {
-          return 1;
-        } else {
-          return 0;
-        }
-    }
-  } else {
-    return rawCompare(ta, tb);
-  }
-};
-
 export let _$n_map_$o_diff_new = (a: CalcitValue, b: CalcitValue): CalcitMap => {
   if ((a instanceof CalcitMap || a instanceof CalcitSliceMap) && (b instanceof CalcitMap || b instanceof CalcitSliceMap)) {
     return a.diffNew(b);
@@ -1447,6 +1365,23 @@ export let _$n_get_os = (): CalcitKeyword => {
   return kwd("js-engine");
 };
 
+export let _$n_buffer = (...xs: CalcitValue[]): Uint8Array => {
+  let buf = new Uint8Array(xs.length);
+
+  for (let idx = 0; idx < xs.length; idx++) {
+    let x = xs[idx];
+    if (typeof x === "number") {
+      buf[idx] = x;
+    } else if (typeof x === "string") {
+      buf[idx] = parseInt(x, 16);
+    } else {
+      throw new Error("invalid value for buffer");
+    }
+  }
+
+  return buf;
+};
+
 // special procs have to be defined manually
 export let reduce = foldl;
 

package/ts-src/custom-formatter.mts

@@ -66,6 +66,13 @@ export let load_console_formatter_$x_ = () => {
             }
             return ret;
           }
+          if (obj instanceof CalcitTuple) {
+            let ret: any[] = ["div", {}];
+            ret.push(["div", { style: "display: inline-block; color: hsl(300, 100%, 40%); " }, "::"]);
+            ret.push(["div", { style: "margin-left: 6px; display: inline-block;" }, embedObject(obj.fst)]);
+            ret.push(["div", { style: "margin-left: 6px; display: inline-block;" }, embedObject(obj.snd)]);
+            return ret;
+          }
           if (obj instanceof CalcitRef) {
             return [
               "div",
@@ -110,12 +117,6 @@ export let load_console_formatter_$x_ = () => {
             }
             return ret;
           }
-          if (obj instanceof CalcitTuple) {
-            let ret: any[] = ["div", { style: "color: hsl(200, 90%, 60%)" }];
-            ret.push(["div", { style: "margin-left: 8px; display: inline-block;" }, embedObject(obj.fst)]);
-            ret.push(["div", { style: "margin-left: 8px; display: inline-block;" }, embedObject(obj.snd)]);
-            return ret;
-          }
           if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
             let ret: any[] = ["div", { style: "color: hsl(280, 80%, 60%)" }];
             let pairs = obj.pairs();

package/ts-src/js-cirru.mts

@@ -1,7 +1,7 @@
 import { overwriteComparator, initTernaryTreeMap } from "@calcit/ternary-tree";
 import { CirruWriterNode, writeCirruCode } from "@cirru/writer.ts";
 
-import { CalcitValue } from "./js-primes.mjs";
+import { CalcitValue, _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitRecord } from "./js-record.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
@@ -50,7 +50,14 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
   }
   if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
     let buffer: CirruEdnFormat = ["{}"];
-    for (let [k, v] of x.pairs()) {
+    let pairs: [CalcitValue, CalcitValue][] = [];
+    for (let pair of x.pairs()) {
+      pairs.push(pair);
+    }
+    pairs.sort((a, b) => {
+      return _$n_compare(a[0], b[0]);
+    });
+    for (let [k, v] of pairs) {
       buffer.push([to_cirru_edn(k), to_cirru_edn(v)]);
     }
     return buffer;
@@ -65,6 +72,9 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
   if (x instanceof CalcitSet) {
     let buffer: CirruEdnFormat = ["#{}"];
     let values = x.values();
+    values.sort((a, b) => {
+      return _$n_compare(a, b);
+    });
     for (let idx = 0; idx < values.length; idx++) {
       let y = values[idx];
       buffer.push(to_cirru_edn(y));

package/ts-src/js-primes.mts

@@ -22,3 +22,86 @@ export type CalcitValue =
   | CalcitRecur // should not be exposed to function
   | CalcitRecord
   | null;
+
+enum PseudoTypeIndex {
+  nil,
+  bool,
+  number,
+  symbol,
+  keyword,
+  string,
+  ref,
+  tuple,
+  recur,
+  list,
+  set,
+  map,
+  record,
+  fn,
+}
+
+let typeAsInt = (x: CalcitValue): number => {
+  // based on order used in Ord traint
+  if (x == null) return PseudoTypeIndex.nil;
+  let t = typeof x;
+  if (t === "boolean") return PseudoTypeIndex.bool;
+  if (t === "number") return PseudoTypeIndex.number;
+  if (x instanceof CalcitSymbol) return PseudoTypeIndex.symbol;
+  if (x instanceof CalcitKeyword) return PseudoTypeIndex.keyword;
+  if (t === "string") return PseudoTypeIndex.string;
+  if (x instanceof CalcitRef) return PseudoTypeIndex.ref;
+  if (x instanceof CalcitTuple) return PseudoTypeIndex.tuple;
+  if (x instanceof CalcitRecur) return PseudoTypeIndex.recur;
+  if (x instanceof CalcitList || x instanceof CalcitSliceList) return PseudoTypeIndex.list;
+  if (x instanceof CalcitSet) return PseudoTypeIndex.set;
+  if (x instanceof CalcitMap || x instanceof CalcitSliceMap) return PseudoTypeIndex.map;
+  if (x instanceof CalcitRecord) return PseudoTypeIndex.record;
+  // proc, fn, macro, syntax, not distinguished
+  if (t === "function") return PseudoTypeIndex.fn;
+  throw new Error("unknown type to compare");
+};
+
+let rawCompare = (x: any, y: any): number => {
+  if (x < y) {
+    return -1;
+  } else if (x > y) {
+    return 1;
+  } else {
+    return 0;
+  }
+};
+
+export let _$n_compare = (a: CalcitValue, b: CalcitValue): number => {
+  if (a === b) return 0;
+  let ta = typeAsInt(a);
+  let tb = typeAsInt(b);
+  if (ta === tb) {
+    switch (ta) {
+      case PseudoTypeIndex.nil:
+        return 0;
+      case PseudoTypeIndex.bool:
+        return rawCompare(a, b);
+      case PseudoTypeIndex.number:
+        return rawCompare(a, b);
+      case PseudoTypeIndex.keyword:
+        return rawCompare((a as CalcitKeyword).value, (b as CalcitKeyword).value);
+      case PseudoTypeIndex.symbol:
+        return rawCompare(a, b);
+      case PseudoTypeIndex.string:
+        return rawCompare(a, b);
+      case PseudoTypeIndex.ref:
+        return rawCompare((a as CalcitRef).path, (b as CalcitRef).path);
+      default:
+        // TODO, need more accurate solution
+        if (a < b) {
+          return -1;
+        } else if (a > b) {
+          return 1;
+        } else {
+          return 0;
+        }
+    }
+  } else {
+    return rawCompare(ta, tb);
+  }
+};