@batijs/build 0.0.1

package/dist/testUtils.js

@@ -0,0 +1,837 @@
+// ../../node_modules/.pnpm/dequal@2.0.3/node_modules/dequal/dist/index.mjs
+var has = Object.prototype.hasOwnProperty;
+function find(iter, tar, key) {
+  for (key of iter.keys()) {
+    if (dequal(key, tar))
+      return key;
+  }
+}
+function dequal(foo, bar) {
+  var ctor, len, tmp;
+  if (foo === bar)
+    return true;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date)
+      return foo.getTime() === bar.getTime();
+    if (ctor === RegExp)
+      return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && dequal(foo[len], bar[len]))
+          ;
+      }
+      return len === -1;
+    }
+    if (ctor === Set) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len;
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp);
+          if (!tmp)
+            return false;
+        }
+        if (!bar.has(tmp))
+          return false;
+      }
+      return true;
+    }
+    if (ctor === Map) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len[0];
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp);
+          if (!tmp)
+            return false;
+        }
+        if (!dequal(len[1], bar.get(tmp))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (ctor === ArrayBuffer) {
+      foo = new Uint8Array(foo);
+      bar = new Uint8Array(bar);
+    } else if (ctor === DataView) {
+      if ((len = foo.byteLength) === bar.byteLength) {
+        while (len-- && foo.getInt8(len) === bar.getInt8(len))
+          ;
+      }
+      return len === -1;
+    }
+    if (ArrayBuffer.isView(foo)) {
+      if ((len = foo.byteLength) === bar.byteLength) {
+        while (len-- && foo[len] === bar[len])
+          ;
+      }
+      return len === -1;
+    }
+    if (!ctor || typeof foo === "object") {
+      len = 0;
+      for (ctor in foo) {
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor))
+          return false;
+        if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor]))
+          return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+  return foo !== foo && bar !== bar;
+}
+
+// ../../node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/index.mjs
+var FORCE_COLOR;
+var NODE_DISABLE_COLORS;
+var NO_COLOR;
+var TERM;
+var isTTY = true;
+if (typeof process !== "undefined") {
+  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+  isTTY = process.stdout && process.stdout.isTTY;
+}
+var $ = {
+  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY),
+  // modifiers
+  reset: init(0, 0),
+  bold: init(1, 22),
+  dim: init(2, 22),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  // colors
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  grey: init(90, 39),
+  // background colors
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49)
+};
+function run(arr, str) {
+  let i = 0, tmp, beg = "", end = "";
+  for (; i < arr.length; i++) {
+    tmp = arr[i];
+    beg += tmp.open;
+    end += tmp.close;
+    if (!!~str.indexOf(tmp.close)) {
+      str = str.replace(tmp.rgx, tmp.close + tmp.open);
+    }
+  }
+  return beg + str + end;
+}
+function chain(has2, keys) {
+  let ctx = { has: has2, keys };
+  ctx.reset = $.reset.bind(ctx);
+  ctx.bold = $.bold.bind(ctx);
+  ctx.dim = $.dim.bind(ctx);
+  ctx.italic = $.italic.bind(ctx);
+  ctx.underline = $.underline.bind(ctx);
+  ctx.inverse = $.inverse.bind(ctx);
+  ctx.hidden = $.hidden.bind(ctx);
+  ctx.strikethrough = $.strikethrough.bind(ctx);
+  ctx.black = $.black.bind(ctx);
+  ctx.red = $.red.bind(ctx);
+  ctx.green = $.green.bind(ctx);
+  ctx.yellow = $.yellow.bind(ctx);
+  ctx.blue = $.blue.bind(ctx);
+  ctx.magenta = $.magenta.bind(ctx);
+  ctx.cyan = $.cyan.bind(ctx);
+  ctx.white = $.white.bind(ctx);
+  ctx.gray = $.gray.bind(ctx);
+  ctx.grey = $.grey.bind(ctx);
+  ctx.bgBlack = $.bgBlack.bind(ctx);
+  ctx.bgRed = $.bgRed.bind(ctx);
+  ctx.bgGreen = $.bgGreen.bind(ctx);
+  ctx.bgYellow = $.bgYellow.bind(ctx);
+  ctx.bgBlue = $.bgBlue.bind(ctx);
+  ctx.bgMagenta = $.bgMagenta.bind(ctx);
+  ctx.bgCyan = $.bgCyan.bind(ctx);
+  ctx.bgWhite = $.bgWhite.bind(ctx);
+  return ctx;
+}
+function init(open, close) {
+  let blk = {
+    open: `\x1B[${open}m`,
+    close: `\x1B[${close}m`,
+    rgx: new RegExp(`\\x1b\\[${close}m`, "g")
+  };
+  return function(txt) {
+    if (this !== void 0 && this.has !== void 0) {
+      !!~this.has.indexOf(open) || (this.has.push(open), this.keys.push(blk));
+      return txt === void 0 ? this : $.enabled ? run(this.keys, txt + "") : txt + "";
+    }
+    return txt === void 0 ? chain([open], [blk]) : $.enabled ? run([blk], txt + "") : txt + "";
+  };
+}
+var kleur_default = $;
+
+// ../../node_modules/.pnpm/diff@5.1.0/node_modules/diff/lib/index.mjs
+function Diff() {
+}
+Diff.prototype = {
+  diff: function diff(oldString, newString) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var callback = options.callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    this.options = options;
+    var self = this;
+    function done(value) {
+      if (callback) {
+        setTimeout(function() {
+          callback(void 0, value);
+        }, 0);
+        return true;
+      } else {
+        return value;
+      }
+    }
+    oldString = this.castInput(oldString);
+    newString = this.castInput(newString);
+    oldString = this.removeEmpty(this.tokenize(oldString));
+    newString = this.removeEmpty(this.tokenize(newString));
+    var newLen = newString.length, oldLen = oldString.length;
+    var editLength = 1;
+    var maxEditLength = newLen + oldLen;
+    if (options.maxEditLength) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    var bestPath = [{
+      newPos: -1,
+      components: []
+    }];
+    var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+    if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
+      return done([{
+        value: this.join(newString),
+        count: newString.length
+      }]);
+    }
+    function execEditLength() {
+      for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
+        var basePath = void 0;
+        var addPath = bestPath[diagonalPath - 1], removePath = bestPath[diagonalPath + 1], _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
+        if (addPath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        var canAdd = addPath && addPath.newPos + 1 < newLen, canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
+          basePath = clonePath(removePath);
+          self.pushComponent(basePath.components, void 0, true);
+        } else {
+          basePath = addPath;
+          basePath.newPos++;
+          self.pushComponent(basePath.components, true, void 0);
+        }
+        _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath);
+        if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
+          return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
+        } else {
+          bestPath[diagonalPath] = basePath;
+        }
+      }
+      editLength++;
+    }
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength) {
+            return callback();
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength) {
+        var ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  },
+  pushComponent: function pushComponent(components, added, removed) {
+    var last = components[components.length - 1];
+    if (last && last.added === added && last.removed === removed) {
+      components[components.length - 1] = {
+        count: last.count + 1,
+        added,
+        removed
+      };
+    } else {
+      components.push({
+        count: 1,
+        added,
+        removed
+      });
+    }
+  },
+  extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
+    var newLen = newString.length, oldLen = oldString.length, newPos = basePath.newPos, oldPos = newPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+    }
+    if (commonCount) {
+      basePath.components.push({
+        count: commonCount
+      });
+    }
+    basePath.newPos = newPos;
+    return oldPos;
+  },
+  equals: function equals(left, right) {
+    if (this.options.comparator) {
+      return this.options.comparator(left, right);
+    } else {
+      return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  },
+  removeEmpty: function removeEmpty(array) {
+    var ret = [];
+    for (var i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  },
+  castInput: function castInput(value) {
+    return value;
+  },
+  tokenize: function tokenize(value) {
+    return value.split("");
+  },
+  join: function join(chars2) {
+    return chars2.join("");
+  }
+};
+function buildValues(diff2, components, newString, oldString, useLongestToken) {
+  var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
+  for (; componentPos < componentLen; componentPos++) {
+    var component = components[componentPos];
+    if (!component.removed) {
+      if (!component.added && useLongestToken) {
+        var value = newString.slice(newPos, newPos + component.count);
+        value = value.map(function(value2, i) {
+          var oldValue = oldString[oldPos + i];
+          return oldValue.length > value2.length ? oldValue : value2;
+        });
+        component.value = diff2.join(value);
+      } else {
+        component.value = diff2.join(newString.slice(newPos, newPos + component.count));
+      }
+      newPos += component.count;
+      if (!component.added) {
+        oldPos += component.count;
+      }
+    } else {
+      component.value = diff2.join(oldString.slice(oldPos, oldPos + component.count));
+      oldPos += component.count;
+      if (componentPos && components[componentPos - 1].added) {
+        var tmp = components[componentPos - 1];
+        components[componentPos - 1] = components[componentPos];
+        components[componentPos] = tmp;
+      }
+    }
+  }
+  var lastComponent = components[componentLen - 1];
+  if (componentLen > 1 && typeof lastComponent.value === "string" && (lastComponent.added || lastComponent.removed) && diff2.equals("", lastComponent.value)) {
+    components[componentLen - 2].value += lastComponent.value;
+    components.pop();
+  }
+  return components;
+}
+function clonePath(path) {
+  return {
+    newPos: path.newPos,
+    components: path.components.slice(0)
+  };
+}
+var characterDiff = new Diff();
+function diffChars(oldStr, newStr, options) {
+  return characterDiff.diff(oldStr, newStr, options);
+}
+var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
+var reWhitespace = /\S/;
+var wordDiff = new Diff();
+wordDiff.equals = function(left, right) {
+  if (this.options.ignoreCase) {
+    left = left.toLowerCase();
+    right = right.toLowerCase();
+  }
+  return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
+};
+wordDiff.tokenize = function(value) {
+  var tokens = value.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/);
+  for (var i = 0; i < tokens.length - 1; i++) {
+    if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
+      tokens[i] += tokens[i + 2];
+      tokens.splice(i + 1, 2);
+      i--;
+    }
+  }
+  return tokens;
+};
+var lineDiff = new Diff();
+lineDiff.tokenize = function(value) {
+  var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (var i = 0; i < linesAndNewlines.length; i++) {
+    var line2 = linesAndNewlines[i];
+    if (i % 2 && !this.options.newlineIsToken) {
+      retLines[retLines.length - 1] += line2;
+    } else {
+      if (this.options.ignoreWhitespace) {
+        line2 = line2.trim();
+      }
+      retLines.push(line2);
+    }
+  }
+  return retLines;
+};
+function diffLines(oldStr, newStr, callback) {
+  return lineDiff.diff(oldStr, newStr, callback);
+}
+var sentenceDiff = new Diff();
+sentenceDiff.tokenize = function(value) {
+  return value.split(/(\S.+?[.!?])(?=\s+|$)/);
+};
+var cssDiff = new Diff();
+cssDiff.tokenize = function(value) {
+  return value.split(/([{}:;,]|\s+)/);
+};
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+var objectPrototypeToString = Object.prototype.toString;
+var jsonDiff = new Diff();
+jsonDiff.useLongestToken = true;
+jsonDiff.tokenize = lineDiff.tokenize;
+jsonDiff.castInput = function(value) {
+  var _this$options = this.options, undefinedReplacement = _this$options.undefinedReplacement, _this$options$stringi = _this$options.stringifyReplacer, stringifyReplacer = _this$options$stringi === void 0 ? function(k, v) {
+    return typeof v === "undefined" ? undefinedReplacement : v;
+  } : _this$options$stringi;
+  return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, "  ");
+};
+jsonDiff.equals = function(left, right) {
+  return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"));
+};
+function canonicalize(obj, stack, replacementStack, replacer, key) {
+  stack = stack || [];
+  replacementStack = replacementStack || [];
+  if (replacer) {
+    obj = replacer(key, obj);
+  }
+  var i;
+  for (i = 0; i < stack.length; i += 1) {
+    if (stack[i] === obj) {
+      return replacementStack[i];
+    }
+  }
+  var canonicalizedObj;
+  if ("[object Array]" === objectPrototypeToString.call(obj)) {
+    stack.push(obj);
+    canonicalizedObj = new Array(obj.length);
+    replacementStack.push(canonicalizedObj);
+    for (i = 0; i < obj.length; i += 1) {
+      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
+    }
+    stack.pop();
+    replacementStack.pop();
+    return canonicalizedObj;
+  }
+  if (obj && obj.toJSON) {
+    obj = obj.toJSON();
+  }
+  if (_typeof(obj) === "object" && obj !== null) {
+    stack.push(obj);
+    canonicalizedObj = {};
+    replacementStack.push(canonicalizedObj);
+    var sortedKeys = [], _key;
+    for (_key in obj) {
+      if (obj.hasOwnProperty(_key)) {
+        sortedKeys.push(_key);
+      }
+    }
+    sortedKeys.sort();
+    for (i = 0; i < sortedKeys.length; i += 1) {
+      _key = sortedKeys[i];
+      canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
+    }
+    stack.pop();
+    replacementStack.pop();
+  } else {
+    canonicalizedObj = obj;
+  }
+  return canonicalizedObj;
+}
+var arrayDiff = new Diff();
+arrayDiff.tokenize = function(value) {
+  return value.slice();
+};
+arrayDiff.join = arrayDiff.removeEmpty = function(value) {
+  return value;
+};
+function diffArrays(oldArr, newArr, callback) {
+  return arrayDiff.diff(oldArr, newArr, callback);
+}
+
+// ../../node_modules/.pnpm/uvu@0.5.6/node_modules/uvu/diff/index.mjs
+var colors = {
+  "--": kleur_default.red,
+  "\xB7\xB7": kleur_default.grey,
+  "++": kleur_default.green
+};
+var TITLE = kleur_default.dim().italic;
+var TAB = kleur_default.dim("\u2192");
+var SPACE = kleur_default.dim("\xB7");
+var NL = kleur_default.dim("\u21B5");
+var LOG = (sym, str) => colors[sym](sym + PRETTY(str)) + "\n";
+var LINE = (num, x) => kleur_default.dim("L" + String(num).padStart(x, "0") + " ");
+var PRETTY = (str) => str.replace(/[ ]/g, SPACE).replace(/\t/g, TAB).replace(/(\r?\n)/g, NL);
+function line(obj, prev, pad) {
+  let char = obj.removed ? "--" : obj.added ? "++" : "\xB7\xB7";
+  let arr = obj.value.replace(/\r?\n$/, "").split("\n");
+  let i = 0, tmp, out = "";
+  if (obj.added)
+    out += colors[char]().underline(TITLE("Expected:")) + "\n";
+  else if (obj.removed)
+    out += colors[char]().underline(TITLE("Actual:")) + "\n";
+  for (; i < arr.length; i++) {
+    tmp = arr[i];
+    if (tmp != null) {
+      if (prev)
+        out += LINE(prev + i, pad);
+      out += LOG(char, tmp || "\n");
+    }
+  }
+  return out;
+}
+function arrays(input, expect) {
+  let arr = diffArrays(input, expect);
+  let i = 0, j = 0, k = 0, tmp, val, char, isObj, str;
+  let out = LOG("\xB7\xB7", "[");
+  for (; i < arr.length; i++) {
+    char = (tmp = arr[i]).removed ? "--" : tmp.added ? "++" : "\xB7\xB7";
+    if (tmp.added) {
+      out += colors[char]().underline(TITLE("Expected:")) + "\n";
+    } else if (tmp.removed) {
+      out += colors[char]().underline(TITLE("Actual:")) + "\n";
+    }
+    for (j = 0; j < tmp.value.length; j++) {
+      isObj = tmp.value[j] && typeof tmp.value[j] === "object";
+      val = stringify(tmp.value[j]).split(/\r?\n/g);
+      for (k = 0; k < val.length; ) {
+        str = "  " + val[k++] + (isObj ? "" : ",");
+        if (isObj && k === val.length && j + 1 < tmp.value.length)
+          str += ",";
+        out += LOG(char, str);
+      }
+    }
+  }
+  return out + LOG("\xB7\xB7", "]");
+}
+function lines(input, expect, linenum = 0) {
+  let i = 0, tmp, output = "";
+  let arr = diffLines(input, expect);
+  let pad = String(expect.split(/\r?\n/g).length - linenum).length;
+  for (; i < arr.length; i++) {
+    output += line(tmp = arr[i], linenum, pad);
+    if (linenum && !tmp.removed)
+      linenum += tmp.count;
+  }
+  return output;
+}
+function chars(input, expect) {
+  let arr = diffChars(input, expect);
+  let i = 0, output = "", tmp;
+  let l1 = input.length;
+  let l2 = expect.length;
+  let p1 = PRETTY(input);
+  let p2 = PRETTY(expect);
+  tmp = arr[i];
+  if (l1 === l2) {
+  } else if (tmp.removed && arr[i + 1]) {
+    let del = tmp.count - arr[i + 1].count;
+    if (del == 0) {
+    } else if (del > 0) {
+      expect = " ".repeat(del) + expect;
+      p2 = " ".repeat(del) + p2;
+      l2 += del;
+    } else if (del < 0) {
+      input = " ".repeat(-del) + input;
+      p1 = " ".repeat(-del) + p1;
+      l1 += -del;
+    }
+  }
+  output += direct(p1, p2, l1, l2);
+  if (l1 === l2) {
+    for (tmp = "  "; i < l1; i++) {
+      tmp += input[i] === expect[i] ? " " : "^";
+    }
+  } else {
+    for (tmp = "  "; i < arr.length; i++) {
+      tmp += (arr[i].added || arr[i].removed ? "^" : " ").repeat(Math.max(arr[i].count, 0));
+      if (i + 1 < arr.length && (arr[i].added && arr[i + 1].removed || arr[i].removed && arr[i + 1].added)) {
+        arr[i + 1].count -= arr[i].count;
+      }
+    }
+  }
+  return output + kleur_default.red(tmp);
+}
+function direct(input, expect, lenA = String(input).length, lenB = String(expect).length) {
+  let gutter = 4;
+  let lenC = Math.max(lenA, lenB);
+  let typeA = typeof input, typeB = typeof expect;
+  if (typeA !== typeB) {
+    gutter = 2;
+    let delA = gutter + lenC - lenA;
+    let delB = gutter + lenC - lenB;
+    input += " ".repeat(delA) + kleur_default.dim(`[${typeA}]`);
+    expect += " ".repeat(delB) + kleur_default.dim(`[${typeB}]`);
+    lenA += delA + typeA.length + 2;
+    lenB += delB + typeB.length + 2;
+    lenC = Math.max(lenA, lenB);
+  }
+  let output = colors["++"]("++" + expect + " ".repeat(gutter + lenC - lenB) + TITLE("(Expected)")) + "\n";
+  return output + colors["--"]("--" + input + " ".repeat(gutter + lenC - lenA) + TITLE("(Actual)")) + "\n";
+}
+function sort(input, expect) {
+  var k, i = 0, tmp, isArr = Array.isArray(input);
+  var keys = [], out = isArr ? Array(input.length) : {};
+  if (isArr) {
+    for (i = 0; i < out.length; i++) {
+      tmp = input[i];
+      if (!tmp || typeof tmp !== "object")
+        out[i] = tmp;
+      else
+        out[i] = sort(tmp, expect[i]);
+    }
+  } else {
+    for (k in expect)
+      keys.push(k);
+    for (; i < keys.length; i++) {
+      if (Object.prototype.hasOwnProperty.call(input, k = keys[i])) {
+        if (!(tmp = input[k]) || typeof tmp !== "object")
+          out[k] = tmp;
+        else
+          out[k] = sort(tmp, expect[k]);
+      }
+    }
+    for (k in input) {
+      if (!out.hasOwnProperty(k)) {
+        out[k] = input[k];
+      }
+    }
+  }
+  return out;
+}
+function circular() {
+  var cache = /* @__PURE__ */ new Set();
+  return function print(key, val) {
+    if (val === void 0)
+      return "[__VOID__]";
+    if (typeof val === "number" && val !== val)
+      return "[__NAN__]";
+    if (typeof val === "bigint")
+      return val.toString();
+    if (!val || typeof val !== "object")
+      return val;
+    if (cache.has(val))
+      return "[Circular]";
+    cache.add(val);
+    return val;
+  };
+}
+function stringify(input) {
+  return JSON.stringify(input, circular(), 2).replace(/"\[__NAN__\]"/g, "NaN").replace(/"\[__VOID__\]"/g, "undefined");
+}
+function compare(input, expect) {
+  if (Array.isArray(expect) && Array.isArray(input))
+    return arrays(input, expect);
+  if (expect instanceof RegExp)
+    return chars("" + input, "" + expect);
+  let isA = input && typeof input == "object";
+  let isB = expect && typeof expect == "object";
+  if (isA && isB)
+    input = sort(input, expect);
+  if (isB)
+    expect = stringify(expect);
+  if (isA)
+    input = stringify(input);
+  if (expect && typeof expect == "object") {
+    input = stringify(sort(input, expect));
+    expect = stringify(expect);
+  }
+  isA = typeof input == "string";
+  isB = typeof expect == "string";
+  if (isA && /\r?\n/.test(input))
+    return lines(input, "" + expect);
+  if (isB && /\r?\n/.test(expect))
+    return lines("" + input, expect);
+  if (isA && isB)
+    return chars(input, expect);
+  return direct(input, expect);
+}
+
+// ../../node_modules/.pnpm/uvu@0.5.6/node_modules/uvu/assert/index.mjs
+function dedent(str) {
+  str = str.replace(/\r?\n/g, "\n");
+  let arr = str.match(/^[ \t]*(?=\S)/gm);
+  let i = 0, min = 1 / 0, len = (arr || []).length;
+  for (; i < len; i++)
+    min = Math.min(min, arr[i].length);
+  return len && min ? str.replace(new RegExp(`^[ \\t]{${min}}`, "gm"), "") : str;
+}
+var Assertion = class extends Error {
+  constructor(opts = {}) {
+    super(opts.message);
+    this.name = "Assertion";
+    this.code = "ERR_ASSERTION";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.details = opts.details || false;
+    this.generated = !!opts.generated;
+    this.operator = opts.operator;
+    this.expects = opts.expects;
+    this.actual = opts.actual;
+  }
+};
+function assert(bool, actual, expects, operator, detailer, backup, msg) {
+  if (bool)
+    return;
+  let message = msg || backup;
+  if (msg instanceof Error)
+    throw msg;
+  let details = detailer && detailer(actual, expects);
+  throw new Assertion({ actual, expects, operator, message, details, generated: !msg });
+}
+function ok(val, msg) {
+  assert(!!val, false, true, "ok", false, "Expected value to be truthy", msg);
+}
+function is(val, exp, msg) {
+  assert(val === exp, val, exp, "is", compare, "Expected values to be strictly equal:", msg);
+}
+function equal(val, exp, msg) {
+  assert(dequal(val, exp), val, exp, "equal", compare, "Expected values to be deeply equal:", msg);
+}
+function not(val, msg) {
+  assert(!val, true, false, "not", false, "Expected value to be falsey", msg);
+}
+not.ok = not;
+is.not = function(val, exp, msg) {
+  assert(val !== exp, val, exp, "is.not", false, "Expected values not to be strictly equal", msg);
+};
+not.equal = function(val, exp, msg) {
+  assert(!dequal(val, exp), val, exp, "not.equal", false, "Expected values not to be deeply equal", msg);
+};
+not.type = function(val, exp, msg) {
+  let tmp = typeof val;
+  assert(tmp !== exp, tmp, exp, "not.type", false, `Expected "${tmp}" not to be "${exp}"`, msg);
+};
+not.instance = function(val, exp, msg) {
+  let name = "`" + (exp.name || exp.constructor.name) + "`";
+  assert(!(val instanceof exp), val, exp, "not.instance", false, `Expected value not to be an instance of ${name}`, msg);
+};
+not.snapshot = function(val, exp, msg) {
+  val = dedent(val);
+  exp = dedent(exp);
+  assert(val !== exp, val, exp, "not.snapshot", false, "Expected value not to match snapshot", msg);
+};
+not.fixture = function(val, exp, msg) {
+  val = dedent(val);
+  exp = dedent(exp);
+  assert(val !== exp, val, exp, "not.fixture", false, "Expected value not to match fixture", msg);
+};
+not.match = function(val, exp, msg) {
+  if (typeof exp === "string") {
+    assert(!val.includes(exp), val, exp, "not.match", false, `Expected value not to include "${exp}" substring`, msg);
+  } else {
+    assert(!exp.test(val), val, exp, "not.match", false, `Expected value not to match \`${String(exp)}\` pattern`, msg);
+  }
+};
+not.throws = function(blk, exp, msg) {
+  if (!msg && typeof exp === "string") {
+    msg = exp;
+    exp = null;
+  }
+  try {
+    blk();
+  } catch (err) {
+    if (typeof exp === "function") {
+      assert(!exp(err), true, false, "not.throws", false, "Expected function not to throw matching exception", msg);
+    } else if (exp instanceof RegExp) {
+      assert(!exp.test(err.message), true, false, "not.throws", false, `Expected function not to throw exception matching \`${String(exp)}\` pattern`, msg);
+    } else if (!exp) {
+      assert(false, true, false, "not.throws", false, "Expected function not to throw", msg);
+    }
+  }
+};
+
+// src/testUtils.ts
+import { prettyPrint, types } from "recast";
+function assertEquivalentAst(ast1, ast2) {
+  if (types.astNodesAreEquivalent(ast1, ast2)) {
+    return ok(true);
+  } else {
+    return equal(
+      prettyPrint(ast1, {
+        tabWidth: 2,
+        reuseWhitespace: false,
+        wrapColumn: 120
+      }).code,
+      prettyPrint(ast2, {
+        tabWidth: 2,
+        reuseWhitespace: false,
+        wrapColumn: 120
+      }).code
+    );
+  }
+}
+export {
+  assertEquivalentAst
+};